ifconfig.c revision 194799
1/* 2 * Copyright (c) 1983, 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 * 4. Neither the name of the University nor the names of its contributors 14 * may be used to endorse or promote products derived from this software 15 * without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30#ifndef lint 31static const char copyright[] = 32"@(#) Copyright (c) 1983, 1993\n\ 33 The Regents of the University of California. All rights reserved.\n"; 34#endif /* not lint */ 35 36#ifndef lint 37#if 0 38static char sccsid[] = "@(#)ifconfig.c 8.2 (Berkeley) 2/16/94"; 39#endif 40static const char rcsid[] = 41 "$FreeBSD: head/sbin/ifconfig/ifconfig.c 194799 2009-06-23 23:49:52Z delphij $"; 42#endif /* not lint */ 43 44#include <sys/param.h> 45#include <sys/ioctl.h> 46#include <sys/socket.h> 47#include <sys/sysctl.h> 48#include <sys/time.h> 49#include <sys/module.h> 50#include <sys/linker.h> 51 52#include <net/ethernet.h> 53#include <net/if.h> 54#include <net/if_var.h> 55#include <net/if_dl.h> 56#include <net/if_types.h> 57#include <net/route.h> 58 59/* IP */ 60#include <netinet/in.h> 61#include <netinet/in_var.h> 62#include <arpa/inet.h> 63#include <netdb.h> 64 65#include <ifaddrs.h> 66#include <ctype.h> 67#include <err.h> 68#include <errno.h> 69#include <fcntl.h> 70#include <stdio.h> 71#include <stdlib.h> 72#include <string.h> 73#include <unistd.h> 74 75#include "ifconfig.h" 76 77/* 78 * Since "struct ifreq" is composed of various union members, callers 79 * should pay special attention to interprete the value. 80 * (.e.g. little/big endian difference in the structure.) 81 */ 82struct ifreq ifr; 83 84char name[IFNAMSIZ]; 85int setaddr; 86int setmask; 87int doalias; 88int clearaddr; 89int newaddr = 1; 90int verbose; 91int noload; 92 93int supmedia = 0; 94int printkeys = 0; /* Print keying material for interfaces. */ 95 96static int ifconfig(int argc, char *const *argv, int iscreate, 97 const struct afswtch *afp); 98static void status(const struct afswtch *afp, const struct sockaddr_dl *sdl, 99 struct ifaddrs *ifa); 100static void tunnel_status(int s); 101static void usage(void); 102 103static struct afswtch *af_getbyname(const char *name); 104static struct afswtch *af_getbyfamily(int af); 105static void af_other_status(int); 106 107static struct option *opts = NULL; 108 109void 110opt_register(struct option *p) 111{ 112 p->next = opts; 113 opts = p; 114} 115 116static void 117usage(void) 118{ 119 char options[1024]; 120 struct option *p; 121 122 /* XXX not right but close enough for now */ 123 options[0] = '\0'; 124 for (p = opts; p != NULL; p = p->next) { 125 strlcat(options, p->opt_usage, sizeof(options)); 126 strlcat(options, " ", sizeof(options)); 127 } 128 129 fprintf(stderr, 130 "usage: ifconfig %sinterface address_family [address [dest_address]]\n" 131 " [parameters]\n" 132 " ifconfig interface create\n" 133 " ifconfig -a %s[-d] [-m] [-u] [-v] [address_family]\n" 134 " ifconfig -l [-d] [-u] [address_family]\n" 135 " ifconfig %s[-d] [-m] [-u] [-v]\n", 136 options, options, options); 137 exit(1); 138} 139 140int 141main(int argc, char *argv[]) 142{ 143 int c, all, namesonly, downonly, uponly; 144 const struct afswtch *afp = NULL; 145 int ifindex; 146 struct ifaddrs *ifap, *ifa; 147 struct ifreq paifr; 148 const struct sockaddr_dl *sdl; 149 char options[1024], *cp; 150 const char *ifname; 151 struct option *p; 152 size_t iflen; 153 154 all = downonly = uponly = namesonly = noload = verbose = 0; 155 156 /* Parse leading line options */ 157 strlcpy(options, "adklmnuv", sizeof(options)); 158 for (p = opts; p != NULL; p = p->next) 159 strlcat(options, p->opt, sizeof(options)); 160 while ((c = getopt(argc, argv, options)) != -1) { 161 switch (c) { 162 case 'a': /* scan all interfaces */ 163 all++; 164 break; 165 case 'd': /* restrict scan to "down" interfaces */ 166 downonly++; 167 break; 168 case 'k': 169 printkeys++; 170 break; 171 case 'l': /* scan interface names only */ 172 namesonly++; 173 break; 174 case 'm': /* show media choices in status */ 175 supmedia = 1; 176 break; 177 case 'n': /* suppress module loading */ 178 noload++; 179 break; 180 case 'u': /* restrict scan to "up" interfaces */ 181 uponly++; 182 break; 183 case 'v': 184 verbose++; 185 break; 186 default: 187 for (p = opts; p != NULL; p = p->next) 188 if (p->opt[0] == c) { 189 p->cb(optarg); 190 break; 191 } 192 if (p == NULL) 193 usage(); 194 break; 195 } 196 } 197 argc -= optind; 198 argv += optind; 199 200 /* -l cannot be used with -a or -m */ 201 if (namesonly && (all || supmedia)) 202 usage(); 203 204 /* nonsense.. */ 205 if (uponly && downonly) 206 usage(); 207 208 /* no arguments is equivalent to '-a' */ 209 if (!namesonly && argc < 1) 210 all = 1; 211 212 /* -a and -l allow an address family arg to limit the output */ 213 if (all || namesonly) { 214 if (argc > 1) 215 usage(); 216 217 ifname = NULL; 218 ifindex = 0; 219 if (argc == 1) { 220 afp = af_getbyname(*argv); 221 if (afp == NULL) 222 usage(); 223 if (afp->af_name != NULL) 224 argc--, argv++; 225 /* leave with afp non-zero */ 226 } 227 } else { 228 /* not listing, need an argument */ 229 if (argc < 1) 230 usage(); 231 232 ifname = *argv; 233 argc--, argv++; 234 235 /* check and maybe load support for this interface */ 236 ifmaybeload(ifname); 237 238 ifindex = if_nametoindex(ifname); 239 if (ifindex == 0) { 240 /* 241 * NOTE: We must special-case the `create' command 242 * right here as we would otherwise fail when trying 243 * to find the interface. 244 */ 245 if (argc > 0 && (strcmp(argv[0], "create") == 0 || 246 strcmp(argv[0], "plumb") == 0)) { 247 iflen = strlcpy(name, ifname, sizeof(name)); 248 if (iflen >= sizeof(name)) 249 errx(1, "%s: cloning name too long", 250 ifname); 251 ifconfig(argc, argv, 1, NULL); 252 exit(0); 253 } 254 errx(1, "interface %s does not exist", ifname); 255 } 256 } 257 258 /* Check for address family */ 259 if (argc > 0) { 260 afp = af_getbyname(*argv); 261 if (afp != NULL) 262 argc--, argv++; 263 } 264 265 if (getifaddrs(&ifap) != 0) 266 err(EXIT_FAILURE, "getifaddrs"); 267 cp = NULL; 268 ifindex = 0; 269 for (ifa = ifap; ifa; ifa = ifa->ifa_next) { 270 memset(&paifr, 0, sizeof(paifr)); 271 strncpy(paifr.ifr_name, ifa->ifa_name, sizeof(paifr.ifr_name)); 272 if (sizeof(paifr.ifr_addr) >= ifa->ifa_addr->sa_len) { 273 memcpy(&paifr.ifr_addr, ifa->ifa_addr, 274 ifa->ifa_addr->sa_len); 275 } 276 277 if (ifname != NULL && strcmp(ifname, ifa->ifa_name) != 0) 278 continue; 279 if (ifa->ifa_addr->sa_family == AF_LINK) 280 sdl = (const struct sockaddr_dl *) ifa->ifa_addr; 281 else 282 sdl = NULL; 283 if (cp != NULL && strcmp(cp, ifa->ifa_name) == 0) 284 continue; 285 iflen = strlcpy(name, ifa->ifa_name, sizeof(name)); 286 if (iflen >= sizeof(name)) { 287 warnx("%s: interface name too long, skipping", 288 ifa->ifa_name); 289 continue; 290 } 291 cp = ifa->ifa_name; 292 293 if (downonly && (ifa->ifa_flags & IFF_UP) != 0) 294 continue; 295 if (uponly && (ifa->ifa_flags & IFF_UP) == 0) 296 continue; 297 ifindex++; 298 /* 299 * Are we just listing the interfaces? 300 */ 301 if (namesonly) { 302 if (ifindex > 1) 303 printf(" "); 304 fputs(name, stdout); 305 continue; 306 } 307 308 if (argc > 0) 309 ifconfig(argc, argv, 0, afp); 310 else 311 status(afp, sdl, ifa); 312 } 313 if (namesonly) 314 printf("\n"); 315 freeifaddrs(ifap); 316 317 exit(0); 318} 319 320static struct afswtch *afs = NULL; 321 322void 323af_register(struct afswtch *p) 324{ 325 p->af_next = afs; 326 afs = p; 327} 328 329static struct afswtch * 330af_getbyname(const char *name) 331{ 332 struct afswtch *afp; 333 334 for (afp = afs; afp != NULL; afp = afp->af_next) 335 if (strcmp(afp->af_name, name) == 0) 336 return afp; 337 return NULL; 338} 339 340static struct afswtch * 341af_getbyfamily(int af) 342{ 343 struct afswtch *afp; 344 345 for (afp = afs; afp != NULL; afp = afp->af_next) 346 if (afp->af_af == af) 347 return afp; 348 return NULL; 349} 350 351static void 352af_other_status(int s) 353{ 354 struct afswtch *afp; 355 uint8_t afmask[howmany(AF_MAX, NBBY)]; 356 357 memset(afmask, 0, sizeof(afmask)); 358 for (afp = afs; afp != NULL; afp = afp->af_next) { 359 if (afp->af_other_status == NULL) 360 continue; 361 if (afp->af_af != AF_UNSPEC && isset(afmask, afp->af_af)) 362 continue; 363 afp->af_other_status(s); 364 setbit(afmask, afp->af_af); 365 } 366} 367 368static void 369af_all_tunnel_status(int s) 370{ 371 struct afswtch *afp; 372 uint8_t afmask[howmany(AF_MAX, NBBY)]; 373 374 memset(afmask, 0, sizeof(afmask)); 375 for (afp = afs; afp != NULL; afp = afp->af_next) { 376 if (afp->af_status_tunnel == NULL) 377 continue; 378 if (afp->af_af != AF_UNSPEC && isset(afmask, afp->af_af)) 379 continue; 380 afp->af_status_tunnel(s); 381 setbit(afmask, afp->af_af); 382 } 383} 384 385static struct cmd *cmds = NULL; 386 387void 388cmd_register(struct cmd *p) 389{ 390 p->c_next = cmds; 391 cmds = p; 392} 393 394static const struct cmd * 395cmd_lookup(const char *name, int iscreate) 396{ 397#define N(a) (sizeof(a)/sizeof(a[0])) 398 const struct cmd *p; 399 400 for (p = cmds; p != NULL; p = p->c_next) 401 if (strcmp(name, p->c_name) == 0) { 402 if (iscreate) { 403 if (p->c_iscloneop) 404 return p; 405 } else { 406 if (!p->c_iscloneop) 407 return p; 408 } 409 } 410 return NULL; 411#undef N 412} 413 414struct callback { 415 callback_func *cb_func; 416 void *cb_arg; 417 struct callback *cb_next; 418}; 419static struct callback *callbacks = NULL; 420 421void 422callback_register(callback_func *func, void *arg) 423{ 424 struct callback *cb; 425 426 cb = malloc(sizeof(struct callback)); 427 if (cb == NULL) 428 errx(1, "unable to allocate memory for callback"); 429 cb->cb_func = func; 430 cb->cb_arg = arg; 431 cb->cb_next = callbacks; 432 callbacks = cb; 433} 434 435/* specially-handled commands */ 436static void setifaddr(const char *, int, int, const struct afswtch *); 437static const struct cmd setifaddr_cmd = DEF_CMD("ifaddr", 0, setifaddr); 438 439static void setifdstaddr(const char *, int, int, const struct afswtch *); 440static const struct cmd setifdstaddr_cmd = 441 DEF_CMD("ifdstaddr", 0, setifdstaddr); 442 443static int 444ifconfig(int argc, char *const *argv, int iscreate, const struct afswtch *uafp) 445{ 446 const struct afswtch *afp, *nafp; 447 const struct cmd *p; 448 struct callback *cb; 449 int s; 450 451 strncpy(ifr.ifr_name, name, sizeof ifr.ifr_name); 452 afp = uafp != NULL ? uafp : af_getbyname("inet"); 453top: 454 ifr.ifr_addr.sa_family = 455 afp->af_af == AF_LINK || afp->af_af == AF_UNSPEC ? 456 AF_LOCAL : afp->af_af; 457 458 if ((s = socket(ifr.ifr_addr.sa_family, SOCK_DGRAM, 0)) < 0 && 459 (uafp != NULL || errno != EPROTONOSUPPORT || 460 (s = socket(AF_LOCAL, SOCK_DGRAM, 0)) < 0)) 461 err(1, "socket(family %u,SOCK_DGRAM", ifr.ifr_addr.sa_family); 462 463 while (argc > 0) { 464 p = cmd_lookup(*argv, iscreate); 465 if (iscreate && p == NULL) { 466 /* 467 * Push the clone create callback so the new 468 * device is created and can be used for any 469 * remaining arguments. 470 */ 471 cb = callbacks; 472 if (cb == NULL) 473 errx(1, "internal error, no callback"); 474 callbacks = cb->cb_next; 475 cb->cb_func(s, cb->cb_arg); 476 iscreate = 0; 477 /* 478 * Handle any address family spec that 479 * immediately follows and potentially 480 * recreate the socket. 481 */ 482 nafp = af_getbyname(*argv); 483 if (nafp != NULL) { 484 argc--, argv++; 485 if (nafp != afp) { 486 close(s); 487 afp = nafp; 488 goto top; 489 } 490 } 491 /* 492 * Look for a normal parameter. 493 */ 494 continue; 495 } 496 if (p == NULL) { 497 /* 498 * Not a recognized command, choose between setting 499 * the interface address and the dst address. 500 */ 501 p = (setaddr ? &setifdstaddr_cmd : &setifaddr_cmd); 502 } 503 if (p->c_u.c_func || p->c_u.c_func2) { 504 if (p->c_parameter == NEXTARG) { 505 if (argv[1] == NULL) 506 errx(1, "'%s' requires argument", 507 p->c_name); 508 p->c_u.c_func(argv[1], 0, s, afp); 509 argc--, argv++; 510 } else if (p->c_parameter == OPTARG) { 511 p->c_u.c_func(argv[1], 0, s, afp); 512 if (argv[1] != NULL) 513 argc--, argv++; 514 } else if (p->c_parameter == NEXTARG2) { 515 if (argc < 3) 516 errx(1, "'%s' requires 2 arguments", 517 p->c_name); 518 p->c_u.c_func2(argv[1], argv[2], s, afp); 519 argc -= 2, argv += 2; 520 } else 521 p->c_u.c_func(*argv, p->c_parameter, s, afp); 522 } 523 argc--, argv++; 524 } 525 526 /* 527 * Do any post argument processing required by the address family. 528 */ 529 if (afp->af_postproc != NULL) 530 afp->af_postproc(s, afp); 531 /* 532 * Do deferred callbacks registered while processing 533 * command-line arguments. 534 */ 535 for (cb = callbacks; cb != NULL; cb = cb->cb_next) 536 cb->cb_func(s, cb->cb_arg); 537 /* 538 * Do deferred operations. 539 */ 540 if (clearaddr) { 541 if (afp->af_ridreq == NULL || afp->af_difaddr == 0) { 542 warnx("interface %s cannot change %s addresses!", 543 name, afp->af_name); 544 clearaddr = 0; 545 } 546 } 547 if (clearaddr) { 548 int ret; 549 strncpy(afp->af_ridreq, name, sizeof ifr.ifr_name); 550 ret = ioctl(s, afp->af_difaddr, afp->af_ridreq); 551 if (ret < 0) { 552 if (errno == EADDRNOTAVAIL && (doalias >= 0)) { 553 /* means no previous address for interface */ 554 } else 555 Perror("ioctl (SIOCDIFADDR)"); 556 } 557 } 558 if (newaddr) { 559 if (afp->af_addreq == NULL || afp->af_aifaddr == 0) { 560 warnx("interface %s cannot change %s addresses!", 561 name, afp->af_name); 562 newaddr = 0; 563 } 564 } 565 if (newaddr && (setaddr || setmask)) { 566 strncpy(afp->af_addreq, name, sizeof ifr.ifr_name); 567 if (ioctl(s, afp->af_aifaddr, afp->af_addreq) < 0) 568 Perror("ioctl (SIOCAIFADDR)"); 569 } 570 571 close(s); 572 return(0); 573} 574 575/*ARGSUSED*/ 576static void 577setifaddr(const char *addr, int param, int s, const struct afswtch *afp) 578{ 579 if (afp->af_getaddr == NULL) 580 return; 581 /* 582 * Delay the ioctl to set the interface addr until flags are all set. 583 * The address interpretation may depend on the flags, 584 * and the flags may change when the address is set. 585 */ 586 setaddr++; 587 if (doalias == 0 && afp->af_af != AF_LINK) 588 clearaddr = 1; 589 afp->af_getaddr(addr, (doalias >= 0 ? ADDR : RIDADDR)); 590} 591 592static void 593settunnel(const char *src, const char *dst, int s, const struct afswtch *afp) 594{ 595 struct addrinfo *srcres, *dstres; 596 int ecode; 597 598 if (afp->af_settunnel == NULL) { 599 warn("address family %s does not support tunnel setup", 600 afp->af_name); 601 return; 602 } 603 604 if ((ecode = getaddrinfo(src, NULL, NULL, &srcres)) != 0) 605 errx(1, "error in parsing address string: %s", 606 gai_strerror(ecode)); 607 608 if ((ecode = getaddrinfo(dst, NULL, NULL, &dstres)) != 0) 609 errx(1, "error in parsing address string: %s", 610 gai_strerror(ecode)); 611 612 if (srcres->ai_addr->sa_family != dstres->ai_addr->sa_family) 613 errx(1, 614 "source and destination address families do not match"); 615 616 afp->af_settunnel(s, srcres, dstres); 617 618 freeaddrinfo(srcres); 619 freeaddrinfo(dstres); 620} 621 622/* ARGSUSED */ 623static void 624deletetunnel(const char *vname, int param, int s, const struct afswtch *afp) 625{ 626 627 if (ioctl(s, SIOCDIFPHYADDR, &ifr) < 0) 628 err(1, "SIOCDIFPHYADDR"); 629} 630 631static void 632setifnetmask(const char *addr, int dummy __unused, int s, 633 const struct afswtch *afp) 634{ 635 if (afp->af_getaddr != NULL) { 636 setmask++; 637 afp->af_getaddr(addr, MASK); 638 } 639} 640 641static void 642setifbroadaddr(const char *addr, int dummy __unused, int s, 643 const struct afswtch *afp) 644{ 645 if (afp->af_getaddr != NULL) 646 afp->af_getaddr(addr, DSTADDR); 647} 648 649static void 650setifipdst(const char *addr, int dummy __unused, int s, 651 const struct afswtch *afp) 652{ 653 const struct afswtch *inet; 654 655 inet = af_getbyname("inet"); 656 if (inet == NULL) 657 return; 658 inet->af_getaddr(addr, DSTADDR); 659 clearaddr = 0; 660 newaddr = 0; 661} 662 663static void 664notealias(const char *addr, int param, int s, const struct afswtch *afp) 665{ 666#define rqtosa(x) (&(((struct ifreq *)(afp->x))->ifr_addr)) 667 if (setaddr && doalias == 0 && param < 0) 668 if (afp->af_addreq != NULL && afp->af_ridreq != NULL) 669 bcopy((caddr_t)rqtosa(af_addreq), 670 (caddr_t)rqtosa(af_ridreq), 671 rqtosa(af_addreq)->sa_len); 672 doalias = param; 673 if (param < 0) { 674 clearaddr = 1; 675 newaddr = 0; 676 } else 677 clearaddr = 0; 678#undef rqtosa 679} 680 681/*ARGSUSED*/ 682static void 683setifdstaddr(const char *addr, int param __unused, int s, 684 const struct afswtch *afp) 685{ 686 if (afp->af_getaddr != NULL) 687 afp->af_getaddr(addr, DSTADDR); 688} 689 690/* 691 * Note: doing an SIOCIGIFFLAGS scribbles on the union portion 692 * of the ifreq structure, which may confuse other parts of ifconfig. 693 * Make a private copy so we can avoid that. 694 */ 695static void 696setifflags(const char *vname, int value, int s, const struct afswtch *afp) 697{ 698 struct ifreq my_ifr; 699 int flags; 700 701 memset(&my_ifr, 0, sizeof(my_ifr)); 702 (void) strlcpy(my_ifr.ifr_name, name, sizeof(my_ifr.ifr_name)); 703 704 if (ioctl(s, SIOCGIFFLAGS, (caddr_t)&my_ifr) < 0) { 705 Perror("ioctl (SIOCGIFFLAGS)"); 706 exit(1); 707 } 708 flags = (my_ifr.ifr_flags & 0xffff) | (my_ifr.ifr_flagshigh << 16); 709 710 if (value < 0) { 711 value = -value; 712 flags &= ~value; 713 } else 714 flags |= value; 715 my_ifr.ifr_flags = flags & 0xffff; 716 my_ifr.ifr_flagshigh = flags >> 16; 717 if (ioctl(s, SIOCSIFFLAGS, (caddr_t)&my_ifr) < 0) 718 Perror(vname); 719} 720 721void 722setifcap(const char *vname, int value, int s, const struct afswtch *afp) 723{ 724 int flags; 725 726 if (ioctl(s, SIOCGIFCAP, (caddr_t)&ifr) < 0) { 727 Perror("ioctl (SIOCGIFCAP)"); 728 exit(1); 729 } 730 flags = ifr.ifr_curcap; 731 if (value < 0) { 732 value = -value; 733 flags &= ~value; 734 } else 735 flags |= value; 736 flags &= ifr.ifr_reqcap; 737 ifr.ifr_reqcap = flags; 738 if (ioctl(s, SIOCSIFCAP, (caddr_t)&ifr) < 0) 739 Perror(vname); 740} 741 742static void 743setifmetric(const char *val, int dummy __unused, int s, 744 const struct afswtch *afp) 745{ 746 strncpy(ifr.ifr_name, name, sizeof (ifr.ifr_name)); 747 ifr.ifr_metric = atoi(val); 748 if (ioctl(s, SIOCSIFMETRIC, (caddr_t)&ifr) < 0) 749 warn("ioctl (set metric)"); 750} 751 752static void 753setifmtu(const char *val, int dummy __unused, int s, 754 const struct afswtch *afp) 755{ 756 strncpy(ifr.ifr_name, name, sizeof (ifr.ifr_name)); 757 ifr.ifr_mtu = atoi(val); 758 if (ioctl(s, SIOCSIFMTU, (caddr_t)&ifr) < 0) 759 warn("ioctl (set mtu)"); 760} 761 762static void 763setifname(const char *val, int dummy __unused, int s, 764 const struct afswtch *afp) 765{ 766 char *newname; 767 768 newname = strdup(val); 769 if (newname == NULL) { 770 warn("no memory to set ifname"); 771 return; 772 } 773 ifr.ifr_data = newname; 774 if (ioctl(s, SIOCSIFNAME, (caddr_t)&ifr) < 0) { 775 warn("ioctl (set name)"); 776 free(newname); 777 return; 778 } 779 strlcpy(name, newname, sizeof(name)); 780 free(newname); 781} 782 783#define IFFBITS \ 784"\020\1UP\2BROADCAST\3DEBUG\4LOOPBACK\5POINTOPOINT\6SMART\7RUNNING" \ 785"\10NOARP\11PROMISC\12ALLMULTI\13OACTIVE\14SIMPLEX\15LINK0\16LINK1\17LINK2" \ 786"\20MULTICAST\22PPROMISC\23MONITOR\24STATICARP" 787 788#define IFCAPBITS \ 789"\020\1RXCSUM\2TXCSUM\3NETCONS\4VLAN_MTU\5VLAN_HWTAGGING\6JUMBO_MTU\7POLLING" \ 790"\10VLAN_HWCSUM\11TSO4\12TSO6\13LRO\14WOL_UCAST\15WOL_MCAST\16WOL_MAGIC" \ 791"\21VLAN_HWFILTER" 792 793/* 794 * Print the status of the interface. If an address family was 795 * specified, show only it; otherwise, show them all. 796 */ 797static void 798status(const struct afswtch *afp, const struct sockaddr_dl *sdl, 799 struct ifaddrs *ifa) 800{ 801 struct ifaddrs *ift; 802 int allfamilies, s; 803 struct ifstat ifs; 804 805 if (afp == NULL) { 806 allfamilies = 1; 807 ifr.ifr_addr.sa_family = AF_LOCAL; 808 } else { 809 allfamilies = 0; 810 ifr.ifr_addr.sa_family = 811 afp->af_af == AF_LINK ? AF_LOCAL : afp->af_af; 812 } 813 strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name)); 814 815 s = socket(ifr.ifr_addr.sa_family, SOCK_DGRAM, 0); 816 if (s < 0) 817 err(1, "socket(family %u,SOCK_DGRAM)", ifr.ifr_addr.sa_family); 818 819 printf("%s: ", name); 820 printb("flags", ifa->ifa_flags, IFFBITS); 821 if (ioctl(s, SIOCGIFMETRIC, &ifr) != -1) 822 printf(" metric %d", ifr.ifr_metric); 823 if (ioctl(s, SIOCGIFMTU, &ifr) != -1) 824 printf(" mtu %d", ifr.ifr_mtu); 825 putchar('\n'); 826 827 if (ioctl(s, SIOCGIFCAP, (caddr_t)&ifr) == 0) { 828 if (ifr.ifr_curcap != 0) { 829 printb("\toptions", ifr.ifr_curcap, IFCAPBITS); 830 putchar('\n'); 831 } 832 if (supmedia && ifr.ifr_reqcap != 0) { 833 printb("\tcapabilities", ifr.ifr_reqcap, IFCAPBITS); 834 putchar('\n'); 835 } 836 } 837 838 tunnel_status(s); 839 840 for (ift = ifa; ift != NULL; ift = ift->ifa_next) { 841 if (ift->ifa_addr == NULL) 842 continue; 843 if (strcmp(ifa->ifa_name, ift->ifa_name) != 0) 844 continue; 845 if (allfamilies) { 846 const struct afswtch *p; 847 p = af_getbyfamily(ift->ifa_addr->sa_family); 848 if (p != NULL && p->af_status != NULL) 849 p->af_status(s, ift); 850 } else if (afp->af_af == ift->ifa_addr->sa_family) 851 afp->af_status(s, ift); 852 } 853#if 0 854 if (allfamilies || afp->af_af == AF_LINK) { 855 const struct afswtch *lafp; 856 857 /* 858 * Hack; the link level address is received separately 859 * from the routing information so any address is not 860 * handled above. Cobble together an entry and invoke 861 * the status method specially. 862 */ 863 lafp = af_getbyname("lladdr"); 864 if (lafp != NULL) { 865 info.rti_info[RTAX_IFA] = (struct sockaddr *)sdl; 866 lafp->af_status(s, &info); 867 } 868 } 869#endif 870 if (allfamilies) 871 af_other_status(s); 872 else if (afp->af_other_status != NULL) 873 afp->af_other_status(s); 874 875 strncpy(ifs.ifs_name, name, sizeof ifs.ifs_name); 876 if (ioctl(s, SIOCGIFSTATUS, &ifs) == 0) 877 printf("%s", ifs.ascii); 878 879 close(s); 880 return; 881} 882 883static void 884tunnel_status(int s) 885{ 886 af_all_tunnel_status(s); 887} 888 889void 890Perror(const char *cmd) 891{ 892 switch (errno) { 893 894 case ENXIO: 895 errx(1, "%s: no such interface", cmd); 896 break; 897 898 case EPERM: 899 errx(1, "%s: permission denied", cmd); 900 break; 901 902 default: 903 err(1, "%s", cmd); 904 } 905} 906 907/* 908 * Print a value a la the %b format of the kernel's printf 909 */ 910void 911printb(const char *s, unsigned v, const char *bits) 912{ 913 int i, any = 0; 914 char c; 915 916 if (bits && *bits == 8) 917 printf("%s=%o", s, v); 918 else 919 printf("%s=%x", s, v); 920 bits++; 921 if (bits) { 922 putchar('<'); 923 while ((i = *bits++) != '\0') { 924 if (v & (1 << (i-1))) { 925 if (any) 926 putchar(','); 927 any = 1; 928 for (; (c = *bits) > 32; bits++) 929 putchar(c); 930 } else 931 for (; *bits > 32; bits++) 932 ; 933 } 934 putchar('>'); 935 } 936} 937 938void 939ifmaybeload(const char *name) 940{ 941#define MOD_PREFIX_LEN 3 /* "if_" */ 942 struct module_stat mstat; 943 int fileid, modid; 944 char ifkind[IFNAMSIZ + MOD_PREFIX_LEN], ifname[IFNAMSIZ], *dp; 945 const char *cp; 946 947 /* loading suppressed by the user */ 948 if (noload) 949 return; 950 951 /* trim the interface number off the end */ 952 strlcpy(ifname, name, sizeof(ifname)); 953 for (dp = ifname; *dp != 0; dp++) 954 if (isdigit(*dp)) { 955 *dp = 0; 956 break; 957 } 958 959 /* turn interface and unit into module name */ 960 strcpy(ifkind, "if_"); 961 strlcpy(ifkind + MOD_PREFIX_LEN, ifname, 962 sizeof(ifkind) - MOD_PREFIX_LEN); 963 964 /* scan files in kernel */ 965 mstat.version = sizeof(struct module_stat); 966 for (fileid = kldnext(0); fileid > 0; fileid = kldnext(fileid)) { 967 /* scan modules in file */ 968 for (modid = kldfirstmod(fileid); modid > 0; 969 modid = modfnext(modid)) { 970 if (modstat(modid, &mstat) < 0) 971 continue; 972 /* strip bus name if present */ 973 if ((cp = strchr(mstat.name, '/')) != NULL) { 974 cp++; 975 } else { 976 cp = mstat.name; 977 } 978 /* already loaded? */ 979 if (strncmp(ifname, cp, strlen(ifname) + 1) == 0 || 980 strncmp(ifkind, cp, strlen(ifkind) + 1) == 0) 981 return; 982 } 983 } 984 985 /* not present, we should try to load it */ 986 kldload(ifkind); 987} 988 989static struct cmd basic_cmds[] = { 990 DEF_CMD("up", IFF_UP, setifflags), 991 DEF_CMD("down", -IFF_UP, setifflags), 992 DEF_CMD("arp", -IFF_NOARP, setifflags), 993 DEF_CMD("-arp", IFF_NOARP, setifflags), 994 DEF_CMD("debug", IFF_DEBUG, setifflags), 995 DEF_CMD("-debug", -IFF_DEBUG, setifflags), 996 DEF_CMD("promisc", IFF_PPROMISC, setifflags), 997 DEF_CMD("-promisc", -IFF_PPROMISC, setifflags), 998 DEF_CMD("add", IFF_UP, notealias), 999 DEF_CMD("alias", IFF_UP, notealias), 1000 DEF_CMD("-alias", -IFF_UP, notealias), 1001 DEF_CMD("delete", -IFF_UP, notealias), 1002 DEF_CMD("remove", -IFF_UP, notealias), 1003#ifdef notdef 1004#define EN_SWABIPS 0x1000 1005 DEF_CMD("swabips", EN_SWABIPS, setifflags), 1006 DEF_CMD("-swabips", -EN_SWABIPS, setifflags), 1007#endif 1008 DEF_CMD_ARG("netmask", setifnetmask), 1009 DEF_CMD_ARG("metric", setifmetric), 1010 DEF_CMD_ARG("broadcast", setifbroadaddr), 1011 DEF_CMD_ARG("ipdst", setifipdst), 1012 DEF_CMD_ARG2("tunnel", settunnel), 1013 DEF_CMD("-tunnel", 0, deletetunnel), 1014 DEF_CMD("deletetunnel", 0, deletetunnel), 1015 DEF_CMD("link0", IFF_LINK0, setifflags), 1016 DEF_CMD("-link0", -IFF_LINK0, setifflags), 1017 DEF_CMD("link1", IFF_LINK1, setifflags), 1018 DEF_CMD("-link1", -IFF_LINK1, setifflags), 1019 DEF_CMD("link2", IFF_LINK2, setifflags), 1020 DEF_CMD("-link2", -IFF_LINK2, setifflags), 1021 DEF_CMD("monitor", IFF_MONITOR, setifflags), 1022 DEF_CMD("-monitor", -IFF_MONITOR, setifflags), 1023 DEF_CMD("staticarp", IFF_STATICARP, setifflags), 1024 DEF_CMD("-staticarp", -IFF_STATICARP, setifflags), 1025 DEF_CMD("rxcsum", IFCAP_RXCSUM, setifcap), 1026 DEF_CMD("-rxcsum", -IFCAP_RXCSUM, setifcap), 1027 DEF_CMD("txcsum", IFCAP_TXCSUM, setifcap), 1028 DEF_CMD("-txcsum", -IFCAP_TXCSUM, setifcap), 1029 DEF_CMD("netcons", IFCAP_NETCONS, setifcap), 1030 DEF_CMD("-netcons", -IFCAP_NETCONS, setifcap), 1031 DEF_CMD("polling", IFCAP_POLLING, setifcap), 1032 DEF_CMD("-polling", -IFCAP_POLLING, setifcap), 1033 DEF_CMD("tso", IFCAP_TSO, setifcap), 1034 DEF_CMD("-tso", -IFCAP_TSO, setifcap), 1035 DEF_CMD("lro", IFCAP_LRO, setifcap), 1036 DEF_CMD("-lro", -IFCAP_LRO, setifcap), 1037 DEF_CMD("wol", IFCAP_WOL, setifcap), 1038 DEF_CMD("-wol", -IFCAP_WOL, setifcap), 1039 DEF_CMD("wol_ucast", IFCAP_WOL_UCAST, setifcap), 1040 DEF_CMD("-wol_ucast", -IFCAP_WOL_UCAST, setifcap), 1041 DEF_CMD("wol_mcast", IFCAP_WOL_MCAST, setifcap), 1042 DEF_CMD("-wol_mcast", -IFCAP_WOL_MCAST, setifcap), 1043 DEF_CMD("wol_magic", IFCAP_WOL_MAGIC, setifcap), 1044 DEF_CMD("-wol_magic", -IFCAP_WOL_MAGIC, setifcap), 1045 DEF_CMD("normal", -IFF_LINK0, setifflags), 1046 DEF_CMD("compress", IFF_LINK0, setifflags), 1047 DEF_CMD("noicmp", IFF_LINK1, setifflags), 1048 DEF_CMD_ARG("mtu", setifmtu), 1049 DEF_CMD_ARG("name", setifname), 1050}; 1051 1052static __constructor void 1053ifconfig_ctor(void) 1054{ 1055#define N(a) (sizeof(a) / sizeof(a[0])) 1056 size_t i; 1057 1058 for (i = 0; i < N(basic_cmds); i++) 1059 cmd_register(&basic_cmds[i]); 1060#undef N 1061} 1062