sbin/brconfig/brconfig.c

   1 /*
   2  * Copyright 2001 Wasabi Systems, Inc.
   3  * All rights reserved.
   4  *
   5  * Written by Jason R. Thorpe for Wasabi Systems, Inc.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. All advertising materials mentioning features or use of this software
  16  *    must display the following acknowledgement:
  17  *      This product includes software developed for the NetBSD Project by
  18  *      Wasabi Systems, Inc.
  19  * 4. The name of Wasabi Systems, Inc. may not be used to endorse
  20  *    or promote products derived from this software without specific prior
  21  *    written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  25  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  26  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL WASABI SYSTEMS, INC
  27  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  28  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  29  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  30  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  31  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  32  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  33  * POSSIBILITY OF SUCH DAMAGE.
  34  *
  35  * $NetBSD: brconfig.c,v 1.7 2003/09/19 08:39:09 itojun Exp $
  36  * $DragonFly: src/sbin/brconfig/Attic/brconfig.c,v 1.1 2005/12/21 16:33:20 corecode Exp $
  37  *
  38  */
  39
  40 /*
  41  * brconfig(8) --
  42  *
  43  *      Configuration utility for the bridge(4) driver.
  44  */
  45 #include <sys/cdefs.h>
  46
  47 #include <sys/param.h>
  48 #include <sys/socket.h>
  49 #include <sys/ioctl.h>
  50
  51 #include <net/if.h>
  52 #include <net/if_dl.h>
  53 #include <net/if_types.h>
  54 #include <net/if_var.h>
  55 #include <netinet/in.h> /* for struct arpcom */
  56 #include <netinet/in_systm.h>
  57 #include <netinet/in_var.h>
  58 #include <netinet/ip.h>
  59 #include <net/if.h>
  60 #include <netinet/if_ether.h>
  61 #include <net/bridge/if_bridgevar.h>
  62
  63 #include <ctype.h>
  64 #include <err.h>
  65 #include <errno.h>
  66 #include <stdio.h>
  67 #include <stdlib.h>
  68 #include <string.h>
  69 #include <unistd.h>
  70 #include <ifaddrs.h>
  71
  72 struct command {
  73         const char *cmd_keyword;
  74         int     cmd_argcnt;
  75         int     cmd_flags;
  76         void    (*cmd_func)(const struct command *, int, const char *,
  77                     char **);
  78 };
  79
  80 #define CMD_INVERT      0x01    /* "invert" the sense of the command */
  81
  82 void    cmd_add(const struct command *, int, const char *, char **);
  83 void    cmd_delete(const struct command *, int, const char *, char **);
  84 void    cmd_up(const struct command *, int, const char *, char **);
  85 void    cmd_down(const struct command *, int, const char *, char **);
  86 void    cmd_discover(const struct command *, int, const char *, char **);
  87 void    cmd_learn(const struct command *, int, const char *, char **);
  88 void    cmd_flush(const struct command *, int, const char *, char **);
  89 void    cmd_flushall(const struct command *, int, const char *, char **);
  90 void    cmd_static(const struct command *, int, const char *, char **);
  91 void    cmd_deladdr(const struct command *, int, const char *, char **);
  92 void    cmd_addr(const struct command *, int, const char *, char **);
  93 void    cmd_maxaddr(const struct command *, int, const char *, char **);
  94 void    cmd_hellotime(const struct command *, int, const char *, char **);
  95 void    cmd_fwddelay(const struct command *, int, const char *, char **);
  96 void    cmd_maxage(const struct command *, int, const char *, char **);
  97 void    cmd_priority(const struct command *, int, const char *, char **);
  98 void    cmd_ifpriority(const struct command *, int, const char *, char **);
  99 void    cmd_ifpathcost(const struct command *, int, const char *, char **);
 100 void    cmd_timeout(const struct command *, int, const char *, char **);
 101 void    cmd_stp(const struct command *, int, const char *, char **);
 102
 103 const struct command command_table[] = {
 104         { "add",                1,      0,              cmd_add },
 105         { "delete",             1,      0,              cmd_delete },
 106
 107         { "up",                 0,      0,              cmd_up },
 108         { "down",               0,      0,              cmd_down },
 109
 110         { "discover",           1,      0,              cmd_discover },
 111         { "-discover",          1,      CMD_INVERT,     cmd_discover },
 112
 113         { "learn",              1,      0,              cmd_learn },
 114         { "-learn",             1,      CMD_INVERT,     cmd_learn },
 115
 116         { "flush",              0,      0,              cmd_flush },
 117         { "flushall",           0,      0,              cmd_flushall },
 118
 119         { "static",             2,      0,              cmd_static },
 120         { "deladdr",            1,      0,              cmd_deladdr },
 121
 122         { "addr",               0,      0,              cmd_addr },
 123         { "maxaddr",            1,      0,              cmd_maxaddr },
 124
 125         { "hellotime",          1,      0,              cmd_hellotime },
 126         { "fwddelay",           1,      0,              cmd_fwddelay },
 127         { "maxage",             1,      0,              cmd_maxage },
 128         { "priority",           1,      0,              cmd_priority },
 129         { "ifpriority",         2,      0,              cmd_ifpriority },
 130         { "ifpathcost",         2,      0,              cmd_ifpathcost },
 131         { "timeout",            1,      0,              cmd_timeout },
 132         { "stp",                1,      0,              cmd_stp },
 133         { "-stp",               1,      CMD_INVERT,     cmd_stp },
 134
 135         { NULL,                 0,      0,              NULL },
 136 };
 137
 138 void    printall(int);
 139 void    status(int, const char *);
 140 int     is_bridge(const char *);
 141 void    show_config(int, const char *, const char *);
 142 void    show_interfaces(int, const char *, const char *);
 143 void    show_addresses(int, const char *, const char *);
 144 int     get_val(const char *, u_long *);
 145 int     do_cmd(int, const char *, u_long, void *, size_t, int);
 146 void    do_ifflag(int, const char *, int, int);
 147 void    do_bridgeflag(int, const char *, const char *, int, int);
 148
 149 void    printb(const char *, u_int, const char *);
 150
 151 int     main(int, char *[]);
 152 void    usage(void);
 153
 154 int     aflag;
 155
 156 struct ifreq g_ifr;
 157 int     g_ifr_updated;
 158
 159 #define IFFBITS \
 160 "\020\1UP\2BROADCAST\3DEBUG\4LOOPBACK\5POINTOPOINT\6NOTRAILERS\7RUNNING\10NOARP\
 161 \11PROMISC\12ALLMULTI\13OACTIVE\14SIMPLEX\15LINK0\16LINK1\17LINK2\20MULTICAST"
 162
 163 int
 164 main(int argc, char *argv[])
 165 {
 166         const struct command *cmd;
 167         char *bridge;
 168         int sock, ch;
 169
 170         if (argc < 2)
 171                 usage();
 172
 173         sock = socket(AF_INET, SOCK_DGRAM, 0);
 174         if (sock < 0)
 175                 err(1, "socket");
 176
 177         while ((ch = getopt(argc, argv, "a")) != -1) {
 178                 switch (ch) {
 179                 case 'a':
 180                         aflag = 1;
 181                         break;
 182
 183                 default:
 184                         usage();
 185                 }
 186         }
 187
 188         argc -= optind;
 189         argv += optind;
 190
 191         if (aflag) {
 192                 if (argc != 0)
 193                         usage();
 194                 printall(sock);
 195                 exit(0);
 196         }
 197
 198         if (argc == 0)
 199                 usage();
 200
 201         bridge = argv[0];
 202
 203         if (is_bridge(bridge) == 0)
 204                 errx(1, "%s is not a bridge", bridge);
 205
 206         /* Get a copy of the interface flags. */
 207         strlcpy(g_ifr.ifr_name, bridge, sizeof(g_ifr.ifr_name));
 208         if (ioctl(sock, SIOCGIFFLAGS, &g_ifr) < 0)
 209                 err(1, "unable to get interface flags");
 210
 211         argc--;
 212         argv++;
 213
 214         if (argc == 0) {
 215                 status(sock, bridge);
 216                 exit(0);
 217         }
 218
 219         while (argc != 0) {
 220                 for (cmd = command_table; cmd->cmd_keyword != NULL; cmd++) {
 221                         if (strcmp(cmd->cmd_keyword, argv[0]) == 0)
 222                                 break;
 223                 }
 224                 if (cmd->cmd_keyword == NULL)
 225                         errx(1, "unknown command: %s", argv[0]);
 226
 227                 argc--;
 228                 argv++;
 229
 230                 if (argc < cmd->cmd_argcnt)
 231                         errx(1, "command %s requires %d argument%s",
 232                             cmd->cmd_keyword, cmd->cmd_argcnt,
 233                             cmd->cmd_argcnt == 1 ? "" : "s");
 234
 235                 (*cmd->cmd_func)(cmd, sock, bridge, argv);
 236
 237                 argc -= cmd->cmd_argcnt;
 238                 argv += cmd->cmd_argcnt;
 239         }
 240
 241         /* If the flags changed, update them. */
 242         if (g_ifr_updated && ioctl(sock, SIOCSIFFLAGS, &g_ifr) < 0)
 243                 err(1, "unable to set interface flags");
 244
 245         exit (0);
 246 }
 247
 248 void
 249 usage(void)
 250 {
 251         static const char *usage_strings[] = {
 252                 "-a",
 253                 "<bridge>",
 254                 "<bridge> up|down",
 255                 "<bridge> addr",
 256                 "<bridge> add <interface>",
 257                 "<bridge> delete <interface>",
 258                 "<bridge> maxaddr <size>",
 259                 "<bridge> timeout <time>",
 260                 "<bridge> static <interface> <address>",
 261                 "<bridge> deladdr <address>",
 262                 "<bridge> flush",
 263                 "<bridge> flushall",
 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 int
 287 is_bridge(const char *bridge)
 288 {
 289
 290         if (strncmp(bridge, "bridge", 6) != 0 ||
 291             isdigit(bridge[6]) == 0)
 292                 return (0);
 293
 294         return (1);
 295 }
 296
 297 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         bits++;
 308         if (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 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 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 void
 379 show_config(int sock, const char *bridge, const char *prefix)
 380 {
 381         struct ifbrparam param;
 382         u_int16_t pri;
 383         u_int8_t ht, fd, ma;
 384
 385         if (do_cmd(sock, bridge, BRDGGPRI, &param, 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, &param, sizeof(param), 0) < 0)
 390                 err(1, "unable to get hellotime");
 391         ht = param.ifbrp_hellotime;
 392
 393         if (do_cmd(sock, bridge, BRDGGFD, &param, 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, &param, 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
 405 void
 406 show_interfaces(int sock, const char *bridge, const char *prefix)
 407 {
 408         static const char *stpstates[] = {
 409                 "disabled",
 410                 "listening",
 411                 "learning",
 412                 "forwarding",
 413                 "blocking",
 414         };
 415         struct ifbifconf bifc;
 416         struct ifbreq *req;
 417         char *inbuf = NULL, *ninbuf;
 418         int i, len = 8192;
 419
 420         for (;;) {
 421                 ninbuf = realloc(inbuf, len);
 422                 if (ninbuf == NULL)
 423                         err(1, "unable to allocate interface buffer");
 424                 bifc.ifbic_len = len;
 425                 bifc.ifbic_buf = inbuf = ninbuf;
 426                 if (do_cmd(sock, bridge, BRDGGIFS, &bifc, sizeof(bifc), 0) < 0)
 427                         err(1, "unable to get interface list");
 428                 if ((bifc.ifbic_len + sizeof(*req)) < len)
 429                         break;
 430                 len *= 2;
 431         }
 432
 433         for (i = 0; i < bifc.ifbic_len / sizeof(*req); i++) {
 434                 req = bifc.ifbic_req + i;
 435                 printf("%s%s ", prefix, req->ifbr_ifsname);
 436                 printb("flags", req->ifbr_ifsflags, IFBIFBITS);
 437                 printf("\n");
 438                 printf("%s\t", prefix);
 439                 printf("port %u priority %u",
 440                     req->ifbr_portno, req->ifbr_priority);
 441                 if (req->ifbr_ifsflags & IFBIF_STP) {
 442                         printf(" path cost %u", req->ifbr_path_cost);
 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, *ninbuf;
 462         int i, len = 8192;
 463         struct ether_addr ea;
 464
 465         for (;;) {
 466                 ninbuf = realloc(inbuf, len);
 467                 if (ninbuf == NULL)
 468                         err(1, "unable to allocate address buffer");
 469                 ifbac.ifbac_len = len;
 470                 ifbac.ifbac_buf = inbuf = ninbuf;
 471                 if (do_cmd(sock, bridge, BRDGRTS, &ifbac, sizeof(ifbac), 0) < 0)
 472                         err(1, "unable to get address cache");
 473                 if ((ifbac.ifbac_len + sizeof(*ifba)) < len)
 474                         break;
 475                 len *= 2;
 476         }
 477
 478         for (i = 0; i < ifbac.ifbac_len / sizeof(*ifba); i++) {
 479                 ifba = ifbac.ifbac_req + i;
 480                 memcpy(ea.octet, ifba->ifba_dst,
 481                     sizeof(ea.octet));
 482                 printf("%s%s %s %lu ", prefix, ether_ntoa(&ea),
 483                     ifba->ifba_ifsname, ifba->ifba_expire);
 484                 printb("flags", ifba->ifba_flags, IFBAFBITS);
 485                 printf("\n");
 486         }
 487
 488         free(inbuf);
 489 }
 490
 491 int
 492 get_val(const char *cp, u_long *valp)
 493 {
 494         char *endptr;
 495         u_long val;
 496
 497         errno = 0;
 498         val = strtoul(cp, &endptr, 0);
 499         if (cp[0] == '\0' || endptr[0] != '\0' || errno == ERANGE)
 500                 return (-1);
 501
 502         *valp = val;
 503         return (0);
 504 }
 505
 506 int
 507 do_cmd(int sock, const char *bridge, u_long op, void *arg, size_t argsize,
 508     int set)
 509 {
 510         struct ifdrv ifd;
 511
 512         memset(&ifd, 0, sizeof(ifd));
 513
 514         strlcpy(ifd.ifd_name, bridge, sizeof(ifd.ifd_name));
 515         ifd.ifd_cmd = op;
 516         ifd.ifd_len = argsize;
 517         ifd.ifd_data = arg;
 518
 519         return (ioctl(sock, set ? SIOCSDRVSPEC : SIOCGDRVSPEC, &ifd));
 520 }
 521
 522 void
 523 do_ifflag(int sock, const char *bridge, int flag, int set)
 524 {
 525
 526         if (set)
 527                 g_ifr.ifr_flags |= flag;
 528         else
 529                 g_ifr.ifr_flags &= ~flag;
 530
 531         g_ifr_updated = 1;
 532 }
 533
 534 void
 535 do_bridgeflag(int sock, const char *bridge, const char *ifs, int flag,
 536     int set)
 537 {
 538         struct ifbreq req;
 539
 540         strlcpy(req.ifbr_ifsname, ifs, sizeof(req.ifbr_ifsname));
 541
 542         if (do_cmd(sock, bridge, BRDGGIFFLGS, &req, sizeof(req), 0) < 0)
 543                 err(1, "unable to get bridge flags");
 544
 545         if (set)
 546                 req.ifbr_ifsflags |= flag;
 547         else
 548                 req.ifbr_ifsflags &= ~flag;
 549
 550         if (do_cmd(sock, bridge, BRDGSIFFLGS, &req, sizeof(req), 1) < 0)
 551                 err(1, "unable to set bridge flags");
 552 }
 553
 554 void
 555 cmd_add(const struct command *cmd, int sock, const char *bridge,
 556     char **argv)
 557 {
 558         struct ifbreq req;
 559
 560         memset(&req, 0, sizeof(req));
 561
 562         strlcpy(req.ifbr_ifsname, argv[0], sizeof(req.ifbr_ifsname));
 563         if (do_cmd(sock, bridge, BRDGADD, &req, sizeof(req), 1) < 0)
 564                 err(1, "%s %s", cmd->cmd_keyword, argv[0]);
 565 }
 566
 567 void
 568 cmd_delete(const struct command *cmd, int sock, const char *bridge,
 569     char **argv)
 570 {
 571         struct ifbreq req;
 572
 573         memset(&req, 0, sizeof(req));
 574         strlcpy(req.ifbr_ifsname, argv[0], sizeof(req.ifbr_ifsname));
 575         if (do_cmd(sock, bridge, BRDGDEL, &req, sizeof(req), 1) < 0)
 576                 err(1, "%s %s", cmd->cmd_keyword, argv[0]);
 577 }
 578
 579 void
 580 cmd_up(const struct command *cmd, int sock, const char *bridge,
 581     char **argv)
 582 {
 583
 584         do_ifflag(sock, bridge, IFF_UP, 1);
 585 }
 586
 587 void
 588 cmd_down(const struct command *cmd, int sock, const char *bridge,
 589     char **argv)
 590 {
 591
 592         do_ifflag(sock, bridge, IFF_UP, 0);
 593 }
 594
 595 void
 596 cmd_discover(const struct command *cmd, int sock, const char *bridge,
 597     char **argv)
 598 {
 599
 600         do_bridgeflag(sock, bridge, argv[0], IFBIF_DISCOVER,
 601             (cmd->cmd_flags & CMD_INVERT) ? 0 : 1);
 602 }
 603
 604 void
 605 cmd_learn(const struct command *cmd, int sock, const char *bridge,
 606     char **argv)
 607 {
 608
 609         do_bridgeflag(sock, bridge, argv[0], IFBIF_LEARNING,
 610             (cmd->cmd_flags & CMD_INVERT) ? 0 : 1);
 611 }
 612
 613 void
 614 cmd_stp(const struct command *cmd, int sock, const char *bridge,
 615     char **argv)
 616 {
 617
 618         do_bridgeflag(sock, bridge, argv[0], IFBIF_STP,
 619             (cmd->cmd_flags & CMD_INVERT) ? 0 : 1);
 620 }
 621
 622 void
 623 cmd_flush(const struct command *cmd, int sock, const char *bridge,
 624     char **argv)
 625 {
 626         struct ifbreq req;
 627
 628         memset(&req, 0, sizeof(req));
 629         req.ifbr_ifsflags = IFBF_FLUSHDYN;
 630         if (do_cmd(sock, bridge, BRDGFLUSH, &req, sizeof(req), 1) < 0)
 631                 err(1, "%s", cmd->cmd_keyword);
 632 }
 633
 634 void
 635 cmd_flushall(const struct command *cmd, int sock, const char *bridge,
 636     char **argv)
 637 {
 638         struct ifbreq req;
 639
 640         memset(&req, 0, sizeof(req));
 641         req.ifbr_ifsflags = IFBF_FLUSHALL;
 642         if (do_cmd(sock, bridge, BRDGFLUSH, &req, sizeof(req), 1) < 0)
 643                 err(1, "%s", cmd->cmd_keyword);
 644 }
 645
 646 void
 647 cmd_static(const struct command *cmd, int sock, const char *bridge,
 648     char **argv)
 649 {
 650         struct ifbareq req;
 651         struct ether_addr *ea;
 652
 653         memset(&req, 0, sizeof(req));
 654         strlcpy(req.ifba_ifsname, argv[0], sizeof(req.ifba_ifsname));
 655
 656         ea = ether_aton(argv[1]);
 657         if (ea == NULL)
 658                 errx(1, "%s: invalid address: %s", cmd->cmd_keyword, argv[1]);
 659
 660         memcpy(req.ifba_dst, ea->octet, sizeof(req.ifba_dst));
 661         req.ifba_flags = IFBAF_STATIC;
 662
 663         if (do_cmd(sock, bridge, BRDGSADDR, &req, sizeof(req), 1) < 0)
 664                 err(1, "%s %s %s", cmd->cmd_keyword, argv[0], argv[1]);
 665 }
 666
 667 void
 668 cmd_deladdr(const struct command *cmd, int sock, const char *bridge,
 669     char **argv)
 670 {
 671         struct ifbareq req;
 672         struct ether_addr *ea;
 673
 674         memset(&req, 0, sizeof(req));
 675
 676         ea = ether_aton(argv[0]);
 677         if (ea == NULL)
 678                 errx(1, "%s: invalid address: %s", cmd->cmd_keyword, argv[0]);
 679
 680         memcpy(req.ifba_dst, ea->octet, sizeof(req.ifba_dst));
 681
 682         if (do_cmd(sock, bridge, BRDGDADDR, &req, sizeof(req), 1) < 0)
 683                 err(1, "%s %s", cmd->cmd_keyword, argv[0]);
 684 }
 685
 686 void
 687 cmd_addr(const struct command *cmd, int sock, const char *bridge,
 688     char **argv)
 689 {
 690
 691         show_addresses(sock, bridge, "\t");
 692 }
 693
 694 void
 695 cmd_maxaddr(const struct command *cmd, int sock, const char *bridge,
 696     char **argv)
 697 {
 698         struct ifbrparam param;
 699         u_long val;
 700
 701         if (get_val(argv[0], &val) < 0 || (val & ~0xffffffff) != 0)
 702                 errx(1, "%s: invalid value: %s", cmd->cmd_keyword, argv[0]);
 703
 704         param.ifbrp_csize = val & 0xffffffff;
 705
 706         if (do_cmd(sock, bridge, BRDGSCACHE, &param, sizeof(param), 1) < 0)
 707                 err(1, "%s %s", cmd->cmd_keyword, argv[0]);
 708 }
 709
 710 void
 711 cmd_hellotime(const struct command *cmd, int sock, const char *bridge,
 712     char **argv)
 713 {
 714         struct ifbrparam param;
 715         u_long val;
 716
 717         if (get_val(argv[0], &val) < 0 || (val & ~0xff) != 0)
 718                 errx(1, "%s: invalid value: %s", cmd->cmd_keyword, argv[0]);
 719
 720         param.ifbrp_hellotime = val & 0xff;
 721
 722         if (do_cmd(sock, bridge, BRDGSHT, &param, sizeof(param), 1) < 0)
 723                 err(1, "%s %s", cmd->cmd_keyword, argv[0]);
 724 }
 725
 726 void
 727 cmd_fwddelay(const struct command *cmd, int sock, const char *bridge,
 728     char **argv)
 729 {
 730         struct ifbrparam param;
 731         u_long val;
 732
 733         if (get_val(argv[0], &val) < 0 || (val & ~0xff) != 0)
 734                 errx(1, "%s: invalid value: %s", cmd->cmd_keyword, argv[0]);
 735
 736         param.ifbrp_fwddelay = val & 0xff;
 737
 738         if (do_cmd(sock, bridge, BRDGSFD, &param, sizeof(param), 1) < 0)
 739                 err(1, "%s %s", cmd->cmd_keyword, argv[0]);
 740 }
 741
 742 void
 743 cmd_maxage(const struct command *cmd, int sock, const char *bridge,
 744     char **argv)
 745 {
 746         struct ifbrparam param;
 747         u_long val;
 748
 749         if (get_val(argv[0], &val) < 0 || (val & ~0xff) != 0)
 750                 errx(1, "%s: invalid value: %s", cmd->cmd_keyword, argv[0]);
 751
 752         param.ifbrp_maxage = val & 0xff;
 753
 754         if (do_cmd(sock, bridge, BRDGSMA, &param, sizeof(param), 1) < 0)
 755                 err(1, "%s %s", cmd->cmd_keyword, argv[0]);
 756 }
 757
 758 void
 759 cmd_priority(const struct command *cmd, int sock, const char *bridge,
 760     char **argv)
 761 {
 762         struct ifbrparam param;
 763         u_long val;
 764
 765         if (get_val(argv[0], &val) < 0 || (val & ~0xffff) != 0)
 766                 errx(1, "%s: invalid value: %s", cmd->cmd_keyword, argv[0]);
 767
 768         param.ifbrp_prio = val & 0xffff;
 769
 770         if (do_cmd(sock, bridge, BRDGSPRI, &param, sizeof(param), 1) < 0)
 771                 err(1, "%s %s", cmd->cmd_keyword, argv[0]);
 772 }
 773
 774 void
 775 cmd_ifpriority(const struct command *cmd, int sock, const char *bridge,
 776     char **argv)
 777 {
 778         struct ifbreq req;
 779         u_long val;
 780
 781         memset(&req, 0, sizeof(req));
 782
 783         if (get_val(argv[1], &val) < 0 || (val & ~0xff) != 0)
 784                 errx(1, "%s: invalid value: %s", cmd->cmd_keyword, argv[1]);
 785
 786         strlcpy(req.ifbr_ifsname, argv[0], sizeof(req.ifbr_ifsname));
 787         req.ifbr_priority = val & 0xff;
 788
 789         if (do_cmd(sock, bridge, BRDGSIFPRIO, &req, sizeof(req), 1) < 0)
 790                 err(1, "%s %s", cmd->cmd_keyword, argv[0]);
 791 }
 792
 793 void
 794 cmd_ifpathcost(const struct command *cmd, int sock, const char *bridge,
 795     char **argv)
 796 {
 797         struct ifbreq req;
 798         u_long val;
 799
 800         memset(&req, 0, sizeof(req));
 801
 802         if (get_val(argv[1], &val) < 0 || (val & ~0xff) != 0)
 803                 errx(1, "%s: invalid value: %s", cmd->cmd_keyword, argv[1]);
 804
 805         strlcpy(req.ifbr_ifsname, argv[0], sizeof(req.ifbr_ifsname));
 806         req.ifbr_path_cost = val & 0xffff;
 807
 808         if (do_cmd(sock, bridge, BRDGSIFCOST, &req, sizeof(req), 1) < 0)
 809                 err(1, "%s %s", cmd->cmd_keyword, argv[0]);
 810 }
 811
 812 void
 813 cmd_timeout(const struct command *cmd, int sock, const char *bridge,
 814     char **argv)
 815 {
 816         struct ifbrparam param;
 817         u_long val;
 818
 819         if (get_val(argv[0], &val) < 0 || (val & ~0xffffffff) != 0)
 820                 errx(1, "%s: invalid value: %s", cmd->cmd_keyword, argv[0]);
 821
 822         param.ifbrp_ctime = val & 0xffffffff;
 823
 824         if (do_cmd(sock, bridge, BRDGSTO, &param, sizeof(param), 1) < 0)
 825                 err(1, "%s %s", cmd->cmd_keyword, argv[0]);
 826 }