in.c revision 1.236
1 /* $NetBSD: in.c,v 1.236 2019/12/18 00:49:15 roy 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 * 49 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 50 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 51 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 52 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 53 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 54 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 55 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 56 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 57 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 58 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 59 * POSSIBILITY OF SUCH DAMAGE. 60 */ 61 62 /* 63 * Copyright (c) 1982, 1986, 1991, 1993 64 * The Regents of the University of California. All rights reserved. 65 * 66 * Redistribution and use in source and binary forms, with or without 67 * modification, are permitted provided that the following conditions 68 * are met: 69 * 1. Redistributions of source code must retain the above copyright 70 * notice, this list of conditions and the following disclaimer. 71 * 2. Redistributions in binary form must reproduce the above copyright 72 * notice, this list of conditions and the following disclaimer in the 73 * documentation and/or other materials provided with the distribution. 74 * 3. Neither the name of the University nor the names of its contributors 75 * may be used to endorse or promote products derived from this software 76 * without specific prior written permission. 77 * 78 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 79 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 80 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 81 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 82 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 83 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 84 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 85 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 86 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 87 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 88 * SUCH DAMAGE. 89 * 90 * @(#)in.c 8.4 (Berkeley) 1/9/95 91 */ 92 93 #include <sys/cdefs.h> 94 __KERNEL_RCSID(0, "$NetBSD: in.c,v 1.236 2019/12/18 00:49:15 roy Exp $"); 95 96 #include "arp.h" 97 98 #ifdef _KERNEL_OPT 99 #include "opt_inet.h" 100 #include "opt_inet_conf.h" 101 #include "opt_mrouting.h" 102 #include "opt_net_mpsafe.h" 103 #endif 104 105 #include <sys/param.h> 106 #include <sys/ioctl.h> 107 #include <sys/errno.h> 108 #include <sys/kernel.h> 109 #include <sys/malloc.h> 110 #include <sys/socket.h> 111 #include <sys/socketvar.h> 112 #include <sys/sysctl.h> 113 #include <sys/systm.h> 114 #include <sys/proc.h> 115 #include <sys/syslog.h> 116 #include <sys/kauth.h> 117 #include <sys/kmem.h> 118 119 #include <sys/cprng.h> 120 121 #include <net/if.h> 122 #include <net/route.h> 123 #include <net/pfil.h> 124 125 #include <net/if_arp.h> 126 #include <net/if_ether.h> 127 #include <net/if_types.h> 128 #include <net/if_llatbl.h> 129 #include <net/if_dl.h> 130 131 #include <netinet/in_systm.h> 132 #include <netinet/in.h> 133 #include <netinet/in_var.h> 134 #include <netinet/ip.h> 135 #include <netinet/ip_var.h> 136 #include <netinet/in_ifattach.h> 137 #include <netinet/in_pcb.h> 138 #include <netinet/in_selsrc.h> 139 #include <netinet/if_inarp.h> 140 #include <netinet/ip_mroute.h> 141 #include <netinet/igmp_var.h> 142 143 #ifdef IPSELSRC 144 #include <netinet/in_selsrc.h> 145 #endif 146 147 static u_int in_mask2len(struct in_addr *); 148 static void in_len2mask(struct in_addr *, u_int); 149 static int in_lifaddr_ioctl(struct socket *, u_long, void *, 150 struct ifnet *); 151 152 static void in_addrhash_insert_locked(struct in_ifaddr *); 153 static void in_addrhash_remove_locked(struct in_ifaddr *); 154 155 static int in_addprefix(struct in_ifaddr *, int); 156 static void in_scrubaddr(struct in_ifaddr *); 157 static int in_scrubprefix(struct in_ifaddr *); 158 static void in_sysctl_init(struct sysctllog **); 159 160 #ifndef SUBNETSARELOCAL 161 #define SUBNETSARELOCAL 1 162 #endif 163 164 #ifndef HOSTZEROBROADCAST 165 #define HOSTZEROBROADCAST 0 166 #endif 167 168 /* Note: 61, 127, 251, 509, 1021, 2039 are good. */ 169 #ifndef IN_MULTI_HASH_SIZE 170 #define IN_MULTI_HASH_SIZE 509 171 #endif 172 173 static int subnetsarelocal = SUBNETSARELOCAL; 174 static int hostzeroisbroadcast = HOSTZEROBROADCAST; 175 176 /* 177 * This list is used to keep track of in_multi chains which belong to 178 * deleted interface addresses. We use in_ifaddr so that a chain head 179 * won't be deallocated until all multicast address record are deleted. 180 */ 181 182 LIST_HEAD(in_multihashhead, in_multi); /* Type of the hash head */ 183 184 static struct pool inmulti_pool; 185 static u_int in_multientries; 186 static struct in_multihashhead *in_multihashtbl; 187 static u_long in_multihash; 188 static krwlock_t in_multilock; 189 190 #define IN_MULTI_HASH(x, ifp) \ 191 (in_multihashtbl[(u_long)((x) ^ (ifp->if_index)) % IN_MULTI_HASH_SIZE]) 192 193 /* XXX DEPRECATED. Keep them to avoid breaking kvm(3) users. */ 194 struct in_ifaddrhashhead * in_ifaddrhashtbl; 195 u_long in_ifaddrhash; 196 struct in_ifaddrhead in_ifaddrhead; 197 static kmutex_t in_ifaddr_lock; 198 199 pserialize_t in_ifaddrhash_psz; 200 struct pslist_head * in_ifaddrhashtbl_pslist; 201 u_long in_ifaddrhash_pslist; 202 struct pslist_head in_ifaddrhead_pslist; 203 204 void 205 in_init(void) 206 { 207 pool_init(&inmulti_pool, sizeof(struct in_multi), 0, 0, 0, "inmltpl", 208 NULL, IPL_SOFTNET); 209 TAILQ_INIT(&in_ifaddrhead); 210 PSLIST_INIT(&in_ifaddrhead_pslist); 211 212 in_ifaddrhashtbl = hashinit(IN_IFADDR_HASH_SIZE, HASH_LIST, true, 213 &in_ifaddrhash); 214 215 in_ifaddrhash_psz = pserialize_create(); 216 in_ifaddrhashtbl_pslist = hashinit(IN_IFADDR_HASH_SIZE, HASH_PSLIST, 217 true, &in_ifaddrhash_pslist); 218 mutex_init(&in_ifaddr_lock, MUTEX_DEFAULT, IPL_NONE); 219 220 in_multihashtbl = hashinit(IN_IFADDR_HASH_SIZE, HASH_LIST, true, 221 &in_multihash); 222 rw_init(&in_multilock); 223 224 in_sysctl_init(NULL); 225 } 226 227 /* 228 * Return 1 if an internet address is for a ``local'' host 229 * (one to which we have a connection). If subnetsarelocal 230 * is true, this includes other subnets of the local net. 231 * Otherwise, it includes only the directly-connected (sub)nets. 232 */ 233 int 234 in_localaddr(struct in_addr in) 235 { 236 struct in_ifaddr *ia; 237 int localaddr = 0; 238 int s = pserialize_read_enter(); 239 240 if (subnetsarelocal) { 241 IN_ADDRLIST_READER_FOREACH(ia) { 242 if ((in.s_addr & ia->ia_netmask) == ia->ia_net) { 243 localaddr = 1; 244 break; 245 } 246 } 247 } else { 248 IN_ADDRLIST_READER_FOREACH(ia) { 249 if ((in.s_addr & ia->ia_subnetmask) == ia->ia_subnet) { 250 localaddr = 1; 251 break; 252 } 253 } 254 } 255 pserialize_read_exit(s); 256 257 return localaddr; 258 } 259 260 /* 261 * like in_localaddr() but can specify ifp. 262 */ 263 int 264 in_direct(struct in_addr in, struct ifnet *ifp) 265 { 266 struct ifaddr *ifa; 267 int localaddr = 0; 268 int s; 269 270 KASSERT(ifp != NULL); 271 272 #define ia (ifatoia(ifa)) 273 s = pserialize_read_enter(); 274 if (subnetsarelocal) { 275 IFADDR_READER_FOREACH(ifa, ifp) { 276 if (ifa->ifa_addr->sa_family == AF_INET && 277 ((in.s_addr & ia->ia_netmask) == ia->ia_net)) { 278 localaddr = 1; 279 break; 280 } 281 } 282 } else { 283 IFADDR_READER_FOREACH(ifa, ifp) { 284 if (ifa->ifa_addr->sa_family == AF_INET && 285 (in.s_addr & ia->ia_subnetmask) == ia->ia_subnet) { 286 localaddr = 1; 287 break; 288 } 289 } 290 } 291 pserialize_read_exit(s); 292 293 return localaddr; 294 #undef ia 295 } 296 297 /* 298 * Determine whether an IP address is in a reserved set of addresses 299 * that may not be forwarded, or whether datagrams to that destination 300 * may be forwarded. 301 */ 302 int 303 in_canforward(struct in_addr in) 304 { 305 u_int32_t net; 306 307 if (IN_EXPERIMENTAL(in.s_addr) || IN_MULTICAST(in.s_addr)) 308 return (0); 309 if (IN_CLASSA(in.s_addr)) { 310 net = in.s_addr & IN_CLASSA_NET; 311 if (net == 0 || net == htonl(IN_LOOPBACKNET << IN_CLASSA_NSHIFT)) 312 return (0); 313 } 314 return (1); 315 } 316 317 /* 318 * Trim a mask in a sockaddr 319 */ 320 void 321 in_socktrim(struct sockaddr_in *ap) 322 { 323 char *cplim = (char *) &ap->sin_addr; 324 char *cp = (char *) (&ap->sin_addr + 1); 325 326 ap->sin_len = 0; 327 while (--cp >= cplim) 328 if (*cp) { 329 (ap)->sin_len = cp - (char *) (ap) + 1; 330 break; 331 } 332 } 333 334 /* 335 * Maintain the "in_maxmtu" variable, which is the largest 336 * mtu for non-local interfaces with AF_INET addresses assigned 337 * to them that are up. 338 */ 339 unsigned long in_maxmtu; 340 341 void 342 in_setmaxmtu(void) 343 { 344 struct in_ifaddr *ia; 345 struct ifnet *ifp; 346 unsigned long maxmtu = 0; 347 int s = pserialize_read_enter(); 348 349 IN_ADDRLIST_READER_FOREACH(ia) { 350 if ((ifp = ia->ia_ifp) == 0) 351 continue; 352 if ((ifp->if_flags & (IFF_UP|IFF_LOOPBACK)) != IFF_UP) 353 continue; 354 if (ifp->if_mtu > maxmtu) 355 maxmtu = ifp->if_mtu; 356 } 357 if (maxmtu) 358 in_maxmtu = maxmtu; 359 pserialize_read_exit(s); 360 } 361 362 static u_int 363 in_mask2len(struct in_addr *mask) 364 { 365 u_int x, y; 366 u_char *p; 367 368 p = (u_char *)mask; 369 for (x = 0; x < sizeof(*mask); x++) { 370 if (p[x] != 0xff) 371 break; 372 } 373 y = 0; 374 if (x < sizeof(*mask)) { 375 for (y = 0; y < NBBY; y++) { 376 if ((p[x] & (0x80 >> y)) == 0) 377 break; 378 } 379 } 380 return x * NBBY + y; 381 } 382 383 static void 384 in_len2mask(struct in_addr *mask, u_int len) 385 { 386 u_int i; 387 u_char *p; 388 389 p = (u_char *)mask; 390 memset(mask, 0, sizeof(*mask)); 391 for (i = 0; i < len / NBBY; i++) 392 p[i] = 0xff; 393 if (len % NBBY) 394 p[i] = (0xff00 >> (len % NBBY)) & 0xff; 395 } 396 397 /* 398 * Generic internet control operations (ioctl's). 399 * Ifp is 0 if not an interface-specific ioctl. 400 */ 401 /* ARGSUSED */ 402 static int 403 in_control0(struct socket *so, u_long cmd, void *data, struct ifnet *ifp) 404 { 405 struct ifreq *ifr = (struct ifreq *)data; 406 struct in_ifaddr *ia = NULL; 407 struct in_aliasreq *ifra = (struct in_aliasreq *)data; 408 struct sockaddr_in oldaddr, *new_dstaddr; 409 int error, hostIsNew, maskIsNew; 410 int newifaddr = 0; 411 bool run_hook = false; 412 bool need_reinsert = false; 413 struct psref psref; 414 int bound; 415 416 switch (cmd) { 417 case SIOCALIFADDR: 418 case SIOCDLIFADDR: 419 case SIOCGLIFADDR: 420 if (ifp == NULL) 421 return EINVAL; 422 return in_lifaddr_ioctl(so, cmd, data, ifp); 423 case SIOCGIFADDRPREF: 424 case SIOCSIFADDRPREF: 425 if (ifp == NULL) 426 return EINVAL; 427 return ifaddrpref_ioctl(so, cmd, data, ifp); 428 } 429 430 bound = curlwp_bind(); 431 /* 432 * Find address for this interface, if it exists. 433 */ 434 if (ifp != NULL) 435 ia = in_get_ia_from_ifp_psref(ifp, &psref); 436 437 hostIsNew = 1; /* moved here to appease gcc */ 438 switch (cmd) { 439 case SIOCAIFADDR: 440 case SIOCDIFADDR: 441 case SIOCGIFALIAS: 442 case SIOCGIFAFLAG_IN: 443 if (ifra->ifra_addr.sin_family == AF_INET) { 444 int s; 445 446 if (ia != NULL) 447 ia4_release(ia, &psref); 448 s = pserialize_read_enter(); 449 IN_ADDRHASH_READER_FOREACH(ia, 450 ifra->ifra_addr.sin_addr.s_addr) { 451 if (ia->ia_ifp == ifp && 452 in_hosteq(ia->ia_addr.sin_addr, 453 ifra->ifra_addr.sin_addr)) 454 break; 455 } 456 if (ia != NULL) 457 ia4_acquire(ia, &psref); 458 pserialize_read_exit(s); 459 } 460 if ((cmd == SIOCDIFADDR || 461 cmd == SIOCGIFALIAS || 462 cmd == SIOCGIFAFLAG_IN) && 463 ia == NULL) { 464 error = EADDRNOTAVAIL; 465 goto out; 466 } 467 468 if (cmd == SIOCDIFADDR && 469 ifra->ifra_addr.sin_family == AF_UNSPEC) { 470 ifra->ifra_addr.sin_family = AF_INET; 471 } 472 /* FALLTHROUGH */ 473 case SIOCSIFADDR: 474 if (ia == NULL || ia->ia_addr.sin_family != AF_INET) 475 ; 476 else if (ifra->ifra_addr.sin_len == 0) { 477 ifra->ifra_addr = ia->ia_addr; 478 hostIsNew = 0; 479 } else if (in_hosteq(ia->ia_addr.sin_addr, 480 ifra->ifra_addr.sin_addr)) 481 hostIsNew = 0; 482 if (ifra->ifra_addr.sin_family != AF_INET) { 483 error = EAFNOSUPPORT; 484 goto out; 485 } 486 /* FALLTHROUGH */ 487 case SIOCSIFDSTADDR: 488 if (cmd == SIOCSIFDSTADDR && 489 ifreq_getaddr(cmd, ifr)->sa_family != AF_INET) { 490 error = EAFNOSUPPORT; 491 goto out; 492 } 493 /* FALLTHROUGH */ 494 case SIOCSIFNETMASK: 495 if (ifp == NULL) 496 panic("in_control"); 497 498 if (cmd == SIOCGIFALIAS || cmd == SIOCGIFAFLAG_IN) 499 break; 500 501 if (ia == NULL && 502 (cmd == SIOCSIFNETMASK || cmd == SIOCSIFDSTADDR)) { 503 error = EADDRNOTAVAIL; 504 goto out; 505 } 506 507 if (kauth_authorize_network(curlwp->l_cred, KAUTH_NETWORK_INTERFACE, 508 KAUTH_REQ_NETWORK_INTERFACE_SETPRIV, ifp, (void *)cmd, 509 NULL) != 0) { 510 error = EPERM; 511 goto out; 512 } 513 514 if (ia == NULL) { 515 ia = malloc(sizeof(*ia), M_IFADDR, M_WAITOK|M_ZERO); 516 if (ia == NULL) { 517 error = ENOBUFS; 518 goto out; 519 } 520 ia->ia_ifa.ifa_addr = sintosa(&ia->ia_addr); 521 ia->ia_ifa.ifa_dstaddr = sintosa(&ia->ia_dstaddr); 522 ia->ia_ifa.ifa_netmask = sintosa(&ia->ia_sockmask); 523 #ifdef IPSELSRC 524 ia->ia_ifa.ifa_getifa = in_getifa; 525 #else /* IPSELSRC */ 526 ia->ia_ifa.ifa_getifa = NULL; 527 #endif /* IPSELSRC */ 528 ia->ia_sockmask.sin_len = 8; 529 ia->ia_sockmask.sin_family = AF_INET; 530 if (ifp->if_flags & IFF_BROADCAST) { 531 ia->ia_broadaddr.sin_len = sizeof(ia->ia_addr); 532 ia->ia_broadaddr.sin_family = AF_INET; 533 } 534 ia->ia_ifp = ifp; 535 ia->ia_idsalt = cprng_fast32() % 65535; 536 LIST_INIT(&ia->ia_multiaddrs); 537 IN_ADDRHASH_ENTRY_INIT(ia); 538 IN_ADDRLIST_ENTRY_INIT(ia); 539 ifa_psref_init(&ia->ia_ifa); 540 /* 541 * We need a reference to make ia survive over in_ifinit 542 * that does ifaref and ifafree. 543 */ 544 ifaref(&ia->ia_ifa); 545 546 newifaddr = 1; 547 } 548 break; 549 550 case SIOCSIFBRDADDR: 551 if (kauth_authorize_network(curlwp->l_cred, KAUTH_NETWORK_INTERFACE, 552 KAUTH_REQ_NETWORK_INTERFACE_SETPRIV, ifp, (void *)cmd, 553 NULL) != 0) { 554 error = EPERM; 555 goto out; 556 } 557 /* FALLTHROUGH */ 558 559 case SIOCGIFADDR: 560 case SIOCGIFNETMASK: 561 case SIOCGIFDSTADDR: 562 case SIOCGIFBRDADDR: 563 if (ia == NULL) { 564 error = EADDRNOTAVAIL; 565 goto out; 566 } 567 break; 568 } 569 error = 0; 570 switch (cmd) { 571 572 case SIOCGIFADDR: 573 ifreq_setaddr(cmd, ifr, sintocsa(&ia->ia_addr)); 574 break; 575 576 case SIOCGIFBRDADDR: 577 if ((ifp->if_flags & IFF_BROADCAST) == 0) { 578 error = EINVAL; 579 goto out; 580 } 581 ifreq_setdstaddr(cmd, ifr, sintocsa(&ia->ia_broadaddr)); 582 break; 583 584 case SIOCGIFDSTADDR: 585 if ((ifp->if_flags & IFF_POINTOPOINT) == 0) { 586 error = EINVAL; 587 goto out; 588 } 589 ifreq_setdstaddr(cmd, ifr, sintocsa(&ia->ia_dstaddr)); 590 break; 591 592 case SIOCGIFNETMASK: 593 /* 594 * We keep the number of trailing zero bytes the sin_len field 595 * of ia_sockmask, so we fix this before we pass it back to 596 * userland. 597 */ 598 oldaddr = ia->ia_sockmask; 599 oldaddr.sin_len = sizeof(struct sockaddr_in); 600 ifreq_setaddr(cmd, ifr, (const void *)&oldaddr); 601 break; 602 603 case SIOCSIFDSTADDR: 604 if ((ifp->if_flags & IFF_POINTOPOINT) == 0) { 605 error = EINVAL; 606 goto out; 607 } 608 oldaddr = ia->ia_dstaddr; 609 ia->ia_dstaddr = *satocsin(ifreq_getdstaddr(cmd, ifr)); 610 if ((error = if_addr_init(ifp, &ia->ia_ifa, false)) != 0) { 611 ia->ia_dstaddr = oldaddr; 612 goto out; 613 } 614 if (ia->ia_flags & IFA_ROUTE) { 615 ia->ia_ifa.ifa_dstaddr = sintosa(&oldaddr); 616 rtinit(&ia->ia_ifa, RTM_DELETE, RTF_HOST); 617 ia->ia_ifa.ifa_dstaddr = sintosa(&ia->ia_dstaddr); 618 rtinit(&ia->ia_ifa, RTM_ADD, RTF_HOST|RTF_UP); 619 } 620 break; 621 622 case SIOCSIFBRDADDR: 623 if ((ifp->if_flags & IFF_BROADCAST) == 0) { 624 error = EINVAL; 625 goto out; 626 } 627 ia->ia_broadaddr = *satocsin(ifreq_getbroadaddr(cmd, ifr)); 628 break; 629 630 case SIOCSIFADDR: 631 if (!newifaddr) { 632 in_addrhash_remove(ia); 633 need_reinsert = true; 634 } 635 error = in_ifinit(ifp, ia, satocsin(ifreq_getaddr(cmd, ifr)), 636 NULL, 1); 637 638 run_hook = true; 639 break; 640 641 case SIOCSIFNETMASK: 642 in_scrubprefix(ia); 643 ia->ia_sockmask = *satocsin(ifreq_getaddr(cmd, ifr)); 644 ia->ia_subnetmask = ia->ia_sockmask.sin_addr.s_addr; 645 if (!newifaddr) { 646 in_addrhash_remove(ia); 647 need_reinsert = true; 648 } 649 error = in_ifinit(ifp, ia, NULL, NULL, 0); 650 break; 651 652 case SIOCAIFADDR: 653 maskIsNew = 0; 654 if (ifra->ifra_mask.sin_len) { 655 in_scrubprefix(ia); 656 ia->ia_sockmask = ifra->ifra_mask; 657 ia->ia_subnetmask = ia->ia_sockmask.sin_addr.s_addr; 658 maskIsNew = 1; 659 } 660 if ((ifp->if_flags & IFF_POINTOPOINT) && 661 (ifra->ifra_dstaddr.sin_family == AF_INET)) { 662 new_dstaddr = &ifra->ifra_dstaddr; 663 maskIsNew = 1; /* We lie; but the effect's the same */ 664 } else 665 new_dstaddr = NULL; 666 if (ifra->ifra_addr.sin_family == AF_INET && 667 (hostIsNew || maskIsNew)) { 668 if (!newifaddr) { 669 in_addrhash_remove(ia); 670 need_reinsert = true; 671 } 672 error = in_ifinit(ifp, ia, &ifra->ifra_addr, 673 new_dstaddr, 0); 674 } 675 if ((ifp->if_flags & IFF_BROADCAST) && 676 (ifra->ifra_broadaddr.sin_family == AF_INET)) 677 ia->ia_broadaddr = ifra->ifra_broadaddr; 678 run_hook = true; 679 break; 680 681 case SIOCGIFALIAS: 682 ifra->ifra_mask = ia->ia_sockmask; 683 if ((ifp->if_flags & IFF_POINTOPOINT) && 684 (ia->ia_dstaddr.sin_family == AF_INET)) 685 ifra->ifra_dstaddr = ia->ia_dstaddr; 686 else if ((ifp->if_flags & IFF_BROADCAST) && 687 (ia->ia_broadaddr.sin_family == AF_INET)) 688 ifra->ifra_broadaddr = ia->ia_broadaddr; 689 else 690 memset(&ifra->ifra_broadaddr, 0, 691 sizeof(ifra->ifra_broadaddr)); 692 break; 693 694 case SIOCGIFAFLAG_IN: 695 ifr->ifr_addrflags = ia->ia4_flags; 696 break; 697 698 case SIOCDIFADDR: 699 ia4_release(ia, &psref); 700 ifaref(&ia->ia_ifa); 701 in_purgeaddr(&ia->ia_ifa); 702 pfil_run_addrhooks(if_pfil, cmd, &ia->ia_ifa); 703 ifafree(&ia->ia_ifa); 704 ia = NULL; 705 break; 706 707 #ifdef MROUTING 708 case SIOCGETVIFCNT: 709 case SIOCGETSGCNT: 710 error = mrt_ioctl(so, cmd, data); 711 break; 712 #endif /* MROUTING */ 713 714 default: 715 error = ENOTTY; 716 goto out; 717 } 718 719 /* 720 * XXX insert regardless of error to make in_purgeaddr below work. 721 * Need to improve. 722 */ 723 if (newifaddr) { 724 ifaref(&ia->ia_ifa); 725 ifa_insert(ifp, &ia->ia_ifa); 726 727 mutex_enter(&in_ifaddr_lock); 728 TAILQ_INSERT_TAIL(&in_ifaddrhead, ia, ia_list); 729 IN_ADDRLIST_WRITER_INSERT_TAIL(ia); 730 in_addrhash_insert_locked(ia); 731 /* Release a reference that is held just after creation. */ 732 ifafree(&ia->ia_ifa); 733 mutex_exit(&in_ifaddr_lock); 734 } else if (need_reinsert) { 735 in_addrhash_insert(ia); 736 } 737 738 if (error == 0) { 739 if (run_hook) 740 pfil_run_addrhooks(if_pfil, cmd, &ia->ia_ifa); 741 } else if (newifaddr) { 742 KASSERT(ia != NULL); 743 in_purgeaddr(&ia->ia_ifa); 744 ia = NULL; 745 } 746 747 out: 748 if (!newifaddr && ia != NULL) 749 ia4_release(ia, &psref); 750 curlwp_bindx(bound); 751 return error; 752 } 753 754 int 755 in_control(struct socket *so, u_long cmd, void *data, struct ifnet *ifp) 756 { 757 int error; 758 759 #ifndef NET_MPSAFE 760 KASSERT(KERNEL_LOCKED_P()); 761 #endif 762 error = in_control0(so, cmd, data, ifp); 763 764 return error; 765 } 766 767 /* Add ownaddr as loopback rtentry. */ 768 static void 769 in_ifaddlocal(struct ifaddr *ifa) 770 { 771 struct in_ifaddr *ia; 772 773 ia = (struct in_ifaddr *)ifa; 774 if (ia->ia_addr.sin_addr.s_addr == INADDR_ANY || 775 (ia->ia_ifp->if_flags & IFF_POINTOPOINT && 776 in_hosteq(ia->ia_dstaddr.sin_addr, ia->ia_addr.sin_addr))) 777 { 778 rt_addrmsg(RTM_NEWADDR, ifa); 779 return; 780 } 781 782 rt_ifa_addlocal(ifa); 783 } 784 785 /* Remove loopback entry of ownaddr */ 786 static void 787 in_ifremlocal(struct ifaddr *ifa) 788 { 789 struct in_ifaddr *ia, *p; 790 struct ifaddr *alt_ifa = NULL; 791 int ia_count = 0; 792 int s; 793 struct psref psref; 794 int bound = curlwp_bind(); 795 796 ia = (struct in_ifaddr *)ifa; 797 /* Delete the entry if exactly one ifaddr matches the 798 * address, ifa->ifa_addr. */ 799 s = pserialize_read_enter(); 800 IN_ADDRLIST_READER_FOREACH(p) { 801 if (!in_hosteq(p->ia_addr.sin_addr, ia->ia_addr.sin_addr)) 802 continue; 803 if (p->ia_ifp != ia->ia_ifp) 804 alt_ifa = &p->ia_ifa; 805 if (++ia_count > 1 && alt_ifa != NULL) 806 break; 807 } 808 if (alt_ifa != NULL && ia_count > 1) 809 ifa_acquire(alt_ifa, &psref); 810 pserialize_read_exit(s); 811 812 if (ia_count == 0) 813 goto out; 814 815 rt_ifa_remlocal(ifa, ia_count == 1 ? NULL : alt_ifa); 816 if (alt_ifa != NULL && ia_count > 1) 817 ifa_release(alt_ifa, &psref); 818 out: 819 curlwp_bindx(bound); 820 } 821 822 static void 823 in_scrubaddr(struct in_ifaddr *ia) 824 { 825 826 /* stop DAD processing */ 827 if (ia->ia_dad_stop != NULL) 828 ia->ia_dad_stop(&ia->ia_ifa); 829 830 in_scrubprefix(ia); 831 in_ifremlocal(&ia->ia_ifa); 832 833 mutex_enter(&in_ifaddr_lock); 834 if (ia->ia_allhosts != NULL) { 835 in_delmulti(ia->ia_allhosts); 836 ia->ia_allhosts = NULL; 837 } 838 mutex_exit(&in_ifaddr_lock); 839 } 840 841 /* 842 * Depends on it isn't called in concurrent. It should be guaranteed 843 * by ifa->ifa_ifp's ioctl lock. The possible callers are in_control 844 * and if_purgeaddrs; the former is called iva ifa->ifa_ifp's ioctl 845 * and the latter is called via ifa->ifa_ifp's if_detach. The functions 846 * never be executed in concurrent. 847 */ 848 void 849 in_purgeaddr(struct ifaddr *ifa) 850 { 851 struct in_ifaddr *ia = (void *) ifa; 852 struct ifnet *ifp = ifa->ifa_ifp; 853 854 /* KASSERT(!ifa_held(ifa)); XXX need ifa_not_held (psref_not_held) */ 855 856 ifa->ifa_flags |= IFA_DESTROYING; 857 in_scrubaddr(ia); 858 859 mutex_enter(&in_ifaddr_lock); 860 in_addrhash_remove_locked(ia); 861 TAILQ_REMOVE(&in_ifaddrhead, ia, ia_list); 862 IN_ADDRLIST_WRITER_REMOVE(ia); 863 ifa_remove(ifp, &ia->ia_ifa); 864 /* Assume ifa_remove called pserialize_perform and psref_destroy */ 865 mutex_exit(&in_ifaddr_lock); 866 IN_ADDRHASH_ENTRY_DESTROY(ia); 867 IN_ADDRLIST_ENTRY_DESTROY(ia); 868 ifafree(&ia->ia_ifa); 869 in_setmaxmtu(); 870 } 871 872 static void 873 in_addrhash_insert_locked(struct in_ifaddr *ia) 874 { 875 876 KASSERT(mutex_owned(&in_ifaddr_lock)); 877 878 LIST_INSERT_HEAD(&IN_IFADDR_HASH(ia->ia_addr.sin_addr.s_addr), ia, 879 ia_hash); 880 IN_ADDRHASH_ENTRY_INIT(ia); 881 IN_ADDRHASH_WRITER_INSERT_HEAD(ia); 882 } 883 884 void 885 in_addrhash_insert(struct in_ifaddr *ia) 886 { 887 888 mutex_enter(&in_ifaddr_lock); 889 in_addrhash_insert_locked(ia); 890 mutex_exit(&in_ifaddr_lock); 891 } 892 893 static void 894 in_addrhash_remove_locked(struct in_ifaddr *ia) 895 { 896 897 KASSERT(mutex_owned(&in_ifaddr_lock)); 898 899 LIST_REMOVE(ia, ia_hash); 900 IN_ADDRHASH_WRITER_REMOVE(ia); 901 } 902 903 void 904 in_addrhash_remove(struct in_ifaddr *ia) 905 { 906 907 mutex_enter(&in_ifaddr_lock); 908 in_addrhash_remove_locked(ia); 909 #ifdef NET_MPSAFE 910 pserialize_perform(in_ifaddrhash_psz); 911 #endif 912 mutex_exit(&in_ifaddr_lock); 913 IN_ADDRHASH_ENTRY_DESTROY(ia); 914 } 915 916 void 917 in_purgeif(struct ifnet *ifp) /* MUST be called at splsoftnet() */ 918 { 919 920 IFNET_LOCK(ifp); 921 if_purgeaddrs(ifp, AF_INET, in_purgeaddr); 922 igmp_purgeif(ifp); /* manipulates pools */ 923 #ifdef MROUTING 924 ip_mrouter_detach(ifp); 925 #endif 926 IFNET_UNLOCK(ifp); 927 } 928 929 /* 930 * SIOC[GAD]LIFADDR. 931 * SIOCGLIFADDR: get first address. (???) 932 * SIOCGLIFADDR with IFLR_PREFIX: 933 * get first address that matches the specified prefix. 934 * SIOCALIFADDR: add the specified address. 935 * SIOCALIFADDR with IFLR_PREFIX: 936 * EINVAL since we can't deduce hostid part of the address. 937 * SIOCDLIFADDR: delete the specified address. 938 * SIOCDLIFADDR with IFLR_PREFIX: 939 * delete the first address that matches the specified prefix. 940 * return values: 941 * EINVAL on invalid parameters 942 * EADDRNOTAVAIL on prefix match failed/specified address not found 943 * other values may be returned from in_ioctl() 944 */ 945 static int 946 in_lifaddr_ioctl(struct socket *so, u_long cmd, void *data, 947 struct ifnet *ifp) 948 { 949 struct if_laddrreq *iflr = (struct if_laddrreq *)data; 950 struct ifaddr *ifa; 951 struct sockaddr *sa; 952 953 /* sanity checks */ 954 if (data == NULL || ifp == NULL) { 955 panic("invalid argument to in_lifaddr_ioctl"); 956 /*NOTRECHED*/ 957 } 958 959 switch (cmd) { 960 case SIOCGLIFADDR: 961 /* address must be specified on GET with IFLR_PREFIX */ 962 if ((iflr->flags & IFLR_PREFIX) == 0) 963 break; 964 /*FALLTHROUGH*/ 965 case SIOCALIFADDR: 966 case SIOCDLIFADDR: 967 /* address must be specified on ADD and DELETE */ 968 sa = (struct sockaddr *)&iflr->addr; 969 if (sa->sa_family != AF_INET) 970 return EINVAL; 971 if (sa->sa_len != sizeof(struct sockaddr_in)) 972 return EINVAL; 973 /* XXX need improvement */ 974 sa = (struct sockaddr *)&iflr->dstaddr; 975 if (sa->sa_family != AF_UNSPEC && sa->sa_family != AF_INET) 976 return EINVAL; 977 if (sa->sa_len != 0 && sa->sa_len != sizeof(struct sockaddr_in)) 978 return EINVAL; 979 break; 980 default: /*shouldn't happen*/ 981 #if 0 982 panic("invalid cmd to in_lifaddr_ioctl"); 983 /*NOTREACHED*/ 984 #else 985 return EOPNOTSUPP; 986 #endif 987 } 988 if (sizeof(struct in_addr) * NBBY < iflr->prefixlen) 989 return EINVAL; 990 991 switch (cmd) { 992 case SIOCALIFADDR: 993 { 994 struct in_aliasreq ifra; 995 996 if (iflr->flags & IFLR_PREFIX) 997 return EINVAL; 998 999 /* copy args to in_aliasreq, perform ioctl(SIOCAIFADDR). */ 1000 memset(&ifra, 0, sizeof(ifra)); 1001 memcpy(ifra.ifra_name, iflr->iflr_name, 1002 sizeof(ifra.ifra_name)); 1003 1004 memcpy(&ifra.ifra_addr, &iflr->addr, 1005 ((struct sockaddr *)&iflr->addr)->sa_len); 1006 1007 if (((struct sockaddr *)&iflr->dstaddr)->sa_family) { /*XXX*/ 1008 memcpy(&ifra.ifra_dstaddr, &iflr->dstaddr, 1009 ((struct sockaddr *)&iflr->dstaddr)->sa_len); 1010 } 1011 1012 ifra.ifra_mask.sin_family = AF_INET; 1013 ifra.ifra_mask.sin_len = sizeof(struct sockaddr_in); 1014 in_len2mask(&ifra.ifra_mask.sin_addr, iflr->prefixlen); 1015 1016 return in_control(so, SIOCAIFADDR, &ifra, ifp); 1017 } 1018 case SIOCGLIFADDR: 1019 case SIOCDLIFADDR: 1020 { 1021 struct in_ifaddr *ia; 1022 struct in_addr mask, candidate, match; 1023 struct sockaddr_in *sin; 1024 int cmp, s; 1025 1026 memset(&mask, 0, sizeof(mask)); 1027 memset(&match, 0, sizeof(match)); /* XXX gcc */ 1028 if (iflr->flags & IFLR_PREFIX) { 1029 /* lookup a prefix rather than address. */ 1030 in_len2mask(&mask, iflr->prefixlen); 1031 1032 sin = (struct sockaddr_in *)&iflr->addr; 1033 match.s_addr = sin->sin_addr.s_addr; 1034 match.s_addr &= mask.s_addr; 1035 1036 /* if you set extra bits, that's wrong */ 1037 if (match.s_addr != sin->sin_addr.s_addr) 1038 return EINVAL; 1039 1040 cmp = 1; 1041 } else { 1042 if (cmd == SIOCGLIFADDR) { 1043 /* on getting an address, take the 1st match */ 1044 cmp = 0; /*XXX*/ 1045 } else { 1046 /* on deleting an address, do exact match */ 1047 in_len2mask(&mask, 32); 1048 sin = (struct sockaddr_in *)&iflr->addr; 1049 match.s_addr = sin->sin_addr.s_addr; 1050 1051 cmp = 1; 1052 } 1053 } 1054 1055 s = pserialize_read_enter(); 1056 IFADDR_READER_FOREACH(ifa, ifp) { 1057 if (ifa->ifa_addr->sa_family != AF_INET) 1058 continue; 1059 if (cmp == 0) 1060 break; 1061 candidate.s_addr = ((struct sockaddr_in *)ifa->ifa_addr)->sin_addr.s_addr; 1062 candidate.s_addr &= mask.s_addr; 1063 if (candidate.s_addr == match.s_addr) 1064 break; 1065 } 1066 if (ifa == NULL) { 1067 pserialize_read_exit(s); 1068 return EADDRNOTAVAIL; 1069 } 1070 ia = (struct in_ifaddr *)ifa; 1071 1072 if (cmd == SIOCGLIFADDR) { 1073 /* fill in the if_laddrreq structure */ 1074 memcpy(&iflr->addr, &ia->ia_addr, ia->ia_addr.sin_len); 1075 1076 if ((ifp->if_flags & IFF_POINTOPOINT) != 0) { 1077 memcpy(&iflr->dstaddr, &ia->ia_dstaddr, 1078 ia->ia_dstaddr.sin_len); 1079 } else 1080 memset(&iflr->dstaddr, 0, sizeof(iflr->dstaddr)); 1081 1082 iflr->prefixlen = 1083 in_mask2len(&ia->ia_sockmask.sin_addr); 1084 1085 iflr->flags = 0; /*XXX*/ 1086 pserialize_read_exit(s); 1087 1088 return 0; 1089 } else { 1090 struct in_aliasreq ifra; 1091 1092 /* fill in_aliasreq and do ioctl(SIOCDIFADDR) */ 1093 memset(&ifra, 0, sizeof(ifra)); 1094 memcpy(ifra.ifra_name, iflr->iflr_name, 1095 sizeof(ifra.ifra_name)); 1096 1097 memcpy(&ifra.ifra_addr, &ia->ia_addr, 1098 ia->ia_addr.sin_len); 1099 if ((ifp->if_flags & IFF_POINTOPOINT) != 0) { 1100 memcpy(&ifra.ifra_dstaddr, &ia->ia_dstaddr, 1101 ia->ia_dstaddr.sin_len); 1102 } 1103 memcpy(&ifra.ifra_dstaddr, &ia->ia_sockmask, 1104 ia->ia_sockmask.sin_len); 1105 pserialize_read_exit(s); 1106 1107 return in_control(so, SIOCDIFADDR, &ifra, ifp); 1108 } 1109 } 1110 } 1111 1112 return EOPNOTSUPP; /*just for safety*/ 1113 } 1114 1115 /* 1116 * Initialize an interface's internet address 1117 * and routing table entry. 1118 */ 1119 int 1120 in_ifinit(struct ifnet *ifp, struct in_ifaddr *ia, 1121 const struct sockaddr_in *sin, const struct sockaddr_in *dst, int scrub) 1122 { 1123 u_int32_t i; 1124 struct sockaddr_in oldaddr, olddst; 1125 int s, oldflags, flags = RTF_UP, error, hostIsNew; 1126 1127 if (sin == NULL) 1128 sin = &ia->ia_addr; 1129 if (dst == NULL) 1130 dst = &ia->ia_dstaddr; 1131 1132 /* 1133 * Set up new addresses. 1134 */ 1135 oldaddr = ia->ia_addr; 1136 olddst = ia->ia_dstaddr; 1137 oldflags = ia->ia4_flags; 1138 ia->ia_addr = *sin; 1139 ia->ia_dstaddr = *dst; 1140 hostIsNew = oldaddr.sin_family != AF_INET || 1141 !in_hosteq(ia->ia_addr.sin_addr, oldaddr.sin_addr); 1142 if (!scrub) 1143 scrub = oldaddr.sin_family != ia->ia_dstaddr.sin_family || 1144 !in_hosteq(ia->ia_dstaddr.sin_addr, olddst.sin_addr); 1145 1146 /* 1147 * Configure address flags. 1148 * We need to do this early because they may be adjusted 1149 * by if_addr_init depending on the address. 1150 */ 1151 if (ia->ia4_flags & IN_IFF_DUPLICATED) { 1152 ia->ia4_flags &= ~IN_IFF_DUPLICATED; 1153 hostIsNew = 1; 1154 } 1155 if (ifp->if_link_state == LINK_STATE_DOWN) { 1156 ia->ia4_flags |= IN_IFF_DETACHED; 1157 ia->ia4_flags &= ~IN_IFF_TENTATIVE; 1158 } else if (hostIsNew && if_do_dad(ifp) && ip_dad_enabled()) 1159 ia->ia4_flags |= IN_IFF_TRYTENTATIVE; 1160 1161 /* 1162 * Give the interface a chance to initialize 1163 * if this is its first address, 1164 * and to validate the address if necessary. 1165 */ 1166 s = splsoftnet(); 1167 error = if_addr_init(ifp, &ia->ia_ifa, true); 1168 splx(s); 1169 /* Now clear the try tentative flag, its job is done. */ 1170 ia->ia4_flags &= ~IN_IFF_TRYTENTATIVE; 1171 if (error != 0) { 1172 ia->ia_addr = oldaddr; 1173 ia->ia_dstaddr = olddst; 1174 ia->ia4_flags = oldflags; 1175 return error; 1176 } 1177 1178 if (scrub || hostIsNew) { 1179 int newflags = ia->ia4_flags; 1180 1181 ia->ia_ifa.ifa_addr = sintosa(&oldaddr); 1182 ia->ia_ifa.ifa_dstaddr = sintosa(&olddst); 1183 ia->ia4_flags = oldflags; 1184 if (hostIsNew) 1185 in_scrubaddr(ia); 1186 else if (scrub) 1187 in_scrubprefix(ia); 1188 ia->ia_ifa.ifa_addr = sintosa(&ia->ia_addr); 1189 ia->ia_ifa.ifa_dstaddr = sintosa(&ia->ia_dstaddr); 1190 ia->ia4_flags = newflags; 1191 } 1192 1193 i = ia->ia_addr.sin_addr.s_addr; 1194 if (ifp->if_flags & IFF_POINTOPOINT) 1195 ia->ia_netmask = INADDR_BROADCAST; /* default to /32 */ 1196 else if (IN_CLASSA(i)) 1197 ia->ia_netmask = IN_CLASSA_NET; 1198 else if (IN_CLASSB(i)) 1199 ia->ia_netmask = IN_CLASSB_NET; 1200 else 1201 ia->ia_netmask = IN_CLASSC_NET; 1202 /* 1203 * The subnet mask usually includes at least the standard network part, 1204 * but may may be smaller in the case of supernetting. 1205 * If it is set, we believe it. 1206 */ 1207 if (ia->ia_subnetmask == 0) { 1208 ia->ia_subnetmask = ia->ia_netmask; 1209 ia->ia_sockmask.sin_addr.s_addr = ia->ia_subnetmask; 1210 } else 1211 ia->ia_netmask &= ia->ia_subnetmask; 1212 1213 ia->ia_net = i & ia->ia_netmask; 1214 ia->ia_subnet = i & ia->ia_subnetmask; 1215 in_socktrim(&ia->ia_sockmask); 1216 1217 /* re-calculate the "in_maxmtu" value */ 1218 in_setmaxmtu(); 1219 1220 ia->ia_ifa.ifa_metric = ifp->if_metric; 1221 if (ifp->if_flags & IFF_BROADCAST) { 1222 if (ia->ia_subnetmask == IN_RFC3021_MASK) { 1223 ia->ia_broadaddr.sin_addr.s_addr = INADDR_BROADCAST; 1224 ia->ia_netbroadcast.s_addr = INADDR_BROADCAST; 1225 } else { 1226 ia->ia_broadaddr.sin_addr.s_addr = 1227 ia->ia_subnet | ~ia->ia_subnetmask; 1228 ia->ia_netbroadcast.s_addr = 1229 ia->ia_net | ~ia->ia_netmask; 1230 } 1231 } else if (ifp->if_flags & IFF_LOOPBACK) { 1232 ia->ia_dstaddr = ia->ia_addr; 1233 flags |= RTF_HOST; 1234 } else if (ifp->if_flags & IFF_POINTOPOINT) { 1235 if (ia->ia_dstaddr.sin_family != AF_INET) 1236 return (0); 1237 flags |= RTF_HOST; 1238 } 1239 1240 /* Add the local route to the address */ 1241 in_ifaddlocal(&ia->ia_ifa); 1242 1243 /* Add the prefix route for the address */ 1244 error = in_addprefix(ia, flags); 1245 1246 /* 1247 * If the interface supports multicast, join the "all hosts" 1248 * multicast group on that interface. 1249 */ 1250 mutex_enter(&in_ifaddr_lock); 1251 if ((ifp->if_flags & IFF_MULTICAST) != 0 && ia->ia_allhosts == NULL) { 1252 struct in_addr addr; 1253 1254 addr.s_addr = INADDR_ALLHOSTS_GROUP; 1255 ia->ia_allhosts = in_addmulti(&addr, ifp); 1256 } 1257 mutex_exit(&in_ifaddr_lock); 1258 1259 if (hostIsNew && 1260 ia->ia4_flags & IN_IFF_TENTATIVE && 1261 if_do_dad(ifp)) 1262 ia->ia_dad_start((struct ifaddr *)ia); 1263 1264 return error; 1265 } 1266 1267 #define rtinitflags(x) \ 1268 ((((x)->ia_ifp->if_flags & (IFF_LOOPBACK | IFF_POINTOPOINT)) != 0) \ 1269 ? RTF_HOST : 0) 1270 1271 /* 1272 * add a route to prefix ("connected route" in cisco terminology). 1273 * does nothing if there's some interface address with the same prefix already. 1274 */ 1275 static int 1276 in_addprefix(struct in_ifaddr *target, int flags) 1277 { 1278 struct in_ifaddr *ia; 1279 struct in_addr prefix, mask, p; 1280 int error; 1281 int s; 1282 1283 if ((flags & RTF_HOST) != 0) 1284 prefix = target->ia_dstaddr.sin_addr; 1285 else { 1286 prefix = target->ia_addr.sin_addr; 1287 mask = target->ia_sockmask.sin_addr; 1288 prefix.s_addr &= mask.s_addr; 1289 } 1290 1291 s = pserialize_read_enter(); 1292 IN_ADDRLIST_READER_FOREACH(ia) { 1293 if (rtinitflags(ia)) 1294 p = ia->ia_dstaddr.sin_addr; 1295 else { 1296 p = ia->ia_addr.sin_addr; 1297 p.s_addr &= ia->ia_sockmask.sin_addr.s_addr; 1298 } 1299 1300 if (prefix.s_addr != p.s_addr) 1301 continue; 1302 1303 /* 1304 * if we got a matching prefix route inserted by other 1305 * interface address, we don't need to bother 1306 * 1307 * XXX RADIX_MPATH implications here? -dyoung 1308 */ 1309 if (ia->ia_flags & IFA_ROUTE) { 1310 pserialize_read_exit(s); 1311 return 0; 1312 } 1313 } 1314 pserialize_read_exit(s); 1315 1316 /* 1317 * noone seem to have prefix route. insert it. 1318 */ 1319 error = rtinit(&target->ia_ifa, RTM_ADD, flags); 1320 if (error == 0) 1321 target->ia_flags |= IFA_ROUTE; 1322 else if (error == EEXIST) { 1323 /* 1324 * the fact the route already exists is not an error. 1325 */ 1326 error = 0; 1327 } 1328 return error; 1329 } 1330 1331 /* 1332 * remove a route to prefix ("connected route" in cisco terminology). 1333 * re-installs the route by using another interface address, if there's one 1334 * with the same prefix (otherwise we lose the route mistakenly). 1335 */ 1336 static int 1337 in_scrubprefix(struct in_ifaddr *target) 1338 { 1339 struct in_ifaddr *ia; 1340 struct in_addr prefix, mask, p; 1341 int error; 1342 int s; 1343 1344 /* If we don't have IFA_ROUTE we have nothing to do */ 1345 if ((target->ia_flags & IFA_ROUTE) == 0) 1346 return 0; 1347 1348 if (rtinitflags(target)) 1349 prefix = target->ia_dstaddr.sin_addr; 1350 else { 1351 prefix = target->ia_addr.sin_addr; 1352 mask = target->ia_sockmask.sin_addr; 1353 prefix.s_addr &= mask.s_addr; 1354 } 1355 1356 s = pserialize_read_enter(); 1357 IN_ADDRLIST_READER_FOREACH(ia) { 1358 if (rtinitflags(ia)) 1359 p = ia->ia_dstaddr.sin_addr; 1360 else { 1361 p = ia->ia_addr.sin_addr; 1362 p.s_addr &= ia->ia_sockmask.sin_addr.s_addr; 1363 } 1364 1365 if (prefix.s_addr != p.s_addr) 1366 continue; 1367 1368 /* 1369 * if we got a matching prefix route, move IFA_ROUTE to him 1370 */ 1371 if ((ia->ia_flags & IFA_ROUTE) == 0) { 1372 struct psref psref; 1373 int bound = curlwp_bind(); 1374 1375 ia4_acquire(ia, &psref); 1376 pserialize_read_exit(s); 1377 1378 rtinit(&target->ia_ifa, RTM_DELETE, 1379 rtinitflags(target)); 1380 target->ia_flags &= ~IFA_ROUTE; 1381 1382 error = rtinit(&ia->ia_ifa, RTM_ADD, 1383 rtinitflags(ia) | RTF_UP); 1384 if (error == 0) 1385 ia->ia_flags |= IFA_ROUTE; 1386 1387 ia4_release(ia, &psref); 1388 curlwp_bindx(bound); 1389 1390 return error; 1391 } 1392 } 1393 pserialize_read_exit(s); 1394 1395 /* 1396 * noone seem to have prefix route. remove it. 1397 */ 1398 rtinit(&target->ia_ifa, RTM_DELETE, rtinitflags(target)); 1399 target->ia_flags &= ~IFA_ROUTE; 1400 return 0; 1401 } 1402 1403 #undef rtinitflags 1404 1405 /* 1406 * Return 1 if the address might be a local broadcast address. 1407 */ 1408 int 1409 in_broadcast(struct in_addr in, struct ifnet *ifp) 1410 { 1411 struct ifaddr *ifa; 1412 int s; 1413 1414 KASSERT(ifp != NULL); 1415 1416 if (in.s_addr == INADDR_BROADCAST || 1417 in_nullhost(in)) 1418 return 1; 1419 if ((ifp->if_flags & IFF_BROADCAST) == 0) 1420 return 0; 1421 /* 1422 * Look through the list of addresses for a match 1423 * with a broadcast address. 1424 */ 1425 #define ia (ifatoia(ifa)) 1426 s = pserialize_read_enter(); 1427 IFADDR_READER_FOREACH(ifa, ifp) { 1428 if (ifa->ifa_addr->sa_family == AF_INET && 1429 !in_hosteq(in, ia->ia_addr.sin_addr) && 1430 (in_hosteq(in, ia->ia_broadaddr.sin_addr) || 1431 in_hosteq(in, ia->ia_netbroadcast) || 1432 (hostzeroisbroadcast && 1433 /* 1434 * Check for old-style (host 0) broadcast, but 1435 * taking into account that RFC 3021 obsoletes it. 1436 */ 1437 ia->ia_subnetmask != IN_RFC3021_MASK && 1438 (in.s_addr == ia->ia_subnet || 1439 in.s_addr == ia->ia_net)))) { 1440 pserialize_read_exit(s); 1441 return 1; 1442 } 1443 } 1444 pserialize_read_exit(s); 1445 return (0); 1446 #undef ia 1447 } 1448 1449 /* 1450 * perform DAD when interface becomes IFF_UP. 1451 */ 1452 void 1453 in_if_link_up(struct ifnet *ifp) 1454 { 1455 struct ifaddr *ifa; 1456 struct in_ifaddr *ia; 1457 int s, bound; 1458 1459 /* Ensure it's sane to run DAD */ 1460 if (ifp->if_link_state == LINK_STATE_DOWN) 1461 return; 1462 if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) 1463 return; 1464 1465 bound = curlwp_bind(); 1466 s = pserialize_read_enter(); 1467 IFADDR_READER_FOREACH(ifa, ifp) { 1468 struct psref psref; 1469 1470 if (ifa->ifa_addr->sa_family != AF_INET) 1471 continue; 1472 ifa_acquire(ifa, &psref); 1473 pserialize_read_exit(s); 1474 1475 ia = (struct in_ifaddr *)ifa; 1476 1477 /* If detached then mark as tentative */ 1478 if (ia->ia4_flags & IN_IFF_DETACHED) { 1479 ia->ia4_flags &= ~IN_IFF_DETACHED; 1480 if (ip_dad_enabled() && if_do_dad(ifp) && 1481 ia->ia_dad_start != NULL) 1482 ia->ia4_flags |= IN_IFF_TENTATIVE; 1483 else if ((ia->ia4_flags & IN_IFF_TENTATIVE) == 0) 1484 rt_addrmsg(RTM_NEWADDR, ifa); 1485 } 1486 1487 if (ia->ia4_flags & IN_IFF_TENTATIVE) { 1488 /* Clear the duplicated flag as we're starting DAD. */ 1489 ia->ia4_flags &= ~IN_IFF_DUPLICATED; 1490 ia->ia_dad_start(ifa); 1491 } 1492 1493 s = pserialize_read_enter(); 1494 ifa_release(ifa, &psref); 1495 } 1496 pserialize_read_exit(s); 1497 curlwp_bindx(bound); 1498 } 1499 1500 void 1501 in_if_up(struct ifnet *ifp) 1502 { 1503 1504 /* interface may not support link state, so bring it up also */ 1505 in_if_link_up(ifp); 1506 } 1507 1508 /* 1509 * Mark all addresses as detached. 1510 */ 1511 void 1512 in_if_link_down(struct ifnet *ifp) 1513 { 1514 struct ifaddr *ifa; 1515 struct in_ifaddr *ia; 1516 int s, bound; 1517 1518 bound = curlwp_bind(); 1519 s = pserialize_read_enter(); 1520 IFADDR_READER_FOREACH(ifa, ifp) { 1521 struct psref psref; 1522 1523 if (ifa->ifa_addr->sa_family != AF_INET) 1524 continue; 1525 ifa_acquire(ifa, &psref); 1526 pserialize_read_exit(s); 1527 1528 ia = (struct in_ifaddr *)ifa; 1529 1530 /* Stop DAD processing */ 1531 if (ia->ia_dad_stop != NULL) 1532 ia->ia_dad_stop(ifa); 1533 1534 /* 1535 * Mark the address as detached. 1536 */ 1537 if (!(ia->ia4_flags & IN_IFF_DETACHED)) { 1538 ia->ia4_flags |= IN_IFF_DETACHED; 1539 ia->ia4_flags &= 1540 ~(IN_IFF_TENTATIVE | IN_IFF_DUPLICATED); 1541 rt_addrmsg(RTM_NEWADDR, ifa); 1542 } 1543 1544 s = pserialize_read_enter(); 1545 ifa_release(ifa, &psref); 1546 } 1547 pserialize_read_exit(s); 1548 curlwp_bindx(bound); 1549 } 1550 1551 void 1552 in_if_down(struct ifnet *ifp) 1553 { 1554 1555 in_if_link_down(ifp); 1556 #if NARP > 0 1557 lltable_purge_entries(LLTABLE(ifp)); 1558 #endif 1559 } 1560 1561 void 1562 in_if_link_state_change(struct ifnet *ifp, int link_state) 1563 { 1564 1565 switch (link_state) { 1566 case LINK_STATE_DOWN: 1567 in_if_link_down(ifp); 1568 break; 1569 case LINK_STATE_UP: 1570 in_if_link_up(ifp); 1571 break; 1572 } 1573 } 1574 1575 /* 1576 * in_lookup_multi: look up the in_multi record for a given IP 1577 * multicast address on a given interface. If no matching record is 1578 * found, return NULL. 1579 */ 1580 struct in_multi * 1581 in_lookup_multi(struct in_addr addr, ifnet_t *ifp) 1582 { 1583 struct in_multi *inm; 1584 1585 KASSERT(rw_lock_held(&in_multilock)); 1586 1587 LIST_FOREACH(inm, &IN_MULTI_HASH(addr.s_addr, ifp), inm_list) { 1588 if (in_hosteq(inm->inm_addr, addr) && inm->inm_ifp == ifp) 1589 break; 1590 } 1591 return inm; 1592 } 1593 1594 /* 1595 * in_multi_group: check whether the address belongs to an IP multicast 1596 * group we are joined on this interface. Returns true or false. 1597 */ 1598 bool 1599 in_multi_group(struct in_addr addr, ifnet_t *ifp, int flags) 1600 { 1601 bool ingroup; 1602 1603 if (__predict_true(flags & IP_IGMP_MCAST) == 0) { 1604 rw_enter(&in_multilock, RW_READER); 1605 ingroup = in_lookup_multi(addr, ifp) != NULL; 1606 rw_exit(&in_multilock); 1607 } else { 1608 /* XXX Recursive call from ip_output(). */ 1609 KASSERT(rw_lock_held(&in_multilock)); 1610 ingroup = in_lookup_multi(addr, ifp) != NULL; 1611 } 1612 return ingroup; 1613 } 1614 1615 /* 1616 * Add an address to the list of IP multicast addresses for a given interface. 1617 */ 1618 struct in_multi * 1619 in_addmulti(struct in_addr *ap, ifnet_t *ifp) 1620 { 1621 struct sockaddr_in sin; 1622 struct in_multi *inm; 1623 1624 /* 1625 * See if address already in list. 1626 */ 1627 rw_enter(&in_multilock, RW_WRITER); 1628 inm = in_lookup_multi(*ap, ifp); 1629 if (inm != NULL) { 1630 /* 1631 * Found it; just increment the reference count. 1632 */ 1633 inm->inm_refcount++; 1634 rw_exit(&in_multilock); 1635 return inm; 1636 } 1637 1638 /* 1639 * New address; allocate a new multicast record. 1640 */ 1641 inm = pool_get(&inmulti_pool, PR_NOWAIT); 1642 if (inm == NULL) { 1643 rw_exit(&in_multilock); 1644 return NULL; 1645 } 1646 inm->inm_addr = *ap; 1647 inm->inm_ifp = ifp; 1648 inm->inm_refcount = 1; 1649 1650 /* 1651 * Ask the network driver to update its multicast reception 1652 * filter appropriately for the new address. 1653 */ 1654 sockaddr_in_init(&sin, ap, 0); 1655 if (if_mcast_op(ifp, SIOCADDMULTI, sintosa(&sin)) != 0) { 1656 rw_exit(&in_multilock); 1657 pool_put(&inmulti_pool, inm); 1658 return NULL; 1659 } 1660 1661 /* 1662 * Let IGMP know that we have joined a new IP multicast group. 1663 */ 1664 if (igmp_joingroup(inm) != 0) { 1665 rw_exit(&in_multilock); 1666 pool_put(&inmulti_pool, inm); 1667 return NULL; 1668 } 1669 LIST_INSERT_HEAD( 1670 &IN_MULTI_HASH(inm->inm_addr.s_addr, ifp), 1671 inm, inm_list); 1672 in_multientries++; 1673 rw_exit(&in_multilock); 1674 1675 return inm; 1676 } 1677 1678 /* 1679 * Delete a multicast address record. 1680 */ 1681 void 1682 in_delmulti(struct in_multi *inm) 1683 { 1684 struct sockaddr_in sin; 1685 1686 rw_enter(&in_multilock, RW_WRITER); 1687 if (--inm->inm_refcount > 0) { 1688 rw_exit(&in_multilock); 1689 return; 1690 } 1691 1692 /* 1693 * No remaining claims to this record; let IGMP know that 1694 * we are leaving the multicast group. 1695 */ 1696 igmp_leavegroup(inm); 1697 1698 /* 1699 * Notify the network driver to update its multicast reception 1700 * filter. 1701 */ 1702 sockaddr_in_init(&sin, &inm->inm_addr, 0); 1703 if_mcast_op(inm->inm_ifp, SIOCDELMULTI, sintosa(&sin)); 1704 1705 /* 1706 * Unlink from list. 1707 */ 1708 LIST_REMOVE(inm, inm_list); 1709 in_multientries--; 1710 rw_exit(&in_multilock); 1711 1712 pool_put(&inmulti_pool, inm); 1713 } 1714 1715 /* 1716 * in_next_multi: step through all of the in_multi records, one at a time. 1717 * The current position is remembered in "step", which the caller must 1718 * provide. in_first_multi(), below, must be called to initialize "step" 1719 * and get the first record. Both macros return a NULL "inm" when there 1720 * are no remaining records. 1721 */ 1722 struct in_multi * 1723 in_next_multi(struct in_multistep *step) 1724 { 1725 struct in_multi *inm; 1726 1727 KASSERT(rw_lock_held(&in_multilock)); 1728 1729 while (step->i_inm == NULL && step->i_n < IN_MULTI_HASH_SIZE) { 1730 step->i_inm = LIST_FIRST(&in_multihashtbl[++step->i_n]); 1731 } 1732 if ((inm = step->i_inm) != NULL) { 1733 step->i_inm = LIST_NEXT(inm, inm_list); 1734 } 1735 return inm; 1736 } 1737 1738 struct in_multi * 1739 in_first_multi(struct in_multistep *step) 1740 { 1741 KASSERT(rw_lock_held(&in_multilock)); 1742 1743 step->i_n = 0; 1744 step->i_inm = LIST_FIRST(&in_multihashtbl[0]); 1745 return in_next_multi(step); 1746 } 1747 1748 void 1749 in_multi_lock(int op) 1750 { 1751 rw_enter(&in_multilock, op); 1752 } 1753 1754 void 1755 in_multi_unlock(void) 1756 { 1757 rw_exit(&in_multilock); 1758 } 1759 1760 int 1761 in_multi_lock_held(void) 1762 { 1763 return rw_lock_held(&in_multilock); 1764 } 1765 1766 struct in_ifaddr * 1767 in_selectsrc(struct sockaddr_in *sin, struct route *ro, 1768 int soopts, struct ip_moptions *mopts, int *errorp, struct psref *psref) 1769 { 1770 struct rtentry *rt = NULL; 1771 struct in_ifaddr *ia = NULL; 1772 1773 KASSERT(ISSET(curlwp->l_pflag, LP_BOUND)); 1774 /* 1775 * If route is known or can be allocated now, take the 1776 * source address from the interface. Otherwise, punt. 1777 */ 1778 if ((soopts & SO_DONTROUTE) != 0) 1779 rtcache_free(ro); 1780 else { 1781 union { 1782 struct sockaddr dst; 1783 struct sockaddr_in dst4; 1784 } u; 1785 1786 sockaddr_in_init(&u.dst4, &sin->sin_addr, 0); 1787 rt = rtcache_lookup(ro, &u.dst); 1788 } 1789 /* 1790 * If we found a route, use the address 1791 * corresponding to the outgoing interface 1792 * unless it is the loopback (in case a route 1793 * to our address on another net goes to loopback). 1794 * 1795 * XXX Is this still true? Do we care? 1796 */ 1797 if (rt != NULL && (rt->rt_ifp->if_flags & IFF_LOOPBACK) == 0) { 1798 int s; 1799 struct ifaddr *ifa; 1800 /* 1801 * Just in case. May not need to do this workaround. 1802 * Revisit when working on rtentry MP-ification. 1803 */ 1804 s = pserialize_read_enter(); 1805 IFADDR_READER_FOREACH(ifa, rt->rt_ifp) { 1806 if (ifa == rt->rt_ifa) 1807 break; 1808 } 1809 if (ifa != NULL) 1810 ifa_acquire(ifa, psref); 1811 pserialize_read_exit(s); 1812 1813 ia = ifatoia(ifa); 1814 } 1815 if (ia == NULL) { 1816 u_int16_t fport = sin->sin_port; 1817 struct ifaddr *ifa; 1818 int s; 1819 1820 sin->sin_port = 0; 1821 ifa = ifa_ifwithladdr_psref(sintosa(sin), psref); 1822 sin->sin_port = fport; 1823 if (ifa == NULL) { 1824 /* Find 1st non-loopback AF_INET address */ 1825 s = pserialize_read_enter(); 1826 IN_ADDRLIST_READER_FOREACH(ia) { 1827 if (!(ia->ia_ifp->if_flags & IFF_LOOPBACK)) 1828 break; 1829 } 1830 if (ia != NULL) 1831 ia4_acquire(ia, psref); 1832 pserialize_read_exit(s); 1833 } else { 1834 /* ia is already referenced by psref */ 1835 ia = ifatoia(ifa); 1836 } 1837 if (ia == NULL) { 1838 *errorp = EADDRNOTAVAIL; 1839 goto out; 1840 } 1841 } 1842 /* 1843 * If the destination address is multicast and an outgoing 1844 * interface has been set as a multicast option, use the 1845 * address of that interface as our source address. 1846 */ 1847 if (IN_MULTICAST(sin->sin_addr.s_addr) && mopts != NULL) { 1848 struct ip_moptions *imo; 1849 1850 imo = mopts; 1851 if (imo->imo_multicast_if_index != 0) { 1852 struct ifnet *ifp; 1853 int s; 1854 1855 if (ia != NULL) 1856 ia4_release(ia, psref); 1857 s = pserialize_read_enter(); 1858 ifp = if_byindex(imo->imo_multicast_if_index); 1859 if (ifp != NULL) { 1860 /* XXX */ 1861 ia = in_get_ia_from_ifp_psref(ifp, psref); 1862 } else 1863 ia = NULL; 1864 if (ia == NULL || ia->ia4_flags & IN_IFF_NOTREADY) { 1865 pserialize_read_exit(s); 1866 if (ia != NULL) 1867 ia4_release(ia, psref); 1868 *errorp = EADDRNOTAVAIL; 1869 ia = NULL; 1870 goto out; 1871 } 1872 pserialize_read_exit(s); 1873 } 1874 } 1875 if (ia->ia_ifa.ifa_getifa != NULL) { 1876 ia = ifatoia((*ia->ia_ifa.ifa_getifa)(&ia->ia_ifa, 1877 sintosa(sin))); 1878 if (ia == NULL) { 1879 *errorp = EADDRNOTAVAIL; 1880 goto out; 1881 } 1882 /* FIXME NOMPSAFE */ 1883 ia4_acquire(ia, psref); 1884 } 1885 #ifdef GETIFA_DEBUG 1886 else 1887 printf("%s: missing ifa_getifa\n", __func__); 1888 #endif 1889 out: 1890 rtcache_unref(rt, ro); 1891 return ia; 1892 } 1893 1894 int 1895 in_tunnel_validate(const struct ip *ip, struct in_addr src, struct in_addr dst) 1896 { 1897 struct in_ifaddr *ia4; 1898 int s; 1899 1900 /* check for address match */ 1901 if (src.s_addr != ip->ip_dst.s_addr || 1902 dst.s_addr != ip->ip_src.s_addr) 1903 return 0; 1904 1905 /* martian filters on outer source - NOT done in ip_input! */ 1906 if (IN_MULTICAST(ip->ip_src.s_addr)) 1907 return 0; 1908 switch ((ntohl(ip->ip_src.s_addr) & 0xff000000) >> 24) { 1909 case 0: 1910 case 127: 1911 case 255: 1912 return 0; 1913 } 1914 /* reject packets with broadcast on source */ 1915 s = pserialize_read_enter(); 1916 IN_ADDRLIST_READER_FOREACH(ia4) { 1917 if ((ia4->ia_ifa.ifa_ifp->if_flags & IFF_BROADCAST) == 0) 1918 continue; 1919 if (ip->ip_src.s_addr == ia4->ia_broadaddr.sin_addr.s_addr) { 1920 pserialize_read_exit(s); 1921 return 0; 1922 } 1923 } 1924 pserialize_read_exit(s); 1925 1926 /* NOTE: packet may dropped by uRPF */ 1927 1928 /* return valid bytes length */ 1929 return sizeof(src) + sizeof(dst); 1930 } 1931 1932 #if NARP > 0 1933 1934 #define IN_LLTBL_DEFAULT_HSIZE 32 1935 #define IN_LLTBL_HASH(k, h) \ 1936 (((((((k >> 8) ^ k) >> 8) ^ k) >> 8) ^ k) & ((h) - 1)) 1937 1938 /* 1939 * Do actual deallocation of @lle. 1940 * Called by LLE_FREE_LOCKED when number of references 1941 * drops to zero. 1942 */ 1943 static void 1944 in_lltable_destroy_lle(struct llentry *lle) 1945 { 1946 1947 KASSERTMSG(lle->la_numheld == 0, "la_numheld=%d", lle->la_numheld); 1948 1949 LLE_WUNLOCK(lle); 1950 LLE_LOCK_DESTROY(lle); 1951 llentry_pool_put(lle); 1952 } 1953 1954 static struct llentry * 1955 in_lltable_new(struct in_addr addr4, u_int flags) 1956 { 1957 struct llentry *lle; 1958 1959 lle = llentry_pool_get(PR_NOWAIT); 1960 if (lle == NULL) /* NB: caller generates msg */ 1961 return NULL; 1962 1963 /* 1964 * For IPv4 this will trigger "arpresolve" to generate 1965 * an ARP request. 1966 */ 1967 lle->la_expire = time_uptime; /* mark expired */ 1968 lle->r_l3addr.addr4 = addr4; 1969 lle->lle_refcnt = 1; 1970 lle->lle_free = in_lltable_destroy_lle; 1971 LLE_LOCK_INIT(lle); 1972 callout_init(&lle->la_timer, CALLOUT_MPSAFE); 1973 1974 return lle; 1975 } 1976 1977 #define IN_ARE_MASKED_ADDR_EQUAL(d, a, m) ( \ 1978 (((ntohl((d).s_addr) ^ (a)->sin_addr.s_addr) & (m)->sin_addr.s_addr)) == 0 ) 1979 1980 static int 1981 in_lltable_match_prefix(const struct sockaddr *prefix, 1982 const struct sockaddr *mask, u_int flags, struct llentry *lle) 1983 { 1984 const struct sockaddr_in *pfx = (const struct sockaddr_in *)prefix; 1985 const struct sockaddr_in *msk = (const struct sockaddr_in *)mask; 1986 struct in_addr lle_addr; 1987 1988 lle_addr.s_addr = ntohl(lle->r_l3addr.addr4.s_addr); 1989 1990 /* 1991 * (flags & LLE_STATIC) means deleting all entries 1992 * including static ARP entries. 1993 */ 1994 if (IN_ARE_MASKED_ADDR_EQUAL(lle_addr, pfx, msk) && 1995 ((flags & LLE_STATIC) || !(lle->la_flags & LLE_STATIC))) 1996 return (1); 1997 1998 return (0); 1999 } 2000 2001 static void 2002 in_lltable_free_entry(struct lltable *llt, struct llentry *lle) 2003 { 2004 size_t pkts_dropped; 2005 2006 LLE_WLOCK_ASSERT(lle); 2007 KASSERT(llt != NULL); 2008 2009 pkts_dropped = llentry_free(lle); 2010 arp_stat_add(ARP_STAT_DFRDROPPED, (uint64_t)pkts_dropped); 2011 } 2012 2013 static int 2014 in_lltable_rtcheck(struct ifnet *ifp, u_int flags, const struct sockaddr *l3addr, 2015 const struct rtentry *rt) 2016 { 2017 int error = EINVAL; 2018 2019 if (rt == NULL) 2020 return error; 2021 2022 /* 2023 * If the gateway for an existing host route matches the target L3 2024 * address, which is a special route inserted by some implementation 2025 * such as MANET, and the interface is of the correct type, then 2026 * allow for ARP to proceed. 2027 */ 2028 if (rt->rt_flags & RTF_GATEWAY) { 2029 if (!(rt->rt_flags & RTF_HOST) || !rt->rt_ifp || 2030 rt->rt_ifp->if_type != IFT_ETHER || 2031 (rt->rt_ifp->if_flags & IFF_NOARP) != 0 || 2032 memcmp(rt->rt_gateway->sa_data, l3addr->sa_data, 2033 sizeof(in_addr_t)) != 0) { 2034 goto error; 2035 } 2036 } 2037 2038 /* 2039 * Make sure that at least the destination address is covered 2040 * by the route. This is for handling the case where 2 or more 2041 * interfaces have the same prefix. An incoming packet arrives 2042 * on one interface and the corresponding outgoing packet leaves 2043 * another interface. 2044 */ 2045 if (!(rt->rt_flags & RTF_HOST) && rt->rt_ifp != ifp) { 2046 const char *sa, *mask, *addr, *lim; 2047 int len; 2048 2049 mask = (const char *)rt_mask(rt); 2050 /* 2051 * Just being extra cautious to avoid some custom 2052 * code getting into trouble. 2053 */ 2054 if (mask == NULL) 2055 goto error; 2056 2057 sa = (const char *)rt_getkey(rt); 2058 addr = (const char *)l3addr; 2059 len = ((const struct sockaddr_in *)l3addr)->sin_len; 2060 lim = addr + len; 2061 2062 for ( ; addr < lim; sa++, mask++, addr++) { 2063 if ((*sa ^ *addr) & *mask) { 2064 #ifdef DIAGNOSTIC 2065 log(LOG_INFO, "IPv4 address: \"%s\" is not on the network\n", 2066 inet_ntoa(((const struct sockaddr_in *)l3addr)->sin_addr)); 2067 #endif 2068 goto error; 2069 } 2070 } 2071 } 2072 2073 error = 0; 2074 error: 2075 return error; 2076 } 2077 2078 static inline uint32_t 2079 in_lltable_hash_dst(const struct in_addr dst, uint32_t hsize) 2080 { 2081 2082 return (IN_LLTBL_HASH(dst.s_addr, hsize)); 2083 } 2084 2085 static uint32_t 2086 in_lltable_hash(const struct llentry *lle, uint32_t hsize) 2087 { 2088 2089 return (in_lltable_hash_dst(lle->r_l3addr.addr4, hsize)); 2090 } 2091 2092 static void 2093 in_lltable_fill_sa_entry(const struct llentry *lle, struct sockaddr *sa) 2094 { 2095 struct sockaddr_in *sin; 2096 2097 sin = (struct sockaddr_in *)sa; 2098 memset(sin, 0, sizeof(*sin)); 2099 sin->sin_family = AF_INET; 2100 sin->sin_len = sizeof(*sin); 2101 sin->sin_addr = lle->r_l3addr.addr4; 2102 } 2103 2104 static inline struct llentry * 2105 in_lltable_find_dst(struct lltable *llt, struct in_addr dst) 2106 { 2107 struct llentry *lle; 2108 struct llentries *lleh; 2109 u_int hashidx; 2110 2111 hashidx = in_lltable_hash_dst(dst, llt->llt_hsize); 2112 lleh = &llt->lle_head[hashidx]; 2113 LIST_FOREACH(lle, lleh, lle_next) { 2114 if (lle->la_flags & LLE_DELETED) 2115 continue; 2116 if (lle->r_l3addr.addr4.s_addr == dst.s_addr) 2117 break; 2118 } 2119 2120 return (lle); 2121 } 2122 2123 static int 2124 in_lltable_delete(struct lltable *llt, u_int flags, 2125 const struct sockaddr *l3addr) 2126 { 2127 const struct sockaddr_in *sin = (const struct sockaddr_in *)l3addr; 2128 struct ifnet *ifp __diagused = llt->llt_ifp; 2129 struct llentry *lle; 2130 2131 IF_AFDATA_WLOCK_ASSERT(ifp); 2132 KASSERTMSG(l3addr->sa_family == AF_INET, 2133 "sin_family %d", l3addr->sa_family); 2134 2135 lle = in_lltable_find_dst(llt, sin->sin_addr); 2136 if (lle == NULL) { 2137 #ifdef LLTABLE_DEBUG 2138 char buf[64]; 2139 sockaddr_format(l3addr, buf, sizeof(buf)); 2140 log(LOG_INFO, "%s: cache for %s is not found\n", 2141 __func__, buf); 2142 #endif 2143 return (ENOENT); 2144 } 2145 2146 LLE_WLOCK(lle); 2147 #ifdef LLTABLE_DEBUG 2148 { 2149 char buf[64]; 2150 sockaddr_format(l3addr, buf, sizeof(buf)); 2151 log(LOG_INFO, "%s: cache for %s (%p) is deleted\n", 2152 __func__, buf, lle); 2153 } 2154 #endif 2155 llentry_free(lle); 2156 2157 return (0); 2158 } 2159 2160 static struct llentry * 2161 in_lltable_create(struct lltable *llt, u_int flags, const struct sockaddr *l3addr, 2162 const struct rtentry *rt) 2163 { 2164 const struct sockaddr_in *sin = (const struct sockaddr_in *)l3addr; 2165 struct ifnet *ifp = llt->llt_ifp; 2166 struct llentry *lle; 2167 2168 IF_AFDATA_WLOCK_ASSERT(ifp); 2169 KASSERTMSG(l3addr->sa_family == AF_INET, 2170 "sin_family %d", l3addr->sa_family); 2171 2172 lle = in_lltable_find_dst(llt, sin->sin_addr); 2173 2174 if (lle != NULL) { 2175 LLE_WLOCK(lle); 2176 return (lle); 2177 } 2178 2179 /* no existing record, we need to create new one */ 2180 2181 /* 2182 * A route that covers the given address must have 2183 * been installed 1st because we are doing a resolution, 2184 * verify this. 2185 */ 2186 if (!(flags & LLE_IFADDR) && 2187 in_lltable_rtcheck(ifp, flags, l3addr, rt) != 0) 2188 return (NULL); 2189 2190 lle = in_lltable_new(sin->sin_addr, flags); 2191 if (lle == NULL) { 2192 log(LOG_INFO, "lla_lookup: new lle malloc failed\n"); 2193 return (NULL); 2194 } 2195 lle->la_flags = flags; 2196 if ((flags & LLE_IFADDR) == LLE_IFADDR) { 2197 memcpy(&lle->ll_addr, CLLADDR(ifp->if_sadl), ifp->if_addrlen); 2198 lle->la_flags |= (LLE_VALID | LLE_STATIC); 2199 } 2200 2201 lltable_link_entry(llt, lle); 2202 LLE_WLOCK(lle); 2203 2204 return (lle); 2205 } 2206 2207 /* 2208 * Return NULL if not found or marked for deletion. 2209 * If found return lle read locked. 2210 */ 2211 static struct llentry * 2212 in_lltable_lookup(struct lltable *llt, u_int flags, const struct sockaddr *l3addr) 2213 { 2214 const struct sockaddr_in *sin = (const struct sockaddr_in *)l3addr; 2215 struct llentry *lle; 2216 2217 IF_AFDATA_LOCK_ASSERT(llt->llt_ifp); 2218 KASSERTMSG(l3addr->sa_family == AF_INET, 2219 "sin_family %d", l3addr->sa_family); 2220 2221 lle = in_lltable_find_dst(llt, sin->sin_addr); 2222 2223 if (lle == NULL) 2224 return NULL; 2225 2226 if (flags & LLE_EXCLUSIVE) 2227 LLE_WLOCK(lle); 2228 else 2229 LLE_RLOCK(lle); 2230 2231 return lle; 2232 } 2233 2234 static int 2235 in_lltable_dump_entry(struct lltable *llt, struct llentry *lle, 2236 struct rt_walkarg *w) 2237 { 2238 struct sockaddr_in sin; 2239 2240 LLTABLE_LOCK_ASSERT(); 2241 2242 /* skip deleted entries */ 2243 if (lle->la_flags & LLE_DELETED) 2244 return 0; 2245 2246 sockaddr_in_init(&sin, &lle->r_l3addr.addr4, 0); 2247 2248 return lltable_dump_entry(llt, lle, w, sintosa(&sin)); 2249 } 2250 2251 #endif /* NARP > 0 */ 2252 2253 static int 2254 in_multicast_sysctl(SYSCTLFN_ARGS) 2255 { 2256 struct ifnet *ifp; 2257 struct ifaddr *ifa; 2258 struct in_ifaddr *ifa4; 2259 struct in_multi *inm; 2260 uint32_t tmp; 2261 int error; 2262 size_t written; 2263 struct psref psref; 2264 int bound; 2265 2266 if (namelen != 1) 2267 return EINVAL; 2268 2269 bound = curlwp_bind(); 2270 ifp = if_get_byindex(name[0], &psref); 2271 if (ifp == NULL) { 2272 curlwp_bindx(bound); 2273 return ENODEV; 2274 } 2275 2276 if (oldp == NULL) { 2277 *oldlenp = 0; 2278 IFADDR_FOREACH(ifa, ifp) { 2279 if (ifa->ifa_addr->sa_family != AF_INET) 2280 continue; 2281 ifa4 = (void *)ifa; 2282 LIST_FOREACH(inm, &ifa4->ia_multiaddrs, inm_list) { 2283 *oldlenp += 2 * sizeof(struct in_addr) + 2284 sizeof(uint32_t); 2285 } 2286 } 2287 if_put(ifp, &psref); 2288 curlwp_bindx(bound); 2289 return 0; 2290 } 2291 2292 error = 0; 2293 written = 0; 2294 IFADDR_FOREACH(ifa, ifp) { 2295 if (ifa->ifa_addr->sa_family != AF_INET) 2296 continue; 2297 ifa4 = (void *)ifa; 2298 LIST_FOREACH(inm, &ifa4->ia_multiaddrs, inm_list) { 2299 if (written + 2 * sizeof(struct in_addr) + 2300 sizeof(uint32_t) > *oldlenp) 2301 goto done; 2302 error = sysctl_copyout(l, &ifa4->ia_addr.sin_addr, 2303 oldp, sizeof(struct in_addr)); 2304 if (error) 2305 goto done; 2306 oldp = (char *)oldp + sizeof(struct in_addr); 2307 written += sizeof(struct in_addr); 2308 error = sysctl_copyout(l, &inm->inm_addr, 2309 oldp, sizeof(struct in_addr)); 2310 if (error) 2311 goto done; 2312 oldp = (char *)oldp + sizeof(struct in_addr); 2313 written += sizeof(struct in_addr); 2314 tmp = inm->inm_refcount; 2315 error = sysctl_copyout(l, &tmp, oldp, sizeof(tmp)); 2316 if (error) 2317 goto done; 2318 oldp = (char *)oldp + sizeof(tmp); 2319 written += sizeof(tmp); 2320 } 2321 } 2322 done: 2323 if_put(ifp, &psref); 2324 curlwp_bindx(bound); 2325 *oldlenp = written; 2326 return error; 2327 } 2328 2329 static void 2330 in_sysctl_init(struct sysctllog **clog) 2331 { 2332 sysctl_createv(clog, 0, NULL, NULL, 2333 CTLFLAG_PERMANENT, 2334 CTLTYPE_NODE, "inet", 2335 SYSCTL_DESCR("PF_INET related settings"), 2336 NULL, 0, NULL, 0, 2337 CTL_NET, PF_INET, CTL_EOL); 2338 sysctl_createv(clog, 0, NULL, NULL, 2339 CTLFLAG_PERMANENT, 2340 CTLTYPE_NODE, "multicast", 2341 SYSCTL_DESCR("Multicast information"), 2342 in_multicast_sysctl, 0, NULL, 0, 2343 CTL_NET, PF_INET, CTL_CREATE, CTL_EOL); 2344 sysctl_createv(clog, 0, NULL, NULL, 2345 CTLFLAG_PERMANENT, 2346 CTLTYPE_NODE, "ip", 2347 SYSCTL_DESCR("IPv4 related settings"), 2348 NULL, 0, NULL, 0, 2349 CTL_NET, PF_INET, IPPROTO_IP, CTL_EOL); 2350 2351 sysctl_createv(clog, 0, NULL, NULL, 2352 CTLFLAG_PERMANENT|CTLFLAG_READWRITE, 2353 CTLTYPE_INT, "subnetsarelocal", 2354 SYSCTL_DESCR("Whether logical subnets are considered " 2355 "local"), 2356 NULL, 0, &subnetsarelocal, 0, 2357 CTL_NET, PF_INET, IPPROTO_IP, 2358 IPCTL_SUBNETSARELOCAL, CTL_EOL); 2359 sysctl_createv(clog, 0, NULL, NULL, 2360 CTLFLAG_PERMANENT|CTLFLAG_READWRITE, 2361 CTLTYPE_INT, "hostzerobroadcast", 2362 SYSCTL_DESCR("All zeroes address is broadcast address"), 2363 NULL, 0, &hostzeroisbroadcast, 0, 2364 CTL_NET, PF_INET, IPPROTO_IP, 2365 IPCTL_HOSTZEROBROADCAST, CTL_EOL); 2366 } 2367 2368 #if NARP > 0 2369 2370 static struct lltable * 2371 in_lltattach(struct ifnet *ifp) 2372 { 2373 struct lltable *llt; 2374 2375 llt = lltable_allocate_htbl(IN_LLTBL_DEFAULT_HSIZE); 2376 llt->llt_af = AF_INET; 2377 llt->llt_ifp = ifp; 2378 2379 llt->llt_lookup = in_lltable_lookup; 2380 llt->llt_create = in_lltable_create; 2381 llt->llt_delete = in_lltable_delete; 2382 llt->llt_dump_entry = in_lltable_dump_entry; 2383 llt->llt_hash = in_lltable_hash; 2384 llt->llt_fill_sa_entry = in_lltable_fill_sa_entry; 2385 llt->llt_free_entry = in_lltable_free_entry; 2386 llt->llt_match_prefix = in_lltable_match_prefix; 2387 lltable_link(llt); 2388 2389 return (llt); 2390 } 2391 2392 #endif /* NARP > 0 */ 2393 2394 void * 2395 in_domifattach(struct ifnet *ifp) 2396 { 2397 struct in_ifinfo *ii; 2398 2399 ii = kmem_zalloc(sizeof(struct in_ifinfo), KM_SLEEP); 2400 2401 #if NARP > 0 2402 ii->ii_llt = in_lltattach(ifp); 2403 #endif 2404 2405 #ifdef IPSELSRC 2406 ii->ii_selsrc = in_selsrc_domifattach(ifp); 2407 KASSERT(ii->ii_selsrc != NULL); 2408 #endif 2409 2410 return ii; 2411 } 2412 2413 void 2414 in_domifdetach(struct ifnet *ifp, void *aux) 2415 { 2416 struct in_ifinfo *ii = aux; 2417 2418 #ifdef IPSELSRC 2419 in_selsrc_domifdetach(ifp, ii->ii_selsrc); 2420 #endif 2421 #if NARP > 0 2422 lltable_free(ii->ii_llt); 2423 #endif 2424 kmem_free(ii, sizeof(struct in_ifinfo)); 2425 } 2426
Indexes created Wed Sep 24 02:09:48 GMT 2025