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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 网络编程 > 查看源码
IN.C
资源名称：Nwpro.rar　[点击查看]
上传用户：tjbfgc
上传日期：2013-03-31
资源大小：140k
文件大小：17k
源码类别：

网络编程

开发平台：

C/C++

IN.C：源码内容
  1. /*
  2.  * Copyright (c) 1982, 1986, 1991, 1993
  3.  * The Regents of the University of California.  All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice, this list of conditions and the following disclaimer.
  10.  * 2. Redistributions in binary form must reproduce the above copyright
  11.  *    notice, this list of conditions and the following disclaimer in the
  12.  *    documentation and/or other materials provided with the distribution.
  13.  * 3. All advertising materials mentioning features or use of this software
  14.  *    must display the following acknowledgement:
  15.  * This product includes software developed by the University of
  16.  * California, Berkeley and its contributors.
  17.  * 4. Neither the name of the University nor the names of its contributors
  18.  *    may be used to endorse or promote products derived from this software
  19.  *    without specific prior written permission.
  20.  *
  21.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31.  * SUCH DAMAGE.
  32.  *
  33.  * @(#)in.c 8.2 (Berkeley) 11/15/93
  34.  */
  36. #include <sys/param.h>
  37. #include <sys/ioctl.h>
  38. #include <sys/errno.h>
  39. #include <sys/malloc.h>
  40. #include <sys/socket.h>
  41. #include <sys/socketvar.h>
  43. #include <net/if.h>
  44. #include <net/route.h>
  46. #include <netinet/in_systm.h>
  47. #include <netinet/in.h>
  48. #include <netinet/in_var.h>
  49. #include <netinet/if_ether.h>
  51. #ifdef INET
  52. /*
  53.  * Return the network number from an internet address.
  54.  */
  55. u_long
  56. in_netof(in)
  57. struct in_addr in;
  58. {
  59. register u_long i = ntohl(in.s_addr);
  60. register u_long net;
  61. register struct in_ifaddr *ia;
  63. if (IN_CLASSA(i))
  64. net = i & IN_CLASSA_NET;
  65. else if (IN_CLASSB(i))
  66. net = i & IN_CLASSB_NET;
  67. else if (IN_CLASSC(i))
  68. net = i & IN_CLASSC_NET;
  69. else if (IN_CLASSD(i))
  70. net = i & IN_CLASSD_NET;
  71. else
  72. return (0);
  74. /*
  75.  * Check whether network is a subnet;
  76.  * if so, return subnet number.
  77.  */
  78. for (ia = in_ifaddr; ia; ia = ia->ia_next)
  79. if (net == ia->ia_net)
  80. return (i & ia->ia_subnetmask);
  81. return (net);
  82. }
  84. #ifndef SUBNETSARELOCAL
  85. #define SUBNETSARELOCAL 1
  86. #endif
  87. int subnetsarelocal = SUBNETSARELOCAL;
  88. /*
  89.  * Return 1 if an internet address is for a ``local'' host
  90.  * (one to which we have a connection).  If subnetsarelocal
  91.  * is true, this includes other subnets of the local net.
  92.  * Otherwise, it includes only the directly-connected (sub)nets.
  93.  */
  94. in_localaddr(in)
  95. struct in_addr in;
  96. {
  97. register u_long i = ntohl(in.s_addr);
  98. register struct in_ifaddr *ia;
  100. if (subnetsarelocal) {
  101. for (ia = in_ifaddr; ia; ia = ia->ia_next)
  102. if ((i & ia->ia_netmask) == ia->ia_net)
  103. return (1);
  104. } else {
  105. for (ia = in_ifaddr; ia; ia = ia->ia_next)
  106. if ((i & ia->ia_subnetmask) == ia->ia_subnet)
  107. return (1);
  108. }
  109. return (0);
  110. }
  112. /*
  113.  * Determine whether an IP address is in a reserved set of addresses
  114.  * that may not be forwarded, or whether datagrams to that destination
  115.  * may be forwarded.
  116.  */
  117. in_canforward(in)
  118. struct in_addr in;
  119. {
  120. register u_long i = ntohl(in.s_addr);
  121. register u_long net;
  123. if (IN_EXPERIMENTAL(i) || IN_MULTICAST(i))
  124. return (0);
  125. if (IN_CLASSA(i)) {
  126. net = i & IN_CLASSA_NET;
  127. if (net == 0 || net == (IN_LOOPBACKNET << IN_CLASSA_NSHIFT))
  128. return (0);
  129. }
  130. return (1);
  131. }
  133. /*
  134.  * Trim a mask in a sockaddr
  135.  */
  136. void
  137. in_socktrim(ap)
  138. struct sockaddr_in *ap;
  139. {
  140.     register char *cplim = (char *) &ap->sin_addr;
  141.     register char *cp = (char *) (&ap->sin_addr + 1);
  143.     ap->sin_len = 0;
  144.     while (--cp > cplim)
  145.         if (*cp) {
  146.     (ap)->sin_len = cp - (char *) (ap) + 1;
  147.     break;
  148. }
  149. }
  151. int in_interfaces; /* number of external internet interfaces */
  152. extern struct ifnet loif;
  154. /*
  155.  * Generic internet control operations (ioctl's).
  156.  * Ifp is 0 if not an interface-specific ioctl.
  157.  */
  158. /* ARGSUSED */
  159. in_control(so, cmd, data, ifp)
  160. struct socket *so;
  161. int cmd;
  162. caddr_t data;
  163. register struct ifnet *ifp;
  164. {
  165. register struct ifreq *ifr = (struct ifreq *)data;
  166. register struct in_ifaddr *ia = 0;
  167. register struct ifaddr *ifa;
  168. struct in_ifaddr *oia;
  169. struct in_aliasreq *ifra = (struct in_aliasreq *)data;
  170. struct sockaddr_in oldaddr;
  171. int error, hostIsNew, maskIsNew;
  172. u_long i;
  174. /*
  175.  * Find address for this interface, if it exists.
  176.  */
  177. if (ifp)
  178. for (ia = in_ifaddr; ia; ia = ia->ia_next)
  179. if (ia->ia_ifp == ifp)
  180. break;
  182. switch (cmd) {
  184. case SIOCAIFADDR:
  185. case SIOCDIFADDR:
  186. if (ifra->ifra_addr.sin_family == AF_INET)
  187.     for (oia = ia; ia; ia = ia->ia_next) {
  188. if (ia->ia_ifp == ifp  &&
  189.     ia->ia_addr.sin_addr.s_addr ==
  190. ifra->ifra_addr.sin_addr.s_addr)
  191.     break;
  192. }
  193. if (cmd == SIOCDIFADDR && ia == 0)
  194. return (EADDRNOTAVAIL);
  195. /* FALLTHROUGH */
  196. case SIOCSIFADDR:
  197. case SIOCSIFNETMASK:
  198. case SIOCSIFDSTADDR:
  199. if ((so->so_state & SS_PRIV) == 0)
  200. return (EPERM);
  202. if (ifp == 0)
  203. panic("in_control");
  204. if (ia == (struct in_ifaddr *)0) {
  205. oia = (struct in_ifaddr *)
  206. malloc(sizeof *oia, M_IFADDR, M_WAITOK);
  207. if (oia == (struct in_ifaddr *)NULL)
  208. return (ENOBUFS);
  209. bzero((caddr_t)oia, sizeof *oia);
  210. if (ia = in_ifaddr) {
  211. for ( ; ia->ia_next; ia = ia->ia_next)
  212. continue;
  213. ia->ia_next = oia;
  214. } else
  215. in_ifaddr = oia;
  216. ia = oia;
  217. if (ifa = ifp->if_addrlist) {
  218. for ( ; ifa->ifa_next; ifa = ifa->ifa_next)
  219. continue;
  220. ifa->ifa_next = (struct ifaddr *) ia;
  221. } else
  222. ifp->if_addrlist = (struct ifaddr *) ia;
  223. ia->ia_ifa.ifa_addr = (struct sockaddr *)&ia->ia_addr;
  224. ia->ia_ifa.ifa_dstaddr
  225. = (struct sockaddr *)&ia->ia_dstaddr;
  226. ia->ia_ifa.ifa_netmask
  227. = (struct sockaddr *)&ia->ia_sockmask;
  228. ia->ia_sockmask.sin_len = 8;
  229. if (ifp->if_flags & IFF_BROADCAST) {
  230. ia->ia_broadaddr.sin_len = sizeof(ia->ia_addr);
  231. ia->ia_broadaddr.sin_family = AF_INET;
  232. }
  233. ia->ia_ifp = ifp;
  234. if (ifp != &loif)
  235. in_interfaces++;
  236. }
  237. break;
  239. case SIOCSIFBRDADDR:
  240. if ((so->so_state & SS_PRIV) == 0)
  241. return (EPERM);
  242. /* FALLTHROUGH */
  244. case SIOCGIFADDR:
  245. case SIOCGIFNETMASK:
  246. case SIOCGIFDSTADDR:
  247. case SIOCGIFBRDADDR:
  248. if (ia == (struct in_ifaddr *)0)
  249. return (EADDRNOTAVAIL);
  250. break;
  251. }
  252. switch (cmd) {
  254. case SIOCGIFADDR:
  255. *((struct sockaddr_in *)&ifr->ifr_addr) = ia->ia_addr;
  256. break;
  258. case SIOCGIFBRDADDR:
  259. if ((ifp->if_flags & IFF_BROADCAST) == 0)
  260. return (EINVAL);
  261. *((struct sockaddr_in *)&ifr->ifr_dstaddr) = ia->ia_broadaddr;
  262. break;
  264. case SIOCGIFDSTADDR:
  265. if ((ifp->if_flags & IFF_POINTOPOINT) == 0)
  266. return (EINVAL);
  267. *((struct sockaddr_in *)&ifr->ifr_dstaddr) = ia->ia_dstaddr;
  268. break;
  270. case SIOCGIFNETMASK:
  271. *((struct sockaddr_in *)&ifr->ifr_addr) = ia->ia_sockmask;
  272. break;
  274. case SIOCSIFDSTADDR:
  275. if ((ifp->if_flags & IFF_POINTOPOINT) == 0)
  276. return (EINVAL);
  277. oldaddr = ia->ia_dstaddr;
  278. ia->ia_dstaddr = *(struct sockaddr_in *)&ifr->ifr_dstaddr;
  279. if (ifp->if_ioctl && (error = (*ifp->if_ioctl)
  280. (ifp, SIOCSIFDSTADDR, (caddr_t)ia))) {
  281. ia->ia_dstaddr = oldaddr;
  282. return (error);
  283. }
  284. if (ia->ia_flags & IFA_ROUTE) {
  285. ia->ia_ifa.ifa_dstaddr = (struct sockaddr *)&oldaddr;
  286. rtinit(&(ia->ia_ifa), (int)RTM_DELETE, RTF_HOST);
  287. ia->ia_ifa.ifa_dstaddr =
  288. (struct sockaddr *)&ia->ia_dstaddr;
  289. rtinit(&(ia->ia_ifa), (int)RTM_ADD, RTF_HOST|RTF_UP);
  290. }
  291. break;
  293. case SIOCSIFBRDADDR:
  294. if ((ifp->if_flags & IFF_BROADCAST) == 0)
  295. return (EINVAL);
  296. ia->ia_broadaddr = *(struct sockaddr_in *)&ifr->ifr_broadaddr;
  297. break;
  299. case SIOCSIFADDR:
  300. return (in_ifinit(ifp, ia,
  301.     (struct sockaddr_in *) &ifr->ifr_addr, 1));
  303. case SIOCSIFNETMASK:
  304. i = ifra->ifra_addr.sin_addr.s_addr;
  305. ia->ia_subnetmask = ntohl(ia->ia_sockmask.sin_addr.s_addr = i);
  306. break;
  308. case SIOCAIFADDR:
  309. maskIsNew = 0;
  310. hostIsNew = 1;
  311. error = 0;
  312. if (ia->ia_addr.sin_family == AF_INET) {
  313. if (ifra->ifra_addr.sin_len == 0) {
  314. ifra->ifra_addr = ia->ia_addr;
  315. hostIsNew = 0;
  316. } else if (ifra->ifra_addr.sin_addr.s_addr ==
  317.        ia->ia_addr.sin_addr.s_addr)
  318. hostIsNew = 0;
  319. }
  320. if (ifra->ifra_mask.sin_len) {
  321. in_ifscrub(ifp, ia);
  322. ia->ia_sockmask = ifra->ifra_mask;
  323. ia->ia_subnetmask =
  324.      ntohl(ia->ia_sockmask.sin_addr.s_addr);
  325. maskIsNew = 1;
  326. }
  327. if ((ifp->if_flags & IFF_POINTOPOINT) &&
  328.     (ifra->ifra_dstaddr.sin_family == AF_INET)) {
  329. in_ifscrub(ifp, ia);
  330. ia->ia_dstaddr = ifra->ifra_dstaddr;
  331. maskIsNew  = 1; /* We lie; but the effect's the same */
  332. }
  333. if (ifra->ifra_addr.sin_family == AF_INET &&
  334.     (hostIsNew || maskIsNew))
  335. error = in_ifinit(ifp, ia, &ifra->ifra_addr, 0);
  336. if ((ifp->if_flags & IFF_BROADCAST) &&
  337.     (ifra->ifra_broadaddr.sin_family == AF_INET))
  338. ia->ia_broadaddr = ifra->ifra_broadaddr;
  339. return (error);
  341. case SIOCDIFADDR:
  342. in_ifscrub(ifp, ia);
  343. if ((ifa = ifp->if_addrlist) == (struct ifaddr *)ia)
  344. ifp->if_addrlist = ifa->ifa_next;
  345. else {
  346. while (ifa->ifa_next &&
  347.        (ifa->ifa_next != (struct ifaddr *)ia))
  348.     ifa = ifa->ifa_next;
  349. if (ifa->ifa_next)
  350. ifa->ifa_next = ((struct ifaddr *)ia)->ifa_next;
  351. else
  352. printf("Couldn't unlink inifaddr from ifpn");
  353. }
  354. oia = ia;
  355. if (oia == (ia = in_ifaddr))
  356. in_ifaddr = ia->ia_next;
  357. else {
  358. while (ia->ia_next && (ia->ia_next != oia))
  359. ia = ia->ia_next;
  360. if (ia->ia_next)
  361. ia->ia_next = oia->ia_next;
  362. else
  363. printf("Didn't unlink inifadr from listn");
  364. }
  365. IFAFREE((&oia->ia_ifa));
  366. break;
  368. default:
  369. if (ifp == 0 || ifp->if_ioctl == 0)
  370. return (EOPNOTSUPP);
  371. return ((*ifp->if_ioctl)(ifp, cmd, data));
  372. }
  373. return (0);
  374. }
  376. /*
  377.  * Delete any existing route for an interface.
  378.  */
  379. void
  380. in_ifscrub(ifp, ia)
  381. register struct ifnet *ifp;
  382. register struct in_ifaddr *ia;
  383. {
  385. if ((ia->ia_flags & IFA_ROUTE) == 0)
  386. return;
  387. if (ifp->if_flags & (IFF_LOOPBACK|IFF_POINTOPOINT))
  388. rtinit(&(ia->ia_ifa), (int)RTM_DELETE, RTF_HOST);
  389. else
  390. rtinit(&(ia->ia_ifa), (int)RTM_DELETE, 0);
  391. ia->ia_flags &= ~IFA_ROUTE;
  392. }
  394. /*
  395.  * Initialize an interface's internet address
  396.  * and routing table entry.
  397.  */
  398. in_ifinit(ifp, ia, sin, scrub)
  399. register struct ifnet *ifp;
  400. register struct in_ifaddr *ia;
  401. struct sockaddr_in *sin;
  402. int scrub;
  403. {
  404. register u_long i = ntohl(sin->sin_addr.s_addr);
  405. struct sockaddr_in oldaddr;
  406. int s = splimp(), flags = RTF_UP, error, ether_output();
  408. oldaddr = ia->ia_addr;
  409. ia->ia_addr = *sin;
  410. /*
  411.  * Give the interface a chance to initialize
  412.  * if this is its first address,
  413.  * and to validate the address if necessary.
  414.  */
  415. if (ifp->if_ioctl &&
  416.     (error = (*ifp->if_ioctl)(ifp, SIOCSIFADDR, (caddr_t)ia))) {
  417. splx(s);
  418. ia->ia_addr = oldaddr;
  419. return (error);
  420. }
  421. if (ifp->if_output == ether_output) { /* XXX: Another Kludge */
  422. ia->ia_ifa.ifa_rtrequest = arp_rtrequest;
  423. ia->ia_ifa.ifa_flags |= RTF_CLONING;
  424. }
  425. splx(s);
  426. if (scrub) {
  427. ia->ia_ifa.ifa_addr = (struct sockaddr *)&oldaddr;
  428. in_ifscrub(ifp, ia);
  429. ia->ia_ifa.ifa_addr = (struct sockaddr *)&ia->ia_addr;
  430. }
  431. if (IN_CLASSA(i))
  432. ia->ia_netmask = IN_CLASSA_NET;
  433. else if (IN_CLASSB(i))
  434. ia->ia_netmask = IN_CLASSB_NET;
  435. else
  436. ia->ia_netmask = IN_CLASSC_NET;
  437. /*
  438.  * The subnet mask usually includes at least the standard network part,
  439.  * but may may be smaller in the case of supernetting.
  440.  * If it is set, we believe it.
  441.  */
  442. if (ia->ia_subnetmask == 0) {
  443. ia->ia_subnetmask = ia->ia_netmask;
  444. ia->ia_sockmask.sin_addr.s_addr = htonl(ia->ia_subnetmask);
  445. } else
  446. ia->ia_netmask &= ia->ia_subnetmask;
  447. ia->ia_net = i & ia->ia_netmask;
  448. ia->ia_subnet = i & ia->ia_subnetmask;
  449. in_socktrim(&ia->ia_sockmask);
  450. /*
  451.  * Add route for the network.
  452.  */
  453. ia->ia_ifa.ifa_metric = ifp->if_metric;
  454. if (ifp->if_flags & IFF_BROADCAST) {
  455. ia->ia_broadaddr.sin_addr.s_addr =
  456. htonl(ia->ia_subnet | ~ia->ia_subnetmask);
  457. ia->ia_netbroadcast.s_addr =
  458. htonl(ia->ia_net | ~ ia->ia_netmask);
  459. } else if (ifp->if_flags & IFF_LOOPBACK) {
  460. ia->ia_ifa.ifa_dstaddr = ia->ia_ifa.ifa_addr;
  461. flags |= RTF_HOST;
  462. } else if (ifp->if_flags & IFF_POINTOPOINT) {
  463. if (ia->ia_dstaddr.sin_family != AF_INET)
  464. return (0);
  465. flags |= RTF_HOST;
  466. }
  467. if ((error = rtinit(&(ia->ia_ifa), (int)RTM_ADD, flags)) == 0)
  468. ia->ia_flags |= IFA_ROUTE;
  469. /*
  470.  * If the interface supports multicast, join the "all hosts"
  471.  * multicast group on that interface.
  472.  */
  473. if (ifp->if_flags & IFF_MULTICAST) {
  474. struct in_addr addr;
  476. addr.s_addr = htonl(INADDR_ALLHOSTS_GROUP);
  477. in_addmulti(&addr, ifp);
  478. }
  479. return (error);
  480. }
  483. /*
  484.  * Return 1 if the address might be a local broadcast address.
  485.  */
  486. in_broadcast(in, ifp)
  487. struct in_addr in;
  488.         struct ifnet *ifp;
  489. {
  490. register struct ifaddr *ifa;
  491. u_long t;
  493. if (in.s_addr == INADDR_BROADCAST ||
  494.     in.s_addr == INADDR_ANY)
  495. return 1;
  496. if ((ifp->if_flags & IFF_BROADCAST) == 0)
  497. return 0;
  498. t = ntohl(in.s_addr);
  499. /*
  500.  * Look through the list of addresses for a match
  501.  * with a broadcast address.
  502.  */
  503. #define ia ((struct in_ifaddr *)ifa)
  504. for (ifa = ifp->if_addrlist; ifa; ifa = ifa->ifa_next)
  505. if (ifa->ifa_addr->sa_family == AF_INET &&
  506.     (in.s_addr == ia->ia_broadaddr.sin_addr.s_addr ||
  507.      in.s_addr == ia->ia_netbroadcast.s_addr ||
  508.      /*
  509.       * Check for old-style (host 0) broadcast.
  510.       */
  511.      t == ia->ia_subnet || t == ia->ia_net))
  512.     return 1;
  513. return (0);
  514. #undef ia
  515. }
  516. /*
  517.  * Add an address to the list of IP multicast addresses for a given interface.
  518.  */
  519. struct in_multi *
  520. in_addmulti(ap, ifp)
  521. register struct in_addr *ap;
  522. register struct ifnet *ifp;
  523. {
  524. register struct in_multi *inm;
  525. struct ifreq ifr;
  526. struct in_ifaddr *ia;
  527. int s = splnet();
  529. /*
  530.  * See if address already in list.
  531.  */
  532. IN_LOOKUP_MULTI(*ap, ifp, inm);
  533. if (inm != NULL) {
  534. /*
  535.  * Found it; just increment the reference count.
  536.  */
  537. ++inm->inm_refcount;
  538. }
  539. else {
  540. /*
  541.  * New address; allocate a new multicast record
  542.  * and link it into the interface's multicast list.
  543.  */
  544. inm = (struct in_multi *)malloc(sizeof(*inm),
  545.     M_IPMADDR, M_NOWAIT);
  546. if (inm == NULL) {
  547. splx(s);
  548. return (NULL);
  549. }
  550. inm->inm_addr = *ap;
  551. inm->inm_ifp = ifp;
  552. inm->inm_refcount = 1;
  553. IFP_TO_IA(ifp, ia);
  554. if (ia == NULL) {
  555. free(inm, M_IPMADDR);
  556. splx(s);
  557. return (NULL);
  558. }
  559. inm->inm_ia = ia;
  560. inm->inm_next = ia->ia_multiaddrs;
  561. ia->ia_multiaddrs = inm;
  562. /*
  563.  * Ask the network driver to update its multicast reception
  564.  * filter appropriately for the new address.
  565.  */
  566. ((struct sockaddr_in *)&ifr.ifr_addr)->sin_family = AF_INET;
  567. ((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr = *ap;
  568. if ((ifp->if_ioctl == NULL) ||
  569.     (*ifp->if_ioctl)(ifp, SIOCADDMULTI,(caddr_t)&ifr) != 0) {
  570. ia->ia_multiaddrs = inm->inm_next;
  571. free(inm, M_IPMADDR);
  572. splx(s);
  573. return (NULL);
  574. }
  575. /*
  576.  * Let IGMP know that we have joined a new IP multicast group.
  577.  */
  578. igmp_joingroup(inm);
  579. }
  580. splx(s);
  581. return (inm);
  582. }
  584. /*
  585.  * Delete a multicast address record.
  586.  */
  587. int
  588. in_delmulti(inm)
  589. register struct in_multi *inm;
  590. {
  591. register struct in_multi **p;
  592. struct ifreq ifr;
  593. int s = splnet();
  595. if (--inm->inm_refcount == 0) {
  596. /*
  597.  * No remaining claims to this record; let IGMP know that
  598.  * we are leaving the multicast group.
  599.  */
  600. igmp_leavegroup(inm);
  601. /*
  602.  * Unlink from list.
  603.  */
  604. for (p = &inm->inm_ia->ia_multiaddrs;
  605.      *p != inm;
  606.      p = &(*p)->inm_next)
  607.  continue;
  608. *p = (*p)->inm_next;
  609. /*
  610.  * Notify the network driver to update its multicast reception
  611.  * filter.
  612.  */
  613. ((struct sockaddr_in *)&(ifr.ifr_addr))->sin_family = AF_INET;
  614. ((struct sockaddr_in *)&(ifr.ifr_addr))->sin_addr =
  615. inm->inm_addr;
  616. (*inm->inm_ifp->if_ioctl)(inm->inm_ifp, SIOCDELMULTI,
  617.      (caddr_t)&ifr);
  618. free(inm, M_IPMADDR);
  619. }
  620. splx(s);
  621. }
  622. #endif