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