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

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

VxWorks

开发平台：

C/C++

in_pcb.c：源码内容
  1. /* in_pcb.c - internet protocol control block routines */
  3. /* Copyright 1984 - 2001 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7.  * Copyright (c) 1982, 1986, 1991, 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.  * @(#)in_pcb.c 8.4 (Berkeley) 5/24/95
  39.  */
  41. /*
  42. modification history
  43. --------------------
  44. 01g,12oct01,rae  merge from truestack ver 01k, base 01f (SPR #69867 etc.)
  45. 01f,05oct97,vin  changed ip_freemoptions for new multicasting changes.
  46. 01e,01jul97,vin  added rtMissMsgHook for scalability of routing sockets.
  47. 01d,31mar97,vin  integrated with FREEBSD 2.2.1 for hashlookups of pcbs
  48. 01c,05feb97,rjc  changed for tos routing.
  49. 01b,05dec96,vin  replaced malloc with MALLOC and free with FREE(),
  50. 01a,03mar96,vin  created from BSD4.4 stuff,integrated with 02k of in_pcb.c
  51. */
  53. /*
  54. DESCRIPTION
  55. */
  57. #include "vxWorks.h"
  58. #include "net/systm.h"
  59. #include "errno.h"
  60. #include "net/mbuf.h"
  61. #include "sys/socket.h"
  62. #include "net/socketvar.h"
  63. #include "sys/ioctl.h"
  64. #include "net/if.h"
  65. #include "netinet/in.h"
  66. #include "netinet/in_systm.h"
  67. #include "net/route.h"
  68. #include "netinet/in_pcb.h"
  69. #include "netinet/in_var.h"
  70. #include "netinet/ip_var.h"
  71. #include "net/protosw.h"
  72. #include "routeEnhLib.h"
  74. #ifdef VIRTUAL_STACK
  75. #include "netinet/vsLib.h"
  76. #endif /* VIRTUAL_STACK */
  78. #ifdef WV_INSTRUMENTATION
  79. #ifdef INCLUDE_WVNET
  80. #include "wvNetLib.h"
  81. #endif
  82. #endif
  84. struct in_addr   zeroin_addr;
  86. #ifdef VIRTUAL_STACK
  87. #define IN_IFADDR _in_ifaddr
  88. #else
  89. #define IN_IFADDR in_ifaddr
  90. #endif
  92. #ifdef WV_INSTRUMENTATION
  93. #ifdef INCLUDE_WVNET
  94.     /* Set common fields of event identifiers for this module. */
  96. LOCAL UCHAR wvNetModuleId = WV_NET_INPCB_MODULE;   /* Value for in_pcb.c */
  97. LOCAL UCHAR wvNetLocalFilter = WV_NET_NONE;     /* Available event filter */
  99. LOCAL ULONG wvNetEventId;       /* Event identifier: see wvNetLib.h */
  100. #endif    /* INCLUDE_WVNET */
  101. #endif
  103. int
  104. in_pcballoc(so, pcbinfo)
  105. struct socket *so;
  106. struct inpcbinfo *pcbinfo;
  107. {
  108. register struct inpcb *inp;
  109. int s;
  111. MALLOC(inp, struct inpcb *, sizeof(*inp), MT_PCB, M_DONTWAIT);
  112. if (inp == NULL)
  113.             {
  114. #ifdef WV_INSTRUMENTATION
  115. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  116.             WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_EMERGENCY, 13, 1, 
  117.                              WV_NETEVENT_PCBALLOC_NOBUFS, so->so_fd)
  118. #endif  /* INCLUDE_WVNET */
  119. #endif
  121.             return (ENOBUFS);
  122.             }
  123. bzero((caddr_t)inp, sizeof(*inp));
  124. inp->inp_pcbinfo = pcbinfo;
  125. inp->inp_socket = so;
  126. s = splnet();
  127. LIST_INSERT_HEAD(pcbinfo->listhead, inp, inp_list);
  128. in_pcbinshash(inp);
  129. splx(s);
  130. so->so_pcb = (caddr_t)inp;
  131. return (0);
  132. }
  134. int
  135. in_pcbbind(inp, nam)
  136. register struct inpcb *inp;
  137. struct mbuf *nam;
  138. {
  139. register struct socket *so = inp->inp_socket;
  140. unsigned short *lastport = &inp->inp_pcbinfo->lastport;
  141. struct sockaddr_in *sin;
  142. u_short lport = 0;
  143. int wild = 0, reuseport = (so->so_options & SO_REUSEPORT);
  145. #ifdef WV_INSTRUMENTATION
  146. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  147.     WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_VERBOSE, 23, 11, 
  148.                      WV_NETEVENT_PCBBIND_START, so->so_fd)
  149. #endif  /* INCLUDE_WVNET */
  150. #endif
  152. #ifdef VIRTUAL_STACK
  153. if (_in_ifaddr == 0)
  154. #else
  155. if (in_ifaddr == 0)
  156. #endif /* VIRTUAL_STACK */
  157.             {
  158. #ifdef WV_INSTRUMENTATION
  159. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  160.             WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_ERROR, 10, 2,
  161.                              WV_NETEVENT_PCBBIND_NOADDR, so->so_fd)
  162. #endif  /* INCLUDE_WVNET */
  163. #endif
  165.             return (EADDRNOTAVAIL);
  166.             }
  167. if (inp->inp_lport || inp->inp_laddr.s_addr != INADDR_ANY)
  168.             {
  169. #ifdef WV_INSTRUMENTATION
  170. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  171.             WV_NET_MARKER_3 (NET_AUX_EVENT, WV_NET_ERROR, 11, 3,
  172.                              WV_NETEVENT_PCBBIND_BADSOCK, so->so_fd,
  173.                              inp->inp_laddr.s_addr, inp->inp_lport)
  174. #endif  /* INCLUDE_WVNET */
  175. #endif
  177.             return (EINVAL);
  178.             }
  179. if ((so->so_options & (SO_REUSEADDR|SO_REUSEPORT)) == 0 &&
  180.     ((so->so_proto->pr_flags & PR_CONNREQUIRED) == 0 ||
  181.      (so->so_options & SO_ACCEPTCONN) == 0))
  182. wild = INPLOOKUP_WILDCARD;
  183. if (nam) {
  184. sin = mtod(nam, struct sockaddr_in *);
  185. if (nam->m_len != sizeof (*sin))
  186.                     {
  187. #ifdef WV_INSTRUMENTATION
  188. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  189.             WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_ERROR, 12, 4, 
  190.                              WV_NETEVENT_PCBBIND_BADADDRLEN,
  191.                              so->so_fd, nam->m_len)
  192. #endif  /* INCLUDE_WVNET */
  193. #endif
  195.                     return (EINVAL);
  196.                     }
  197. #ifdef notdef
  198. /*
  199.  * We should check the family, but old programs
  200.  * incorrectly fail to initialize it.
  201.  */
  202. if (sin->sin_family != AF_INET)
  203. return (EAFNOSUPPORT);
  204. #endif
  205. lport = sin->sin_port;
  206. if (IN_MULTICAST(ntohl(sin->sin_addr.s_addr))) {
  207. /*
  208.  * Treat SO_REUSEADDR as SO_REUSEPORT for multicast;
  209.  * allow complete duplication of binding if
  210.  * SO_REUSEPORT is set, or if SO_REUSEADDR is set
  211.  * and a multicast address is bound on both
  212.  * new and duplicated sockets.
  213.  */
  214. if (so->so_options & SO_REUSEADDR)
  215. reuseport = SO_REUSEADDR|SO_REUSEPORT;
  216. } else if (sin->sin_addr.s_addr != INADDR_ANY) {
  217. sin->sin_port = 0; /* yech... */
  218. if (ifa_ifwithaddr((struct sockaddr *)sin) == 0)
  219.                             {
  220. #ifdef WV_INSTRUMENTATION
  221. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  222.             WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_ERROR, 13, 5, 
  223.                              WV_NETEVENT_PCBBIND_BADADDR,
  224.                              so->so_fd, sin->sin_addr.s_addr)
  225. #endif  /* INCLUDE_WVNET */
  226. #endif
  228.                             return (EADDRNOTAVAIL);
  229.                             }
  230. }
  231. if (lport) {
  232. struct inpcb *t;
  234. /* GROSS */
  235. #if 0 /* XXX took out because we are always in super user mode. */
  236. if (ntohs(lport) < IPPORT_RESERVED &&
  237.     (error = suser(p->p_ucred, &p->p_acflag)))
  238. return (EACCES);
  239. #endif
  240. t = in_pcblookup(inp->inp_pcbinfo, zeroin_addr, 0,
  241.     sin->sin_addr, lport, wild);
  242. if (t && (reuseport & t->inp_socket->so_options) == 0)
  243.                             {
  244. #ifdef WV_INSTRUMENTATION
  245. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  246.             WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_ERROR, 14, 6, 
  247.                              WV_NETEVENT_PCBBIND_BADPORT, so->so_fd, lport)
  248. #endif  /* INCLUDE_WVNET */
  249. #endif
  251.                             return (EADDRINUSE);
  252.                             }
  253. }
  254. inp->inp_laddr = sin->sin_addr;
  255. }
  256. if (lport == 0)
  257. do {
  258. ++*lastport;
  259. if (*lastport < IPPORT_RESERVED ||
  260.     *lastport > IPPORT_USERRESERVED)
  261. *lastport = IPPORT_RESERVED;
  262. lport = htons(*lastport);
  263. } while (in_pcblookup(inp->inp_pcbinfo,
  264.     zeroin_addr, 0, inp->inp_laddr, lport, wild));
  265. inp->inp_lport = lport;
  266. in_pcbrehash(inp);
  267. return (0);
  268. }
  270. /*
  271.  *   Transform old in_pcbconnect() into an inner subroutine for new
  272.  *   in_pcbconnect(): Do some validity-checking on the remote
  273.  *   address (in mbuf 'nam') and then determine local host address
  274.  *   (i.e., which interface) to use to access that remote host.
  275.  *
  276.  *   This preserves definition of in_pcbconnect(), while supporting a
  277.  *   slightly different version for T/TCP.  (This is more than
  278.  *   a bit of a kludge, but cleaning up the internal interfaces would
  279.  *   have forced minor changes in every protocol).
  280.  */
  282. int
  283. in_pcbladdr(inp, nam, plocal_sin)
  284. register struct inpcb *inp;
  285. struct mbuf *nam;
  286. struct sockaddr_in **plocal_sin;
  287. {
  288. struct in_ifaddr *ia;
  289. register struct sockaddr_in *sin = mtod(nam, struct sockaddr_in *);
  291. if (nam->m_len != sizeof (*sin))
  292.             {
  293. #ifdef WV_INSTRUMENTATION
  294. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  295.             WV_NET_MARKER_4 (NET_AUX_EVENT, WV_NET_ERROR, 15, 7, 
  296.                              WV_NETEVENT_PCBLADDR_BADADDR, 
  297.                              inp->inp_socket->so_fd, nam->m_len, 
  298.                              sin->sin_family, sin->sin_port)
  299. #endif  /* INCLUDE_WVNET */
  300. #endif
  302.             return (EINVAL);
  303.             }
  304. if (sin->sin_family != AF_INET)
  305.             {
  306. #ifdef WV_INSTRUMENTATION
  307. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  308.             WV_NET_MARKER_4 (NET_AUX_EVENT, WV_NET_ERROR, 15, 7, 
  309.                              WV_NETEVENT_PCBLADDR_BADADDR, 
  310.                              inp->inp_socket->so_fd, nam->m_len, 
  311.                              sin->sin_family, sin->sin_port)
  312. #endif  /* INCLUDE_WVNET */
  313. #endif
  315.             return (EAFNOSUPPORT);
  316.             }
  317. if (sin->sin_port == 0)
  318.             {
  319. #ifdef WV_INSTRUMENTATION
  320. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  321.             WV_NET_MARKER_4 (NET_AUX_EVENT, WV_NET_ERROR, 15, 7, 
  322.                              WV_NETEVENT_PCBLADDR_BADADDR, 
  323.                              inp->inp_socket->so_fd, nam->m_len, 
  324.                              sin->sin_family, sin->sin_port)
  325. #endif  /* INCLUDE_WVNET */
  326. #endif
  328.             return (EADDRNOTAVAIL);
  329.             }
  331. if (IN_IFADDR)
  332.         {
  333. /*
  334.  * If the destination address is INADDR_ANY,
  335.  * use the primary local address.
  336.  * If the supplied address is INADDR_BROADCAST,
  337.  * and the primary interface supports broadcast,
  338.  * choose the broadcast address for that interface.
  339.  */
  340. #define satosin(sa) ((struct sockaddr_in *)(sa))
  341. #define sintosa(sin) ((struct sockaddr *)(sin))
  342. #define ifatoia(ifa) ((struct in_ifaddr *)(ifa))
  343. if (sin->sin_addr.s_addr == INADDR_ANY)
  344.     sin->sin_addr = IA_SIN(IN_IFADDR)->sin_addr;
  346. else if (sin->sin_addr.s_addr == (u_long)INADDR_BROADCAST)
  347.     {
  348.                     for (ia = IN_IFADDR; ia; ia = ia->ia_next) 
  349.  {
  350.  if (ia->ia_ifp->if_flags & IFF_BROADCAST)
  351.      {
  352.              sin->sin_addr = 
  353.          satosin(&IN_IFADDR->ia_next->ia_broadaddr)->sin_addr;
  354.                              break;
  355.      }
  356.                          }
  357.                     }
  358. }
  359. if (inp->inp_laddr.s_addr == INADDR_ANY) {
  360. register struct route *ro;
  362. ia = (struct in_ifaddr *)0;
  363. /*
  364.  * If route is known or can be allocated now,
  365.  * our src addr is taken from the i/f, else punt.
  366.  */
  367. ro = &inp->inp_route;
  368. if (ro->ro_rt &&
  369.     (satosin(&ro->ro_dst)->sin_addr.s_addr !=
  370. sin->sin_addr.s_addr ||
  371.     inp->inp_socket->so_options & SO_DONTROUTE)) {
  372. RTFREE(ro->ro_rt);
  373. ro->ro_rt = (struct rtentry *)0;
  374. }
  375. if ((inp->inp_socket->so_options & SO_DONTROUTE) == 0 && /*XXX*/
  376.     (ro->ro_rt == (struct rtentry *)0 ||
  377.     ro->ro_rt->rt_ifp == (struct ifnet *)0)) {
  378. /* No route yet, so try to acquire one */
  379. ro->ro_dst.sa_family = AF_INET;
  380. ro->ro_dst.sa_len = sizeof(struct sockaddr_in);
  381. ((struct sockaddr_in *) &ro->ro_dst)->sin_addr =
  382. sin->sin_addr;
  383.                         TOS_SET ((struct sockaddr_in *) &ro->ro_dst, inp->inp_ip.ip_tos);
  384. rtalloc(ro);
  385. }
  386. /*
  387.  * If we found a route, use the address
  388.  * corresponding to the outgoing interface
  389.  * unless it is the loopback (in case a route
  390.  * to our address on another net goes to loopback).
  391.  */
  392. if (ro->ro_rt && !(ro->ro_rt->rt_ifp->if_flags & IFF_LOOPBACK))
  393. ia = ifatoia(ro->ro_rt->rt_ifa);
  394. if (ia == 0) {
  395. u_short fport = sin->sin_port;
  397. sin->sin_port = 0;
  398. ia = ifatoia(ifa_ifwithdstaddr(sintosa(sin)));
  399. if (ia == 0)
  400. ia = ifatoia(ifa_ifwithnet(sintosa(sin)));
  401. sin->sin_port = fport;
  402. if (ia == 0)
  403. ia = IN_IFADDR;
  404. if (ia == 0)
  405.                             {
  406. #ifdef WV_INSTRUMENTATION
  407. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  408.             WV_NET_MARKER_4 (NET_AUX_EVENT, WV_NET_ERROR, 15, 7, 
  409.                              WV_NETEVENT_PCBLADDR_BADADDR, 
  410.                              inp->inp_socket->so_fd, nam->m_len, 
  411.                              sin->sin_family, sin->sin_port)
  412. #endif  /* INCLUDE_WVNET */
  413. #endif
  415.                             return (EADDRNOTAVAIL);
  416.                             }
  417. }
  418. /*
  419.  * If the destination address is multicast and an outgoing
  420.  * interface has been set as a multicast option, use the
  421.  * address of that interface as our source address.
  422.  */
  423. if (IN_MULTICAST(ntohl(sin->sin_addr.s_addr)) &&
  424.     inp->inp_moptions != NULL) {
  425. struct ip_moptions *imo;
  426. struct ifnet *ifp;
  428. imo = inp->inp_moptions;
  429. if (imo->imo_multicast_ifp != NULL) {
  430. ifp = imo->imo_multicast_ifp;
  431. for (ia = IN_IFADDR; ia; ia = ia->ia_next)
  432. if (ia->ia_ifp == ifp)
  433. break;
  434. if (ia == 0)
  435.                                     {
  436. #ifdef WV_INSTRUMENTATION
  437. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  438.           WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_ERROR, 16, 8, 
  439.                            WV_NETEVENT_PCBLADDR_BADIF, inp->inp_socket->so_fd)
  440. #endif  /* INCLUDE_WVNET */
  441. #endif
  443.                                     return (EADDRNOTAVAIL);
  444.                                     }
  445. }
  446. }
  447. /*
  448.  * Don't do pcblookup call here; return interface in plocal_sin
  449.  * and exit to caller, that will do the lookup.
  450.  */
  451. *plocal_sin = &ia->ia_addr;
  453. }
  454. return(0);
  455. }
  457. /*
  458.  * Outer subroutine:
  459.  * Connect from a socket to a specified address.
  460.  * Both address and port must be specified in argument sin.
  461.  * If don't have a local address for this socket yet,
  462.  * then pick one.
  463.  */
  464. int
  465. in_pcbconnect(inp, nam)
  466. register struct inpcb *inp;
  467. struct mbuf *nam;
  468. {
  469. struct sockaddr_in *ifaddr;
  470. register struct sockaddr_in *sin = mtod(nam, struct sockaddr_in *);
  471. int error;
  473. #ifdef WV_INSTRUMENTATION
  474. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  475.     WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_VERBOSE, 24, 12, 
  476.                      WV_NETEVENT_PCBCONNECT_START, inp->inp_socket->so_fd)
  477. #endif  /* INCLUDE_WVNET */
  478. #endif
  480. /*
  481.  *   Call inner routine, to assign local interface address.
  482.  */
  483. if ((error = in_pcbladdr(inp, nam, &ifaddr)) != 0)
  484. return(error);
  486. if (in_pcblookuphash(inp->inp_pcbinfo, sin->sin_addr, sin->sin_port,
  487.     ((inp->inp_laddr.s_addr) ? inp->inp_laddr : ifaddr->sin_addr),
  488.     inp->inp_lport, 0) != NULL)
  489.             {
  490. #ifdef WV_INSTRUMENTATION
  491. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  492.             WV_NET_MARKER_4 (NET_AUX_EVENT, WV_NET_ERROR, 17, 9, 
  493.                              WV_NETEVENT_PCBCONNECT_BADADDR,
  494.                              inp->inp_socket->so_fd, sin->sin_addr.s_addr,
  495.                              inp->inp_laddr.s_addr, inp->inp_lport);
  496. #endif  /* INCLUDE_WVNET */
  497. #endif
  499.             return (EADDRINUSE);
  500.             }
  501. if (inp->inp_laddr.s_addr == INADDR_ANY) {
  502. if (inp->inp_lport == 0)
  503. (void)in_pcbbind(inp, (struct mbuf *)0);
  504. inp->inp_laddr = ifaddr->sin_addr;
  505. }
  506. inp->inp_faddr = sin->sin_addr;
  507. inp->inp_fport = sin->sin_port;
  508. in_pcbrehash(inp);
  509. return (0);
  510. }
  512. void
  513. in_pcbdisconnect(inp)
  514. struct inpcb *inp;
  515. {
  516. #ifdef WV_INSTRUMENTATION
  517. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  518.     WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_VERBOSE, 25, 13, 
  519.                      WV_NETEVENT_PCBDISCONN_START, inp->inp_socket->so_fd)
  520. #endif  /* INCLUDE_WVNET */
  521. #endif
  523. inp->inp_faddr.s_addr = INADDR_ANY;
  524. inp->inp_fport = 0;
  525. in_pcbrehash(inp);
  526. if (inp->inp_socket->so_state & SS_NOFDREF)
  527. in_pcbdetach(inp);
  528. }
  530. void
  531. in_pcbdetach(inp)
  532. struct inpcb *inp;
  533. {
  534. struct socket *so = inp->inp_socket;
  535. int s;
  537. so->so_pcb = 0;
  538. sofree(so);
  539. if (inp->inp_options)
  540. (void)m_free(inp->inp_options);
  541. if (inp->inp_route.ro_rt)
  542. rtfree(inp->inp_route.ro_rt);
  543. ip_freemoptions(inp->inp_moptions, inp);
  544. s = splnet();
  545. LIST_REMOVE(inp, inp_hash);
  546. LIST_REMOVE(inp, inp_list);
  547. splx(s);
  548. FREE(inp, MT_PCB);
  549. }
  551. void
  552. in_setsockaddr(inp, nam)
  553. register struct inpcb *inp;
  554. struct mbuf *nam;
  555. {
  556. register struct sockaddr_in *sin;
  558. nam->m_len = sizeof (*sin);
  559. sin = mtod(nam, struct sockaddr_in *);
  560. bzero((caddr_t)sin, sizeof (*sin));
  561. sin->sin_family = AF_INET;
  562. sin->sin_len = sizeof(*sin);
  563. sin->sin_port = inp->inp_lport;
  564. sin->sin_addr = inp->inp_laddr;
  565. }
  567. void
  568. in_setpeeraddr(inp, nam)
  569. struct inpcb *inp;
  570. struct mbuf *nam;
  571. {
  572. register struct sockaddr_in *sin;
  574. nam->m_len = sizeof (*sin);
  575. sin = mtod(nam, struct sockaddr_in *);
  576. bzero((caddr_t)sin, sizeof (*sin));
  577. sin->sin_family = AF_INET;
  578. sin->sin_len = sizeof(*sin);
  579. sin->sin_port = inp->inp_fport;
  580. sin->sin_addr = inp->inp_faddr;
  581. }
  583. /*
  584.  * Pass some notification to all connections of a protocol
  585.  * associated with address dst.  The local address and/or port numbers
  586.  * may be specified to limit the search.  The "usual action" will be
  587.  * taken, depending on the ctlinput cmd.  The caller must filter any
  588.  * cmds that are uninteresting (e.g., no error in the map).
  589.  * Call the protocol specific routine (if any) to report
  590.  * any errors for each matching socket.
  591.  *
  592.  * Must be called at splnet.
  593.  */
  594. void
  595. in_pcbnotify(head, dst, fport_arg, laddr, lport_arg, cmd, notify)
  596. struct inpcbhead *head;
  597. struct sockaddr *dst;
  598. u_int fport_arg, lport_arg;
  599. struct in_addr laddr;
  600. int cmd;
  601. void (*notify) (struct inpcb *, int);
  602. {
  603. register struct inpcb *inp, *oinp;
  604. struct in_addr faddr;
  605. u_short fport = fport_arg, lport = lport_arg;
  606. int errno, s;
  608. #ifdef WV_INSTRUMENTATION
  609. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  610.     WV_NET_MARKER_3 (NET_AUX_EVENT, WV_NET_VERBOSE, 26, 14, 
  611.                      WV_NETEVENT_PCBNOTIFY_START, cmd, laddr.s_addr,
  612.                      ((struct sockaddr_in *)dst)->sin_addr.s_addr)
  613. #endif  /* INCLUDE_WVNET */
  614. #endif
  616. if ((unsigned)cmd > PRC_NCMDS || dst->sa_family != AF_INET)
  617. return;
  618. faddr = ((struct sockaddr_in *)dst)->sin_addr;
  619. if (faddr.s_addr == INADDR_ANY)
  620. return;
  622. /*
  623.  * Redirects go to all references to the destination,
  624.  * and use in_rtchange to invalidate the route cache.
  625.  * Dead host indications: notify all references to the destination.
  626.  * Otherwise, if we have knowledge of the local port and address,
  627.  * deliver only to that socket.
  628.  */
  629. if (PRC_IS_REDIRECT(cmd) || cmd == PRC_HOSTDEAD) {
  630. fport = 0;
  631. lport = 0;
  632. laddr.s_addr = 0;
  633. if (cmd != PRC_HOSTDEAD)
  634. notify = in_rtchange;
  635. }
  636. errno = inetctlerrmap[cmd];
  637. s = splnet();
  638. for (inp = head->lh_first; inp != NULL;) {
  639. if (inp->inp_faddr.s_addr != faddr.s_addr ||
  640.     inp->inp_socket == 0 ||
  641.     (lport && inp->inp_lport != lport) ||
  642.     (laddr.s_addr && inp->inp_laddr.s_addr != laddr.s_addr) ||
  643.     (fport && inp->inp_fport != fport)) {
  644. inp = inp->inp_list.le_next;
  645. continue;
  646. }
  647. oinp = inp;
  648. inp = inp->inp_list.le_next;
  649. if (notify)
  650. (*notify)(oinp, errno);
  651. }
  652. splx(s);
  653. }
  655. /*
  656.  * Check for alternatives when higher level complains
  657.  * about service problems.  For now, invalidate cached
  658.  * routing information.  If the route was created dynamically
  659.  * (by a redirect), time to try a default gateway again.
  660.  */
  661. void
  662. in_losing(inp)
  663. struct inpcb *inp;
  664. {
  665. register struct rtentry *rt;
  666. struct rt_addrinfo info;
  668. #ifdef WV_INSTRUMENTATION
  669. #ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
  670.     WV_NET_MARKER_0 (NET_CORE_EVENT, WV_NET_WARNING, 7, 10, 
  671.                      WV_NETEVENT_TCPTIMER_ROUTEDROP)
  672. #endif  /* INCLUDE_WVNET */
  673. #endif
  675. if ((rt = inp->inp_route.ro_rt)) {
  676. inp->inp_route.ro_rt = 0;
  677. bzero((caddr_t)&info, sizeof(info));
  678. info.rti_info[RTAX_DST] =
  679. (struct sockaddr *)&inp->inp_route.ro_dst;
  680. info.rti_info[RTAX_GATEWAY] = rt->rt_gateway;
  681. info.rti_info[RTAX_NETMASK] = rt_mask(rt);
  682.                 if (rtMissMsgHook)
  683.                     (*rtMissMsgHook) (RTM_LOSING, &info, rt->rt_flags, 0);
  685.                 /*
  686.                  * Remove the route if appropriate. Do not report the change
  687.                  * since the preceding hook generates both types of messages.
  688.                  */
  690. if (rt->rt_flags & RTF_DYNAMIC)
  691.                     rtrequestDelEqui (rt_key(rt),rt_mask(rt), rt->rt_gateway,
  692.                                       rt->rt_flags, RT_PROTO_GET(rt_key(rt)),
  693.                                       FALSE, FALSE, (ROUTE_ENTRY **)0);
  694. else
  695. /*
  696.  * A new route can be allocated
  697.  * the next time output is attempted.
  698.  */
  699. rtfree(rt);
  700. }
  701. }
  703. /*
  704.  * After a routing change, flush old routing
  705.  * and allocate a (hopefully) better one.
  706.  */
  707. void
  708. in_rtchange(inp, error)
  709. register struct inpcb *inp;
  710. int error;
  711. {
  712. if (inp->inp_route.ro_rt) {
  713. rtfree(inp->inp_route.ro_rt);
  714. inp->inp_route.ro_rt = 0;
  715. /*
  716.  * A new route can be allocated the next time
  717.  * output is attempted.
  718.  */
  719. }
  720. }
  722. struct inpcb *
  723. in_pcblookup(pcbinfo, faddr, fport_arg, laddr, lport_arg, wild_okay)
  724. struct inpcbinfo *pcbinfo;
  725. struct in_addr faddr, laddr;
  726. u_int fport_arg, lport_arg;
  727. int wild_okay;
  728. {
  729. register struct inpcb *inp, *match = NULL;
  730. int matchwild = 3, wildcard;
  731. u_short fport = fport_arg, lport = lport_arg;
  732. int s;
  734. s = splnet();
  736. for (inp = pcbinfo->listhead->lh_first; inp != NULL; inp = inp->inp_list.le_next) {
  737. if (inp->inp_lport != lport)
  738. continue;
  739. wildcard = 0;
  740. if (inp->inp_faddr.s_addr != INADDR_ANY) {
  741. if (faddr.s_addr == INADDR_ANY)
  742. wildcard++;
  743. else if (inp->inp_faddr.s_addr != faddr.s_addr ||
  744.     inp->inp_fport != fport)
  745. continue;
  746. } else {
  747. if (faddr.s_addr != INADDR_ANY)
  748. wildcard++;
  749. }
  750. if (inp->inp_laddr.s_addr != INADDR_ANY) {
  751. if (laddr.s_addr == INADDR_ANY)
  752. wildcard++;
  753. else if (inp->inp_laddr.s_addr != laddr.s_addr)
  754. continue;
  755. } else {
  756. if (laddr.s_addr != INADDR_ANY)
  757. wildcard++;
  758. }
  759. if (wildcard && wild_okay == 0)
  760. continue;
  761. if (wildcard < matchwild) {
  762. match = inp;
  763. matchwild = wildcard;
  764. if (matchwild == 0) {
  765. break;
  766. }
  767. }
  768. }
  769. splx(s);
  770. return (match);
  771. }
  773. /*
  774.  * Lookup PCB in hash list.
  775.  */
  776. struct inpcb *
  777. in_pcblookuphash(pcbinfo, faddr, fport_arg, laddr, lport_arg, wildcard)
  778. struct inpcbinfo *pcbinfo;
  779. struct in_addr faddr, laddr;
  780. u_int fport_arg, lport_arg;
  781. int wildcard;
  782. {
  783. struct inpcbhead *head;
  784. register struct inpcb *inp;
  785. u_short fport = fport_arg, lport = lport_arg;
  786. int s;
  788. s = splnet();
  789. /*
  790.  * First look for an exact match.
  791.  */
  792. head = &pcbinfo->hashbase[INP_PCBHASH(faddr.s_addr, lport, fport, pcbinfo->hashmask)];
  793. for (inp = head->lh_first; inp != NULL; inp = inp->inp_hash.le_next) {
  794. if (inp->inp_faddr.s_addr == faddr.s_addr &&
  795.     inp->inp_fport == fport && inp->inp_lport == lport &&
  796.     inp->inp_laddr.s_addr == laddr.s_addr)
  797. goto found;
  798. }
  799. if (wildcard) {
  800. struct inpcb *local_wild = NULL;
  802. head = &pcbinfo->hashbase[INP_PCBHASH(INADDR_ANY, lport, 0, pcbinfo->hashmask)];
  803. for (inp = head->lh_first; inp != NULL; inp = inp->inp_hash.le_next) {
  804. if (inp->inp_faddr.s_addr == INADDR_ANY &&
  805.     inp->inp_fport == 0 && inp->inp_lport == lport) {
  806. if (inp->inp_laddr.s_addr == laddr.s_addr)
  807. goto found;
  808. else if (inp->inp_laddr.s_addr == INADDR_ANY)
  809. local_wild = inp;
  810. }
  811. }
  812. if (local_wild != NULL) {
  813. inp = local_wild;
  814. goto found;
  815. }
  816. }
  817. splx(s);
  818. return (NULL);
  820. found:
  821. /*
  822.  * Move PCB to head of this hash chain so that it can be
  823.  * found more quickly in the future.
  824.  * XXX - this is a pessimization on machines with few
  825.  * concurrent connections.
  826.  */
  827. if (inp != head->lh_first) {
  828. LIST_REMOVE(inp, inp_hash);
  829. LIST_INSERT_HEAD(head, inp, inp_hash);
  830. }
  831. splx(s);
  832. return (inp);
  833. }
  835. /*
  836.  * Insert PCB into hash chain. Must be called at splnet.
  837.  */
  838. void
  839. in_pcbinshash(inp)
  840. struct inpcb *inp;
  841. {
  842. struct inpcbhead *head;
  844. head = &inp->inp_pcbinfo->hashbase[INP_PCBHASH(inp->inp_faddr.s_addr,
  845.  inp->inp_lport, inp->inp_fport, inp->inp_pcbinfo->hashmask)];
  847. LIST_INSERT_HEAD(head, inp, inp_hash);
  848. }
  850. void
  851. in_pcbrehash(inp)
  852. struct inpcb *inp;
  853. {
  854. struct inpcbhead *head;
  855. int s;
  857. s = splnet();
  858. LIST_REMOVE(inp, inp_hash);
  860. head = &inp->inp_pcbinfo->hashbase[INP_PCBHASH(inp->inp_faddr.s_addr,
  861. inp->inp_lport, inp->inp_fport, inp->inp_pcbinfo->hashmask)];
  863. LIST_INSERT_HEAD(head, inp, inp_hash);
  864. splx(s);
  865. }