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

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

VxWorks

开发平台：

C/C++

in.c：源码内容
  1. /* in.c - internet routines */
  3. /* Copyright 1984 - 2001 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7.  * Copyright (c) 1982, 1986, 1991, 1993
  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.c 8.4 (Berkeley) 1/9/95
  39.  */
  41. /*
  42. modification history
  43. --------------------
  44. 01m,12oct01,rae  merge from truestack ver 01n, base 01j (SPR #67536 etc)
  45. 01l,30jan01,spm  ignored existing routes for alias IP addresses (SPR #62333)
  46. 01k,20apr00,rae  fixed memory leak in in_ifinit, SPR#28903
  47. 01j,22feb99,ham  called in_socktrim() in SIOCSIFNETMASK, SPR#24251.
  48. 01h,06oct98,ham  cancelled "01g" moidification, new fix for SPR#22267.
  49. 01g,08sep98,ham  fixed SIOCAIFADDR inproper work in in_control SPR#22267.
  50. 01f,08dec97,vin  fixed a bug in_addmulti incremented the ref count SPR 9971
  51. 01e,03dec97,vin  changed _pNetDpool to _pNetSysPool
  52. 01d,05oct97,vin  added fast multicasting.
  53. 01c,07jan96,vin  added _igmpJoinGrpHook and _igmpLeaveGrpHook for scaling igmp.
  54. 01b,05dec96,vin  replaced malloc with MALLOC and free with FREE(),
  55. 01a,03mar96,vin  created from BSD4.4 stuff,integrated with 02n of in.c.
  56. */
  58. /*
  59. DESCRIPTION
  60. */
  62. #include "vxWorks.h"
  63. #include "logLib.h"
  64. #include "sys/ioctl.h"
  65. #include "net/mbuf.h"
  66. #include "net/protosw.h"
  67. #include "sys/socket.h"
  68. #include "net/socketvar.h"
  69. #include "net/uio.h"
  70. #include "errno.h"
  71. #include "netinet/in_systm.h"
  72. #include "net/if.h"
  73. #include "net/route.h"
  74. #include "netinet/in.h"
  75. #include "netinet/in_var.h"
  76. #include "net/systm.h"
  77. #include "netinet/igmp_var.h"
  78. #include "net/unixLib.h"
  80. #ifdef VIRTUAL_STACK
  81. #include "netinet/vsLib.h"
  82. #include "netinet/vsIgmp.h"
  83. #endif /* VIRTUAL_STACK */
  85. #ifdef INET
  87. #ifdef WV_INSTRUMENTATION
  88. #ifdef INCLUDE_WVNET
  89. #include "wvNetLib.h"
  90. #endif
  91. #endif
  93. /* defines */
  95. /* externals */
  97. extern void arp_rtrequest (); 
  98. extern VOIDFUNCPTR _igmpJoinGrpHook; 
  99. extern VOIDFUNCPTR _igmpLeaveGrpHook; 
  101. /* globals */
  102. #ifndef SUBNETSARELOCAL
  103. #define SUBNETSARELOCAL 1
  104. #endif
  106. int subnetsarelocal = SUBNETSARELOCAL;
  107. int in_interfaces; /* number of external internet interfaces */
  109. #ifndef VIRTUAL_STACK
  110. extern struct ifnet loif[]; /* loop back interface */
  111. struct mcastHashInfo mCastHashInfo;
  112. #endif
  114. int mCastHashTblSize = 64; /* default size of hash table */
  117. #ifdef WV_INSTRUMENTATION
  118. #ifdef INCLUDE_WVNET
  119.     /* Set common fields of event identifiers for this module. */
  121. LOCAL UCHAR wvNetModuleId = WV_NET_IN_MODULE;   /* Value for in.c */
  122. LOCAL UCHAR wvNetLocalFilter = WV_NET_NONE;     /* Available event filter */
  124. LOCAL ULONG wvNetEventId;       /* Event identifier: see wvNetLib.h */
  125. #endif    /* INCLUDE_WVNET */
  126. #endif
  128. BOOL inet_netmatch(sin1, sin2)
  129. struct sockaddr_in *sin1;
  130. struct sockaddr_in *sin2;
  131. {
  133. return (in_netof(sin1->sin_addr) == in_netof(sin2->sin_addr));
  134. }
  136. /*
  137.  * The following routines, in_netof, and in_lnaof,
  138.  * are similar to the corresponding routines in inetLib, except that
  139.  * these routines take subnet masks into account.
  140.  */
  142. /*
  143.  * Return the network number from an internet address.
  144.  */
  145. u_long
  146. in_netof(in)
  147. struct in_addr in;
  148. {
  149. register u_long i = ntohl(in.s_addr);
  150. register u_long net;
  151. register struct in_ifaddr *ia;
  153. if (IN_CLASSA(i))
  154. net = i & IN_CLASSA_NET; 
  155. else if (IN_CLASSB(i))
  156. net = i & IN_CLASSB_NET;
  157. else if (IN_CLASSC(i))
  158. net = i & IN_CLASSC_NET;
  159. else if (IN_CLASSD(i))
  160. net = i & IN_CLASSD_NET;
  161. else
  162. return (0);
  164. /*
  165.  * Check whether network is a subnet;
  166.  * if so, return subnet number.
  167.  */
  168. #ifdef VIRTUAL_STACK
  169. for (ia = _in_ifaddr; ia; ia = ia->ia_next)
  170. #else
  171. for (ia = in_ifaddr; ia; ia = ia->ia_next)
  172. #endif /* VIRTUAL_STACK */
  173. if (net == ia->ia_net)
  174. return (i & ia->ia_subnetmask);
  175. return (net);
  176. }
  178. /*
  179.  * Return 1 if an internet address is for a ``local'' host
  180.  * (one to which we have a connection).  If subnetsarelocal
  181.  * is true, this includes other subnets of the local net.
  182.  * Otherwise, it includes only the directly-connected (sub)nets.
  183.  */
  184. int
  185. in_localaddr(in)
  186. struct in_addr in;
  187. {
  188. register u_long i = ntohl(in.s_addr);
  189. register struct in_ifaddr *ia;
  191. if (subnetsarelocal) {
  192. #ifdef VIRTUAL_STACK
  193. for (ia = _in_ifaddr; ia; ia = ia->ia_next)
  194. #else
  195. for (ia = in_ifaddr; ia; ia = ia->ia_next)
  196. #endif /* VIRTUAL_STACK */
  197. if ((i & ia->ia_netmask) == ia->ia_net)
  198. return (1);
  199. } else {
  200. #ifdef VIRTUAL_STACK
  201. for (ia = _in_ifaddr; ia; ia = ia->ia_next)
  202. #else
  203. for (ia = in_ifaddr; ia; ia = ia->ia_next)
  204. #endif /* VIRTUAL_STACK */
  205. if ((i & ia->ia_subnetmask) == ia->ia_subnet)
  206. return (1);
  207. }
  208. return (0);
  209. }
  211. /*
  212.  * Determine whether an IP address is in a reserved set of addresses
  213.  * that may not be forwarded, or whether datagrams to that destination
  214.  * may be forwarded.
  215.  */
  216. int
  217. in_canforward(in)
  218. struct in_addr in;
  219. {
  220. register u_long i = ntohl(in.s_addr);
  221. register u_long net;
  223. if (IN_EXPERIMENTAL(i) || IN_MULTICAST(i))
  224. return (0);
  225. if (IN_CLASSA(i)) {
  226. net = i & IN_CLASSA_NET;
  227. if (net == 0 || net == (IN_LOOPBACKNET << IN_CLASSA_NSHIFT))
  228. return (0);
  229. }
  230. return (1);
  231. }
  233. /*
  234.  * Trim a mask in a sockaddr
  235.  */
  236. void
  237. in_socktrim(ap)
  238. struct sockaddr_in *ap;
  239. {
  240.     register char *cplim = (char *) &ap->sin_addr;
  241.     register char *cp = (char *) (&ap->sin_addr + 1);
  243.     ap->sin_len = 0;
  244.     while (--cp >= cplim)
  245.         if (*cp) {
  246.     (ap)->sin_len = cp - (char *) (ap) + 1;
  247.     break;
  248. }
  249. }
  251. /*
  252.  * Return the host portion of an internet address.
  253.  */
  254. u_long
  255. in_lnaof(in)
  256.         struct in_addr in;
  257. {
  258.         register u_long i = ntohl(in.s_addr);
  259.         register u_long net, host;
  260.         register struct in_ifaddr *ia;
  262.         if (IN_CLASSA(i)) {
  263.                 net = i & IN_CLASSA_NET;
  264.                 host = i & IN_CLASSA_HOST;
  265.         } else if (IN_CLASSB(i)) {
  266.                 net = i & IN_CLASSB_NET;
  267.                 host = i & IN_CLASSB_HOST;
  268.         } else if (IN_CLASSC(i)) {
  269.                 net = i & IN_CLASSC_NET;
  270.                 host = i & IN_CLASSC_HOST;
  271.         } else if (IN_CLASSD(i)) {
  272.                 net = i & IN_CLASSD_NET;
  273.                 host = i & IN_CLASSD_HOST;
  274.         } else
  275.                 return (i);
  277.         /*
  278.          * Check whether network is a subnet;
  279.          * if so, use the modified interpretation of `host'.
  280.          */
  281. #ifdef VIRTUAL_STACK
  282.         for (ia = _in_ifaddr; ia; ia = ia->ia_next)
  283. #else
  284.         for (ia = in_ifaddr; ia; ia = ia->ia_next)
  285. #endif /* VIRTUAL_STACK */
  286.                 if (net == ia->ia_net)
  287.                         return (host &~ ia->ia_subnetmask);
  288.         return (host);
  289. }
  291. /*
  292.  * Generic internet control operations (ioctl's).
  293.  * Ifp is 0 if not an interface-specific ioctl.
  294.  */
  295. /* ARGSUSED */
  296. int
  297. in_control(so, cmd, data, ifp)
  298. struct socket *so;
  299. u_long cmd;
  300. caddr_t data;
  301. register struct ifnet *ifp;
  302. {
  303. register struct ifreq *ifr = (struct ifreq *)data;
  304. register struct in_ifaddr *ia = 0;
  305. register struct ifaddr *ifa;
  306. struct in_ifaddr *oia;
  307. struct in_aliasreq *ifra = (struct in_aliasreq *)data;
  308. struct sockaddr_in oldaddr;
  309. int error, hostIsNew, maskIsNew;
  310. u_long i;
  311.         BOOL newRouteFlag = FALSE;  /* Connection to new IP subnet? */
  313. #ifdef WV_INSTRUMENTATION
  314. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  315.         WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_VERBOSE, 18, 7,
  316.                          WV_NETEVENT_INCTRL_START, cmd)
  317. #endif  /* INCLUDE_WVNET */
  318. #endif
  320.             /*
  321.              * Find address for this interface, if it exists.
  322.              */
  323.             if (ifp)
  324. #ifdef VIRTUAL_STACK
  325.                 for (ia = _in_ifaddr; ia; ia = ia->ia_next)
  326. #else
  327.                     for (ia = in_ifaddr; ia; ia = ia->ia_next)
  328. #endif /* VIRTUAL_STACK */
  329. if (ia->ia_ifp == ifp)
  330.                             break;
  331.         
  332. switch (cmd) {
  333.         
  334. case SIOCAIFADDR:
  335.             
  336.             if (ia == 0)
  337.                 {
  338.                 /* First IP address: no matching route should exist. */
  339.                 
  340.                 newRouteFlag = TRUE;
  341.                 }
  342.             
  343.             /* fall-through */
  344.             
  345. case SIOCDIFADDR:
  346.             if (ifra->ifra_addr.sin_family == AF_INET)
  347.                 for (oia = ia; ia; ia = ia->ia_next) {
  348.                 if (ia->ia_ifp == ifp  &&
  349.     ia->ia_addr.sin_addr.s_addr ==
  350.                     ifra->ifra_addr.sin_addr.s_addr)
  351.                     break;
  352. }
  353.             if (cmd == SIOCDIFADDR && ia == 0)
  354.                 {
  355. #ifdef WV_INSTRUMENTATION
  356. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  357.                 WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_ERROR, 8, 4, 
  358.                                  WV_NETEVENT_INCTRL_SEARCHFAIL, cmd, ifp)
  359. #endif  /* INCLUDE_WVNET */
  360. #endif
  361.                     return (EADDRNOTAVAIL);
  362.                 }
  363.             
  364.             /* FALLTHROUGH */
  365. case SIOCSIFADDR:
  366. case SIOCSIFNETMASK:
  367. case SIOCSIFDSTADDR:
  368.             if ((so->so_state & SS_PRIV) == 0)
  369.                 {
  370. #ifdef WV_INSTRUMENTATION
  371. #ifdef INCLUDE_WVNET    /* WV_NET_WARNING event */
  372.                 WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_WARNING, 6, 6, 
  373.                                  WV_NETEVENT_INCTRL_BADSOCK, so->so_fd, cmd)
  374. #endif  /* INCLUDE_WVNET */
  375. #endif
  376.                     return (EPERM);
  377.                 }
  378.             if (ifp == 0)
  379.                 {
  380. #ifdef WV_INSTRUMENTATION
  381. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  382.                 WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_EMERGENCY, 10, 1, 
  383.                                  WV_NETEVENT_INCTRL_PANIC, cmd)
  384. #endif  /* INCLUDE_WVNET */
  385. #endif
  387.                     panic("in_control");
  388.                 }
  389.             if (ia == (struct in_ifaddr *)0) {
  390.             MALLOC (oia, struct in_ifaddr *, sizeof(*oia),
  391. MT_IFADDR, M_WAIT); 
  392. if (oia == (struct in_ifaddr *)NULL)
  393.                             {
  394. #ifdef WV_INSTRUMENTATION
  395. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  396.                             WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_EMERGENCY, 11, 2, 
  397.                                              WV_NETEVENT_INCTRL_NOBUFS, cmd)
  398. #endif  /* INCLUDE_WVNET */
  399. #endif
  400.                             return (ENOBUFS);
  401.                             }
  402. bzero((caddr_t)oia, sizeof *oia);
  403. #ifdef VIRTUAL_STACK
  404. if ((ia = _in_ifaddr)) {
  405. #else
  406. if ((ia = in_ifaddr)) {
  407. #endif /* VIRTUAL_STACK */
  408. for ( ; ia->ia_next; ia = ia->ia_next)
  409. continue;
  410. ia->ia_next = oia;
  411. } else
  412. #ifdef VIRTUAL_STACK
  413. _in_ifaddr = oia;
  414. #else
  415. in_ifaddr = oia;
  416. #endif /* VIRTUAL_STACK */
  417. ia = oia;
  418. if ((ifa = ifp->if_addrlist)) {
  419. for ( ; ifa->ifa_next; ifa = ifa->ifa_next)
  420. continue;
  421. ifa->ifa_next = (struct ifaddr *) ia;
  422. } else
  423. ifp->if_addrlist = (struct ifaddr *) ia;
  424. ia->ia_ifa.ifa_addr = (struct sockaddr *)&ia->ia_addr;
  425. ia->ia_ifa.ifa_dstaddr
  426. = (struct sockaddr *)&ia->ia_dstaddr;
  427. ia->ia_ifa.ifa_netmask
  428. = (struct sockaddr *)&ia->ia_sockmask;
  429. ia->ia_sockmask.sin_len = 8;
  430. if (ifp->if_flags & IFF_BROADCAST) {
  431. ia->ia_broadaddr.sin_len = sizeof(ia->ia_addr);
  432. ia->ia_broadaddr.sin_family = AF_INET;
  433. }
  434. ia->ia_ifp = ifp;
  435. if (ifp != loif)
  436. in_interfaces++;
  437. }
  438. break;
  440. case SIOCSIFBRDADDR:
  441. if ((so->so_state & SS_PRIV) == 0)
  442. return (EPERM);
  443. /* FALLTHROUGH */
  445. case SIOCGIFADDR:
  446. case SIOCGIFNETMASK:
  447. case SIOCGIFDSTADDR:
  448. case SIOCGIFBRDADDR:
  449. if (ia == (struct in_ifaddr *)0)
  450.                     {
  451. #ifdef WV_INSTRUMENTATION
  452. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  453.                     WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_ERROR, 8, 4, 
  454.                                      WV_NETEVENT_INCTRL_SEARCHFAIL, cmd, ifp)
  455. #endif  /* INCLUDE_WVNET */
  456. #endif
  457.                     return (EADDRNOTAVAIL);
  458.                     }
  459. break;
  460. }
  461. switch (cmd) {
  463. case SIOCGIFADDR:
  464. *((struct sockaddr_in *)&ifr->ifr_addr) = ia->ia_addr;
  465. break;
  467. case SIOCGIFBRDADDR:
  468. if ((ifp->if_flags & IFF_BROADCAST) == 0)
  469.                     {
  470. #ifdef WV_INSTRUMENTATION
  471. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  472.                     WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_ERROR, 9, 5, 
  473.                                      WV_NETEVENT_INCTRL_BADFLAGS, cmd, ifp)
  474. #endif  /* INCLUDE_WVNET */
  475. #endif
  476.                     return (EINVAL);
  477.                     }
  478. *((struct sockaddr_in *)&ifr->ifr_dstaddr) = ia->ia_broadaddr;
  479. break;
  481. case SIOCGIFDSTADDR:
  482. if ((ifp->if_flags & IFF_POINTOPOINT) == 0)
  483.                     {
  484. #ifdef WV_INSTRUMENTATION
  485. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  486.                     WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_ERROR, 9, 5, 
  487.                                      WV_NETEVENT_INCTRL_BADFLAGS, cmd, ifp)
  488. #endif  /* INCLUDE_WVNET */
  489. #endif
  490.                     return (EINVAL);
  491.                     }
  492. *((struct sockaddr_in *)&ifr->ifr_dstaddr) = ia->ia_dstaddr;
  493. break;
  495. case SIOCGIFNETMASK:
  496. *((struct sockaddr_in *)&ifr->ifr_addr) = ia->ia_sockmask;
  497. break;
  499. case SIOCSIFDSTADDR:
  500. if ((ifp->if_flags & IFF_POINTOPOINT) == 0)
  501.                     {
  502. #ifdef WV_INSTRUMENTATION
  503. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  504.                     WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_ERROR, 9, 5, 
  505.                                      WV_NETEVENT_INCTRL_BADFLAGS, cmd, ifp)
  506. #endif  /* INCLUDE_WVNET */
  507. #endif
  508.                     return (EINVAL);
  509.                     }
  510. oldaddr = ia->ia_dstaddr;
  511. ia->ia_dstaddr = *(struct sockaddr_in *)&ifr->ifr_dstaddr;
  512. if (ifp->if_ioctl && (error = (*ifp->if_ioctl)
  513. (ifp, SIOCSIFDSTADDR, (caddr_t)ia))) {
  514. ia->ia_dstaddr = oldaddr;
  515. return (error);
  516. }
  517. if (ia->ia_flags & IFA_ROUTE) {
  518. ia->ia_ifa.ifa_dstaddr = (struct sockaddr *)&oldaddr;
  519. rtinit(&(ia->ia_ifa), (int)RTM_DELETE, RTF_HOST);
  520. ia->ia_ifa.ifa_dstaddr =
  521. (struct sockaddr *)&ia->ia_dstaddr;
  522. rtinit(&(ia->ia_ifa), (int)RTM_ADD, RTF_HOST|RTF_UP);
  523. }
  524. break;
  526. case SIOCSIFBRDADDR:
  527. if ((ifp->if_flags & IFF_BROADCAST) == 0)
  528.                     {
  529. #ifdef WV_INSTRUMENTATION
  530. #ifdef INCLUDE_WVNET    /* WV_NET_ERROR event */
  531.                     WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_ERROR, 9, 5, 
  532.                                      WV_NETEVENT_INCTRL_BADFLAGS, cmd, ifp)
  533. #endif  /* INCLUDE_WVNET */
  534. #endif
  535.                     return (EINVAL);
  536.                     }
  537. ia->ia_broadaddr = *(struct sockaddr_in *)&ifr->ifr_broadaddr;
  538. break;
  540. case SIOCSIFADDR:
  541. return (in_ifinit(ifp, ia,
  542.     (struct sockaddr_in *) &ifr->ifr_addr, 1));
  544. case SIOCSIFNETMASK:
  545. i = ifra->ifra_addr.sin_addr.s_addr;
  546. ia->ia_subnetmask = ntohl(ia->ia_sockmask.sin_addr.s_addr = i);
  547. in_socktrim (&ia->ia_sockmask);
  548. break;
  550. case SIOCAIFADDR:
  551. maskIsNew = 0;
  552. hostIsNew = 1;
  553. error = 0;
  554. if (ia->ia_addr.sin_family == AF_INET) {
  555. if (ifra->ifra_addr.sin_len == 0) {
  556. ifra->ifra_addr = ia->ia_addr;
  557. hostIsNew = 0;
  558. } else if (ifra->ifra_addr.sin_addr.s_addr ==
  559.        ia->ia_addr.sin_addr.s_addr)
  560. hostIsNew = 0;
  561. }
  563. if (ifra->ifra_mask.sin_len) {
  564. in_ifscrub(ifp, ia);
  565. ia->ia_sockmask = ifra->ifra_mask;
  566. ia->ia_subnetmask =
  567.      ntohl(ia->ia_sockmask.sin_addr.s_addr);
  568. maskIsNew = 1;
  569. }
  571. if ((ifp->if_flags & IFF_POINTOPOINT) &&
  572.     (ifra->ifra_dstaddr.sin_family == AF_INET)) {
  573. in_ifscrub(ifp, ia);
  574. ia->ia_dstaddr = ifra->ifra_dstaddr;
  575. maskIsNew  = 1; /* We lie; but the effect's the same */
  576. }
  577. if (ifra->ifra_addr.sin_family == AF_INET &&
  578.     (hostIsNew || maskIsNew))
  579. error = in_ifinit(ifp, ia, &ifra->ifra_addr, 0);
  580.                 /*
  581.                  * Ignore the report of an existing route entry if
  582.                  * this new (alias) IP address might use the same
  583.                  * logical subnet as another address/netmask pair.
  584.                  * The SIOCAIFADDR operation continues to provide
  585.                  * the duplicate route error when assigning the
  586.                  * initial address for an interface.
  587.                  */
  589.                 if (error == EEXIST)
  590.                     {
  591.                     /*
  592.                      * The information necessary to determine whether this
  593.                      * address/netmask assignment absolutely requires an
  594.                      * associated route entry is not readily available.
  595.                      * This operation assumes existing routes to a logical
  596.                      * subnet use the same interface as the new address entry.
  597.                      * Under certain circumstances, the ability to ignore
  598.                      * existing routes when assigning additional IP addresses
  599.                      * might allow users to successfully configure interfaces
  600.                      * which are unable to transmit data.
  601.                      */
  603.                     if (newRouteFlag == FALSE)
  604.                         error = 0;
  605.                     }
  607.                 /*
  608.                  * Replace the mask-based broadcast address if the
  609.                  * user provides a specific value.
  610.                  */
  612.                 if ((ifp->if_flags & IFF_BROADCAST) &&
  613.                     (ifra->ifra_broadaddr.sin_family == AF_INET) &&
  614.                     (ifra->ifra_broadaddr.sin_addr.s_addr))
  615.                         ia->ia_broadaddr = ifra->ifra_broadaddr;
  617. return (error);
  619. case SIOCDIFADDR:
  620. in_ifscrub(ifp, ia);
  621. if ((ifa = ifp->if_addrlist) == (struct ifaddr *)ia)
  622. ifp->if_addrlist = ifa->ifa_next;
  623. else {
  624. while (ifa->ifa_next &&
  625.        (ifa->ifa_next != (struct ifaddr *)ia))
  626.     ifa = ifa->ifa_next;
  627. if (ifa->ifa_next)
  628. ifa->ifa_next = ((struct ifaddr *)ia)->ifa_next;
  629. else
  630. logMsg("Couldn't unlink inifaddr from ifpn",
  631.        0,0,0,0,0,0);
  632. }
  633. oia = ia;
  634. #ifdef VIRTUAL_STACK
  635. if (oia == (ia = _in_ifaddr))
  636. _in_ifaddr = ia->ia_next;
  637. #else
  638. if (oia == (ia = in_ifaddr))
  639. in_ifaddr = ia->ia_next;
  640. #endif /* VIRTUAL_STACK */
  641. else {
  642. while (ia->ia_next && (ia->ia_next != oia))
  643. ia = ia->ia_next;
  644. if (ia->ia_next)
  645. ia->ia_next = oia->ia_next;
  646. else
  647. logMsg("Didn't unlink inifadr from listn",
  648.        0,0,0,0,0,0);
  649. }
  650. IFAFREE((&oia->ia_ifa));
  651. break;
  653. default:
  654. if (ifp == 0 || ifp->if_ioctl == 0)
  655. return (EOPNOTSUPP);
  656. return ((*ifp->if_ioctl)(ifp, cmd, data));
  657. }
  658. return (0);
  659. }
  661. /*
  662.  * Delete any existing route for an interface.
  663.  */
  664. void
  665. in_ifscrub(ifp, ia)
  666. register struct ifnet *ifp;
  667. register struct in_ifaddr *ia;
  668. {
  669. #ifdef WV_INSTRUMENTATION
  670. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  671.         WV_NET_MARKER_1 (NET_AUX_EVENT, WV_NET_VERBOSE, 19, 8, 
  672.                          WV_NETEVENT_INROUTEDEL_START, ifp)
  673. #endif  /* INCLUDE_WVNET */
  674. #endif
  676. if ((ia->ia_flags & IFA_ROUTE) == 0)
  677. return;
  678. if (ifp->if_flags & (IFF_LOOPBACK|IFF_POINTOPOINT))
  679. rtinit(&(ia->ia_ifa), (int)RTM_DELETE, RTF_HOST);
  680. else
  681. rtinit(&(ia->ia_ifa), (int)RTM_DELETE, 0);
  682. ia->ia_flags &= ~IFA_ROUTE;
  683. }
  685. /*
  686.  * Initialize an interface's internet address
  687.  * and routing table entry.
  688.  */
  689. int
  690. in_ifinit(ifp, ia, sin, scrub)
  691. register struct ifnet *ifp;
  692. register struct in_ifaddr *ia;
  693. struct sockaddr_in *sin;
  694. int scrub;
  695. {
  696. register u_long i = ntohl(sin->sin_addr.s_addr);
  697. struct sockaddr_in oldaddr;
  698. int s = splimp(), flags = RTF_UP, error, ether_output();
  700. #ifdef WV_INSTRUMENTATION
  701. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  702.     WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_VERBOSE, 20, 9, 
  703.                      WV_NETEVENT_INIFINIT_START, ifp, sin->sin_addr.s_addr)
  704. #endif  /* INCLUDE_WVNET */
  705. #endif
  707. oldaddr = ia->ia_addr;
  708. ia->ia_addr = *sin;
  709. /*
  710.  * Give the interface a chance to initialize
  711.  * if this is its first address,
  712.  * and to validate the address if necessary.
  713.  */
  714. if (ifp->if_ioctl &&
  715.     (error = (*ifp->if_ioctl)(ifp, SIOCSIFADDR, (caddr_t)ia))) {
  716. splx(s);
  717. ia->ia_addr = oldaddr;
  718. return (error);
  719. }
  720. if (ifp->if_output == ether_output) { /* XXX: Another Kludge */
  721. ia->ia_ifa.ifa_rtrequest = arp_rtrequest;
  722. ia->ia_ifa.ifa_flags |= RTF_CLONING;
  723. }
  724. splx(s);
  725. if (scrub) {
  726. ia->ia_ifa.ifa_addr = (struct sockaddr *)&oldaddr;
  727. in_ifscrub(ifp, ia);
  728. ia->ia_ifa.ifa_addr = (struct sockaddr *)&ia->ia_addr;
  729. }
  730. if (IN_CLASSA(i))
  731. ia->ia_netmask = IN_CLASSA_NET;
  732. else if (IN_CLASSB(i))
  733. ia->ia_netmask = IN_CLASSB_NET;
  734. else
  735. ia->ia_netmask = IN_CLASSC_NET;
  736. /*
  737.  * The subnet mask usually includes at least the standard network part,
  738.  * but may may be smaller in the case of supernetting.
  739.  * If it is set, we believe it.
  740.  */
  741. if (ia->ia_subnetmask == 0) {
  742. ia->ia_subnetmask = ia->ia_netmask;
  743. ia->ia_sockmask.sin_addr.s_addr = htonl(ia->ia_subnetmask);
  744. } else
  745. ia->ia_netmask &= ia->ia_subnetmask;
  746. ia->ia_net = i & ia->ia_netmask;
  747. ia->ia_subnet = i & ia->ia_subnetmask;
  748. in_socktrim(&ia->ia_sockmask);
  749. /*
  750.  * Add route for the network.
  751.  */
  752. ia->ia_ifa.ifa_metric = ifp->if_metric;
  753. if (ifp->if_flags & IFF_BROADCAST) {
  754. ia->ia_broadaddr.sin_addr.s_addr =
  755. htonl(ia->ia_subnet | ~ia->ia_subnetmask);
  756. ia->ia_netbroadcast.s_addr =
  757. htonl(ia->ia_net | ~ ia->ia_netmask);
  758. } else if (ifp->if_flags & IFF_LOOPBACK) {
  759. ia->ia_ifa.ifa_dstaddr = ia->ia_ifa.ifa_addr;
  760. flags |= RTF_HOST;
  761. } else if (ifp->if_flags & IFF_POINTOPOINT) {
  762. if (ia->ia_dstaddr.sin_family != AF_INET)
  763. return (0);
  764. flags |= RTF_HOST;
  765. }
  766. if ((error = rtinit(&(ia->ia_ifa), (int)RTM_ADD, flags)) == 0)
  767. ia->ia_flags |= IFA_ROUTE;
  768. /*
  769.  * If the interface supports multicast, join the "all hosts"
  770.  * multicast group on that interface.
  771.  */
  772. if (ifp->if_flags & IFF_MULTICAST) {
  773. struct in_addr addr;
  774.                 struct in_multi * inm;
  775. addr.s_addr = htonl(INADDR_ALLHOSTS_GROUP);
  776.                 IN_LOOKUP_MULTI(addr, ifp, inm);
  777.                 if (inm == NULL)             /* don't add if already there ... SPR#28903 */
  778.                     ifp->pInmMblk = in_addmulti (&addr, ifp, NULL); 
  779. }
  780. return (error);
  781. }
  783. /*******************************************************************************
  784. *
  785. * in_ifaddr_remove - remove an interface from the in_ifaddr list
  786. *
  787. * This function removes the internet interface address given as an input
  788. * parameter, from the global linked-list of internet interface addresses
  789. * pointed by in_ifaddr. This function is called before dettaching an interface
  790. * This function also removes all the internet multicast addresses hooked to 
  791. * the in_ifaddr. It calls in_delmulti() which in turn calls the ioctl for the
  792. * driver to remove the ethernet multicast addresses.
  793. * 
  794. * NOMANUAL
  795. * 
  796. * RETURNS: N/A
  797. */
  798.  
  799. void in_ifaddr_remove 
  800.     (
  801.     struct ifaddr * pIfAddr /* pointer to interface address */
  802.     ) 
  803.     {
  804.     struct in_ifaddr ** pPtrInIfAddr;  /* pointer to pointer to in_ifaddr */
  805.     struct in_ifaddr *  pInIfAddr;  /* pointer to in_ifaddr */
  807. #ifdef WV_INSTRUMENTATION
  808. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  809.     WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_VERBOSE, 21, 10, 
  810.                      WV_NETEVENT_INIFADDRDEL_START)
  811. #endif  /* INCLUDE_WVNET */
  812. #endif
  813.  
  814.  
  815. #ifdef VIRTUAL_STACK
  816.     pPtrInIfAddr = &_in_ifaddr;  /* global variable */
  817. #else
  818.     pPtrInIfAddr = &in_ifaddr;  /* global variable */
  819. #endif /* VIRTUAL_STACK */
  820.     while (*pPtrInIfAddr != NULL)
  821. {
  822. if (*pPtrInIfAddr == (struct in_ifaddr *)pIfAddr)
  823.     {
  824.     pInIfAddr = *pPtrInIfAddr; 
  825.     *pPtrInIfAddr = (*pPtrInIfAddr)->ia_next;  /* delete from list */
  826.     IFAFREE (&pInIfAddr->ia_ifa); /* free address */
  827.     break; 
  828.     }
  829. pPtrInIfAddr = &(*pPtrInIfAddr)->ia_next; 
  830. }
  831.     } 
  833. /*
  834.  * Return 1 if the address might be a local broadcast address.
  835.  */
  836. int
  837. in_broadcast(in, ifp)
  838. struct in_addr in;
  839.         struct ifnet *ifp;
  840. {
  841. register struct ifaddr *ifa;
  842. u_long t;
  844. if (in.s_addr == INADDR_BROADCAST ||
  845.     in.s_addr == INADDR_ANY)
  846. return 1;
  847. if ((ifp->if_flags & IFF_BROADCAST) == 0)
  848. return 0;
  849. t = ntohl(in.s_addr);
  850. /*
  851.  * Look through the list of addresses for a match
  852.  * with a broadcast address.
  853.  */
  854. #define ia ((struct in_ifaddr *)ifa)
  855. for (ifa = ifp->if_addrlist; ifa; ifa = ifa->ifa_next)
  856. if (ifa->ifa_addr->sa_family == AF_INET &&
  857.     (in.s_addr == ia->ia_broadaddr.sin_addr.s_addr ||
  858.      in.s_addr == ia->ia_netbroadcast.s_addr ||
  859.      /*
  860.       * Check for old-style (host 0) broadcast.
  861.       */
  862.      t == ia->ia_subnet || t == ia->ia_net))
  863.     return 1;
  864. return (0);
  865. #undef ia
  866. }
  868. /*
  869.  * Add an address to the list of IP multicast addresses for a given interface.
  870.  */
  871. struct mBlk *
  872. in_addmulti(ap, ifp, pInPcb)
  873. register struct in_addr *ap;
  874. register struct ifnet *ifp;
  875. register struct inpcb * pInPcb;
  876. {
  877. register struct in_multi *inm;
  878. struct ifreq ifr;
  879.         struct mBlk * pInPcbMblk = NULL;
  880.         struct mBlk * pInmMblk = NULL;
  881. struct mBlk * pInmFirstMblk = NULL;
  882. int s = splnet();
  884. #ifdef WV_INSTRUMENTATION
  885. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  886.     WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_VERBOSE, 58, 11, 
  887.                      WV_NETEVENT_INADDMULT_START, ifp, ap->s_addr)
  888. #endif  /* INCLUDE_WVNET */
  889. #endif
  891. /*
  892.  * See if address already in list.
  893.  */
  894. IN_LOOKUP_MULTI(*ap, ifp, inm);
  895. if (inm != NULL) {
  896. /*
  897.  * Found it; duplicate the mBlk, increment reference count.
  898.  */
  899.          if ((pInmMblk = mBlkGet (_pNetSysPool, M_DONTWAIT, MT_IPMADDR))
  900.                     == NULL)
  901.                     {
  902. #ifdef WV_INSTRUMENTATION
  903. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  904.             WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_EMERGENCY, 12, 3, 
  905.                              WV_NETEVENT_INADDMULT_NOBUFS, ifp, ap->s_addr)
  906. #endif  /* INCLUDE_WVNET */
  907. #endif
  909.                     goto inAddMultiError;
  910.                     }
  912.                 /*
  913.  * XXX - The in_multi structures are stored in Mblk chains
  914.  * instead of arrays like in BSD. Therefore when a second 
  915.  * socket joins a multicast group, the Mblk for the in_multi
  916.  * structure is duplicated for this new member. The Mblk
  917.  * address for the in_multi is obtained by using a pointer
  918.  * to the start of the Mblk. This pointer is located just
  919.  * before the structure and is retrieved using DATA_TO_MBLK.
  920.  * This poses a problem when there is more than one Mblk
  921.  * accessing the in_multi structure (like in this case) since
  922.  * Mblk information for the second Mblk is lost. To fix this
  923.  * (SPR #67536), we use the mNextPkt field of the first Mblk
  924.  * to store the Mblk address for the second Mblk. When the 
  925.  * first Mblk is deleted (leaving group), the address of
  926.  * second Mblk can be still be retrieved through the pointer.
  927.  * Though this is not the best way to fix this problem, we
  928.  * leave it this way since the entire design needs to be 
  929.  * rethought (using the Mblk back-ptr is not a good idea).
  930.  */
  932.                 pInmFirstMblk = DATA_TO_MBLK (inm);
  933.                 netMblkDup (pInmFirstMblk, pInmMblk);
  934. pInmFirstMblk->mBlkHdr.mNextPkt = pInmMblk;
  935. pInmMblk->mBlkHdr.mNextPkt = NULL;
  937.                 ++inm->inm_refcount;
  938. }
  939. else {
  940. /*
  941.  * New address; allocate a new multicast record
  942.  * and link it into the interface's multicast list.
  943.  */
  944.         MALLOC(inm, struct in_multi *, sizeof(*inm), MT_IPMADDR,
  945.                        M_DONTWAIT);
  946.                 if (inm == NULL)
  947.                     {
  948. #ifdef WV_INSTRUMENTATION
  949. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  950.             WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_EMERGENCY, 12, 3, 
  951.                              WV_NETEVENT_INADDMULT_NOBUFS, ifp, ap->s_addr)
  952. #endif  /* INCLUDE_WVNET */
  953. #endif
  954.                     goto inAddMultiError;
  955.                     }
  956.                 pInmMblk = DATA_TO_MBLK (inm);
  957. pInmMblk->mBlkHdr.mNextPkt = NULL;
  959.                 bzero ((char *)inm, sizeof (*inm));  /* zero the structure */
  960. inm->inm_addr = *ap;
  961. inm->inm_ifp = ifp;
  962. inm->inm_refcount = 1;
  964.                 /* insert the multicast address into the hash table */
  965.                 if (mcastHashTblInsert (inm) != OK)
  966.                     goto inAddMultiError;
  968. /*
  969.  * Ask the network driver to update its multicast reception
  970.  * filter appropriately for the new address.
  971.  */
  972. ((struct sockaddr_in *)&ifr.ifr_addr)->sin_family = AF_INET;
  973. ((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr = *ap;
  974. if ((ifp->if_ioctl == NULL) ||
  975.     (*ifp->if_ioctl)(ifp, SIOCADDMULTI,(caddr_t)&ifr) != 0) {
  976.                  mcastHashTblDelete (inm);
  977.                         goto inAddMultiError;
  978. }
  979. /*
  980.  * Let IGMP know that we have joined a new IP multicast group.
  981.  */
  982. if (_igmpJoinGrpHook != NULL)
  983.     (*_igmpJoinGrpHook) (inm); 
  984. }
  985.         /*
  986.          * insert the protocol control block into inm pcb list
  987.          * this is done to get to the list of pcbs which have joined a
  988.          * multicast group. When the hash table is looked up the inm
  989.          * returned should have a list of pcbs which the datagram
  990.          * should be delivered to. refer udp_usrreq.c where the pcb
  991.          * list is used.
  992.          */
  993.         if (pInPcb != NULL)
  994.             {
  995.             if ((pInPcbMblk = mBlkGet (_pNetSysPool, M_DONTWAIT, MT_PCB))
  996.                 == NULL)
  997.                 {
  998. #ifdef WV_INSTRUMENTATION
  999. #ifdef INCLUDE_WVNET    /* WV_NET_EMERGENCY event */
  1000.             WV_NET_MARKER_2 (NET_AUX_EVENT, WV_NET_EMERGENCY, 12, 3, 
  1001.                              WV_NETEVENT_INADDMULT_NOBUFS, ifp, ap->s_addr)
  1002. #endif  /* INCLUDE_WVNET */
  1003. #endif
  1004.                 goto inAddMultiError;
  1005.                 }
  1007.             netMblkDup (DATA_TO_MBLK (pInPcb), pInPcbMblk);
  1008.             pInPcbMblk->mBlkHdr.mNext = inm->pInPcbMblk;
  1009.             inm->pInPcbMblk = pInPcbMblk;
  1010.             }
  1011.         
  1012. splx(s);
  1013. return (pInmMblk); /* return the mBlk pointing to the inm */
  1015. inAddMultiError:
  1016.         splx (s);
  1017.         if (pInmMblk)
  1018.             m_free (pInmMblk);
  1019.         return (NULL);
  1020. }
  1022. /*
  1023.  * Delete a multicast address record.
  1024.  * deletes all pcbs if pInPcb is NULL. 
  1025.  */
  1026. int
  1027. in_delmulti(pInmMblk, pInPcb)
  1028.      register struct mBlk * pInmMblk;
  1029. register struct inpcb * pInPcb;
  1030. {
  1031. register struct in_multi *inm;
  1032.         M_BLK_ID *  ppMblk;
  1033.         M_BLK_ID  pInPcbMblk; 
  1034. struct mBlk **           ppInmMblk;
  1035. struct ifreq ifr;
  1036. int s = splnet();
  1038. #ifdef WV_INSTRUMENTATION
  1039. #ifdef INCLUDE_WVNET    /* WV_NET_VERBOSE event */
  1040.     WV_NET_MARKER_0 (NET_AUX_EVENT, WV_NET_VERBOSE, 22, 12, 
  1041.                      WV_NETEVENT_INDELMULT_START)
  1042. #endif  /* INCLUDE_WVNET */
  1043. #endif
  1045.         inm = mtod (pInmMblk, struct in_multi *);
  1047.         /* delete the pcb from the list */
  1048.         ppMblk = &inm->pInPcbMblk;
  1050.         if (pInPcb != NULL)
  1051.             {
  1052.             while ((pInPcbMblk = *ppMblk))
  1053.                 {
  1054.                 if (pInPcb == mtod (pInPcbMblk, struct inpcb *))
  1055.                     {
  1056.                     *ppMblk = (*ppMblk)->mBlkHdr.mNext;
  1057.                     m_free (pInPcbMblk);
  1058.                     break; /* jump out of the while loop */
  1059.                     }
  1060.                 ppMblk = &(*ppMblk)->mBlkHdr.mNext;
  1061.                 }
  1062.             }
  1063.         else if (inm->pInPcbMblk != NULL)
  1064.             m_freem (inm->pInPcbMblk); /* free up all pcbs */
  1066. if (--inm->inm_refcount == 0) {
  1067. /*
  1068.  * No remaining claims to this record; let IGMP know that
  1069.  * we are leaving the multicast group.
  1070.  */
  1071. if (_igmpLeaveGrpHook != NULL)
  1072.     (*_igmpLeaveGrpHook) (inm); 
  1074. /*
  1075.  * Notify the network driver to update its multicast reception
  1076.  * filter.
  1077.  */
  1078. ((struct sockaddr_in *)&(ifr.ifr_addr))->sin_family = AF_INET;
  1079. ((struct sockaddr_in *)&(ifr.ifr_addr))->sin_addr =
  1080. inm->inm_addr;
  1081. (*inm->inm_ifp->if_ioctl)(inm->inm_ifp, SIOCDELMULTI,
  1082.      (caddr_t)&ifr);
  1083.                 /* time to delete entry from hash table */
  1084.                 mcastHashTblDelete (inm);
  1085. }
  1087.         /*
  1088.  * If there is another socket listening to this group, replace
  1089.  * inm's back-ptr to its Mblk (currently that of socket leaving
  1090.  * the group) with the pointer to the Mblk of the other socket
  1091.  */
  1093.         if ((inm != NULL) && (pInmMblk->mBlkHdr.mNextPkt != NULL))
  1094.     {
  1095.     ppInmMblk = (struct mbuf **)((char *)inm - sizeof (struct mbuf **));
  1096.     *ppInmMblk = pInmMblk->mBlkHdr.mNextPkt;
  1097.     (*ppInmMblk)->mBlkHdr.mNextPkt = NULL;
  1098.     }
  1100.         /* free the mblk & inm, actual free only clRefCnt is 1 */
  1102.         m_free (pInmMblk); 
  1103. splx(s);
  1105. return (OK);
  1106. }
  1108. /*
  1109.  * Return address info for specified internet network.
  1110.  */
  1111. struct in_ifaddr *
  1112. in_iaonnetof(net)
  1113. u_long net;
  1114. {
  1115. register struct in_ifaddr *ia;
  1117. #ifdef VIRTUAL_STACK
  1118. for (ia = _in_ifaddr; ia; ia = ia->ia_next)
  1119. #else
  1120. for (ia = in_ifaddr; ia; ia = ia->ia_next)
  1121. #endif /* VIRTUAL_STACK */
  1122. if (ia->ia_subnet == net)
  1123. return (ia);
  1124. return ((struct in_ifaddr *)0);
  1125. }
  1127. /* multicast hashing functions */
  1129. void mcastHashInit ()
  1130.     {
  1132.     /* initialize the mcast hash table */
  1133.     mCastHashInfo.hashBase =  hashinit (mCastHashTblSize,
  1134.                                         MT_IPMADDR,
  1135.                                         &mCastHashInfo.hashMask);
  1136.     }
  1138. STATUS mcastHashTblInsert
  1139.     (
  1140.     struct in_multi *  pInMulti
  1141.     )
  1142.     {
  1143.     IN_MULTI_HEAD *  inMultiHead;
  1144.     int  s; 
  1146.     s = splnet();
  1147.     inMultiHead = &mCastHashInfo.hashBase[MCAST_HASH(pInMulti->inm_addr.s_addr,
  1148.                                                      pInMulti->inm_ifp,
  1149.                                                      mCastHashInfo.hashMask)];
  1151.     /* insert a multicast address structure into the hash table */
  1152.     LIST_INSERT_HEAD(inMultiHead, pInMulti, inm_hash);
  1153.     
  1154.     splx(s);
  1155.     return (OK); 
  1156.     }
  1158. STATUS mcastHashTblDelete
  1159.     (
  1160.     struct in_multi * pInMulti
  1161.     )
  1162.     {
  1163.     int  s; 
  1164.     s = splnet();
  1166.     LIST_REMOVE(pInMulti, inm_hash);
  1168.     splx(s);
  1169.     return (OK); 
  1170.     }
  1172. struct in_multi * mcastHashTblLookup
  1173.     (
  1174.     int mcastAddr, /* multicast Address always in NBO */
  1175.     struct ifnet *  pIf /* interface pointer */
  1176.     )
  1177.     {
  1178.     IN_MULTI_HEAD *  inMultiHead;
  1179.     IN_MULTI *  pInMulti;
  1180.     int  s;
  1182.     s = splnet();
  1184.     /* search a hash table for the appropriate multicast address tied to
  1185.        a particular network interface
  1186.      */
  1187.     inMultiHead = &mCastHashInfo.hashBase[MCAST_HASH(mcastAddr, pIf,
  1188.                                                      mCastHashInfo.hashMask)];
  1189.     for (pInMulti = inMultiHead->lh_first; pInMulti != NULL;
  1190.          pInMulti = pInMulti->inm_hash.le_next)
  1191.         {
  1192.         if (pInMulti->inm_addr.s_addr == mcastAddr &&
  1193.             pInMulti->inm_ifp == pIf)
  1194.             goto found;
  1195.         }
  1197.     splx(s);
  1198.     return (NULL);
  1200.     found:
  1201.     /*
  1202.      * Move IN_MULTI to head of this hash chain so that it can be
  1203.      * found more quickly in the future.
  1204.      * XXX - this is a pessimization on machines with few
  1205.      * concurrent connections.
  1206.      */
  1208.     if (pInMulti != inMultiHead->lh_first)
  1209.         {
  1210.         LIST_REMOVE(pInMulti, inm_hash);
  1211.         LIST_INSERT_HEAD(inMultiHead, pInMulti, inm_hash);
  1212.         }
  1214.     splx(s);
  1215.     return (pInMulti);
  1216.     }
  1218. #endif