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