1 /* $NetBSD: in.c,v 1.97 2004/07/07 01:39:00 mycroft Exp $ */ 2 3 /* 4 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the project nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 /*- 33 * Copyright (c) 1998 The NetBSD Foundation, Inc. 34 * All rights reserved. 35 * 36 * This code is derived from software contributed to The NetBSD Foundation 37 * by Public Access Networks Corporation ("Panix"). It was developed under 38 * contract to Panix by Eric Haszlakiewicz and Thor Lancelot Simon. 39 * 40 * Redistribution and use in source and binary forms, with or without 41 * modification, are permitted provided that the following conditions 42 * are met: 43 * 1. Redistributions of source code must retain the above copyright 44 * notice, this list of conditions and the following disclaimer. 45 * 2. Redistributions in binary form must reproduce the above copyright 46 * notice, this list of conditions and the following disclaimer in the 47 * documentation and/or other materials provided with the distribution. 48 * 3. All advertising materials mentioning features or use of this software 49 * must display the following acknowledgement: 50 * This product includes software developed by the NetBSD 51 * Foundation, Inc. and its contributors. 52 * 4. Neither the name of The NetBSD Foundation nor the names of its 53 * contributors may be used to endorse or promote products derived 54 * from this software without specific prior written permission. 55 * 56 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 57 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 58 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 59 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 60 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 61 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 62 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 63 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 64 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 65 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 66 * POSSIBILITY OF SUCH DAMAGE. 67 */ 68 69 /* 70 * Copyright (c) 1982, 1986, 1991, 1993 71 * The Regents of the University of California. All rights reserved. 72 * 73 * Redistribution and use in source and binary forms, with or without 74 * modification, are permitted provided that the following conditions 75 * are met: 76 * 1. Redistributions of source code must retain the above copyright 77 * notice, this list of conditions and the following disclaimer. 78 * 2. Redistributions in binary form must reproduce the above copyright 79 * notice, this list of conditions and the following disclaimer in the 80 * documentation and/or other materials provided with the distribution. 81 * 3. Neither the name of the University nor the names of its contributors 82 * may be used to endorse or promote products derived from this software 83 * without specific prior written permission. 84 * 85 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 86 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 87 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 88 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 89 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 90 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 91 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 92 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 93 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 94 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 95 * SUCH DAMAGE. 96 * 97 * @(#)in.c 8.4 (Berkeley) 1/9/95 98 */ 99 100 #include <sys/cdefs.h> 101 __KERNEL_RCSID(0, "$NetBSD: in.c,v 1.97 2004/07/07 01:39:00 mycroft Exp $"); 102 103 #include "opt_inet.h" 104 #include "opt_inet_conf.h" 105 #include "opt_mrouting.h" 106 #include "opt_pfil_hooks.h" 107 108 #include <sys/param.h> 109 #include <sys/ioctl.h> 110 #include <sys/errno.h> 111 #include <sys/malloc.h> 112 #include <sys/socket.h> 113 #include <sys/socketvar.h> 114 #include <sys/systm.h> 115 #include <sys/proc.h> 116 #include <sys/syslog.h> 117 118 #include <net/if.h> 119 #include <net/route.h> 120 121 #include <net/if_ether.h> 122 123 #include <netinet/in_systm.h> 124 #include <netinet/in.h> 125 #include <netinet/in_var.h> 126 #include <netinet/ip.h> 127 #include <netinet/ip_var.h> 128 #include <netinet/in_pcb.h> 129 #include <netinet/if_inarp.h> 130 #include <netinet/ip_mroute.h> 131 #include <netinet/igmp_var.h> 132 133 #ifdef PFIL_HOOKS 134 #include <net/pfil.h> 135 #endif 136 137 #ifdef INET 138 static u_int in_mask2len __P((struct in_addr *)); 139 static void in_len2mask __P((struct in_addr *, u_int)); 140 static int in_lifaddr_ioctl __P((struct socket *, u_long, caddr_t, 141 struct ifnet *, struct proc *)); 142 143 static int in_addprefix __P((struct in_ifaddr *, int)); 144 static int in_scrubprefix __P((struct in_ifaddr *)); 145 146 #ifndef SUBNETSARELOCAL 147 #define SUBNETSARELOCAL 1 148 #endif 149 150 #ifndef HOSTZEROBROADCAST 151 #define HOSTZEROBROADCAST 1 152 #endif 153 154 int subnetsarelocal = SUBNETSARELOCAL; 155 int hostzeroisbroadcast = HOSTZEROBROADCAST; 156 157 /* 158 * This list is used to keep track of in_multi chains which belong to 159 * deleted interface addresses. We use in_ifaddr so that a chain head 160 * won't be deallocated until all multicast address record are deleted. 161 */ 162 static TAILQ_HEAD(, in_ifaddr) in_mk = TAILQ_HEAD_INITIALIZER(in_mk); 163 164 /* 165 * Return 1 if an internet address is for a ``local'' host 166 * (one to which we have a connection). If subnetsarelocal 167 * is true, this includes other subnets of the local net. 168 * Otherwise, it includes only the directly-connected (sub)nets. 169 */ 170 int 171 in_localaddr(in) 172 struct in_addr in; 173 { 174 struct in_ifaddr *ia; 175 176 if (subnetsarelocal) { 177 TAILQ_FOREACH(ia, &in_ifaddrhead, ia_list) 178 if ((in.s_addr & ia->ia_netmask) == ia->ia_net) 179 return (1); 180 } else { 181 TAILQ_FOREACH(ia, &in_ifaddrhead, ia_list) 182 if ((in.s_addr & ia->ia_subnetmask) == ia->ia_subnet) 183 return (1); 184 } 185 return (0); 186 } 187 188 /* 189 * Determine whether an IP address is in a reserved set of addresses 190 * that may not be forwarded, or whether datagrams to that destination 191 * may be forwarded. 192 */ 193 int 194 in_canforward(in) 195 struct in_addr in; 196 { 197 u_int32_t net; 198 199 if (IN_EXPERIMENTAL(in.s_addr) || IN_MULTICAST(in.s_addr)) 200 return (0); 201 if (IN_CLASSA(in.s_addr)) { 202 net = in.s_addr & IN_CLASSA_NET; 203 if (net == 0 || net == htonl(IN_LOOPBACKNET << IN_CLASSA_NSHIFT)) 204 return (0); 205 } 206 return (1); 207 } 208 209 /* 210 * Trim a mask in a sockaddr 211 */ 212 void 213 in_socktrim(ap) 214 struct sockaddr_in *ap; 215 { 216 char *cplim = (char *) &ap->sin_addr; 217 char *cp = (char *) (&ap->sin_addr + 1); 218 219 ap->sin_len = 0; 220 while (--cp >= cplim) 221 if (*cp) { 222 (ap)->sin_len = cp - (char *) (ap) + 1; 223 break; 224 } 225 } 226 227 /* 228 * Routine to take an Internet address and convert into a 229 * "dotted quad" representation for printing. 230 */ 231 const char * 232 in_fmtaddr(addr) 233 struct in_addr addr; 234 { 235 static char buf[sizeof("123.456.789.123")]; 236 237 addr.s_addr = ntohl(addr.s_addr); 238 239 snprintf(buf, sizeof(buf), "%d.%d.%d.%d", 240 (addr.s_addr >> 24) & 0xFF, 241 (addr.s_addr >> 16) & 0xFF, 242 (addr.s_addr >> 8) & 0xFF, 243 (addr.s_addr >> 0) & 0xFF); 244 return buf; 245 } 246 247 /* 248 * Maintain the "in_maxmtu" variable, which is the largest 249 * mtu for non-local interfaces with AF_INET addresses assigned 250 * to them that are up. 251 */ 252 unsigned long in_maxmtu; 253 254 void 255 in_setmaxmtu() 256 { 257 struct in_ifaddr *ia; 258 struct ifnet *ifp; 259 unsigned long maxmtu = 0; 260 261 TAILQ_FOREACH(ia, &in_ifaddrhead, ia_list) { 262 if ((ifp = ia->ia_ifp) == 0) 263 continue; 264 if ((ifp->if_flags & (IFF_UP|IFF_LOOPBACK)) != IFF_UP) 265 continue; 266 if (ifp->if_mtu > maxmtu) 267 maxmtu = ifp->if_mtu; 268 } 269 if (maxmtu) 270 in_maxmtu = maxmtu; 271 } 272 273 static u_int 274 in_mask2len(mask) 275 struct in_addr *mask; 276 { 277 u_int x, y; 278 u_char *p; 279 280 p = (u_char *)mask; 281 for (x = 0; x < sizeof(*mask); x++) { 282 if (p[x] != 0xff) 283 break; 284 } 285 y = 0; 286 if (x < sizeof(*mask)) { 287 for (y = 0; y < 8; y++) { 288 if ((p[x] & (0x80 >> y)) == 0) 289 break; 290 } 291 } 292 return x * 8 + y; 293 } 294 295 static void 296 in_len2mask(mask, len) 297 struct in_addr *mask; 298 u_int len; 299 { 300 u_int i; 301 u_char *p; 302 303 p = (u_char *)mask; 304 bzero(mask, sizeof(*mask)); 305 for (i = 0; i < len / 8; i++) 306 p[i] = 0xff; 307 if (len % 8) 308 p[i] = (0xff00 >> (len % 8)) & 0xff; 309 } 310 311 /* 312 * Generic internet control operations (ioctl's). 313 * Ifp is 0 if not an interface-specific ioctl. 314 */ 315 /* ARGSUSED */ 316 int 317 in_control(so, cmd, data, ifp, p) 318 struct socket *so; 319 u_long cmd; 320 caddr_t data; 321 struct ifnet *ifp; 322 struct proc *p; 323 { 324 struct ifreq *ifr = (struct ifreq *)data; 325 struct in_ifaddr *ia = 0; 326 struct in_aliasreq *ifra = (struct in_aliasreq *)data; 327 struct sockaddr_in oldaddr; 328 int error, hostIsNew, maskIsNew; 329 330 switch (cmd) { 331 case SIOCALIFADDR: 332 case SIOCDLIFADDR: 333 if (p == 0 || (error = suser(p->p_ucred, &p->p_acflag))) 334 return (EPERM); 335 /*fall through*/ 336 case SIOCGLIFADDR: 337 if (!ifp) 338 return EINVAL; 339 return in_lifaddr_ioctl(so, cmd, data, ifp, p); 340 } 341 342 /* 343 * Find address for this interface, if it exists. 344 */ 345 if (ifp) 346 IFP_TO_IA(ifp, ia); 347 348 switch (cmd) { 349 350 case SIOCAIFADDR: 351 case SIOCDIFADDR: 352 case SIOCGIFALIAS: 353 if (ifra->ifra_addr.sin_family == AF_INET) 354 LIST_FOREACH(ia, 355 &IN_IFADDR_HASH(ifra->ifra_addr.sin_addr.s_addr), 356 ia_hash) { 357 if (ia->ia_ifp == ifp && 358 in_hosteq(ia->ia_addr.sin_addr, 359 ifra->ifra_addr.sin_addr)) 360 break; 361 } 362 if (cmd == SIOCDIFADDR) { 363 if (ia == 0) 364 return (EADDRNOTAVAIL); 365 #if 1 /*def COMPAT_43*/ 366 if (ifra->ifra_addr.sin_family == AF_UNSPEC) 367 ifra->ifra_addr.sin_family = AF_INET; 368 #endif 369 } 370 /* FALLTHROUGH */ 371 case SIOCSIFADDR: 372 case SIOCSIFDSTADDR: 373 if (ifra->ifra_addr.sin_family != AF_INET) 374 return (EAFNOSUPPORT); 375 /* FALLTHROUGH */ 376 case SIOCSIFNETMASK: 377 if (ifp == 0) 378 panic("in_control"); 379 380 if (cmd == SIOCGIFALIAS) 381 break; 382 383 if (p == 0 || (error = suser(p->p_ucred, &p->p_acflag))) 384 return (EPERM); 385 386 if (ia == 0) { 387 MALLOC(ia, struct in_ifaddr *, sizeof(*ia), 388 M_IFADDR, M_WAITOK); 389 if (ia == 0) 390 return (ENOBUFS); 391 bzero((caddr_t)ia, sizeof *ia); 392 TAILQ_INSERT_TAIL(&in_ifaddrhead, ia, ia_list); 393 IFAREF(&ia->ia_ifa); 394 TAILQ_INSERT_TAIL(&ifp->if_addrlist, &ia->ia_ifa, 395 ifa_list); 396 IFAREF(&ia->ia_ifa); 397 ia->ia_ifa.ifa_addr = sintosa(&ia->ia_addr); 398 ia->ia_ifa.ifa_dstaddr = sintosa(&ia->ia_dstaddr); 399 ia->ia_ifa.ifa_netmask = sintosa(&ia->ia_sockmask); 400 ia->ia_sockmask.sin_len = 8; 401 if (ifp->if_flags & IFF_BROADCAST) { 402 ia->ia_broadaddr.sin_len = sizeof(ia->ia_addr); 403 ia->ia_broadaddr.sin_family = AF_INET; 404 } 405 ia->ia_ifp = ifp; 406 LIST_INIT(&ia->ia_multiaddrs); 407 } 408 break; 409 410 case SIOCSIFBRDADDR: 411 if (p == 0 || (error = suser(p->p_ucred, &p->p_acflag))) 412 return (EPERM); 413 /* FALLTHROUGH */ 414 415 case SIOCGIFADDR: 416 case SIOCGIFNETMASK: 417 case SIOCGIFDSTADDR: 418 case SIOCGIFBRDADDR: 419 if (ia == 0) 420 return (EADDRNOTAVAIL); 421 break; 422 } 423 switch (cmd) { 424 425 case SIOCGIFADDR: 426 *satosin(&ifr->ifr_addr) = ia->ia_addr; 427 break; 428 429 case SIOCGIFBRDADDR: 430 if ((ifp->if_flags & IFF_BROADCAST) == 0) 431 return (EINVAL); 432 *satosin(&ifr->ifr_dstaddr) = ia->ia_broadaddr; 433 break; 434 435 case SIOCGIFDSTADDR: 436 if ((ifp->if_flags & IFF_POINTOPOINT) == 0) 437 return (EINVAL); 438 *satosin(&ifr->ifr_dstaddr) = ia->ia_dstaddr; 439 break; 440 441 case SIOCGIFNETMASK: 442 *satosin(&ifr->ifr_addr) = ia->ia_sockmask; 443 break; 444 445 case SIOCSIFDSTADDR: 446 if ((ifp->if_flags & IFF_POINTOPOINT) == 0) 447 return (EINVAL); 448 oldaddr = ia->ia_dstaddr; 449 ia->ia_dstaddr = *satosin(&ifr->ifr_dstaddr); 450 if (ifp->if_ioctl && (error = (*ifp->if_ioctl) 451 (ifp, SIOCSIFDSTADDR, (caddr_t)ia))) { 452 ia->ia_dstaddr = oldaddr; 453 return (error); 454 } 455 if (ia->ia_flags & IFA_ROUTE) { 456 ia->ia_ifa.ifa_dstaddr = sintosa(&oldaddr); 457 rtinit(&(ia->ia_ifa), (int)RTM_DELETE, RTF_HOST); 458 ia->ia_ifa.ifa_dstaddr = sintosa(&ia->ia_dstaddr); 459 rtinit(&(ia->ia_ifa), (int)RTM_ADD, RTF_HOST|RTF_UP); 460 } 461 break; 462 463 case SIOCSIFBRDADDR: 464 if ((ifp->if_flags & IFF_BROADCAST) == 0) 465 return (EINVAL); 466 ia->ia_broadaddr = *satosin(&ifr->ifr_broadaddr); 467 break; 468 469 case SIOCSIFADDR: 470 error = in_ifinit(ifp, ia, satosin(&ifr->ifr_addr), 1); 471 #ifdef PFIL_HOOK 472 if (!error) 473 (void)pfil_run_hooks(&if_pfil, 474 (struct mbuf **)SIOCSIFADDR, ifp, PFIL_IFADDR); 475 #endif 476 return error; 477 478 case SIOCSIFNETMASK: 479 in_ifscrub(ifp, ia); 480 ia->ia_sockmask = *satosin(&ifr->ifr_addr); 481 ia->ia_subnetmask = ia->ia_sockmask.sin_addr.s_addr; 482 error = in_ifinit(ifp, ia, NULL, 0); 483 return (error); 484 485 case SIOCAIFADDR: 486 maskIsNew = 0; 487 hostIsNew = 1; 488 error = 0; 489 if (ia->ia_addr.sin_family == AF_INET) { 490 if (ifra->ifra_addr.sin_len == 0) { 491 ifra->ifra_addr = ia->ia_addr; 492 hostIsNew = 0; 493 } else if (in_hosteq(ia->ia_addr.sin_addr, ifra->ifra_addr.sin_addr)) 494 hostIsNew = 0; 495 } 496 if (ifra->ifra_mask.sin_len) { 497 in_ifscrub(ifp, ia); 498 ia->ia_sockmask = ifra->ifra_mask; 499 ia->ia_subnetmask = ia->ia_sockmask.sin_addr.s_addr; 500 maskIsNew = 1; 501 } 502 if ((ifp->if_flags & IFF_POINTOPOINT) && 503 (ifra->ifra_dstaddr.sin_family == AF_INET)) { 504 in_ifscrub(ifp, ia); 505 ia->ia_dstaddr = ifra->ifra_dstaddr; 506 maskIsNew = 1; /* We lie; but the effect's the same */ 507 } 508 if (ifra->ifra_addr.sin_family == AF_INET && 509 (hostIsNew || maskIsNew)) { 510 error = in_ifinit(ifp, ia, &ifra->ifra_addr, 0); 511 } 512 if ((ifp->if_flags & IFF_BROADCAST) && 513 (ifra->ifra_broadaddr.sin_family == AF_INET)) 514 ia->ia_broadaddr = ifra->ifra_broadaddr; 515 return (error); 516 517 case SIOCGIFALIAS: 518 ifra->ifra_mask = ia->ia_sockmask; 519 if ((ifp->if_flags & IFF_POINTOPOINT) && 520 (ia->ia_dstaddr.sin_family == AF_INET)) 521 ifra->ifra_dstaddr = ia->ia_dstaddr; 522 else if ((ifp->if_flags & IFF_BROADCAST) && 523 (ia->ia_broadaddr.sin_family == AF_INET)) 524 ifra->ifra_broadaddr = ia->ia_broadaddr; 525 else 526 bzero(&ifra->ifra_broadaddr, 527 sizeof(ifra->ifra_broadaddr)); 528 #ifdef PFIL_HOOK 529 (void)pfil_run_hooks(&if_pfil, 530 (struct mbuf **)SIOCGIFALIAS, ifp, PFIL_IFADDR); 531 #endif 532 return 0; 533 534 case SIOCDIFADDR: 535 in_purgeaddr(&ia->ia_ifa, ifp); 536 #ifdef PFIL_HOOK 537 (void)pfil_run_hooks(&if_pfil, (struct mbuf **)SIOCDIFADDR, 538 ifp, PFIL_IFADDR); 539 #endif 540 break; 541 542 #ifdef MROUTING 543 case SIOCGETVIFCNT: 544 case SIOCGETSGCNT: 545 return (mrt_ioctl(so, cmd, data)); 546 #endif /* MROUTING */ 547 548 default: 549 if (ifp == 0 || ifp->if_ioctl == 0) 550 return (EOPNOTSUPP); 551 error = (*ifp->if_ioctl)(ifp, cmd, data); 552 in_setmaxmtu(); 553 return (error); 554 } 555 return (0); 556 } 557 558 void 559 in_purgeaddr(ifa, ifp) 560 struct ifaddr *ifa; 561 struct ifnet *ifp; 562 { 563 struct in_ifaddr *ia = (void *) ifa; 564 565 in_ifscrub(ifp, ia); 566 LIST_REMOVE(ia, ia_hash); 567 TAILQ_REMOVE(&ifp->if_addrlist, &ia->ia_ifa, ifa_list); 568 IFAFREE(&ia->ia_ifa); 569 TAILQ_REMOVE(&in_ifaddrhead, ia, ia_list); 570 if (ia->ia_allhosts != NULL) 571 in_delmulti(ia->ia_allhosts); 572 IFAFREE(&ia->ia_ifa); 573 in_setmaxmtu(); 574 } 575 576 void 577 in_purgeif(ifp) 578 struct ifnet *ifp; 579 { 580 struct ifaddr *ifa, *nifa; 581 582 for (ifa = TAILQ_FIRST(&ifp->if_addrlist); ifa != NULL; ifa = nifa) { 583 nifa = TAILQ_NEXT(ifa, ifa_list); 584 if (ifa->ifa_addr->sa_family != AF_INET) 585 continue; 586 in_purgeaddr(ifa, ifp); 587 } 588 589 igmp_purgeif(ifp); 590 #ifdef MROUTING 591 ip_mrouter_detach(ifp); 592 #endif 593 } 594 595 /* 596 * SIOC[GAD]LIFADDR. 597 * SIOCGLIFADDR: get first address. (???) 598 * SIOCGLIFADDR with IFLR_PREFIX: 599 * get first address that matches the specified prefix. 600 * SIOCALIFADDR: add the specified address. 601 * SIOCALIFADDR with IFLR_PREFIX: 602 * EINVAL since we can't deduce hostid part of the address. 603 * SIOCDLIFADDR: delete the specified address. 604 * SIOCDLIFADDR with IFLR_PREFIX: 605 * delete the first address that matches the specified prefix. 606 * return values: 607 * EINVAL on invalid parameters 608 * EADDRNOTAVAIL on prefix match failed/specified address not found 609 * other values may be returned from in_ioctl() 610 */ 611 static int 612 in_lifaddr_ioctl(so, cmd, data, ifp, p) 613 struct socket *so; 614 u_long cmd; 615 caddr_t data; 616 struct ifnet *ifp; 617 struct proc *p; 618 { 619 struct if_laddrreq *iflr = (struct if_laddrreq *)data; 620 struct ifaddr *ifa; 621 struct sockaddr *sa; 622 623 /* sanity checks */ 624 if (!data || !ifp) { 625 panic("invalid argument to in_lifaddr_ioctl"); 626 /*NOTRECHED*/ 627 } 628 629 switch (cmd) { 630 case SIOCGLIFADDR: 631 /* address must be specified on GET with IFLR_PREFIX */ 632 if ((iflr->flags & IFLR_PREFIX) == 0) 633 break; 634 /*FALLTHROUGH*/ 635 case SIOCALIFADDR: 636 case SIOCDLIFADDR: 637 /* address must be specified on ADD and DELETE */ 638 sa = (struct sockaddr *)&iflr->addr; 639 if (sa->sa_family != AF_INET) 640 return EINVAL; 641 if (sa->sa_len != sizeof(struct sockaddr_in)) 642 return EINVAL; 643 /* XXX need improvement */ 644 sa = (struct sockaddr *)&iflr->dstaddr; 645 if (sa->sa_family 646 && sa->sa_family != AF_INET) 647 return EINVAL; 648 if (sa->sa_len && sa->sa_len != sizeof(struct sockaddr_in)) 649 return EINVAL; 650 break; 651 default: /*shouldn't happen*/ 652 #if 0 653 panic("invalid cmd to in_lifaddr_ioctl"); 654 /*NOTREACHED*/ 655 #else 656 return EOPNOTSUPP; 657 #endif 658 } 659 if (sizeof(struct in_addr) * 8 < iflr->prefixlen) 660 return EINVAL; 661 662 switch (cmd) { 663 case SIOCALIFADDR: 664 { 665 struct in_aliasreq ifra; 666 667 if (iflr->flags & IFLR_PREFIX) 668 return EINVAL; 669 670 /* copy args to in_aliasreq, perform ioctl(SIOCAIFADDR_IN). */ 671 bzero(&ifra, sizeof(ifra)); 672 bcopy(iflr->iflr_name, ifra.ifra_name, 673 sizeof(ifra.ifra_name)); 674 675 bcopy(&iflr->addr, &ifra.ifra_addr, 676 ((struct sockaddr *)&iflr->addr)->sa_len); 677 678 if (((struct sockaddr *)&iflr->dstaddr)->sa_family) { /*XXX*/ 679 bcopy(&iflr->dstaddr, &ifra.ifra_dstaddr, 680 ((struct sockaddr *)&iflr->dstaddr)->sa_len); 681 } 682 683 ifra.ifra_mask.sin_family = AF_INET; 684 ifra.ifra_mask.sin_len = sizeof(struct sockaddr_in); 685 in_len2mask(&ifra.ifra_mask.sin_addr, iflr->prefixlen); 686 687 return in_control(so, SIOCAIFADDR, (caddr_t)&ifra, ifp, p); 688 } 689 case SIOCGLIFADDR: 690 case SIOCDLIFADDR: 691 { 692 struct in_ifaddr *ia; 693 struct in_addr mask, candidate, match; 694 struct sockaddr_in *sin; 695 int cmp; 696 697 bzero(&mask, sizeof(mask)); 698 if (iflr->flags & IFLR_PREFIX) { 699 /* lookup a prefix rather than address. */ 700 in_len2mask(&mask, iflr->prefixlen); 701 702 sin = (struct sockaddr_in *)&iflr->addr; 703 match.s_addr = sin->sin_addr.s_addr; 704 match.s_addr &= mask.s_addr; 705 706 /* if you set extra bits, that's wrong */ 707 if (match.s_addr != sin->sin_addr.s_addr) 708 return EINVAL; 709 710 cmp = 1; 711 } else { 712 if (cmd == SIOCGLIFADDR) { 713 /* on getting an address, take the 1st match */ 714 cmp = 0; /*XXX*/ 715 } else { 716 /* on deleting an address, do exact match */ 717 in_len2mask(&mask, 32); 718 sin = (struct sockaddr_in *)&iflr->addr; 719 match.s_addr = sin->sin_addr.s_addr; 720 721 cmp = 1; 722 } 723 } 724 725 TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list) { 726 if (ifa->ifa_addr->sa_family != AF_INET) 727 continue; 728 if (!cmp) 729 break; 730 candidate.s_addr = ((struct sockaddr_in *)&ifa->ifa_addr)->sin_addr.s_addr; 731 candidate.s_addr &= mask.s_addr; 732 if (candidate.s_addr == match.s_addr) 733 break; 734 } 735 if (!ifa) 736 return EADDRNOTAVAIL; 737 ia = (struct in_ifaddr *)ifa; 738 739 if (cmd == SIOCGLIFADDR) { 740 /* fill in the if_laddrreq structure */ 741 bcopy(&ia->ia_addr, &iflr->addr, ia->ia_addr.sin_len); 742 743 if ((ifp->if_flags & IFF_POINTOPOINT) != 0) { 744 bcopy(&ia->ia_dstaddr, &iflr->dstaddr, 745 ia->ia_dstaddr.sin_len); 746 } else 747 bzero(&iflr->dstaddr, sizeof(iflr->dstaddr)); 748 749 iflr->prefixlen = 750 in_mask2len(&ia->ia_sockmask.sin_addr); 751 752 iflr->flags = 0; /*XXX*/ 753 754 return 0; 755 } else { 756 struct in_aliasreq ifra; 757 758 /* fill in_aliasreq and do ioctl(SIOCDIFADDR_IN) */ 759 bzero(&ifra, sizeof(ifra)); 760 bcopy(iflr->iflr_name, ifra.ifra_name, 761 sizeof(ifra.ifra_name)); 762 763 bcopy(&ia->ia_addr, &ifra.ifra_addr, 764 ia->ia_addr.sin_len); 765 if ((ifp->if_flags & IFF_POINTOPOINT) != 0) { 766 bcopy(&ia->ia_dstaddr, &ifra.ifra_dstaddr, 767 ia->ia_dstaddr.sin_len); 768 } 769 bcopy(&ia->ia_sockmask, &ifra.ifra_dstaddr, 770 ia->ia_sockmask.sin_len); 771 772 return in_control(so, SIOCDIFADDR, (caddr_t)&ifra, 773 ifp, p); 774 } 775 } 776 } 777 778 return EOPNOTSUPP; /*just for safety*/ 779 } 780 781 /* 782 * Delete any existing route for an interface. 783 */ 784 void 785 in_ifscrub(ifp, ia) 786 struct ifnet *ifp; 787 struct in_ifaddr *ia; 788 { 789 790 in_scrubprefix(ia); 791 } 792 793 /* 794 * Initialize an interface's internet address 795 * and routing table entry. 796 */ 797 int 798 in_ifinit(ifp, ia, sin, scrub) 799 struct ifnet *ifp; 800 struct in_ifaddr *ia; 801 struct sockaddr_in *sin; 802 int scrub; 803 { 804 u_int32_t i; 805 struct sockaddr_in oldaddr; 806 int s = splnet(), flags = RTF_UP, error; 807 808 if (!sin) 809 sin = &ia->ia_addr; 810 811 /* 812 * Set up new addresses. 813 */ 814 oldaddr = ia->ia_addr; 815 if (ia->ia_addr.sin_family == AF_INET) 816 LIST_REMOVE(ia, ia_hash); 817 ia->ia_addr = *sin; 818 LIST_INSERT_HEAD(&IN_IFADDR_HASH(ia->ia_addr.sin_addr.s_addr), ia, ia_hash); 819 820 /* 821 * Give the interface a chance to initialize 822 * if this is its first address, 823 * and to validate the address if necessary. 824 */ 825 if (ifp->if_ioctl && 826 (error = (*ifp->if_ioctl)(ifp, SIOCSIFADDR, (caddr_t)ia))) 827 goto bad; 828 splx(s); 829 if (scrub) { 830 ia->ia_ifa.ifa_addr = sintosa(&oldaddr); 831 in_ifscrub(ifp, ia); 832 ia->ia_ifa.ifa_addr = sintosa(&ia->ia_addr); 833 } 834 835 i = ia->ia_addr.sin_addr.s_addr; 836 if (IN_CLASSA(i)) 837 ia->ia_netmask = IN_CLASSA_NET; 838 else if (IN_CLASSB(i)) 839 ia->ia_netmask = IN_CLASSB_NET; 840 else 841 ia->ia_netmask = IN_CLASSC_NET; 842 /* 843 * The subnet mask usually includes at least the standard network part, 844 * but may may be smaller in the case of supernetting. 845 * If it is set, we believe it. 846 */ 847 if (ia->ia_subnetmask == 0) { 848 ia->ia_subnetmask = ia->ia_netmask; 849 ia->ia_sockmask.sin_addr.s_addr = ia->ia_subnetmask; 850 } else 851 ia->ia_netmask &= ia->ia_subnetmask; 852 853 ia->ia_net = i & ia->ia_netmask; 854 ia->ia_subnet = i & ia->ia_subnetmask; 855 in_socktrim(&ia->ia_sockmask); 856 /* re-calculate the "in_maxmtu" value */ 857 in_setmaxmtu(); 858 /* 859 * Add route for the network. 860 */ 861 ia->ia_ifa.ifa_metric = ifp->if_metric; 862 if (ifp->if_flags & IFF_BROADCAST) { 863 ia->ia_broadaddr.sin_addr.s_addr = 864 ia->ia_subnet | ~ia->ia_subnetmask; 865 ia->ia_netbroadcast.s_addr = 866 ia->ia_net | ~ia->ia_netmask; 867 } else if (ifp->if_flags & IFF_LOOPBACK) { 868 ia->ia_dstaddr = ia->ia_addr; 869 flags |= RTF_HOST; 870 } else if (ifp->if_flags & IFF_POINTOPOINT) { 871 if (ia->ia_dstaddr.sin_family != AF_INET) 872 return (0); 873 flags |= RTF_HOST; 874 } 875 error = in_addprefix(ia, flags); 876 /* 877 * If the interface supports multicast, join the "all hosts" 878 * multicast group on that interface. 879 */ 880 if ((ifp->if_flags & IFF_MULTICAST) != 0 && ia->ia_allhosts == NULL) { 881 struct in_addr addr; 882 883 addr.s_addr = INADDR_ALLHOSTS_GROUP; 884 ia->ia_allhosts = in_addmulti(&addr, ifp); 885 } 886 return (error); 887 bad: 888 splx(s); 889 LIST_REMOVE(ia, ia_hash); 890 ia->ia_addr = oldaddr; 891 if (ia->ia_addr.sin_family == AF_INET) 892 LIST_INSERT_HEAD(&IN_IFADDR_HASH(ia->ia_addr.sin_addr.s_addr), 893 ia, ia_hash); 894 return (error); 895 } 896 897 #define rtinitflags(x) \ 898 ((((x)->ia_ifp->if_flags & (IFF_LOOPBACK | IFF_POINTOPOINT)) != 0) \ 899 ? RTF_HOST : 0) 900 901 /* 902 * add a route to prefix ("connected route" in cisco terminology). 903 * does nothing if there's some interface address with the same prefix already. 904 */ 905 static int 906 in_addprefix(target, flags) 907 struct in_ifaddr *target; 908 int flags; 909 { 910 struct in_ifaddr *ia; 911 struct in_addr prefix, mask, p; 912 int error; 913 914 if ((flags & RTF_HOST) != 0) 915 prefix = target->ia_dstaddr.sin_addr; 916 else { 917 prefix = target->ia_addr.sin_addr; 918 mask = target->ia_sockmask.sin_addr; 919 prefix.s_addr &= mask.s_addr; 920 } 921 922 TAILQ_FOREACH(ia, &in_ifaddrhead, ia_list) { 923 if (rtinitflags(ia)) 924 p = ia->ia_dstaddr.sin_addr; 925 else { 926 p = ia->ia_addr.sin_addr; 927 p.s_addr &= ia->ia_sockmask.sin_addr.s_addr; 928 } 929 930 if (prefix.s_addr != p.s_addr) 931 continue; 932 933 /* 934 * if we got a matching prefix route inserted by other 935 * interface address, we don't need to bother 936 */ 937 if (ia->ia_flags & IFA_ROUTE) 938 return 0; 939 } 940 941 /* 942 * noone seem to have prefix route. insert it. 943 */ 944 error = rtinit(&target->ia_ifa, (int)RTM_ADD, flags); 945 if (!error) 946 target->ia_flags |= IFA_ROUTE; 947 return error; 948 } 949 950 /* 951 * remove a route to prefix ("connected route" in cisco terminology). 952 * re-installs the route by using another interface address, if there's one 953 * with the same prefix (otherwise we lose the route mistakenly). 954 */ 955 static int 956 in_scrubprefix(target) 957 struct in_ifaddr *target; 958 { 959 struct in_ifaddr *ia; 960 struct in_addr prefix, mask, p; 961 int error; 962 963 if ((target->ia_flags & IFA_ROUTE) == 0) 964 return 0; 965 966 if (rtinitflags(target)) 967 prefix = target->ia_dstaddr.sin_addr; 968 else { 969 prefix = target->ia_addr.sin_addr; 970 mask = target->ia_sockmask.sin_addr; 971 prefix.s_addr &= mask.s_addr; 972 } 973 974 TAILQ_FOREACH(ia, &in_ifaddrhead, ia_list) { 975 if (rtinitflags(ia)) 976 p = ia->ia_dstaddr.sin_addr; 977 else { 978 p = ia->ia_addr.sin_addr; 979 p.s_addr &= ia->ia_sockmask.sin_addr.s_addr; 980 } 981 982 if (prefix.s_addr != p.s_addr) 983 continue; 984 985 /* 986 * if we got a matching prefix route, move IFA_ROUTE to him 987 */ 988 if ((ia->ia_flags & IFA_ROUTE) == 0) { 989 rtinit(&(target->ia_ifa), (int)RTM_DELETE, 990 rtinitflags(target)); 991 target->ia_flags &= ~IFA_ROUTE; 992 993 error = rtinit(&ia->ia_ifa, (int)RTM_ADD, 994 rtinitflags(ia) | RTF_UP); 995 if (error == 0) 996 ia->ia_flags |= IFA_ROUTE; 997 return error; 998 } 999 } 1000 1001 /* 1002 * noone seem to have prefix route. remove it. 1003 */ 1004 rtinit(&(target->ia_ifa), (int)RTM_DELETE, rtinitflags(target)); 1005 target->ia_flags &= ~IFA_ROUTE; 1006 return 0; 1007 } 1008 1009 #undef rtinitflags 1010 1011 /* 1012 * Return 1 if the address might be a local broadcast address. 1013 */ 1014 int 1015 in_broadcast(in, ifp) 1016 struct in_addr in; 1017 struct ifnet *ifp; 1018 { 1019 struct ifaddr *ifa; 1020 1021 if (in.s_addr == INADDR_BROADCAST || 1022 in_nullhost(in)) 1023 return 1; 1024 if ((ifp->if_flags & IFF_BROADCAST) == 0) 1025 return 0; 1026 /* 1027 * Look through the list of addresses for a match 1028 * with a broadcast address. 1029 */ 1030 #define ia (ifatoia(ifa)) 1031 TAILQ_FOREACH(ifa, &ifp->if_addrlist, ifa_list) 1032 if (ifa->ifa_addr->sa_family == AF_INET && 1033 !in_hosteq(in, ia->ia_addr.sin_addr) && 1034 (in_hosteq(in, ia->ia_broadaddr.sin_addr) || 1035 in_hosteq(in, ia->ia_netbroadcast) || 1036 (hostzeroisbroadcast && 1037 /* 1038 * Check for old-style (host 0) broadcast. 1039 */ 1040 (in.s_addr == ia->ia_subnet || 1041 in.s_addr == ia->ia_net)))) 1042 return 1; 1043 return (0); 1044 #undef ia 1045 } 1046 1047 /* 1048 * Add an address to the list of IP multicast addresses for a given interface. 1049 */ 1050 struct in_multi * 1051 in_addmulti(ap, ifp) 1052 struct in_addr *ap; 1053 struct ifnet *ifp; 1054 { 1055 struct in_multi *inm; 1056 struct ifreq ifr; 1057 int s = splsoftnet(); 1058 1059 /* 1060 * See if address already in list. 1061 */ 1062 IN_LOOKUP_MULTI(*ap, ifp, inm); 1063 if (inm != NULL) { 1064 /* 1065 * Found it; just increment the reference count. 1066 */ 1067 ++inm->inm_refcount; 1068 } else { 1069 /* 1070 * New address; allocate a new multicast record 1071 * and link it into the interface's multicast list. 1072 */ 1073 inm = pool_get(&inmulti_pool, PR_NOWAIT); 1074 if (inm == NULL) { 1075 splx(s); 1076 return (NULL); 1077 } 1078 inm->inm_addr = *ap; 1079 inm->inm_ifp = ifp; 1080 inm->inm_refcount = 1; 1081 LIST_INSERT_HEAD( 1082 &IN_MULTI_HASH(inm->inm_addr.s_addr, ifp), 1083 inm, inm_list); 1084 /* 1085 * Ask the network driver to update its multicast reception 1086 * filter appropriately for the new address. 1087 */ 1088 satosin(&ifr.ifr_addr)->sin_len = sizeof(struct sockaddr_in); 1089 satosin(&ifr.ifr_addr)->sin_family = AF_INET; 1090 satosin(&ifr.ifr_addr)->sin_addr = *ap; 1091 if ((ifp->if_ioctl == NULL) || 1092 (*ifp->if_ioctl)(ifp, SIOCADDMULTI,(caddr_t)&ifr) != 0) { 1093 LIST_REMOVE(inm, inm_list); 1094 pool_put(&inmulti_pool, inm); 1095 splx(s); 1096 return (NULL); 1097 } 1098 /* 1099 * Let IGMP know that we have joined a new IP multicast group. 1100 */ 1101 if (igmp_joingroup(inm) != 0) { 1102 LIST_REMOVE(inm, inm_list); 1103 pool_put(&inmulti_pool, inm); 1104 splx(s); 1105 return (NULL); 1106 } 1107 in_multientries++; 1108 } 1109 splx(s); 1110 return (inm); 1111 } 1112 1113 /* 1114 * Delete a multicast address record. 1115 */ 1116 void 1117 in_delmulti(inm) 1118 struct in_multi *inm; 1119 { 1120 struct ifreq ifr; 1121 int s = splsoftnet(); 1122 1123 if (--inm->inm_refcount == 0) { 1124 /* 1125 * No remaining claims to this record; let IGMP know that 1126 * we are leaving the multicast group. 1127 */ 1128 igmp_leavegroup(inm); 1129 /* 1130 * Unlink from list. 1131 */ 1132 LIST_REMOVE(inm, inm_list); 1133 in_multientries--; 1134 /* 1135 * Notify the network driver to update its multicast reception 1136 * filter. 1137 */ 1138 satosin(&ifr.ifr_addr)->sin_family = AF_INET; 1139 satosin(&ifr.ifr_addr)->sin_addr = inm->inm_addr; 1140 (*inm->inm_ifp->if_ioctl)(inm->inm_ifp, SIOCDELMULTI, 1141 (caddr_t)&ifr); 1142 pool_put(&inmulti_pool, inm); 1143 } 1144 splx(s); 1145 } 1146 #endif 1147