1 /* 2 * Copyright (c) 1980, 1986, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. All advertising materials mentioning features or use of this software 14 * must display the following acknowledgement: 15 * This product includes software developed by the University of 16 * California, Berkeley and its contributors. 17 * 4. Neither the name of the University nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * @(#)if.c 8.3 (Berkeley) 1/4/94 34 * $FreeBSD: src/sys/net/if.c,v 1.185 2004/03/13 02:35:03 brooks Exp $ 35 * $DragonFly: src/sys/net/if.c,v 1.16 2004/03/24 02:08:33 hsu Exp $ 36 */ 37 38 #include "opt_compat.h" 39 #include "opt_inet6.h" 40 #include "opt_inet.h" 41 42 #include <sys/param.h> 43 #include <sys/malloc.h> 44 #include <sys/mbuf.h> 45 #include <sys/systm.h> 46 #include <sys/proc.h> 47 #include <sys/protosw.h> 48 #include <sys/socket.h> 49 #include <sys/socketvar.h> 50 #include <sys/socketops.h> 51 #include <sys/protosw.h> 52 #include <sys/kernel.h> 53 #include <sys/sockio.h> 54 #include <sys/syslog.h> 55 #include <sys/sysctl.h> 56 57 #include <net/if.h> 58 #include <net/if_arp.h> 59 #include <net/if_dl.h> 60 #include <net/if_types.h> 61 #include <net/if_var.h> 62 #include <net/radix.h> 63 #include <net/route.h> 64 #include <machine/stdarg.h> 65 66 #if defined(INET) || defined(INET6) 67 /*XXX*/ 68 #include <netinet/in.h> 69 #include <netinet/in_var.h> 70 #include <netinet/if_ether.h> 71 #ifdef INET6 72 #include <machine/clock.h> /* XXX: temporal workaround for fxp issue */ 73 #include <netinet6/in6_var.h> 74 #include <netinet6/in6_ifattach.h> 75 #endif 76 #endif 77 78 #if defined(COMPAT_43) 79 #include <emulation/43bsd/43bsd_socket.h> 80 #endif /* COMPAT_43 */ 81 82 /* 83 * System initialization 84 */ 85 86 static int ifconf (u_long, caddr_t, struct thread *); 87 static void ifinit (void *); 88 static void if_qflush (struct ifqueue *); 89 static void if_slowtimo (void *); 90 static void link_rtrequest (int, struct rtentry *, struct rt_addrinfo *); 91 static int if_rtdel (struct radix_node *, void *); 92 93 SYSINIT(interfaces, SI_SUB_PROTO_IF, SI_ORDER_FIRST, ifinit, NULL) 94 95 MALLOC_DEFINE(M_IFADDR, "ifaddr", "interface address"); 96 MALLOC_DEFINE(M_IFMADDR, "ether_multi", "link-level multicast address"); 97 MALLOC_DEFINE(M_CLONE, "clone", "interface cloning framework"); 98 99 int ifqmaxlen = IFQ_MAXLEN; 100 struct ifnethead ifnet; /* depend on static init XXX */ 101 102 #ifdef INET6 103 /* 104 * XXX: declare here to avoid to include many inet6 related files.. 105 * should be more generalized? 106 */ 107 extern void nd6_setmtu (struct ifnet *); 108 #endif 109 110 struct if_clone *if_clone_lookup (const char *, int *); 111 int if_clone_list (struct if_clonereq *); 112 113 LIST_HEAD(, if_clone) if_cloners = LIST_HEAD_INITIALIZER(if_cloners); 114 int if_cloners_count; 115 116 /* 117 * Network interface utility routines. 118 * 119 * Routines with ifa_ifwith* names take sockaddr *'s as 120 * parameters. 121 */ 122 /* ARGSUSED*/ 123 void 124 ifinit(dummy) 125 void *dummy; 126 { 127 struct ifnet *ifp; 128 int s; 129 130 s = splimp(); 131 TAILQ_FOREACH(ifp, &ifnet, if_link) { 132 if (ifp->if_snd.ifq_maxlen == 0) { 133 if_printf(ifp, "XXX: driver didn't set ifq_maxlen\n"); 134 ifp->if_snd.ifq_maxlen = ifqmaxlen; 135 } 136 } 137 splx(s); 138 if_slowtimo(0); 139 } 140 141 int if_index = 0; 142 struct ifaddr **ifnet_addrs; 143 struct ifnet **ifindex2ifnet = NULL; 144 145 146 /* 147 * Attach an interface to the 148 * list of "active" interfaces. 149 */ 150 void 151 if_attach(ifp) 152 struct ifnet *ifp; 153 { 154 unsigned socksize, ifasize; 155 int namelen, masklen; 156 struct sockaddr_dl *sdl; 157 struct ifaddr *ifa; 158 static int if_indexlim = 8; 159 static int inited; 160 161 if (!inited) { 162 TAILQ_INIT(&ifnet); 163 inited = 1; 164 } 165 166 TAILQ_INSERT_TAIL(&ifnet, ifp, if_link); 167 ifp->if_index = ++if_index; 168 /* 169 * XXX - 170 * The old code would work if the interface passed a pre-existing 171 * chain of ifaddrs to this code. We don't trust our callers to 172 * properly initialize the tailq, however, so we no longer allow 173 * this unlikely case. 174 */ 175 TAILQ_INIT(&ifp->if_addrhead); 176 TAILQ_INIT(&ifp->if_prefixhead); 177 LIST_INIT(&ifp->if_multiaddrs); 178 getmicrotime(&ifp->if_lastchange); 179 if (ifnet_addrs == 0 || if_index >= if_indexlim) { 180 unsigned n = (if_indexlim <<= 1) * sizeof(ifa); 181 caddr_t q = malloc(n, M_IFADDR, M_WAITOK); 182 bzero(q, n); 183 if (ifnet_addrs) { 184 bcopy((caddr_t)ifnet_addrs, (caddr_t)q, n/2); 185 free((caddr_t)ifnet_addrs, M_IFADDR); 186 } 187 ifnet_addrs = (struct ifaddr **)q; 188 189 /* grow ifindex2ifnet */ 190 n = if_indexlim * sizeof(struct ifnet *); 191 q = malloc(n, M_IFADDR, M_WAITOK); 192 bzero(q, n); 193 if (ifindex2ifnet) { 194 bcopy((caddr_t)ifindex2ifnet, q, n/2); 195 free((caddr_t)ifindex2ifnet, M_IFADDR); 196 } 197 ifindex2ifnet = (struct ifnet **)q; 198 } 199 200 ifindex2ifnet[if_index] = ifp; 201 202 /* 203 * create a Link Level name for this device 204 */ 205 namelen = strlen(ifp->if_xname); 206 #define _offsetof(t, m) ((int)((caddr_t)&((t *)0)->m)) 207 masklen = _offsetof(struct sockaddr_dl, sdl_data[0]) + namelen; 208 socksize = masklen + ifp->if_addrlen; 209 #define ROUNDUP(a) (1 + (((a) - 1) | (sizeof(long) - 1))) 210 if (socksize < sizeof(*sdl)) 211 socksize = sizeof(*sdl); 212 socksize = ROUNDUP(socksize); 213 ifasize = sizeof(*ifa) + 2 * socksize; 214 ifa = (struct ifaddr *)malloc(ifasize, M_IFADDR, M_WAITOK); 215 if (ifa) { 216 bzero((caddr_t)ifa, ifasize); 217 sdl = (struct sockaddr_dl *)(ifa + 1); 218 sdl->sdl_len = socksize; 219 sdl->sdl_family = AF_LINK; 220 bcopy(ifp->if_xname, sdl->sdl_data, namelen); 221 sdl->sdl_nlen = namelen; 222 sdl->sdl_index = ifp->if_index; 223 sdl->sdl_type = ifp->if_type; 224 ifnet_addrs[if_index - 1] = ifa; 225 ifa->ifa_ifp = ifp; 226 ifa->ifa_rtrequest = link_rtrequest; 227 ifa->ifa_addr = (struct sockaddr *)sdl; 228 sdl = (struct sockaddr_dl *)(socksize + (caddr_t)sdl); 229 ifa->ifa_netmask = (struct sockaddr *)sdl; 230 sdl->sdl_len = masklen; 231 while (namelen != 0) 232 sdl->sdl_data[--namelen] = 0xff; 233 TAILQ_INSERT_HEAD(&ifp->if_addrhead, ifa, ifa_link); 234 } 235 236 /* Announce the interface. */ 237 rt_ifannouncemsg(ifp, IFAN_ARRIVAL); 238 } 239 240 /* 241 * Detach an interface, removing it from the 242 * list of "active" interfaces. 243 */ 244 void 245 if_detach(ifp) 246 struct ifnet *ifp; 247 { 248 struct ifaddr *ifa; 249 struct radix_node_head *rnh; 250 int s; 251 int i; 252 253 /* 254 * Remove routes and flush queues. 255 */ 256 s = splnet(); 257 if_down(ifp); 258 259 /* 260 * Remove address from ifnet_addrs[] and maybe decrement if_index. 261 * Clean up all addresses. 262 */ 263 ifnet_addrs[ifp->if_index - 1] = 0; 264 while (if_index > 0 && ifnet_addrs[if_index - 1] == 0) 265 if_index--; 266 267 for (ifa = TAILQ_FIRST(&ifp->if_addrhead); ifa; 268 ifa = TAILQ_FIRST(&ifp->if_addrhead)) { 269 #ifdef INET 270 /* XXX: Ugly!! ad hoc just for INET */ 271 if (ifa->ifa_addr && ifa->ifa_addr->sa_family == AF_INET) { 272 struct ifaliasreq ifr; 273 274 bzero(&ifr, sizeof(ifr)); 275 ifr.ifra_addr = *ifa->ifa_addr; 276 if (ifa->ifa_dstaddr) 277 ifr.ifra_broadaddr = *ifa->ifa_dstaddr; 278 if (in_control(NULL, SIOCDIFADDR, (caddr_t)&ifr, ifp, 279 NULL) == 0) 280 continue; 281 } 282 #endif /* INET */ 283 #ifdef INET6 284 if (ifa->ifa_addr && ifa->ifa_addr->sa_family == AF_INET6) { 285 in6_purgeaddr(ifa); 286 /* ifp_addrhead is already updated */ 287 continue; 288 } 289 #endif /* INET6 */ 290 TAILQ_REMOVE(&ifp->if_addrhead, ifa, ifa_link); 291 IFAFREE(ifa); 292 } 293 294 #ifdef INET6 295 /* 296 * Remove all IPv6 kernel structs related to ifp. This should be done 297 * before removing routing entries below, since IPv6 interface direct 298 * routes are expected to be removed by the IPv6-specific kernel API. 299 * Otherwise, the kernel will detect some inconsistency and bark it. 300 */ 301 in6_ifdetach(ifp); 302 #endif 303 304 /* 305 * Delete all remaining routes using this interface 306 * Unfortuneatly the only way to do this is to slog through 307 * the entire routing table looking for routes which point 308 * to this interface...oh well... 309 */ 310 for (i = 1; i <= AF_MAX; i++) { 311 if ((rnh = rt_tables[i]) == NULL) 312 continue; 313 (void) rnh->rnh_walktree(rnh, if_rtdel, ifp); 314 } 315 316 /* Announce that the interface is gone. */ 317 rt_ifannouncemsg(ifp, IFAN_DEPARTURE); 318 319 TAILQ_REMOVE(&ifnet, ifp, if_link); 320 splx(s); 321 } 322 323 /* 324 * Delete Routes for a Network Interface 325 * 326 * Called for each routing entry via the rnh->rnh_walktree() call above 327 * to delete all route entries referencing a detaching network interface. 328 * 329 * Arguments: 330 * rn pointer to node in the routing table 331 * arg argument passed to rnh->rnh_walktree() - detaching interface 332 * 333 * Returns: 334 * 0 successful 335 * errno failed - reason indicated 336 * 337 */ 338 static int 339 if_rtdel(rn, arg) 340 struct radix_node *rn; 341 void *arg; 342 { 343 struct rtentry *rt = (struct rtentry *)rn; 344 struct ifnet *ifp = arg; 345 int err; 346 347 if (rt->rt_ifp == ifp) { 348 349 /* 350 * Protect (sorta) against walktree recursion problems 351 * with cloned routes 352 */ 353 if ((rt->rt_flags & RTF_UP) == 0) 354 return (0); 355 356 err = rtrequest(RTM_DELETE, rt_key(rt), rt->rt_gateway, 357 rt_mask(rt), rt->rt_flags, 358 (struct rtentry **) NULL); 359 if (err) { 360 log(LOG_WARNING, "if_rtdel: error %d\n", err); 361 } 362 } 363 364 return (0); 365 } 366 367 /* 368 * Create a clone network interface. 369 */ 370 int 371 if_clone_create(name, len) 372 char *name; 373 int len; 374 { 375 struct if_clone *ifc; 376 char *dp; 377 int wildcard, bytoff, bitoff; 378 int unit; 379 int err; 380 381 ifc = if_clone_lookup(name, &unit); 382 if (ifc == NULL) 383 return (EINVAL); 384 385 if (ifunit(name) != NULL) 386 return (EEXIST); 387 388 bytoff = bitoff = 0; 389 wildcard = (unit < 0); 390 /* 391 * Find a free unit if none was given. 392 */ 393 if (wildcard) { 394 while ((bytoff < ifc->ifc_bmlen) 395 && (ifc->ifc_units[bytoff] == 0xff)) 396 bytoff++; 397 if (bytoff >= ifc->ifc_bmlen) 398 return (ENOSPC); 399 while ((ifc->ifc_units[bytoff] & (1 << bitoff)) != 0) 400 bitoff++; 401 unit = (bytoff << 3) + bitoff; 402 } 403 404 if (unit > ifc->ifc_maxunit) 405 return (ENXIO); 406 407 err = (*ifc->ifc_create)(ifc, unit); 408 if (err != 0) 409 return (err); 410 411 if (!wildcard) { 412 bytoff = unit >> 3; 413 bitoff = unit - (bytoff << 3); 414 } 415 416 /* 417 * Allocate the unit in the bitmap. 418 */ 419 KASSERT((ifc->ifc_units[bytoff] & (1 << bitoff)) == 0, 420 ("%s: bit is already set", __func__)); 421 ifc->ifc_units[bytoff] |= (1 << bitoff); 422 423 /* In the wildcard case, we need to update the name. */ 424 if (wildcard) { 425 for (dp = name; *dp != '\0'; dp++); 426 if (snprintf(dp, len - (dp-name), "%d", unit) > 427 len - (dp-name) - 1) { 428 /* 429 * This can only be a programmer error and 430 * there's no straightforward way to recover if 431 * it happens. 432 */ 433 panic("if_clone_create(): interface name too long"); 434 } 435 436 } 437 438 return (0); 439 } 440 441 /* 442 * Destroy a clone network interface. 443 */ 444 int 445 if_clone_destroy(name) 446 const char *name; 447 { 448 struct if_clone *ifc; 449 struct ifnet *ifp; 450 int bytoff, bitoff; 451 int unit; 452 453 ifc = if_clone_lookup(name, &unit); 454 if (ifc == NULL) 455 return (EINVAL); 456 457 if (unit < ifc->ifc_minifs) 458 return (EINVAL); 459 460 ifp = ifunit(name); 461 if (ifp == NULL) 462 return (ENXIO); 463 464 if (ifc->ifc_destroy == NULL) 465 return (EOPNOTSUPP); 466 467 (*ifc->ifc_destroy)(ifp); 468 469 /* 470 * Compute offset in the bitmap and deallocate the unit. 471 */ 472 bytoff = unit >> 3; 473 bitoff = unit - (bytoff << 3); 474 KASSERT((ifc->ifc_units[bytoff] & (1 << bitoff)) != 0, 475 ("%s: bit is already cleared", __func__)); 476 ifc->ifc_units[bytoff] &= ~(1 << bitoff); 477 return (0); 478 } 479 480 /* 481 * Look up a network interface cloner. 482 */ 483 struct if_clone * 484 if_clone_lookup(name, unitp) 485 const char *name; 486 int *unitp; 487 { 488 struct if_clone *ifc; 489 const char *cp; 490 int i; 491 492 for (ifc = LIST_FIRST(&if_cloners); ifc != NULL;) { 493 for (cp = name, i = 0; i < ifc->ifc_namelen; i++, cp++) { 494 if (ifc->ifc_name[i] != *cp) 495 goto next_ifc; 496 } 497 goto found_name; 498 next_ifc: 499 ifc = LIST_NEXT(ifc, ifc_list); 500 } 501 502 /* No match. */ 503 return ((struct if_clone *)NULL); 504 505 found_name: 506 if (*cp == '\0') { 507 i = -1; 508 } else { 509 for (i = 0; *cp != '\0'; cp++) { 510 if (*cp < '0' || *cp > '9') { 511 /* Bogus unit number. */ 512 return (NULL); 513 } 514 i = (i * 10) + (*cp - '0'); 515 } 516 } 517 518 if (unitp != NULL) 519 *unitp = i; 520 return (ifc); 521 } 522 523 /* 524 * Register a network interface cloner. 525 */ 526 void 527 if_clone_attach(ifc) 528 struct if_clone *ifc; 529 { 530 int bytoff, bitoff; 531 int err; 532 int len, maxclone; 533 int unit; 534 535 KASSERT(ifc->ifc_minifs - 1 <= ifc->ifc_maxunit, 536 ("%s: %s requested more units then allowed (%d > %d)", 537 __func__, ifc->ifc_name, ifc->ifc_minifs, 538 ifc->ifc_maxunit + 1)); 539 /* 540 * Compute bitmap size and allocate it. 541 */ 542 maxclone = ifc->ifc_maxunit + 1; 543 len = maxclone >> 3; 544 if ((len << 3) < maxclone) 545 len++; 546 ifc->ifc_units = malloc(len, M_CLONE, M_WAITOK | M_ZERO); 547 ifc->ifc_bmlen = len; 548 549 LIST_INSERT_HEAD(&if_cloners, ifc, ifc_list); 550 if_cloners_count++; 551 552 for (unit = 0; unit < ifc->ifc_minifs; unit++) { 553 err = (*ifc->ifc_create)(ifc, unit); 554 KASSERT(err == 0, 555 ("%s: failed to create required interface %s%d", 556 __func__, ifc->ifc_name, unit)); 557 558 /* Allocate the unit in the bitmap. */ 559 bytoff = unit >> 3; 560 bitoff = unit - (bytoff << 3); 561 ifc->ifc_units[bytoff] |= (1 << bitoff); 562 } 563 } 564 565 /* 566 * Unregister a network interface cloner. 567 */ 568 void 569 if_clone_detach(ifc) 570 struct if_clone *ifc; 571 { 572 573 LIST_REMOVE(ifc, ifc_list); 574 free(ifc->ifc_units, M_CLONE); 575 if_cloners_count--; 576 } 577 578 /* 579 * Provide list of interface cloners to userspace. 580 */ 581 int 582 if_clone_list(ifcr) 583 struct if_clonereq *ifcr; 584 { 585 char outbuf[IFNAMSIZ], *dst; 586 struct if_clone *ifc; 587 int count, error = 0; 588 589 ifcr->ifcr_total = if_cloners_count; 590 if ((dst = ifcr->ifcr_buffer) == NULL) { 591 /* Just asking how many there are. */ 592 return (0); 593 } 594 595 if (ifcr->ifcr_count < 0) 596 return (EINVAL); 597 598 count = (if_cloners_count < ifcr->ifcr_count) ? 599 if_cloners_count : ifcr->ifcr_count; 600 601 for (ifc = LIST_FIRST(&if_cloners); ifc != NULL && count != 0; 602 ifc = LIST_NEXT(ifc, ifc_list), count--, dst += IFNAMSIZ) { 603 strlcpy(outbuf, ifc->ifc_name, IFNAMSIZ); 604 error = copyout(outbuf, dst, IFNAMSIZ); 605 if (error) 606 break; 607 } 608 609 return (error); 610 } 611 612 /* 613 * Locate an interface based on a complete address. 614 */ 615 /*ARGSUSED*/ 616 struct ifaddr * 617 ifa_ifwithaddr(addr) 618 struct sockaddr *addr; 619 { 620 struct ifnet *ifp; 621 struct ifaddr *ifa; 622 623 #define equal(a1, a2) \ 624 (bcmp((caddr_t)(a1), (caddr_t)(a2), ((struct sockaddr *)(a1))->sa_len) == 0) 625 TAILQ_FOREACH(ifp, &ifnet, if_link) 626 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) { 627 if (ifa->ifa_addr->sa_family != addr->sa_family) 628 continue; 629 if (equal(addr, ifa->ifa_addr)) 630 return (ifa); 631 if ((ifp->if_flags & IFF_BROADCAST) && ifa->ifa_broadaddr && 632 /* IP6 doesn't have broadcast */ 633 ifa->ifa_broadaddr->sa_len != 0 && 634 equal(ifa->ifa_broadaddr, addr)) 635 return (ifa); 636 } 637 return ((struct ifaddr *)0); 638 } 639 /* 640 * Locate the point to point interface with a given destination address. 641 */ 642 /*ARGSUSED*/ 643 struct ifaddr * 644 ifa_ifwithdstaddr(addr) 645 struct sockaddr *addr; 646 { 647 struct ifnet *ifp; 648 struct ifaddr *ifa; 649 650 TAILQ_FOREACH(ifp, &ifnet, if_link) 651 if (ifp->if_flags & IFF_POINTOPOINT) 652 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) { 653 if (ifa->ifa_addr->sa_family != addr->sa_family) 654 continue; 655 if (ifa->ifa_dstaddr && equal(addr, ifa->ifa_dstaddr)) 656 return (ifa); 657 } 658 return ((struct ifaddr *)0); 659 } 660 661 /* 662 * Find an interface on a specific network. If many, choice 663 * is most specific found. 664 */ 665 struct ifaddr * 666 ifa_ifwithnet(addr) 667 struct sockaddr *addr; 668 { 669 struct ifnet *ifp; 670 struct ifaddr *ifa; 671 struct ifaddr *ifa_maybe = (struct ifaddr *) 0; 672 u_int af = addr->sa_family; 673 char *addr_data = addr->sa_data, *cplim; 674 675 /* 676 * AF_LINK addresses can be looked up directly by their index number, 677 * so do that if we can. 678 */ 679 if (af == AF_LINK) { 680 struct sockaddr_dl *sdl = (struct sockaddr_dl *)addr; 681 if (sdl->sdl_index && sdl->sdl_index <= if_index) 682 return (ifnet_addrs[sdl->sdl_index - 1]); 683 } 684 685 /* 686 * Scan though each interface, looking for ones that have 687 * addresses in this address family. 688 */ 689 TAILQ_FOREACH(ifp, &ifnet, if_link) { 690 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) { 691 char *cp, *cp2, *cp3; 692 693 if (ifa->ifa_addr->sa_family != af) 694 next: continue; 695 if (af == AF_INET && ifp->if_flags & IFF_POINTOPOINT) { 696 /* 697 * This is a bit broken as it doesn't 698 * take into account that the remote end may 699 * be a single node in the network we are 700 * looking for. 701 * The trouble is that we don't know the 702 * netmask for the remote end. 703 */ 704 if (ifa->ifa_dstaddr != 0 705 && equal(addr, ifa->ifa_dstaddr)) 706 return (ifa); 707 } else { 708 /* 709 * if we have a special address handler, 710 * then use it instead of the generic one. 711 */ 712 if (ifa->ifa_claim_addr) { 713 if ((*ifa->ifa_claim_addr)(ifa, addr)) { 714 return (ifa); 715 } else { 716 continue; 717 } 718 } 719 720 /* 721 * Scan all the bits in the ifa's address. 722 * If a bit dissagrees with what we are 723 * looking for, mask it with the netmask 724 * to see if it really matters. 725 * (A byte at a time) 726 */ 727 if (ifa->ifa_netmask == 0) 728 continue; 729 cp = addr_data; 730 cp2 = ifa->ifa_addr->sa_data; 731 cp3 = ifa->ifa_netmask->sa_data; 732 cplim = ifa->ifa_netmask->sa_len 733 + (char *)ifa->ifa_netmask; 734 while (cp3 < cplim) 735 if ((*cp++ ^ *cp2++) & *cp3++) 736 goto next; /* next address! */ 737 /* 738 * If the netmask of what we just found 739 * is more specific than what we had before 740 * (if we had one) then remember the new one 741 * before continuing to search 742 * for an even better one. 743 */ 744 if (ifa_maybe == 0 || 745 rn_refines((caddr_t)ifa->ifa_netmask, 746 (caddr_t)ifa_maybe->ifa_netmask)) 747 ifa_maybe = ifa; 748 } 749 } 750 } 751 return (ifa_maybe); 752 } 753 754 /* 755 * Find an interface address specific to an interface best matching 756 * a given address. 757 */ 758 struct ifaddr * 759 ifaof_ifpforaddr(addr, ifp) 760 struct sockaddr *addr; 761 struct ifnet *ifp; 762 { 763 struct ifaddr *ifa; 764 char *cp, *cp2, *cp3; 765 char *cplim; 766 struct ifaddr *ifa_maybe = 0; 767 u_int af = addr->sa_family; 768 769 if (af >= AF_MAX) 770 return (0); 771 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) { 772 if (ifa->ifa_addr->sa_family != af) 773 continue; 774 if (ifa_maybe == 0) 775 ifa_maybe = ifa; 776 if (ifa->ifa_netmask == 0) { 777 if (equal(addr, ifa->ifa_addr) || 778 (ifa->ifa_dstaddr && equal(addr, ifa->ifa_dstaddr))) 779 return (ifa); 780 continue; 781 } 782 if (ifp->if_flags & IFF_POINTOPOINT) { 783 if (equal(addr, ifa->ifa_dstaddr)) 784 return (ifa); 785 } else { 786 cp = addr->sa_data; 787 cp2 = ifa->ifa_addr->sa_data; 788 cp3 = ifa->ifa_netmask->sa_data; 789 cplim = ifa->ifa_netmask->sa_len + (char *)ifa->ifa_netmask; 790 for (; cp3 < cplim; cp3++) 791 if ((*cp++ ^ *cp2++) & *cp3) 792 break; 793 if (cp3 == cplim) 794 return (ifa); 795 } 796 } 797 return (ifa_maybe); 798 } 799 800 #include <net/route.h> 801 802 /* 803 * Default action when installing a route with a Link Level gateway. 804 * Lookup an appropriate real ifa to point to. 805 * This should be moved to /sys/net/link.c eventually. 806 */ 807 static void 808 link_rtrequest(cmd, rt, info) 809 int cmd; 810 struct rtentry *rt; 811 struct rt_addrinfo *info; 812 { 813 struct ifaddr *ifa; 814 struct sockaddr *dst; 815 struct ifnet *ifp; 816 817 if (cmd != RTM_ADD || ((ifa = rt->rt_ifa) == 0) || 818 ((ifp = ifa->ifa_ifp) == 0) || ((dst = rt_key(rt)) == 0)) 819 return; 820 ifa = ifaof_ifpforaddr(dst, ifp); 821 if (ifa) { 822 IFAFREE(rt->rt_ifa); 823 rt->rt_ifa = ifa; 824 ifa->ifa_refcnt++; 825 if (ifa->ifa_rtrequest && ifa->ifa_rtrequest != link_rtrequest) 826 ifa->ifa_rtrequest(cmd, rt, info); 827 } 828 } 829 830 /* 831 * Mark an interface down and notify protocols of 832 * the transition. 833 * NOTE: must be called at splnet or eqivalent. 834 */ 835 void 836 if_unroute(ifp, flag, fam) 837 struct ifnet *ifp; 838 int flag, fam; 839 { 840 struct ifaddr *ifa; 841 842 ifp->if_flags &= ~flag; 843 getmicrotime(&ifp->if_lastchange); 844 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) 845 if (fam == PF_UNSPEC || (fam == ifa->ifa_addr->sa_family)) 846 pfctlinput(PRC_IFDOWN, ifa->ifa_addr); 847 if_qflush(&ifp->if_snd); 848 rt_ifmsg(ifp); 849 } 850 851 /* 852 * Mark an interface up and notify protocols of 853 * the transition. 854 * NOTE: must be called at splnet or eqivalent. 855 */ 856 void 857 if_route(ifp, flag, fam) 858 struct ifnet *ifp; 859 int flag, fam; 860 { 861 struct ifaddr *ifa; 862 863 ifp->if_flags |= flag; 864 getmicrotime(&ifp->if_lastchange); 865 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) 866 if (fam == PF_UNSPEC || (fam == ifa->ifa_addr->sa_family)) 867 pfctlinput(PRC_IFUP, ifa->ifa_addr); 868 rt_ifmsg(ifp); 869 #ifdef INET6 870 in6_if_up(ifp); 871 #endif 872 } 873 874 /* 875 * Mark an interface down and notify protocols of 876 * the transition. 877 * NOTE: must be called at splnet or eqivalent. 878 */ 879 void 880 if_down(ifp) 881 struct ifnet *ifp; 882 { 883 884 if_unroute(ifp, IFF_UP, AF_UNSPEC); 885 } 886 887 /* 888 * Mark an interface up and notify protocols of 889 * the transition. 890 * NOTE: must be called at splnet or eqivalent. 891 */ 892 void 893 if_up(ifp) 894 struct ifnet *ifp; 895 { 896 897 if_route(ifp, IFF_UP, AF_UNSPEC); 898 } 899 900 /* 901 * Flush an interface queue. 902 */ 903 static void 904 if_qflush(ifq) 905 struct ifqueue *ifq; 906 { 907 struct mbuf *m, *n; 908 909 n = ifq->ifq_head; 910 while ((m = n) != 0) { 911 n = m->m_act; 912 m_freem(m); 913 } 914 ifq->ifq_head = 0; 915 ifq->ifq_tail = 0; 916 ifq->ifq_len = 0; 917 } 918 919 /* 920 * Handle interface watchdog timer routines. Called 921 * from softclock, we decrement timers (if set) and 922 * call the appropriate interface routine on expiration. 923 */ 924 static void 925 if_slowtimo(arg) 926 void *arg; 927 { 928 struct ifnet *ifp; 929 int s = splimp(); 930 931 TAILQ_FOREACH(ifp, &ifnet, if_link) { 932 if (ifp->if_timer == 0 || --ifp->if_timer) 933 continue; 934 if (ifp->if_watchdog) 935 (*ifp->if_watchdog)(ifp); 936 } 937 splx(s); 938 timeout(if_slowtimo, (void *)0, hz / IFNET_SLOWHZ); 939 } 940 941 /* 942 * Map interface name to 943 * interface structure pointer. 944 */ 945 struct ifnet * 946 ifunit(const char *name) 947 { 948 struct ifnet *ifp; 949 950 /* 951 * Search all the interfaces for this name/number 952 */ 953 954 TAILQ_FOREACH(ifp, &ifnet, if_link) { 955 if (strncmp(ifp->if_xname, name, IFNAMSIZ) == 0) 956 break; 957 } 958 return (ifp); 959 } 960 961 962 /* 963 * Map interface name in a sockaddr_dl to 964 * interface structure pointer. 965 */ 966 struct ifnet * 967 if_withname(sa) 968 struct sockaddr *sa; 969 { 970 char ifname[IFNAMSIZ+1]; 971 struct sockaddr_dl *sdl = (struct sockaddr_dl *)sa; 972 973 if ( (sa->sa_family != AF_LINK) || (sdl->sdl_nlen == 0) || 974 (sdl->sdl_nlen > IFNAMSIZ) ) 975 return NULL; 976 977 /* 978 * ifunit wants a null-terminated name. It may not be null-terminated 979 * in the sockaddr. We don't want to change the caller's sockaddr, 980 * and there might not be room to put the trailing null anyway, so we 981 * make a local copy that we know we can null terminate safely. 982 */ 983 984 bcopy(sdl->sdl_data, ifname, sdl->sdl_nlen); 985 ifname[sdl->sdl_nlen] = '\0'; 986 return ifunit(ifname); 987 } 988 989 990 /* 991 * Interface ioctls. 992 */ 993 int 994 ifioctl(struct socket *so, u_long cmd, caddr_t data, struct thread *td) 995 { 996 struct ifnet *ifp; 997 struct ifreq *ifr; 998 struct ifstat *ifs; 999 int error; 1000 short oif_flags; 1001 int new_flags; 1002 size_t namelen, onamelen; 1003 char new_name[IFNAMSIZ]; 1004 struct ifaddr *ifa; 1005 struct sockaddr_dl *sdl; 1006 1007 switch (cmd) { 1008 1009 case SIOCGIFCONF: 1010 case OSIOCGIFCONF: 1011 return (ifconf(cmd, data, td)); 1012 } 1013 ifr = (struct ifreq *)data; 1014 1015 switch (cmd) { 1016 case SIOCIFCREATE: 1017 case SIOCIFDESTROY: 1018 if ((error = suser(td)) != 0) 1019 return (error); 1020 return ((cmd == SIOCIFCREATE) ? 1021 if_clone_create(ifr->ifr_name, sizeof(ifr->ifr_name)) : 1022 if_clone_destroy(ifr->ifr_name)); 1023 1024 case SIOCIFGCLONERS: 1025 return (if_clone_list((struct if_clonereq *)data)); 1026 } 1027 1028 ifp = ifunit(ifr->ifr_name); 1029 if (ifp == 0) 1030 return (ENXIO); 1031 switch (cmd) { 1032 1033 case SIOCGIFFLAGS: 1034 ifr->ifr_flags = ifp->if_flags; 1035 ifr->ifr_flagshigh = ifp->if_ipending >> 16; 1036 break; 1037 1038 case SIOCGIFCAP: 1039 ifr->ifr_reqcap = ifp->if_capabilities; 1040 ifr->ifr_curcap = ifp->if_capenable; 1041 break; 1042 1043 case SIOCGIFMETRIC: 1044 ifr->ifr_metric = ifp->if_metric; 1045 break; 1046 1047 case SIOCGIFMTU: 1048 ifr->ifr_mtu = ifp->if_mtu; 1049 break; 1050 1051 case SIOCGIFPHYS: 1052 ifr->ifr_phys = ifp->if_physical; 1053 break; 1054 1055 case SIOCSIFFLAGS: 1056 error = suser(td); 1057 if (error) 1058 return (error); 1059 new_flags = (ifr->ifr_flags & 0xffff) | 1060 (ifr->ifr_flagshigh << 16); 1061 if (ifp->if_flags & IFF_SMART) { 1062 /* Smart drivers twiddle their own routes */ 1063 } else if (ifp->if_flags & IFF_UP && 1064 (new_flags & IFF_UP) == 0) { 1065 int s = splimp(); 1066 if_down(ifp); 1067 splx(s); 1068 } else if (new_flags & IFF_UP && 1069 (ifp->if_flags & IFF_UP) == 0) { 1070 int s = splimp(); 1071 if_up(ifp); 1072 splx(s); 1073 } 1074 ifp->if_flags = (ifp->if_flags & IFF_CANTCHANGE) | 1075 (new_flags &~ IFF_CANTCHANGE); 1076 ifp->if_ipending = (ifp->if_ipending & IFF_CANTCHANGE) | 1077 (new_flags &~ IFF_CANTCHANGE); 1078 if (new_flags & IFF_PPROMISC) { 1079 /* Permanently promiscuous mode requested */ 1080 ifp->if_flags |= IFF_PROMISC; 1081 } else if (ifp->if_pcount == 0) { 1082 ifp->if_flags &= ~IFF_PROMISC; 1083 } 1084 if (ifp->if_ioctl) 1085 (void) (*ifp->if_ioctl)(ifp, cmd, data, 1086 td->td_proc->p_ucred); 1087 getmicrotime(&ifp->if_lastchange); 1088 break; 1089 1090 case SIOCSIFCAP: 1091 error = suser(td); 1092 if (error) 1093 return (error); 1094 if (ifr->ifr_reqcap & ~ifp->if_capabilities) 1095 return (EINVAL); 1096 (void) (*ifp->if_ioctl)(ifp, cmd, data, td->td_proc->p_ucred); 1097 break; 1098 1099 case SIOCSIFNAME: 1100 error = suser(td); 1101 if (error != 0) 1102 return (error); 1103 error = copyinstr(ifr->ifr_data, new_name, IFNAMSIZ, NULL); 1104 if (error != 0) 1105 return (error); 1106 if (new_name[0] == '\0') 1107 return (EINVAL); 1108 if (ifunit(new_name) != NULL) 1109 return (EEXIST); 1110 1111 /* Announce the departure of the interface. */ 1112 rt_ifannouncemsg(ifp, IFAN_DEPARTURE); 1113 1114 strlcpy(ifp->if_xname, new_name, sizeof(ifp->if_xname)); 1115 ifa = TAILQ_FIRST(&ifp->if_addrhead); 1116 /* XXX IFA_LOCK(ifa); */ 1117 sdl = (struct sockaddr_dl *)ifa->ifa_addr; 1118 namelen = strlen(new_name); 1119 onamelen = sdl->sdl_nlen; 1120 /* 1121 * Move the address if needed. This is safe because we 1122 * allocate space for a name of length IFNAMSIZ when we 1123 * create this in if_attach(). 1124 */ 1125 if (namelen != onamelen) { 1126 bcopy(sdl->sdl_data + onamelen, 1127 sdl->sdl_data + namelen, sdl->sdl_alen); 1128 } 1129 bcopy(new_name, sdl->sdl_data, namelen); 1130 sdl->sdl_nlen = namelen; 1131 sdl = (struct sockaddr_dl *)ifa->ifa_netmask; 1132 bzero(sdl->sdl_data, onamelen); 1133 while (namelen != 0) 1134 sdl->sdl_data[--namelen] = 0xff; 1135 /* XXX IFA_UNLOCK(ifa) */ 1136 1137 /* Announce the return of the interface. */ 1138 rt_ifannouncemsg(ifp, IFAN_ARRIVAL); 1139 break; 1140 1141 case SIOCSIFMETRIC: 1142 error = suser(td); 1143 if (error) 1144 return (error); 1145 ifp->if_metric = ifr->ifr_metric; 1146 getmicrotime(&ifp->if_lastchange); 1147 break; 1148 1149 case SIOCSIFPHYS: 1150 error = suser(td); 1151 if (error) 1152 return error; 1153 if (!ifp->if_ioctl) 1154 return EOPNOTSUPP; 1155 error = (*ifp->if_ioctl)(ifp, cmd, data, td->td_proc->p_ucred); 1156 if (error == 0) 1157 getmicrotime(&ifp->if_lastchange); 1158 return(error); 1159 1160 case SIOCSIFMTU: 1161 { 1162 u_long oldmtu = ifp->if_mtu; 1163 1164 error = suser(td); 1165 if (error) 1166 return (error); 1167 if (ifp->if_ioctl == NULL) 1168 return (EOPNOTSUPP); 1169 if (ifr->ifr_mtu < IF_MINMTU || ifr->ifr_mtu > IF_MAXMTU) 1170 return (EINVAL); 1171 error = (*ifp->if_ioctl)(ifp, cmd, data, td->td_proc->p_ucred); 1172 if (error == 0) { 1173 getmicrotime(&ifp->if_lastchange); 1174 rt_ifmsg(ifp); 1175 } 1176 /* 1177 * If the link MTU changed, do network layer specific procedure. 1178 */ 1179 if (ifp->if_mtu != oldmtu) { 1180 #ifdef INET6 1181 nd6_setmtu(ifp); 1182 #endif 1183 } 1184 return (error); 1185 } 1186 1187 case SIOCADDMULTI: 1188 case SIOCDELMULTI: 1189 error = suser(td); 1190 if (error) 1191 return (error); 1192 1193 /* Don't allow group membership on non-multicast interfaces. */ 1194 if ((ifp->if_flags & IFF_MULTICAST) == 0) 1195 return EOPNOTSUPP; 1196 1197 /* Don't let users screw up protocols' entries. */ 1198 if (ifr->ifr_addr.sa_family != AF_LINK) 1199 return EINVAL; 1200 1201 if (cmd == SIOCADDMULTI) { 1202 struct ifmultiaddr *ifma; 1203 error = if_addmulti(ifp, &ifr->ifr_addr, &ifma); 1204 } else { 1205 error = if_delmulti(ifp, &ifr->ifr_addr); 1206 } 1207 if (error == 0) 1208 getmicrotime(&ifp->if_lastchange); 1209 return error; 1210 1211 case SIOCSIFPHYADDR: 1212 case SIOCDIFPHYADDR: 1213 #ifdef INET6 1214 case SIOCSIFPHYADDR_IN6: 1215 #endif 1216 case SIOCSLIFPHYADDR: 1217 case SIOCSIFMEDIA: 1218 case SIOCSIFGENERIC: 1219 error = suser(td); 1220 if (error) 1221 return (error); 1222 if (ifp->if_ioctl == 0) 1223 return (EOPNOTSUPP); 1224 error = (*ifp->if_ioctl)(ifp, cmd, data, td->td_proc->p_ucred); 1225 if (error == 0) 1226 getmicrotime(&ifp->if_lastchange); 1227 return error; 1228 1229 case SIOCGIFSTATUS: 1230 ifs = (struct ifstat *)data; 1231 ifs->ascii[0] = '\0'; 1232 1233 case SIOCGIFPSRCADDR: 1234 case SIOCGIFPDSTADDR: 1235 case SIOCGLIFPHYADDR: 1236 case SIOCGIFMEDIA: 1237 case SIOCGIFGENERIC: 1238 if (ifp->if_ioctl == 0) 1239 return (EOPNOTSUPP); 1240 return ((*ifp->if_ioctl)(ifp, cmd, data, td->td_proc->p_ucred)); 1241 1242 case SIOCSIFLLADDR: 1243 error = suser(td); 1244 if (error) 1245 return (error); 1246 return if_setlladdr(ifp, 1247 ifr->ifr_addr.sa_data, ifr->ifr_addr.sa_len); 1248 1249 default: 1250 oif_flags = ifp->if_flags; 1251 if (so->so_proto == 0) 1252 return (EOPNOTSUPP); 1253 #ifndef COMPAT_43 1254 error = so_pru_control(so, cmd, data, ifp, td); 1255 #else 1256 { 1257 int ocmd = cmd; 1258 1259 switch (cmd) { 1260 1261 case SIOCSIFDSTADDR: 1262 case SIOCSIFADDR: 1263 case SIOCSIFBRDADDR: 1264 case SIOCSIFNETMASK: 1265 #if BYTE_ORDER != BIG_ENDIAN 1266 if (ifr->ifr_addr.sa_family == 0 && 1267 ifr->ifr_addr.sa_len < 16) { 1268 ifr->ifr_addr.sa_family = ifr->ifr_addr.sa_len; 1269 ifr->ifr_addr.sa_len = 16; 1270 } 1271 #else 1272 if (ifr->ifr_addr.sa_len == 0) 1273 ifr->ifr_addr.sa_len = 16; 1274 #endif 1275 break; 1276 1277 case OSIOCGIFADDR: 1278 cmd = SIOCGIFADDR; 1279 break; 1280 1281 case OSIOCGIFDSTADDR: 1282 cmd = SIOCGIFDSTADDR; 1283 break; 1284 1285 case OSIOCGIFBRDADDR: 1286 cmd = SIOCGIFBRDADDR; 1287 break; 1288 1289 case OSIOCGIFNETMASK: 1290 cmd = SIOCGIFNETMASK; 1291 } 1292 error = so_pru_control(so, cmd, data, ifp, td); 1293 switch (ocmd) { 1294 1295 case OSIOCGIFADDR: 1296 case OSIOCGIFDSTADDR: 1297 case OSIOCGIFBRDADDR: 1298 case OSIOCGIFNETMASK: 1299 *(u_short *)&ifr->ifr_addr = ifr->ifr_addr.sa_family; 1300 1301 } 1302 } 1303 #endif /* COMPAT_43 */ 1304 1305 if ((oif_flags ^ ifp->if_flags) & IFF_UP) { 1306 #ifdef INET6 1307 DELAY(100);/* XXX: temporary workaround for fxp issue*/ 1308 if (ifp->if_flags & IFF_UP) { 1309 int s = splimp(); 1310 in6_if_up(ifp); 1311 splx(s); 1312 } 1313 #endif 1314 } 1315 return (error); 1316 1317 } 1318 return (0); 1319 } 1320 1321 /* 1322 * Set/clear promiscuous mode on interface ifp based on the truth value 1323 * of pswitch. The calls are reference counted so that only the first 1324 * "on" request actually has an effect, as does the final "off" request. 1325 * Results are undefined if the "off" and "on" requests are not matched. 1326 */ 1327 int 1328 ifpromisc(ifp, pswitch) 1329 struct ifnet *ifp; 1330 int pswitch; 1331 { 1332 struct ifreq ifr; 1333 int error; 1334 int oldflags; 1335 1336 oldflags = ifp->if_flags; 1337 if (ifp->if_ipending & IFF_PPROMISC) { 1338 /* Do nothing if device is in permanently promiscuous mode */ 1339 ifp->if_pcount += pswitch ? 1 : -1; 1340 return (0); 1341 } 1342 if (pswitch) { 1343 /* 1344 * If the device is not configured up, we cannot put it in 1345 * promiscuous mode. 1346 */ 1347 if ((ifp->if_flags & IFF_UP) == 0) 1348 return (ENETDOWN); 1349 if (ifp->if_pcount++ != 0) 1350 return (0); 1351 ifp->if_flags |= IFF_PROMISC; 1352 log(LOG_INFO, "%s: promiscuous mode enabled\n", 1353 ifp->if_xname); 1354 } else { 1355 if (--ifp->if_pcount > 0) 1356 return (0); 1357 ifp->if_flags &= ~IFF_PROMISC; 1358 log(LOG_INFO, "%s: promiscuous mode disabled\n", 1359 ifp->if_xname); 1360 } 1361 ifr.ifr_flags = ifp->if_flags; 1362 ifr.ifr_flagshigh = ifp->if_ipending >> 16; 1363 error = (*ifp->if_ioctl)(ifp, SIOCSIFFLAGS, (caddr_t)&ifr, 1364 (struct ucred *)NULL); 1365 if (error == 0) 1366 rt_ifmsg(ifp); 1367 else 1368 ifp->if_flags = oldflags; 1369 return error; 1370 } 1371 1372 /* 1373 * Return interface configuration 1374 * of system. List may be used 1375 * in later ioctl's (above) to get 1376 * other information. 1377 */ 1378 /*ARGSUSED*/ 1379 static int 1380 ifconf(u_long cmd, caddr_t data, struct thread *td) 1381 { 1382 struct ifconf *ifc = (struct ifconf *)data; 1383 struct ifnet *ifp; 1384 struct ifaddr *ifa; 1385 struct sockaddr *sa; 1386 struct ifreq ifr, *ifrp; 1387 int space = ifc->ifc_len, error = 0; 1388 1389 ifrp = ifc->ifc_req; 1390 TAILQ_FOREACH(ifp, &ifnet, if_link) { 1391 int addrs; 1392 1393 if (space <= sizeof (ifr)) 1394 break; 1395 if (strlcpy(ifr.ifr_name, ifp->if_xname, sizeof(ifr.ifr_name)) 1396 >= sizeof(ifr.ifr_name)) { 1397 error = ENAMETOOLONG; 1398 break; 1399 } 1400 1401 addrs = 0; 1402 ifa = ifp->if_addrhead.tqh_first; 1403 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) { 1404 if (space <= sizeof(ifr)) 1405 break; 1406 sa = ifa->ifa_addr; 1407 if (td->td_proc->p_ucred->cr_prison && 1408 prison_if(td, sa)) 1409 continue; 1410 addrs++; 1411 #ifdef COMPAT_43 1412 if (cmd == OSIOCGIFCONF) { 1413 struct osockaddr *osa = 1414 (struct osockaddr *)&ifr.ifr_addr; 1415 ifr.ifr_addr = *sa; 1416 osa->sa_family = sa->sa_family; 1417 error = copyout((caddr_t)&ifr, (caddr_t)ifrp, 1418 sizeof (ifr)); 1419 ifrp++; 1420 } else 1421 #endif 1422 if (sa->sa_len <= sizeof(*sa)) { 1423 ifr.ifr_addr = *sa; 1424 error = copyout((caddr_t)&ifr, (caddr_t)ifrp, 1425 sizeof (ifr)); 1426 ifrp++; 1427 } else { 1428 if (space < sizeof (ifr) + sa->sa_len - 1429 sizeof(*sa)) 1430 break; 1431 space -= sa->sa_len - sizeof(*sa); 1432 error = copyout((caddr_t)&ifr, (caddr_t)ifrp, 1433 sizeof (ifr.ifr_name)); 1434 if (error == 0) 1435 error = copyout((caddr_t)sa, 1436 (caddr_t)&ifrp->ifr_addr, sa->sa_len); 1437 ifrp = (struct ifreq *) 1438 (sa->sa_len + (caddr_t)&ifrp->ifr_addr); 1439 } 1440 if (error) 1441 break; 1442 space -= sizeof (ifr); 1443 } 1444 if (error) 1445 break; 1446 if (!addrs) { 1447 bzero((caddr_t)&ifr.ifr_addr, sizeof(ifr.ifr_addr)); 1448 error = copyout((caddr_t)&ifr, (caddr_t)ifrp, 1449 sizeof (ifr)); 1450 if (error) 1451 break; 1452 space -= sizeof (ifr); 1453 ifrp++; 1454 } 1455 } 1456 ifc->ifc_len -= space; 1457 return (error); 1458 } 1459 1460 /* 1461 * Just like if_promisc(), but for all-multicast-reception mode. 1462 */ 1463 int 1464 if_allmulti(ifp, onswitch) 1465 struct ifnet *ifp; 1466 int onswitch; 1467 { 1468 int error = 0; 1469 int s = splimp(); 1470 struct ifreq ifr; 1471 1472 if (onswitch) { 1473 if (ifp->if_amcount++ == 0) { 1474 ifp->if_flags |= IFF_ALLMULTI; 1475 ifr.ifr_flags = ifp->if_flags; 1476 ifr.ifr_flagshigh = ifp->if_ipending >> 16; 1477 error = ifp->if_ioctl(ifp, SIOCSIFFLAGS, (caddr_t)&ifr, 1478 (struct ucred *)NULL); 1479 } 1480 } else { 1481 if (ifp->if_amcount > 1) { 1482 ifp->if_amcount--; 1483 } else { 1484 ifp->if_amcount = 0; 1485 ifp->if_flags &= ~IFF_ALLMULTI; 1486 ifr.ifr_flags = ifp->if_flags; 1487 ifr.ifr_flagshigh = ifp->if_ipending >> 16; 1488 error = ifp->if_ioctl(ifp, SIOCSIFFLAGS, (caddr_t)&ifr, 1489 (struct ucred *)NULL); 1490 } 1491 } 1492 splx(s); 1493 1494 if (error == 0) 1495 rt_ifmsg(ifp); 1496 return error; 1497 } 1498 1499 /* 1500 * Add a multicast listenership to the interface in question. 1501 * The link layer provides a routine which converts 1502 */ 1503 int 1504 if_addmulti(ifp, sa, retifma) 1505 struct ifnet *ifp; /* interface to manipulate */ 1506 struct sockaddr *sa; /* address to add */ 1507 struct ifmultiaddr **retifma; 1508 { 1509 struct sockaddr *llsa, *dupsa; 1510 int error, s; 1511 struct ifmultiaddr *ifma; 1512 1513 /* 1514 * If the matching multicast address already exists 1515 * then don't add a new one, just add a reference 1516 */ 1517 LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { 1518 if (equal(sa, ifma->ifma_addr)) { 1519 ifma->ifma_refcount++; 1520 if (retifma) 1521 *retifma = ifma; 1522 return 0; 1523 } 1524 } 1525 1526 /* 1527 * Give the link layer a chance to accept/reject it, and also 1528 * find out which AF_LINK address this maps to, if it isn't one 1529 * already. 1530 */ 1531 if (ifp->if_resolvemulti) { 1532 error = ifp->if_resolvemulti(ifp, &llsa, sa); 1533 if (error) return error; 1534 } else { 1535 llsa = 0; 1536 } 1537 1538 MALLOC(ifma, struct ifmultiaddr *, sizeof *ifma, M_IFMADDR, M_WAITOK); 1539 MALLOC(dupsa, struct sockaddr *, sa->sa_len, M_IFMADDR, M_WAITOK); 1540 bcopy(sa, dupsa, sa->sa_len); 1541 1542 ifma->ifma_addr = dupsa; 1543 ifma->ifma_lladdr = llsa; 1544 ifma->ifma_ifp = ifp; 1545 ifma->ifma_refcount = 1; 1546 ifma->ifma_protospec = 0; 1547 rt_newmaddrmsg(RTM_NEWMADDR, ifma); 1548 1549 /* 1550 * Some network interfaces can scan the address list at 1551 * interrupt time; lock them out. 1552 */ 1553 s = splimp(); 1554 LIST_INSERT_HEAD(&ifp->if_multiaddrs, ifma, ifma_link); 1555 splx(s); 1556 *retifma = ifma; 1557 1558 if (llsa != 0) { 1559 LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { 1560 if (equal(ifma->ifma_addr, llsa)) 1561 break; 1562 } 1563 if (ifma) { 1564 ifma->ifma_refcount++; 1565 } else { 1566 MALLOC(ifma, struct ifmultiaddr *, sizeof *ifma, 1567 M_IFMADDR, M_WAITOK); 1568 MALLOC(dupsa, struct sockaddr *, llsa->sa_len, 1569 M_IFMADDR, M_WAITOK); 1570 bcopy(llsa, dupsa, llsa->sa_len); 1571 ifma->ifma_addr = dupsa; 1572 ifma->ifma_ifp = ifp; 1573 ifma->ifma_refcount = 1; 1574 s = splimp(); 1575 LIST_INSERT_HEAD(&ifp->if_multiaddrs, ifma, ifma_link); 1576 splx(s); 1577 } 1578 } 1579 /* 1580 * We are certain we have added something, so call down to the 1581 * interface to let them know about it. 1582 */ 1583 s = splimp(); 1584 ifp->if_ioctl(ifp, SIOCADDMULTI, 0, (struct ucred *)NULL); 1585 splx(s); 1586 1587 return 0; 1588 } 1589 1590 /* 1591 * Remove a reference to a multicast address on this interface. Yell 1592 * if the request does not match an existing membership. 1593 */ 1594 int 1595 if_delmulti(ifp, sa) 1596 struct ifnet *ifp; 1597 struct sockaddr *sa; 1598 { 1599 struct ifmultiaddr *ifma; 1600 int s; 1601 1602 LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) 1603 if (equal(sa, ifma->ifma_addr)) 1604 break; 1605 if (ifma == 0) 1606 return ENOENT; 1607 1608 if (ifma->ifma_refcount > 1) { 1609 ifma->ifma_refcount--; 1610 return 0; 1611 } 1612 1613 rt_newmaddrmsg(RTM_DELMADDR, ifma); 1614 sa = ifma->ifma_lladdr; 1615 s = splimp(); 1616 LIST_REMOVE(ifma, ifma_link); 1617 /* 1618 * Make sure the interface driver is notified 1619 * in the case of a link layer mcast group being left. 1620 */ 1621 if (ifma->ifma_addr->sa_family == AF_LINK && sa == 0) 1622 ifp->if_ioctl(ifp, SIOCDELMULTI, 0, (struct ucred *)NULL); 1623 splx(s); 1624 free(ifma->ifma_addr, M_IFMADDR); 1625 free(ifma, M_IFMADDR); 1626 if (sa == 0) 1627 return 0; 1628 1629 /* 1630 * Now look for the link-layer address which corresponds to 1631 * this network address. It had been squirreled away in 1632 * ifma->ifma_lladdr for this purpose (so we don't have 1633 * to call ifp->if_resolvemulti() again), and we saved that 1634 * value in sa above. If some nasty deleted the 1635 * link-layer address out from underneath us, we can deal because 1636 * the address we stored was is not the same as the one which was 1637 * in the record for the link-layer address. (So we don't complain 1638 * in that case.) 1639 */ 1640 LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) 1641 if (equal(sa, ifma->ifma_addr)) 1642 break; 1643 if (ifma == 0) 1644 return 0; 1645 1646 if (ifma->ifma_refcount > 1) { 1647 ifma->ifma_refcount--; 1648 return 0; 1649 } 1650 1651 s = splimp(); 1652 LIST_REMOVE(ifma, ifma_link); 1653 ifp->if_ioctl(ifp, SIOCDELMULTI, 0, (struct ucred *)NULL); 1654 splx(s); 1655 free(ifma->ifma_addr, M_IFMADDR); 1656 free(sa, M_IFMADDR); 1657 free(ifma, M_IFMADDR); 1658 1659 return 0; 1660 } 1661 1662 /* 1663 * Set the link layer address on an interface. 1664 * 1665 * At this time we only support certain types of interfaces, 1666 * and we don't allow the length of the address to change. 1667 */ 1668 int 1669 if_setlladdr(struct ifnet *ifp, const u_char *lladdr, int len) 1670 { 1671 struct sockaddr_dl *sdl; 1672 struct ifaddr *ifa; 1673 struct ifreq ifr; 1674 1675 ifa = ifnet_addrs[ifp->if_index - 1]; 1676 if (ifa == NULL) 1677 return (EINVAL); 1678 sdl = (struct sockaddr_dl *)ifa->ifa_addr; 1679 if (sdl == NULL) 1680 return (EINVAL); 1681 if (len != sdl->sdl_alen) /* don't allow length to change */ 1682 return (EINVAL); 1683 switch (ifp->if_type) { 1684 case IFT_ETHER: /* these types use struct arpcom */ 1685 case IFT_FDDI: 1686 case IFT_XETHER: 1687 case IFT_ISO88025: 1688 case IFT_L2VLAN: 1689 bcopy(lladdr, ((struct arpcom *)ifp->if_softc)->ac_enaddr, len); 1690 /* FALLTHROUGH */ 1691 case IFT_ARCNET: 1692 bcopy(lladdr, LLADDR(sdl), len); 1693 break; 1694 default: 1695 return (ENODEV); 1696 } 1697 /* 1698 * If the interface is already up, we need 1699 * to re-init it in order to reprogram its 1700 * address filter. 1701 */ 1702 if ((ifp->if_flags & IFF_UP) != 0) { 1703 ifp->if_flags &= ~IFF_UP; 1704 ifr.ifr_flags = ifp->if_flags; 1705 ifr.ifr_flagshigh = ifp->if_ipending >> 16; 1706 (*ifp->if_ioctl)(ifp, SIOCSIFFLAGS, (caddr_t)&ifr, 1707 (struct ucred *)NULL); 1708 ifp->if_flags |= IFF_UP; 1709 ifr.ifr_flags = ifp->if_flags; 1710 ifr.ifr_flagshigh = ifp->if_ipending >> 16; 1711 (*ifp->if_ioctl)(ifp, SIOCSIFFLAGS, (caddr_t)&ifr, 1712 (struct ucred *)NULL); 1713 #ifdef INET 1714 /* 1715 * Also send gratuitous ARPs to notify other nodes about 1716 * the address change. 1717 */ 1718 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) { 1719 if (ifa->ifa_addr != NULL && 1720 ifa->ifa_addr->sa_family == AF_INET) 1721 arp_ifinit(ifp, ifa); 1722 } 1723 #endif 1724 } 1725 return (0); 1726 } 1727 1728 struct ifmultiaddr * 1729 ifmaof_ifpforaddr(sa, ifp) 1730 struct sockaddr *sa; 1731 struct ifnet *ifp; 1732 { 1733 struct ifmultiaddr *ifma; 1734 1735 LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) 1736 if (equal(ifma->ifma_addr, sa)) 1737 break; 1738 1739 return ifma; 1740 } 1741 1742 /* 1743 * The name argument must be a pointer to storage which will last as 1744 * long as the interface does. For physical devices, the result of 1745 * device_get_name(dev) is a good choice and for pseudo-devices a 1746 * static string works well. 1747 */ 1748 void 1749 if_initname(struct ifnet *ifp, const char *name, int unit) 1750 { 1751 ifp->if_dname = name; 1752 ifp->if_dunit = unit; 1753 if (unit != IF_DUNIT_NONE) 1754 snprintf(ifp->if_xname, IFNAMSIZ, "%s%d", name, unit); 1755 else 1756 strlcpy(ifp->if_xname, name, IFNAMSIZ); 1757 } 1758 1759 int 1760 if_printf(struct ifnet *ifp, const char *fmt, ...) 1761 { 1762 __va_list ap; 1763 int retval; 1764 1765 retval = printf("%s: ", ifp->if_xname); 1766 __va_start(ap, fmt); 1767 retval += vprintf(fmt, ap); 1768 __va_end(ap); 1769 return (retval); 1770 } 1771 1772 SYSCTL_NODE(_net, PF_LINK, link, CTLFLAG_RW, 0, "Link layers"); 1773 SYSCTL_NODE(_net_link, 0, generic, CTLFLAG_RW, 0, "Generic link-management"); 1774