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