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