in.c revision 1.117
1 /* $NetBSD: in.c,v 1.117 2007/04/15 06:15:58 dyoung 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.117 2007/04/15 06:15:58 dyoung 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/sysctl.h> 115 #include <sys/systm.h> 116 #include <sys/proc.h> 117 #include <sys/syslog.h> 118 #include <sys/kauth.h> 119 120 #include <net/if.h> 121 #include <net/route.h> 122 123 #include <net/if_ether.h> 124 125 #include <netinet/in_systm.h> 126 #include <netinet/in.h> 127 #include <netinet/in_var.h> 128 #include <netinet/ip.h> 129 #include <netinet/ip_var.h> 130 #include <netinet/in_ifattach.h> 131 #include <netinet/in_pcb.h> 132 #include <netinet/if_inarp.h> 133 #include <netinet/ip_mroute.h> 134 #include <netinet/igmp_var.h> 135 136 #ifdef IPSELSRC 137 #include <netinet/in_selsrc.h> 138 #endif 139 140 #ifdef PFIL_HOOKS 141 #include <net/pfil.h> 142 #endif 143 144 #ifdef INET 145 static u_int in_mask2len(struct in_addr *); 146 static void in_len2mask(struct in_addr *, u_int); 147 static int in_lifaddr_ioctl(struct socket *, u_long, void *, 148 struct ifnet *, struct lwp *); 149 150 static int in_ifaddrpref_ioctl(struct socket *, u_long, void *, 151 struct ifnet *); 152 static int in_addprefix(struct in_ifaddr *, int); 153 static int in_scrubprefix(struct in_ifaddr *); 154 155 #ifndef SUBNETSARELOCAL 156 #define SUBNETSARELOCAL 1 157 #endif 158 159 #ifndef HOSTZEROBROADCAST 160 #define HOSTZEROBROADCAST 1 161 #endif 162 163 int subnetsarelocal = SUBNETSARELOCAL; 164 int hostzeroisbroadcast = HOSTZEROBROADCAST; 165 166 /* 167 * This list is used to keep track of in_multi chains which belong to 168 * deleted interface addresses. We use in_ifaddr so that a chain head 169 * won't be deallocated until all multicast address record are deleted. 170 */ 171 static TAILQ_HEAD(, in_ifaddr) in_mk = TAILQ_HEAD_INITIALIZER(in_mk); 172 173 /* 174 * Return 1 if an internet address is for a ``local'' host 175 * (one to which we have a connection). If subnetsarelocal 176 * is true, this includes other subnets of the local net. 177 * Otherwise, it includes only the directly-connected (sub)nets. 178 */ 179 int 180 in_localaddr(struct in_addr in) 181 { 182 struct in_ifaddr *ia; 183 184 if (subnetsarelocal) { 185 TAILQ_FOREACH(ia, &in_ifaddrhead, ia_list) 186 if ((in.s_addr & ia->ia_netmask) == ia->ia_net) 187 return (1); 188 } else { 189 TAILQ_FOREACH(ia, &in_ifaddrhead, ia_list) 190 if ((in.s_addr & ia->ia_subnetmask) == ia->ia_subnet) 191 return (1); 192 } 193 return (0); 194 } 195 196 /* 197 * Determine whether an IP address is in a reserved set of addresses 198 * that may not be forwarded, or whether datagrams to that destination 199 * may be forwarded. 200 */ 201 int 202 in_canforward(struct in_addr in) 203 { 204 u_int32_t net; 205 206 if (IN_EXPERIMENTAL(in.s_addr) || IN_MULTICAST(in.s_addr)) 207 return (0); 208 if (IN_CLASSA(in.s_addr)) { 209 net = in.s_addr & IN_CLASSA_NET; 210 if (net == 0 || net == htonl(IN_LOOPBACKNET << IN_CLASSA_NSHIFT)) 211 return (0); 212 } 213 return (1); 214 } 215 216 /* 217 * Trim a mask in a sockaddr 218 */ 219 void 220 in_socktrim(struct sockaddr_in *ap) 221 { 222 char *cplim = (char *) &ap->sin_addr; 223 char *cp = (char *) (&ap->sin_addr + 1); 224 225 ap->sin_len = 0; 226 while (--cp >= cplim) 227 if (*cp) { 228 (ap)->sin_len = cp - (char *) (ap) + 1; 229 break; 230 } 231 } 232 233 /* 234 * Routine to take an Internet address and convert into a 235 * "dotted quad" representation for printing. 236 */ 237 const char * 238 in_fmtaddr(struct in_addr addr) 239 { 240 static char buf[sizeof("123.456.789.123")]; 241 242 addr.s_addr = ntohl(addr.s_addr); 243 244 snprintf(buf, sizeof(buf), "%d.%d.%d.%d", 245 (addr.s_addr >> 24) & 0xFF, 246 (addr.s_addr >> 16) & 0xFF, 247 (addr.s_addr >> 8) & 0xFF, 248 (addr.s_addr >> 0) & 0xFF); 249 return buf; 250 } 251 252 /* 253 * Maintain the "in_maxmtu" variable, which is the largest 254 * mtu for non-local interfaces with AF_INET addresses assigned 255 * to them that are up. 256 */ 257 unsigned long in_maxmtu; 258 259 void 260 in_setmaxmtu(void) 261 { 262 struct in_ifaddr *ia; 263 struct ifnet *ifp; 264 unsigned long maxmtu = 0; 265 266 TAILQ_FOREACH(ia, &in_ifaddrhead, ia_list) { 267 if ((ifp = ia->ia_ifp) == 0) 268 continue; 269 if ((ifp->if_flags & (IFF_UP|IFF_LOOPBACK)) != IFF_UP) 270 continue; 271 if (ifp->if_mtu > maxmtu) 272 maxmtu = ifp->if_mtu; 273 } 274 if (maxmtu) 275 in_maxmtu = maxmtu; 276 } 277 278 static u_int 279 in_mask2len(struct in_addr *mask) 280 { 281 u_int x, y; 282 u_char *p; 283 284 p = (u_char *)mask; 285 for (x = 0; x < sizeof(*mask); x++) { 286 if (p[x] != 0xff) 287 break; 288 } 289 y = 0; 290 if (x < sizeof(*mask)) { 291 for (y = 0; y < 8; y++) { 292 if ((p[x] & (0x80 >> y)) == 0) 293 break; 294 } 295 } 296 return x * 8 + y; 297 } 298 299 static void 300 in_len2mask(struct in_addr *mask, u_int len) 301 { 302 u_int i; 303 u_char *p; 304 305 p = (u_char *)mask; 306 bzero(mask, sizeof(*mask)); 307 for (i = 0; i < len / 8; i++) 308 p[i] = 0xff; 309 if (len % 8) 310 p[i] = (0xff00 >> (len % 8)) & 0xff; 311 } 312 313 /* 314 * Generic internet control operations (ioctl's). 315 * Ifp is 0 if not an interface-specific ioctl. 316 */ 317 /* ARGSUSED */ 318 int 319 in_control(struct socket *so, u_long cmd, void *data, struct ifnet *ifp, 320 struct lwp *l) 321 { 322 struct ifreq *ifr = (struct ifreq *)data; 323 struct in_ifaddr *ia = 0; 324 struct in_aliasreq *ifra = (struct in_aliasreq *)data; 325 struct sockaddr_in oldaddr; 326 int error, hostIsNew, maskIsNew; 327 int newifaddr = 0; 328 329 switch (cmd) { 330 case SIOCALIFADDR: 331 case SIOCDLIFADDR: 332 case SIOCSIFADDRPREF: 333 if (l == NULL) 334 return (EPERM); 335 if (kauth_authorize_network(l->l_cred, KAUTH_NETWORK_INTERFACE, 336 KAUTH_REQ_NETWORK_INTERFACE_SETPRIV, ifp, (void *)cmd, 337 NULL) != 0) 338 return (EPERM); 339 /*FALLTHROUGH*/ 340 case SIOCGIFADDRPREF: 341 case SIOCGLIFADDR: 342 if (ifp == NULL) 343 return EINVAL; 344 if (cmd == SIOCGIFADDRPREF || cmd == SIOCSIFADDRPREF) 345 return in_ifaddrpref_ioctl(so, cmd, data, ifp); 346 else 347 return in_lifaddr_ioctl(so, cmd, data, ifp, l); 348 } 349 350 /* 351 * Find address for this interface, if it exists. 352 */ 353 if (ifp != NULL) 354 IFP_TO_IA(ifp, ia); 355 356 switch (cmd) { 357 358 case SIOCAIFADDR: 359 case SIOCDIFADDR: 360 case SIOCGIFALIAS: 361 if (ifra->ifra_addr.sin_family == AF_INET) 362 LIST_FOREACH(ia, 363 &IN_IFADDR_HASH(ifra->ifra_addr.sin_addr.s_addr), 364 ia_hash) { 365 if (ia->ia_ifp == ifp && 366 in_hosteq(ia->ia_addr.sin_addr, 367 ifra->ifra_addr.sin_addr)) 368 break; 369 } 370 if ((cmd == SIOCDIFADDR || cmd == SIOCGIFALIAS) && ia == NULL) 371 return (EADDRNOTAVAIL); 372 373 #if 1 /*def COMPAT_43*/ 374 if (cmd == SIOCDIFADDR && 375 ifra->ifra_addr.sin_family == AF_UNSPEC) { 376 ifra->ifra_addr.sin_family = AF_INET; 377 } 378 #endif 379 /* FALLTHROUGH */ 380 case SIOCSIFADDR: 381 case SIOCSIFDSTADDR: 382 if (ifra->ifra_addr.sin_family != AF_INET) 383 return (EAFNOSUPPORT); 384 /* FALLTHROUGH */ 385 case SIOCSIFNETMASK: 386 if (ifp == NULL) 387 panic("in_control"); 388 389 if (cmd == SIOCGIFALIAS) 390 break; 391 392 if (ia == NULL && 393 (cmd == SIOCSIFNETMASK || cmd == SIOCSIFDSTADDR)) 394 return (EADDRNOTAVAIL); 395 396 if (l == NULL) 397 return (EPERM); 398 if (kauth_authorize_network(l->l_cred, KAUTH_NETWORK_INTERFACE, 399 KAUTH_REQ_NETWORK_INTERFACE_SETPRIV, ifp, (void *)cmd, 400 NULL) != 0) 401 return (EPERM); 402 403 if (ia == 0) { 404 MALLOC(ia, struct in_ifaddr *, sizeof(*ia), 405 M_IFADDR, M_WAITOK); 406 if (ia == 0) 407 return (ENOBUFS); 408 bzero((void *)ia, sizeof *ia); 409 TAILQ_INSERT_TAIL(&in_ifaddrhead, ia, ia_list); 410 IFAREF(&ia->ia_ifa); 411 TAILQ_INSERT_TAIL(&ifp->if_addrlist, &ia->ia_ifa, 412 ifa_list); 413 IFAREF(&ia->ia_ifa); 414 ia->ia_ifa.ifa_addr = sintosa(&ia->ia_addr); 415 ia->ia_ifa.ifa_dstaddr = sintosa(&ia->ia_dstaddr); 416 ia->ia_ifa.ifa_netmask = sintosa(&ia->ia_sockmask); 417 #ifdef IPSELSRC 418 ia->ia_ifa.ifa_getifa = in_getifa; 419 #else /* IPSELSRC */ 420 ia->ia_ifa.ifa_getifa = NULL; 421 #endif /* IPSELSRC */ 422 ia->ia_sockmask.sin_len = 8; 423 if (ifp->if_flags & IFF_BROADCAST) { 424 ia->ia_broadaddr.sin_len = sizeof(ia->ia_addr); 425 ia->ia_broadaddr.sin_family = AF_INET; 426 } 427 ia->ia_ifp = ifp; 428 LIST_INIT(&ia->ia_multiaddrs); 429 newifaddr = 1; 430 } 431 break; 432 433 case SIOCSIFBRDADDR: 434 if (l == NULL) 435 return (EPERM); 436 if (kauth_authorize_network(l->l_cred, KAUTH_NETWORK_INTERFACE, 437 KAUTH_REQ_NETWORK_INTERFACE_SETPRIV, ifp, (void *)cmd, 438 NULL) != 0) 439 return (EPERM); 440 /* FALLTHROUGH */ 441 442 case SIOCGIFADDR: 443 case SIOCGIFNETMASK: 444 case SIOCGIFDSTADDR: 445 case SIOCGIFBRDADDR: 446 if (ia == 0) 447 return (EADDRNOTAVAIL); 448 break; 449 } 450 error = 0; 451 switch (cmd) { 452 453 case SIOCGIFADDR: 454 *satosin(&ifr->ifr_addr) = ia->ia_addr; 455 break; 456 457 case SIOCGIFBRDADDR: 458 if ((ifp->if_flags & IFF_BROADCAST) == 0) 459 return (EINVAL); 460 *satosin(&ifr->ifr_dstaddr) = ia->ia_broadaddr; 461 break; 462 463 case SIOCGIFDSTADDR: 464 if ((ifp->if_flags & IFF_POINTOPOINT) == 0) 465 return (EINVAL); 466 *satosin(&ifr->ifr_dstaddr) = ia->ia_dstaddr; 467 break; 468 469 case SIOCGIFNETMASK: 470 *satosin(&ifr->ifr_addr) = ia->ia_sockmask; 471 break; 472 473 case SIOCSIFDSTADDR: 474 if ((ifp->if_flags & IFF_POINTOPOINT) == 0) 475 return (EINVAL); 476 oldaddr = ia->ia_dstaddr; 477 ia->ia_dstaddr = *satosin(&ifr->ifr_dstaddr); 478 if (ifp->if_ioctl != NULL && 479 (error = (*ifp->if_ioctl)(ifp, SIOCSIFDSTADDR, 480 (void *)ia)) != 0) { 481 ia->ia_dstaddr = oldaddr; 482 return error; 483 } 484 if (ia->ia_flags & IFA_ROUTE) { 485 ia->ia_ifa.ifa_dstaddr = sintosa(&oldaddr); 486 rtinit(&ia->ia_ifa, RTM_DELETE, RTF_HOST); 487 ia->ia_ifa.ifa_dstaddr = sintosa(&ia->ia_dstaddr); 488 rtinit(&ia->ia_ifa, RTM_ADD, RTF_HOST|RTF_UP); 489 } 490 break; 491 492 case SIOCSIFBRDADDR: 493 if ((ifp->if_flags & IFF_BROADCAST) == 0) 494 return EINVAL; 495 ia->ia_broadaddr = *satosin(&ifr->ifr_broadaddr); 496 break; 497 498 case SIOCSIFADDR: 499 error = in_ifinit(ifp, ia, satosin(&ifr->ifr_addr), 1); 500 #ifdef PFIL_HOOKS 501 if (error == 0) 502 (void)pfil_run_hooks(&if_pfil, 503 (struct mbuf **)SIOCSIFADDR, ifp, PFIL_IFADDR); 504 #endif 505 break; 506 507 case SIOCSIFNETMASK: 508 in_ifscrub(ifp, ia); 509 ia->ia_sockmask = *satosin(&ifr->ifr_addr); 510 ia->ia_subnetmask = ia->ia_sockmask.sin_addr.s_addr; 511 error = in_ifinit(ifp, ia, NULL, 0); 512 break; 513 514 case SIOCAIFADDR: 515 maskIsNew = 0; 516 hostIsNew = 1; 517 if (ia->ia_addr.sin_family != AF_INET) 518 ; 519 else if (ifra->ifra_addr.sin_len == 0) { 520 ifra->ifra_addr = ia->ia_addr; 521 hostIsNew = 0; 522 } else if (in_hosteq(ia->ia_addr.sin_addr, 523 ifra->ifra_addr.sin_addr)) 524 hostIsNew = 0; 525 if (ifra->ifra_mask.sin_len) { 526 in_ifscrub(ifp, ia); 527 ia->ia_sockmask = ifra->ifra_mask; 528 ia->ia_subnetmask = ia->ia_sockmask.sin_addr.s_addr; 529 maskIsNew = 1; 530 } 531 if ((ifp->if_flags & IFF_POINTOPOINT) && 532 (ifra->ifra_dstaddr.sin_family == AF_INET)) { 533 in_ifscrub(ifp, ia); 534 ia->ia_dstaddr = ifra->ifra_dstaddr; 535 maskIsNew = 1; /* We lie; but the effect's the same */ 536 } 537 if (ifra->ifra_addr.sin_family == AF_INET && 538 (hostIsNew || maskIsNew)) { 539 error = in_ifinit(ifp, ia, &ifra->ifra_addr, 0); 540 } 541 if ((ifp->if_flags & IFF_BROADCAST) && 542 (ifra->ifra_broadaddr.sin_family == AF_INET)) 543 ia->ia_broadaddr = ifra->ifra_broadaddr; 544 #ifdef PFIL_HOOKS 545 if (error == 0) 546 (void)pfil_run_hooks(&if_pfil, 547 (struct mbuf **)SIOCAIFADDR, ifp, PFIL_IFADDR); 548 #endif 549 break; 550 551 case SIOCGIFALIAS: 552 ifra->ifra_mask = ia->ia_sockmask; 553 if ((ifp->if_flags & IFF_POINTOPOINT) && 554 (ia->ia_dstaddr.sin_family == AF_INET)) 555 ifra->ifra_dstaddr = ia->ia_dstaddr; 556 else if ((ifp->if_flags & IFF_BROADCAST) && 557 (ia->ia_broadaddr.sin_family == AF_INET)) 558 ifra->ifra_broadaddr = ia->ia_broadaddr; 559 else 560 memset(&ifra->ifra_broadaddr, 0, 561 sizeof(ifra->ifra_broadaddr)); 562 break; 563 564 case SIOCDIFADDR: 565 in_purgeaddr(&ia->ia_ifa, ifp); 566 #ifdef PFIL_HOOKS 567 (void)pfil_run_hooks(&if_pfil, (struct mbuf **)SIOCDIFADDR, 568 ifp, PFIL_IFADDR); 569 #endif 570 break; 571 572 #ifdef MROUTING 573 case SIOCGETVIFCNT: 574 case SIOCGETSGCNT: 575 error = mrt_ioctl(so, cmd, data); 576 break; 577 #endif /* MROUTING */ 578 579 default: 580 if (ifp == NULL || ifp->if_ioctl == NULL) 581 return EOPNOTSUPP; 582 error = (*ifp->if_ioctl)(ifp, cmd, data); 583 in_setmaxmtu(); 584 break; 585 } 586 587 if (error != 0 && newifaddr) { 588 KASSERT(ia != NULL); 589 in_purgeaddr(&ia->ia_ifa, ifp); 590 } 591 592 return error; 593 } 594 595 void 596 in_purgeaddr(struct ifaddr *ifa, struct ifnet *ifp) 597 { 598 struct in_ifaddr *ia = (void *) ifa; 599 600 in_ifscrub(ifp, ia); 601 LIST_REMOVE(ia, ia_hash); 602 TAILQ_REMOVE(&ifp->if_addrlist, &ia->ia_ifa, ifa_list); 603 IFAFREE(&ia->ia_ifa); 604 TAILQ_REMOVE(&in_ifaddrhead, ia, ia_list); 605 if (ia->ia_allhosts != NULL) 606 in_delmulti(ia->ia_allhosts); 607 IFAFREE(&ia->ia_ifa); 608 in_setmaxmtu(); 609 } 610 611 void 612 in_purgeif(struct ifnet *ifp) /* MUST be called at splsoftnet() */ 613 { 614 struct ifaddr *ifa, *nifa; 615 616 for (ifa = TAILQ_FIRST(&ifp->if_addrlist); ifa != NULL; ifa = nifa) { 617 nifa = TAILQ_NEXT(ifa, ifa_list); 618 if (ifa->ifa_addr->sa_family != AF_INET) 619 continue; 620 in_purgeaddr(ifa, ifp); 621 } 622 623 igmp_purgeif(ifp); /* manipulates pools */ 624 #ifdef MROUTING 625 ip_mrouter_detach(ifp); 626 #endif 627 } 628 629 /* 630 * SIOC[GAD]LIFADDR. 631 * SIOCGLIFADDR: get first address. (???) 632 * SIOCGLIFADDR with IFLR_PREFIX: 633 * get first address that matches the specified prefix. 634 * SIOCALIFADDR: add the specified address. 635 * SIOCALIFADDR with IFLR_PREFIX: 636 * EINVAL since we can't deduce hostid part of the address. 637 * SIOCDLIFADDR: delete the specified address. 638 * SIOCDLIFADDR with IFLR_PREFIX: 639 * delete the first address that matches the specified prefix. 640 * return values: 641 * EINVAL on invalid parameters 642 * EADDRNOTAVAIL on prefix match failed/specified address not found 643 * other values may be returned from in_ioctl() 644 */ 645 static int 646 in_lifaddr_ioctl(struct socket *so, u_long cmd, void *data, 647 struct ifnet *ifp, struct lwp *l) 648 { 649 struct if_laddrreq *iflr = (struct if_laddrreq *)data; 650 struct ifaddr *ifa; 651 struct sockaddr *sa; 652 653 /* sanity checks */ 654 if (!data || !ifp) { 655 panic("invalid argument to in_lifaddr_ioctl"); 656 /*NOTRECHED*/ 657 } 658 659 switch (cmd) { 660 case SIOCGLIFADDR: 661 /* address must be specified on GET with IFLR_PREFIX */ 662 if ((iflr->flags & IFLR_PREFIX) == 0) 663 break; 664 /*FALLTHROUGH*/ 665 case SIOCALIFADDR: 666 case SIOCDLIFADDR: 667 /* address must be specified on ADD and DELETE */ 668 sa = (struct sockaddr *)&iflr->addr; 669 if (sa->sa_family != AF_INET) 670 return EINVAL; 671 if (sa->sa_len != sizeof(struct sockaddr_in)) 672 return EINVAL; 673 /* XXX need improvement */ 674 sa = (struct sockaddr *)&iflr->dstaddr; 675 if (sa->sa_family 676 && sa->sa_family != AF_INET) 677 return EINVAL; 678 if (sa->sa_len && sa->sa_len != sizeof(struct sockaddr_in)) 679 return EINVAL; 680 break; 681 default: /*shouldn't happen*/ 682 #if 0 683 panic("invalid cmd to in_lifaddr_ioctl"); 684 /*NOTREACHED*/ 685 #else 686 return EOPNOTSUPP; 687 #endif 688 } 689 if (sizeof(struct in_addr) * 8 < iflr->prefixlen) 690 return EINVAL; 691 692 switch (cmd) { 693 case SIOCALIFADDR: 694 { 695 struct in_aliasreq ifra; 696 697 if (iflr->flags & IFLR_PREFIX) 698 return EINVAL; 699 700 /* copy args to in_aliasreq, perform ioctl(SIOCAIFADDR). */ 701 bzero(&ifra, sizeof(ifra)); 702 bcopy(iflr->iflr_name, ifra.ifra_name, 703 sizeof(ifra.ifra_name)); 704 705 bcopy(&iflr->addr, &ifra.ifra_addr, 706 ((struct sockaddr *)&iflr->addr)->sa_len); 707 708 if (((struct sockaddr *)&iflr->dstaddr)->sa_family) { /*XXX*/ 709 bcopy(&iflr->dstaddr, &ifra.ifra_dstaddr, 710 ((struct sockaddr *)&iflr->dstaddr)->sa_len); 711 } 712 713 ifra.ifra_mask.sin_family = AF_INET; 714 ifra.ifra_mask.sin_len = sizeof(struct sockaddr_in); 715 in_len2mask(&ifra.ifra_mask.sin_addr, iflr->prefixlen); 716 717 return in_control(so, SIOCAIFADDR, (void *)&ifra, ifp, l); 718 } 719 case SIOCGLIFADDR: 720 case SIOCDLIFADDR: 721 { 722 struct in_ifaddr *ia; 723 struct in_addr mask, candidate, match; 724 struct sockaddr_in *sin; 725 int cmp; 726 727 bzero(&mask, sizeof(mask)); 728 bzero(&match, sizeof(match)); /* XXX gcc */ 729 if (iflr->flags & IFLR_PREFIX) { 730 /* lookup a prefix rather than address. */ 731 in_len2mask(&mask, iflr->prefixlen); 732 733 sin = (struct sockaddr_in *)&iflr->addr; 734 match.s_addr = sin->sin_addr.s_addr; 735 match.s_addr &= mask.s_addr; 736 737 /* if you set extra bits, that's wrong */ 738 if (match.s_addr != sin->sin_addr.s_addr) 739 return EINVAL; 740 741 cmp = 1; 742 } else { 743 if (cmd == SIOCGLIFADDR) { 744 /* on getting an address, take the 1st match */ 745 cmp = 0; /*XXX*/ 746 } else { 747 /* on deleting an address, do exact match */ 748 in_len2mask(&mask, 32); 749 sin = (struct sockaddr_in *)&iflr->addr; 750 match.s_addr = sin->sin_addr.s_addr; 751 752 cmp = 1; 753 } 754 } 755 756 IFADDR_FOREACH(ifa, ifp) { 757 if (ifa->ifa_addr->sa_family != AF_INET) 758 continue; 759 if (!cmp) 760 break; 761 candidate.s_addr = ((struct sockaddr_in *)&ifa->ifa_addr)->sin_addr.s_addr; 762 candidate.s_addr &= mask.s_addr; 763 if (candidate.s_addr == match.s_addr) 764 break; 765 } 766 if (!ifa) 767 return EADDRNOTAVAIL; 768 ia = (struct in_ifaddr *)ifa; 769 770 if (cmd == SIOCGLIFADDR) { 771 /* fill in the if_laddrreq structure */ 772 bcopy(&ia->ia_addr, &iflr->addr, ia->ia_addr.sin_len); 773 774 if ((ifp->if_flags & IFF_POINTOPOINT) != 0) { 775 bcopy(&ia->ia_dstaddr, &iflr->dstaddr, 776 ia->ia_dstaddr.sin_len); 777 } else 778 bzero(&iflr->dstaddr, sizeof(iflr->dstaddr)); 779 780 iflr->prefixlen = 781 in_mask2len(&ia->ia_sockmask.sin_addr); 782 783 iflr->flags = 0; /*XXX*/ 784 785 return 0; 786 } else { 787 struct in_aliasreq ifra; 788 789 /* fill in_aliasreq and do ioctl(SIOCDIFADDR) */ 790 bzero(&ifra, sizeof(ifra)); 791 bcopy(iflr->iflr_name, ifra.ifra_name, 792 sizeof(ifra.ifra_name)); 793 794 bcopy(&ia->ia_addr, &ifra.ifra_addr, 795 ia->ia_addr.sin_len); 796 if ((ifp->if_flags & IFF_POINTOPOINT) != 0) { 797 bcopy(&ia->ia_dstaddr, &ifra.ifra_dstaddr, 798 ia->ia_dstaddr.sin_len); 799 } 800 bcopy(&ia->ia_sockmask, &ifra.ifra_dstaddr, 801 ia->ia_sockmask.sin_len); 802 803 return in_control(so, SIOCDIFADDR, (void *)&ifra, 804 ifp, l); 805 } 806 } 807 } 808 809 return EOPNOTSUPP; /*just for safety*/ 810 } 811 812 static int 813 in_ifaddrpref_ioctl(struct socket *so, u_long cmd, void *data, 814 struct ifnet *ifp) 815 { 816 struct if_addrprefreq *ifap = (struct if_addrprefreq *)data; 817 struct ifaddr *ifa; 818 struct sockaddr *sa; 819 struct in_ifaddr *ia = NULL; /* appease gcc -Wuninitialized */ 820 struct in_addr match; 821 struct sockaddr_in *sin; 822 823 /* sanity checks */ 824 if (data == NULL || ifp == NULL) { 825 panic("invalid argument to %s", __func__); 826 /*NOTREACHED*/ 827 } 828 829 /* address must be specified on ADD and DELETE */ 830 sa = (struct sockaddr *)&ifap->ifap_addr; 831 if (sa->sa_family != AF_INET) 832 return EINVAL; 833 if (sa->sa_len != sizeof(struct sockaddr_in)) 834 return EINVAL; 835 836 switch (cmd) { 837 case SIOCSIFADDRPREF: 838 case SIOCGIFADDRPREF: 839 break; 840 default: 841 return EOPNOTSUPP; 842 } 843 844 sin = (struct sockaddr_in *)&ifap->ifap_addr; 845 match.s_addr = sin->sin_addr.s_addr; 846 847 IFADDR_FOREACH(ifa, ifp) { 848 ia = (struct in_ifaddr *)ifa; 849 if (ia->ia_addr.sin_family != AF_INET) 850 continue; 851 if (ia->ia_addr.sin_addr.s_addr == match.s_addr) 852 break; 853 } 854 if (ifa == NULL) 855 return EADDRNOTAVAIL; 856 857 switch (cmd) { 858 case SIOCSIFADDRPREF: 859 ifa->ifa_preference = ifap->ifap_preference; 860 return 0; 861 case SIOCGIFADDRPREF: 862 /* fill in the if_laddrreq structure */ 863 (void)memcpy(&ifap->ifap_addr, &ia->ia_addr, 864 ia->ia_addr.sin_len); 865 ifap->ifap_preference = ifa->ifa_preference; 866 return 0; 867 default: 868 return EOPNOTSUPP; 869 } 870 } 871 872 /* 873 * Delete any existing route for an interface. 874 */ 875 void 876 in_ifscrub(struct ifnet *ifp, struct in_ifaddr *ia) 877 { 878 879 in_scrubprefix(ia); 880 } 881 882 /* 883 * Initialize an interface's internet address 884 * and routing table entry. 885 */ 886 int 887 in_ifinit(struct ifnet *ifp, struct in_ifaddr *ia, 888 struct sockaddr_in *sin, int scrub) 889 { 890 u_int32_t i; 891 struct sockaddr_in oldaddr; 892 int s = splnet(), flags = RTF_UP, error; 893 894 if (!sin) 895 sin = &ia->ia_addr; 896 897 /* 898 * Set up new addresses. 899 */ 900 oldaddr = ia->ia_addr; 901 if (ia->ia_addr.sin_family == AF_INET) 902 LIST_REMOVE(ia, ia_hash); 903 ia->ia_addr = *sin; 904 LIST_INSERT_HEAD(&IN_IFADDR_HASH(ia->ia_addr.sin_addr.s_addr), ia, ia_hash); 905 906 /* 907 * Give the interface a chance to initialize 908 * if this is its first address, 909 * and to validate the address if necessary. 910 */ 911 if (ifp->if_ioctl && 912 (error = (*ifp->if_ioctl)(ifp, SIOCSIFADDR, (void *)ia))) 913 goto bad; 914 splx(s); 915 if (scrub) { 916 ia->ia_ifa.ifa_addr = sintosa(&oldaddr); 917 in_ifscrub(ifp, ia); 918 ia->ia_ifa.ifa_addr = sintosa(&ia->ia_addr); 919 } 920 921 i = ia->ia_addr.sin_addr.s_addr; 922 if (IN_CLASSA(i)) 923 ia->ia_netmask = IN_CLASSA_NET; 924 else if (IN_CLASSB(i)) 925 ia->ia_netmask = IN_CLASSB_NET; 926 else 927 ia->ia_netmask = IN_CLASSC_NET; 928 /* 929 * The subnet mask usually includes at least the standard network part, 930 * but may may be smaller in the case of supernetting. 931 * If it is set, we believe it. 932 */ 933 if (ia->ia_subnetmask == 0) { 934 ia->ia_subnetmask = ia->ia_netmask; 935 ia->ia_sockmask.sin_addr.s_addr = ia->ia_subnetmask; 936 } else 937 ia->ia_netmask &= ia->ia_subnetmask; 938 939 ia->ia_net = i & ia->ia_netmask; 940 ia->ia_subnet = i & ia->ia_subnetmask; 941 in_socktrim(&ia->ia_sockmask); 942 /* re-calculate the "in_maxmtu" value */ 943 in_setmaxmtu(); 944 /* 945 * Add route for the network. 946 */ 947 ia->ia_ifa.ifa_metric = ifp->if_metric; 948 if (ifp->if_flags & IFF_BROADCAST) { 949 ia->ia_broadaddr.sin_addr.s_addr = 950 ia->ia_subnet | ~ia->ia_subnetmask; 951 ia->ia_netbroadcast.s_addr = 952 ia->ia_net | ~ia->ia_netmask; 953 } else if (ifp->if_flags & IFF_LOOPBACK) { 954 ia->ia_dstaddr = ia->ia_addr; 955 flags |= RTF_HOST; 956 } else if (ifp->if_flags & IFF_POINTOPOINT) { 957 if (ia->ia_dstaddr.sin_family != AF_INET) 958 return (0); 959 flags |= RTF_HOST; 960 } 961 error = in_addprefix(ia, flags); 962 /* 963 * If the interface supports multicast, join the "all hosts" 964 * multicast group on that interface. 965 */ 966 if ((ifp->if_flags & IFF_MULTICAST) != 0 && ia->ia_allhosts == NULL) { 967 struct in_addr addr; 968 969 addr.s_addr = INADDR_ALLHOSTS_GROUP; 970 ia->ia_allhosts = in_addmulti(&addr, ifp); 971 } 972 return (error); 973 bad: 974 splx(s); 975 LIST_REMOVE(ia, ia_hash); 976 ia->ia_addr = oldaddr; 977 if (ia->ia_addr.sin_family == AF_INET) 978 LIST_INSERT_HEAD(&IN_IFADDR_HASH(ia->ia_addr.sin_addr.s_addr), 979 ia, ia_hash); 980 return (error); 981 } 982 983 #define rtinitflags(x) \ 984 ((((x)->ia_ifp->if_flags & (IFF_LOOPBACK | IFF_POINTOPOINT)) != 0) \ 985 ? RTF_HOST : 0) 986 987 /* 988 * add a route to prefix ("connected route" in cisco terminology). 989 * does nothing if there's some interface address with the same prefix already. 990 */ 991 static int 992 in_addprefix(struct in_ifaddr *target, int flags) 993 { 994 struct in_ifaddr *ia; 995 struct in_addr prefix, mask, p; 996 int error; 997 998 if ((flags & RTF_HOST) != 0) 999 prefix = target->ia_dstaddr.sin_addr; 1000 else { 1001 prefix = target->ia_addr.sin_addr; 1002 mask = target->ia_sockmask.sin_addr; 1003 prefix.s_addr &= mask.s_addr; 1004 } 1005 1006 TAILQ_FOREACH(ia, &in_ifaddrhead, ia_list) { 1007 if (rtinitflags(ia)) 1008 p = ia->ia_dstaddr.sin_addr; 1009 else { 1010 p = ia->ia_addr.sin_addr; 1011 p.s_addr &= ia->ia_sockmask.sin_addr.s_addr; 1012 } 1013 1014 if (prefix.s_addr != p.s_addr) 1015 continue; 1016 1017 /* 1018 * if we got a matching prefix route inserted by other 1019 * interface address, we don't need to bother 1020 * 1021 * XXX RADIX_MPATH implications here? -dyoung 1022 */ 1023 if (ia->ia_flags & IFA_ROUTE) 1024 return 0; 1025 } 1026 1027 /* 1028 * noone seem to have prefix route. insert it. 1029 */ 1030 error = rtinit(&target->ia_ifa, (int)RTM_ADD, flags); 1031 if (!error) 1032 target->ia_flags |= IFA_ROUTE; 1033 return error; 1034 } 1035 1036 /* 1037 * remove a route to prefix ("connected route" in cisco terminology). 1038 * re-installs the route by using another interface address, if there's one 1039 * with the same prefix (otherwise we lose the route mistakenly). 1040 */ 1041 static int 1042 in_scrubprefix(struct in_ifaddr *target) 1043 { 1044 struct in_ifaddr *ia; 1045 struct in_addr prefix, mask, p; 1046 int error; 1047 1048 if ((target->ia_flags & IFA_ROUTE) == 0) 1049 return 0; 1050 1051 if (rtinitflags(target)) 1052 prefix = target->ia_dstaddr.sin_addr; 1053 else { 1054 prefix = target->ia_addr.sin_addr; 1055 mask = target->ia_sockmask.sin_addr; 1056 prefix.s_addr &= mask.s_addr; 1057 } 1058 1059 TAILQ_FOREACH(ia, &in_ifaddrhead, ia_list) { 1060 if (rtinitflags(ia)) 1061 p = ia->ia_dstaddr.sin_addr; 1062 else { 1063 p = ia->ia_addr.sin_addr; 1064 p.s_addr &= ia->ia_sockmask.sin_addr.s_addr; 1065 } 1066 1067 if (prefix.s_addr != p.s_addr) 1068 continue; 1069 1070 /* 1071 * if we got a matching prefix route, move IFA_ROUTE to him 1072 */ 1073 if ((ia->ia_flags & IFA_ROUTE) == 0) { 1074 rtinit(&(target->ia_ifa), (int)RTM_DELETE, 1075 rtinitflags(target)); 1076 target->ia_flags &= ~IFA_ROUTE; 1077 1078 error = rtinit(&ia->ia_ifa, (int)RTM_ADD, 1079 rtinitflags(ia) | RTF_UP); 1080 if (error == 0) 1081 ia->ia_flags |= IFA_ROUTE; 1082 return error; 1083 } 1084 } 1085 1086 /* 1087 * noone seem to have prefix route. remove it. 1088 */ 1089 rtinit(&(target->ia_ifa), (int)RTM_DELETE, rtinitflags(target)); 1090 target->ia_flags &= ~IFA_ROUTE; 1091 return 0; 1092 } 1093 1094 #undef rtinitflags 1095 1096 /* 1097 * Return 1 if the address might be a local broadcast address. 1098 */ 1099 int 1100 in_broadcast(struct in_addr in, struct ifnet *ifp) 1101 { 1102 struct ifaddr *ifa; 1103 1104 if (in.s_addr == INADDR_BROADCAST || 1105 in_nullhost(in)) 1106 return 1; 1107 if ((ifp->if_flags & IFF_BROADCAST) == 0) 1108 return 0; 1109 /* 1110 * Look through the list of addresses for a match 1111 * with a broadcast address. 1112 */ 1113 #define ia (ifatoia(ifa)) 1114 IFADDR_FOREACH(ifa, ifp) 1115 if (ifa->ifa_addr->sa_family == AF_INET && 1116 !in_hosteq(in, ia->ia_addr.sin_addr) && 1117 (in_hosteq(in, ia->ia_broadaddr.sin_addr) || 1118 in_hosteq(in, ia->ia_netbroadcast) || 1119 (hostzeroisbroadcast && 1120 /* 1121 * Check for old-style (host 0) broadcast. 1122 */ 1123 (in.s_addr == ia->ia_subnet || 1124 in.s_addr == ia->ia_net)))) 1125 return 1; 1126 return (0); 1127 #undef ia 1128 } 1129 1130 /* 1131 * Add an address to the list of IP multicast addresses for a given interface. 1132 */ 1133 struct in_multi * 1134 in_addmulti(struct in_addr *ap, struct ifnet *ifp) 1135 { 1136 struct in_multi *inm; 1137 struct ifreq ifr; 1138 int s = splsoftnet(); 1139 1140 /* 1141 * See if address already in list. 1142 */ 1143 IN_LOOKUP_MULTI(*ap, ifp, inm); 1144 if (inm != NULL) { 1145 /* 1146 * Found it; just increment the reference count. 1147 */ 1148 ++inm->inm_refcount; 1149 } else { 1150 /* 1151 * New address; allocate a new multicast record 1152 * and link it into the interface's multicast list. 1153 */ 1154 inm = pool_get(&inmulti_pool, PR_NOWAIT); 1155 if (inm == NULL) { 1156 splx(s); 1157 return (NULL); 1158 } 1159 inm->inm_addr = *ap; 1160 inm->inm_ifp = ifp; 1161 inm->inm_refcount = 1; 1162 LIST_INSERT_HEAD( 1163 &IN_MULTI_HASH(inm->inm_addr.s_addr, ifp), 1164 inm, inm_list); 1165 /* 1166 * Ask the network driver to update its multicast reception 1167 * filter appropriately for the new address. 1168 */ 1169 satosin(&ifr.ifr_addr)->sin_len = sizeof(struct sockaddr_in); 1170 satosin(&ifr.ifr_addr)->sin_family = AF_INET; 1171 satosin(&ifr.ifr_addr)->sin_addr = *ap; 1172 if ((ifp->if_ioctl == NULL) || 1173 (*ifp->if_ioctl)(ifp, SIOCADDMULTI,(void *)&ifr) != 0) { 1174 LIST_REMOVE(inm, inm_list); 1175 pool_put(&inmulti_pool, inm); 1176 splx(s); 1177 return (NULL); 1178 } 1179 /* 1180 * Let IGMP know that we have joined a new IP multicast group. 1181 */ 1182 if (igmp_joingroup(inm) != 0) { 1183 LIST_REMOVE(inm, inm_list); 1184 pool_put(&inmulti_pool, inm); 1185 splx(s); 1186 return (NULL); 1187 } 1188 in_multientries++; 1189 } 1190 splx(s); 1191 return (inm); 1192 } 1193 1194 /* 1195 * Delete a multicast address record. 1196 */ 1197 void 1198 in_delmulti(struct in_multi *inm) 1199 { 1200 struct ifreq ifr; 1201 int s = splsoftnet(); 1202 1203 if (--inm->inm_refcount == 0) { 1204 /* 1205 * No remaining claims to this record; let IGMP know that 1206 * we are leaving the multicast group. 1207 */ 1208 igmp_leavegroup(inm); 1209 /* 1210 * Unlink from list. 1211 */ 1212 LIST_REMOVE(inm, inm_list); 1213 in_multientries--; 1214 /* 1215 * Notify the network driver to update its multicast reception 1216 * filter. 1217 */ 1218 satosin(&ifr.ifr_addr)->sin_family = AF_INET; 1219 satosin(&ifr.ifr_addr)->sin_addr = inm->inm_addr; 1220 (*inm->inm_ifp->if_ioctl)(inm->inm_ifp, SIOCDELMULTI, 1221 (void *)&ifr); 1222 pool_put(&inmulti_pool, inm); 1223 } 1224 splx(s); 1225 } 1226 #endif /* INET */ 1227
Indexes created Thu Sep 25 08:09:54 GMT 2025