ifconfig.c revision 1.236.16.1
1 /* $NetBSD: ifconfig.c,v 1.236.16.1 2019/06/10 22:05:34 christos Exp $ */ 2 3 /*- 4 * Copyright (c) 1997, 1998, 2000 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility, 9 * NASA Ames Research Center. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 30 * POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 /* 34 * Copyright (c) 1983, 1993 35 * The Regents of the University of California. All rights reserved. 36 * 37 * Redistribution and use in source and binary forms, with or without 38 * modification, are permitted provided that the following conditions 39 * are met: 40 * 1. Redistributions of source code must retain the above copyright 41 * notice, this list of conditions and the following disclaimer. 42 * 2. Redistributions in binary form must reproduce the above copyright 43 * notice, this list of conditions and the following disclaimer in the 44 * documentation and/or other materials provided with the distribution. 45 * 3. Neither the name of the University nor the names of its contributors 46 * may be used to endorse or promote products derived from this software 47 * without specific prior written permission. 48 * 49 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 50 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 51 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 52 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 53 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 54 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 55 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 56 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 57 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 58 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 59 * SUCH DAMAGE. 60 */ 61 62 #include <sys/cdefs.h> 63 #ifndef lint 64 __COPYRIGHT("@(#) Copyright (c) 1983, 1993\ 65 The Regents of the University of California. All rights reserved."); 66 __RCSID("$NetBSD: ifconfig.c,v 1.236.16.1 2019/06/10 22:05:34 christos Exp $"); 67 #endif /* not lint */ 68 69 #include <sys/param.h> 70 #include <sys/queue.h> 71 #include <sys/socket.h> 72 #include <sys/ioctl.h> 73 74 #include <net/if.h> 75 #include <net/if_dl.h> 76 #include <net/if_media.h> 77 #include <net/if_ether.h> 78 #include <netinet/in.h> /* XXX */ 79 #include <netinet/in_var.h> /* XXX */ 80 81 #include <netdb.h> 82 83 #include <sys/protosw.h> 84 85 #include <assert.h> 86 #include <ctype.h> 87 #include <err.h> 88 #include <errno.h> 89 #include <stdbool.h> 90 #include <stddef.h> 91 #include <stdio.h> 92 #include <stdlib.h> 93 #include <string.h> 94 #include <unistd.h> 95 #include <ifaddrs.h> 96 #include <util.h> 97 98 #include "extern.h" 99 100 #include "media.h" 101 #include "parse.h" 102 #include "env.h" 103 #include "prog_ops.h" 104 105 #define WAIT_DAD 10000000 /* nanoseconds between each poll, 10ms */ 106 107 static bool bflag, dflag, hflag, sflag, uflag, Wflag, wflag; 108 bool lflag, Nflag, vflag, zflag; 109 static long wflag_secs, Wflag_secs; 110 111 static char gflags[10 + 26 * 2 + 1] = "AabCdhlNsuvW:w:z"; 112 bool gflagset[10 + 26 * 2]; 113 114 static int carrier(prop_dictionary_t); 115 static int clone_command(prop_dictionary_t, prop_dictionary_t); 116 static void do_setifpreference(prop_dictionary_t); 117 static int flag_index(int); 118 static void init_afs(void); 119 static int list_cloners(prop_dictionary_t, prop_dictionary_t); 120 static int media_status_exec(prop_dictionary_t, prop_dictionary_t); 121 static int wait_dad_exec(prop_dictionary_t, prop_dictionary_t); 122 static int no_cmds_exec(prop_dictionary_t, prop_dictionary_t); 123 static int notrailers(prop_dictionary_t, prop_dictionary_t); 124 static void printall(const char *, prop_dictionary_t); 125 static int setifaddr(prop_dictionary_t, prop_dictionary_t); 126 static int setifbroadaddr(prop_dictionary_t, prop_dictionary_t); 127 static int setifcaps(prop_dictionary_t, prop_dictionary_t); 128 static int setifdstormask(prop_dictionary_t, prop_dictionary_t); 129 static int setifflags(prop_dictionary_t, prop_dictionary_t); 130 static int setifmetric(prop_dictionary_t, prop_dictionary_t); 131 static int setifmtu(prop_dictionary_t, prop_dictionary_t); 132 static int setifnetmask(prop_dictionary_t, prop_dictionary_t); 133 static int setifprefixlen(prop_dictionary_t, prop_dictionary_t); 134 static int setlinkstr(prop_dictionary_t, prop_dictionary_t); 135 static int unsetlinkstr(prop_dictionary_t, prop_dictionary_t); 136 static void status(const struct sockaddr *, prop_dictionary_t, 137 prop_dictionary_t); 138 __dead static void usage(void); 139 140 static const struct kwinst ifflagskw[] = { 141 IFKW("arp", -IFF_NOARP) 142 , IFKW("debug", IFF_DEBUG) 143 , IFKW("link0", IFF_LINK0) 144 , IFKW("link1", IFF_LINK1) 145 , IFKW("link2", IFF_LINK2) 146 , {.k_word = "down", .k_type = KW_T_INT, .k_int = -IFF_UP} 147 , {.k_word = "up", .k_type = KW_T_INT, .k_int = IFF_UP} 148 }; 149 150 static const struct kwinst ifcapskw[] = { 151 IFKW("ip4csum-tx", IFCAP_CSUM_IPv4_Tx) 152 , IFKW("ip4csum-rx", IFCAP_CSUM_IPv4_Rx) 153 , IFKW("tcp4csum-tx", IFCAP_CSUM_TCPv4_Tx) 154 , IFKW("tcp4csum-rx", IFCAP_CSUM_TCPv4_Rx) 155 , IFKW("udp4csum-tx", IFCAP_CSUM_UDPv4_Tx) 156 , IFKW("udp4csum-rx", IFCAP_CSUM_UDPv4_Rx) 157 , IFKW("tcp6csum-tx", IFCAP_CSUM_TCPv6_Tx) 158 , IFKW("tcp6csum-rx", IFCAP_CSUM_TCPv6_Rx) 159 , IFKW("udp6csum-tx", IFCAP_CSUM_UDPv6_Tx) 160 , IFKW("udp6csum-rx", IFCAP_CSUM_UDPv6_Rx) 161 , IFKW("ip4csum", IFCAP_CSUM_IPv4_Tx|IFCAP_CSUM_IPv4_Rx) 162 , IFKW("tcp4csum", IFCAP_CSUM_TCPv4_Tx|IFCAP_CSUM_TCPv4_Rx) 163 , IFKW("udp4csum", IFCAP_CSUM_UDPv4_Tx|IFCAP_CSUM_UDPv4_Rx) 164 , IFKW("tcp6csum", IFCAP_CSUM_TCPv6_Tx|IFCAP_CSUM_TCPv6_Rx) 165 , IFKW("udp6csum", IFCAP_CSUM_UDPv6_Tx|IFCAP_CSUM_UDPv6_Rx) 166 , IFKW("tso4", IFCAP_TSOv4) 167 , IFKW("tso6", IFCAP_TSOv6) 168 }; 169 170 extern struct pbranch command_root; 171 extern struct pbranch opt_command; 172 extern struct pbranch opt_family, opt_silent_family; 173 extern struct pkw cloning, silent_family, family, ifcaps, ifflags, misc; 174 extern struct pstr parse_linkstr; 175 176 struct pinteger parse_metric = PINTEGER_INITIALIZER(&parse_metric, "metric", 10, 177 setifmetric, "metric", &command_root.pb_parser); 178 179 struct pinteger parse_mtu = PINTEGER_INITIALIZER(&parse_mtu, "mtu", 10, 180 setifmtu, "mtu", &command_root.pb_parser); 181 182 struct pinteger parse_prefixlen = PINTEGER_INITIALIZER(&parse_prefixlen, 183 "prefixlen", 10, setifprefixlen, "prefixlen", &command_root.pb_parser); 184 185 struct pinteger parse_preference = PINTEGER_INITIALIZER1(&parse_preference, 186 "preference", INT16_MIN, INT16_MAX, 10, NULL, "preference", 187 &command_root.pb_parser); 188 189 struct paddr parse_netmask = PADDR_INITIALIZER(&parse_netmask, "netmask", 190 setifnetmask, "dstormask", NULL, NULL, NULL, &command_root.pb_parser); 191 192 struct paddr parse_broadcast = PADDR_INITIALIZER(&parse_broadcast, 193 "broadcast address", 194 setifbroadaddr, "broadcast", NULL, NULL, NULL, &command_root.pb_parser); 195 196 static const struct kwinst misckw[] = { 197 {.k_word = "alias", .k_key = "alias", .k_deact = "alias", 198 .k_type = KW_T_BOOL, .k_neg = true, 199 .k_bool = true, .k_negbool = false, 200 .k_nextparser = &command_root.pb_parser} 201 , {.k_word = "broadcast", .k_nextparser = &parse_broadcast.pa_parser} 202 , {.k_word = "delete", .k_key = "alias", .k_deact = "alias", 203 .k_type = KW_T_BOOL, .k_bool = false, 204 .k_nextparser = &command_root.pb_parser} 205 , {.k_word = "metric", .k_nextparser = &parse_metric.pi_parser} 206 , {.k_word = "mtu", .k_nextparser = &parse_mtu.pi_parser} 207 , {.k_word = "netmask", .k_nextparser = &parse_netmask.pa_parser} 208 , {.k_word = "preference", .k_act = "address", 209 .k_nextparser = &parse_preference.pi_parser} 210 , {.k_word = "prefixlen", .k_nextparser = &parse_prefixlen.pi_parser} 211 , {.k_word = "trailers", .k_neg = true, 212 .k_exec = notrailers, .k_nextparser = &command_root.pb_parser} 213 , {.k_word = "linkstr", .k_nextparser = &parse_linkstr.ps_parser } 214 , {.k_word = "-linkstr", .k_exec = unsetlinkstr, 215 .k_nextparser = &command_root.pb_parser } 216 }; 217 218 /* key: clonecmd */ 219 static const struct kwinst clonekw[] = { 220 {.k_word = "create", .k_type = KW_T_INT, .k_int = SIOCIFCREATE, 221 .k_nextparser = &opt_silent_family.pb_parser}, 222 {.k_word = "destroy", .k_type = KW_T_INT, .k_int = SIOCIFDESTROY} 223 }; 224 225 static struct kwinst familykw[24]; 226 227 struct pterm cloneterm = PTERM_INITIALIZER(&cloneterm, "list cloners", 228 list_cloners, "none"); 229 230 struct pterm wait_dad = PTERM_INITIALIZER(&wait_dad, "wait DAD", wait_dad_exec, 231 "none"); 232 233 struct pterm no_cmds = PTERM_INITIALIZER(&no_cmds, "no commands", no_cmds_exec, 234 "none"); 235 236 struct pkw family_only = 237 PKW_INITIALIZER(&family_only, "family-only", NULL, "af", familykw, 238 __arraycount(familykw), &no_cmds.pt_parser); 239 240 struct paddr address = PADDR_INITIALIZER(&address, 241 "local address (address 1)", 242 setifaddr, "address", "netmask", NULL, "address", &command_root.pb_parser); 243 244 struct paddr dstormask = PADDR_INITIALIZER(&dstormask, 245 "destination/netmask (address 2)", 246 setifdstormask, "dstormask", NULL, "address", "dstormask", 247 &command_root.pb_parser); 248 249 struct paddr broadcast = PADDR_INITIALIZER(&broadcast, 250 "broadcast address (address 3)", 251 setifbroadaddr, "broadcast", NULL, "dstormask", "broadcast", 252 &command_root.pb_parser); 253 254 struct pstr parse_linkstr = PSTR_INITIALIZER(&parse_linkstr, "linkstr", 255 setlinkstr, "linkstr", &command_root.pb_parser); 256 257 static SIMPLEQ_HEAD(, afswtch) aflist = SIMPLEQ_HEAD_INITIALIZER(aflist); 258 259 static SIMPLEQ_HEAD(, usage_func) usage_funcs = 260 SIMPLEQ_HEAD_INITIALIZER(usage_funcs); 261 static SIMPLEQ_HEAD(, status_func) status_funcs = 262 SIMPLEQ_HEAD_INITIALIZER(status_funcs); 263 static SIMPLEQ_HEAD(, statistics_func) statistics_funcs = 264 SIMPLEQ_HEAD_INITIALIZER(statistics_funcs); 265 static SIMPLEQ_HEAD(, cmdloop_branch) cmdloop_branches = 266 SIMPLEQ_HEAD_INITIALIZER(cmdloop_branches); 267 268 struct branch opt_clone_brs[] = { 269 {.b_nextparser = &cloning.pk_parser} 270 , {.b_nextparser = &opt_family.pb_parser} 271 }, opt_silent_family_brs[] = { 272 {.b_nextparser = &silent_family.pk_parser} 273 , {.b_nextparser = &command_root.pb_parser} 274 }, opt_family_brs[] = { 275 {.b_nextparser = &family.pk_parser} 276 , {.b_nextparser = &opt_command.pb_parser} 277 }, command_root_brs[] = { 278 {.b_nextparser = &ifflags.pk_parser} 279 , {.b_nextparser = &ifcaps.pk_parser} 280 , {.b_nextparser = &kwmedia.pk_parser} 281 , {.b_nextparser = &misc.pk_parser} 282 , {.b_nextparser = &address.pa_parser} 283 , {.b_nextparser = &dstormask.pa_parser} 284 , {.b_nextparser = &broadcast.pa_parser} 285 , {.b_nextparser = NULL} 286 }, opt_command_brs[] = { 287 {.b_nextparser = &no_cmds.pt_parser} 288 , {.b_nextparser = &command_root.pb_parser} 289 }; 290 291 struct branch opt_family_only_brs[] = { 292 {.b_nextparser = &no_cmds.pt_parser} 293 , {.b_nextparser = &family_only.pk_parser} 294 }; 295 struct pbranch opt_family_only = PBRANCH_INITIALIZER(&opt_family_only, 296 "opt-family-only", opt_family_only_brs, 297 __arraycount(opt_family_only_brs), true); 298 struct pbranch opt_command = PBRANCH_INITIALIZER(&opt_command, 299 "optional command", 300 opt_command_brs, __arraycount(opt_command_brs), true); 301 302 struct pbranch command_root = PBRANCH_INITIALIZER(&command_root, 303 "command-root", command_root_brs, __arraycount(command_root_brs), true); 304 305 struct piface iface_opt_family_only = 306 PIFACE_INITIALIZER(&iface_opt_family_only, "iface-opt-family-only", 307 NULL, "if", &opt_family_only.pb_parser); 308 309 struct pkw family = PKW_INITIALIZER(&family, "family", NULL, "af", 310 familykw, __arraycount(familykw), &opt_command.pb_parser); 311 312 struct pkw silent_family = PKW_INITIALIZER(&silent_family, "silent family", 313 NULL, "af", familykw, __arraycount(familykw), &command_root.pb_parser); 314 315 struct pkw *family_users[] = {&family_only, &family, &silent_family}; 316 317 struct pkw ifcaps = PKW_INITIALIZER(&ifcaps, "ifcaps", setifcaps, 318 "ifcap", ifcapskw, __arraycount(ifcapskw), &command_root.pb_parser); 319 320 struct pkw ifflags = PKW_INITIALIZER(&ifflags, "ifflags", setifflags, 321 "ifflag", ifflagskw, __arraycount(ifflagskw), &command_root.pb_parser); 322 323 struct pkw cloning = PKW_INITIALIZER(&cloning, "cloning", clone_command, 324 "clonecmd", clonekw, __arraycount(clonekw), NULL); 325 326 struct pkw misc = PKW_INITIALIZER(&misc, "misc", NULL, NULL, 327 misckw, __arraycount(misckw), NULL); 328 329 struct pbranch opt_clone = PBRANCH_INITIALIZER(&opt_clone, 330 "opt-clone", opt_clone_brs, __arraycount(opt_clone_brs), true); 331 332 struct pbranch opt_silent_family = PBRANCH_INITIALIZER(&opt_silent_family, 333 "optional silent family", opt_silent_family_brs, 334 __arraycount(opt_silent_family_brs), true); 335 336 struct pbranch opt_family = PBRANCH_INITIALIZER(&opt_family, 337 "opt-family", opt_family_brs, __arraycount(opt_family_brs), true); 338 339 struct piface iface_start = PIFACE_INITIALIZER(&iface_start, 340 "iface-opt-family", NULL, "if", &opt_clone.pb_parser); 341 342 struct piface iface_only = PIFACE_INITIALIZER(&iface_only, "iface", 343 media_status_exec, "if", NULL); 344 345 static bool 346 flag_is_registered(const char *flags, int flag) 347 { 348 return flags != NULL && strchr(flags, flag) != NULL; 349 } 350 351 static int 352 check_flag(const char *flags, int flag) 353 { 354 if (flag_is_registered(flags, flag)) { 355 errno = EEXIST; 356 return -1; 357 } 358 359 if (flag >= '0' && flag <= '9') 360 return 0; 361 if (flag >= 'a' && flag <= 'z') 362 return 0; 363 if (flag >= 'A' && flag <= 'Z') 364 return 0; 365 366 errno = EINVAL; 367 return -1; 368 } 369 370 void 371 cmdloop_branch_init(cmdloop_branch_t *b, struct parser *p) 372 { 373 b->b_parser = p; 374 } 375 376 void 377 statistics_func_init(statistics_func_t *f, statistics_cb_t func) 378 { 379 f->f_func = func; 380 } 381 382 void 383 status_func_init(status_func_t *f, status_cb_t func) 384 { 385 f->f_func = func; 386 } 387 388 void 389 usage_func_init(usage_func_t *f, usage_cb_t func) 390 { 391 f->f_func = func; 392 } 393 394 int 395 register_cmdloop_branch(cmdloop_branch_t *b) 396 { 397 SIMPLEQ_INSERT_TAIL(&cmdloop_branches, b, b_next); 398 return 0; 399 } 400 401 int 402 register_statistics(statistics_func_t *f) 403 { 404 SIMPLEQ_INSERT_TAIL(&statistics_funcs, f, f_next); 405 return 0; 406 } 407 408 int 409 register_status(status_func_t *f) 410 { 411 SIMPLEQ_INSERT_TAIL(&status_funcs, f, f_next); 412 return 0; 413 } 414 415 int 416 register_usage(usage_func_t *f) 417 { 418 SIMPLEQ_INSERT_TAIL(&usage_funcs, f, f_next); 419 return 0; 420 } 421 422 int 423 register_family(struct afswtch *af) 424 { 425 SIMPLEQ_INSERT_TAIL(&aflist, af, af_next); 426 return 0; 427 } 428 429 int 430 register_flag(int flag) 431 { 432 if (check_flag(gflags, flag) == -1) 433 return -1; 434 435 if (strlen(gflags) + 1 >= sizeof(gflags)) { 436 errno = ENOMEM; 437 return -1; 438 } 439 440 gflags[strlen(gflags)] = flag; 441 442 return 0; 443 } 444 445 static int 446 flag_index(int flag) 447 { 448 if (flag >= '0' && flag <= '9') 449 return flag - '0'; 450 if (flag >= 'a' && flag <= 'z') 451 return 10 + flag - 'a'; 452 if (flag >= 'A' && flag <= 'Z') 453 return 10 + 26 + flag - 'a'; 454 455 errno = EINVAL; 456 return -1; 457 } 458 459 static bool 460 set_flag(int flag) 461 { 462 int idx; 463 464 if ((idx = flag_index(flag)) == -1) 465 return false; 466 467 return gflagset[idx] = true; 468 } 469 470 bool 471 get_flag(int flag) 472 { 473 int idx; 474 475 if ((idx = flag_index(flag)) == -1) 476 return false; 477 478 return gflagset[idx]; 479 } 480 481 static struct parser * 482 init_parser(void) 483 { 484 cmdloop_branch_t *b; 485 486 if (parser_init(&iface_opt_family_only.pif_parser) == -1) 487 err(EXIT_FAILURE, "parser_init(iface_opt_family_only)"); 488 if (parser_init(&iface_only.pif_parser) == -1) 489 err(EXIT_FAILURE, "parser_init(iface_only)"); 490 if (parser_init(&iface_start.pif_parser) == -1) 491 err(EXIT_FAILURE, "parser_init(iface_start)"); 492 493 SIMPLEQ_FOREACH(b, &cmdloop_branches, b_next) 494 pbranch_addbranch(&command_root, b->b_parser); 495 496 return &iface_start.pif_parser; 497 } 498 499 static int 500 no_cmds_exec(prop_dictionary_t env, prop_dictionary_t oenv) 501 { 502 const char *ifname; 503 unsigned short ignore; 504 505 /* ifname == NULL is ok. It indicates 'ifconfig -a'. */ 506 if ((ifname = getifname(env)) == NULL) 507 ; 508 else if (getifflags(env, oenv, &ignore) == -1) 509 err(EXIT_FAILURE, "SIOCGIFFLAGS %s", ifname); 510 511 printall(ifname, env); 512 exit(EXIT_SUCCESS); 513 } 514 515 static int 516 wait_dad_exec(prop_dictionary_t env, prop_dictionary_t oenv) 517 { 518 bool waiting; 519 struct ifaddrs *ifaddrs, *ifa; 520 const struct timespec ts = { .tv_sec = 0, .tv_nsec = WAIT_DAD }; 521 struct timespec now, end_det, end; 522 const struct afswtch *afp; 523 524 if (wflag_secs) { 525 const struct timespec tent = 526 { .tv_sec = wflag_secs, .tv_nsec = 0}; 527 const struct timespec det = 528 { .tv_sec = Wflag_secs, .tv_nsec = 0}; 529 530 if (clock_gettime(CLOCK_MONOTONIC, &now) == -1) 531 err(EXIT_FAILURE, "clock_gettime"); 532 timespecadd(&now, &tent, &end); 533 if (Wflag_secs) 534 timespecadd(&now, &det, &end_det); 535 else 536 timespecclear(&end_det); 537 } else { 538 timespecclear(&end_det); 539 timespecclear(&end); 540 } 541 542 if (getifaddrs(&ifaddrs) == -1) 543 err(EXIT_FAILURE, "getifaddrs"); 544 545 for (;;) { 546 waiting = false; 547 for (ifa = ifaddrs; ifa; ifa = ifa->ifa_next) { 548 if (ifa->ifa_addr == NULL) 549 continue; 550 afp = lookup_af_bynum(ifa->ifa_addr->sa_family); 551 if (afp && 552 ((afp->af_addr_tentative_or_detached && 553 ifa->ifa_flags & IFF_UP && 554 timespecisset(&end_det) && 555 timespeccmp(&now, &end_det, <) && 556 afp->af_addr_tentative_or_detached(ifa)) || 557 (afp->af_addr_tentative && 558 afp->af_addr_tentative(ifa)))) 559 { 560 waiting = true; 561 break; 562 } 563 } 564 if (!waiting) 565 break; 566 nanosleep(&ts, NULL); 567 if (wflag_secs) { 568 if (clock_gettime(CLOCK_MONOTONIC, &now) == -1) 569 err(EXIT_FAILURE, "clock_gettime"); 570 if (timespeccmp(&now, &end, >)) 571 errx(EXIT_FAILURE, "timed out"); 572 } 573 } 574 575 freeifaddrs(ifaddrs); 576 exit(EXIT_SUCCESS); 577 } 578 579 static int 580 media_status_exec(prop_dictionary_t env, prop_dictionary_t oenv) 581 { 582 const char *ifname; 583 unsigned short ignore; 584 585 /* ifname == NULL is ok. It indicates 'ifconfig -a'. */ 586 if ((ifname = getifname(env)) == NULL) 587 ; 588 else if (getifflags(env, oenv, &ignore) == -1) 589 err(EXIT_FAILURE, "SIOCGIFFLAGS %s", ifname); 590 591 exit(carrier(env)); 592 } 593 594 static void 595 do_setifcaps(prop_dictionary_t env) 596 { 597 struct ifcapreq ifcr; 598 prop_data_t d; 599 600 d = (prop_data_t )prop_dictionary_get(env, "ifcaps"); 601 if (d == NULL) 602 return; 603 604 assert(sizeof(ifcr) == prop_data_size(d)); 605 606 memcpy(&ifcr, prop_data_data_nocopy(d), sizeof(ifcr)); 607 if (direct_ioctl(env, SIOCSIFCAP, &ifcr) == -1) 608 err(EXIT_FAILURE, "SIOCSIFCAP"); 609 } 610 611 int 612 main(int argc, char **argv) 613 { 614 const struct afswtch *afp; 615 int af, s, e; 616 bool aflag = false, Cflag = false; 617 struct match match[32]; 618 size_t nmatch; 619 struct parser *start; 620 int ch, narg = 0, rc; 621 prop_dictionary_t env, oenv; 622 const char *ifname; 623 624 memset(match, 0, sizeof(match)); 625 626 init_afs(); 627 628 start = init_parser(); 629 630 /* Parse command-line options */ 631 Nflag = vflag = zflag = false; 632 aflag = argc == 1 ? true : false; 633 if (aflag) 634 start = &opt_family_only.pb_parser; 635 636 while ((ch = getopt(argc, argv, gflags)) != -1) { 637 switch (ch) { 638 case 'A': 639 warnx("-A is deprecated"); 640 break; 641 642 case 'a': 643 aflag = true; 644 break; 645 646 case 'b': 647 bflag = true; 648 break; 649 650 case 'C': 651 Cflag = true; 652 break; 653 654 case 'd': 655 dflag = true; 656 break; 657 case 'h': 658 hflag = true; 659 break; 660 case 'l': 661 lflag = true; 662 break; 663 case 'N': 664 Nflag = true; 665 break; 666 667 case 's': 668 sflag = true; 669 break; 670 671 case 'u': 672 uflag = true; 673 break; 674 675 case 'v': 676 vflag = true; 677 break; 678 679 case 'w': 680 wflag = true; 681 wflag_secs = strtoi(optarg, NULL, 10, 0, INT32_MAX, &e); 682 if (e) 683 errx(EXIT_FAILURE, "%s: not a number", optarg); 684 break; 685 686 case 'W': 687 Wflag = true; 688 Wflag_secs = strtoi(optarg, NULL, 10, 0, INT32_MAX, &e); 689 if (e) 690 errx(EXIT_FAILURE, "%s: not a number", optarg); 691 break; 692 693 case 'z': 694 zflag = true; 695 break; 696 697 default: 698 if (!set_flag(ch)) 699 usage(); 700 break; 701 } 702 switch (ch) { 703 case 'a': 704 start = &opt_family_only.pb_parser; 705 break; 706 707 case 'L': 708 case 'm': 709 case 'z': 710 if (start != &opt_family_only.pb_parser) 711 start = &iface_opt_family_only.pif_parser; 712 break; 713 case 'C': 714 start = &cloneterm.pt_parser; 715 break; 716 case 'l': 717 start = &no_cmds.pt_parser; 718 break; 719 case 's': 720 if (start != &no_cmds.pt_parser && 721 start != &opt_family_only.pb_parser) 722 start = &iface_only.pif_parser; 723 break; 724 case 'w': 725 start = &wait_dad.pt_parser; 726 break; 727 default: 728 break; 729 } 730 } 731 argc -= optind; 732 argv += optind; 733 734 /* 735 * -l means "list all interfaces", and is mutually exclusive with 736 * all other flags/commands. 737 * 738 * -C means "list all names of cloners", and it mutually exclusive 739 * with all other flags/commands. 740 * 741 * -a means "print status of all interfaces". 742 * 743 * -w means "spin until DAD completes for all addreseses", and is 744 * mutually exclusivewith all other flags/commands. 745 */ 746 if ((lflag || Cflag || wflag) && 747 (aflag || get_flag('m') || vflag || zflag)) 748 usage(); 749 if ((lflag || Cflag || wflag) && get_flag('L')) 750 usage(); 751 if ((lflag && Cflag) || (lflag & wflag) || (Cflag && wflag)) 752 usage(); 753 754 nmatch = __arraycount(match); 755 756 rc = parse(argc, argv, start, match, &nmatch, &narg); 757 if (rc != 0) 758 usage(); 759 760 if (prog_init && prog_init() == -1) 761 err(1, "rump client init"); 762 763 if ((oenv = prop_dictionary_create()) == NULL) 764 err(EXIT_FAILURE, "%s: prop_dictionary_create", __func__); 765 766 if (matches_exec(match, oenv, nmatch) == -1) 767 err(EXIT_FAILURE, "exec_matches"); 768 769 argc -= narg; 770 argv += narg; 771 772 env = (nmatch > 0) ? match[(int)nmatch - 1].m_env : NULL; 773 if (env == NULL) 774 env = oenv; 775 else { 776 env = prop_dictionary_augment(env, oenv); 777 if (env == NULL) 778 err(EXIT_FAILURE, "%s: prop_dictionary_augment", 779 __func__); 780 } 781 782 /* Process any media commands that may have been issued. */ 783 process_media_commands(env); 784 785 if ((af = getaf(env)) == -1) 786 af = AF_INET; 787 788 if ((s = getsock(af)) == -1) 789 err(EXIT_FAILURE, "%s: getsock", __func__); 790 791 if ((ifname = getifname(env)) == NULL) 792 err(EXIT_FAILURE, "%s: getifname", __func__); 793 794 if ((afp = lookup_af_bynum(af)) == NULL) 795 errx(EXIT_FAILURE, "%s: lookup_af_bynum", __func__); 796 797 assert(afp->af_addr_commit != NULL); 798 (*afp->af_addr_commit)(env, oenv); 799 800 do_setifpreference(env); 801 do_setifcaps(env); 802 do_setethercaps(env); 803 804 exit(EXIT_SUCCESS); 805 } 806 807 static void 808 init_afs(void) 809 { 810 size_t i; 811 const struct afswtch *afp; 812 struct kwinst kw = {.k_type = KW_T_INT}; 813 814 SIMPLEQ_FOREACH(afp, &aflist, af_next) { 815 kw.k_word = afp->af_name; 816 kw.k_int = afp->af_af; 817 for (i = 0; i < __arraycount(familykw); i++) { 818 if (familykw[i].k_word == NULL) { 819 familykw[i] = kw; 820 break; 821 } 822 } 823 } 824 } 825 826 const struct afswtch * 827 lookup_af_bynum(int afnum) 828 { 829 const struct afswtch *afp; 830 831 SIMPLEQ_FOREACH(afp, &aflist, af_next) { 832 if (afp->af_af == afnum) 833 break; 834 } 835 return afp; 836 } 837 838 void 839 printall(const char *ifname, prop_dictionary_t env0) 840 { 841 struct ifaddrs *ifap, *ifa; 842 struct ifreq ifr; 843 const struct sockaddr *sdl = NULL; 844 prop_dictionary_t env, oenv; 845 int idx; 846 char *p; 847 848 if (env0 == NULL) 849 env = prop_dictionary_create(); 850 else 851 env = prop_dictionary_copy_mutable(env0); 852 853 oenv = prop_dictionary_create(); 854 855 if (env == NULL || oenv == NULL) 856 errx(EXIT_FAILURE, "%s: prop_dictionary_copy/create", __func__); 857 858 if (getifaddrs(&ifap) != 0) 859 err(EXIT_FAILURE, "getifaddrs"); 860 p = NULL; 861 idx = 0; 862 for (ifa = ifap; ifa; ifa = ifa->ifa_next) { 863 memset(&ifr, 0, sizeof(ifr)); 864 estrlcpy(ifr.ifr_name, ifa->ifa_name, sizeof(ifr.ifr_name)); 865 if (sizeof(ifr.ifr_addr) >= ifa->ifa_addr->sa_len) { 866 memcpy(&ifr.ifr_addr, ifa->ifa_addr, 867 ifa->ifa_addr->sa_len); 868 } 869 870 if (ifname != NULL && strcmp(ifname, ifa->ifa_name) != 0) 871 continue; 872 if (ifa->ifa_addr->sa_family == AF_LINK) 873 sdl = ifa->ifa_addr; 874 if (p && strcmp(p, ifa->ifa_name) == 0) 875 continue; 876 if (!prop_dictionary_set_cstring(env, "if", ifa->ifa_name)) 877 continue; 878 p = ifa->ifa_name; 879 880 if (bflag && (ifa->ifa_flags & IFF_BROADCAST) == 0) 881 continue; 882 if (dflag && (ifa->ifa_flags & IFF_UP) != 0) 883 continue; 884 if (uflag && (ifa->ifa_flags & IFF_UP) == 0) 885 continue; 886 887 if (sflag && carrier(env)) 888 continue; 889 idx++; 890 /* 891 * Are we just listing the interfaces? 892 */ 893 if (lflag) { 894 if (idx > 1) 895 printf(" "); 896 fputs(ifa->ifa_name, stdout); 897 continue; 898 } 899 900 status(sdl, env, oenv); 901 sdl = NULL; 902 } 903 if (lflag) 904 printf("\n"); 905 prop_object_release((prop_object_t)env); 906 prop_object_release((prop_object_t)oenv); 907 freeifaddrs(ifap); 908 } 909 910 static int 911 list_cloners(prop_dictionary_t env, prop_dictionary_t oenv) 912 { 913 struct if_clonereq ifcr; 914 char *cp, *buf; 915 int idx, s; 916 917 memset(&ifcr, 0, sizeof(ifcr)); 918 919 s = getsock(AF_INET); 920 921 if (prog_ioctl(s, SIOCIFGCLONERS, &ifcr) == -1) 922 err(EXIT_FAILURE, "SIOCIFGCLONERS for count"); 923 924 buf = malloc(ifcr.ifcr_total * IFNAMSIZ); 925 if (buf == NULL) 926 err(EXIT_FAILURE, "unable to allocate cloner name buffer"); 927 928 ifcr.ifcr_count = ifcr.ifcr_total; 929 ifcr.ifcr_buffer = buf; 930 931 if (prog_ioctl(s, SIOCIFGCLONERS, &ifcr) == -1) 932 err(EXIT_FAILURE, "SIOCIFGCLONERS for names"); 933 934 /* 935 * In case some disappeared in the mean time, clamp it down. 936 */ 937 if (ifcr.ifcr_count > ifcr.ifcr_total) 938 ifcr.ifcr_count = ifcr.ifcr_total; 939 940 for (cp = buf, idx = 0; idx < ifcr.ifcr_count; idx++, cp += IFNAMSIZ) { 941 if (idx > 0) 942 printf(" "); 943 printf("%s", cp); 944 } 945 946 printf("\n"); 947 free(buf); 948 exit(EXIT_SUCCESS); 949 } 950 951 static int 952 clone_command(prop_dictionary_t env, prop_dictionary_t oenv) 953 { 954 int64_t cmd; 955 956 if (!prop_dictionary_get_int64(env, "clonecmd", &cmd)) { 957 errno = ENOENT; 958 return -1; 959 } 960 961 if (indirect_ioctl(env, (unsigned long)cmd, NULL) == -1) { 962 warn("%s", __func__); 963 return -1; 964 } 965 return 0; 966 } 967 968 /*ARGSUSED*/ 969 static int 970 setifaddr(prop_dictionary_t env, prop_dictionary_t oenv) 971 { 972 const struct paddr_prefix *pfx0; 973 struct paddr_prefix *pfx; 974 prop_data_t d; 975 int af; 976 977 if ((af = getaf(env)) == -1) 978 af = AF_INET; 979 980 d = (prop_data_t)prop_dictionary_get(env, "address"); 981 assert(d != NULL); 982 pfx0 = prop_data_data_nocopy(d); 983 984 if (pfx0->pfx_len >= 0) { 985 pfx = prefixlen_to_mask(af, pfx0->pfx_len); 986 if (pfx == NULL) 987 err(EXIT_FAILURE, "prefixlen_to_mask"); 988 free(pfx); 989 } 990 991 return 0; 992 } 993 994 static int 995 setifnetmask(prop_dictionary_t env, prop_dictionary_t oenv) 996 { 997 prop_data_t d; 998 999 d = (prop_data_t)prop_dictionary_get(env, "dstormask"); 1000 assert(d != NULL); 1001 1002 if (!prop_dictionary_set(oenv, "netmask", (prop_object_t)d)) 1003 return -1; 1004 1005 return 0; 1006 } 1007 1008 static int 1009 setifbroadaddr(prop_dictionary_t env, prop_dictionary_t oenv) 1010 { 1011 prop_data_t d; 1012 unsigned short flags; 1013 1014 if (getifflags(env, oenv, &flags) == -1) 1015 err(EXIT_FAILURE, "%s: getifflags", __func__); 1016 1017 if ((flags & IFF_BROADCAST) == 0) 1018 errx(EXIT_FAILURE, "not a broadcast interface"); 1019 1020 d = (prop_data_t)prop_dictionary_get(env, "broadcast"); 1021 assert(d != NULL); 1022 1023 if (!prop_dictionary_set(oenv, "broadcast", (prop_object_t)d)) 1024 return -1; 1025 1026 return 0; 1027 } 1028 1029 /*ARGSUSED*/ 1030 static int 1031 notrailers(prop_dictionary_t env, prop_dictionary_t oenv) 1032 { 1033 puts("Note: trailers are no longer sent, but always received"); 1034 return 0; 1035 } 1036 1037 /*ARGSUSED*/ 1038 static int 1039 setifdstormask(prop_dictionary_t env, prop_dictionary_t oenv) 1040 { 1041 const char *key; 1042 prop_data_t d; 1043 unsigned short flags; 1044 1045 if (getifflags(env, oenv, &flags) == -1) 1046 err(EXIT_FAILURE, "%s: getifflags", __func__); 1047 1048 d = (prop_data_t)prop_dictionary_get(env, "dstormask"); 1049 assert(d != NULL); 1050 1051 if ((flags & IFF_BROADCAST) == 0) { 1052 key = "dst"; 1053 } else { 1054 key = "netmask"; 1055 } 1056 1057 if (!prop_dictionary_set(oenv, key, (prop_object_t)d)) 1058 return -1; 1059 1060 return 0; 1061 } 1062 1063 static int 1064 setifflags(prop_dictionary_t env, prop_dictionary_t oenv) 1065 { 1066 struct ifreq ifr; 1067 int64_t ifflag; 1068 bool rc; 1069 1070 rc = prop_dictionary_get_int64(env, "ifflag", &ifflag); 1071 assert(rc); 1072 1073 if (direct_ioctl(env, SIOCGIFFLAGS, &ifr) == -1) 1074 return -1; 1075 1076 if (ifflag < 0) { 1077 ifflag = -ifflag; 1078 ifr.ifr_flags &= ~ifflag; 1079 } else 1080 ifr.ifr_flags |= ifflag; 1081 1082 if (direct_ioctl(env, SIOCSIFFLAGS, &ifr) == -1) 1083 return -1; 1084 1085 return 0; 1086 } 1087 1088 static int 1089 getifcaps(prop_dictionary_t env, prop_dictionary_t oenv, struct ifcapreq *oifcr) 1090 { 1091 bool rc; 1092 struct ifcapreq ifcr; 1093 const struct ifcapreq *tmpifcr; 1094 prop_data_t capdata; 1095 1096 capdata = (prop_data_t)prop_dictionary_get(env, "ifcaps"); 1097 1098 if (capdata != NULL) { 1099 tmpifcr = prop_data_data_nocopy(capdata); 1100 *oifcr = *tmpifcr; 1101 return 0; 1102 } 1103 1104 (void)direct_ioctl(env, SIOCGIFCAP, &ifcr); 1105 *oifcr = ifcr; 1106 1107 capdata = prop_data_create_data(&ifcr, sizeof(ifcr)); 1108 1109 rc = prop_dictionary_set(oenv, "ifcaps", capdata); 1110 1111 prop_object_release((prop_object_t)capdata); 1112 1113 return rc ? 0 : -1; 1114 } 1115 1116 static int 1117 setifcaps(prop_dictionary_t env, prop_dictionary_t oenv) 1118 { 1119 int64_t ifcap; 1120 bool rc; 1121 prop_data_t capdata; 1122 struct ifcapreq ifcr; 1123 1124 rc = prop_dictionary_get_int64(env, "ifcap", &ifcap); 1125 assert(rc); 1126 1127 if (getifcaps(env, oenv, &ifcr) == -1) 1128 return -1; 1129 1130 if (ifcap < 0) { 1131 ifcap = -ifcap; 1132 ifcr.ifcr_capenable &= ~ifcap; 1133 } else 1134 ifcr.ifcr_capenable |= ifcap; 1135 1136 if ((capdata = prop_data_create_data(&ifcr, sizeof(ifcr))) == NULL) 1137 return -1; 1138 1139 rc = prop_dictionary_set(oenv, "ifcaps", capdata); 1140 prop_object_release((prop_object_t)capdata); 1141 1142 return rc ? 0 : -1; 1143 } 1144 1145 static int 1146 setifmetric(prop_dictionary_t env, prop_dictionary_t oenv) 1147 { 1148 struct ifreq ifr; 1149 bool rc; 1150 int64_t metric; 1151 1152 rc = prop_dictionary_get_int64(env, "metric", &metric); 1153 assert(rc); 1154 1155 ifr.ifr_metric = metric; 1156 if (direct_ioctl(env, SIOCSIFMETRIC, &ifr) == -1) 1157 warn("SIOCSIFMETRIC"); 1158 return 0; 1159 } 1160 1161 static void 1162 do_setifpreference(prop_dictionary_t env) 1163 { 1164 struct if_addrprefreq ifap; 1165 prop_data_t d; 1166 const struct paddr_prefix *pfx; 1167 1168 memset(&ifap, 0, sizeof(ifap)); 1169 1170 if (!prop_dictionary_get_int16(env, "preference", 1171 &ifap.ifap_preference)) 1172 return; 1173 1174 d = (prop_data_t)prop_dictionary_get(env, "address"); 1175 assert(d != NULL); 1176 1177 pfx = prop_data_data_nocopy(d); 1178 1179 memcpy(&ifap.ifap_addr, &pfx->pfx_addr, 1180 MIN(sizeof(ifap.ifap_addr), pfx->pfx_addr.sa_len)); 1181 if (direct_ioctl(env, SIOCSIFADDRPREF, &ifap) == -1) 1182 warn("SIOCSIFADDRPREF"); 1183 } 1184 1185 static int 1186 setifmtu(prop_dictionary_t env, prop_dictionary_t oenv) 1187 { 1188 int64_t mtu; 1189 bool rc; 1190 struct ifreq ifr; 1191 1192 rc = prop_dictionary_get_int64(env, "mtu", &mtu); 1193 assert(rc); 1194 1195 ifr.ifr_mtu = mtu; 1196 if (direct_ioctl(env, SIOCSIFMTU, &ifr) == -1) 1197 warn("SIOCSIFMTU"); 1198 1199 return 0; 1200 } 1201 1202 static int 1203 carrier(prop_dictionary_t env) 1204 { 1205 struct ifmediareq ifmr; 1206 1207 memset(&ifmr, 0, sizeof(ifmr)); 1208 1209 if (direct_ioctl(env, SIOCGIFMEDIA, &ifmr) == -1) { 1210 /* 1211 * Interface doesn't support SIOC{G,S}IFMEDIA; 1212 * assume ok. 1213 */ 1214 return EXIT_SUCCESS; 1215 } 1216 if ((ifmr.ifm_status & IFM_AVALID) == 0) { 1217 /* 1218 * Interface doesn't report media-valid status. 1219 * assume ok. 1220 */ 1221 return EXIT_SUCCESS; 1222 } 1223 /* otherwise, return ok for active, not-ok if not active. */ 1224 if (ifmr.ifm_status & IFM_ACTIVE) 1225 return EXIT_SUCCESS; 1226 else 1227 return EXIT_FAILURE; 1228 } 1229 1230 static void 1231 print_plural(const char *prefix, uint64_t n, const char *unit) 1232 { 1233 printf("%s%" PRIu64 " %s%s", prefix, n, unit, (n == 1) ? "" : "s"); 1234 } 1235 1236 static void 1237 print_human_bytes(bool humanize, uint64_t n) 1238 { 1239 char buf[5]; 1240 1241 if (humanize) { 1242 (void)humanize_number(buf, sizeof(buf), 1243 (int64_t)n, "", HN_AUTOSCALE, HN_NOSPACE | HN_DECIMAL); 1244 printf(", %s byte%s", buf, (atof(buf) == 1.0) ? "" : "s"); 1245 } else 1246 print_plural(", ", n, "byte"); 1247 } 1248 1249 /* 1250 * Print the status of the interface. If an address family was 1251 * specified, show it and it only; otherwise, show them all. 1252 */ 1253 1254 #define MAX_PRINT_LEN 58 /* XXX need a better way to determine this! */ 1255 1256 void 1257 status(const struct sockaddr *sdl, prop_dictionary_t env, 1258 prop_dictionary_t oenv) 1259 { 1260 const struct if_data *ifi; 1261 status_func_t *status_f; 1262 statistics_func_t *statistics_f; 1263 struct ifdatareq ifdr; 1264 struct ifreq ifr; 1265 struct ifdrv ifdrv; 1266 char fbuf[BUFSIZ]; 1267 char *bp; 1268 int af, s; 1269 const char *ifname; 1270 struct ifcapreq ifcr; 1271 unsigned short flags; 1272 const struct afswtch *afp; 1273 1274 if ((af = getaf(env)) == -1) { 1275 afp = NULL; 1276 af = AF_UNSPEC; 1277 } else 1278 afp = lookup_af_bynum(af); 1279 1280 /* get out early if the family is unsupported by the kernel */ 1281 if ((s = getsock(af)) == -1) 1282 err(EXIT_FAILURE, "%s: getsock", __func__); 1283 1284 if ((ifname = getifinfo(env, oenv, &flags)) == NULL) 1285 err(EXIT_FAILURE, "%s: getifinfo", __func__); 1286 1287 (void)snprintb(fbuf, sizeof(fbuf), IFFBITS, flags); 1288 printf("%s: flags=%s", ifname, fbuf); 1289 1290 estrlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name)); 1291 if (prog_ioctl(s, SIOCGIFMETRIC, &ifr) == -1) 1292 warn("SIOCGIFMETRIC %s", ifr.ifr_name); 1293 else if (ifr.ifr_metric != 0) 1294 printf(" metric %d", ifr.ifr_metric); 1295 1296 estrlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name)); 1297 if (prog_ioctl(s, SIOCGIFMTU, &ifr) != -1 && ifr.ifr_mtu != 0) 1298 printf(" mtu %d", ifr.ifr_mtu); 1299 printf("\n"); 1300 1301 if (getifcaps(env, oenv, &ifcr) == -1) 1302 err(EXIT_FAILURE, "%s: getifcaps", __func__); 1303 1304 if (ifcr.ifcr_capabilities != 0) { 1305 (void)snprintb_m(fbuf, sizeof(fbuf), IFCAPBITS, 1306 ifcr.ifcr_capabilities, MAX_PRINT_LEN); 1307 bp = fbuf; 1308 while (*bp != '\0') { 1309 printf("\tcapabilities=%s\n", &bp[2]); 1310 bp += strlen(bp) + 1; 1311 } 1312 (void)snprintb_m(fbuf, sizeof(fbuf), IFCAPBITS, 1313 ifcr.ifcr_capenable, MAX_PRINT_LEN); 1314 bp = fbuf; 1315 while (*bp != '\0') { 1316 printf("\tenabled=%s\n", &bp[2]); 1317 bp += strlen(bp) + 1; 1318 } 1319 } 1320 1321 SIMPLEQ_FOREACH(status_f, &status_funcs, f_next) 1322 (*status_f->f_func)(env, oenv); 1323 1324 print_link_addresses(env, true); 1325 1326 estrlcpy(ifdrv.ifd_name, ifname, sizeof(ifdrv.ifd_name)); 1327 ifdrv.ifd_cmd = IFLINKSTR_QUERYLEN; 1328 ifdrv.ifd_len = 0; 1329 ifdrv.ifd_data = NULL; 1330 /* interface supports linkstr? */ 1331 if (prog_ioctl(s, SIOCGLINKSTR, &ifdrv) != -1) { 1332 char *p; 1333 1334 p = malloc(ifdrv.ifd_len); 1335 if (p == NULL) 1336 err(EXIT_FAILURE, "malloc linkstr buf failed"); 1337 ifdrv.ifd_data = p; 1338 ifdrv.ifd_cmd = 0; 1339 if (prog_ioctl(s, SIOCGLINKSTR, &ifdrv) == -1) 1340 err(EXIT_FAILURE, "failed to query linkstr"); 1341 printf("\tlinkstr: %s\n", (char *)ifdrv.ifd_data); 1342 free(p); 1343 } 1344 1345 media_status(env, oenv); 1346 1347 if (!vflag && !zflag) 1348 goto proto_status; 1349 1350 estrlcpy(ifdr.ifdr_name, ifname, sizeof(ifdr.ifdr_name)); 1351 1352 if (prog_ioctl(s, zflag ? SIOCZIFDATA : SIOCGIFDATA, &ifdr) == -1) 1353 err(EXIT_FAILURE, zflag ? "SIOCZIFDATA" : "SIOCGIFDATA"); 1354 1355 ifi = &ifdr.ifdr_data; 1356 1357 print_plural("\tinput: ", ifi->ifi_ipackets, "packet"); 1358 print_human_bytes(hflag, ifi->ifi_ibytes); 1359 if (ifi->ifi_imcasts) 1360 print_plural(", ", ifi->ifi_imcasts, "multicast"); 1361 if (ifi->ifi_ierrors) 1362 print_plural(", ", ifi->ifi_ierrors, "error"); 1363 if (ifi->ifi_iqdrops) 1364 print_plural(", ", ifi->ifi_iqdrops, "queue drop"); 1365 if (ifi->ifi_noproto) 1366 printf(", %" PRIu64 " unknown protocol", ifi->ifi_noproto); 1367 print_plural("\n\toutput: ", ifi->ifi_opackets, "packet"); 1368 print_human_bytes(hflag, ifi->ifi_obytes); 1369 if (ifi->ifi_omcasts) 1370 print_plural(", ", ifi->ifi_omcasts, "multicast"); 1371 if (ifi->ifi_oerrors) 1372 print_plural(", ", ifi->ifi_oerrors, "error"); 1373 if (ifi->ifi_collisions) 1374 print_plural(", ", ifi->ifi_collisions, "collision"); 1375 printf("\n"); 1376 1377 SIMPLEQ_FOREACH(statistics_f, &statistics_funcs, f_next) 1378 (*statistics_f->f_func)(env); 1379 1380 proto_status: 1381 1382 if (afp != NULL) 1383 (*afp->af_status)(env, oenv, true); 1384 else SIMPLEQ_FOREACH(afp, &aflist, af_next) 1385 (*afp->af_status)(env, oenv, false); 1386 } 1387 1388 static int 1389 setifprefixlen(prop_dictionary_t env, prop_dictionary_t oenv) 1390 { 1391 bool rc; 1392 int64_t plen; 1393 int af; 1394 struct paddr_prefix *pfx; 1395 prop_data_t d; 1396 1397 if ((af = getaf(env)) == -1) 1398 af = AF_INET; 1399 1400 rc = prop_dictionary_get_int64(env, "prefixlen", &plen); 1401 assert(rc); 1402 1403 pfx = prefixlen_to_mask(af, plen); 1404 if (pfx == NULL) 1405 err(EXIT_FAILURE, "prefixlen_to_mask"); 1406 1407 d = prop_data_create_data(pfx, paddr_prefix_size(pfx)); 1408 if (d == NULL) 1409 err(EXIT_FAILURE, "%s: prop_data_create_data", __func__); 1410 1411 if (!prop_dictionary_set(oenv, "netmask", (prop_object_t)d)) 1412 err(EXIT_FAILURE, "%s: prop_dictionary_set", __func__); 1413 1414 free(pfx); 1415 return 0; 1416 } 1417 1418 static int 1419 setlinkstr(prop_dictionary_t env, prop_dictionary_t oenv) 1420 { 1421 struct ifdrv ifdrv; 1422 size_t linkstrlen; 1423 prop_data_t data; 1424 char *linkstr; 1425 1426 data = (prop_data_t)prop_dictionary_get(env, "linkstr"); 1427 if (data == NULL) { 1428 errno = ENOENT; 1429 return -1; 1430 } 1431 linkstrlen = prop_data_size(data)+1; 1432 1433 linkstr = malloc(linkstrlen); 1434 if (linkstr == NULL) 1435 err(EXIT_FAILURE, "malloc linkstr space"); 1436 if (getargstr(env, "linkstr", linkstr, linkstrlen) == -1) 1437 errx(EXIT_FAILURE, "getargstr linkstr failed"); 1438 1439 ifdrv.ifd_cmd = 0; 1440 ifdrv.ifd_len = linkstrlen; 1441 ifdrv.ifd_data = __UNCONST(linkstr); 1442 1443 if (direct_ioctl(env, SIOCSLINKSTR, &ifdrv) == -1) 1444 err(EXIT_FAILURE, "SIOCSLINKSTR"); 1445 free(linkstr); 1446 1447 return 0; 1448 } 1449 1450 static int 1451 unsetlinkstr(prop_dictionary_t env, prop_dictionary_t oenv) 1452 { 1453 struct ifdrv ifdrv; 1454 1455 memset(&ifdrv, 0, sizeof(ifdrv)); 1456 ifdrv.ifd_cmd = IFLINKSTR_UNSET; 1457 1458 if (direct_ioctl(env, SIOCSLINKSTR, &ifdrv) == -1) 1459 err(EXIT_FAILURE, "SIOCSLINKSTR"); 1460 1461 return 0; 1462 } 1463 1464 static void 1465 usage(void) 1466 { 1467 const char *progname = getprogname(); 1468 usage_func_t *usage_f; 1469 prop_dictionary_t env; 1470 1471 if ((env = prop_dictionary_create()) == NULL) 1472 err(EXIT_FAILURE, "%s: prop_dictionary_create", __func__); 1473 1474 fprintf(stderr, "usage: %s [-h] %s[-v] [-z] %sinterface\n" 1475 "\t[ af [ address [ dest_addr ] ] [ netmask mask ] [ prefixlen n ]\n" 1476 "\t\t[ alias | -alias ] ]\n" 1477 "\t[ up ] [ down ] [ metric n ] [ mtu n ]\n", progname, 1478 flag_is_registered(gflags, 'm') ? "[-m] " : "", 1479 flag_is_registered(gflags, 'L') ? "[-L] " : ""); 1480 1481 SIMPLEQ_FOREACH(usage_f, &usage_funcs, f_next) 1482 (*usage_f->f_func)(env); 1483 1484 fprintf(stderr, 1485 "\t[ arp | -arp ]\n" 1486 "\t[ preference n ]\n" 1487 "\t[ link0 | -link0 ] [ link1 | -link1 ] [ link2 | -link2 ]\n" 1488 "\t[ linkstr str | -linkstr ]\n" 1489 " %s -a [-b] [-d] [-h] %s[-u] [-v] [-z] [ af ]\n" 1490 " %s -l [-b] [-d] [-s] [-u]\n" 1491 " %s -C\n" 1492 " %s -w n\n" 1493 " %s interface create\n" 1494 " %s interface destroy\n", 1495 progname, flag_is_registered(gflags, 'm') ? "[-m] " : "", 1496 progname, progname, progname, progname, progname); 1497 1498 prop_object_release((prop_object_t)env); 1499 exit(EXIT_FAILURE); 1500 } 1501
Indexes created Tue Oct 28 12:10:06 GMT 2025