xref: /freebsd/sys/net/if_bridge.c (revision 4a5216a6dc0c3ce4cf5f2d3ee8af0c3ff3402c4f)
1 /*	$NetBSD: if_bridge.c,v 1.31 2005/06/01 19:45:34 jdc 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  * Copyright (c) 1999, 2000 Jason L. Wright (jason@thought.net)
40  * All rights reserved.
41  *
42  * Redistribution and use in source and binary forms, with or without
43  * modification, are permitted provided that the following conditions
44  * are met:
45  * 1. Redistributions of source code must retain the above copyright
46  *    notice, this list of conditions and the following disclaimer.
47  * 2. Redistributions in binary form must reproduce the above copyright
48  *    notice, this list of conditions and the following disclaimer in the
49  *    documentation and/or other materials provided with the distribution.
50  *
51  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
52  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
53  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
54  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
55  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
56  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
57  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
58  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
59  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
60  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
61  * POSSIBILITY OF SUCH DAMAGE.
62  *
63  * OpenBSD: if_bridge.c,v 1.60 2001/06/15 03:38:33 itojun Exp
64  */
65 
66 /*
67  * Network interface bridge support.
68  *
69  * TODO:
70  *
71  *	- Currently only supports Ethernet-like interfaces (Ethernet,
72  *	  802.11, VLANs on Ethernet, etc.)  Figure out a nice way
73  *	  to bridge other types of interfaces (FDDI-FDDI, and maybe
74  *	  consider heterogenous bridges).
75  */
76 
77 #include <sys/cdefs.h>
78 __FBSDID("$FreeBSD$");
79 
80 #include "opt_inet.h"
81 #include "opt_inet6.h"
82 #include "opt_carp.h"
83 
84 #include <sys/param.h>
85 #include <sys/mbuf.h>
86 #include <sys/malloc.h>
87 #include <sys/protosw.h>
88 #include <sys/systm.h>
89 #include <sys/time.h>
90 #include <sys/socket.h> /* for net/if.h */
91 #include <sys/sockio.h>
92 #include <sys/ctype.h>  /* string functions */
93 #include <sys/kernel.h>
94 #include <sys/random.h>
95 #include <sys/syslog.h>
96 #include <sys/sysctl.h>
97 #include <vm/uma.h>
98 #include <sys/module.h>
99 #include <sys/priv.h>
100 #include <sys/proc.h>
101 #include <sys/lock.h>
102 #include <sys/mutex.h>
103 #include <sys/vimage.h>
104 
105 #include <net/bpf.h>
106 #include <net/if.h>
107 #include <net/if_clone.h>
108 #include <net/if_dl.h>
109 #include <net/if_types.h>
110 #include <net/if_var.h>
111 #include <net/pfil.h>
112 
113 #include <netinet/in.h> /* for struct arpcom */
114 #include <netinet/in_systm.h>
115 #include <netinet/in_var.h>
116 #include <netinet/ip.h>
117 #include <netinet/ip_var.h>
118 #ifdef INET6
119 #include <netinet/ip6.h>
120 #include <netinet6/ip6_var.h>
121 #endif
122 #ifdef DEV_CARP
123 #include <netinet/ip_carp.h>
124 #endif
125 #include <machine/in_cksum.h>
126 #include <netinet/if_ether.h> /* for struct arpcom */
127 #include <net/bridgestp.h>
128 #include <net/if_bridgevar.h>
129 #include <net/if_llc.h>
130 #include <net/if_vlan_var.h>
131 
132 #include <net/route.h>
133 #include <netinet/ip_fw.h>
134 #include <netinet/ip_dummynet.h>
135 
136 /*
137  * Size of the route hash table.  Must be a power of two.
138  */
139 #ifndef BRIDGE_RTHASH_SIZE
140 #define	BRIDGE_RTHASH_SIZE		1024
141 #endif
142 
143 #define	BRIDGE_RTHASH_MASK		(BRIDGE_RTHASH_SIZE - 1)
144 
145 /*
146  * Maximum number of addresses to cache.
147  */
148 #ifndef BRIDGE_RTABLE_MAX
149 #define	BRIDGE_RTABLE_MAX		100
150 #endif
151 
152 /*
153  * Timeout (in seconds) for entries learned dynamically.
154  */
155 #ifndef BRIDGE_RTABLE_TIMEOUT
156 #define	BRIDGE_RTABLE_TIMEOUT		(20 * 60)	/* same as ARP */
157 #endif
158 
159 /*
160  * Number of seconds between walks of the route list.
161  */
162 #ifndef BRIDGE_RTABLE_PRUNE_PERIOD
163 #define	BRIDGE_RTABLE_PRUNE_PERIOD	(5 * 60)
164 #endif
165 
166 /*
167  * List of capabilities to possibly mask on the member interface.
168  */
169 #define	BRIDGE_IFCAPS_MASK		(IFCAP_TOE|IFCAP_TSO|IFCAP_TXCSUM)
170 
171 /*
172  * Bridge interface list entry.
173  */
174 struct bridge_iflist {
175 	LIST_ENTRY(bridge_iflist) bif_next;
176 	struct ifnet		*bif_ifp;	/* member if */
177 	struct bstp_port	bif_stp;	/* STP state */
178 	uint32_t		bif_flags;	/* member if flags */
179 	int			bif_savedcaps;	/* saved capabilities */
180 	uint32_t		bif_addrmax;	/* max # of addresses */
181 	uint32_t		bif_addrcnt;	/* cur. # of addresses */
182 	uint32_t		bif_addrexceeded;/* # of address violations */
183 };
184 
185 /*
186  * Bridge route node.
187  */
188 struct bridge_rtnode {
189 	LIST_ENTRY(bridge_rtnode) brt_hash;	/* hash table linkage */
190 	LIST_ENTRY(bridge_rtnode) brt_list;	/* list linkage */
191 	struct bridge_iflist	*brt_dst;	/* destination if */
192 	unsigned long		brt_expire;	/* expiration time */
193 	uint8_t			brt_flags;	/* address flags */
194 	uint8_t			brt_addr[ETHER_ADDR_LEN];
195 	uint16_t		brt_vlan;	/* vlan id */
196 };
197 #define	brt_ifp			brt_dst->bif_ifp
198 
199 /*
200  * Software state for each bridge.
201  */
202 struct bridge_softc {
203 	struct ifnet		*sc_ifp;	/* make this an interface */
204 	LIST_ENTRY(bridge_softc) sc_list;
205 	struct mtx		sc_mtx;
206 	struct cv		sc_cv;
207 	uint32_t		sc_brtmax;	/* max # of addresses */
208 	uint32_t		sc_brtcnt;	/* cur. # of addresses */
209 	uint32_t		sc_brttimeout;	/* rt timeout in seconds */
210 	struct callout		sc_brcallout;	/* bridge callout */
211 	uint32_t		sc_iflist_ref;	/* refcount for sc_iflist */
212 	uint32_t		sc_iflist_xcnt;	/* refcount for sc_iflist */
213 	LIST_HEAD(, bridge_iflist) sc_iflist;	/* member interface list */
214 	LIST_HEAD(, bridge_rtnode) *sc_rthash;	/* our forwarding table */
215 	LIST_HEAD(, bridge_rtnode) sc_rtlist;	/* list version of above */
216 	uint32_t		sc_rthash_key;	/* key for hash */
217 	LIST_HEAD(, bridge_iflist) sc_spanlist;	/* span ports list */
218 	struct bstp_state	sc_stp;		/* STP state */
219 	uint32_t		sc_brtexceeded;	/* # of cache drops */
220 	u_char			sc_defaddr[6];	/* Default MAC address */
221 };
222 
223 static struct mtx 	bridge_list_mtx;
224 eventhandler_tag	bridge_detach_cookie = NULL;
225 
226 int	bridge_rtable_prune_period = BRIDGE_RTABLE_PRUNE_PERIOD;
227 
228 uma_zone_t bridge_rtnode_zone;
229 
230 static int	bridge_clone_create(struct if_clone *, int, caddr_t);
231 static void	bridge_clone_destroy(struct ifnet *);
232 
233 static int	bridge_ioctl(struct ifnet *, u_long, caddr_t);
234 static void	bridge_mutecaps(struct bridge_softc *);
235 static void	bridge_set_ifcap(struct bridge_softc *, struct bridge_iflist *,
236 		    int);
237 static void	bridge_ifdetach(void *arg __unused, struct ifnet *);
238 static void	bridge_init(void *);
239 static void	bridge_dummynet(struct mbuf *, struct ifnet *);
240 static void	bridge_stop(struct ifnet *, int);
241 static void	bridge_start(struct ifnet *);
242 static struct mbuf *bridge_input(struct ifnet *, struct mbuf *);
243 static int	bridge_output(struct ifnet *, struct mbuf *, struct sockaddr *,
244 		    struct rtentry *);
245 static void	bridge_enqueue(struct bridge_softc *, struct ifnet *,
246 		    struct mbuf *);
247 static void	bridge_rtdelete(struct bridge_softc *, struct ifnet *ifp, int);
248 
249 static void	bridge_forward(struct bridge_softc *, struct bridge_iflist *,
250 		    struct mbuf *m);
251 
252 static void	bridge_timer(void *);
253 
254 static void	bridge_broadcast(struct bridge_softc *, struct ifnet *,
255 		    struct mbuf *, int);
256 static void	bridge_span(struct bridge_softc *, struct mbuf *);
257 
258 static int	bridge_rtupdate(struct bridge_softc *, const uint8_t *,
259 		    uint16_t, struct bridge_iflist *, int, uint8_t);
260 static struct ifnet *bridge_rtlookup(struct bridge_softc *, const uint8_t *,
261 		    uint16_t);
262 static void	bridge_rttrim(struct bridge_softc *);
263 static void	bridge_rtage(struct bridge_softc *);
264 static void	bridge_rtflush(struct bridge_softc *, int);
265 static int	bridge_rtdaddr(struct bridge_softc *, const uint8_t *,
266 		    uint16_t);
267 
268 static int	bridge_rtable_init(struct bridge_softc *);
269 static void	bridge_rtable_fini(struct bridge_softc *);
270 
271 static int	bridge_rtnode_addr_cmp(const uint8_t *, const uint8_t *);
272 static struct bridge_rtnode *bridge_rtnode_lookup(struct bridge_softc *,
273 		    const uint8_t *, uint16_t);
274 static int	bridge_rtnode_insert(struct bridge_softc *,
275 		    struct bridge_rtnode *);
276 static void	bridge_rtnode_destroy(struct bridge_softc *,
277 		    struct bridge_rtnode *);
278 static void	bridge_rtable_expire(struct ifnet *, int);
279 static void	bridge_state_change(struct ifnet *, int);
280 
281 static struct bridge_iflist *bridge_lookup_member(struct bridge_softc *,
282 		    const char *name);
283 static struct bridge_iflist *bridge_lookup_member_if(struct bridge_softc *,
284 		    struct ifnet *ifp);
285 static void	bridge_delete_member(struct bridge_softc *,
286 		    struct bridge_iflist *, int);
287 static void	bridge_delete_span(struct bridge_softc *,
288 		    struct bridge_iflist *);
289 
290 static int	bridge_ioctl_add(struct bridge_softc *, void *);
291 static int	bridge_ioctl_del(struct bridge_softc *, void *);
292 static int	bridge_ioctl_gifflags(struct bridge_softc *, void *);
293 static int	bridge_ioctl_sifflags(struct bridge_softc *, void *);
294 static int	bridge_ioctl_scache(struct bridge_softc *, void *);
295 static int	bridge_ioctl_gcache(struct bridge_softc *, void *);
296 static int	bridge_ioctl_gifs(struct bridge_softc *, void *);
297 static int	bridge_ioctl_rts(struct bridge_softc *, void *);
298 static int	bridge_ioctl_saddr(struct bridge_softc *, void *);
299 static int	bridge_ioctl_sto(struct bridge_softc *, void *);
300 static int	bridge_ioctl_gto(struct bridge_softc *, void *);
301 static int	bridge_ioctl_daddr(struct bridge_softc *, void *);
302 static int	bridge_ioctl_flush(struct bridge_softc *, void *);
303 static int	bridge_ioctl_gpri(struct bridge_softc *, void *);
304 static int	bridge_ioctl_spri(struct bridge_softc *, void *);
305 static int	bridge_ioctl_ght(struct bridge_softc *, void *);
306 static int	bridge_ioctl_sht(struct bridge_softc *, void *);
307 static int	bridge_ioctl_gfd(struct bridge_softc *, void *);
308 static int	bridge_ioctl_sfd(struct bridge_softc *, void *);
309 static int	bridge_ioctl_gma(struct bridge_softc *, void *);
310 static int	bridge_ioctl_sma(struct bridge_softc *, void *);
311 static int	bridge_ioctl_sifprio(struct bridge_softc *, void *);
312 static int	bridge_ioctl_sifcost(struct bridge_softc *, void *);
313 static int	bridge_ioctl_sifmaxaddr(struct bridge_softc *, void *);
314 static int	bridge_ioctl_addspan(struct bridge_softc *, void *);
315 static int	bridge_ioctl_delspan(struct bridge_softc *, void *);
316 static int	bridge_ioctl_gbparam(struct bridge_softc *, void *);
317 static int	bridge_ioctl_grte(struct bridge_softc *, void *);
318 static int	bridge_ioctl_gifsstp(struct bridge_softc *, void *);
319 static int	bridge_ioctl_sproto(struct bridge_softc *, void *);
320 static int	bridge_ioctl_stxhc(struct bridge_softc *, void *);
321 static int	bridge_pfil(struct mbuf **, struct ifnet *, struct ifnet *,
322 		    int);
323 static int	bridge_ip_checkbasic(struct mbuf **mp);
324 #ifdef INET6
325 static int	bridge_ip6_checkbasic(struct mbuf **mp);
326 #endif /* INET6 */
327 static int	bridge_fragment(struct ifnet *, struct mbuf *,
328 		    struct ether_header *, int, struct llc *);
329 
330 /* The default bridge vlan is 1 (IEEE 802.1Q-2003 Table 9-2) */
331 #define	VLANTAGOF(_m)	\
332     (_m->m_flags & M_VLANTAG) ? EVL_VLANOFTAG(_m->m_pkthdr.ether_vtag) : 1
333 
334 static struct bstp_cb_ops bridge_ops = {
335 	.bcb_state = bridge_state_change,
336 	.bcb_rtage = bridge_rtable_expire
337 };
338 
339 SYSCTL_DECL(_net_link);
340 SYSCTL_NODE(_net_link, IFT_BRIDGE, bridge, CTLFLAG_RW, 0, "Bridge");
341 
342 static int pfil_onlyip = 1; /* only pass IP[46] packets when pfil is enabled */
343 static int pfil_bridge = 1; /* run pfil hooks on the bridge interface */
344 static int pfil_member = 1; /* run pfil hooks on the member interface */
345 static int pfil_ipfw = 0;   /* layer2 filter with ipfw */
346 static int pfil_ipfw_arp = 0;   /* layer2 filter with ipfw */
347 static int pfil_local_phys = 0; /* run pfil hooks on the physical interface for
348                                    locally destined packets */
349 static int log_stp   = 0;   /* log STP state changes */
350 static int bridge_inherit_mac = 0;   /* share MAC with first bridge member */
351 SYSCTL_INT(_net_link_bridge, OID_AUTO, pfil_onlyip, CTLFLAG_RW,
352     &pfil_onlyip, 0, "Only pass IP packets when pfil is enabled");
353 SYSCTL_INT(_net_link_bridge, OID_AUTO, ipfw_arp, CTLFLAG_RW,
354     &pfil_ipfw_arp, 0, "Filter ARP packets through IPFW layer2");
355 SYSCTL_INT(_net_link_bridge, OID_AUTO, pfil_bridge, CTLFLAG_RW,
356     &pfil_bridge, 0, "Packet filter on the bridge interface");
357 SYSCTL_INT(_net_link_bridge, OID_AUTO, pfil_member, CTLFLAG_RW,
358     &pfil_member, 0, "Packet filter on the member interface");
359 SYSCTL_INT(_net_link_bridge, OID_AUTO, pfil_local_phys, CTLFLAG_RW,
360     &pfil_local_phys, 0,
361     "Packet filter on the physical interface for locally destined packets");
362 SYSCTL_INT(_net_link_bridge, OID_AUTO, log_stp, CTLFLAG_RW,
363     &log_stp, 0, "Log STP state changes");
364 SYSCTL_INT(_net_link_bridge, OID_AUTO, inherit_mac, CTLFLAG_RW,
365     &bridge_inherit_mac, 0,
366     "Inherit MAC address from the first bridge member");
367 
368 struct bridge_control {
369 	int	(*bc_func)(struct bridge_softc *, void *);
370 	int	bc_argsize;
371 	int	bc_flags;
372 };
373 
374 #define	BC_F_COPYIN		0x01	/* copy arguments in */
375 #define	BC_F_COPYOUT		0x02	/* copy arguments out */
376 #define	BC_F_SUSER		0x04	/* do super-user check */
377 
378 const struct bridge_control bridge_control_table[] = {
379 	{ bridge_ioctl_add,		sizeof(struct ifbreq),
380 	  BC_F_COPYIN|BC_F_SUSER },
381 	{ bridge_ioctl_del,		sizeof(struct ifbreq),
382 	  BC_F_COPYIN|BC_F_SUSER },
383 
384 	{ bridge_ioctl_gifflags,	sizeof(struct ifbreq),
385 	  BC_F_COPYIN|BC_F_COPYOUT },
386 	{ bridge_ioctl_sifflags,	sizeof(struct ifbreq),
387 	  BC_F_COPYIN|BC_F_SUSER },
388 
389 	{ bridge_ioctl_scache,		sizeof(struct ifbrparam),
390 	  BC_F_COPYIN|BC_F_SUSER },
391 	{ bridge_ioctl_gcache,		sizeof(struct ifbrparam),
392 	  BC_F_COPYOUT },
393 
394 	{ bridge_ioctl_gifs,		sizeof(struct ifbifconf),
395 	  BC_F_COPYIN|BC_F_COPYOUT },
396 	{ bridge_ioctl_rts,		sizeof(struct ifbaconf),
397 	  BC_F_COPYIN|BC_F_COPYOUT },
398 
399 	{ bridge_ioctl_saddr,		sizeof(struct ifbareq),
400 	  BC_F_COPYIN|BC_F_SUSER },
401 
402 	{ bridge_ioctl_sto,		sizeof(struct ifbrparam),
403 	  BC_F_COPYIN|BC_F_SUSER },
404 	{ bridge_ioctl_gto,		sizeof(struct ifbrparam),
405 	  BC_F_COPYOUT },
406 
407 	{ bridge_ioctl_daddr,		sizeof(struct ifbareq),
408 	  BC_F_COPYIN|BC_F_SUSER },
409 
410 	{ bridge_ioctl_flush,		sizeof(struct ifbreq),
411 	  BC_F_COPYIN|BC_F_SUSER },
412 
413 	{ bridge_ioctl_gpri,		sizeof(struct ifbrparam),
414 	  BC_F_COPYOUT },
415 	{ bridge_ioctl_spri,		sizeof(struct ifbrparam),
416 	  BC_F_COPYIN|BC_F_SUSER },
417 
418 	{ bridge_ioctl_ght,		sizeof(struct ifbrparam),
419 	  BC_F_COPYOUT },
420 	{ bridge_ioctl_sht,		sizeof(struct ifbrparam),
421 	  BC_F_COPYIN|BC_F_SUSER },
422 
423 	{ bridge_ioctl_gfd,		sizeof(struct ifbrparam),
424 	  BC_F_COPYOUT },
425 	{ bridge_ioctl_sfd,		sizeof(struct ifbrparam),
426 	  BC_F_COPYIN|BC_F_SUSER },
427 
428 	{ bridge_ioctl_gma,		sizeof(struct ifbrparam),
429 	  BC_F_COPYOUT },
430 	{ bridge_ioctl_sma,		sizeof(struct ifbrparam),
431 	  BC_F_COPYIN|BC_F_SUSER },
432 
433 	{ bridge_ioctl_sifprio,		sizeof(struct ifbreq),
434 	  BC_F_COPYIN|BC_F_SUSER },
435 
436 	{ bridge_ioctl_sifcost,		sizeof(struct ifbreq),
437 	  BC_F_COPYIN|BC_F_SUSER },
438 
439 	{ bridge_ioctl_addspan,		sizeof(struct ifbreq),
440 	  BC_F_COPYIN|BC_F_SUSER },
441 	{ bridge_ioctl_delspan,		sizeof(struct ifbreq),
442 	  BC_F_COPYIN|BC_F_SUSER },
443 
444 	{ bridge_ioctl_gbparam,		sizeof(struct ifbropreq),
445 	  BC_F_COPYOUT },
446 
447 	{ bridge_ioctl_grte,		sizeof(struct ifbrparam),
448 	  BC_F_COPYOUT },
449 
450 	{ bridge_ioctl_gifsstp,		sizeof(struct ifbpstpconf),
451 	  BC_F_COPYIN|BC_F_COPYOUT },
452 
453 	{ bridge_ioctl_sproto,		sizeof(struct ifbrparam),
454 	  BC_F_COPYIN|BC_F_SUSER },
455 
456 	{ bridge_ioctl_stxhc,		sizeof(struct ifbrparam),
457 	  BC_F_COPYIN|BC_F_SUSER },
458 
459 	{ bridge_ioctl_sifmaxaddr,	sizeof(struct ifbreq),
460 	  BC_F_COPYIN|BC_F_SUSER },
461 
462 };
463 const int bridge_control_table_size =
464     sizeof(bridge_control_table) / sizeof(bridge_control_table[0]);
465 
466 LIST_HEAD(, bridge_softc) bridge_list;
467 
468 IFC_SIMPLE_DECLARE(bridge, 0);
469 
470 static int
471 bridge_modevent(module_t mod, int type, void *data)
472 {
473 
474 	switch (type) {
475 	case MOD_LOAD:
476 		mtx_init(&bridge_list_mtx, "if_bridge list", NULL, MTX_DEF);
477 		if_clone_attach(&bridge_cloner);
478 		bridge_rtnode_zone = uma_zcreate("bridge_rtnode",
479 		    sizeof(struct bridge_rtnode), NULL, NULL, NULL, NULL,
480 		    UMA_ALIGN_PTR, 0);
481 		LIST_INIT(&bridge_list);
482 		bridge_input_p = bridge_input;
483 		bridge_output_p = bridge_output;
484 		bridge_dn_p = bridge_dummynet;
485 		bridge_detach_cookie = EVENTHANDLER_REGISTER(
486 		    ifnet_departure_event, bridge_ifdetach, NULL,
487 		    EVENTHANDLER_PRI_ANY);
488 		break;
489 	case MOD_UNLOAD:
490 		EVENTHANDLER_DEREGISTER(ifnet_departure_event,
491 		    bridge_detach_cookie);
492 		if_clone_detach(&bridge_cloner);
493 		uma_zdestroy(bridge_rtnode_zone);
494 		bridge_input_p = NULL;
495 		bridge_output_p = NULL;
496 		bridge_dn_p = NULL;
497 		mtx_destroy(&bridge_list_mtx);
498 		break;
499 	default:
500 		return (EOPNOTSUPP);
501 	}
502 	return (0);
503 }
504 
505 static moduledata_t bridge_mod = {
506 	"if_bridge",
507 	bridge_modevent,
508 	0
509 };
510 
511 DECLARE_MODULE(if_bridge, bridge_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
512 MODULE_DEPEND(if_bridge, bridgestp, 1, 1, 1);
513 
514 /*
515  * handler for net.link.bridge.pfil_ipfw
516  */
517 static int
518 sysctl_pfil_ipfw(SYSCTL_HANDLER_ARGS)
519 {
520 	int enable = pfil_ipfw;
521 	int error;
522 
523 	error = sysctl_handle_int(oidp, &enable, 0, req);
524 	enable = (enable) ? 1 : 0;
525 
526 	if (enable != pfil_ipfw) {
527 		pfil_ipfw = enable;
528 
529 		/*
530 		 * Disable pfil so that ipfw doesnt run twice, if the user
531 		 * really wants both then they can re-enable pfil_bridge and/or
532 		 * pfil_member. Also allow non-ip packets as ipfw can filter by
533 		 * layer2 type.
534 		 */
535 		if (pfil_ipfw) {
536 			pfil_onlyip = 0;
537 			pfil_bridge = 0;
538 			pfil_member = 0;
539 		}
540 	}
541 
542 	return (error);
543 }
544 SYSCTL_PROC(_net_link_bridge, OID_AUTO, ipfw, CTLTYPE_INT|CTLFLAG_RW,
545 	    &pfil_ipfw, 0, &sysctl_pfil_ipfw, "I", "Layer2 filter with IPFW");
546 
547 /*
548  * bridge_clone_create:
549  *
550  *	Create a new bridge instance.
551  */
552 static int
553 bridge_clone_create(struct if_clone *ifc, int unit, caddr_t params)
554 {
555 	struct bridge_softc *sc, *sc2;
556 	struct ifnet *bifp, *ifp;
557 	int retry;
558 
559 	sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK|M_ZERO);
560 	ifp = sc->sc_ifp = if_alloc(IFT_ETHER);
561 	if (ifp == NULL) {
562 		free(sc, M_DEVBUF);
563 		return (ENOSPC);
564 	}
565 
566 	BRIDGE_LOCK_INIT(sc);
567 	sc->sc_brtmax = BRIDGE_RTABLE_MAX;
568 	sc->sc_brttimeout = BRIDGE_RTABLE_TIMEOUT;
569 
570 	/* Initialize our routing table. */
571 	bridge_rtable_init(sc);
572 
573 	callout_init_mtx(&sc->sc_brcallout, &sc->sc_mtx, 0);
574 
575 	LIST_INIT(&sc->sc_iflist);
576 	LIST_INIT(&sc->sc_spanlist);
577 
578 	ifp->if_softc = sc;
579 	if_initname(ifp, ifc->ifc_name, unit);
580 	ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
581 	ifp->if_ioctl = bridge_ioctl;
582 	ifp->if_start = bridge_start;
583 	ifp->if_init = bridge_init;
584 	ifp->if_type = IFT_BRIDGE;
585 	IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
586 	ifp->if_snd.ifq_drv_maxlen = ifqmaxlen;
587 	IFQ_SET_READY(&ifp->if_snd);
588 
589 	/*
590 	 * Generate a random ethernet address with a locally administered
591 	 * address.
592 	 *
593 	 * Since we are using random ethernet addresses for the bridge, it is
594 	 * possible that we might have address collisions, so make sure that
595 	 * this hardware address isn't already in use on another bridge.
596 	 */
597 	for (retry = 1; retry != 0;) {
598 		arc4rand(sc->sc_defaddr, ETHER_ADDR_LEN, 1);
599 		sc->sc_defaddr[0] &= ~1;	/* clear multicast bit */
600 		sc->sc_defaddr[0] |= 2;		/* set the LAA bit */
601 		retry = 0;
602 		mtx_lock(&bridge_list_mtx);
603 		LIST_FOREACH(sc2, &bridge_list, sc_list) {
604 			bifp = sc2->sc_ifp;
605 			if (memcmp(sc->sc_defaddr,
606 			    IF_LLADDR(bifp), ETHER_ADDR_LEN) == 0)
607 				retry = 1;
608 		}
609 		mtx_unlock(&bridge_list_mtx);
610 	}
611 
612 	bstp_attach(&sc->sc_stp, &bridge_ops);
613 	ether_ifattach(ifp, sc->sc_defaddr);
614 	/* Now undo some of the damage... */
615 	ifp->if_baudrate = 0;
616 	ifp->if_type = IFT_BRIDGE;
617 
618 	mtx_lock(&bridge_list_mtx);
619 	LIST_INSERT_HEAD(&bridge_list, sc, sc_list);
620 	mtx_unlock(&bridge_list_mtx);
621 
622 	return (0);
623 }
624 
625 /*
626  * bridge_clone_destroy:
627  *
628  *	Destroy a bridge instance.
629  */
630 static void
631 bridge_clone_destroy(struct ifnet *ifp)
632 {
633 	struct bridge_softc *sc = ifp->if_softc;
634 	struct bridge_iflist *bif;
635 
636 	BRIDGE_LOCK(sc);
637 
638 	bridge_stop(ifp, 1);
639 	ifp->if_flags &= ~IFF_UP;
640 
641 	while ((bif = LIST_FIRST(&sc->sc_iflist)) != NULL)
642 		bridge_delete_member(sc, bif, 0);
643 
644 	while ((bif = LIST_FIRST(&sc->sc_spanlist)) != NULL) {
645 		bridge_delete_span(sc, bif);
646 	}
647 
648 	BRIDGE_UNLOCK(sc);
649 
650 	callout_drain(&sc->sc_brcallout);
651 
652 	mtx_lock(&bridge_list_mtx);
653 	LIST_REMOVE(sc, sc_list);
654 	mtx_unlock(&bridge_list_mtx);
655 
656 	bstp_detach(&sc->sc_stp);
657 	ether_ifdetach(ifp);
658 	if_free_type(ifp, IFT_ETHER);
659 
660 	/* Tear down the routing table. */
661 	bridge_rtable_fini(sc);
662 
663 	BRIDGE_LOCK_DESTROY(sc);
664 	free(sc, M_DEVBUF);
665 }
666 
667 /*
668  * bridge_ioctl:
669  *
670  *	Handle a control request from the operator.
671  */
672 static int
673 bridge_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
674 {
675 	struct bridge_softc *sc = ifp->if_softc;
676 	struct thread *td = curthread;
677 	union {
678 		struct ifbreq ifbreq;
679 		struct ifbifconf ifbifconf;
680 		struct ifbareq ifbareq;
681 		struct ifbaconf ifbaconf;
682 		struct ifbrparam ifbrparam;
683 		struct ifbropreq ifbropreq;
684 	} args;
685 	struct ifdrv *ifd = (struct ifdrv *) data;
686 	const struct bridge_control *bc;
687 	int error = 0;
688 
689 	switch (cmd) {
690 
691 	case SIOCADDMULTI:
692 	case SIOCDELMULTI:
693 		break;
694 
695 	case SIOCGDRVSPEC:
696 	case SIOCSDRVSPEC:
697 		if (ifd->ifd_cmd >= bridge_control_table_size) {
698 			error = EINVAL;
699 			break;
700 		}
701 		bc = &bridge_control_table[ifd->ifd_cmd];
702 
703 		if (cmd == SIOCGDRVSPEC &&
704 		    (bc->bc_flags & BC_F_COPYOUT) == 0) {
705 			error = EINVAL;
706 			break;
707 		}
708 		else if (cmd == SIOCSDRVSPEC &&
709 		    (bc->bc_flags & BC_F_COPYOUT) != 0) {
710 			error = EINVAL;
711 			break;
712 		}
713 
714 		if (bc->bc_flags & BC_F_SUSER) {
715 			error = priv_check(td, PRIV_NET_BRIDGE);
716 			if (error)
717 				break;
718 		}
719 
720 		if (ifd->ifd_len != bc->bc_argsize ||
721 		    ifd->ifd_len > sizeof(args)) {
722 			error = EINVAL;
723 			break;
724 		}
725 
726 		bzero(&args, sizeof(args));
727 		if (bc->bc_flags & BC_F_COPYIN) {
728 			error = copyin(ifd->ifd_data, &args, ifd->ifd_len);
729 			if (error)
730 				break;
731 		}
732 
733 		BRIDGE_LOCK(sc);
734 		error = (*bc->bc_func)(sc, &args);
735 		BRIDGE_UNLOCK(sc);
736 		if (error)
737 			break;
738 
739 		if (bc->bc_flags & BC_F_COPYOUT)
740 			error = copyout(&args, ifd->ifd_data, ifd->ifd_len);
741 
742 		break;
743 
744 	case SIOCSIFFLAGS:
745 		if (!(ifp->if_flags & IFF_UP) &&
746 		    (ifp->if_drv_flags & IFF_DRV_RUNNING)) {
747 			/*
748 			 * If interface is marked down and it is running,
749 			 * then stop and disable it.
750 			 */
751 			BRIDGE_LOCK(sc);
752 			bridge_stop(ifp, 1);
753 			BRIDGE_UNLOCK(sc);
754 		} else if ((ifp->if_flags & IFF_UP) &&
755 		    !(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
756 			/*
757 			 * If interface is marked up and it is stopped, then
758 			 * start it.
759 			 */
760 			(*ifp->if_init)(sc);
761 		}
762 		break;
763 
764 	case SIOCSIFMTU:
765 		/* Do not allow the MTU to be changed on the bridge */
766 		error = EINVAL;
767 		break;
768 
769 	default:
770 		/*
771 		 * drop the lock as ether_ioctl() will call bridge_start() and
772 		 * cause the lock to be recursed.
773 		 */
774 		error = ether_ioctl(ifp, cmd, data);
775 		break;
776 	}
777 
778 	return (error);
779 }
780 
781 /*
782  * bridge_mutecaps:
783  *
784  *	Clear or restore unwanted capabilities on the member interface
785  */
786 static void
787 bridge_mutecaps(struct bridge_softc *sc)
788 {
789 	struct bridge_iflist *bif;
790 	int enabled, mask;
791 
792 	/* Initial bitmask of capabilities to test */
793 	mask = BRIDGE_IFCAPS_MASK;
794 
795 	LIST_FOREACH(bif, &sc->sc_iflist, bif_next) {
796 		/* Every member must support it or its disabled */
797 		mask &= bif->bif_savedcaps;
798 	}
799 
800 	LIST_FOREACH(bif, &sc->sc_iflist, bif_next) {
801 		enabled = bif->bif_ifp->if_capenable;
802 		/* strip off mask bits and enable them again if allowed */
803 		enabled &= ~BRIDGE_IFCAPS_MASK;
804 		enabled |= mask;
805 		/*
806 		 * Receive offload can only be enabled if all members also
807 		 * support send offload.
808 		 */
809 		if ((enabled & IFCAP_TSO) == 0)
810 			enabled &= ~IFCAP_LRO;
811 
812 		bridge_set_ifcap(sc, bif, enabled);
813 	}
814 
815 }
816 
817 static void
818 bridge_set_ifcap(struct bridge_softc *sc, struct bridge_iflist *bif, int set)
819 {
820 	struct ifnet *ifp = bif->bif_ifp;
821 	struct ifreq ifr;
822 	int error;
823 
824 	bzero(&ifr, sizeof(ifr));
825 	ifr.ifr_reqcap = set;
826 
827 	if (ifp->if_capenable != set) {
828 		IFF_LOCKGIANT(ifp);
829 		error = (*ifp->if_ioctl)(ifp, SIOCSIFCAP, (caddr_t)&ifr);
830 		IFF_UNLOCKGIANT(ifp);
831 		if (error)
832 			if_printf(sc->sc_ifp,
833 			    "error setting interface capabilities on %s\n",
834 			    ifp->if_xname);
835 	}
836 }
837 
838 /*
839  * bridge_lookup_member:
840  *
841  *	Lookup a bridge member interface.
842  */
843 static struct bridge_iflist *
844 bridge_lookup_member(struct bridge_softc *sc, const char *name)
845 {
846 	struct bridge_iflist *bif;
847 	struct ifnet *ifp;
848 
849 	BRIDGE_LOCK_ASSERT(sc);
850 
851 	LIST_FOREACH(bif, &sc->sc_iflist, bif_next) {
852 		ifp = bif->bif_ifp;
853 		if (strcmp(ifp->if_xname, name) == 0)
854 			return (bif);
855 	}
856 
857 	return (NULL);
858 }
859 
860 /*
861  * bridge_lookup_member_if:
862  *
863  *	Lookup a bridge member interface by ifnet*.
864  */
865 static struct bridge_iflist *
866 bridge_lookup_member_if(struct bridge_softc *sc, struct ifnet *member_ifp)
867 {
868 	struct bridge_iflist *bif;
869 
870 	BRIDGE_LOCK_ASSERT(sc);
871 
872 	LIST_FOREACH(bif, &sc->sc_iflist, bif_next) {
873 		if (bif->bif_ifp == member_ifp)
874 			return (bif);
875 	}
876 
877 	return (NULL);
878 }
879 
880 /*
881  * bridge_delete_member:
882  *
883  *	Delete the specified member interface.
884  */
885 static void
886 bridge_delete_member(struct bridge_softc *sc, struct bridge_iflist *bif,
887     int gone)
888 {
889 	struct ifnet *ifs = bif->bif_ifp;
890 	struct ifnet *fif = NULL;
891 
892 	BRIDGE_LOCK_ASSERT(sc);
893 
894 	if (!gone) {
895 		switch (ifs->if_type) {
896 		case IFT_ETHER:
897 		case IFT_L2VLAN:
898 			/*
899 			 * Take the interface out of promiscuous mode.
900 			 */
901 			(void) ifpromisc(ifs, 0);
902 			break;
903 
904 		case IFT_GIF:
905 			break;
906 
907 		default:
908 #ifdef DIAGNOSTIC
909 			panic("bridge_delete_member: impossible");
910 #endif
911 			break;
912 		}
913 		/* reneable any interface capabilities */
914 		bridge_set_ifcap(sc, bif, bif->bif_savedcaps);
915 	}
916 
917 	if (bif->bif_flags & IFBIF_STP)
918 		bstp_disable(&bif->bif_stp);
919 
920 	ifs->if_bridge = NULL;
921 	BRIDGE_XLOCK(sc);
922 	LIST_REMOVE(bif, bif_next);
923 	BRIDGE_XDROP(sc);
924 
925 	/*
926 	 * If removing the interface that gave the bridge its mac address, set
927 	 * the mac address of the bridge to the address of the next member, or
928 	 * to its default address if no members are left.
929 	 */
930 	if (bridge_inherit_mac &&
931 	    !memcmp(IF_LLADDR(sc->sc_ifp), IF_LLADDR(ifs), ETHER_ADDR_LEN)) {
932 		if (LIST_EMPTY(&sc->sc_iflist))
933 			bcopy(sc->sc_defaddr,
934 			    IF_LLADDR(sc->sc_ifp), ETHER_ADDR_LEN);
935 		else {
936 			fif = LIST_FIRST(&sc->sc_iflist)->bif_ifp;
937 			bcopy(IF_LLADDR(fif),
938 			    IF_LLADDR(sc->sc_ifp), ETHER_ADDR_LEN);
939 		}
940 	}
941 
942 	bridge_mutecaps(sc);	/* recalcuate now this interface is removed */
943 	bridge_rtdelete(sc, ifs, IFBF_FLUSHALL);
944 	KASSERT(bif->bif_addrcnt == 0,
945 	    ("%s: %d bridge routes referenced", __func__, bif->bif_addrcnt));
946 
947 	BRIDGE_UNLOCK(sc);
948 	bstp_destroy(&bif->bif_stp);	/* prepare to free */
949 	BRIDGE_LOCK(sc);
950 	free(bif, M_DEVBUF);
951 }
952 
953 /*
954  * bridge_delete_span:
955  *
956  *	Delete the specified span interface.
957  */
958 static void
959 bridge_delete_span(struct bridge_softc *sc, struct bridge_iflist *bif)
960 {
961 	BRIDGE_LOCK_ASSERT(sc);
962 
963 	KASSERT(bif->bif_ifp->if_bridge == NULL,
964 	    ("%s: not a span interface", __func__));
965 
966 	LIST_REMOVE(bif, bif_next);
967 	free(bif, M_DEVBUF);
968 }
969 
970 static int
971 bridge_ioctl_add(struct bridge_softc *sc, void *arg)
972 {
973 	struct ifbreq *req = arg;
974 	struct bridge_iflist *bif = NULL;
975 	struct ifnet *ifs;
976 	int error = 0;
977 
978 	ifs = ifunit(req->ifbr_ifsname);
979 	if (ifs == NULL)
980 		return (ENOENT);
981 	if (ifs->if_ioctl == NULL)	/* must be supported */
982 		return (EINVAL);
983 
984 	/* If it's in the span list, it can't be a member. */
985 	LIST_FOREACH(bif, &sc->sc_spanlist, bif_next)
986 		if (ifs == bif->bif_ifp)
987 			return (EBUSY);
988 
989 	/* Allow the first Ethernet member to define the MTU */
990 	if (ifs->if_type != IFT_GIF) {
991 		if (LIST_EMPTY(&sc->sc_iflist))
992 			sc->sc_ifp->if_mtu = ifs->if_mtu;
993 		else if (sc->sc_ifp->if_mtu != ifs->if_mtu) {
994 			if_printf(sc->sc_ifp, "invalid MTU for %s\n",
995 			    ifs->if_xname);
996 			return (EINVAL);
997 		}
998 	}
999 
1000 	if (ifs->if_bridge == sc)
1001 		return (EEXIST);
1002 
1003 	if (ifs->if_bridge != NULL)
1004 		return (EBUSY);
1005 
1006 	bif = malloc(sizeof(*bif), M_DEVBUF, M_NOWAIT|M_ZERO);
1007 	if (bif == NULL)
1008 		return (ENOMEM);
1009 
1010 	bif->bif_ifp = ifs;
1011 	bif->bif_flags = IFBIF_LEARNING | IFBIF_DISCOVER;
1012 	bif->bif_savedcaps = ifs->if_capenable;
1013 
1014 	switch (ifs->if_type) {
1015 	case IFT_ETHER:
1016 	case IFT_L2VLAN:
1017 		/*
1018 		 * Place the interface into promiscuous mode.
1019 		 */
1020 		error = ifpromisc(ifs, 1);
1021 		if (error)
1022 			goto out;
1023 		break;
1024 
1025 	case IFT_GIF:
1026 		break;
1027 
1028 	default:
1029 		error = EINVAL;
1030 		goto out;
1031 	}
1032 
1033 	/*
1034 	 * Assign the interface's MAC address to the bridge if it's the first
1035 	 * member and the MAC address of the bridge has not been changed from
1036 	 * the default randomly generated one.
1037 	 */
1038 	if (bridge_inherit_mac && LIST_EMPTY(&sc->sc_iflist) &&
1039 	    !memcmp(IF_LLADDR(sc->sc_ifp), sc->sc_defaddr, ETHER_ADDR_LEN))
1040 		bcopy(IF_LLADDR(ifs), IF_LLADDR(sc->sc_ifp), ETHER_ADDR_LEN);
1041 
1042 	ifs->if_bridge = sc;
1043 	bstp_create(&sc->sc_stp, &bif->bif_stp, bif->bif_ifp);
1044 	/*
1045 	 * XXX: XLOCK HERE!?!
1046 	 *
1047 	 * NOTE: insert_***HEAD*** should be safe for the traversals.
1048 	 */
1049 	LIST_INSERT_HEAD(&sc->sc_iflist, bif, bif_next);
1050 
1051 	/* Set interface capabilities to the intersection set of all members */
1052 	bridge_mutecaps(sc);
1053 out:
1054 	if (error) {
1055 		if (bif != NULL)
1056 			free(bif, M_DEVBUF);
1057 	}
1058 	return (error);
1059 }
1060 
1061 static int
1062 bridge_ioctl_del(struct bridge_softc *sc, void *arg)
1063 {
1064 	struct ifbreq *req = arg;
1065 	struct bridge_iflist *bif;
1066 
1067 	bif = bridge_lookup_member(sc, req->ifbr_ifsname);
1068 	if (bif == NULL)
1069 		return (ENOENT);
1070 
1071 	bridge_delete_member(sc, bif, 0);
1072 
1073 	return (0);
1074 }
1075 
1076 static int
1077 bridge_ioctl_gifflags(struct bridge_softc *sc, void *arg)
1078 {
1079 	struct ifbreq *req = arg;
1080 	struct bridge_iflist *bif;
1081 	struct bstp_port *bp;
1082 
1083 	bif = bridge_lookup_member(sc, req->ifbr_ifsname);
1084 	if (bif == NULL)
1085 		return (ENOENT);
1086 
1087 	bp = &bif->bif_stp;
1088 	req->ifbr_ifsflags = bif->bif_flags;
1089 	req->ifbr_state = bp->bp_state;
1090 	req->ifbr_priority = bp->bp_priority;
1091 	req->ifbr_path_cost = bp->bp_path_cost;
1092 	req->ifbr_portno = bif->bif_ifp->if_index & 0xfff;
1093 	req->ifbr_proto = bp->bp_protover;
1094 	req->ifbr_role = bp->bp_role;
1095 	req->ifbr_stpflags = bp->bp_flags;
1096 	req->ifbr_addrcnt = bif->bif_addrcnt;
1097 	req->ifbr_addrmax = bif->bif_addrmax;
1098 	req->ifbr_addrexceeded = bif->bif_addrexceeded;
1099 
1100 	/* Copy STP state options as flags */
1101 	if (bp->bp_operedge)
1102 		req->ifbr_ifsflags |= IFBIF_BSTP_EDGE;
1103 	if (bp->bp_flags & BSTP_PORT_AUTOEDGE)
1104 		req->ifbr_ifsflags |= IFBIF_BSTP_AUTOEDGE;
1105 	if (bp->bp_ptp_link)
1106 		req->ifbr_ifsflags |= IFBIF_BSTP_PTP;
1107 	if (bp->bp_flags & BSTP_PORT_AUTOPTP)
1108 		req->ifbr_ifsflags |= IFBIF_BSTP_AUTOPTP;
1109 	if (bp->bp_flags & BSTP_PORT_ADMEDGE)
1110 		req->ifbr_ifsflags |= IFBIF_BSTP_ADMEDGE;
1111 	if (bp->bp_flags & BSTP_PORT_ADMCOST)
1112 		req->ifbr_ifsflags |= IFBIF_BSTP_ADMCOST;
1113 	return (0);
1114 }
1115 
1116 static int
1117 bridge_ioctl_sifflags(struct bridge_softc *sc, void *arg)
1118 {
1119 	struct ifbreq *req = arg;
1120 	struct bridge_iflist *bif;
1121 	struct bstp_port *bp;
1122 	int error;
1123 
1124 	bif = bridge_lookup_member(sc, req->ifbr_ifsname);
1125 	if (bif == NULL)
1126 		return (ENOENT);
1127 	bp = &bif->bif_stp;
1128 
1129 	if (req->ifbr_ifsflags & IFBIF_SPAN)
1130 		/* SPAN is readonly */
1131 		return (EINVAL);
1132 
1133 	if (req->ifbr_ifsflags & IFBIF_STP) {
1134 		if ((bif->bif_flags & IFBIF_STP) == 0) {
1135 			error = bstp_enable(&bif->bif_stp);
1136 			if (error)
1137 				return (error);
1138 		}
1139 	} else {
1140 		if ((bif->bif_flags & IFBIF_STP) != 0)
1141 			bstp_disable(&bif->bif_stp);
1142 	}
1143 
1144 	/* Pass on STP flags */
1145 	bstp_set_edge(bp, req->ifbr_ifsflags & IFBIF_BSTP_EDGE ? 1 : 0);
1146 	bstp_set_autoedge(bp, req->ifbr_ifsflags & IFBIF_BSTP_AUTOEDGE ? 1 : 0);
1147 	bstp_set_ptp(bp, req->ifbr_ifsflags & IFBIF_BSTP_PTP ? 1 : 0);
1148 	bstp_set_autoptp(bp, req->ifbr_ifsflags & IFBIF_BSTP_AUTOPTP ? 1 : 0);
1149 
1150 	/* Save the bits relating to the bridge */
1151 	bif->bif_flags = req->ifbr_ifsflags & IFBIFMASK;
1152 
1153 	return (0);
1154 }
1155 
1156 static int
1157 bridge_ioctl_scache(struct bridge_softc *sc, void *arg)
1158 {
1159 	struct ifbrparam *param = arg;
1160 
1161 	sc->sc_brtmax = param->ifbrp_csize;
1162 	bridge_rttrim(sc);
1163 
1164 	return (0);
1165 }
1166 
1167 static int
1168 bridge_ioctl_gcache(struct bridge_softc *sc, void *arg)
1169 {
1170 	struct ifbrparam *param = arg;
1171 
1172 	param->ifbrp_csize = sc->sc_brtmax;
1173 
1174 	return (0);
1175 }
1176 
1177 static int
1178 bridge_ioctl_gifs(struct bridge_softc *sc, void *arg)
1179 {
1180 	struct ifbifconf *bifc = arg;
1181 	struct bridge_iflist *bif;
1182 	struct ifbreq breq;
1183 	char *buf, *outbuf;
1184 	int count, buflen, len, error = 0;
1185 
1186 	count = 0;
1187 	LIST_FOREACH(bif, &sc->sc_iflist, bif_next)
1188 		count++;
1189 	LIST_FOREACH(bif, &sc->sc_spanlist, bif_next)
1190 		count++;
1191 
1192 	buflen = sizeof(breq) * count;
1193 	if (bifc->ifbic_len == 0) {
1194 		bifc->ifbic_len = buflen;
1195 		return (0);
1196 	}
1197 	BRIDGE_UNLOCK(sc);
1198 	outbuf = malloc(buflen, M_TEMP, M_WAITOK | M_ZERO);
1199 	BRIDGE_LOCK(sc);
1200 
1201 	count = 0;
1202 	buf = outbuf;
1203 	len = min(bifc->ifbic_len, buflen);
1204 	bzero(&breq, sizeof(breq));
1205 	LIST_FOREACH(bif, &sc->sc_iflist, bif_next) {
1206 		if (len < sizeof(breq))
1207 			break;
1208 
1209 		strlcpy(breq.ifbr_ifsname, bif->bif_ifp->if_xname,
1210 		    sizeof(breq.ifbr_ifsname));
1211 		/* Fill in the ifbreq structure */
1212 		error = bridge_ioctl_gifflags(sc, &breq);
1213 		if (error)
1214 			break;
1215 		memcpy(buf, &breq, sizeof(breq));
1216 		count++;
1217 		buf += sizeof(breq);
1218 		len -= sizeof(breq);
1219 	}
1220 	LIST_FOREACH(bif, &sc->sc_spanlist, bif_next) {
1221 		if (len < sizeof(breq))
1222 			break;
1223 
1224 		strlcpy(breq.ifbr_ifsname, bif->bif_ifp->if_xname,
1225 		    sizeof(breq.ifbr_ifsname));
1226 		breq.ifbr_ifsflags = bif->bif_flags;
1227 		breq.ifbr_portno = bif->bif_ifp->if_index & 0xfff;
1228 		memcpy(buf, &breq, sizeof(breq));
1229 		count++;
1230 		buf += sizeof(breq);
1231 		len -= sizeof(breq);
1232 	}
1233 
1234 	BRIDGE_UNLOCK(sc);
1235 	bifc->ifbic_len = sizeof(breq) * count;
1236 	error = copyout(outbuf, bifc->ifbic_req, bifc->ifbic_len);
1237 	BRIDGE_LOCK(sc);
1238 	free(outbuf, M_TEMP);
1239 	return (error);
1240 }
1241 
1242 static int
1243 bridge_ioctl_rts(struct bridge_softc *sc, void *arg)
1244 {
1245 	struct ifbaconf *bac = arg;
1246 	struct bridge_rtnode *brt;
1247 	struct ifbareq bareq;
1248 	char *buf, *outbuf;
1249 	int count, buflen, len, error = 0;
1250 
1251 	if (bac->ifbac_len == 0)
1252 		return (0);
1253 
1254 	count = 0;
1255 	LIST_FOREACH(brt, &sc->sc_rtlist, brt_list)
1256 		count++;
1257 	buflen = sizeof(bareq) * count;
1258 
1259 	BRIDGE_UNLOCK(sc);
1260 	outbuf = malloc(buflen, M_TEMP, M_WAITOK | M_ZERO);
1261 	BRIDGE_LOCK(sc);
1262 
1263 	count = 0;
1264 	buf = outbuf;
1265 	len = min(bac->ifbac_len, buflen);
1266 	bzero(&bareq, sizeof(bareq));
1267 	LIST_FOREACH(brt, &sc->sc_rtlist, brt_list) {
1268 		if (len < sizeof(bareq))
1269 			goto out;
1270 		strlcpy(bareq.ifba_ifsname, brt->brt_ifp->if_xname,
1271 		    sizeof(bareq.ifba_ifsname));
1272 		memcpy(bareq.ifba_dst, brt->brt_addr, sizeof(brt->brt_addr));
1273 		bareq.ifba_vlan = brt->brt_vlan;
1274 		if ((brt->brt_flags & IFBAF_TYPEMASK) == IFBAF_DYNAMIC &&
1275 				time_uptime < brt->brt_expire)
1276 			bareq.ifba_expire = brt->brt_expire - time_uptime;
1277 		else
1278 			bareq.ifba_expire = 0;
1279 		bareq.ifba_flags = brt->brt_flags;
1280 
1281 		memcpy(buf, &bareq, sizeof(bareq));
1282 		count++;
1283 		buf += sizeof(bareq);
1284 		len -= sizeof(bareq);
1285 	}
1286 out:
1287 	BRIDGE_UNLOCK(sc);
1288 	bac->ifbac_len = sizeof(bareq) * count;
1289 	error = copyout(outbuf, bac->ifbac_req, bac->ifbac_len);
1290 	BRIDGE_LOCK(sc);
1291 	free(outbuf, M_TEMP);
1292 	return (error);
1293 }
1294 
1295 static int
1296 bridge_ioctl_saddr(struct bridge_softc *sc, void *arg)
1297 {
1298 	struct ifbareq *req = arg;
1299 	struct bridge_iflist *bif;
1300 	int error;
1301 
1302 	bif = bridge_lookup_member(sc, req->ifba_ifsname);
1303 	if (bif == NULL)
1304 		return (ENOENT);
1305 
1306 	error = bridge_rtupdate(sc, req->ifba_dst, req->ifba_vlan, bif, 1,
1307 	    req->ifba_flags);
1308 
1309 	return (error);
1310 }
1311 
1312 static int
1313 bridge_ioctl_sto(struct bridge_softc *sc, void *arg)
1314 {
1315 	struct ifbrparam *param = arg;
1316 
1317 	sc->sc_brttimeout = param->ifbrp_ctime;
1318 	return (0);
1319 }
1320 
1321 static int
1322 bridge_ioctl_gto(struct bridge_softc *sc, void *arg)
1323 {
1324 	struct ifbrparam *param = arg;
1325 
1326 	param->ifbrp_ctime = sc->sc_brttimeout;
1327 	return (0);
1328 }
1329 
1330 static int
1331 bridge_ioctl_daddr(struct bridge_softc *sc, void *arg)
1332 {
1333 	struct ifbareq *req = arg;
1334 
1335 	return (bridge_rtdaddr(sc, req->ifba_dst, req->ifba_vlan));
1336 }
1337 
1338 static int
1339 bridge_ioctl_flush(struct bridge_softc *sc, void *arg)
1340 {
1341 	struct ifbreq *req = arg;
1342 
1343 	bridge_rtflush(sc, req->ifbr_ifsflags);
1344 	return (0);
1345 }
1346 
1347 static int
1348 bridge_ioctl_gpri(struct bridge_softc *sc, void *arg)
1349 {
1350 	struct ifbrparam *param = arg;
1351 	struct bstp_state *bs = &sc->sc_stp;
1352 
1353 	param->ifbrp_prio = bs->bs_bridge_priority;
1354 	return (0);
1355 }
1356 
1357 static int
1358 bridge_ioctl_spri(struct bridge_softc *sc, void *arg)
1359 {
1360 	struct ifbrparam *param = arg;
1361 
1362 	return (bstp_set_priority(&sc->sc_stp, param->ifbrp_prio));
1363 }
1364 
1365 static int
1366 bridge_ioctl_ght(struct bridge_softc *sc, void *arg)
1367 {
1368 	struct ifbrparam *param = arg;
1369 	struct bstp_state *bs = &sc->sc_stp;
1370 
1371 	param->ifbrp_hellotime = bs->bs_bridge_htime >> 8;
1372 	return (0);
1373 }
1374 
1375 static int
1376 bridge_ioctl_sht(struct bridge_softc *sc, void *arg)
1377 {
1378 	struct ifbrparam *param = arg;
1379 
1380 	return (bstp_set_htime(&sc->sc_stp, param->ifbrp_hellotime));
1381 }
1382 
1383 static int
1384 bridge_ioctl_gfd(struct bridge_softc *sc, void *arg)
1385 {
1386 	struct ifbrparam *param = arg;
1387 	struct bstp_state *bs = &sc->sc_stp;
1388 
1389 	param->ifbrp_fwddelay = bs->bs_bridge_fdelay >> 8;
1390 	return (0);
1391 }
1392 
1393 static int
1394 bridge_ioctl_sfd(struct bridge_softc *sc, void *arg)
1395 {
1396 	struct ifbrparam *param = arg;
1397 
1398 	return (bstp_set_fdelay(&sc->sc_stp, param->ifbrp_fwddelay));
1399 }
1400 
1401 static int
1402 bridge_ioctl_gma(struct bridge_softc *sc, void *arg)
1403 {
1404 	struct ifbrparam *param = arg;
1405 	struct bstp_state *bs = &sc->sc_stp;
1406 
1407 	param->ifbrp_maxage = bs->bs_bridge_max_age >> 8;
1408 	return (0);
1409 }
1410 
1411 static int
1412 bridge_ioctl_sma(struct bridge_softc *sc, void *arg)
1413 {
1414 	struct ifbrparam *param = arg;
1415 
1416 	return (bstp_set_maxage(&sc->sc_stp, param->ifbrp_maxage));
1417 }
1418 
1419 static int
1420 bridge_ioctl_sifprio(struct bridge_softc *sc, void *arg)
1421 {
1422 	struct ifbreq *req = arg;
1423 	struct bridge_iflist *bif;
1424 
1425 	bif = bridge_lookup_member(sc, req->ifbr_ifsname);
1426 	if (bif == NULL)
1427 		return (ENOENT);
1428 
1429 	return (bstp_set_port_priority(&bif->bif_stp, req->ifbr_priority));
1430 }
1431 
1432 static int
1433 bridge_ioctl_sifcost(struct bridge_softc *sc, void *arg)
1434 {
1435 	struct ifbreq *req = arg;
1436 	struct bridge_iflist *bif;
1437 
1438 	bif = bridge_lookup_member(sc, req->ifbr_ifsname);
1439 	if (bif == NULL)
1440 		return (ENOENT);
1441 
1442 	return (bstp_set_path_cost(&bif->bif_stp, req->ifbr_path_cost));
1443 }
1444 
1445 static int
1446 bridge_ioctl_sifmaxaddr(struct bridge_softc *sc, void *arg)
1447 {
1448 	struct ifbreq *req = arg;
1449 	struct bridge_iflist *bif;
1450 
1451 	bif = bridge_lookup_member(sc, req->ifbr_ifsname);
1452 	if (bif == NULL)
1453 		return (ENOENT);
1454 
1455 	bif->bif_addrmax = req->ifbr_addrmax;
1456 	return (0);
1457 }
1458 
1459 static int
1460 bridge_ioctl_addspan(struct bridge_softc *sc, void *arg)
1461 {
1462 	struct ifbreq *req = arg;
1463 	struct bridge_iflist *bif = NULL;
1464 	struct ifnet *ifs;
1465 
1466 	ifs = ifunit(req->ifbr_ifsname);
1467 	if (ifs == NULL)
1468 		return (ENOENT);
1469 
1470 	LIST_FOREACH(bif, &sc->sc_spanlist, bif_next)
1471 		if (ifs == bif->bif_ifp)
1472 			return (EBUSY);
1473 
1474 	if (ifs->if_bridge != NULL)
1475 		return (EBUSY);
1476 
1477 	switch (ifs->if_type) {
1478 		case IFT_ETHER:
1479 		case IFT_GIF:
1480 		case IFT_L2VLAN:
1481 			break;
1482 		default:
1483 			return (EINVAL);
1484 	}
1485 
1486 	bif = malloc(sizeof(*bif), M_DEVBUF, M_NOWAIT|M_ZERO);
1487 	if (bif == NULL)
1488 		return (ENOMEM);
1489 
1490 	bif->bif_ifp = ifs;
1491 	bif->bif_flags = IFBIF_SPAN;
1492 
1493 	LIST_INSERT_HEAD(&sc->sc_spanlist, bif, bif_next);
1494 
1495 	return (0);
1496 }
1497 
1498 static int
1499 bridge_ioctl_delspan(struct bridge_softc *sc, void *arg)
1500 {
1501 	struct ifbreq *req = arg;
1502 	struct bridge_iflist *bif;
1503 	struct ifnet *ifs;
1504 
1505 	ifs = ifunit(req->ifbr_ifsname);
1506 	if (ifs == NULL)
1507 		return (ENOENT);
1508 
1509 	LIST_FOREACH(bif, &sc->sc_spanlist, bif_next)
1510 		if (ifs == bif->bif_ifp)
1511 			break;
1512 
1513 	if (bif == NULL)
1514 		return (ENOENT);
1515 
1516 	bridge_delete_span(sc, bif);
1517 
1518 	return (0);
1519 }
1520 
1521 static int
1522 bridge_ioctl_gbparam(struct bridge_softc *sc, void *arg)
1523 {
1524 	struct ifbropreq *req = arg;
1525 	struct bstp_state *bs = &sc->sc_stp;
1526 	struct bstp_port *root_port;
1527 
1528 	req->ifbop_maxage = bs->bs_bridge_max_age >> 8;
1529 	req->ifbop_hellotime = bs->bs_bridge_htime >> 8;
1530 	req->ifbop_fwddelay = bs->bs_bridge_fdelay >> 8;
1531 
1532 	root_port = bs->bs_root_port;
1533 	if (root_port == NULL)
1534 		req->ifbop_root_port = 0;
1535 	else
1536 		req->ifbop_root_port = root_port->bp_ifp->if_index;
1537 
1538 	req->ifbop_holdcount = bs->bs_txholdcount;
1539 	req->ifbop_priority = bs->bs_bridge_priority;
1540 	req->ifbop_protocol = bs->bs_protover;
1541 	req->ifbop_root_path_cost = bs->bs_root_pv.pv_cost;
1542 	req->ifbop_bridgeid = bs->bs_bridge_pv.pv_dbridge_id;
1543 	req->ifbop_designated_root = bs->bs_root_pv.pv_root_id;
1544 	req->ifbop_designated_bridge = bs->bs_root_pv.pv_dbridge_id;
1545 	req->ifbop_last_tc_time.tv_sec = bs->bs_last_tc_time.tv_sec;
1546 	req->ifbop_last_tc_time.tv_usec = bs->bs_last_tc_time.tv_usec;
1547 
1548 	return (0);
1549 }
1550 
1551 static int
1552 bridge_ioctl_grte(struct bridge_softc *sc, void *arg)
1553 {
1554 	struct ifbrparam *param = arg;
1555 
1556 	param->ifbrp_cexceeded = sc->sc_brtexceeded;
1557 	return (0);
1558 }
1559 
1560 static int
1561 bridge_ioctl_gifsstp(struct bridge_softc *sc, void *arg)
1562 {
1563 	struct ifbpstpconf *bifstp = arg;
1564 	struct bridge_iflist *bif;
1565 	struct bstp_port *bp;
1566 	struct ifbpstpreq bpreq;
1567 	char *buf, *outbuf;
1568 	int count, buflen, len, error = 0;
1569 
1570 	count = 0;
1571 	LIST_FOREACH(bif, &sc->sc_iflist, bif_next) {
1572 		if ((bif->bif_flags & IFBIF_STP) != 0)
1573 			count++;
1574 	}
1575 
1576 	buflen = sizeof(bpreq) * count;
1577 	if (bifstp->ifbpstp_len == 0) {
1578 		bifstp->ifbpstp_len = buflen;
1579 		return (0);
1580 	}
1581 
1582 	BRIDGE_UNLOCK(sc);
1583 	outbuf = malloc(buflen, M_TEMP, M_WAITOK | M_ZERO);
1584 	BRIDGE_LOCK(sc);
1585 
1586 	count = 0;
1587 	buf = outbuf;
1588 	len = min(bifstp->ifbpstp_len, buflen);
1589 	bzero(&bpreq, sizeof(bpreq));
1590 	LIST_FOREACH(bif, &sc->sc_iflist, bif_next) {
1591 		if (len < sizeof(bpreq))
1592 			break;
1593 
1594 		if ((bif->bif_flags & IFBIF_STP) == 0)
1595 			continue;
1596 
1597 		bp = &bif->bif_stp;
1598 		bpreq.ifbp_portno = bif->bif_ifp->if_index & 0xfff;
1599 		bpreq.ifbp_fwd_trans = bp->bp_forward_transitions;
1600 		bpreq.ifbp_design_cost = bp->bp_desg_pv.pv_cost;
1601 		bpreq.ifbp_design_port = bp->bp_desg_pv.pv_port_id;
1602 		bpreq.ifbp_design_bridge = bp->bp_desg_pv.pv_dbridge_id;
1603 		bpreq.ifbp_design_root = bp->bp_desg_pv.pv_root_id;
1604 
1605 		memcpy(buf, &bpreq, sizeof(bpreq));
1606 		count++;
1607 		buf += sizeof(bpreq);
1608 		len -= sizeof(bpreq);
1609 	}
1610 
1611 	BRIDGE_UNLOCK(sc);
1612 	bifstp->ifbpstp_len = sizeof(bpreq) * count;
1613 	error = copyout(outbuf, bifstp->ifbpstp_req, bifstp->ifbpstp_len);
1614 	BRIDGE_LOCK(sc);
1615 	free(outbuf, M_TEMP);
1616 	return (error);
1617 }
1618 
1619 static int
1620 bridge_ioctl_sproto(struct bridge_softc *sc, void *arg)
1621 {
1622 	struct ifbrparam *param = arg;
1623 
1624 	return (bstp_set_protocol(&sc->sc_stp, param->ifbrp_proto));
1625 }
1626 
1627 static int
1628 bridge_ioctl_stxhc(struct bridge_softc *sc, void *arg)
1629 {
1630 	struct ifbrparam *param = arg;
1631 
1632 	return (bstp_set_holdcount(&sc->sc_stp, param->ifbrp_txhc));
1633 }
1634 
1635 /*
1636  * bridge_ifdetach:
1637  *
1638  *	Detach an interface from a bridge.  Called when a member
1639  *	interface is detaching.
1640  */
1641 static void
1642 bridge_ifdetach(void *arg __unused, struct ifnet *ifp)
1643 {
1644 	struct bridge_softc *sc = ifp->if_bridge;
1645 	struct bridge_iflist *bif;
1646 
1647 	/* Check if the interface is a bridge member */
1648 	if (sc != NULL) {
1649 		BRIDGE_LOCK(sc);
1650 
1651 		bif = bridge_lookup_member_if(sc, ifp);
1652 		if (bif != NULL)
1653 			bridge_delete_member(sc, bif, 1);
1654 
1655 		BRIDGE_UNLOCK(sc);
1656 		return;
1657 	}
1658 
1659 	/* Check if the interface is a span port */
1660 	mtx_lock(&bridge_list_mtx);
1661 	LIST_FOREACH(sc, &bridge_list, sc_list) {
1662 		BRIDGE_LOCK(sc);
1663 		LIST_FOREACH(bif, &sc->sc_spanlist, bif_next)
1664 			if (ifp == bif->bif_ifp) {
1665 				bridge_delete_span(sc, bif);
1666 				break;
1667 			}
1668 
1669 		BRIDGE_UNLOCK(sc);
1670 	}
1671 	mtx_unlock(&bridge_list_mtx);
1672 }
1673 
1674 /*
1675  * bridge_init:
1676  *
1677  *	Initialize a bridge interface.
1678  */
1679 static void
1680 bridge_init(void *xsc)
1681 {
1682 	struct bridge_softc *sc = (struct bridge_softc *)xsc;
1683 	struct ifnet *ifp = sc->sc_ifp;
1684 
1685 	if (ifp->if_drv_flags & IFF_DRV_RUNNING)
1686 		return;
1687 
1688 	BRIDGE_LOCK(sc);
1689 	callout_reset(&sc->sc_brcallout, bridge_rtable_prune_period * hz,
1690 	    bridge_timer, sc);
1691 
1692 	ifp->if_drv_flags |= IFF_DRV_RUNNING;
1693 	bstp_init(&sc->sc_stp);		/* Initialize Spanning Tree */
1694 
1695 	BRIDGE_UNLOCK(sc);
1696 }
1697 
1698 /*
1699  * bridge_stop:
1700  *
1701  *	Stop the bridge interface.
1702  */
1703 static void
1704 bridge_stop(struct ifnet *ifp, int disable)
1705 {
1706 	struct bridge_softc *sc = ifp->if_softc;
1707 
1708 	BRIDGE_LOCK_ASSERT(sc);
1709 
1710 	if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
1711 		return;
1712 
1713 	callout_stop(&sc->sc_brcallout);
1714 	bstp_stop(&sc->sc_stp);
1715 
1716 	bridge_rtflush(sc, IFBF_FLUSHDYN);
1717 
1718 	ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
1719 }
1720 
1721 /*
1722  * bridge_enqueue:
1723  *
1724  *	Enqueue a packet on a bridge member interface.
1725  *
1726  */
1727 static void
1728 bridge_enqueue(struct bridge_softc *sc, struct ifnet *dst_ifp, struct mbuf *m)
1729 {
1730 	int len, err = 0;
1731 	short mflags;
1732 	struct mbuf *m0;
1733 
1734 	len = m->m_pkthdr.len;
1735 	mflags = m->m_flags;
1736 
1737 	/* We may be sending a fragment so traverse the mbuf */
1738 	for (; m; m = m0) {
1739 		m0 = m->m_nextpkt;
1740 		m->m_nextpkt = NULL;
1741 
1742 		/*
1743 		 * If underlying interface can not do VLAN tag insertion itself
1744 		 * then attach a packet tag that holds it.
1745 		 */
1746 		if ((m->m_flags & M_VLANTAG) &&
1747 		    (dst_ifp->if_capenable & IFCAP_VLAN_HWTAGGING) == 0) {
1748 			m = ether_vlanencap(m, m->m_pkthdr.ether_vtag);
1749 			if (m == NULL) {
1750 				if_printf(dst_ifp,
1751 				    "unable to prepend VLAN header\n");
1752 				dst_ifp->if_oerrors++;
1753 				continue;
1754 			}
1755 			m->m_flags &= ~M_VLANTAG;
1756 		}
1757 
1758 		if (err == 0)
1759 			IFQ_ENQUEUE(&dst_ifp->if_snd, m, err);
1760 	}
1761 
1762 	if (err == 0) {
1763 
1764 		sc->sc_ifp->if_opackets++;
1765 		sc->sc_ifp->if_obytes += len;
1766 
1767 		dst_ifp->if_obytes += len;
1768 
1769 		if (mflags & M_MCAST) {
1770 			sc->sc_ifp->if_omcasts++;
1771 			dst_ifp->if_omcasts++;
1772 		}
1773 	}
1774 
1775 	if ((dst_ifp->if_drv_flags & IFF_DRV_OACTIVE) == 0)
1776 		(*dst_ifp->if_start)(dst_ifp);
1777 }
1778 
1779 /*
1780  * bridge_dummynet:
1781  *
1782  * 	Receive a queued packet from dummynet and pass it on to the output
1783  * 	interface.
1784  *
1785  *	The mbuf has the Ethernet header already attached.
1786  */
1787 static void
1788 bridge_dummynet(struct mbuf *m, struct ifnet *ifp)
1789 {
1790 	struct bridge_softc *sc;
1791 
1792 	sc = ifp->if_bridge;
1793 
1794 	/*
1795 	 * The packet didnt originate from a member interface. This should only
1796 	 * ever happen if a member interface is removed while packets are
1797 	 * queued for it.
1798 	 */
1799 	if (sc == NULL) {
1800 		m_freem(m);
1801 		return;
1802 	}
1803 
1804 	if (PFIL_HOOKED(&inet_pfil_hook)
1805 #ifdef INET6
1806 	    || PFIL_HOOKED(&inet6_pfil_hook)
1807 #endif
1808 	    ) {
1809 		if (bridge_pfil(&m, sc->sc_ifp, ifp, PFIL_OUT) != 0)
1810 			return;
1811 		if (m == NULL)
1812 			return;
1813 	}
1814 
1815 	bridge_enqueue(sc, ifp, m);
1816 }
1817 
1818 /*
1819  * bridge_output:
1820  *
1821  *	Send output from a bridge member interface.  This
1822  *	performs the bridging function for locally originated
1823  *	packets.
1824  *
1825  *	The mbuf has the Ethernet header already attached.  We must
1826  *	enqueue or free the mbuf before returning.
1827  */
1828 static int
1829 bridge_output(struct ifnet *ifp, struct mbuf *m, struct sockaddr *sa,
1830     struct rtentry *rt)
1831 {
1832 	struct ether_header *eh;
1833 	struct ifnet *dst_if;
1834 	struct bridge_softc *sc;
1835 	uint16_t vlan;
1836 
1837 	if (m->m_len < ETHER_HDR_LEN) {
1838 		m = m_pullup(m, ETHER_HDR_LEN);
1839 		if (m == NULL)
1840 			return (0);
1841 	}
1842 
1843 	eh = mtod(m, struct ether_header *);
1844 	sc = ifp->if_bridge;
1845 	vlan = VLANTAGOF(m);
1846 
1847 	BRIDGE_LOCK(sc);
1848 
1849 	/*
1850 	 * If bridge is down, but the original output interface is up,
1851 	 * go ahead and send out that interface.  Otherwise, the packet
1852 	 * is dropped below.
1853 	 */
1854 	if ((sc->sc_ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
1855 		dst_if = ifp;
1856 		goto sendunicast;
1857 	}
1858 
1859 	/*
1860 	 * If the packet is a multicast, or we don't know a better way to
1861 	 * get there, send to all interfaces.
1862 	 */
1863 	if (ETHER_IS_MULTICAST(eh->ether_dhost))
1864 		dst_if = NULL;
1865 	else
1866 		dst_if = bridge_rtlookup(sc, eh->ether_dhost, vlan);
1867 	if (dst_if == NULL) {
1868 		struct bridge_iflist *bif;
1869 		struct mbuf *mc;
1870 		int error = 0, used = 0;
1871 
1872 		bridge_span(sc, m);
1873 
1874 		BRIDGE_LOCK2REF(sc, error);
1875 		if (error) {
1876 			m_freem(m);
1877 			return (0);
1878 		}
1879 
1880 		LIST_FOREACH(bif, &sc->sc_iflist, bif_next) {
1881 			dst_if = bif->bif_ifp;
1882 
1883 			if (dst_if->if_type == IFT_GIF)
1884 				continue;
1885 			if ((dst_if->if_drv_flags & IFF_DRV_RUNNING) == 0)
1886 				continue;
1887 
1888 			/*
1889 			 * If this is not the original output interface,
1890 			 * and the interface is participating in spanning
1891 			 * tree, make sure the port is in a state that
1892 			 * allows forwarding.
1893 			 */
1894 			if (dst_if != ifp && (bif->bif_flags & IFBIF_STP) &&
1895 			    bif->bif_stp.bp_state == BSTP_IFSTATE_DISCARDING)
1896 				continue;
1897 
1898 			if (LIST_NEXT(bif, bif_next) == NULL) {
1899 				used = 1;
1900 				mc = m;
1901 			} else {
1902 				mc = m_copypacket(m, M_DONTWAIT);
1903 				if (mc == NULL) {
1904 					sc->sc_ifp->if_oerrors++;
1905 					continue;
1906 				}
1907 			}
1908 
1909 			bridge_enqueue(sc, dst_if, mc);
1910 		}
1911 		if (used == 0)
1912 			m_freem(m);
1913 		BRIDGE_UNREF(sc);
1914 		return (0);
1915 	}
1916 
1917 sendunicast:
1918 	/*
1919 	 * XXX Spanning tree consideration here?
1920 	 */
1921 
1922 	bridge_span(sc, m);
1923 	if ((dst_if->if_drv_flags & IFF_DRV_RUNNING) == 0) {
1924 		m_freem(m);
1925 		BRIDGE_UNLOCK(sc);
1926 		return (0);
1927 	}
1928 
1929 	BRIDGE_UNLOCK(sc);
1930 	bridge_enqueue(sc, dst_if, m);
1931 	return (0);
1932 }
1933 
1934 /*
1935  * bridge_start:
1936  *
1937  *	Start output on a bridge.
1938  *
1939  */
1940 static void
1941 bridge_start(struct ifnet *ifp)
1942 {
1943 	struct bridge_softc *sc;
1944 	struct mbuf *m;
1945 	struct ether_header *eh;
1946 	struct ifnet *dst_if;
1947 
1948 	sc = ifp->if_softc;
1949 
1950 	ifp->if_drv_flags |= IFF_DRV_OACTIVE;
1951 	for (;;) {
1952 		IFQ_DEQUEUE(&ifp->if_snd, m);
1953 		if (m == 0)
1954 			break;
1955 		ETHER_BPF_MTAP(ifp, m);
1956 
1957 		eh = mtod(m, struct ether_header *);
1958 		dst_if = NULL;
1959 
1960 		BRIDGE_LOCK(sc);
1961 		if ((m->m_flags & (M_BCAST|M_MCAST)) == 0) {
1962 			dst_if = bridge_rtlookup(sc, eh->ether_dhost, 1);
1963 		}
1964 
1965 		if (dst_if == NULL)
1966 			bridge_broadcast(sc, ifp, m, 0);
1967 		else {
1968 			BRIDGE_UNLOCK(sc);
1969 			bridge_enqueue(sc, dst_if, m);
1970 		}
1971 	}
1972 	ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
1973 }
1974 
1975 /*
1976  * bridge_forward:
1977  *
1978  *	The forwarding function of the bridge.
1979  *
1980  *	NOTE: Releases the lock on return.
1981  */
1982 static void
1983 bridge_forward(struct bridge_softc *sc, struct bridge_iflist *sbif,
1984     struct mbuf *m)
1985 {
1986 	struct bridge_iflist *dbif;
1987 	struct ifnet *src_if, *dst_if, *ifp;
1988 	struct ether_header *eh;
1989 	uint16_t vlan;
1990 	uint8_t *dst;
1991 	int error;
1992 
1993 	src_if = m->m_pkthdr.rcvif;
1994 	ifp = sc->sc_ifp;
1995 
1996 	ifp->if_ipackets++;
1997 	ifp->if_ibytes += m->m_pkthdr.len;
1998 	vlan = VLANTAGOF(m);
1999 
2000 	if ((sbif->bif_flags & IFBIF_STP) &&
2001 	    sbif->bif_stp.bp_state == BSTP_IFSTATE_DISCARDING)
2002 		goto drop;
2003 
2004 	eh = mtod(m, struct ether_header *);
2005 	dst = eh->ether_dhost;
2006 
2007 	/* If the interface is learning, record the address. */
2008 	if (sbif->bif_flags & IFBIF_LEARNING) {
2009 		error = bridge_rtupdate(sc, eh->ether_shost, vlan,
2010 		    sbif, 0, IFBAF_DYNAMIC);
2011 		/*
2012 		 * If the interface has addresses limits then deny any source
2013 		 * that is not in the cache.
2014 		 */
2015 		if (error && sbif->bif_addrmax)
2016 			goto drop;
2017 	}
2018 
2019 	if ((sbif->bif_flags & IFBIF_STP) != 0 &&
2020 	    sbif->bif_stp.bp_state == BSTP_IFSTATE_LEARNING)
2021 		goto drop;
2022 
2023 	/*
2024 	 * At this point, the port either doesn't participate
2025 	 * in spanning tree or it is in the forwarding state.
2026 	 */
2027 
2028 	/*
2029 	 * If the packet is unicast, destined for someone on
2030 	 * "this" side of the bridge, drop it.
2031 	 */
2032 	if ((m->m_flags & (M_BCAST|M_MCAST)) == 0) {
2033 		dst_if = bridge_rtlookup(sc, dst, vlan);
2034 		if (src_if == dst_if)
2035 			goto drop;
2036 	} else {
2037 		/*
2038 		 * Check if its a reserved multicast address, any address
2039 		 * listed in 802.1D section 7.12.6 may not be forwarded by the
2040 		 * bridge.
2041 		 * This is currently 01-80-C2-00-00-00 to 01-80-C2-00-00-0F
2042 		 */
2043 		if (dst[0] == 0x01 && dst[1] == 0x80 &&
2044 		    dst[2] == 0xc2 && dst[3] == 0x00 &&
2045 		    dst[4] == 0x00 && dst[5] <= 0x0f)
2046 			goto drop;
2047 
2048 		/* ...forward it to all interfaces. */
2049 		ifp->if_imcasts++;
2050 		dst_if = NULL;
2051 	}
2052 
2053 	/*
2054 	 * If we have a destination interface which is a member of our bridge,
2055 	 * OR this is a unicast packet, push it through the bpf(4) machinery.
2056 	 * For broadcast or multicast packets, don't bother because it will
2057 	 * be reinjected into ether_input. We do this before we pass the packets
2058 	 * through the pfil(9) framework, as it is possible that pfil(9) will
2059 	 * drop the packet, or possibly modify it, making it difficult to debug
2060 	 * firewall issues on the bridge.
2061 	 */
2062 	if (dst_if != NULL || (m->m_flags & (M_BCAST | M_MCAST)) == 0)
2063 		ETHER_BPF_MTAP(ifp, m);
2064 
2065 	/* run the packet filter */
2066 	if (PFIL_HOOKED(&inet_pfil_hook)
2067 #ifdef INET6
2068 	    || PFIL_HOOKED(&inet6_pfil_hook)
2069 #endif
2070 	    ) {
2071 		BRIDGE_UNLOCK(sc);
2072 		if (bridge_pfil(&m, ifp, src_if, PFIL_IN) != 0)
2073 			return;
2074 		if (m == NULL)
2075 			return;
2076 		BRIDGE_LOCK(sc);
2077 	}
2078 
2079 	if (dst_if == NULL) {
2080 		bridge_broadcast(sc, src_if, m, 1);
2081 		return;
2082 	}
2083 
2084 	/*
2085 	 * At this point, we're dealing with a unicast frame
2086 	 * going to a different interface.
2087 	 */
2088 	if ((dst_if->if_drv_flags & IFF_DRV_RUNNING) == 0)
2089 		goto drop;
2090 
2091 	dbif = bridge_lookup_member_if(sc, dst_if);
2092 	if (dbif == NULL)
2093 		/* Not a member of the bridge (anymore?) */
2094 		goto drop;
2095 
2096 	/* Private segments can not talk to each other */
2097 	if (sbif->bif_flags & dbif->bif_flags & IFBIF_PRIVATE)
2098 		goto drop;
2099 
2100 	if ((dbif->bif_flags & IFBIF_STP) &&
2101 	    dbif->bif_stp.bp_state == BSTP_IFSTATE_DISCARDING)
2102 		goto drop;
2103 
2104 	BRIDGE_UNLOCK(sc);
2105 
2106 	if (PFIL_HOOKED(&inet_pfil_hook)
2107 #ifdef INET6
2108 	    || PFIL_HOOKED(&inet6_pfil_hook)
2109 #endif
2110 	    ) {
2111 		if (bridge_pfil(&m, ifp, dst_if, PFIL_OUT) != 0)
2112 			return;
2113 		if (m == NULL)
2114 			return;
2115 	}
2116 
2117 	bridge_enqueue(sc, dst_if, m);
2118 	return;
2119 
2120 drop:
2121 	BRIDGE_UNLOCK(sc);
2122 	m_freem(m);
2123 }
2124 
2125 /*
2126  * bridge_input:
2127  *
2128  *	Receive input from a member interface.  Queue the packet for
2129  *	bridging if it is not for us.
2130  */
2131 static struct mbuf *
2132 bridge_input(struct ifnet *ifp, struct mbuf *m)
2133 {
2134 	struct bridge_softc *sc = ifp->if_bridge;
2135 	struct bridge_iflist *bif, *bif2;
2136 	struct ifnet *bifp;
2137 	struct ether_header *eh;
2138 	struct mbuf *mc, *mc2;
2139 	uint16_t vlan;
2140 	int error;
2141 
2142 	if ((sc->sc_ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
2143 		return (m);
2144 
2145 	bifp = sc->sc_ifp;
2146 	vlan = VLANTAGOF(m);
2147 
2148 	/*
2149 	 * Implement support for bridge monitoring. If this flag has been
2150 	 * set on this interface, discard the packet once we push it through
2151 	 * the bpf(4) machinery, but before we do, increment the byte and
2152 	 * packet counters associated with this interface.
2153 	 */
2154 	if ((bifp->if_flags & IFF_MONITOR) != 0) {
2155 		m->m_pkthdr.rcvif  = bifp;
2156 		ETHER_BPF_MTAP(bifp, m);
2157 		bifp->if_ipackets++;
2158 		bifp->if_ibytes += m->m_pkthdr.len;
2159 		m_freem(m);
2160 		return (NULL);
2161 	}
2162 	BRIDGE_LOCK(sc);
2163 	bif = bridge_lookup_member_if(sc, ifp);
2164 	if (bif == NULL) {
2165 		BRIDGE_UNLOCK(sc);
2166 		return (m);
2167 	}
2168 
2169 	eh = mtod(m, struct ether_header *);
2170 
2171 	bridge_span(sc, m);
2172 
2173 	if (m->m_flags & (M_BCAST|M_MCAST)) {
2174 		/* Tap off 802.1D packets; they do not get forwarded. */
2175 		if (memcmp(eh->ether_dhost, bstp_etheraddr,
2176 		    ETHER_ADDR_LEN) == 0) {
2177 			m = bstp_input(&bif->bif_stp, ifp, m);
2178 			if (m == NULL) {
2179 				BRIDGE_UNLOCK(sc);
2180 				return (NULL);
2181 			}
2182 		}
2183 
2184 		if ((bif->bif_flags & IFBIF_STP) &&
2185 		    bif->bif_stp.bp_state == BSTP_IFSTATE_DISCARDING) {
2186 			BRIDGE_UNLOCK(sc);
2187 			return (m);
2188 		}
2189 
2190 		/*
2191 		 * Make a deep copy of the packet and enqueue the copy
2192 		 * for bridge processing; return the original packet for
2193 		 * local processing.
2194 		 */
2195 		mc = m_dup(m, M_DONTWAIT);
2196 		if (mc == NULL) {
2197 			BRIDGE_UNLOCK(sc);
2198 			return (m);
2199 		}
2200 
2201 		/* Perform the bridge forwarding function with the copy. */
2202 		bridge_forward(sc, bif, mc);
2203 
2204 		/*
2205 		 * Reinject the mbuf as arriving on the bridge so we have a
2206 		 * chance at claiming multicast packets. We can not loop back
2207 		 * here from ether_input as a bridge is never a member of a
2208 		 * bridge.
2209 		 */
2210 		KASSERT(bifp->if_bridge == NULL,
2211 		    ("loop created in bridge_input"));
2212 		mc2 = m_dup(m, M_DONTWAIT);
2213 		if (mc2 != NULL) {
2214 			/* Keep the layer3 header aligned */
2215 			int i = min(mc2->m_pkthdr.len, max_protohdr);
2216 			mc2 = m_copyup(mc2, i, ETHER_ALIGN);
2217 		}
2218 		if (mc2 != NULL) {
2219 			mc2->m_pkthdr.rcvif = bifp;
2220 			(*bifp->if_input)(bifp, mc2);
2221 		}
2222 
2223 		/* Return the original packet for local processing. */
2224 		return (m);
2225 	}
2226 
2227 	if ((bif->bif_flags & IFBIF_STP) &&
2228 	    bif->bif_stp.bp_state == BSTP_IFSTATE_DISCARDING) {
2229 		BRIDGE_UNLOCK(sc);
2230 		return (m);
2231 	}
2232 
2233 #ifdef DEV_CARP
2234 #   define OR_CARP_CHECK_WE_ARE_DST(iface) \
2235 	|| ((iface)->if_carp \
2236 	    && carp_forus((iface)->if_carp, eh->ether_dhost))
2237 #   define OR_CARP_CHECK_WE_ARE_SRC(iface) \
2238 	|| ((iface)->if_carp \
2239 	    && carp_forus((iface)->if_carp, eh->ether_shost))
2240 #else
2241 #   define OR_CARP_CHECK_WE_ARE_DST(iface)
2242 #   define OR_CARP_CHECK_WE_ARE_SRC(iface)
2243 #endif
2244 
2245 #ifdef INET6
2246 #   define OR_PFIL_HOOKED_INET6 \
2247 	|| PFIL_HOOKED(&inet6_pfil_hook)
2248 #else
2249 #   define OR_PFIL_HOOKED_INET6
2250 #endif
2251 
2252 #define GRAB_OUR_PACKETS(iface) \
2253 	if ((iface)->if_type == IFT_GIF) \
2254 		continue; \
2255 	/* It is destined for us. */ \
2256 	if (memcmp(IF_LLADDR((iface)), eh->ether_dhost,  ETHER_ADDR_LEN) == 0 \
2257 	    OR_CARP_CHECK_WE_ARE_DST((iface))				\
2258 	    ) {								\
2259 		if ((iface)->if_type == IFT_BRIDGE) {			\
2260 			ETHER_BPF_MTAP(iface, m);			\
2261 			iface->if_ipackets++;				\
2262 			/* Filter on the physical interface. */		\
2263 			if (pfil_local_phys &&				\
2264 			    (PFIL_HOOKED(&inet_pfil_hook)		\
2265 			     OR_PFIL_HOOKED_INET6)) {			\
2266 				if (bridge_pfil(&m, NULL, ifp,		\
2267 				    PFIL_IN) != 0 || m == NULL) {	\
2268 					BRIDGE_UNLOCK(sc);		\
2269 					return (NULL);			\
2270 				}					\
2271 			}						\
2272 		}							\
2273 		if (bif->bif_flags & IFBIF_LEARNING) {			\
2274 			error = bridge_rtupdate(sc, eh->ether_shost,	\
2275 			    vlan, bif, 0, IFBAF_DYNAMIC);		\
2276 			if (error && bif->bif_addrmax) {		\
2277 				BRIDGE_UNLOCK(sc);			\
2278 				m_freem(m);				\
2279 				return (NULL);				\
2280 			}						\
2281 		}							\
2282 		m->m_pkthdr.rcvif = iface;				\
2283 		BRIDGE_UNLOCK(sc);					\
2284 		return (m);						\
2285 	}								\
2286 									\
2287 	/* We just received a packet that we sent out. */		\
2288 	if (memcmp(IF_LLADDR((iface)), eh->ether_shost, ETHER_ADDR_LEN) == 0 \
2289 	    OR_CARP_CHECK_WE_ARE_SRC((iface))			\
2290 	    ) {								\
2291 		BRIDGE_UNLOCK(sc);					\
2292 		m_freem(m);						\
2293 		return (NULL);						\
2294 	}
2295 
2296 	/*
2297 	 * Unicast.  Make sure it's not for the bridge.
2298 	 */
2299 	do { GRAB_OUR_PACKETS(bifp) } while (0);
2300 
2301 	/*
2302 	 * Give a chance for ifp at first priority. This will help when	the
2303 	 * packet comes through the interface like VLAN's with the same MACs
2304 	 * on several interfaces from the same bridge. This also will save
2305 	 * some CPU cycles in case the destination interface and the input
2306 	 * interface (eq ifp) are the same.
2307 	 */
2308 	do { GRAB_OUR_PACKETS(ifp) } while (0);
2309 
2310 	/* Now check the all bridge members. */
2311 	LIST_FOREACH(bif2, &sc->sc_iflist, bif_next) {
2312 		GRAB_OUR_PACKETS(bif2->bif_ifp)
2313 	}
2314 
2315 #undef OR_CARP_CHECK_WE_ARE_DST
2316 #undef OR_CARP_CHECK_WE_ARE_SRC
2317 #undef OR_PFIL_HOOKED_INET6
2318 #undef GRAB_OUR_PACKETS
2319 
2320 	/* Perform the bridge forwarding function. */
2321 	bridge_forward(sc, bif, m);
2322 
2323 	return (NULL);
2324 }
2325 
2326 /*
2327  * bridge_broadcast:
2328  *
2329  *	Send a frame to all interfaces that are members of
2330  *	the bridge, except for the one on which the packet
2331  *	arrived.
2332  *
2333  *	NOTE: Releases the lock on return.
2334  */
2335 static void
2336 bridge_broadcast(struct bridge_softc *sc, struct ifnet *src_if,
2337     struct mbuf *m, int runfilt)
2338 {
2339 	struct bridge_iflist *dbif, *sbif;
2340 	struct mbuf *mc;
2341 	struct ifnet *dst_if;
2342 	int error = 0, used = 0, i;
2343 
2344 	sbif = bridge_lookup_member_if(sc, src_if);
2345 
2346 	BRIDGE_LOCK2REF(sc, error);
2347 	if (error) {
2348 		m_freem(m);
2349 		return;
2350 	}
2351 
2352 	/* Filter on the bridge interface before broadcasting */
2353 	if (runfilt && (PFIL_HOOKED(&inet_pfil_hook)
2354 #ifdef INET6
2355 	    || PFIL_HOOKED(&inet6_pfil_hook)
2356 #endif
2357 	    )) {
2358 		if (bridge_pfil(&m, sc->sc_ifp, NULL, PFIL_OUT) != 0)
2359 			goto out;
2360 		if (m == NULL)
2361 			goto out;
2362 	}
2363 
2364 	LIST_FOREACH(dbif, &sc->sc_iflist, bif_next) {
2365 		dst_if = dbif->bif_ifp;
2366 		if (dst_if == src_if)
2367 			continue;
2368 
2369 		/* Private segments can not talk to each other */
2370 		if (sbif && (sbif->bif_flags & dbif->bif_flags & IFBIF_PRIVATE))
2371 			continue;
2372 
2373 		if ((dbif->bif_flags & IFBIF_STP) &&
2374 		    dbif->bif_stp.bp_state == BSTP_IFSTATE_DISCARDING)
2375 			continue;
2376 
2377 		if ((dbif->bif_flags & IFBIF_DISCOVER) == 0 &&
2378 		    (m->m_flags & (M_BCAST|M_MCAST)) == 0)
2379 			continue;
2380 
2381 		if ((dst_if->if_drv_flags & IFF_DRV_RUNNING) == 0)
2382 			continue;
2383 
2384 		if (LIST_NEXT(dbif, bif_next) == NULL) {
2385 			mc = m;
2386 			used = 1;
2387 		} else {
2388 			mc = m_dup(m, M_DONTWAIT);
2389 			if (mc == NULL) {
2390 				sc->sc_ifp->if_oerrors++;
2391 				continue;
2392 			}
2393 		}
2394 
2395 		/*
2396 		 * Filter on the output interface. Pass a NULL bridge interface
2397 		 * pointer so we do not redundantly filter on the bridge for
2398 		 * each interface we broadcast on.
2399 		 */
2400 		if (runfilt && (PFIL_HOOKED(&inet_pfil_hook)
2401 #ifdef INET6
2402 		    || PFIL_HOOKED(&inet6_pfil_hook)
2403 #endif
2404 		    )) {
2405 			if (used == 0) {
2406 				/* Keep the layer3 header aligned */
2407 				i = min(mc->m_pkthdr.len, max_protohdr);
2408 				mc = m_copyup(mc, i, ETHER_ALIGN);
2409 				if (mc == NULL) {
2410 					sc->sc_ifp->if_oerrors++;
2411 					continue;
2412 				}
2413 			}
2414 			if (bridge_pfil(&mc, NULL, dst_if, PFIL_OUT) != 0)
2415 				continue;
2416 			if (mc == NULL)
2417 				continue;
2418 		}
2419 
2420 		bridge_enqueue(sc, dst_if, mc);
2421 	}
2422 	if (used == 0)
2423 		m_freem(m);
2424 
2425 out:
2426 	BRIDGE_UNREF(sc);
2427 }
2428 
2429 /*
2430  * bridge_span:
2431  *
2432  *	Duplicate a packet out one or more interfaces that are in span mode,
2433  *	the original mbuf is unmodified.
2434  */
2435 static void
2436 bridge_span(struct bridge_softc *sc, struct mbuf *m)
2437 {
2438 	struct bridge_iflist *bif;
2439 	struct ifnet *dst_if;
2440 	struct mbuf *mc;
2441 
2442 	if (LIST_EMPTY(&sc->sc_spanlist))
2443 		return;
2444 
2445 	LIST_FOREACH(bif, &sc->sc_spanlist, bif_next) {
2446 		dst_if = bif->bif_ifp;
2447 
2448 		if ((dst_if->if_drv_flags & IFF_DRV_RUNNING) == 0)
2449 			continue;
2450 
2451 		mc = m_copypacket(m, M_DONTWAIT);
2452 		if (mc == NULL) {
2453 			sc->sc_ifp->if_oerrors++;
2454 			continue;
2455 		}
2456 
2457 		bridge_enqueue(sc, dst_if, mc);
2458 	}
2459 }
2460 
2461 /*
2462  * bridge_rtupdate:
2463  *
2464  *	Add a bridge routing entry.
2465  */
2466 static int
2467 bridge_rtupdate(struct bridge_softc *sc, const uint8_t *dst, uint16_t vlan,
2468     struct bridge_iflist *bif, int setflags, uint8_t flags)
2469 {
2470 	struct bridge_rtnode *brt;
2471 	int error;
2472 
2473 	BRIDGE_LOCK_ASSERT(sc);
2474 
2475 	/* Check the source address is valid and not multicast. */
2476 	if (ETHER_IS_MULTICAST(dst) ||
2477 	    (dst[0] == 0 && dst[1] == 0 && dst[2] == 0 &&
2478 	     dst[3] == 0 && dst[4] == 0 && dst[5] == 0) != 0)
2479 		return (EINVAL);
2480 
2481 	/* 802.1p frames map to vlan 1 */
2482 	if (vlan == 0)
2483 		vlan = 1;
2484 
2485 	/*
2486 	 * A route for this destination might already exist.  If so,
2487 	 * update it, otherwise create a new one.
2488 	 */
2489 	if ((brt = bridge_rtnode_lookup(sc, dst, vlan)) == NULL) {
2490 		if (sc->sc_brtcnt >= sc->sc_brtmax) {
2491 			sc->sc_brtexceeded++;
2492 			return (ENOSPC);
2493 		}
2494 		/* Check per interface address limits (if enabled) */
2495 		if (bif->bif_addrmax && bif->bif_addrcnt >= bif->bif_addrmax) {
2496 			bif->bif_addrexceeded++;
2497 			return (ENOSPC);
2498 		}
2499 
2500 		/*
2501 		 * Allocate a new bridge forwarding node, and
2502 		 * initialize the expiration time and Ethernet
2503 		 * address.
2504 		 */
2505 		brt = uma_zalloc(bridge_rtnode_zone, M_NOWAIT | M_ZERO);
2506 		if (brt == NULL)
2507 			return (ENOMEM);
2508 
2509 		if (bif->bif_flags & IFBIF_STICKY)
2510 			brt->brt_flags = IFBAF_STICKY;
2511 		else
2512 			brt->brt_flags = IFBAF_DYNAMIC;
2513 
2514 		memcpy(brt->brt_addr, dst, ETHER_ADDR_LEN);
2515 		brt->brt_vlan = vlan;
2516 
2517 		if ((error = bridge_rtnode_insert(sc, brt)) != 0) {
2518 			uma_zfree(bridge_rtnode_zone, brt);
2519 			return (error);
2520 		}
2521 		brt->brt_dst = bif;
2522 		bif->bif_addrcnt++;
2523 	}
2524 
2525 	if ((brt->brt_flags & IFBAF_TYPEMASK) == IFBAF_DYNAMIC &&
2526 	    brt->brt_dst != bif) {
2527 		brt->brt_dst->bif_addrcnt--;
2528 		brt->brt_dst = bif;
2529 		brt->brt_dst->bif_addrcnt++;
2530 	}
2531 
2532 	if ((flags & IFBAF_TYPEMASK) == IFBAF_DYNAMIC)
2533 		brt->brt_expire = time_uptime + sc->sc_brttimeout;
2534 	if (setflags)
2535 		brt->brt_flags = flags;
2536 
2537 	return (0);
2538 }
2539 
2540 /*
2541  * bridge_rtlookup:
2542  *
2543  *	Lookup the destination interface for an address.
2544  */
2545 static struct ifnet *
2546 bridge_rtlookup(struct bridge_softc *sc, const uint8_t *addr, uint16_t vlan)
2547 {
2548 	struct bridge_rtnode *brt;
2549 
2550 	BRIDGE_LOCK_ASSERT(sc);
2551 
2552 	if ((brt = bridge_rtnode_lookup(sc, addr, vlan)) == NULL)
2553 		return (NULL);
2554 
2555 	return (brt->brt_ifp);
2556 }
2557 
2558 /*
2559  * bridge_rttrim:
2560  *
2561  *	Trim the routine table so that we have a number
2562  *	of routing entries less than or equal to the
2563  *	maximum number.
2564  */
2565 static void
2566 bridge_rttrim(struct bridge_softc *sc)
2567 {
2568 	struct bridge_rtnode *brt, *nbrt;
2569 
2570 	BRIDGE_LOCK_ASSERT(sc);
2571 
2572 	/* Make sure we actually need to do this. */
2573 	if (sc->sc_brtcnt <= sc->sc_brtmax)
2574 		return;
2575 
2576 	/* Force an aging cycle; this might trim enough addresses. */
2577 	bridge_rtage(sc);
2578 	if (sc->sc_brtcnt <= sc->sc_brtmax)
2579 		return;
2580 
2581 	LIST_FOREACH_SAFE(brt, &sc->sc_rtlist, brt_list, nbrt) {
2582 		if ((brt->brt_flags & IFBAF_TYPEMASK) == IFBAF_DYNAMIC) {
2583 			bridge_rtnode_destroy(sc, brt);
2584 			if (sc->sc_brtcnt <= sc->sc_brtmax)
2585 				return;
2586 		}
2587 	}
2588 }
2589 
2590 /*
2591  * bridge_timer:
2592  *
2593  *	Aging timer for the bridge.
2594  */
2595 static void
2596 bridge_timer(void *arg)
2597 {
2598 	struct bridge_softc *sc = arg;
2599 
2600 	BRIDGE_LOCK_ASSERT(sc);
2601 
2602 	bridge_rtage(sc);
2603 
2604 	if (sc->sc_ifp->if_drv_flags & IFF_DRV_RUNNING)
2605 		callout_reset(&sc->sc_brcallout,
2606 		    bridge_rtable_prune_period * hz, bridge_timer, sc);
2607 }
2608 
2609 /*
2610  * bridge_rtage:
2611  *
2612  *	Perform an aging cycle.
2613  */
2614 static void
2615 bridge_rtage(struct bridge_softc *sc)
2616 {
2617 	struct bridge_rtnode *brt, *nbrt;
2618 
2619 	BRIDGE_LOCK_ASSERT(sc);
2620 
2621 	LIST_FOREACH_SAFE(brt, &sc->sc_rtlist, brt_list, nbrt) {
2622 		if ((brt->brt_flags & IFBAF_TYPEMASK) == IFBAF_DYNAMIC) {
2623 			if (time_uptime >= brt->brt_expire)
2624 				bridge_rtnode_destroy(sc, brt);
2625 		}
2626 	}
2627 }
2628 
2629 /*
2630  * bridge_rtflush:
2631  *
2632  *	Remove all dynamic addresses from the bridge.
2633  */
2634 static void
2635 bridge_rtflush(struct bridge_softc *sc, int full)
2636 {
2637 	struct bridge_rtnode *brt, *nbrt;
2638 
2639 	BRIDGE_LOCK_ASSERT(sc);
2640 
2641 	LIST_FOREACH_SAFE(brt, &sc->sc_rtlist, brt_list, nbrt) {
2642 		if (full || (brt->brt_flags & IFBAF_TYPEMASK) == IFBAF_DYNAMIC)
2643 			bridge_rtnode_destroy(sc, brt);
2644 	}
2645 }
2646 
2647 /*
2648  * bridge_rtdaddr:
2649  *
2650  *	Remove an address from the table.
2651  */
2652 static int
2653 bridge_rtdaddr(struct bridge_softc *sc, const uint8_t *addr, uint16_t vlan)
2654 {
2655 	struct bridge_rtnode *brt;
2656 	int found = 0;
2657 
2658 	BRIDGE_LOCK_ASSERT(sc);
2659 
2660 	/*
2661 	 * If vlan is zero then we want to delete for all vlans so the lookup
2662 	 * may return more than one.
2663 	 */
2664 	while ((brt = bridge_rtnode_lookup(sc, addr, vlan)) != NULL) {
2665 		bridge_rtnode_destroy(sc, brt);
2666 		found = 1;
2667 	}
2668 
2669 	return (found ? 0 : ENOENT);
2670 }
2671 
2672 /*
2673  * bridge_rtdelete:
2674  *
2675  *	Delete routes to a speicifc member interface.
2676  */
2677 static void
2678 bridge_rtdelete(struct bridge_softc *sc, struct ifnet *ifp, int full)
2679 {
2680 	struct bridge_rtnode *brt, *nbrt;
2681 
2682 	BRIDGE_LOCK_ASSERT(sc);
2683 
2684 	LIST_FOREACH_SAFE(brt, &sc->sc_rtlist, brt_list, nbrt) {
2685 		if (brt->brt_ifp == ifp && (full ||
2686 			    (brt->brt_flags & IFBAF_TYPEMASK) == IFBAF_DYNAMIC))
2687 			bridge_rtnode_destroy(sc, brt);
2688 	}
2689 }
2690 
2691 /*
2692  * bridge_rtable_init:
2693  *
2694  *	Initialize the route table for this bridge.
2695  */
2696 static int
2697 bridge_rtable_init(struct bridge_softc *sc)
2698 {
2699 	int i;
2700 
2701 	sc->sc_rthash = malloc(sizeof(*sc->sc_rthash) * BRIDGE_RTHASH_SIZE,
2702 	    M_DEVBUF, M_NOWAIT);
2703 	if (sc->sc_rthash == NULL)
2704 		return (ENOMEM);
2705 
2706 	for (i = 0; i < BRIDGE_RTHASH_SIZE; i++)
2707 		LIST_INIT(&sc->sc_rthash[i]);
2708 
2709 	sc->sc_rthash_key = arc4random();
2710 
2711 	LIST_INIT(&sc->sc_rtlist);
2712 
2713 	return (0);
2714 }
2715 
2716 /*
2717  * bridge_rtable_fini:
2718  *
2719  *	Deconstruct the route table for this bridge.
2720  */
2721 static void
2722 bridge_rtable_fini(struct bridge_softc *sc)
2723 {
2724 
2725 	KASSERT(sc->sc_brtcnt == 0,
2726 	    ("%s: %d bridge routes referenced", __func__, sc->sc_brtcnt));
2727 	free(sc->sc_rthash, M_DEVBUF);
2728 }
2729 
2730 /*
2731  * The following hash function is adapted from "Hash Functions" by Bob Jenkins
2732  * ("Algorithm Alley", Dr. Dobbs Journal, September 1997).
2733  */
2734 #define	mix(a, b, c)							\
2735 do {									\
2736 	a -= b; a -= c; a ^= (c >> 13);					\
2737 	b -= c; b -= a; b ^= (a << 8);					\
2738 	c -= a; c -= b; c ^= (b >> 13);					\
2739 	a -= b; a -= c; a ^= (c >> 12);					\
2740 	b -= c; b -= a; b ^= (a << 16);					\
2741 	c -= a; c -= b; c ^= (b >> 5);					\
2742 	a -= b; a -= c; a ^= (c >> 3);					\
2743 	b -= c; b -= a; b ^= (a << 10);					\
2744 	c -= a; c -= b; c ^= (b >> 15);					\
2745 } while (/*CONSTCOND*/0)
2746 
2747 static __inline uint32_t
2748 bridge_rthash(struct bridge_softc *sc, const uint8_t *addr)
2749 {
2750 	uint32_t a = 0x9e3779b9, b = 0x9e3779b9, c = sc->sc_rthash_key;
2751 
2752 	b += addr[5] << 8;
2753 	b += addr[4];
2754 	a += addr[3] << 24;
2755 	a += addr[2] << 16;
2756 	a += addr[1] << 8;
2757 	a += addr[0];
2758 
2759 	mix(a, b, c);
2760 
2761 	return (c & BRIDGE_RTHASH_MASK);
2762 }
2763 
2764 #undef mix
2765 
2766 static int
2767 bridge_rtnode_addr_cmp(const uint8_t *a, const uint8_t *b)
2768 {
2769 	int i, d;
2770 
2771 	for (i = 0, d = 0; i < ETHER_ADDR_LEN && d == 0; i++) {
2772 		d = ((int)a[i]) - ((int)b[i]);
2773 	}
2774 
2775 	return (d);
2776 }
2777 
2778 /*
2779  * bridge_rtnode_lookup:
2780  *
2781  *	Look up a bridge route node for the specified destination. Compare the
2782  *	vlan id or if zero then just return the first match.
2783  */
2784 static struct bridge_rtnode *
2785 bridge_rtnode_lookup(struct bridge_softc *sc, const uint8_t *addr, uint16_t vlan)
2786 {
2787 	struct bridge_rtnode *brt;
2788 	uint32_t hash;
2789 	int dir;
2790 
2791 	BRIDGE_LOCK_ASSERT(sc);
2792 
2793 	hash = bridge_rthash(sc, addr);
2794 	LIST_FOREACH(brt, &sc->sc_rthash[hash], brt_hash) {
2795 		dir = bridge_rtnode_addr_cmp(addr, brt->brt_addr);
2796 		if (dir == 0 && (brt->brt_vlan == vlan || vlan == 0))
2797 			return (brt);
2798 		if (dir > 0)
2799 			return (NULL);
2800 	}
2801 
2802 	return (NULL);
2803 }
2804 
2805 /*
2806  * bridge_rtnode_insert:
2807  *
2808  *	Insert the specified bridge node into the route table.  We
2809  *	assume the entry is not already in the table.
2810  */
2811 static int
2812 bridge_rtnode_insert(struct bridge_softc *sc, struct bridge_rtnode *brt)
2813 {
2814 	struct bridge_rtnode *lbrt;
2815 	uint32_t hash;
2816 	int dir;
2817 
2818 	BRIDGE_LOCK_ASSERT(sc);
2819 
2820 	hash = bridge_rthash(sc, brt->brt_addr);
2821 
2822 	lbrt = LIST_FIRST(&sc->sc_rthash[hash]);
2823 	if (lbrt == NULL) {
2824 		LIST_INSERT_HEAD(&sc->sc_rthash[hash], brt, brt_hash);
2825 		goto out;
2826 	}
2827 
2828 	do {
2829 		dir = bridge_rtnode_addr_cmp(brt->brt_addr, lbrt->brt_addr);
2830 		if (dir == 0 && brt->brt_vlan == lbrt->brt_vlan)
2831 			return (EEXIST);
2832 		if (dir > 0) {
2833 			LIST_INSERT_BEFORE(lbrt, brt, brt_hash);
2834 			goto out;
2835 		}
2836 		if (LIST_NEXT(lbrt, brt_hash) == NULL) {
2837 			LIST_INSERT_AFTER(lbrt, brt, brt_hash);
2838 			goto out;
2839 		}
2840 		lbrt = LIST_NEXT(lbrt, brt_hash);
2841 	} while (lbrt != NULL);
2842 
2843 #ifdef DIAGNOSTIC
2844 	panic("bridge_rtnode_insert: impossible");
2845 #endif
2846 
2847 out:
2848 	LIST_INSERT_HEAD(&sc->sc_rtlist, brt, brt_list);
2849 	sc->sc_brtcnt++;
2850 
2851 	return (0);
2852 }
2853 
2854 /*
2855  * bridge_rtnode_destroy:
2856  *
2857  *	Destroy a bridge rtnode.
2858  */
2859 static void
2860 bridge_rtnode_destroy(struct bridge_softc *sc, struct bridge_rtnode *brt)
2861 {
2862 	BRIDGE_LOCK_ASSERT(sc);
2863 
2864 	LIST_REMOVE(brt, brt_hash);
2865 
2866 	LIST_REMOVE(brt, brt_list);
2867 	sc->sc_brtcnt--;
2868 	brt->brt_dst->bif_addrcnt--;
2869 	uma_zfree(bridge_rtnode_zone, brt);
2870 }
2871 
2872 /*
2873  * bridge_rtable_expire:
2874  *
2875  *	Set the expiry time for all routes on an interface.
2876  */
2877 static void
2878 bridge_rtable_expire(struct ifnet *ifp, int age)
2879 {
2880 	struct bridge_softc *sc = ifp->if_bridge;
2881 	struct bridge_rtnode *brt;
2882 
2883 	BRIDGE_LOCK(sc);
2884 
2885 	/*
2886 	 * If the age is zero then flush, otherwise set all the expiry times to
2887 	 * age for the interface
2888 	 */
2889 	if (age == 0)
2890 		bridge_rtdelete(sc, ifp, IFBF_FLUSHDYN);
2891 	else {
2892 		LIST_FOREACH(brt, &sc->sc_rtlist, brt_list) {
2893 			/* Cap the expiry time to 'age' */
2894 			if (brt->brt_ifp == ifp &&
2895 			    brt->brt_expire > time_uptime + age &&
2896 			    (brt->brt_flags & IFBAF_TYPEMASK) == IFBAF_DYNAMIC)
2897 				brt->brt_expire = time_uptime + age;
2898 		}
2899 	}
2900 	BRIDGE_UNLOCK(sc);
2901 }
2902 
2903 /*
2904  * bridge_state_change:
2905  *
2906  *	Callback from the bridgestp code when a port changes states.
2907  */
2908 static void
2909 bridge_state_change(struct ifnet *ifp, int state)
2910 {
2911 	struct bridge_softc *sc = ifp->if_bridge;
2912 	static const char *stpstates[] = {
2913 		"disabled",
2914 		"listening",
2915 		"learning",
2916 		"forwarding",
2917 		"blocking",
2918 		"discarding"
2919 	};
2920 
2921 	if (log_stp)
2922 		log(LOG_NOTICE, "%s: state changed to %s on %s\n",
2923 		    sc->sc_ifp->if_xname, stpstates[state], ifp->if_xname);
2924 }
2925 
2926 /*
2927  * Send bridge packets through pfil if they are one of the types pfil can deal
2928  * with, or if they are ARP or REVARP.  (pfil will pass ARP and REVARP without
2929  * question.) If *bifp or *ifp are NULL then packet filtering is skipped for
2930  * that interface.
2931  */
2932 static int
2933 bridge_pfil(struct mbuf **mp, struct ifnet *bifp, struct ifnet *ifp, int dir)
2934 {
2935 	int snap, error, i, hlen;
2936 	struct ether_header *eh1, eh2;
2937 	struct ip_fw_args args;
2938 	struct ip *ip;
2939 	struct llc llc1;
2940 	u_int16_t ether_type;
2941 
2942 	snap = 0;
2943 	error = -1;	/* Default error if not error == 0 */
2944 
2945 #if 0
2946 	/* we may return with the IP fields swapped, ensure its not shared */
2947 	KASSERT(M_WRITABLE(*mp), ("%s: modifying a shared mbuf", __func__));
2948 #endif
2949 
2950 	if (pfil_bridge == 0 && pfil_member == 0 && pfil_ipfw == 0)
2951 		return (0); /* filtering is disabled */
2952 
2953 	i = min((*mp)->m_pkthdr.len, max_protohdr);
2954 	if ((*mp)->m_len < i) {
2955 	    *mp = m_pullup(*mp, i);
2956 	    if (*mp == NULL) {
2957 		printf("%s: m_pullup failed\n", __func__);
2958 		return (-1);
2959 	    }
2960 	}
2961 
2962 	eh1 = mtod(*mp, struct ether_header *);
2963 	ether_type = ntohs(eh1->ether_type);
2964 
2965 	/*
2966 	 * Check for SNAP/LLC.
2967 	 */
2968 	if (ether_type < ETHERMTU) {
2969 		struct llc *llc2 = (struct llc *)(eh1 + 1);
2970 
2971 		if ((*mp)->m_len >= ETHER_HDR_LEN + 8 &&
2972 		    llc2->llc_dsap == LLC_SNAP_LSAP &&
2973 		    llc2->llc_ssap == LLC_SNAP_LSAP &&
2974 		    llc2->llc_control == LLC_UI) {
2975 			ether_type = htons(llc2->llc_un.type_snap.ether_type);
2976 			snap = 1;
2977 		}
2978 	}
2979 
2980 	/*
2981 	 * If we're trying to filter bridge traffic, don't look at anything
2982 	 * other than IP and ARP traffic.  If the filter doesn't understand
2983 	 * IPv6, don't allow IPv6 through the bridge either.  This is lame
2984 	 * since if we really wanted, say, an AppleTalk filter, we are hosed,
2985 	 * but of course we don't have an AppleTalk filter to begin with.
2986 	 * (Note that since pfil doesn't understand ARP it will pass *ALL*
2987 	 * ARP traffic.)
2988 	 */
2989 	switch (ether_type) {
2990 		case ETHERTYPE_ARP:
2991 		case ETHERTYPE_REVARP:
2992 			if (pfil_ipfw_arp == 0)
2993 				return (0); /* Automatically pass */
2994 			break;
2995 
2996 		case ETHERTYPE_IP:
2997 #ifdef INET6
2998 		case ETHERTYPE_IPV6:
2999 #endif /* INET6 */
3000 			break;
3001 		default:
3002 			/*
3003 			 * Check to see if the user wants to pass non-ip
3004 			 * packets, these will not be checked by pfil(9) and
3005 			 * passed unconditionally so the default is to drop.
3006 			 */
3007 			if (pfil_onlyip)
3008 				goto bad;
3009 	}
3010 
3011 	/* Strip off the Ethernet header and keep a copy. */
3012 	m_copydata(*mp, 0, ETHER_HDR_LEN, (caddr_t) &eh2);
3013 	m_adj(*mp, ETHER_HDR_LEN);
3014 
3015 	/* Strip off snap header, if present */
3016 	if (snap) {
3017 		m_copydata(*mp, 0, sizeof(struct llc), (caddr_t) &llc1);
3018 		m_adj(*mp, sizeof(struct llc));
3019 	}
3020 
3021 	/*
3022 	 * Check the IP header for alignment and errors
3023 	 */
3024 	if (dir == PFIL_IN) {
3025 		switch (ether_type) {
3026 			case ETHERTYPE_IP:
3027 				error = bridge_ip_checkbasic(mp);
3028 				break;
3029 #ifdef INET6
3030 			case ETHERTYPE_IPV6:
3031 				error = bridge_ip6_checkbasic(mp);
3032 				break;
3033 #endif /* INET6 */
3034 			default:
3035 				error = 0;
3036 		}
3037 		if (error)
3038 			goto bad;
3039 	}
3040 
3041 	if (IPFW_LOADED && pfil_ipfw != 0 && dir == PFIL_OUT && ifp != NULL) {
3042 		INIT_VNET_IPFW(curvnet);
3043 
3044 		error = -1;
3045 		args.rule = ip_dn_claim_rule(*mp);
3046 		if (args.rule != NULL && V_fw_one_pass)
3047 			goto ipfwpass; /* packet already partially processed */
3048 
3049 		args.m = *mp;
3050 		args.oif = ifp;
3051 		args.next_hop = NULL;
3052 		args.eh = &eh2;
3053 		args.inp = NULL;	/* used by ipfw uid/gid/jail rules */
3054 		i = ip_fw_chk_ptr(&args);
3055 		*mp = args.m;
3056 
3057 		if (*mp == NULL)
3058 			return (error);
3059 
3060 		if (DUMMYNET_LOADED && (i == IP_FW_DUMMYNET)) {
3061 
3062 			/* put the Ethernet header back on */
3063 			M_PREPEND(*mp, ETHER_HDR_LEN, M_DONTWAIT);
3064 			if (*mp == NULL)
3065 				return (error);
3066 			bcopy(&eh2, mtod(*mp, caddr_t), ETHER_HDR_LEN);
3067 
3068 			/*
3069 			 * Pass the pkt to dummynet, which consumes it. The
3070 			 * packet will return to us via bridge_dummynet().
3071 			 */
3072 			args.oif = ifp;
3073 			ip_dn_io_ptr(mp, DN_TO_IFB_FWD, &args);
3074 			return (error);
3075 		}
3076 
3077 		if (i != IP_FW_PASS) /* drop */
3078 			goto bad;
3079 	}
3080 
3081 ipfwpass:
3082 	error = 0;
3083 
3084 	/*
3085 	 * Run the packet through pfil
3086 	 */
3087 	switch (ether_type) {
3088 	case ETHERTYPE_IP:
3089 		/*
3090 		 * before calling the firewall, swap fields the same as
3091 		 * IP does. here we assume the header is contiguous
3092 		 */
3093 		ip = mtod(*mp, struct ip *);
3094 
3095 		ip->ip_len = ntohs(ip->ip_len);
3096 		ip->ip_off = ntohs(ip->ip_off);
3097 
3098 		/*
3099 		 * Run pfil on the member interface and the bridge, both can
3100 		 * be skipped by clearing pfil_member or pfil_bridge.
3101 		 *
3102 		 * Keep the order:
3103 		 *   in_if -> bridge_if -> out_if
3104 		 */
3105 		if (pfil_bridge && dir == PFIL_OUT && bifp != NULL)
3106 			error = pfil_run_hooks(&inet_pfil_hook, mp, bifp,
3107 					dir, NULL);
3108 
3109 		if (*mp == NULL || error != 0) /* filter may consume */
3110 			break;
3111 
3112 		if (pfil_member && ifp != NULL)
3113 			error = pfil_run_hooks(&inet_pfil_hook, mp, ifp,
3114 					dir, NULL);
3115 
3116 		if (*mp == NULL || error != 0) /* filter may consume */
3117 			break;
3118 
3119 		if (pfil_bridge && dir == PFIL_IN && bifp != NULL)
3120 			error = pfil_run_hooks(&inet_pfil_hook, mp, bifp,
3121 					dir, NULL);
3122 
3123 		if (*mp == NULL || error != 0) /* filter may consume */
3124 			break;
3125 
3126 		/* check if we need to fragment the packet */
3127 		if (pfil_member && ifp != NULL && dir == PFIL_OUT) {
3128 			i = (*mp)->m_pkthdr.len;
3129 			if (i > ifp->if_mtu) {
3130 				error = bridge_fragment(ifp, *mp, &eh2, snap,
3131 					    &llc1);
3132 				return (error);
3133 			}
3134 		}
3135 
3136 		/* Recalculate the ip checksum and restore byte ordering */
3137 		ip = mtod(*mp, struct ip *);
3138 		hlen = ip->ip_hl << 2;
3139 		if (hlen < sizeof(struct ip))
3140 			goto bad;
3141 		if (hlen > (*mp)->m_len) {
3142 			if ((*mp = m_pullup(*mp, hlen)) == 0)
3143 				goto bad;
3144 			ip = mtod(*mp, struct ip *);
3145 			if (ip == NULL)
3146 				goto bad;
3147 		}
3148 		ip->ip_len = htons(ip->ip_len);
3149 		ip->ip_off = htons(ip->ip_off);
3150 		ip->ip_sum = 0;
3151 		if (hlen == sizeof(struct ip))
3152 			ip->ip_sum = in_cksum_hdr(ip);
3153 		else
3154 			ip->ip_sum = in_cksum(*mp, hlen);
3155 
3156 		break;
3157 #ifdef INET6
3158 	case ETHERTYPE_IPV6:
3159 		if (pfil_bridge && dir == PFIL_OUT && bifp != NULL)
3160 			error = pfil_run_hooks(&inet6_pfil_hook, mp, bifp,
3161 					dir, NULL);
3162 
3163 		if (*mp == NULL || error != 0) /* filter may consume */
3164 			break;
3165 
3166 		if (pfil_member && ifp != NULL)
3167 			error = pfil_run_hooks(&inet6_pfil_hook, mp, ifp,
3168 					dir, NULL);
3169 
3170 		if (*mp == NULL || error != 0) /* filter may consume */
3171 			break;
3172 
3173 		if (pfil_bridge && dir == PFIL_IN && bifp != NULL)
3174 			error = pfil_run_hooks(&inet6_pfil_hook, mp, bifp,
3175 					dir, NULL);
3176 		break;
3177 #endif
3178 	default:
3179 		error = 0;
3180 		break;
3181 	}
3182 
3183 	if (*mp == NULL)
3184 		return (error);
3185 	if (error != 0)
3186 		goto bad;
3187 
3188 	error = -1;
3189 
3190 	/*
3191 	 * Finally, put everything back the way it was and return
3192 	 */
3193 	if (snap) {
3194 		M_PREPEND(*mp, sizeof(struct llc), M_DONTWAIT);
3195 		if (*mp == NULL)
3196 			return (error);
3197 		bcopy(&llc1, mtod(*mp, caddr_t), sizeof(struct llc));
3198 	}
3199 
3200 	M_PREPEND(*mp, ETHER_HDR_LEN, M_DONTWAIT);
3201 	if (*mp == NULL)
3202 		return (error);
3203 	bcopy(&eh2, mtod(*mp, caddr_t), ETHER_HDR_LEN);
3204 
3205 	return (0);
3206 
3207 bad:
3208 	m_freem(*mp);
3209 	*mp = NULL;
3210 	return (error);
3211 }
3212 
3213 /*
3214  * Perform basic checks on header size since
3215  * pfil assumes ip_input has already processed
3216  * it for it.  Cut-and-pasted from ip_input.c.
3217  * Given how simple the IPv6 version is,
3218  * does the IPv4 version really need to be
3219  * this complicated?
3220  *
3221  * XXX Should we update ipstat here, or not?
3222  * XXX Right now we update ipstat but not
3223  * XXX csum_counter.
3224  */
3225 static int
3226 bridge_ip_checkbasic(struct mbuf **mp)
3227 {
3228 	INIT_VNET_INET(curvnet);
3229 	struct mbuf *m = *mp;
3230 	struct ip *ip;
3231 	int len, hlen;
3232 	u_short sum;
3233 
3234 	if (*mp == NULL)
3235 		return (-1);
3236 
3237 	if (IP_HDR_ALIGNED_P(mtod(m, caddr_t)) == 0) {
3238 		if ((m = m_copyup(m, sizeof(struct ip),
3239 			(max_linkhdr + 3) & ~3)) == NULL) {
3240 			/* XXXJRT new stat, please */
3241 			V_ipstat.ips_toosmall++;
3242 			goto bad;
3243 		}
3244 	} else if (__predict_false(m->m_len < sizeof (struct ip))) {
3245 		if ((m = m_pullup(m, sizeof (struct ip))) == NULL) {
3246 			V_ipstat.ips_toosmall++;
3247 			goto bad;
3248 		}
3249 	}
3250 	ip = mtod(m, struct ip *);
3251 	if (ip == NULL) goto bad;
3252 
3253 	if (ip->ip_v != IPVERSION) {
3254 		V_ipstat.ips_badvers++;
3255 		goto bad;
3256 	}
3257 	hlen = ip->ip_hl << 2;
3258 	if (hlen < sizeof(struct ip)) { /* minimum header length */
3259 		V_ipstat.ips_badhlen++;
3260 		goto bad;
3261 	}
3262 	if (hlen > m->m_len) {
3263 		if ((m = m_pullup(m, hlen)) == 0) {
3264 			V_ipstat.ips_badhlen++;
3265 			goto bad;
3266 		}
3267 		ip = mtod(m, struct ip *);
3268 		if (ip == NULL) goto bad;
3269 	}
3270 
3271 	if (m->m_pkthdr.csum_flags & CSUM_IP_CHECKED) {
3272 		sum = !(m->m_pkthdr.csum_flags & CSUM_IP_VALID);
3273 	} else {
3274 		if (hlen == sizeof(struct ip)) {
3275 			sum = in_cksum_hdr(ip);
3276 		} else {
3277 			sum = in_cksum(m, hlen);
3278 		}
3279 	}
3280 	if (sum) {
3281 		V_ipstat.ips_badsum++;
3282 		goto bad;
3283 	}
3284 
3285 	/* Retrieve the packet length. */
3286 	len = ntohs(ip->ip_len);
3287 
3288 	/*
3289 	 * Check for additional length bogosity
3290 	 */
3291 	if (len < hlen) {
3292 		V_ipstat.ips_badlen++;
3293 		goto bad;
3294 	}
3295 
3296 	/*
3297 	 * Check that the amount of data in the buffers
3298 	 * is as at least much as the IP header would have us expect.
3299 	 * Drop packet if shorter than we expect.
3300 	 */
3301 	if (m->m_pkthdr.len < len) {
3302 		V_ipstat.ips_tooshort++;
3303 		goto bad;
3304 	}
3305 
3306 	/* Checks out, proceed */
3307 	*mp = m;
3308 	return (0);
3309 
3310 bad:
3311 	*mp = m;
3312 	return (-1);
3313 }
3314 
3315 #ifdef INET6
3316 /*
3317  * Same as above, but for IPv6.
3318  * Cut-and-pasted from ip6_input.c.
3319  * XXX Should we update ip6stat, or not?
3320  */
3321 static int
3322 bridge_ip6_checkbasic(struct mbuf **mp)
3323 {
3324 	INIT_VNET_INET6(curvnet);
3325 	struct mbuf *m = *mp;
3326 	struct ip6_hdr *ip6;
3327 
3328 	/*
3329 	 * If the IPv6 header is not aligned, slurp it up into a new
3330 	 * mbuf with space for link headers, in the event we forward
3331 	 * it.  Otherwise, if it is aligned, make sure the entire base
3332 	 * IPv6 header is in the first mbuf of the chain.
3333 	 */
3334 	if (IP6_HDR_ALIGNED_P(mtod(m, caddr_t)) == 0) {
3335 		struct ifnet *inifp = m->m_pkthdr.rcvif;
3336 		if ((m = m_copyup(m, sizeof(struct ip6_hdr),
3337 			    (max_linkhdr + 3) & ~3)) == NULL) {
3338 			/* XXXJRT new stat, please */
3339 			V_ip6stat.ip6s_toosmall++;
3340 			in6_ifstat_inc(inifp, ifs6_in_hdrerr);
3341 			goto bad;
3342 		}
3343 	} else if (__predict_false(m->m_len < sizeof(struct ip6_hdr))) {
3344 		struct ifnet *inifp = m->m_pkthdr.rcvif;
3345 		if ((m = m_pullup(m, sizeof(struct ip6_hdr))) == NULL) {
3346 			V_ip6stat.ip6s_toosmall++;
3347 			in6_ifstat_inc(inifp, ifs6_in_hdrerr);
3348 			goto bad;
3349 		}
3350 	}
3351 
3352 	ip6 = mtod(m, struct ip6_hdr *);
3353 
3354 	if ((ip6->ip6_vfc & IPV6_VERSION_MASK) != IPV6_VERSION) {
3355 		V_ip6stat.ip6s_badvers++;
3356 		in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_hdrerr);
3357 		goto bad;
3358 	}
3359 
3360 	/* Checks out, proceed */
3361 	*mp = m;
3362 	return (0);
3363 
3364 bad:
3365 	*mp = m;
3366 	return (-1);
3367 }
3368 #endif /* INET6 */
3369 
3370 /*
3371  * bridge_fragment:
3372  *
3373  *	Return a fragmented mbuf chain.
3374  */
3375 static int
3376 bridge_fragment(struct ifnet *ifp, struct mbuf *m, struct ether_header *eh,
3377     int snap, struct llc *llc)
3378 {
3379 	INIT_VNET_INET(curvnet);
3380 	struct mbuf *m0;
3381 	struct ip *ip;
3382 	int error = -1;
3383 
3384 	if (m->m_len < sizeof(struct ip) &&
3385 	    (m = m_pullup(m, sizeof(struct ip))) == NULL)
3386 		goto out;
3387 	ip = mtod(m, struct ip *);
3388 
3389 	error = ip_fragment(ip, &m, ifp->if_mtu, ifp->if_hwassist,
3390 		    CSUM_DELAY_IP);
3391 	if (error)
3392 		goto out;
3393 
3394 	/* walk the chain and re-add the Ethernet header */
3395 	for (m0 = m; m0; m0 = m0->m_nextpkt) {
3396 		if (error == 0) {
3397 			if (snap) {
3398 				M_PREPEND(m0, sizeof(struct llc), M_DONTWAIT);
3399 				if (m0 == NULL) {
3400 					error = ENOBUFS;
3401 					continue;
3402 				}
3403 				bcopy(llc, mtod(m0, caddr_t),
3404 				    sizeof(struct llc));
3405 			}
3406 			M_PREPEND(m0, ETHER_HDR_LEN, M_DONTWAIT);
3407 			if (m0 == NULL) {
3408 				error = ENOBUFS;
3409 				continue;
3410 			}
3411 			bcopy(eh, mtod(m0, caddr_t), ETHER_HDR_LEN);
3412 		} else
3413 			m_freem(m);
3414 	}
3415 
3416 	if (error == 0)
3417 		V_ipstat.ips_fragmented++;
3418 
3419 	return (error);
3420 
3421 out:
3422 	if (m != NULL)
3423 		m_freem(m);
3424 	return (error);
3425 }
3426