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