1 /* $NetBSD: brconfig.c,v 1.18 2024/09/03 08:00:30 ozaki-r Exp $ */ 2 3 /* 4 * Copyright 2001 Wasabi Systems, Inc. 5 * All rights reserved. 6 * 7 * Written by Jason R. Thorpe for Wasabi Systems, Inc. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. All advertising materials mentioning features or use of this software 18 * must display the following acknowledgement: 19 * This product includes software developed for the NetBSD Project by 20 * Wasabi Systems, Inc. 21 * 4. The name of Wasabi Systems, Inc. may not be used to endorse 22 * or promote products derived from this software without specific prior 23 * written permission. 24 * 25 * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND 26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 27 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 28 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL WASABI SYSTEMS, INC 29 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 32 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 33 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 34 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 35 * POSSIBILITY OF SUCH DAMAGE. 36 */ 37 38 /* 39 * brconfig(8) -- 40 * 41 * Configuration utility for the bridge(4) driver. 42 */ 43 #include <sys/cdefs.h> 44 45 #ifndef lint 46 __RCSID("$NetBSD: brconfig.c,v 1.18 2024/09/03 08:00:30 ozaki-r Exp $"); 47 #endif 48 49 50 #include <sys/param.h> 51 #include <sys/socket.h> 52 #include <sys/ioctl.h> 53 54 #include <net/if.h> 55 #include <net/if_ether.h> 56 #include <net/if_bridgevar.h> 57 58 #include <ctype.h> 59 #include <err.h> 60 #include <errno.h> 61 #include <stdio.h> 62 #include <stdlib.h> 63 #include <string.h> 64 #include <unistd.h> 65 #include <ifaddrs.h> 66 67 struct command { 68 const char *cmd_keyword; 69 int cmd_argcnt; 70 int cmd_flags; 71 void (*cmd_func)(const struct command *, int, const char *, 72 char **); 73 }; 74 75 #define CMD_INVERT 0x01 /* "invert" the sense of the command */ 76 77 static void cmd_add(const struct command *, int, const char *, char **); 78 static void cmd_delete(const struct command *, int, const char *, char **); 79 static void cmd_up(const struct command *, int, const char *, char **); 80 static void cmd_down(const struct command *, int, const char *, char **); 81 static void cmd_discover(const struct command *, int, const char *, char **); 82 static void cmd_learn(const struct command *, int, const char *, char **); 83 static void cmd_flush(const struct command *, int, const char *, char **); 84 static void cmd_flushall(const struct command *, int, const char *, char **); 85 static void cmd_static(const struct command *, int, const char *, char **); 86 static void cmd_deladdr(const struct command *, int, const char *, char **); 87 static void cmd_addr(const struct command *, int, const char *, char **); 88 static void cmd_maxaddr(const struct command *, int, const char *, char **); 89 static void cmd_hellotime(const struct command *, int, const char *, char **); 90 static void cmd_fwddelay(const struct command *, int, const char *, char **); 91 static void cmd_maxage(const struct command *, int, const char *, char **); 92 static void cmd_priority(const struct command *, int, const char *, char **); 93 static void cmd_ifpriority(const struct command *, int, const char *, char **); 94 static void cmd_ifpathcost(const struct command *, int, const char *, char **); 95 static void cmd_timeout(const struct command *, int, const char *, char **); 96 static void cmd_stp(const struct command *, int, const char *, char **); 97 static void cmd_ipf(const struct command *, int, const char *, char **); 98 static void cmd_protect(const struct command *, int, const char *, char **); 99 100 static const struct command command_table[] = { 101 { "add", 1, 0, cmd_add }, 102 { "delete", 1, 0, cmd_delete }, 103 104 { "up", 0, 0, cmd_up }, 105 { "down", 0, 0, cmd_down }, 106 107 { "discover", 1, 0, cmd_discover }, 108 { "-discover", 1, CMD_INVERT, cmd_discover }, 109 110 { "learn", 1, 0, cmd_learn }, 111 { "-learn", 1, CMD_INVERT, cmd_learn }, 112 113 { "flush", 0, 0, cmd_flush }, 114 { "flushall", 0, 0, cmd_flushall }, 115 116 { "static", 2, 0, cmd_static }, 117 { "deladdr", 1, 0, cmd_deladdr }, 118 119 { "addr", 0, 0, cmd_addr }, 120 { "maxaddr", 1, 0, cmd_maxaddr }, 121 122 { "hellotime", 1, 0, cmd_hellotime }, 123 { "fwddelay", 1, 0, cmd_fwddelay }, 124 { "maxage", 1, 0, cmd_maxage }, 125 { "priority", 1, 0, cmd_priority }, 126 { "ifpriority", 2, 0, cmd_ifpriority }, 127 { "ifpathcost", 2, 0, cmd_ifpathcost }, 128 { "timeout", 1, 0, cmd_timeout }, 129 { "stp", 1, 0, cmd_stp }, 130 { "-stp", 1, CMD_INVERT, cmd_stp }, 131 132 { "ipf", 0, 0, cmd_ipf }, 133 { "-ipf", 0, CMD_INVERT, cmd_ipf }, 134 135 { "protect", 1, 0, cmd_protect }, 136 { "-protect", 1, CMD_INVERT, cmd_protect }, 137 138 { NULL, 0, 0, NULL }, 139 }; 140 141 static void printall(int); 142 static void status(int, const char *); 143 static int is_bridge(const char *); 144 static void show_config(int, const char *, const char *); 145 static void show_interfaces(int, const char *, const char *); 146 static void show_addresses(int, const char *, const char *); 147 static int get_val(const char *, u_long *); 148 #define do_cmd(a,b,c,d,e,f) do_cmd2((a),(b),(c),(d),(e),NULL,(f)) 149 static int do_cmd2(int, const char *, u_long, void *, size_t, size_t *, int); 150 static void do_ifflag(int, const char *, int, int); 151 static void do_bridgeflag(int, const char *, const char *, int, int); 152 153 static void printb(const char *, u_int, const char *); 154 155 __dead static void usage(void); 156 157 static int aflag; 158 159 static struct ifreq g_ifr; 160 static int g_ifr_updated; 161 162 int 163 main(int argc, char *argv[]) 164 { 165 const struct command *cmd; 166 char *bridge; 167 int sock, ch; 168 169 if (argc < 2) 170 usage(); 171 172 sock = socket(AF_INET, SOCK_DGRAM, 0); 173 if (sock < 0) 174 err(1, "socket"); 175 176 while ((ch = getopt(argc, argv, "a")) != -1) { 177 switch (ch) { 178 case 'a': 179 aflag = 1; 180 break; 181 182 default: 183 usage(); 184 } 185 } 186 187 argc -= optind; 188 argv += optind; 189 190 if (aflag) { 191 if (argc != 0) 192 usage(); 193 printall(sock); 194 exit(0); 195 } 196 197 if (argc == 0) 198 usage(); 199 200 bridge = argv[0]; 201 202 if (is_bridge(bridge) == 0) 203 errx(1, "%s is not a bridge", bridge); 204 205 /* Get a copy of the interface flags. */ 206 strlcpy(g_ifr.ifr_name, bridge, sizeof(g_ifr.ifr_name)); 207 if (ioctl(sock, SIOCGIFFLAGS, &g_ifr) < 0) 208 err(1, "unable to get interface flags"); 209 210 argc--; 211 argv++; 212 213 if (argc == 0) { 214 status(sock, bridge); 215 exit(0); 216 } 217 218 while (argc != 0) { 219 for (cmd = command_table; cmd->cmd_keyword != NULL; cmd++) { 220 if (strcmp(cmd->cmd_keyword, argv[0]) == 0) 221 break; 222 } 223 if (cmd->cmd_keyword == NULL) 224 errx(1, "unknown command: %s", argv[0]); 225 226 argc--; 227 argv++; 228 229 if (argc < cmd->cmd_argcnt) 230 errx(1, "command %s requires %d argument%s", 231 cmd->cmd_keyword, cmd->cmd_argcnt, 232 cmd->cmd_argcnt == 1 ? "" : "s"); 233 234 (*cmd->cmd_func)(cmd, sock, bridge, argv); 235 236 argc -= cmd->cmd_argcnt; 237 argv += cmd->cmd_argcnt; 238 } 239 240 /* If the flags changed, update them. */ 241 if (g_ifr_updated && ioctl(sock, SIOCSIFFLAGS, &g_ifr) < 0) 242 err(1, "unable to set interface flags"); 243 244 exit (0); 245 } 246 247 static void 248 usage(void) 249 { 250 static const char *usage_strings[] = { 251 "-a", 252 "<bridge>", 253 "<bridge> up|down", 254 "<bridge> addr", 255 "<bridge> add <interface>", 256 "<bridge> delete <interface>", 257 "<bridge> maxaddr <size>", 258 "<bridge> timeout <time>", 259 "<bridge> static <interface> <address>", 260 "<bridge> deladdr <address>", 261 "<bridge> flush", 262 "<bridge> flushall", 263 "<bridge> ipf|-ipf", 264 "<bridge> discover|-discover <interface>", 265 "<bridge> learn|-learn <interface>", 266 "<bridge> stp|-stp <interface>", 267 "<bridge> maxage <time>", 268 "<bridge> fwddelay <time>", 269 "<bridge> hellotime <time>", 270 "<bridge> priority <value>", 271 "<bridge> ifpriority <interface> <value>", 272 "<bridge> ifpathcost <interface> <value>", 273 NULL, 274 }; 275 extern const char *__progname; 276 int i; 277 278 for (i = 0; usage_strings[i] != NULL; i++) 279 fprintf(stderr, "%s %s %s\n", 280 i == 0 ? "usage:" : " ", 281 __progname, usage_strings[i]); 282 283 exit(1); 284 } 285 286 static int 287 is_bridge(const char *bridge) 288 { 289 290 if (strncmp(bridge, "bridge", 6) != 0 || 291 isdigit((unsigned char)bridge[6]) == 0) 292 return (0); 293 294 return (1); 295 } 296 297 static void 298 printb(const char *s, u_int v, const char *bits) 299 { 300 int i, any = 0; 301 char c; 302 303 if (bits && *bits == 8) 304 printf("%s=%o", s, v); 305 else 306 printf("%s=%x", s, v); 307 if (bits) { 308 bits++; 309 putchar('<'); 310 while ((i = *bits++) != 0) { 311 if (v & (1 << (i-1))) { 312 if (any) 313 putchar(','); 314 any = 1; 315 for (; (c = *bits) > 32; bits++) 316 putchar(c); 317 } else 318 for (; *bits > 32; bits++) 319 ; 320 } 321 putchar('>'); 322 } 323 } 324 325 static void 326 printall(int sock) 327 { 328 struct ifaddrs *ifap, *ifa; 329 char *p; 330 331 if (getifaddrs(&ifap) != 0) 332 err(1, "getifaddrs"); 333 p = NULL; 334 for (ifa = ifap; ifa != NULL; ifa = ifa->ifa_next) { 335 if (is_bridge(ifa->ifa_name) == 0) 336 continue; 337 if (p != NULL && strcmp(p, ifa->ifa_name) == 0) 338 continue; 339 p = ifa->ifa_name; 340 status(sock, ifa->ifa_name); 341 } 342 343 freeifaddrs(ifap); 344 } 345 346 static void 347 status(int sock, const char *bridge) 348 { 349 struct ifreq ifr; 350 struct ifbrparam bp1, bp2; 351 352 memset(&ifr, 0, sizeof(ifr)); 353 354 strlcpy(ifr.ifr_name, bridge, sizeof(ifr.ifr_name)); 355 if (ioctl(sock, SIOCGIFFLAGS, &ifr) < 0) 356 err(1, "unable to get flags"); 357 358 printf("%s: ", bridge); 359 printb("flags", ifr.ifr_flags, IFFBITS); 360 printf("\n"); 361 362 printf("\tConfiguration:\n"); 363 show_config(sock, bridge, "\t\t"); 364 365 printf("\tInterfaces:\n"); 366 show_interfaces(sock, bridge, "\t\t"); 367 368 if (do_cmd(sock, bridge, BRDGGCACHE, &bp1, sizeof(bp1), 0) < 0) 369 err(1, "unable to get address cache size"); 370 if (do_cmd(sock, bridge, BRDGGTO, &bp2, sizeof(bp2), 0) < 0) 371 err(1, "unable to get address timeout"); 372 373 printf("\tAddress cache (max cache: %u, timeout: %u):\n", 374 bp1.ifbrp_csize, bp2.ifbrp_ctime); 375 show_addresses(sock, bridge, "\t\t"); 376 } 377 378 static void 379 show_config(int sock, const char *bridge, const char *prefix) 380 { 381 struct ifbrparam param; 382 u_int32_t ipfflags; 383 u_int16_t pri; 384 u_int8_t ht, fd, ma; 385 386 if (do_cmd(sock, bridge, BRDGGPRI, ¶m, sizeof(param), 0) < 0) 387 err(1, "unable to get bridge priority"); 388 pri = param.ifbrp_prio; 389 390 if (do_cmd(sock, bridge, BRDGGHT, ¶m, sizeof(param), 0) < 0) 391 err(1, "unable to get hellotime"); 392 ht = param.ifbrp_hellotime; 393 394 if (do_cmd(sock, bridge, BRDGGFD, ¶m, sizeof(param), 0) < 0) 395 err(1, "unable to get forward delay"); 396 fd = param.ifbrp_fwddelay; 397 398 if (do_cmd(sock, bridge, BRDGGMA, ¶m, sizeof(param), 0) < 0) 399 err(1, "unable to get max age"); 400 ma = param.ifbrp_maxage; 401 402 printf("%spriority %u hellotime %u fwddelay %u maxage %u\n", 403 prefix, pri, ht, fd, ma); 404 405 if (do_cmd(sock, bridge, BRDGGFILT, ¶m, sizeof(param), 0) < 0) { 406 /* err(1, "unable to get ipfilter status"); */ 407 param.ifbrp_filter = 0; 408 } 409 410 ipfflags = param.ifbrp_filter; 411 printf("%sipfilter %s flags 0x%x\n", prefix, 412 (ipfflags & IFBF_FILT_USEIPF) ? "enabled" : "disabled", 413 ipfflags); 414 } 415 416 static void 417 show_interfaces(int sock, const char *bridge, const char *prefix) 418 { 419 static const char stpstates[][11] = { 420 "disabled", 421 "listening", 422 "learning", 423 "forwarding", 424 "blocking", 425 }; 426 struct ifbreq *req; 427 char *inbuf = NULL, *ninbuf; 428 size_t len = 8192, nlen; 429 430 do { 431 nlen = len; 432 ninbuf = realloc(inbuf, nlen); 433 if (ninbuf == NULL) 434 err(1, "unable to allocate interface buffer"); 435 inbuf = ninbuf; 436 if (do_cmd2(sock, bridge, BRDGGIFS, inbuf, nlen, &len, 0) < 0) 437 err(1, "unable to get interface list"); 438 } while (len > nlen); 439 440 for (size_t i = 0; i < len / sizeof(*req); i++) { 441 req = (struct ifbreq *)inbuf + i; 442 printf("%s%s ", prefix, req->ifbr_ifsname); 443 printb("flags", req->ifbr_ifsflags, IFBIFBITS); 444 printf("\n"); 445 printf("%s\t", prefix); 446 printf("port %u priority %u", 447 req->ifbr_portno, req->ifbr_priority); 448 if (req->ifbr_ifsflags & IFBIF_STP) { 449 printf(" path cost %u", req->ifbr_path_cost); 450 if (req->ifbr_state < 451 sizeof(stpstates) / sizeof(stpstates[0])) 452 printf(" %s", stpstates[req->ifbr_state]); 453 else 454 printf(" <unknown state %d>", 455 req->ifbr_state); 456 } 457 printf("\n"); 458 } 459 460 free(inbuf); 461 } 462 463 static void 464 show_addresses(int sock, const char *bridge, const char *prefix) 465 { 466 struct ifbareq *ifba; 467 char *inbuf = NULL, *ninbuf; 468 struct ether_addr ea; 469 size_t len = 8192, nlen; 470 471 do { 472 nlen = len; 473 ninbuf = realloc(inbuf, nlen); 474 if (ninbuf == NULL) 475 err(1, "unable to allocate address buffer"); 476 inbuf = ninbuf; 477 if (do_cmd2(sock, bridge, BRDGRTS, inbuf, nlen, &len, 0) < 0) 478 err(1, "unable to get address cache"); 479 } while (len > nlen); 480 481 for (size_t i = 0; i < len / sizeof(*ifba); i++) { 482 ifba = (struct ifbareq *)inbuf + i; 483 memcpy(ea.ether_addr_octet, ifba->ifba_dst, 484 sizeof(ea.ether_addr_octet)); 485 printf("%s%s %s %jd ", prefix, ether_ntoa(&ea), 486 ifba->ifba_ifsname, (uintmax_t)ifba->ifba_expire); 487 printb("flags", ifba->ifba_flags, IFBAFBITS); 488 printf("\n"); 489 } 490 491 free(inbuf); 492 } 493 494 static int 495 get_val(const char *cp, u_long *valp) 496 { 497 char *endptr; 498 u_long val; 499 500 errno = 0; 501 val = strtoul(cp, &endptr, 0); 502 if (cp[0] == '\0' || endptr[0] != '\0' || errno == ERANGE) 503 return (-1); 504 505 *valp = val; 506 return (0); 507 } 508 509 static int 510 do_cmd2(int sock, const char *bridge, u_long op, void *arg, size_t argsize, 511 size_t *outsizep, int set) 512 { 513 struct ifdrv ifd; 514 int error; 515 516 memset(&ifd, 0, sizeof(ifd)); 517 518 strlcpy(ifd.ifd_name, bridge, sizeof(ifd.ifd_name)); 519 ifd.ifd_cmd = op; 520 ifd.ifd_len = argsize; 521 ifd.ifd_data = arg; 522 523 error = ioctl(sock, set ? SIOCSDRVSPEC : SIOCGDRVSPEC, &ifd); 524 525 if (outsizep) 526 *outsizep = ifd.ifd_len; 527 528 return error; 529 } 530 531 static void 532 do_ifflag(int sock, const char *bridge, int flag, int set) 533 { 534 535 if (set) 536 g_ifr.ifr_flags |= flag; 537 else 538 g_ifr.ifr_flags &= ~flag; 539 540 g_ifr_updated = 1; 541 } 542 543 static void 544 do_bridgeflag(int sock, const char *bridge, const char *ifs, int flag, 545 int set) 546 { 547 struct ifbreq req; 548 549 strlcpy(req.ifbr_ifsname, ifs, sizeof(req.ifbr_ifsname)); 550 551 if (do_cmd(sock, bridge, BRDGGIFFLGS, &req, sizeof(req), 0) < 0) 552 err(1, "unable to get bridge flags"); 553 554 if (set) 555 req.ifbr_ifsflags |= flag; 556 else 557 req.ifbr_ifsflags &= ~flag; 558 559 if (do_cmd(sock, bridge, BRDGSIFFLGS, &req, sizeof(req), 1) < 0) 560 err(1, "unable to set bridge flags"); 561 } 562 563 static void 564 cmd_add(const struct command *cmd, int sock, const char *bridge, 565 char **argv) 566 { 567 struct ifbreq req; 568 569 memset(&req, 0, sizeof(req)); 570 571 strlcpy(req.ifbr_ifsname, argv[0], sizeof(req.ifbr_ifsname)); 572 if (do_cmd(sock, bridge, BRDGADD, &req, sizeof(req), 1) < 0) 573 err(1, "%s %s", cmd->cmd_keyword, argv[0]); 574 } 575 576 static void 577 cmd_delete(const struct command *cmd, int sock, const char *bridge, 578 char **argv) 579 { 580 struct ifbreq req; 581 582 memset(&req, 0, sizeof(req)); 583 strlcpy(req.ifbr_ifsname, argv[0], sizeof(req.ifbr_ifsname)); 584 if (do_cmd(sock, bridge, BRDGDEL, &req, sizeof(req), 1) < 0) 585 err(1, "%s %s", cmd->cmd_keyword, argv[0]); 586 } 587 588 static void 589 cmd_up(const struct command *cmd, int sock, const char *bridge, 590 char **argv) 591 { 592 593 do_ifflag(sock, bridge, IFF_UP, 1); 594 } 595 596 static void 597 cmd_down(const struct command *cmd, int sock, const char *bridge, 598 char **argv) 599 { 600 601 do_ifflag(sock, bridge, IFF_UP, 0); 602 } 603 604 static void 605 cmd_discover(const struct command *cmd, int sock, const char *bridge, 606 char **argv) 607 { 608 609 do_bridgeflag(sock, bridge, argv[0], IFBIF_DISCOVER, 610 (cmd->cmd_flags & CMD_INVERT) ? 0 : 1); 611 } 612 613 static void 614 cmd_learn(const struct command *cmd, int sock, const char *bridge, 615 char **argv) 616 { 617 618 do_bridgeflag(sock, bridge, argv[0], IFBIF_LEARNING, 619 (cmd->cmd_flags & CMD_INVERT) ? 0 : 1); 620 } 621 622 static void 623 cmd_stp(const struct command *cmd, int sock, const char *bridge, 624 char **argv) 625 { 626 627 do_bridgeflag(sock, bridge, argv[0], IFBIF_STP, 628 (cmd->cmd_flags & CMD_INVERT) ? 0 : 1); 629 } 630 631 static void 632 cmd_protect(const struct command *cmd, int sock, const char *bridge, 633 char **argv) 634 { 635 636 do_bridgeflag(sock, bridge, argv[0], IFBIF_PROTECTED, 637 (cmd->cmd_flags & CMD_INVERT) ? 0 : 1); 638 } 639 640 static void 641 cmd_flush(const struct command *cmd, int sock, const char *bridge, 642 char **argv) 643 { 644 struct ifbreq req; 645 646 memset(&req, 0, sizeof(req)); 647 req.ifbr_ifsflags = IFBF_FLUSHDYN; 648 if (do_cmd(sock, bridge, BRDGFLUSH, &req, sizeof(req), 1) < 0) 649 err(1, "%s", cmd->cmd_keyword); 650 } 651 652 static void 653 cmd_flushall(const struct command *cmd, int sock, const char *bridge, 654 char **argv) 655 { 656 struct ifbreq req; 657 658 memset(&req, 0, sizeof(req)); 659 req.ifbr_ifsflags = IFBF_FLUSHALL; 660 if (do_cmd(sock, bridge, BRDGFLUSH, &req, sizeof(req), 1) < 0) 661 err(1, "%s", cmd->cmd_keyword); 662 } 663 664 static void 665 cmd_static(const struct command *cmd, int sock, const char *bridge, 666 char **argv) 667 { 668 struct ifbareq req; 669 struct ether_addr *ea; 670 671 memset(&req, 0, sizeof(req)); 672 strlcpy(req.ifba_ifsname, argv[0], sizeof(req.ifba_ifsname)); 673 674 ea = ether_aton(argv[1]); 675 if (ea == NULL) 676 errx(1, "%s: invalid address: %s", cmd->cmd_keyword, argv[1]); 677 678 memcpy(req.ifba_dst, ea->ether_addr_octet, sizeof(req.ifba_dst)); 679 req.ifba_flags = IFBAF_STATIC; 680 681 if (do_cmd(sock, bridge, BRDGSADDR, &req, sizeof(req), 1) < 0) 682 err(1, "%s %s %s", cmd->cmd_keyword, argv[0], argv[1]); 683 } 684 685 static void 686 cmd_deladdr(const struct command *cmd, int sock, const char *bridge, 687 char **argv) 688 { 689 struct ifbareq req; 690 struct ether_addr *ea; 691 692 memset(&req, 0, sizeof(req)); 693 694 ea = ether_aton(argv[0]); 695 if (ea == NULL) 696 errx(1, "%s: invalid address: %s", cmd->cmd_keyword, argv[0]); 697 698 memcpy(req.ifba_dst, ea->ether_addr_octet, sizeof(req.ifba_dst)); 699 700 if (do_cmd(sock, bridge, BRDGDADDR, &req, sizeof(req), 1) < 0) 701 err(1, "%s %s", cmd->cmd_keyword, argv[0]); 702 } 703 704 static void 705 cmd_addr(const struct command *cmd, int sock, const char *bridge, 706 char **argv) 707 { 708 709 show_addresses(sock, bridge, "\t"); 710 } 711 712 static void 713 cmd_maxaddr(const struct command *cmd, int sock, const char *bridge, 714 char **argv) 715 { 716 struct ifbrparam param; 717 u_long val; 718 719 if (get_val(argv[0], &val) < 0 || (val & ~0xffffffff) != 0) 720 errx(1, "%s: invalid value: %s", cmd->cmd_keyword, argv[0]); 721 722 param.ifbrp_csize = val & 0xffffffff; 723 724 if (do_cmd(sock, bridge, BRDGSCACHE, ¶m, sizeof(param), 1) < 0) 725 err(1, "%s %s", cmd->cmd_keyword, argv[0]); 726 } 727 728 static void 729 cmd_hellotime(const struct command *cmd, int sock, const char *bridge, 730 char **argv) 731 { 732 struct ifbrparam param; 733 u_long val; 734 735 if (get_val(argv[0], &val) < 0 || (val & ~0xff) != 0) 736 errx(1, "%s: invalid value: %s", cmd->cmd_keyword, argv[0]); 737 738 param.ifbrp_hellotime = val & 0xff; 739 740 if (do_cmd(sock, bridge, BRDGSHT, ¶m, sizeof(param), 1) < 0) 741 err(1, "%s %s", cmd->cmd_keyword, argv[0]); 742 } 743 744 static void 745 cmd_fwddelay(const struct command *cmd, int sock, const char *bridge, 746 char **argv) 747 { 748 struct ifbrparam param; 749 u_long val; 750 751 if (get_val(argv[0], &val) < 0 || (val & ~0xff) != 0) 752 errx(1, "%s: invalid value: %s", cmd->cmd_keyword, argv[0]); 753 754 param.ifbrp_fwddelay = val & 0xff; 755 756 if (do_cmd(sock, bridge, BRDGSFD, ¶m, sizeof(param), 1) < 0) 757 err(1, "%s %s", cmd->cmd_keyword, argv[0]); 758 } 759 760 static void 761 cmd_maxage(const struct command *cmd, int sock, const char *bridge, 762 char **argv) 763 { 764 struct ifbrparam param; 765 u_long val; 766 767 if (get_val(argv[0], &val) < 0 || (val & ~0xff) != 0) 768 errx(1, "%s: invalid value: %s", cmd->cmd_keyword, argv[0]); 769 770 param.ifbrp_maxage = val & 0xff; 771 772 if (do_cmd(sock, bridge, BRDGSMA, ¶m, sizeof(param), 1) < 0) 773 err(1, "%s %s", cmd->cmd_keyword, argv[0]); 774 } 775 776 static void 777 cmd_priority(const struct command *cmd, int sock, const char *bridge, 778 char **argv) 779 { 780 struct ifbrparam param; 781 u_long val; 782 783 if (get_val(argv[0], &val) < 0 || (val & ~0xffff) != 0) 784 errx(1, "%s: invalid value: %s", cmd->cmd_keyword, argv[0]); 785 786 param.ifbrp_prio = val & 0xffff; 787 788 if (do_cmd(sock, bridge, BRDGSPRI, ¶m, sizeof(param), 1) < 0) 789 err(1, "%s %s", cmd->cmd_keyword, argv[0]); 790 } 791 792 static void 793 cmd_ifpriority(const struct command *cmd, int sock, const char *bridge, 794 char **argv) 795 { 796 struct ifbreq req; 797 u_long val; 798 799 memset(&req, 0, sizeof(req)); 800 801 if (get_val(argv[1], &val) < 0 || (val & ~0xff) != 0) 802 errx(1, "%s: invalid value: %s", cmd->cmd_keyword, argv[1]); 803 804 strlcpy(req.ifbr_ifsname, argv[0], sizeof(req.ifbr_ifsname)); 805 req.ifbr_priority = val & 0xff; 806 807 if (do_cmd(sock, bridge, BRDGSIFPRIO, &req, sizeof(req), 1) < 0) 808 err(1, "%s %s", cmd->cmd_keyword, argv[0]); 809 } 810 811 static void 812 cmd_ifpathcost(const struct command *cmd, int sock, const char *bridge, 813 char **argv) 814 { 815 struct ifbreq req; 816 u_long val; 817 818 memset(&req, 0, sizeof(req)); 819 820 if (get_val(argv[1], &val) < 0 || (val & ~0xff) != 0) 821 errx(1, "%s: invalid value: %s", cmd->cmd_keyword, argv[1]); 822 823 strlcpy(req.ifbr_ifsname, argv[0], sizeof(req.ifbr_ifsname)); 824 req.ifbr_path_cost = val & 0xffff; 825 826 if (do_cmd(sock, bridge, BRDGSIFCOST, &req, sizeof(req), 1) < 0) 827 err(1, "%s %s", cmd->cmd_keyword, argv[0]); 828 } 829 830 static void 831 cmd_timeout(const struct command *cmd, int sock, const char *bridge, 832 char **argv) 833 { 834 struct ifbrparam param; 835 u_long val; 836 837 if (get_val(argv[0], &val) < 0 || (val & ~0xffffffff) != 0) 838 errx(1, "%s: invalid value: %s", cmd->cmd_keyword, argv[0]); 839 840 param.ifbrp_ctime = val & 0xffffffff; 841 842 if (do_cmd(sock, bridge, BRDGSTO, ¶m, sizeof(param), 1) < 0) 843 err(1, "%s %s", cmd->cmd_keyword, argv[0]); 844 } 845 846 static void 847 cmd_ipf(const struct command *cmd, int sock, const char *bridge, 848 char **argv) 849 { 850 struct ifbrparam param; 851 852 if (do_cmd(sock, bridge, BRDGGFILT, ¶m, sizeof(param), 0) < 0) 853 err(1, "%s", cmd->cmd_keyword); 854 855 param.ifbrp_filter &= ~IFBF_FILT_USEIPF; 856 param.ifbrp_filter |= (cmd->cmd_flags & CMD_INVERT) ? 0 : IFBF_FILT_USEIPF; 857 if (do_cmd(sock, bridge, BRDGSFILT, ¶m, sizeof(param), 1) < 0) 858 err(1, "%s %x", cmd->cmd_keyword, param.ifbrp_filter); 859 } 860