开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
udp_usrreq.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：33k
源码类别：

VxWorks

开发平台：

C/C++

udp_usrreq.c：源码内容
  1. /* udp_usrreq.c - UDP protocol routines */
  3. /* Copyright 1984 - 2001 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7.  * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1995
  8.  * The Regents of the University of California.  All rights reserved.
  9.  *
  10.  * Redistribution and use in source and binary forms, with or without
  11.  * modification, are permitted provided that the following conditions
  12.  * are met:
  13.  * 1. Redistributions of source code must retain the above copyright
  14.  *    notice, this list of conditions and the following disclaimer.
  15.  * 2. Redistributions in binary form must reproduce the above copyright
  16.  *    notice, this list of conditions and the following disclaimer in the
  17.  *    documentation and/or other materials provided with the distribution.
  18.  * 3. All advertising materials mentioning features or use of this software
  19.  *    must display the following acknowledgement:
  20.  * This product includes software developed by the University of
  21.  * California, Berkeley and its contributors.
  22.  * 4. Neither the name of the University nor the names of its contributors
  23.  *    may be used to endorse or promote products derived from this software
  24.  *    without specific prior written permission.
  25.  *
  26.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  27.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  30.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  31.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  32.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  33.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  34.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  35.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  36.  * SUCH DAMAGE.
  37.  *
  38.  * @(#)udp_usrreq.c 8.6 (Berkeley) 5/23/95
  39.  */
  41. /*
  42. modification history
  43. --------------------
  44. 03g,12oct01,rae  merge from truestack ver 03k, base 03f (SPR #65887 etc.)
  45. 03f,31aug98,n_s  added udp_hlen validty check to udp_input (). spr #6263.
  46. 03e,05oct97,vin  added fast multicasting.
  47. 03d,31mar97,vin  modified for hash look ups for pcbs(FREEBSD 2.2.1).
  48. 03c,20jan97,vin  replace icmp_error with _icmpErrorHook for scalability, 
  49.  added new udpDoCkSumRcv variable, fixed bugs mentioned
  50.  in Stevens VOLII chapter 23, pg772 & pg774.
  51. 03b,22nov96,vin  added cluster support replaced m_get(..) with mBufClGet(..).
  52. 03a,03mar96,vin  created from BSD4.4 stuff,integrated with 02r of udp_usrreq.c.
  53. */
  55. /*
  56. DESCRIPTION
  57. */
  59. #include "vxWorks.h"
  60. #include "net/mbuf.h"
  61. #include "net/protosw.h"
  62. #include "sys/socket.h"
  63. #include "net/socketvar.h"
  64. #include "errno.h"
  66. #include "net/if.h"
  67. #include "net/route.h"
  69. #include "netinet/in.h"
  70. #include "netinet/in_pcb.h"
  71. #include "netinet/in_systm.h"
  72. #include "netinet/ip.h"
  73. #include "netinet/ip_var.h"
  74. #include "netinet/in_var.h"
  75. #include "netinet/ip_icmp.h"
  76. #include "netinet/udp.h"
  77. #include "netinet/udp_var.h"
  78. #include "net/systm.h"
  79. #include "stdio.h"
  81. #ifdef WV_INSTRUMENTATION
  82. #ifdef INCLUDE_WVNET
  83. #include "wvNetLib.h"
  84. #endif
  85. #endif
  87. #ifdef VIRTUAL_STACK
  88. #include "netinet/vsLib.h"
  89. #endif
  91. /*
  92.  * UDP protocol implementation.
  93.  * Per RFC 768, August, 1980.
  94.  */
  96. #ifndef UDBHASHSIZE
  97. #define UDBHASHSIZE 64
  98. #endif
  100. #ifndef VIRTUAL_STACK
  102. #ifndef COMPAT_42
  103. int udpcksum  = 1; /* turn on send checksum by default */
  104. int udpDoCkSumRcv = 1; /* turn on recv checksum by default */
  105. #else
  106. int udpcksum  = 0; /* XXX */
  107. int udpDoCkSumRcv = 0;
  108. #endif
  110. /* externs */
  111. extern VOIDFUNCPTR _icmpErrorHook;
  113. /* globals */
  115. struct  inpcbhead udb;          /* from udp_var.h */
  116. struct  inpcbinfo udbinfo;
  117. struct  udpstat udpstat; /* global udp statistics structure */
  118. struct  sockaddr_in udp_in = { sizeof(udp_in), AF_INET };
  119. struct inpcb * udp_last_inpcb = NULL; /* last PCB cache for fast look up */
  120. int udp_ttl = UDP_TTL;
  121. u_long udp_sendspace = 9216; /* really max datagram size */
  122. u_long udp_recvspace = 40 * (1024 + sizeof(struct sockaddr_in));
  123. /* 40 1K datagrams */
  124. u_short udp_pcbhashsize = UDBHASHSIZE;  /* size of hash table */
  126. #endif    /* VIRTUAL_STACK */
  128. /* locals */
  130. #ifdef WV_INSTRUMENTATION
  131. #ifdef INCLUDE_WVNET
  132.     /* Set common fields of event identifiers for this module. */
  134. LOCAL UCHAR wvNetModuleId = WV_NET_UDPREQ_MODULE; /* Value for udp_usrreq.c */
  135. LOCAL UCHAR wvNetLocalFilter = WV_NET_NONE;     /* Available event filter */
  137. LOCAL ULONG wvNetEventId;       /* Event identifier: see wvNetLib.h */
  138. #endif    /* INCLUDE_WVNET */
  139. #endif
  141. /* forward declarations */
  143. static void udp_detach (struct inpcb *);
  144. static void udp_notify (struct inpcb *, int);
  145. static struct mbuf *udp_saveopt (caddr_t, int, int);
  147. void
  148. udp_init()
  149. {
  150. #ifdef WV_INSTRUMENTATION
  151. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  152.     WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_VERBOSE, 43, 16,
  153.                      WV_NETEVENT_UDPINIT_START)
  154. #endif  /* INCLUDE_WVNET */
  155. #endif
  157. LIST_INIT(&udb);
  158. udbinfo.listhead = &udb;
  160. #ifdef VIRTUAL_STACK
  161.         udp_in.sin_len     = sizeof(udp_in);
  162.         udp_in.sin_family  = AF_INET;
  163.         udp_last_inpcb     = NULL;
  164.         udp_ttl            = UDP_TTL;
  165.         udp_sendspace      = 9216;
  166.         udp_recvspace      = 40 * (1024 + sizeof (struct sockaddr_in));
  167.         udp_pcbhashsize    = UDBHASHSIZE;
  169. #ifndef COMPAT_42
  170.         udpcksum     = 1; /* turn on send checksum by default */
  171.         udpDoCkSumRcv    = 1; /* turn on recv checksum by default */
  172. #else
  173.         udpcksum     = 0; /* XXX */
  174.         udpDoCkSumRcv    = 0;
  175. #endif    /* COMPAT_42 */
  177. #endif    /* VIRTUAL_STACK */
  179. udbinfo.hashbase = hashinit(udp_pcbhashsize, MT_PCB, &udbinfo.hashmask);
  180. }
  182. void
  183. udp_input(m, iphlen)
  184. register struct mbuf *m;
  185. int iphlen;
  186. {
  187. register struct ip *ip;
  188. register struct udphdr *uh;
  189. register struct inpcb *inp;
  190. struct mbuf *opts = 0;
  191. int len;
  192. struct ip save_ip;
  194. #ifdef WV_INSTRUMENTATION
  195. #ifdef INCLUDE_WVNET    /* WV_NET_NOTICE event */
  196.     WV_NET_EVENT_0 (NET_CORE_EVENT, WV_NET_NOTICE, 21, 10,
  197.                     WV_NETEVENT_UDPIN_START, WV_NET_RECV)
  198. #endif  /* INCLUDE_WVNET */
  199. #endif
  201. udpstat.udps_ipackets++;
  203. /*
  204.  * Strip IP options, if any; should skip this,
  205.  * make available to user, and use on returned packets,
  206.  * but we don't yet have a way to check the checksum
  207.  * with options still present.
  208.  */
  209. if (iphlen > sizeof (struct ip)) {
  210. ip_stripoptions(m, (struct mbuf *)0);
  211. iphlen = sizeof(struct ip);
  212. }
  214. /*
  215.  * Get IP and UDP header together in first mbuf.
  216.  */
  217. ip = mtod(m, struct ip *);
  218. if (m->m_len < iphlen + sizeof(struct udphdr)) {
  219. if ((m = m_pullup(m, iphlen + sizeof(struct udphdr))) == 0) {
  220. udpstat.udps_hdrops++;
  221. #ifdef WV_INSTRUMENTATION
  222. #ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
  223.             WV_NET_EVENT_0 (NET_CORE_EVENT, WV_NET_WARNING, 14, 4,
  224.                             WV_NETEVENT_UDPIN_SHORTPKTHDR, WV_NET_RECV)
  225. #endif  /* INCLUDE_WVNET */
  226. #endif
  228. return;
  229. }
  230. ip = mtod(m, struct ip *);
  231. }
  232. uh = (struct udphdr *)((caddr_t)ip + iphlen);
  234. /*
  235.  * Make mbuf data length reflect UDP length.
  236.  * If not enough data to reflect UDP length, drop.
  237.  */
  238. len = ntohs((u_short)uh->uh_ulen);
  240. if (len < sizeof (struct udphdr))
  241.     {
  242.     udpstat.udps_badlen++;
  243.     goto bad;
  244.     }
  246. if (ip->ip_len != len) {
  247. if (len > ip->ip_len) {
  248. #ifdef WV_INSTRUMENTATION
  249. #ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
  250.             WV_NET_EVENT_0 (NET_CORE_EVENT, WV_NET_WARNING, 15, 5,
  251.                             WV_NETEVENT_UDPIN_BADLEN, WV_NET_RECV)
  252. #endif  /* INCLUDE_WVNET */
  253. #endif
  255. udpstat.udps_badlen++;
  256. goto bad;
  257. }
  258. m_adj(m, len - ip->ip_len);
  259. /* ip->ip_len = len; */
  260. }
  261. /*
  262.  * Save a copy of the IP header in case we want restore it
  263.  * for sending an ICMP error message in response.
  264.  */
  265. save_ip = *ip;
  267. /*
  268.  * Checksum extended UDP header and data.
  269.  */
  270. if (udpDoCkSumRcv && uh->uh_sum) {
  271. ((struct ipovly *)ip)->ih_next = 0;
  272. ((struct ipovly *)ip)->ih_prev = 0;
  273. ((struct ipovly *)ip)->ih_x1 = 0;
  274. ((struct ipovly *)ip)->ih_len = uh->uh_ulen;
  275. if ((uh->uh_sum = in_cksum(m, len + sizeof (struct ip)))) {
  276. #ifdef WV_INSTRUMENTATION
  277. #ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
  278.             WV_NET_EVENT_0 (NET_CORE_EVENT, WV_NET_WARNING, 16, 6,
  279.                             WV_NETEVENT_UDPIN_BADSUM, WV_NET_RECV)
  280. #endif  /* INCLUDE_WVNET */
  281. #endif
  283. udpstat.udps_badsum++;
  284. m_freem(m);
  285. return;
  286. }
  287. }
  289.         if(IN_MULTICAST(ntohl(ip->ip_dst.s_addr)))
  290.             {
  291.             IN_MULTI *  pInMulti;
  292.             M_BLK_ID pInPcbMblk;
  294.             IN_LOOKUP_MULTI(ip->ip_dst, m->m_pkthdr.rcvif, pInMulti);
  296.             /* give the packet to all pcbs registered */
  298.             if (pInMulti != NULL)
  299.                 {
  300. struct socket *last;
  301. /*
  302.  * Construct sockaddr format source address.
  303.  */
  304. udp_in.sin_port = uh->uh_sport;
  305. udp_in.sin_addr = ip->ip_src;
  306. m->m_len -= sizeof (struct udpiphdr);
  307. m->m_data += sizeof (struct udpiphdr);
  308. /*
  309.  * give the datagrams to all the pcbs 
  310.  * 
  311.  */
  312. last = NULL;
  313. for (pInPcbMblk = pInMulti->pInPcbMblk; pInPcbMblk != NULL;
  314.                      pInPcbMblk = pInPcbMblk->mBlkHdr.mNext)
  315.                     {
  316.                     inp = mtod (pInPcbMblk, struct inpcb *);
  317.                     if (inp->inp_lport != uh->uh_dport)
  318.                         continue;
  319.                     if (inp->inp_laddr.s_addr != INADDR_ANY)
  320.                         if (inp->inp_laddr.s_addr != ip->ip_dst.s_addr)
  321.                             continue;
  322.                     if (inp->inp_faddr.s_addr != INADDR_ANY)
  323.                         if (inp->inp_faddr.s_addr != ip->ip_src.s_addr ||
  324.                             inp->inp_fport != uh->uh_sport)
  325.                             continue;
  327.                     if (last != NULL)
  328.                         {
  329.                         struct mbuf *n;
  331.                         if ((n = m_copy(m, 0, M_COPYALL)) != NULL)
  332.                             {
  333. #ifdef WV_INSTRUMENTATION
  334. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  335.                 WV_NET_PORTIN_EVENT_4 (NET_CORE_EVENT, WV_NET_INFO, 56, 18,
  336.                                        uh->uh_sport, uh->uh_dport,
  337.                                        WV_NETEVENT_UDPIN_PCBGOOD, WV_NET_RECV,
  338.                                        ip->ip_src.s_addr, uh->uh_sport,
  339.                                        last->so_fd, uh->uh_dport)
  340. #endif  /* INCLUDE_WVNET */
  341. #endif
  343.                             if (sbappendaddr(&last->so_rcv,
  344.                                              (struct sockaddr *)&udp_in,
  345.                                              n, (struct mbuf *)0) == 0)
  346.                                 {
  347. #ifdef WV_INSTRUMENTATION
  348. #ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
  349.                 WV_NET_PORTIN_EVENT_1 (NET_CORE_EVENT, WV_NET_WARNING, 17, 7,
  350.                                        uh->uh_sport, uh->uh_dport,
  351.                                        WV_NETEVENT_UDPIN_FULLSOCK, WV_NET_RECV,
  352.                                        last->so_fd)
  353. #endif  /* INCLUDE_WVNET */
  354. #endif
  356.                                 m_freem(n);
  357.                                 udpstat.udps_fullsock++;
  358.                                 }
  359.                             else
  360.                                 sorwakeup(last);
  361.                             }
  362.                         }
  363.                     last = inp->inp_socket;
  364.                     /*
  365.                      * Don't look for additional matches if this one does
  366.                      * not have either the SO_REUSEPORT or SO_REUSEADDR
  367.                      * socket options set.  This heuristic avoids searching
  368.                      * through all pcbs in the common case of a non-shared
  369.                      * port.  It assumes that an application will never
  370.                      * clear these options after setting them.
  371.                      */
  372.                     if ((last->so_options & (SO_REUSEPORT|SO_REUSEADDR)) == 0)
  373.                         break;
  374.                     }
  376. if (last == NULL)
  377.                     {
  378.                     /*
  379.                      * No matching pcb found; discard datagram.
  380.                      * (No need to send an ICMP Port Unreachable
  381.                      * for a broadcast or multicast datgram.)
  382.                      */
  384. #ifdef WV_INSTRUMENTATION
  385. #ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
  386.             WV_NET_PORTIN_EVENT_4 (NET_CORE_EVENT, WV_NET_WARNING, 18, 8,
  387.                                    uh->uh_sport, uh->uh_dport,
  388.                                    WV_NETEVENT_UDPIN_SEARCHFAIL, WV_NET_RECV,
  389.                                    ip->ip_src.s_addr, uh->uh_sport,
  390.                                    ip->ip_dst.s_addr, uh->uh_dport)
  391. #endif  /* INCLUDE_WVNET */
  392. #endif
  394.                     udpstat.udps_noportbcast++;
  395.                     goto bad;
  396.                     }
  398. #ifdef WV_INSTRUMENTATION
  399. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  400.             WV_NET_PORTIN_EVENT_4 (NET_CORE_EVENT, WV_NET_INFO, 56, 18,
  401.                                    uh->uh_sport, uh->uh_dport,
  402.                                    WV_NETEVENT_UDPIN_PCBGOOD, WV_NET_RECV,
  403.                                    ip->ip_src.s_addr, uh->uh_sport,
  404.                                    last->so_fd, uh->uh_dport)
  405. #endif  /* INCLUDE_WVNET */
  406. #endif
  408. if (sbappendaddr(&last->so_rcv, (struct sockaddr *)&udp_in,
  409.                                  m, (struct mbuf *)0) == 0)
  410.                     {
  411. #ifdef WV_INSTRUMENTATION
  412. #ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
  413.             WV_NET_PORTIN_EVENT_1 (NET_CORE_EVENT, WV_NET_WARNING, 17, 7,
  414.                                    uh->uh_sport, uh->uh_dport,
  415.                                    WV_NETEVENT_UDPIN_FULLSOCK, WV_NET_RECV,
  416.                                    last->so_fd)
  417. #endif  /* INCLUDE_WVNET */
  418. #endif
  420.                     udpstat.udps_fullsock++;
  421.                     goto bad;
  422.                     }
  423. sorwakeup(last);
  424. return;
  425.                 }
  426.             }
  427.         
  428. if (in_broadcast(ip->ip_dst, m->m_pkthdr.rcvif)) {
  429. struct socket *last;
  430. /*
  431.  * Deliver a multicast or broadcast datagram to *all* sockets
  432.  * for which the local and remote addresses and ports match
  433.  * those of the incoming datagram.  This allows more than
  434.  * one process to receive multi/broadcasts on the same port.
  435.  * (This really ought to be done for unicast datagrams as
  436.  * well, but that would cause problems with existing
  437.  * applications that open both address-specific sockets and
  438.  * a wildcard socket listening to the same port -- they would
  439.  * end up receiving duplicates of every unicast datagram.
  440.  * Those applications open the multiple sockets to overcome an
  441.  * inadequacy of the UDP socket interface, but for backwards
  442.  * compatibility we avoid the problem here rather than
  443.  * fixing the interface.  Maybe 4.5BSD will remedy this?)
  444.  */
  446. /*
  447.  * Construct sockaddr format source address.
  448.  */
  449. udp_in.sin_port = uh->uh_sport;
  450. udp_in.sin_addr = ip->ip_src;
  451. m->m_len -= sizeof (struct udpiphdr);
  452. m->m_data += sizeof (struct udpiphdr);
  453. /*
  454.  * Locate pcb(s) for datagram.
  455.  * (Algorithm copied from raw_intr().)
  456.  */
  457. last = NULL;
  458. for (inp = udb.lh_first; inp != NULL;
  459.                      inp = inp->inp_list.le_next) {
  460. if (inp->inp_lport != uh->uh_dport)
  461. continue;
  462. if (inp->inp_laddr.s_addr != INADDR_ANY) {
  463. if (inp->inp_laddr.s_addr !=
  464.     ip->ip_dst.s_addr)
  465. continue;
  466. }
  467. if (inp->inp_faddr.s_addr != INADDR_ANY) {
  468. if (inp->inp_faddr.s_addr !=
  469.     ip->ip_src.s_addr ||
  470.     inp->inp_fport != uh->uh_sport)
  471. continue;
  472. }
  474. if (last != NULL) {
  475. struct mbuf *n;
  477. if ((n = m_copy(m, 0, M_COPYALL)) != NULL) {
  478. #ifdef WV_INSTRUMENTATION
  479. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  480.             WV_NET_PORTIN_EVENT_4 (NET_CORE_EVENT, WV_NET_INFO, 56, 18,
  481.                                    uh->uh_sport, uh->uh_dport,
  482.                                    WV_NETEVENT_UDPIN_PCBGOOD, WV_NET_RECV,
  483.                                    ip->ip_src.s_addr, uh->uh_sport,
  484.                                    last->so_fd, uh->uh_dport)
  485. #endif  /* INCLUDE_WVNET */
  486. #endif
  488. if (sbappendaddr(&last->so_rcv,
  489. (struct sockaddr *)&udp_in,
  490. n, (struct mbuf *)0) == 0) {
  491. m_freem(n);
  492. #ifdef WV_INSTRUMENTATION
  493. #ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
  494.             WV_NET_PORTIN_EVENT_1 (NET_CORE_EVENT, WV_NET_WARNING, 17, 7,
  495.                                    uh->uh_sport, uh->uh_dport,
  496.                                    WV_NETEVENT_UDPIN_FULLSOCK, WV_NET_RECV,
  497.                                    last->so_fd)
  498. #endif  /* INCLUDE_WVNET */
  499. #endif
  501. udpstat.udps_fullsock++;
  502. } else
  503. sorwakeup(last);
  504. }
  505. }
  506. last = inp->inp_socket;
  507. /*
  508.  * Don't look for additional matches if this one does
  509.  * not have either the SO_REUSEPORT or SO_REUSEADDR
  510.  * socket options set.  This heuristic avoids searching
  511.  * through all pcbs in the common case of a non-shared
  512.  * port.  It * assumes that an application will never
  513.  * clear these options after setting them.
  514.  */
  515. if ((last->so_options & (SO_REUSEPORT|SO_REUSEADDR))
  516.                             == 0)
  517. break;
  518. }
  520. if (last == NULL) {
  521. /*
  522.  * No matching pcb found; discard datagram.
  523.  * (No need to send an ICMP Port Unreachable
  524.  * for a broadcast or multicast datgram.)
  525.  */
  527. #ifdef WV_INSTRUMENTATION
  528. #ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
  529.             WV_NET_PORTIN_EVENT_4 (NET_CORE_EVENT, WV_NET_WARNING, 18, 8,
  530.                                    uh->uh_sport, uh->uh_dport,
  531.                                    WV_NETEVENT_UDPIN_SEARCHFAIL, WV_NET_RECV,
  532.                                    ip->ip_src.s_addr, uh->uh_sport,
  533.                                    ip->ip_dst.s_addr, uh->uh_dport)
  534. #endif  /* INCLUDE_WVNET */
  535. #endif
  537. udpstat.udps_noportbcast++;
  538. goto bad;
  539. }
  540. #ifdef WV_INSTRUMENTATION
  541. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  542.             WV_NET_PORTIN_EVENT_4 (NET_CORE_EVENT, WV_NET_INFO, 56, 18,
  543.                                    uh->uh_sport, uh->uh_dport,
  544.                                    WV_NETEVENT_UDPIN_PCBGOOD, WV_NET_RECV,
  545.                                    ip->ip_src.s_addr, uh->uh_sport,
  546.                                    last->so_fd, uh->uh_dport)
  547. #endif  /* INCLUDE_WVNET */
  548. #endif
  550. if (sbappendaddr(&last->so_rcv, (struct sockaddr *)&udp_in,
  551.      m, (struct mbuf *)0) == 0) {
  552. #ifdef WV_INSTRUMENTATION
  553. #ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
  554.             WV_NET_PORTIN_EVENT_1 (NET_CORE_EVENT, WV_NET_WARNING, 17, 7,
  555.                                    uh->uh_sport, uh->uh_dport,
  556.                                    WV_NETEVENT_UDPIN_FULLSOCK, WV_NET_RECV,
  557.                                    last->so_fd)
  558. #endif  /* INCLUDE_WVNET */
  559. #endif
  561. udpstat.udps_fullsock++;
  562. goto bad;
  563. }
  564. sorwakeup(last);
  565. return;
  566. }
  567. /*
  568.  * Locate pcb for datagram. use the cached pcb if it matches.
  569.  */
  570. inp = udp_last_inpcb;
  571.         if ((inp != NULL) &&
  572.             (inp->inp_lport == uh->uh_dport) &&
  573.     (inp->inp_fport == uh->uh_sport) &&
  574.     (inp->inp_faddr.s_addr == ip->ip_src.s_addr) &&
  575.             (inp->inp_laddr.s_addr == ip->ip_dst.s_addr))
  576.             {
  577.             goto pcbMatchFound;
  578.             }
  579.         else
  580.             {
  581. #ifdef WV_INSTRUMENTATION
  582. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  583.             WV_NET_PORTIN_EVENT_4 (NET_CORE_EVENT, WV_NET_VERBOSE, 44, 17,
  584.                                    uh->uh_sport, uh->uh_dport,
  585.                                    WV_NETEVENT_UDPIN_CACHEMISS, WV_NET_RECV,
  586.                                    ip->ip_src.s_addr, uh->uh_sport,
  587.                                    ip->ip_dst.s_addr, uh->uh_dport)
  588. #endif  /* INCLUDE_WVNET */
  589. #endif
  591.             udpstat.udpps_pcbcachemiss++;
  592.             /*
  593.              * Locate pcb for datagram.
  594.              */
  595.             inp = in_pcblookuphash(&udbinfo, ip->ip_src, uh->uh_sport,
  596.                                        ip->ip_dst, uh->uh_dport, 1);
  597.             if (inp == NULL)
  598.                 { /* look up for the wildcard match, hash look up failed */
  599.                 udpstat.udpps_pcbhashmiss++;
  601.                 udpstat.udps_noport++;
  603. #ifdef WV_INSTRUMENTATION
  604. #ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
  605.             WV_NET_PORTIN_EVENT_4 (NET_CORE_EVENT, WV_NET_WARNING, 18, 8,
  606.                                    uh->uh_sport, uh->uh_dport,
  607.                                    WV_NETEVENT_UDPIN_SEARCHFAIL, WV_NET_RECV,
  608.                                    ip->ip_src.s_addr, uh->uh_sport,
  609.                                    ip->ip_dst.s_addr, uh->uh_dport)
  610. #endif  /* INCLUDE_WVNET */
  611. #endif
  612.                 if (m->m_flags & (M_BCAST | M_MCAST))
  613.                     {
  614.                     udpstat.udps_noportbcast++;
  615.                     goto bad;
  616.                     }
  618. #ifdef WV_INSTRUMENTATION
  619. #ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
  620.             WV_NET_PORTIN_EVENT_4 (NET_CORE_EVENT, WV_NET_WARNING, 19, 9,
  621.                                    uh->uh_sport, uh->uh_dport,
  622.                                    WV_NETEVENT_UDPIN_NOPORT, WV_NET_RECV,
  623.                                    ip->ip_src.s_addr, uh->uh_sport,
  624.                                    ip->ip_dst.s_addr, uh->uh_dport)
  625. #endif  /* INCLUDE_WVNET */
  626. #endif
  628.                 *ip = save_ip;
  630.                 /* bug fix mentioned in Stevens VolII page774,(vinai) */
  631.                 /* ip->ip_len += iphlen; */
  632.                 if (_icmpErrorHook != NULL)
  633.                     (*_icmpErrorHook) (m, ICMP_UNREACH, ICMP_UNREACH_PORT, 
  634.                                        0, 0);
  635.                 return;
  636.                 }
  637.             }
  638.         udp_last_inpcb = inp;
  639.         
  640. pcbMatchFound:
  641. #ifdef WV_INSTRUMENTATION
  642. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  643.             WV_NET_PORTIN_EVENT_4 (NET_CORE_EVENT, WV_NET_INFO, 56, 18,
  644.                                    uh->uh_sport, uh->uh_dport,
  645.                                    WV_NETEVENT_UDPIN_PCBGOOD, WV_NET_RECV,
  646.                                    ip->ip_src.s_addr, uh->uh_sport,
  647.                                    inp->inp_socket->so_fd, uh->uh_dport)
  648. #endif  /* INCLUDE_WVNET */
  649. #endif
  651. /*
  652.  * Construct sockaddr format source address.
  653.  * Stuff source address and datagram in user buffer.
  654.  */
  655. udp_in.sin_port = uh->uh_sport;
  656. udp_in.sin_addr = ip->ip_src;
  657. if (inp->inp_flags & INP_CONTROLOPTS) {
  658. struct mbuf **mp = &opts;
  660. if (inp->inp_flags & INP_RECVDSTADDR) {
  661. *mp = udp_saveopt((caddr_t) &ip->ip_dst,
  662.     sizeof(struct in_addr), IP_RECVDSTADDR);
  663. if (*mp)
  664. mp = &(*mp)->m_next;
  665. }
  666. #ifdef notyet
  667. /* options were tossed above */
  668. if (inp->inp_flags & INP_RECVOPTS) {
  669. *mp = udp_saveopt((caddr_t) opts_deleted_above,
  670.     sizeof(struct in_addr), IP_RECVOPTS);
  671. if (*mp)
  672. mp = &(*mp)->m_next;
  673. }
  674. /* ip_srcroute doesn't do what we want here, need to fix */
  675. if (inp->inp_flags & INP_RECVRETOPTS) {
  676. *mp = udp_saveopt((caddr_t) ip_srcroute(),
  677.     sizeof(struct in_addr), IP_RECVRETOPTS);
  678. if (*mp)
  679. mp = &(*mp)->m_next;
  680. }
  681. #endif
  682. }
  683. iphlen += sizeof(struct udphdr);
  684. m->m_len -= iphlen;
  685. m->m_pkthdr.len -= iphlen;
  686. m->m_data += iphlen;
  687. if (sbappendaddr(&inp->inp_socket->so_rcv, (struct sockaddr *)&udp_in,
  688.     m, opts) == 0) {
  689. #ifdef WV_INSTRUMENTATION
  690. #ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
  691.             WV_NET_PORTIN_EVENT_1 (NET_CORE_EVENT, WV_NET_WARNING, 17, 7,
  692.                                    uh->uh_sport, uh->uh_dport,
  693.                                    WV_NETEVENT_UDPIN_FULLSOCK, WV_NET_RECV,
  694.                                    inp->inp_socket->so_fd)
  695. #endif  /* INCLUDE_WVNET */
  696. #endif
  698. udpstat.udps_fullsock++;
  699. goto bad;
  700. }
  701. sorwakeup(inp->inp_socket);
  702. return;
  703. bad:
  704. m_freem(m);
  705. if (opts)
  706. m_freem(opts);
  707. }
  709. /*
  710.  * Create a "control" mbuf containing the specified data
  711.  * with the specified type for presentation with a datagram.
  712.  */
  713. struct mbuf *
  714. udp_saveopt(p, size, type)
  715. caddr_t p;
  716. register int size;
  717. int type;
  718. {
  719. register struct cmsghdr *cp;
  720. struct mbuf *m;
  722. if ((m = mBufClGet(M_DONTWAIT, MT_CONTROL, CL_SIZE_128, TRUE)) == NULL)
  723. return ((struct mbuf *) NULL);
  724. cp = (struct cmsghdr *) mtod(m, struct cmsghdr *);
  725. bcopy(p, CMSG_DATA(cp), size);
  726. size += sizeof(*cp);
  727. m->m_len = size;
  728. cp->cmsg_len = size;
  729. cp->cmsg_level = IPPROTO_IP;
  730. cp->cmsg_type = type;
  731. return (m);
  732. }
  734. /*
  735.  * Notify a udp user of an asynchronous error;
  736.  * just wake up so that he can collect error status.
  737.  */
  738. static void
  739. udp_notify(inp, error)
  740. register struct inpcb *inp;
  741. int error;
  742. {
  743. #ifdef WV_INSTRUMENTATION
  744. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  745.     WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_INFO, 48, 12,
  746.                      WV_NETEVENT_UDPNOTIFY_START,
  747.                      inp->inp_socket->so_fd, error)
  748. #endif  /* INCLUDE_WVNET */
  749. #endif
  751. inp->inp_socket->so_error = error;
  752. sorwakeup(inp->inp_socket);
  753. sowwakeup(inp->inp_socket);
  754. }
  756. void
  757. udp_ctlinput(cmd, sa, ip)
  758. int cmd;
  759. struct sockaddr *sa;
  760. register struct ip *ip;
  761. {
  762. register struct udphdr *uh;
  763. extern struct in_addr zeroin_addr;
  764. extern u_char inetctlerrmap[];
  766. #ifdef WV_INSTRUMENTATION
  767. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  768.     WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_INFO, 49, 13,
  769.                      WV_NETEVENT_UDPCTLIN_START, cmd)
  770. #endif  /* INCLUDE_WVNET */
  771. #endif
  773. if (!PRC_IS_REDIRECT(cmd) &&
  774.     ((unsigned)cmd >= PRC_NCMDS || inetctlerrmap[cmd] == 0))
  775. return;
  776. if (ip) {
  777. uh = (struct udphdr *)((caddr_t)ip + (ip->ip_hl << 2));
  778. in_pcbnotify(&udb, sa, uh->uh_dport, ip->ip_src, uh->uh_sport,
  779. cmd, udp_notify);
  780. } else
  781. in_pcbnotify(&udb, sa, 0, zeroin_addr, 0, cmd, udp_notify);
  782. }
  784. int
  785. udp_output(inp, m, addr, control)
  786. register struct inpcb *inp;
  787. register struct mbuf *m;
  788. struct mbuf *addr, *control;
  789. {
  790.         struct rtentry *rt;
  791. register struct udpiphdr *ui;
  792. register int len = m->m_pkthdr.len;
  793. struct in_addr laddr;
  794. int s = 0, error = 0;
  796. if (control)
  797. m_freem(control); /* XXX */
  799. if (addr) {
  800. laddr = inp->inp_laddr;
  801. if (inp->inp_faddr.s_addr != INADDR_ANY) {
  802. error = EISCONN;
  803. goto release;
  804. }
  805. /*
  806.  * Must block input while temporarily connected.
  807.  */
  808. s = splnet();
  809. error = in_pcbconnect(inp, addr);
  810. if (error) {
  811. splx(s);
  812. goto release;
  813. }
  814. } else {
  815. if (inp->inp_faddr.s_addr == INADDR_ANY) {
  816. error = ENOTCONN;
  817. goto release;
  818. }
  819. }
  820. /*
  821.  * Calculate data length and get a mbuf
  822.  * for UDP and IP headers.
  823.  */
  824. M_PREPEND(m, sizeof(struct udpiphdr), M_DONTWAIT);
  825. if (m == 0) {
  826. error = ENOBUFS;
  827. if (addr)
  828.     {
  829.                     in_pcbdisconnect(inp);
  830.     splx (s);
  831.     }
  833. goto release;
  834. }
  836. /*
  837.  * Fill in mbuf with extended UDP header
  838.  * and addresses and length put into network format.
  839.  */
  840. ui = mtod(m, struct udpiphdr *);
  841. ui->ui_next = ui->ui_prev = 0;
  842. ui->ui_x1 = 0;
  843. ui->ui_pr = IPPROTO_UDP;
  844. ui->ui_len = htons((u_short)len + sizeof (struct udphdr));
  845. ui->ui_src = inp->inp_laddr;
  846. ui->ui_dst = inp->inp_faddr;
  847. ui->ui_sport = inp->inp_lport;
  848. ui->ui_dport = inp->inp_fport;
  849. ui->ui_ulen = ui->ui_len;
  851. /*
  852.  * Stuff checksum and output datagram.
  853.  */
  854. ui->ui_sum = 0;
  855. if (udpcksum) {
  856.     if ((ui->ui_sum = in_cksum(m, sizeof (struct udpiphdr) + len)) == 0)
  857. ui->ui_sum = 0xffff;
  858. }
  859. ((struct ip *)ui)->ip_len = sizeof (struct udpiphdr) + len;
  860. ((struct ip *)ui)->ip_ttl = inp->inp_ip.ip_ttl; /* XXX */
  861. ((struct ip *)ui)->ip_tos = inp->inp_ip.ip_tos; /* XXX */
  862. udpstat.udps_opackets++;
  864.         /*
  865.          * Prevent fragmentation to continue (or trigger) path MTU discovery
  866.          * if the required routing entry and path MTU estimate are available
  867.          * and path MTU discovery is enabled for this socket. Since UDP
  868.          * produces a single datagram for each send operation, the application
  869.          * which enables path MTU discovery must send datagrams equal to
  870.          * the current MTU estimate or the process will not complete.
  871.          */
  873.         rt = inp->inp_route.ro_rt;
  874.         if (rt && (rt->rt_flags & RTF_UP) && !(rt->rt_rmx.rmx_locks & RTV_MTU))
  875.             {
  876.             if (inp->inp_socket->so_options & SO_USEPATHMTU)
  877.                 ( (struct ip *)ui)->ip_off |= IP_DF;
  878.             }
  880. error = ip_output(m, inp->inp_options, &inp->inp_route,
  881.     inp->inp_socket->so_options & (SO_DONTROUTE | SO_BROADCAST),
  882.     inp->inp_moptions);
  884. #ifdef WV_INSTRUMENTATION
  885. #ifdef INCLUDE_WVNET    /* WV_NET_NOTICE event */
  886.     WV_NET_PORTOUT_EVENT_4 (NET_CORE_EVENT, WV_NET_NOTICE, 22, 11,
  887.                             inp->inp_lport, inp->inp_fport,
  888.                             WV_NETEVENT_UDPOUT_FINISH, WV_NET_SEND,
  889.                             inp->inp_socket->so_fd, error,
  890.                             inp->inp_lport, inp->inp_fport)
  891. #endif  /* INCLUDE_WVNET */
  892. #endif
  894. if (addr) {
  895. in_pcbdisconnect(inp);
  896. inp->inp_laddr = laddr;
  897. splx(s);
  898. }
  900. return (error);
  902. release:
  903. #ifdef WV_INSTRUMENTATION
  904. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  905.     WV_NET_EVENT_2 (NET_CORE_EVENT, WV_NET_ERROR, 41, 2,
  906.                     WV_NETEVENT_UDPOUT_FAIL, WV_NET_SEND,
  907.                     inp->inp_socket->so_fd, error)
  908. #endif  /* INCLUDE_WVNET */
  909. #endif
  911. m_freem(m);
  912. return (error);
  913. }
  915. /*ARGSUSED*/
  916. int
  917. udp_usrreq(so, req, m, addr, control)
  918. struct socket *so;
  919. int req;
  920. struct mbuf *m, *addr, *control;
  921. {
  922. struct inpcb *inp = sotoinpcb(so);
  923. int error = 0;
  924. int s;
  926. #ifdef WV_INSTRUMENTATION
  927. #ifdef INCLUDE_WVNET    /* WV_NET_INFO event */
  928.     WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_INFO, 50, 14,
  929.                      WV_NETEVENT_UDPREQ_START, so->so_fd, req)
  930. #endif  /* INCLUDE_WVNET */
  931. #endif
  933. if (req == PRU_CONTROL)
  934. return (in_control(so, (u_long)m, (caddr_t)addr,
  935. (struct ifnet *)control));
  936. if (inp == NULL && req != PRU_ATTACH) {
  937. #ifdef WV_INSTRUMENTATION
  938. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  939.         WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_ERROR, 42, 3,
  940.                         WV_NETEVENT_UDPREQ_NOPCB, so->so_fd, req)
  941. #endif  /* INCLUDE_WVNET */
  942. #endif
  944. error = EINVAL;
  945. goto release;
  946. }
  947. /*
  948.  * Note: need to block udp_input while changing
  949.  * the udp pcb queue and/or pcb addresses.
  950.  */
  951. switch (req) {
  953. case PRU_ATTACH:
  954. if (inp != NULL) {
  955. error = EINVAL;
  956. break;
  957. }
  958. s = splnet();
  959. error = in_pcballoc(so, &udbinfo);
  960. splx(s);
  961. if (error)
  962. break;
  963. error = soreserve(so, udp_sendspace, udp_recvspace);
  964. if (error)
  965. break;
  966. ((struct inpcb *) so->so_pcb)->inp_ip.ip_ttl = ip_defttl;
  967. break;
  969. case PRU_DETACH:
  970. udp_detach(inp);
  971. break;
  973. case PRU_BIND:
  974. s = splnet();
  975. error = in_pcbbind(inp, addr);
  976. splx(s);
  977. break;
  979. case PRU_LISTEN:
  980. error = EOPNOTSUPP;
  981. break;
  983. case PRU_CONNECT:
  984. if (inp->inp_faddr.s_addr != INADDR_ANY) {
  985. error = EISCONN;
  986. break;
  987. }
  988. s = splnet();
  989. error = in_pcbconnect(inp, addr);
  990. splx(s);
  991. if (error == 0)
  992. soisconnected(so);
  993. break;
  995. case PRU_CONNECT2:
  996. error = EOPNOTSUPP;
  997. break;
  999. case PRU_ACCEPT:
  1000. error = EOPNOTSUPP;
  1001. break;
  1003. case PRU_DISCONNECT:
  1004. if (inp->inp_faddr.s_addr == INADDR_ANY) {
  1005. error = ENOTCONN;
  1006. break;
  1007. }
  1008. s = splnet();
  1009. in_pcbdisconnect(inp);
  1010. inp->inp_laddr.s_addr = INADDR_ANY;
  1011. splx(s);
  1012. so->so_state &= ~SS_ISCONNECTED; /* XXX */
  1013. break;
  1015. case PRU_SHUTDOWN:
  1016. socantsendmore(so);
  1017. break;
  1019. case PRU_SEND:
  1020. return (udp_output(inp, m, addr, control));
  1022. case PRU_ABORT:
  1023. soisdisconnected(so);
  1024. udp_detach(inp);
  1025. break;
  1027. case PRU_SOCKADDR:
  1028. in_setsockaddr(inp, addr);
  1029. break;
  1031. case PRU_PEERADDR:
  1032. in_setpeeraddr(inp, addr);
  1033. break;
  1035. case PRU_SENSE:
  1036. /*
  1037.  * stat: don't bother with a blocksize.
  1038.  */
  1039. return (0);
  1041. case PRU_SENDOOB:
  1042. case PRU_FASTTIMO:
  1043. case PRU_SLOWTIMO:
  1044. case PRU_PROTORCV:
  1045. case PRU_PROTOSEND:
  1046. error =  EOPNOTSUPP;
  1047. break;
  1049. case PRU_RCVD:
  1050. case PRU_RCVOOB:
  1051. return (EOPNOTSUPP); /* do not free mbuf's */
  1053. default:
  1054. #ifdef WV_INSTRUMENTATION
  1055. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  1056.             WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_EMERGENCY, 32, 1,
  1057.                              WV_NETEVENT_UDPREQ_PANIC, so->so_fd, req)
  1058. #endif  /* INCLUDE_WVNET */
  1059. #endif
  1061. panic("udp_usrreq");
  1062. }
  1064. release:
  1065. if (control) {
  1066. printf("udp control data unexpectedly retainedn");
  1067. m_freem(control);
  1068. }
  1069. if (m)
  1070. m_freem(m);
  1071. return (error);
  1072. }
  1074. static void
  1075. udp_detach(inp)
  1076. struct inpcb *inp;
  1077. {
  1078. int s = splnet();
  1080. if (inp == udp_last_inpcb)
  1081.             udp_last_inpcb = NULL;
  1082. in_pcbdetach(inp);
  1083. splx(s);
  1084. }
  1086. #ifdef SYSCTL_SUPPORT
  1087. /*
  1088.  * Sysctl for udp variables.
  1089.  */
  1090. udp_sysctl(name, namelen, oldp, oldlenp, newp, newlen)
  1091. int *name;
  1092. u_int namelen;
  1093. void *oldp;
  1094. size_t *oldlenp;
  1095. void *newp;
  1096. size_t newlen;
  1097. {
  1098. /*
  1099.  * XXX - This event cannot currently occur: the udp_sysctl() routine
  1100.  *       is only called by the Unix sysctl command which is not supported
  1101.  *       by VxWorks
  1104. #ifdef WV_INSTRUMENTATION
  1105. #ifdef INCLUDE_WVNET    /@ WV_NET_INFO event @/
  1106.     WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_INFO, 51, 15,
  1107.                      WV_NETEVENT_UDPCTRL_START, name[0])
  1108. #endif  /@ INCLUDE_WVNET @/
  1109. #endif
  1111.  * XXX - end of unused event
  1112.  */
  1114. /* All sysctl names at this level are terminal. */
  1115. if (namelen != 1)
  1116. return (ENOTDIR);
  1118. switch (name[0]) {
  1119. case UDPCTL_CHECKSUM:
  1120. return (sysctl_int(oldp, oldlenp, newp, newlen, &udpcksum));
  1121. default:
  1122. return (ENOPROTOOPT);
  1123. }
  1124. /* NOTREACHED */
  1125. }
  1126. #endif /* SYSCTL_SUPPORT */