1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 1983, 1993 5 * The Regents of the University of California. 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 University 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 REGENTS 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 REGENTS 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 #ifndef lint 33 static const char copyright[] = 34 "@(#) Copyright (c) 1983, 1993\n\ 35 The Regents of the University of California. All rights reserved.\n"; 36 #endif /* not lint */ 37 38 #ifndef lint 39 #if 0 40 static char sccsid[] = "@(#)ifconfig.c 8.2 (Berkeley) 2/16/94"; 41 #endif 42 static const char rcsid[] = 43 "$FreeBSD$"; 44 #endif /* not lint */ 45 46 #include <sys/param.h> 47 #include <sys/ioctl.h> 48 #include <sys/module.h> 49 #include <sys/linker.h> 50 #include <sys/queue.h> 51 #include <sys/socket.h> 52 #include <sys/time.h> 53 54 #include <net/ethernet.h> 55 #include <net/if.h> 56 #include <net/if_dl.h> 57 #include <net/if_types.h> 58 #include <net/route.h> 59 60 /* IP */ 61 #include <netinet/in.h> 62 #include <netinet/in_var.h> 63 #include <arpa/inet.h> 64 #include <netdb.h> 65 66 #include <fnmatch.h> 67 #include <ifaddrs.h> 68 #include <ctype.h> 69 #include <err.h> 70 #include <errno.h> 71 #include <fcntl.h> 72 #ifdef JAIL 73 #include <jail.h> 74 #endif 75 #include <stdbool.h> 76 #include <stdio.h> 77 #include <stdlib.h> 78 #include <string.h> 79 #include <unistd.h> 80 81 #include "ifconfig.h" 82 83 /* 84 * Since "struct ifreq" is composed of various union members, callers 85 * should pay special attention to interpret the value. 86 * (.e.g. little/big endian difference in the structure.) 87 */ 88 struct ifreq ifr; 89 90 char name[IFNAMSIZ]; 91 char *descr = NULL; 92 size_t descrlen = 64; 93 int setaddr; 94 int setmask; 95 int doalias; 96 int clearaddr; 97 int newaddr = 1; 98 int verbose; 99 int noload; 100 int printifname = 0; 101 102 int supmedia = 0; 103 int printkeys = 0; /* Print keying material for interfaces. */ 104 int exit_code = 0; 105 106 /* Formatter Strings */ 107 char *f_inet, *f_inet6, *f_ether, *f_addr; 108 109 static bool group_member(const char *ifname, const char *match, 110 const char *nomatch); 111 static int ifconfig(int argc, char *const *argv, int iscreate, 112 const struct afswtch *afp); 113 static void status(const struct afswtch *afp, const struct sockaddr_dl *sdl, 114 struct ifaddrs *ifa); 115 static void tunnel_status(int s); 116 static _Noreturn void usage(void); 117 118 static int getifflags(const char *ifname, int us); 119 120 static struct afswtch *af_getbyname(const char *name); 121 static struct afswtch *af_getbyfamily(int af); 122 static void af_other_status(int); 123 124 void printifnamemaybe(void); 125 126 static struct option *opts = NULL; 127 128 struct ifa_order_elt { 129 int if_order; 130 int af_orders[255]; 131 struct ifaddrs *ifa; 132 TAILQ_ENTRY(ifa_order_elt) link; 133 }; 134 135 TAILQ_HEAD(ifa_queue, ifa_order_elt); 136 137 static struct module_map_entry { 138 const char *ifname; 139 const char *kldname; 140 } module_map[] = { 141 { 142 .ifname = "tun", 143 .kldname = "if_tuntap", 144 }, 145 { 146 .ifname = "tap", 147 .kldname = "if_tuntap", 148 }, 149 { 150 .ifname = "vmnet", 151 .kldname = "if_tuntap", 152 }, 153 { 154 .ifname = "ipsec", 155 .kldname = "ipsec", 156 }, 157 { 158 /* 159 * This mapping exists because there is a conflicting enc module 160 * in CAM. ifconfig's guessing behavior will attempt to match 161 * the ifname to a module as well as if_${ifname} and clash with 162 * CAM enc. This is an assertion of the correct module to load. 163 */ 164 .ifname = "enc", 165 .kldname = "if_enc", 166 }, 167 }; 168 169 170 void 171 opt_register(struct option *p) 172 { 173 p->next = opts; 174 opts = p; 175 } 176 177 static void 178 usage(void) 179 { 180 char options[1024]; 181 struct option *p; 182 183 /* XXX not right but close enough for now */ 184 options[0] = '\0'; 185 for (p = opts; p != NULL; p = p->next) { 186 strlcat(options, p->opt_usage, sizeof(options)); 187 strlcat(options, " ", sizeof(options)); 188 } 189 190 fprintf(stderr, 191 "usage: ifconfig [-f type:format] %sinterface address_family\n" 192 " [address [dest_address]] [parameters]\n" 193 " ifconfig interface create\n" 194 " ifconfig -a %s[-d] [-m] [-u] [-v] [address_family]\n" 195 " ifconfig -l [-d] [-u] [address_family]\n" 196 " ifconfig %s[-d] [-m] [-u] [-v]\n", 197 options, options, options); 198 exit(1); 199 } 200 201 #define ORDERS_SIZE(x) sizeof(x) / sizeof(x[0]) 202 203 static int 204 calcorders(struct ifaddrs *ifa, struct ifa_queue *q) 205 { 206 struct ifaddrs *prev; 207 struct ifa_order_elt *cur; 208 unsigned int ord, af, ifa_ord; 209 210 prev = NULL; 211 cur = NULL; 212 ord = 0; 213 ifa_ord = 0; 214 215 while (ifa != NULL) { 216 if (prev == NULL || 217 strcmp(ifa->ifa_name, prev->ifa_name) != 0) { 218 cur = calloc(1, sizeof(*cur)); 219 220 if (cur == NULL) 221 return (-1); 222 223 TAILQ_INSERT_TAIL(q, cur, link); 224 cur->if_order = ifa_ord ++; 225 cur->ifa = ifa; 226 ord = 0; 227 } 228 229 if (ifa->ifa_addr) { 230 af = ifa->ifa_addr->sa_family; 231 232 if (af < ORDERS_SIZE(cur->af_orders) && 233 cur->af_orders[af] == 0) 234 cur->af_orders[af] = ++ord; 235 } 236 prev = ifa; 237 ifa = ifa->ifa_next; 238 } 239 240 return (0); 241 } 242 243 static int 244 cmpifaddrs(struct ifaddrs *a, struct ifaddrs *b, struct ifa_queue *q) 245 { 246 struct ifa_order_elt *cur, *e1, *e2; 247 unsigned int af1, af2; 248 int ret; 249 250 e1 = e2 = NULL; 251 252 ret = strcmp(a->ifa_name, b->ifa_name); 253 if (ret != 0) { 254 TAILQ_FOREACH(cur, q, link) { 255 if (e1 && e2) 256 break; 257 258 if (strcmp(cur->ifa->ifa_name, a->ifa_name) == 0) 259 e1 = cur; 260 else if (strcmp(cur->ifa->ifa_name, b->ifa_name) == 0) 261 e2 = cur; 262 } 263 264 if (!e1 || !e2) 265 return (0); 266 else 267 return (e1->if_order - e2->if_order); 268 269 } else if (a->ifa_addr != NULL && b->ifa_addr != NULL) { 270 TAILQ_FOREACH(cur, q, link) { 271 if (strcmp(cur->ifa->ifa_name, a->ifa_name) == 0) { 272 e1 = cur; 273 break; 274 } 275 } 276 277 if (!e1) 278 return (0); 279 280 af1 = a->ifa_addr->sa_family; 281 af2 = b->ifa_addr->sa_family; 282 283 if (af1 < ORDERS_SIZE(e1->af_orders) && 284 af2 < ORDERS_SIZE(e1->af_orders)) 285 return (e1->af_orders[af1] - e1->af_orders[af2]); 286 } 287 288 return (0); 289 } 290 291 static void freeformat(void) 292 { 293 294 if (f_inet != NULL) 295 free(f_inet); 296 if (f_inet6 != NULL) 297 free(f_inet6); 298 if (f_ether != NULL) 299 free(f_ether); 300 if (f_addr != NULL) 301 free(f_addr); 302 } 303 304 static void setformat(char *input) 305 { 306 char *formatstr, *category, *modifier; 307 308 formatstr = strdup(input); 309 while ((category = strsep(&formatstr, ",")) != NULL) { 310 modifier = strchr(category, ':'); 311 if (modifier == NULL || modifier[1] == '\0') { 312 warnx("Skipping invalid format specification: %s\n", 313 category); 314 continue; 315 } 316 317 /* Split the string on the separator, then seek past it */ 318 modifier[0] = '\0'; 319 modifier++; 320 321 if (strcmp(category, "addr") == 0) 322 f_addr = strdup(modifier); 323 else if (strcmp(category, "ether") == 0) 324 f_ether = strdup(modifier); 325 else if (strcmp(category, "inet") == 0) 326 f_inet = strdup(modifier); 327 else if (strcmp(category, "inet6") == 0) 328 f_inet6 = strdup(modifier); 329 } 330 free(formatstr); 331 } 332 333 #undef ORDERS_SIZE 334 335 static struct ifaddrs * 336 sortifaddrs(struct ifaddrs *list, 337 int (*compare)(struct ifaddrs *, struct ifaddrs *, struct ifa_queue *), 338 struct ifa_queue *q) 339 { 340 struct ifaddrs *right, *temp, *last, *result, *next, *tail; 341 342 right = list; 343 temp = list; 344 last = list; 345 result = NULL; 346 next = NULL; 347 tail = NULL; 348 349 if (!list || !list->ifa_next) 350 return (list); 351 352 while (temp && temp->ifa_next) { 353 last = right; 354 right = right->ifa_next; 355 temp = temp->ifa_next->ifa_next; 356 } 357 358 last->ifa_next = NULL; 359 360 list = sortifaddrs(list, compare, q); 361 right = sortifaddrs(right, compare, q); 362 363 while (list || right) { 364 365 if (!right) { 366 next = list; 367 list = list->ifa_next; 368 } else if (!list) { 369 next = right; 370 right = right->ifa_next; 371 } else if (compare(list, right, q) <= 0) { 372 next = list; 373 list = list->ifa_next; 374 } else { 375 next = right; 376 right = right->ifa_next; 377 } 378 379 if (!result) 380 result = next; 381 else 382 tail->ifa_next = next; 383 384 tail = next; 385 } 386 387 return (result); 388 } 389 390 void printifnamemaybe() 391 { 392 if (printifname) 393 printf("%s\n", name); 394 } 395 396 int 397 main(int argc, char *argv[]) 398 { 399 int c, all, namesonly, downonly, uponly; 400 const struct afswtch *afp = NULL; 401 int ifindex; 402 struct ifaddrs *ifap, *sifap, *ifa; 403 struct ifreq paifr; 404 const struct sockaddr_dl *sdl; 405 char options[1024], *cp, *envformat, *namecp = NULL; 406 struct ifa_queue q = TAILQ_HEAD_INITIALIZER(q); 407 struct ifa_order_elt *cur, *tmp; 408 const char *ifname, *matchgroup, *nogroup; 409 struct option *p; 410 size_t iflen; 411 int flags; 412 413 all = downonly = uponly = namesonly = noload = verbose = 0; 414 f_inet = f_inet6 = f_ether = f_addr = NULL; 415 matchgroup = nogroup = NULL; 416 417 envformat = getenv("IFCONFIG_FORMAT"); 418 if (envformat != NULL) 419 setformat(envformat); 420 421 /* 422 * Ensure we print interface name when expected to, 423 * even if we terminate early due to error. 424 */ 425 atexit(printifnamemaybe); 426 427 /* Parse leading line options */ 428 strlcpy(options, "G:adf:klmnuv", sizeof(options)); 429 for (p = opts; p != NULL; p = p->next) 430 strlcat(options, p->opt, sizeof(options)); 431 while ((c = getopt(argc, argv, options)) != -1) { 432 switch (c) { 433 case 'a': /* scan all interfaces */ 434 all++; 435 break; 436 case 'd': /* restrict scan to "down" interfaces */ 437 downonly++; 438 break; 439 case 'f': 440 if (optarg == NULL) 441 usage(); 442 setformat(optarg); 443 break; 444 case 'G': 445 if (optarg == NULL || all == 0) 446 usage(); 447 nogroup = optarg; 448 break; 449 case 'k': 450 printkeys++; 451 break; 452 case 'l': /* scan interface names only */ 453 namesonly++; 454 break; 455 case 'm': /* show media choices in status */ 456 supmedia = 1; 457 break; 458 case 'n': /* suppress module loading */ 459 noload++; 460 break; 461 case 'u': /* restrict scan to "up" interfaces */ 462 uponly++; 463 break; 464 case 'v': 465 verbose++; 466 break; 467 case 'g': 468 if (all) { 469 if (optarg == NULL) 470 usage(); 471 matchgroup = optarg; 472 break; 473 } 474 /* FALLTHROUGH */ 475 default: 476 for (p = opts; p != NULL; p = p->next) 477 if (p->opt[0] == c) { 478 p->cb(optarg); 479 break; 480 } 481 if (p == NULL) 482 usage(); 483 break; 484 } 485 } 486 argc -= optind; 487 argv += optind; 488 489 /* -l cannot be used with -a or -m */ 490 if (namesonly && (all || supmedia)) 491 usage(); 492 493 /* nonsense.. */ 494 if (uponly && downonly) 495 usage(); 496 497 /* no arguments is equivalent to '-a' */ 498 if (!namesonly && argc < 1) 499 all = 1; 500 501 /* -a and -l allow an address family arg to limit the output */ 502 if (all || namesonly) { 503 if (argc > 1) 504 usage(); 505 506 ifname = NULL; 507 ifindex = 0; 508 if (argc == 1) { 509 afp = af_getbyname(*argv); 510 if (afp == NULL) { 511 warnx("Address family '%s' unknown.", *argv); 512 usage(); 513 } 514 if (afp->af_name != NULL) 515 argc--, argv++; 516 /* leave with afp non-zero */ 517 } 518 } else { 519 /* not listing, need an argument */ 520 if (argc < 1) 521 usage(); 522 523 ifname = *argv; 524 argc--, argv++; 525 526 /* check and maybe load support for this interface */ 527 ifmaybeload(ifname); 528 529 ifindex = if_nametoindex(ifname); 530 if (ifindex == 0) { 531 /* 532 * NOTE: We must special-case the `create' command 533 * right here as we would otherwise fail when trying 534 * to find the interface. 535 */ 536 if (argc > 0 && (strcmp(argv[0], "create") == 0 || 537 strcmp(argv[0], "plumb") == 0)) { 538 iflen = strlcpy(name, ifname, sizeof(name)); 539 if (iflen >= sizeof(name)) 540 errx(1, "%s: cloning name too long", 541 ifname); 542 ifconfig(argc, argv, 1, NULL); 543 exit(exit_code); 544 } 545 #ifdef JAIL 546 /* 547 * NOTE: We have to special-case the `-vnet' command 548 * right here as we would otherwise fail when trying 549 * to find the interface as it lives in another vnet. 550 */ 551 if (argc > 0 && (strcmp(argv[0], "-vnet") == 0)) { 552 iflen = strlcpy(name, ifname, sizeof(name)); 553 if (iflen >= sizeof(name)) 554 errx(1, "%s: interface name too long", 555 ifname); 556 ifconfig(argc, argv, 0, NULL); 557 exit(exit_code); 558 } 559 #endif 560 errx(1, "interface %s does not exist", ifname); 561 } else { 562 /* 563 * Do not allow use `create` command as hostname if 564 * address family is not specified. 565 */ 566 if (argc > 0 && (strcmp(argv[0], "create") == 0 || 567 strcmp(argv[0], "plumb") == 0)) { 568 if (argc == 1) 569 errx(1, "interface %s already exists", 570 ifname); 571 argc--, argv++; 572 } 573 } 574 } 575 576 /* Check for address family */ 577 if (argc > 0) { 578 afp = af_getbyname(*argv); 579 if (afp != NULL) 580 argc--, argv++; 581 } 582 583 /* 584 * Check for a requested configuration action on a single interface, 585 * which doesn't require building, sorting, and searching the entire 586 * system address list 587 */ 588 if ((argc > 0) && (ifname != NULL)) { 589 iflen = strlcpy(name, ifname, sizeof(name)); 590 if (iflen >= sizeof(name)) { 591 warnx("%s: interface name too long, skipping", ifname); 592 } else { 593 flags = getifflags(name, -1); 594 if (!(((flags & IFF_CANTCONFIG) != 0) || 595 (downonly && (flags & IFF_UP) != 0) || 596 (uponly && (flags & IFF_UP) == 0))) 597 ifconfig(argc, argv, 0, afp); 598 } 599 goto done; 600 } 601 602 if (getifaddrs(&ifap) != 0) 603 err(EXIT_FAILURE, "getifaddrs"); 604 605 cp = NULL; 606 607 if (calcorders(ifap, &q) != 0) 608 err(EXIT_FAILURE, "calcorders"); 609 610 sifap = sortifaddrs(ifap, cmpifaddrs, &q); 611 612 TAILQ_FOREACH_SAFE(cur, &q, link, tmp) 613 free(cur); 614 615 ifindex = 0; 616 for (ifa = sifap; ifa; ifa = ifa->ifa_next) { 617 memset(&paifr, 0, sizeof(paifr)); 618 strlcpy(paifr.ifr_name, ifa->ifa_name, sizeof(paifr.ifr_name)); 619 if (sizeof(paifr.ifr_addr) >= ifa->ifa_addr->sa_len) { 620 memcpy(&paifr.ifr_addr, ifa->ifa_addr, 621 ifa->ifa_addr->sa_len); 622 } 623 624 if (ifname != NULL && strcmp(ifname, ifa->ifa_name) != 0) 625 continue; 626 if (ifa->ifa_addr->sa_family == AF_LINK) 627 sdl = (const struct sockaddr_dl *) ifa->ifa_addr; 628 else 629 sdl = NULL; 630 if (cp != NULL && strcmp(cp, ifa->ifa_name) == 0 && !namesonly) 631 continue; 632 iflen = strlcpy(name, ifa->ifa_name, sizeof(name)); 633 if (iflen >= sizeof(name)) { 634 warnx("%s: interface name too long, skipping", 635 ifa->ifa_name); 636 continue; 637 } 638 cp = ifa->ifa_name; 639 640 if ((ifa->ifa_flags & IFF_CANTCONFIG) != 0) 641 continue; 642 if (downonly && (ifa->ifa_flags & IFF_UP) != 0) 643 continue; 644 if (uponly && (ifa->ifa_flags & IFF_UP) == 0) 645 continue; 646 if (!group_member(ifa->ifa_name, matchgroup, nogroup)) 647 continue; 648 /* 649 * Are we just listing the interfaces? 650 */ 651 if (namesonly) { 652 if (namecp == cp) 653 continue; 654 if (afp != NULL) { 655 /* special case for "ether" address family */ 656 if (!strcmp(afp->af_name, "ether")) { 657 if (sdl == NULL || 658 (sdl->sdl_type != IFT_ETHER && 659 sdl->sdl_type != IFT_L2VLAN && 660 sdl->sdl_type != IFT_BRIDGE) || 661 sdl->sdl_alen != ETHER_ADDR_LEN) 662 continue; 663 } else { 664 if (ifa->ifa_addr->sa_family 665 != afp->af_af) 666 continue; 667 } 668 } 669 namecp = cp; 670 ifindex++; 671 if (ifindex > 1) 672 printf(" "); 673 fputs(name, stdout); 674 continue; 675 } 676 ifindex++; 677 678 if (argc > 0) 679 ifconfig(argc, argv, 0, afp); 680 else 681 status(afp, sdl, ifa); 682 } 683 if (namesonly) 684 printf("\n"); 685 freeifaddrs(ifap); 686 687 done: 688 freeformat(); 689 exit(exit_code); 690 } 691 692 /* 693 * Returns true if an interface should be listed because any its groups 694 * matches shell pattern "match" and none of groups matches pattern "nomatch". 695 * If any pattern is NULL, corresponding condition is skipped. 696 */ 697 static bool 698 group_member(const char *ifname, const char *match, const char *nomatch) 699 { 700 static int sock = -1; 701 702 struct ifgroupreq ifgr; 703 struct ifg_req *ifg; 704 int len; 705 bool matched, nomatched; 706 707 /* Sanity checks. */ 708 if (match == NULL && nomatch == NULL) 709 return (true); 710 if (ifname == NULL) 711 return (false); 712 713 memset(&ifgr, 0, sizeof(ifgr)); 714 strlcpy(ifgr.ifgr_name, ifname, IFNAMSIZ); 715 716 /* The socket is opened once. Let _exit() close it. */ 717 if (sock == -1) { 718 sock = socket(AF_LOCAL, SOCK_DGRAM, 0); 719 if (sock == -1) 720 errx(1, "%s: socket(AF_LOCAL,SOCK_DGRAM)", __func__); 721 } 722 723 /* Determine amount of memory for the list of groups. */ 724 if (ioctl(sock, SIOCGIFGROUP, (caddr_t)&ifgr) == -1) { 725 if (errno == EINVAL || errno == ENOTTY) 726 return (false); 727 else 728 errx(1, "%s: SIOCGIFGROUP", __func__); 729 } 730 731 /* Obtain the list of groups. */ 732 len = ifgr.ifgr_len; 733 ifgr.ifgr_groups = 734 (struct ifg_req *)calloc(len / sizeof(*ifg), sizeof(*ifg)); 735 736 if (ifgr.ifgr_groups == NULL) 737 errx(1, "%s: no memory", __func__); 738 if (ioctl(sock, SIOCGIFGROUP, (caddr_t)&ifgr) == -1) 739 errx(1, "%s: SIOCGIFGROUP", __func__); 740 741 /* Perform matching. */ 742 matched = false; 743 nomatched = true; 744 for (ifg = ifgr.ifgr_groups; ifg && len >= sizeof(*ifg); ifg++) { 745 len -= sizeof(struct ifg_req); 746 if (match) 747 matched |= !fnmatch(match, ifg->ifgrq_group, 0); 748 if (nomatch) 749 nomatched &= fnmatch(nomatch, ifg->ifgrq_group, 0); 750 } 751 free(ifgr.ifgr_groups); 752 753 if (match && !nomatch) 754 return (matched); 755 if (!match && nomatch) 756 return (nomatched); 757 return (matched && nomatched); 758 } 759 760 static struct afswtch *afs = NULL; 761 762 void 763 af_register(struct afswtch *p) 764 { 765 p->af_next = afs; 766 afs = p; 767 } 768 769 static struct afswtch * 770 af_getbyname(const char *name) 771 { 772 struct afswtch *afp; 773 774 for (afp = afs; afp != NULL; afp = afp->af_next) 775 if (strcmp(afp->af_name, name) == 0) 776 return afp; 777 return NULL; 778 } 779 780 static struct afswtch * 781 af_getbyfamily(int af) 782 { 783 struct afswtch *afp; 784 785 for (afp = afs; afp != NULL; afp = afp->af_next) 786 if (afp->af_af == af) 787 return afp; 788 return NULL; 789 } 790 791 static void 792 af_other_status(int s) 793 { 794 struct afswtch *afp; 795 uint8_t afmask[howmany(AF_MAX, NBBY)]; 796 797 memset(afmask, 0, sizeof(afmask)); 798 for (afp = afs; afp != NULL; afp = afp->af_next) { 799 if (afp->af_other_status == NULL) 800 continue; 801 if (afp->af_af != AF_UNSPEC && isset(afmask, afp->af_af)) 802 continue; 803 afp->af_other_status(s); 804 setbit(afmask, afp->af_af); 805 } 806 } 807 808 static void 809 af_all_tunnel_status(int s) 810 { 811 struct afswtch *afp; 812 uint8_t afmask[howmany(AF_MAX, NBBY)]; 813 814 memset(afmask, 0, sizeof(afmask)); 815 for (afp = afs; afp != NULL; afp = afp->af_next) { 816 if (afp->af_status_tunnel == NULL) 817 continue; 818 if (afp->af_af != AF_UNSPEC && isset(afmask, afp->af_af)) 819 continue; 820 afp->af_status_tunnel(s); 821 setbit(afmask, afp->af_af); 822 } 823 } 824 825 static struct cmd *cmds = NULL; 826 827 void 828 cmd_register(struct cmd *p) 829 { 830 p->c_next = cmds; 831 cmds = p; 832 } 833 834 static const struct cmd * 835 cmd_lookup(const char *name, int iscreate) 836 { 837 const struct cmd *p; 838 839 for (p = cmds; p != NULL; p = p->c_next) 840 if (strcmp(name, p->c_name) == 0) { 841 if (iscreate) { 842 if (p->c_iscloneop) 843 return p; 844 } else { 845 if (!p->c_iscloneop) 846 return p; 847 } 848 } 849 return NULL; 850 } 851 852 struct callback { 853 callback_func *cb_func; 854 void *cb_arg; 855 struct callback *cb_next; 856 }; 857 static struct callback *callbacks = NULL; 858 859 void 860 callback_register(callback_func *func, void *arg) 861 { 862 struct callback *cb; 863 864 cb = malloc(sizeof(struct callback)); 865 if (cb == NULL) 866 errx(1, "unable to allocate memory for callback"); 867 cb->cb_func = func; 868 cb->cb_arg = arg; 869 cb->cb_next = callbacks; 870 callbacks = cb; 871 } 872 873 /* specially-handled commands */ 874 static void setifaddr(const char *, int, int, const struct afswtch *); 875 static const struct cmd setifaddr_cmd = DEF_CMD("ifaddr", 0, setifaddr); 876 877 static void setifdstaddr(const char *, int, int, const struct afswtch *); 878 static const struct cmd setifdstaddr_cmd = 879 DEF_CMD("ifdstaddr", 0, setifdstaddr); 880 881 static int 882 ifconfig(int argc, char *const *argv, int iscreate, const struct afswtch *uafp) 883 { 884 const struct afswtch *afp, *nafp; 885 const struct cmd *p; 886 struct callback *cb; 887 int s; 888 889 strlcpy(ifr.ifr_name, name, sizeof ifr.ifr_name); 890 afp = NULL; 891 if (uafp != NULL) 892 afp = uafp; 893 /* 894 * This is the historical "accident" allowing users to configure IPv4 895 * addresses without the "inet" keyword which while a nice feature has 896 * proven to complicate other things. We cannot remove this but only 897 * make sure we will never have a similar implicit default for IPv6 or 898 * any other address familiy. We need a fallback though for 899 * ifconfig IF up/down etc. to work without INET support as people 900 * never used ifconfig IF link up/down, etc. either. 901 */ 902 #ifndef RESCUE 903 #ifdef INET 904 if (afp == NULL && feature_present("inet")) 905 afp = af_getbyname("inet"); 906 #endif 907 #endif 908 if (afp == NULL) 909 afp = af_getbyname("link"); 910 if (afp == NULL) { 911 warnx("Please specify an address_family."); 912 usage(); 913 } 914 top: 915 ifr.ifr_addr.sa_family = 916 afp->af_af == AF_LINK || afp->af_af == AF_UNSPEC ? 917 AF_LOCAL : afp->af_af; 918 919 if ((s = socket(ifr.ifr_addr.sa_family, SOCK_DGRAM, 0)) < 0 && 920 (uafp != NULL || errno != EAFNOSUPPORT || 921 (s = socket(AF_LOCAL, SOCK_DGRAM, 0)) < 0)) 922 err(1, "socket(family %u,SOCK_DGRAM)", ifr.ifr_addr.sa_family); 923 924 while (argc > 0) { 925 p = cmd_lookup(*argv, iscreate); 926 if (iscreate && p == NULL) { 927 /* 928 * Push the clone create callback so the new 929 * device is created and can be used for any 930 * remaining arguments. 931 */ 932 cb = callbacks; 933 if (cb == NULL) 934 errx(1, "internal error, no callback"); 935 callbacks = cb->cb_next; 936 cb->cb_func(s, cb->cb_arg); 937 iscreate = 0; 938 /* 939 * Handle any address family spec that 940 * immediately follows and potentially 941 * recreate the socket. 942 */ 943 nafp = af_getbyname(*argv); 944 if (nafp != NULL) { 945 argc--, argv++; 946 if (nafp != afp) { 947 close(s); 948 afp = nafp; 949 goto top; 950 } 951 } 952 /* 953 * Look for a normal parameter. 954 */ 955 continue; 956 } 957 if (p == NULL) { 958 /* 959 * Not a recognized command, choose between setting 960 * the interface address and the dst address. 961 */ 962 p = (setaddr ? &setifdstaddr_cmd : &setifaddr_cmd); 963 } 964 if (p->c_parameter == NEXTARG && p->c_u.c_func) { 965 if (argv[1] == NULL) 966 errx(1, "'%s' requires argument", 967 p->c_name); 968 p->c_u.c_func(argv[1], 0, s, afp); 969 argc--, argv++; 970 } else if (p->c_parameter == OPTARG && p->c_u.c_func) { 971 p->c_u.c_func(argv[1], 0, s, afp); 972 if (argv[1] != NULL) 973 argc--, argv++; 974 } else if (p->c_parameter == NEXTARG2 && p->c_u.c_func2) { 975 if (argc < 3) 976 errx(1, "'%s' requires 2 arguments", 977 p->c_name); 978 p->c_u.c_func2(argv[1], argv[2], s, afp); 979 argc -= 2, argv += 2; 980 } else if (p->c_u.c_func) 981 p->c_u.c_func(*argv, p->c_parameter, s, afp); 982 argc--, argv++; 983 } 984 985 /* 986 * Do any post argument processing required by the address family. 987 */ 988 if (afp->af_postproc != NULL) 989 afp->af_postproc(s, afp); 990 /* 991 * Do deferred callbacks registered while processing 992 * command-line arguments. 993 */ 994 for (cb = callbacks; cb != NULL; cb = cb->cb_next) 995 cb->cb_func(s, cb->cb_arg); 996 /* 997 * Do deferred operations. 998 */ 999 if (clearaddr) { 1000 if (afp->af_ridreq == NULL || afp->af_difaddr == 0) { 1001 warnx("interface %s cannot change %s addresses!", 1002 name, afp->af_name); 1003 clearaddr = 0; 1004 } 1005 } 1006 if (clearaddr) { 1007 int ret; 1008 strlcpy(((struct ifreq *)afp->af_ridreq)->ifr_name, name, 1009 sizeof ifr.ifr_name); 1010 ret = ioctl(s, afp->af_difaddr, afp->af_ridreq); 1011 if (ret < 0) { 1012 if (errno == EADDRNOTAVAIL && (doalias >= 0)) { 1013 /* means no previous address for interface */ 1014 } else 1015 Perror("ioctl (SIOCDIFADDR)"); 1016 } 1017 } 1018 if (newaddr) { 1019 if (afp->af_addreq == NULL || afp->af_aifaddr == 0) { 1020 warnx("interface %s cannot change %s addresses!", 1021 name, afp->af_name); 1022 newaddr = 0; 1023 } 1024 } 1025 if (newaddr && (setaddr || setmask)) { 1026 strlcpy(((struct ifreq *)afp->af_addreq)->ifr_name, name, 1027 sizeof ifr.ifr_name); 1028 if (ioctl(s, afp->af_aifaddr, afp->af_addreq) < 0) 1029 Perror("ioctl (SIOCAIFADDR)"); 1030 } 1031 1032 close(s); 1033 return(0); 1034 } 1035 1036 /*ARGSUSED*/ 1037 static void 1038 setifaddr(const char *addr, int param, int s, const struct afswtch *afp) 1039 { 1040 if (afp->af_getaddr == NULL) 1041 return; 1042 /* 1043 * Delay the ioctl to set the interface addr until flags are all set. 1044 * The address interpretation may depend on the flags, 1045 * and the flags may change when the address is set. 1046 */ 1047 setaddr++; 1048 if (doalias == 0 && afp->af_af != AF_LINK) 1049 clearaddr = 1; 1050 afp->af_getaddr(addr, (doalias >= 0 ? ADDR : RIDADDR)); 1051 } 1052 1053 static void 1054 settunnel(const char *src, const char *dst, int s, const struct afswtch *afp) 1055 { 1056 struct addrinfo *srcres, *dstres; 1057 int ecode; 1058 1059 if (afp->af_settunnel == NULL) { 1060 warn("address family %s does not support tunnel setup", 1061 afp->af_name); 1062 return; 1063 } 1064 1065 if ((ecode = getaddrinfo(src, NULL, NULL, &srcres)) != 0) 1066 errx(1, "error in parsing address string: %s", 1067 gai_strerror(ecode)); 1068 1069 if ((ecode = getaddrinfo(dst, NULL, NULL, &dstres)) != 0) 1070 errx(1, "error in parsing address string: %s", 1071 gai_strerror(ecode)); 1072 1073 if (srcres->ai_addr->sa_family != dstres->ai_addr->sa_family) 1074 errx(1, 1075 "source and destination address families do not match"); 1076 1077 afp->af_settunnel(s, srcres, dstres); 1078 1079 freeaddrinfo(srcres); 1080 freeaddrinfo(dstres); 1081 } 1082 1083 /* ARGSUSED */ 1084 static void 1085 deletetunnel(const char *vname, int param, int s, const struct afswtch *afp) 1086 { 1087 1088 if (ioctl(s, SIOCDIFPHYADDR, &ifr) < 0) 1089 err(1, "SIOCDIFPHYADDR"); 1090 } 1091 1092 #ifdef JAIL 1093 static void 1094 setifvnet(const char *jname, int dummy __unused, int s, 1095 const struct afswtch *afp) 1096 { 1097 struct ifreq my_ifr; 1098 1099 memcpy(&my_ifr, &ifr, sizeof(my_ifr)); 1100 my_ifr.ifr_jid = jail_getid(jname); 1101 if (my_ifr.ifr_jid < 0) 1102 errx(1, "%s", jail_errmsg); 1103 if (ioctl(s, SIOCSIFVNET, &my_ifr) < 0) 1104 err(1, "SIOCSIFVNET"); 1105 } 1106 1107 static void 1108 setifrvnet(const char *jname, int dummy __unused, int s, 1109 const struct afswtch *afp) 1110 { 1111 struct ifreq my_ifr; 1112 1113 memcpy(&my_ifr, &ifr, sizeof(my_ifr)); 1114 my_ifr.ifr_jid = jail_getid(jname); 1115 if (my_ifr.ifr_jid < 0) 1116 errx(1, "%s", jail_errmsg); 1117 if (ioctl(s, SIOCSIFRVNET, &my_ifr) < 0) 1118 err(1, "SIOCSIFRVNET(%d, %s)", my_ifr.ifr_jid, my_ifr.ifr_name); 1119 } 1120 #endif 1121 1122 static void 1123 setifnetmask(const char *addr, int dummy __unused, int s, 1124 const struct afswtch *afp) 1125 { 1126 if (afp->af_getaddr != NULL) { 1127 setmask++; 1128 afp->af_getaddr(addr, MASK); 1129 } 1130 } 1131 1132 static void 1133 setifbroadaddr(const char *addr, int dummy __unused, int s, 1134 const struct afswtch *afp) 1135 { 1136 if (afp->af_getaddr != NULL) 1137 afp->af_getaddr(addr, DSTADDR); 1138 } 1139 1140 static void 1141 notealias(const char *addr, int param, int s, const struct afswtch *afp) 1142 { 1143 #define rqtosa(x) (&(((struct ifreq *)(afp->x))->ifr_addr)) 1144 if (setaddr && doalias == 0 && param < 0) 1145 if (afp->af_addreq != NULL && afp->af_ridreq != NULL) 1146 bcopy((caddr_t)rqtosa(af_addreq), 1147 (caddr_t)rqtosa(af_ridreq), 1148 rqtosa(af_addreq)->sa_len); 1149 doalias = param; 1150 if (param < 0) { 1151 clearaddr = 1; 1152 newaddr = 0; 1153 } else 1154 clearaddr = 0; 1155 #undef rqtosa 1156 } 1157 1158 /*ARGSUSED*/ 1159 static void 1160 setifdstaddr(const char *addr, int param __unused, int s, 1161 const struct afswtch *afp) 1162 { 1163 if (afp->af_getaddr != NULL) 1164 afp->af_getaddr(addr, DSTADDR); 1165 } 1166 1167 static int 1168 getifflags(const char *ifname, int us) 1169 { 1170 struct ifreq my_ifr; 1171 int s; 1172 1173 memset(&my_ifr, 0, sizeof(my_ifr)); 1174 (void) strlcpy(my_ifr.ifr_name, ifname, sizeof(my_ifr.ifr_name)); 1175 if (us < 0) { 1176 if ((s = socket(AF_LOCAL, SOCK_DGRAM, 0)) < 0) 1177 err(1, "socket(family AF_LOCAL,SOCK_DGRAM"); 1178 } else 1179 s = us; 1180 if (ioctl(s, SIOCGIFFLAGS, (caddr_t)&my_ifr) < 0) { 1181 Perror("ioctl (SIOCGIFFLAGS)"); 1182 exit(1); 1183 } 1184 if (us < 0) 1185 close(s); 1186 return ((my_ifr.ifr_flags & 0xffff) | (my_ifr.ifr_flagshigh << 16)); 1187 } 1188 1189 /* 1190 * Note: doing an SIOCIGIFFLAGS scribbles on the union portion 1191 * of the ifreq structure, which may confuse other parts of ifconfig. 1192 * Make a private copy so we can avoid that. 1193 */ 1194 static void 1195 setifflags(const char *vname, int value, int s, const struct afswtch *afp) 1196 { 1197 struct ifreq my_ifr; 1198 int flags; 1199 1200 flags = getifflags(name, s); 1201 if (value < 0) { 1202 value = -value; 1203 flags &= ~value; 1204 } else 1205 flags |= value; 1206 memset(&my_ifr, 0, sizeof(my_ifr)); 1207 (void) strlcpy(my_ifr.ifr_name, name, sizeof(my_ifr.ifr_name)); 1208 my_ifr.ifr_flags = flags & 0xffff; 1209 my_ifr.ifr_flagshigh = flags >> 16; 1210 if (ioctl(s, SIOCSIFFLAGS, (caddr_t)&my_ifr) < 0) 1211 Perror(vname); 1212 } 1213 1214 void 1215 setifcap(const char *vname, int value, int s, const struct afswtch *afp) 1216 { 1217 int flags; 1218 1219 if (ioctl(s, SIOCGIFCAP, (caddr_t)&ifr) < 0) { 1220 Perror("ioctl (SIOCGIFCAP)"); 1221 exit(1); 1222 } 1223 flags = ifr.ifr_curcap; 1224 if (value < 0) { 1225 value = -value; 1226 flags &= ~value; 1227 } else 1228 flags |= value; 1229 flags &= ifr.ifr_reqcap; 1230 ifr.ifr_reqcap = flags; 1231 if (ioctl(s, SIOCSIFCAP, (caddr_t)&ifr) < 0) 1232 Perror(vname); 1233 } 1234 1235 static void 1236 setifmetric(const char *val, int dummy __unused, int s, 1237 const struct afswtch *afp) 1238 { 1239 strlcpy(ifr.ifr_name, name, sizeof (ifr.ifr_name)); 1240 ifr.ifr_metric = atoi(val); 1241 if (ioctl(s, SIOCSIFMETRIC, (caddr_t)&ifr) < 0) 1242 err(1, "ioctl SIOCSIFMETRIC (set metric)"); 1243 } 1244 1245 static void 1246 setifmtu(const char *val, int dummy __unused, int s, 1247 const struct afswtch *afp) 1248 { 1249 strlcpy(ifr.ifr_name, name, sizeof (ifr.ifr_name)); 1250 ifr.ifr_mtu = atoi(val); 1251 if (ioctl(s, SIOCSIFMTU, (caddr_t)&ifr) < 0) 1252 err(1, "ioctl SIOCSIFMTU (set mtu)"); 1253 } 1254 1255 static void 1256 setifpcp(const char *val, int arg __unused, int s, const struct afswtch *afp) 1257 { 1258 u_long ul; 1259 char *endp; 1260 1261 ul = strtoul(val, &endp, 0); 1262 if (*endp != '\0') 1263 errx(1, "invalid value for pcp"); 1264 if (ul > 7) 1265 errx(1, "value for pcp out of range"); 1266 ifr.ifr_lan_pcp = ul; 1267 if (ioctl(s, SIOCSLANPCP, (caddr_t)&ifr) == -1) 1268 err(1, "SIOCSLANPCP"); 1269 } 1270 1271 static void 1272 disableifpcp(const char *val, int arg __unused, int s, 1273 const struct afswtch *afp) 1274 { 1275 1276 ifr.ifr_lan_pcp = IFNET_PCP_NONE; 1277 if (ioctl(s, SIOCSLANPCP, (caddr_t)&ifr) == -1) 1278 err(1, "SIOCSLANPCP"); 1279 } 1280 1281 static void 1282 setifname(const char *val, int dummy __unused, int s, 1283 const struct afswtch *afp) 1284 { 1285 char *newname; 1286 1287 strlcpy(ifr.ifr_name, name, sizeof(ifr.ifr_name)); 1288 1289 newname = strdup(val); 1290 if (newname == NULL) 1291 err(1, "no memory to set ifname"); 1292 ifr.ifr_data = newname; 1293 if (ioctl(s, SIOCSIFNAME, (caddr_t)&ifr) < 0) { 1294 free(newname); 1295 err(1, "ioctl SIOCSIFNAME (set name)"); 1296 } 1297 printifname = 1; 1298 strlcpy(name, newname, sizeof(name)); 1299 free(newname); 1300 } 1301 1302 /* ARGSUSED */ 1303 static void 1304 setifdescr(const char *val, int dummy __unused, int s, 1305 const struct afswtch *afp) 1306 { 1307 char *newdescr; 1308 1309 strlcpy(ifr.ifr_name, name, sizeof(ifr.ifr_name)); 1310 1311 ifr.ifr_buffer.length = strlen(val) + 1; 1312 if (ifr.ifr_buffer.length == 1) { 1313 ifr.ifr_buffer.buffer = newdescr = NULL; 1314 ifr.ifr_buffer.length = 0; 1315 } else { 1316 newdescr = strdup(val); 1317 ifr.ifr_buffer.buffer = newdescr; 1318 if (newdescr == NULL) { 1319 warn("no memory to set ifdescr"); 1320 return; 1321 } 1322 } 1323 1324 if (ioctl(s, SIOCSIFDESCR, (caddr_t)&ifr) < 0) 1325 err(1, "ioctl SIOCSIFDESCR (set descr)"); 1326 1327 free(newdescr); 1328 } 1329 1330 /* ARGSUSED */ 1331 static void 1332 unsetifdescr(const char *val, int value, int s, const struct afswtch *afp) 1333 { 1334 1335 setifdescr("", 0, s, 0); 1336 } 1337 1338 #define IFFBITS \ 1339 "\020\1UP\2BROADCAST\3DEBUG\4LOOPBACK\5POINTOPOINT\7RUNNING" \ 1340 "\10NOARP\11PROMISC\12ALLMULTI\13OACTIVE\14SIMPLEX\15LINK0\16LINK1\17LINK2" \ 1341 "\20MULTICAST\22PPROMISC\23MONITOR\24STATICARP" 1342 1343 #define IFCAPBITS \ 1344 "\020\1RXCSUM\2TXCSUM\3NETCONS\4VLAN_MTU\5VLAN_HWTAGGING\6JUMBO_MTU\7POLLING" \ 1345 "\10VLAN_HWCSUM\11TSO4\12TSO6\13LRO\14WOL_UCAST\15WOL_MCAST\16WOL_MAGIC" \ 1346 "\17TOE4\20TOE6\21VLAN_HWFILTER\23VLAN_HWTSO\24LINKSTATE\25NETMAP" \ 1347 "\26RXCSUM_IPV6\27TXCSUM_IPV6\31TXRTLMT\32HWRXTSTMP\33NOMAP\34TXTLS4\35TXTLS6" 1348 1349 /* 1350 * Print the status of the interface. If an address family was 1351 * specified, show only it; otherwise, show them all. 1352 */ 1353 static void 1354 status(const struct afswtch *afp, const struct sockaddr_dl *sdl, 1355 struct ifaddrs *ifa) 1356 { 1357 struct ifaddrs *ift; 1358 int allfamilies, s; 1359 struct ifstat ifs; 1360 1361 if (afp == NULL) { 1362 allfamilies = 1; 1363 ifr.ifr_addr.sa_family = AF_LOCAL; 1364 } else { 1365 allfamilies = 0; 1366 ifr.ifr_addr.sa_family = 1367 afp->af_af == AF_LINK ? AF_LOCAL : afp->af_af; 1368 } 1369 strlcpy(ifr.ifr_name, name, sizeof(ifr.ifr_name)); 1370 1371 s = socket(ifr.ifr_addr.sa_family, SOCK_DGRAM, 0); 1372 if (s < 0) 1373 err(1, "socket(family %u,SOCK_DGRAM)", ifr.ifr_addr.sa_family); 1374 1375 printf("%s: ", name); 1376 printb("flags", ifa->ifa_flags, IFFBITS); 1377 if (ioctl(s, SIOCGIFMETRIC, &ifr) != -1) 1378 printf(" metric %d", ifr.ifr_metric); 1379 if (ioctl(s, SIOCGIFMTU, &ifr) != -1) 1380 printf(" mtu %d", ifr.ifr_mtu); 1381 putchar('\n'); 1382 1383 for (;;) { 1384 if ((descr = reallocf(descr, descrlen)) != NULL) { 1385 ifr.ifr_buffer.buffer = descr; 1386 ifr.ifr_buffer.length = descrlen; 1387 if (ioctl(s, SIOCGIFDESCR, &ifr) == 0) { 1388 if (ifr.ifr_buffer.buffer == descr) { 1389 if (strlen(descr) > 0) 1390 printf("\tdescription: %s\n", 1391 descr); 1392 } else if (ifr.ifr_buffer.length > descrlen) { 1393 descrlen = ifr.ifr_buffer.length; 1394 continue; 1395 } 1396 } 1397 } else 1398 warn("unable to allocate memory for interface" 1399 "description"); 1400 break; 1401 } 1402 1403 if (ioctl(s, SIOCGIFCAP, (caddr_t)&ifr) == 0) { 1404 if (ifr.ifr_curcap != 0) { 1405 printb("\toptions", ifr.ifr_curcap, IFCAPBITS); 1406 putchar('\n'); 1407 } 1408 if (supmedia && ifr.ifr_reqcap != 0) { 1409 printb("\tcapabilities", ifr.ifr_reqcap, IFCAPBITS); 1410 putchar('\n'); 1411 } 1412 } 1413 1414 tunnel_status(s); 1415 1416 for (ift = ifa; ift != NULL; ift = ift->ifa_next) { 1417 if (ift->ifa_addr == NULL) 1418 continue; 1419 if (strcmp(ifa->ifa_name, ift->ifa_name) != 0) 1420 continue; 1421 if (allfamilies) { 1422 const struct afswtch *p; 1423 p = af_getbyfamily(ift->ifa_addr->sa_family); 1424 if (p != NULL && p->af_status != NULL) 1425 p->af_status(s, ift); 1426 } else if (afp->af_af == ift->ifa_addr->sa_family) 1427 afp->af_status(s, ift); 1428 } 1429 #if 0 1430 if (allfamilies || afp->af_af == AF_LINK) { 1431 const struct afswtch *lafp; 1432 1433 /* 1434 * Hack; the link level address is received separately 1435 * from the routing information so any address is not 1436 * handled above. Cobble together an entry and invoke 1437 * the status method specially. 1438 */ 1439 lafp = af_getbyname("lladdr"); 1440 if (lafp != NULL) { 1441 info.rti_info[RTAX_IFA] = (struct sockaddr *)sdl; 1442 lafp->af_status(s, &info); 1443 } 1444 } 1445 #endif 1446 if (allfamilies) 1447 af_other_status(s); 1448 else if (afp->af_other_status != NULL) 1449 afp->af_other_status(s); 1450 1451 strlcpy(ifs.ifs_name, name, sizeof ifs.ifs_name); 1452 if (ioctl(s, SIOCGIFSTATUS, &ifs) == 0) 1453 printf("%s", ifs.ascii); 1454 1455 if (verbose > 0) 1456 sfp_status(s, &ifr, verbose); 1457 1458 close(s); 1459 return; 1460 } 1461 1462 static void 1463 tunnel_status(int s) 1464 { 1465 af_all_tunnel_status(s); 1466 } 1467 1468 void 1469 Perror(const char *cmd) 1470 { 1471 switch (errno) { 1472 1473 case ENXIO: 1474 errx(1, "%s: no such interface", cmd); 1475 break; 1476 1477 case EPERM: 1478 errx(1, "%s: permission denied", cmd); 1479 break; 1480 1481 default: 1482 err(1, "%s", cmd); 1483 } 1484 } 1485 1486 /* 1487 * Print a value a la the %b format of the kernel's printf 1488 */ 1489 void 1490 printb(const char *s, unsigned v, const char *bits) 1491 { 1492 int i, any = 0; 1493 char c; 1494 1495 if (bits && *bits == 8) 1496 printf("%s=%o", s, v); 1497 else 1498 printf("%s=%x", s, v); 1499 if (bits) { 1500 bits++; 1501 putchar('<'); 1502 while ((i = *bits++) != '\0') { 1503 if (v & (1 << (i-1))) { 1504 if (any) 1505 putchar(','); 1506 any = 1; 1507 for (; (c = *bits) > 32; bits++) 1508 putchar(c); 1509 } else 1510 for (; *bits > 32; bits++) 1511 ; 1512 } 1513 putchar('>'); 1514 } 1515 } 1516 1517 void 1518 print_vhid(const struct ifaddrs *ifa, const char *s) 1519 { 1520 struct if_data *ifd; 1521 1522 if (ifa->ifa_data == NULL) 1523 return; 1524 1525 ifd = ifa->ifa_data; 1526 if (ifd->ifi_vhid == 0) 1527 return; 1528 1529 printf(" vhid %d", ifd->ifi_vhid); 1530 } 1531 1532 void 1533 ifmaybeload(const char *name) 1534 { 1535 #define MOD_PREFIX_LEN 3 /* "if_" */ 1536 struct module_stat mstat; 1537 int i, fileid, modid; 1538 char ifkind[IFNAMSIZ + MOD_PREFIX_LEN], ifname[IFNAMSIZ], *dp; 1539 const char *cp; 1540 struct module_map_entry *mme; 1541 bool found; 1542 1543 /* loading suppressed by the user */ 1544 if (noload) 1545 return; 1546 1547 /* trim the interface number off the end */ 1548 strlcpy(ifname, name, sizeof(ifname)); 1549 for (dp = ifname; *dp != 0; dp++) 1550 if (isdigit(*dp)) { 1551 *dp = 0; 1552 break; 1553 } 1554 1555 /* Either derive it from the map or guess otherwise */ 1556 *ifkind = '\0'; 1557 found = false; 1558 for (i = 0; i < nitems(module_map); ++i) { 1559 mme = &module_map[i]; 1560 if (strcmp(mme->ifname, ifname) == 0) { 1561 strlcpy(ifkind, mme->kldname, sizeof(ifkind)); 1562 found = true; 1563 break; 1564 } 1565 } 1566 1567 /* We didn't have an alias for it... we'll guess. */ 1568 if (!found) { 1569 /* turn interface and unit into module name */ 1570 strlcpy(ifkind, "if_", sizeof(ifkind)); 1571 strlcat(ifkind, ifname, sizeof(ifkind)); 1572 } 1573 1574 /* scan files in kernel */ 1575 mstat.version = sizeof(struct module_stat); 1576 for (fileid = kldnext(0); fileid > 0; fileid = kldnext(fileid)) { 1577 /* scan modules in file */ 1578 for (modid = kldfirstmod(fileid); modid > 0; 1579 modid = modfnext(modid)) { 1580 if (modstat(modid, &mstat) < 0) 1581 continue; 1582 /* strip bus name if present */ 1583 if ((cp = strchr(mstat.name, '/')) != NULL) { 1584 cp++; 1585 } else { 1586 cp = mstat.name; 1587 } 1588 /* 1589 * Is it already loaded? Don't compare with ifname if 1590 * we were specifically told which kld to use. Doing 1591 * so could lead to conflicts not trivially solved. 1592 */ 1593 if ((!found && strcmp(ifname, cp) == 0) || 1594 strcmp(ifkind, cp) == 0) 1595 return; 1596 } 1597 } 1598 1599 /* 1600 * Try to load the module. But ignore failures, because ifconfig can't 1601 * infer the names of all drivers (eg mlx4en(4)). 1602 */ 1603 (void) kldload(ifkind); 1604 } 1605 1606 static struct cmd basic_cmds[] = { 1607 DEF_CMD("up", IFF_UP, setifflags), 1608 DEF_CMD("down", -IFF_UP, setifflags), 1609 DEF_CMD("arp", -IFF_NOARP, setifflags), 1610 DEF_CMD("-arp", IFF_NOARP, setifflags), 1611 DEF_CMD("debug", IFF_DEBUG, setifflags), 1612 DEF_CMD("-debug", -IFF_DEBUG, setifflags), 1613 DEF_CMD_ARG("description", setifdescr), 1614 DEF_CMD_ARG("descr", setifdescr), 1615 DEF_CMD("-description", 0, unsetifdescr), 1616 DEF_CMD("-descr", 0, unsetifdescr), 1617 DEF_CMD("promisc", IFF_PPROMISC, setifflags), 1618 DEF_CMD("-promisc", -IFF_PPROMISC, setifflags), 1619 DEF_CMD("add", IFF_UP, notealias), 1620 DEF_CMD("alias", IFF_UP, notealias), 1621 DEF_CMD("-alias", -IFF_UP, notealias), 1622 DEF_CMD("delete", -IFF_UP, notealias), 1623 DEF_CMD("remove", -IFF_UP, notealias), 1624 #ifdef notdef 1625 #define EN_SWABIPS 0x1000 1626 DEF_CMD("swabips", EN_SWABIPS, setifflags), 1627 DEF_CMD("-swabips", -EN_SWABIPS, setifflags), 1628 #endif 1629 DEF_CMD_ARG("netmask", setifnetmask), 1630 DEF_CMD_ARG("metric", setifmetric), 1631 DEF_CMD_ARG("broadcast", setifbroadaddr), 1632 DEF_CMD_ARG2("tunnel", settunnel), 1633 DEF_CMD("-tunnel", 0, deletetunnel), 1634 DEF_CMD("deletetunnel", 0, deletetunnel), 1635 #ifdef JAIL 1636 DEF_CMD_ARG("vnet", setifvnet), 1637 DEF_CMD_ARG("-vnet", setifrvnet), 1638 #endif 1639 DEF_CMD("link0", IFF_LINK0, setifflags), 1640 DEF_CMD("-link0", -IFF_LINK0, setifflags), 1641 DEF_CMD("link1", IFF_LINK1, setifflags), 1642 DEF_CMD("-link1", -IFF_LINK1, setifflags), 1643 DEF_CMD("link2", IFF_LINK2, setifflags), 1644 DEF_CMD("-link2", -IFF_LINK2, setifflags), 1645 DEF_CMD("monitor", IFF_MONITOR, setifflags), 1646 DEF_CMD("-monitor", -IFF_MONITOR, setifflags), 1647 DEF_CMD("nomap", IFCAP_NOMAP, setifcap), 1648 DEF_CMD("-nomap", -IFCAP_NOMAP, setifcap), 1649 DEF_CMD("staticarp", IFF_STATICARP, setifflags), 1650 DEF_CMD("-staticarp", -IFF_STATICARP, setifflags), 1651 DEF_CMD("rxcsum6", IFCAP_RXCSUM_IPV6, setifcap), 1652 DEF_CMD("-rxcsum6", -IFCAP_RXCSUM_IPV6, setifcap), 1653 DEF_CMD("txcsum6", IFCAP_TXCSUM_IPV6, setifcap), 1654 DEF_CMD("-txcsum6", -IFCAP_TXCSUM_IPV6, setifcap), 1655 DEF_CMD("rxcsum", IFCAP_RXCSUM, setifcap), 1656 DEF_CMD("-rxcsum", -IFCAP_RXCSUM, setifcap), 1657 DEF_CMD("txcsum", IFCAP_TXCSUM, setifcap), 1658 DEF_CMD("-txcsum", -IFCAP_TXCSUM, setifcap), 1659 DEF_CMD("netcons", IFCAP_NETCONS, setifcap), 1660 DEF_CMD("-netcons", -IFCAP_NETCONS, setifcap), 1661 DEF_CMD_ARG("pcp", setifpcp), 1662 DEF_CMD("-pcp", 0, disableifpcp), 1663 DEF_CMD("polling", IFCAP_POLLING, setifcap), 1664 DEF_CMD("-polling", -IFCAP_POLLING, setifcap), 1665 DEF_CMD("tso6", IFCAP_TSO6, setifcap), 1666 DEF_CMD("-tso6", -IFCAP_TSO6, setifcap), 1667 DEF_CMD("tso4", IFCAP_TSO4, setifcap), 1668 DEF_CMD("-tso4", -IFCAP_TSO4, setifcap), 1669 DEF_CMD("tso", IFCAP_TSO, setifcap), 1670 DEF_CMD("-tso", -IFCAP_TSO, setifcap), 1671 DEF_CMD("toe", IFCAP_TOE, setifcap), 1672 DEF_CMD("-toe", -IFCAP_TOE, setifcap), 1673 DEF_CMD("lro", IFCAP_LRO, setifcap), 1674 DEF_CMD("-lro", -IFCAP_LRO, setifcap), 1675 DEF_CMD("txtls", IFCAP_TXTLS, setifcap), 1676 DEF_CMD("-txtls", -IFCAP_TXTLS, setifcap), 1677 DEF_CMD("wol", IFCAP_WOL, setifcap), 1678 DEF_CMD("-wol", -IFCAP_WOL, setifcap), 1679 DEF_CMD("wol_ucast", IFCAP_WOL_UCAST, setifcap), 1680 DEF_CMD("-wol_ucast", -IFCAP_WOL_UCAST, setifcap), 1681 DEF_CMD("wol_mcast", IFCAP_WOL_MCAST, setifcap), 1682 DEF_CMD("-wol_mcast", -IFCAP_WOL_MCAST, setifcap), 1683 DEF_CMD("wol_magic", IFCAP_WOL_MAGIC, setifcap), 1684 DEF_CMD("-wol_magic", -IFCAP_WOL_MAGIC, setifcap), 1685 DEF_CMD("txrtlmt", IFCAP_TXRTLMT, setifcap), 1686 DEF_CMD("-txrtlmt", -IFCAP_TXRTLMT, setifcap), 1687 DEF_CMD("hwrxtstmp", IFCAP_HWRXTSTMP, setifcap), 1688 DEF_CMD("-hwrxtstmp", -IFCAP_HWRXTSTMP, setifcap), 1689 DEF_CMD("normal", -IFF_LINK0, setifflags), 1690 DEF_CMD("compress", IFF_LINK0, setifflags), 1691 DEF_CMD("noicmp", IFF_LINK1, setifflags), 1692 DEF_CMD_ARG("mtu", setifmtu), 1693 DEF_CMD_ARG("name", setifname), 1694 }; 1695 1696 static __constructor void 1697 ifconfig_ctor(void) 1698 { 1699 size_t i; 1700 1701 for (i = 0; i < nitems(basic_cmds); i++) 1702 cmd_register(&basic_cmds[i]); 1703 } 1704