if_bridge.c source code [codebrowser/bsd/net/if_bridge.c]

1	/*
2	* Copyright (c) 2004-2018 Apple Inc. All rights reserved.
3	*
4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5	*
6	* This file contains Original Code and/or Modifications of Original Code
7	* as defined in and that are subject to the Apple Public Source License
8	* Version 2.0 (the 'License'). You may not use this file except in
9	* compliance with the License. The rights granted to you under the License
10	* may not be used to create, or enable the creation or redistribution of,
11	* unlawful or unlicensed copies of an Apple operating system, or to
12	* circumvent, violate, or enable the circumvention or violation of, any
13	* terms of an Apple operating system software license agreement.
14	*
15	* Please obtain a copy of the License at
16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
17	*
18	* The Original Code and all software distributed under the License are
19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23	* Please see the License for the specific language governing rights and
24	* limitations under the License.
25	*
26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27	*/
28
29	/ $NetBSD: if_bridge.c,v 1.31 2005/06/01 19:45:34 jdc Exp $ /
30	/*
31	* Copyright 2001 Wasabi Systems, Inc.
32	* All rights reserved.
33	*
34	* Written by Jason R. Thorpe for Wasabi Systems, Inc.
35	*
36	* Redistribution and use in source and binary forms, with or without
37	* modification, are permitted provided that the following conditions
38	* are met:
39	* 1. Redistributions of source code must retain the above copyright
40	* notice, this list of conditions and the following disclaimer.
41	* 2. Redistributions in binary form must reproduce the above copyright
42	* notice, this list of conditions and the following disclaimer in the
43	* documentation and/or other materials provided with the distribution.
44	* 3. All advertising materials mentioning features or use of this software
45	* must display the following acknowledgement:
46	* This product includes software developed for the NetBSD Project by
47	* Wasabi Systems, Inc.
48	* 4. The name of Wasabi Systems, Inc. may not be used to endorse
49	* or promote products derived from this software without specific prior
50	* written permission.
51	*
52	* THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
53	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
54	* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
55	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL WASABI SYSTEMS, INC
56	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
57	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
58	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
59	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
60	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
61	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
62	* POSSIBILITY OF SUCH DAMAGE.
63	*/
64
65	/*
66	* Copyright (c) 1999, 2000 Jason L. Wright (jason@thought.net)
67	* All rights reserved.
68	*
69	* Redistribution and use in source and binary forms, with or without
70	* modification, are permitted provided that the following conditions
71	* are met:
72	* 1. Redistributions of source code must retain the above copyright
73	* notice, this list of conditions and the following disclaimer.
74	* 2. Redistributions in binary form must reproduce the above copyright
75	* notice, this list of conditions and the following disclaimer in the
76	* documentation and/or other materials provided with the distribution.
77	*
78	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
79	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
80	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
81	* DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
82	* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
83	* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
84	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
85	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
86	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
87	* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
88	* POSSIBILITY OF SUCH DAMAGE.
89	*
90	* OpenBSD: if_bridge.c,v 1.60 2001/06/15 03:38:33 itojun Exp
91	*/
92
93	/*
94	* Network interface bridge support.
95	*
96	* TODO:
97	*
98	* - Currently only supports Ethernet-like interfaces (Ethernet,
99	* 802.11, VLANs on Ethernet, etc.) Figure out a nice way
100	* to bridge other types of interfaces (FDDI-FDDI, and maybe
101	* consider heterogenous bridges).
102	*
103	* - GIF isn't handled due to the lack of IPPROTO_ETHERIP support.
104	*/
105
106	#include <sys/cdefs.h>
107
108	#define BRIDGE_DEBUG 1
109
110	#include <sys/param.h>
111	#include <sys/mbuf.h>
112	#include <sys/malloc.h>
113	#include <sys/protosw.h>
114	#include <sys/systm.h>
115	#include <sys/time.h>
116	#include <sys/socket.h> /* for net/if.h */
117	#include <sys/sockio.h>
118	#include <sys/kernel.h>
119	#include <sys/random.h>
120	#include <sys/syslog.h>
121	#include <sys/sysctl.h>
122	#include <sys/proc.h>
123	#include <sys/lock.h>
124	#include <sys/mcache.h>
125
126	#include <sys/kauth.h>
127
128	#include <kern/thread_call.h>
129
130	#include <libkern/libkern.h>
131
132	#include <kern/zalloc.h>
133
134	#if NBPFILTER > 0
135	#include <net/bpf.h>
136	#endif
137	#include <net/if.h>
138	#include <net/if_dl.h>
139	#include <net/if_types.h>
140	#include <net/if_var.h>
141	#include <net/if_media.h>
142	#include <net/net_api_stats.h>
143
144	#include <netinet/in.h> /* for struct arpcom */
145	#include <netinet/in_systm.h>
146	#include <netinet/in_var.h>
147	#define _IP_VHL
148	#include <netinet/ip.h>
149	#include <netinet/ip_var.h>
150	#if INET6
151	#include <netinet/ip6.h>
152	#include <netinet6/ip6_var.h>
153	#endif
154	#ifdef DEV_CARP
155	#include <netinet/ip_carp.h>
156	#endif
157	#include <netinet/if_ether.h> /* for struct arpcom */
158	#include <net/bridgestp.h>
159	#include <net/if_bridgevar.h>
160	#include <net/if_llc.h>
161	#if NVLAN > 0
162	#include <net/if_vlan_var.h>
163	#endif /* NVLAN > 0 */
164
165	#include <net/if_ether.h>
166	#include <net/dlil.h>
167	#include <net/kpi_interfacefilter.h>
168
169	#include <net/route.h>
170	#ifdef PFIL_HOOKS
171	#include <netinet/ip_fw2.h>
172	#include <netinet/ip_dummynet.h>
173	#endif /* PFIL_HOOKS */
174	#include <dev/random/randomdev.h>
175
176	#include <netinet/bootp.h>
177	#include <netinet/dhcp.h>
178
179
180	#if BRIDGE_DEBUG
181	#define BR_DBGF_LIFECYCLE 0x0001
182	#define BR_DBGF_INPUT 0x0002
183	#define BR_DBGF_OUTPUT 0x0004
184	#define BR_DBGF_RT_TABLE 0x0008
185	#define BR_DBGF_DELAYED_CALL 0x0010
186	#define BR_DBGF_IOCTL 0x0020
187	#define BR_DBGF_MBUF 0x0040
188	#define BR_DBGF_MCAST 0x0080
189	#define BR_DBGF_HOSTFILTER 0x0100
190	#endif /* BRIDGE_DEBUG */
191
192	#define _BRIDGE_LOCK(_sc) lck_mtx_lock(&(_sc)->sc_mtx)
193	#define _BRIDGE_UNLOCK(_sc) lck_mtx_unlock(&(_sc)->sc_mtx)
194	#define BRIDGE_LOCK_ASSERT_HELD(_sc) \
195	LCK_MTX_ASSERT(&(_sc)->sc_mtx, LCK_MTX_ASSERT_OWNED)
196	#define BRIDGE_LOCK_ASSERT_NOTHELD(_sc) \
197	LCK_MTX_ASSERT(&(_sc)->sc_mtx, LCK_MTX_ASSERT_NOTOWNED)
198
199	#if BRIDGE_DEBUG
200
201	#define BR_LCKDBG_MAX 4
202
203	#define BRIDGE_LOCK(_sc) bridge_lock(_sc)
204	#define BRIDGE_UNLOCK(_sc) bridge_unlock(_sc)
205	#define BRIDGE_LOCK2REF(_sc, _err) _err = bridge_lock2ref(_sc)
206	#define BRIDGE_UNREF(_sc) bridge_unref(_sc)
207	#define BRIDGE_XLOCK(_sc) bridge_xlock(_sc)
208	#define BRIDGE_XDROP(_sc) bridge_xdrop(_sc)
209
210	#else /* !BRIDGE_DEBUG */
211
212	#define BRIDGE_LOCK(_sc) _BRIDGE_LOCK(_sc)
213	#define BRIDGE_UNLOCK(_sc) _BRIDGE_UNLOCK(_sc)
214	#define BRIDGE_LOCK2REF(_sc, _err) do { \
215	BRIDGE_LOCK_ASSERT_HELD(_sc); \
216	if ((_sc)->sc_iflist_xcnt > 0) \
217	(_err) = EBUSY; \
218	else \
219	(_sc)->sc_iflist_ref++; \
220	_BRIDGE_UNLOCK(_sc); \
221	} while (0)
222	#define BRIDGE_UNREF(_sc) do { \
223	_BRIDGE_LOCK(_sc); \
224	(_sc)->sc_iflist_ref--; \
225	if (((_sc)->sc_iflist_xcnt > 0) && ((_sc)->sc_iflist_ref == 0)) { \
226	_BRIDGE_UNLOCK(_sc); \
227	wakeup(&(_sc)->sc_cv); \
228	} else \
229	_BRIDGE_UNLOCK(_sc); \
230	} while (0)
231	#define BRIDGE_XLOCK(_sc) do { \
232	BRIDGE_LOCK_ASSERT_HELD(_sc); \
233	(_sc)->sc_iflist_xcnt++; \
234	while ((_sc)->sc_iflist_ref > 0) \
235	msleep(&(_sc)->sc_cv, &(_sc)->sc_mtx, PZERO, \
236	"BRIDGE_XLOCK", NULL); \
237	} while (0)
238	#define BRIDGE_XDROP(_sc) do { \
239	BRIDGE_LOCK_ASSERT_HELD(_sc); \
240	(_sc)->sc_iflist_xcnt--; \
241	} while (0)
242
243	#endif /* BRIDGE_DEBUG */
244
245	#if NBPFILTER > 0
246	#define BRIDGE_BPF_MTAP_INPUT(sc, m) \
247	if (sc->sc_bpf_input) \
248	bridge_bpf_input(sc->sc_ifp, m)
249	#else /* NBPFILTER */
250	#define BRIDGE_BPF_MTAP_INPUT(ifp, m)
251	#endif /* NBPFILTER */
252
253	/*
254	* Initial size of the route hash table. Must be a power of two.
255	*/
256	#ifndef BRIDGE_RTHASH_SIZE
257	#define BRIDGE_RTHASH_SIZE 16
258	#endif
259
260	/*
261	* Maximum size of the routing hash table
262	*/
263	#define BRIDGE_RTHASH_SIZE_MAX 2048
264
265	#define BRIDGE_RTHASH_MASK(sc) ((sc)->sc_rthash_size - 1)
266
267	/*
268	* Maximum number of addresses to cache.
269	*/
270	#ifndef BRIDGE_RTABLE_MAX
271	#define BRIDGE_RTABLE_MAX 100
272	#endif
273
274
275	/*
276	* Timeout (in seconds) for entries learned dynamically.
277	*/
278	#ifndef BRIDGE_RTABLE_TIMEOUT
279	#define BRIDGE_RTABLE_TIMEOUT (20 * 60) /* same as ARP */
280	#endif
281
282	/*
283	* Number of seconds between walks of the route list.
284	*/
285	#ifndef BRIDGE_RTABLE_PRUNE_PERIOD
286	#define BRIDGE_RTABLE_PRUNE_PERIOD (5 * 60)
287	#endif
288
289	/*
290	* List of capabilities to possibly mask on the member interface.
291	*/
292	#define BRIDGE_IFCAPS_MASK (IFCAP_TOE\|IFCAP_TSO\|IFCAP_TXCSUM)
293	/*
294	* List of capabilities to disable on the member interface.
295	*/
296	#define BRIDGE_IFCAPS_STRIP IFCAP_LRO
297
298	/*
299	* Bridge interface list entry.
300	*/
301	struct bridge_iflist {
302	TAILQ_ENTRY(bridge_iflist) bif_next;
303	struct ifnet bif_ifp; /* member if /
304	struct bstp_port bif_stp; / STP state /
305	uint32_t bif_ifflags; / member if flags /
306	int bif_savedcaps; / saved capabilities /
307	uint32_t bif_addrmax; / max # of addresses /
308	uint32_t bif_addrcnt; / cur. # of addresses /
309	uint32_t bif_addrexceeded; / # of address violations /
310
311	interface_filter_t bif_iff_ref;
312	struct bridge_softc *bif_sc;
313	uint32_t bif_flags;
314
315	struct in_addr bif_hf_ipsrc;
316	uint8_t bif_hf_hwsrc[ETHER_ADDR_LEN];
317	};
318
319	#define BIFF_PROMISC 0x01 /* promiscuous mode set */
320	#define BIFF_PROTO_ATTACHED 0x02 /* protocol attached */
321	#define BIFF_FILTER_ATTACHED 0x04 /* interface filter attached */
322	#define BIFF_MEDIA_ACTIVE 0x08 /* interface media active */
323	#define BIFF_HOST_FILTER 0x10 /* host filter enabled */
324	#define BIFF_HF_HWSRC 0x20 /* host filter source MAC is set */
325	#define BIFF_HF_IPSRC 0x40 /* host filter source IP is set */
326
327	/*
328	* Bridge route node.
329	*/
330	struct bridge_rtnode {
331	LIST_ENTRY(bridge_rtnode) brt_hash; / hash table linkage /
332	LIST_ENTRY(bridge_rtnode) brt_list; / list linkage /
333	struct bridge_iflist brt_dst; /* destination if /
334	unsigned long brt_expire; / expiration time /
335	uint8_t brt_flags; / address flags /
336	uint8_t brt_addr[ETHER_ADDR_LEN];
337	uint16_t brt_vlan; / vlan id /
338
339	};
340	#define brt_ifp brt_dst->bif_ifp
341
342	/*
343	* Bridge delayed function call context
344	*/
345	typedef void (bridge_delayed_func_t)(struct* bridge_softc *);
346
347	struct bridge_delayed_call {
348	struct bridge_softc *bdc_sc;
349	bridge_delayed_func_t bdc_func; / Function to call /
350	struct timespec bdc_ts; / Time to call /
351	u_int32_t bdc_flags;
352	thread_call_t bdc_thread_call;
353	};
354
355	#define BDCF_OUTSTANDING 0x01 /* Delayed call has been scheduled */
356	#define BDCF_CANCELLING 0x02 /* May be waiting for call completion */
357
358
359	/*
360	* Software state for each bridge.
361	*/
362	LIST_HEAD(_bridge_rtnode_list, bridge_rtnode);
363
364	typedef struct {
365	struct _bridge_rtnode_list bb_rthash; /* our forwarding table /
366	struct _bridge_rtnode_list bb_rtlist; / list version of above /
367	uint32_t bb_rthash_key; / key for hash /
368	uint32_t bb_rthash_size; / size of the hash table /
369	struct bridge_delayed_call bb_aging_timer;
370	struct bridge_delayed_call bb_resize_call;
371	TAILQ_HEAD(, bridge_iflist) bb_spanlist; / span ports list /
372	struct bstp_state bb_stp; / STP state /
373	bpf_packet_func bb_bpf_input;
374	bpf_packet_func bb_bpf_output;
375	} bridge_bsd, *bridge_bsd_t;
376
377	#define sc_rthash sc_u.scu_bsd.bb_rthash
378	#define sc_rtlist sc_u.scu_bsd.bb_rtlist
379	#define sc_rthash_key sc_u.scu_bsd.bb_rthash_key
380	#define sc_rthash_size sc_u.scu_bsd.bb_rthash_size
381	#define sc_aging_timer sc_u.scu_bsd.bb_aging_timer
382	#define sc_resize_call sc_u.scu_bsd.bb_resize_call
383	#define sc_spanlist sc_u.scu_bsd.bb_spanlist
384	#define sc_stp sc_u.scu_bsd.bb_stp
385	#define sc_bpf_input sc_u.scu_bsd.bb_bpf_input
386	#define sc_bpf_output sc_u.scu_bsd.bb_bpf_output
387
388	struct bridge_softc {
389	struct ifnet sc_ifp; /* make this an interface /
390	u_int32_t sc_flags;
391	union {
392	bridge_bsd scu_bsd;
393	} sc_u;
394	LIST_ENTRY(bridge_softc) sc_list;
395	decl_lck_mtx_data(, sc_mtx);
396	void *sc_cv;
397	uint32_t sc_brtmax; / max # of addresses /
398	uint32_t sc_brtcnt; / cur. # of addresses /
399	uint32_t sc_brttimeout; / rt timeout in seconds /
400	uint32_t sc_iflist_ref; / refcount for sc_iflist /
401	uint32_t sc_iflist_xcnt; / refcount for sc_iflist /
402	TAILQ_HEAD(, bridge_iflist) sc_iflist; / member interface list /
403	uint32_t sc_brtexceeded; / # of cache drops /
404	uint32_t sc_filter_flags; / ipf and flags /
405	struct ifnet sc_ifaddr; /* member mac copied from /
406	u_char sc_defaddr[`6`]; / Default MAC address /
407	char sc_if_xname[IFNAMSIZ];
408
409	#if BRIDGE_DEBUG
410	/*
411	* Locking and unlocking calling history
412	*/
413	void *lock_lr[BR_LCKDBG_MAX];
414	int next_lock_lr;
415	void *unlock_lr[BR_LCKDBG_MAX];
416	int next_unlock_lr;
417	#endif /* BRIDGE_DEBUG */
418	};
419
420	#define SCF_DETACHING 0x01
421	#define SCF_RESIZING 0x02
422	#define SCF_MEDIA_ACTIVE 0x04
423	#define SCF_BSD_MODE 0x08
424
425	static inline void
426	bridge_set_bsd_mode(struct bridge_softc * sc)
427	{
428	sc->sc_flags \|= SCF_BSD_MODE;
429	}
430
431	static inline boolean_t
432	bridge_in_bsd_mode(const struct bridge_softc * sc)
433	{
434	return ((sc->sc_flags & SCF_BSD_MODE) != `0`);
435	}
436
437	struct bridge_hostfilter_stats bridge_hostfilter_stats;
438
439	decl_lck_mtx_data(static, bridge_list_mtx);
440
441	static int bridge_rtable_prune_period = BRIDGE_RTABLE_PRUNE_PERIOD;
442
443	static zone_t bridge_rtnode_pool = NULL;
444
445	static int bridge_clone_create(struct if_clone , uint32_t, void* *);
446	static int bridge_clone_destroy(struct ifnet *);
447
448	static errno_t bridge_ioctl(struct ifnet , u_long, void* *);
449	#if HAS_IF_CAP
450	static void bridge_mutecaps(struct bridge_softc *);
451	static void bridge_set_ifcap(struct bridge_softc , struct* bridge_iflist *,
452	int);
453	#endif
454	static errno_t bridge_set_tso(struct bridge_softc *);
455	__private_extern__ void bridge_ifdetach(struct bridge_iflist , struct* ifnet *);
456	static int bridge_init(struct ifnet *);
457	#if HAS_BRIDGE_DUMMYNET
458	static void bridge_dummynet(struct mbuf , struct* ifnet *);
459	#endif
460	static void bridge_ifstop(struct ifnet , int*);
461	static int bridge_output(struct ifnet , struct* mbuf *);
462	static void bridge_finalize_cksum(struct ifnet , struct* mbuf *);
463	static void bridge_start(struct ifnet *);
464	__private_extern__ errno_t bridge_input(struct ifnet , struct* mbuf , void* *);
465	#if BRIDGE_MEMBER_OUT_FILTER
466	static errno_t bridge_iff_output(void *, ifnet_t, protocol_family_t,
467	mbuf_t *);
468	static int bridge_member_output(struct ifnet , struct* mbuf *,
469	struct sockaddr , struct* rtentry *);
470	#endif
471	static int bridge_enqueue(struct bridge_softc , struct* ifnet *,
472	struct mbuf *);
473	static void bridge_rtdelete(struct bridge_softc , struct* ifnet ifp, int*);
474
475	static void bridge_forward(struct bridge_softc , struct* bridge_iflist *,
476	struct mbuf *);
477
478	static void bridge_aging_timer(struct bridge_softc *sc);
479
480	static void bridge_broadcast(struct bridge_softc , struct* ifnet *,
481	struct mbuf , int*);
482	static void bridge_span(struct bridge_softc , struct* mbuf *);
483
484	static int bridge_rtupdate(struct bridge_softc , const* uint8_t *,
485	uint16_t, struct bridge_iflist , int*, uint8_t);
486	static struct ifnet bridge_rtlookup(struct* bridge_softc , const* uint8_t *,
487	uint16_t);
488	static void bridge_rttrim(struct bridge_softc *);
489	static void bridge_rtage(struct bridge_softc *);
490	static void bridge_rtflush(struct bridge_softc , int*);
491	static int bridge_rtdaddr(struct bridge_softc , const* uint8_t *,
492	uint16_t);
493
494	static int bridge_rtable_init(struct bridge_softc *);
495	static void bridge_rtable_fini(struct bridge_softc *);
496
497	static void bridge_rthash_resize(struct bridge_softc *);
498
499	static int bridge_rtnode_addr_cmp(const uint8_t , const* uint8_t *);
500	static struct bridge_rtnode bridge_rtnode_lookup(struct* bridge_softc *,
501	const uint8_t *, uint16_t);
502	static int bridge_rtnode_hash(struct bridge_softc *,
503	struct bridge_rtnode *);
504	static int bridge_rtnode_insert(struct bridge_softc *,
505	struct bridge_rtnode *);
506	static void bridge_rtnode_destroy(struct bridge_softc *,
507	struct bridge_rtnode *);
508	#if BRIDGESTP
509	static void bridge_rtable_expire(struct ifnet , int*);
510	static void bridge_state_change(struct ifnet , int*);
511	#endif /* BRIDGESTP */
512
513	static struct bridge_iflist bridge_lookup_member(struct* bridge_softc *,
514	const char *name);
515	static struct bridge_iflist bridge_lookup_member_if(struct* bridge_softc *,
516	struct ifnet *ifp);
517	static void bridge_delete_member(struct bridge_softc *,
518	struct bridge_iflist , int*);
519	static void bridge_delete_span(struct bridge_softc *,
520	struct bridge_iflist *);
521
522	static int bridge_ioctl_add(struct bridge_softc , void* *);
523	static int bridge_ioctl_del(struct bridge_softc , void* *);
524	static int bridge_ioctl_gifflags(struct bridge_softc , void* *);
525	static int bridge_ioctl_sifflags(struct bridge_softc , void* *);
526	static int bridge_ioctl_scache(struct bridge_softc , void* *);
527	static int bridge_ioctl_gcache(struct bridge_softc , void* *);
528	static int bridge_ioctl_gifs32(struct bridge_softc , void* *);
529	static int bridge_ioctl_gifs64(struct bridge_softc , void* *);
530	static int bridge_ioctl_rts32(struct bridge_softc , void* *);
531	static int bridge_ioctl_rts64(struct bridge_softc , void* *);
532	static int bridge_ioctl_saddr32(struct bridge_softc , void* *);
533	static int bridge_ioctl_saddr64(struct bridge_softc , void* *);
534	static int bridge_ioctl_sto(struct bridge_softc , void* *);
535	static int bridge_ioctl_gto(struct bridge_softc , void* *);
536	static int bridge_ioctl_daddr32(struct bridge_softc , void* *);
537	static int bridge_ioctl_daddr64(struct bridge_softc , void* *);
538	static int bridge_ioctl_flush(struct bridge_softc , void* *);
539	static int bridge_ioctl_gpri(struct bridge_softc , void* *);
540	static int bridge_ioctl_spri(struct bridge_softc , void* *);
541	static int bridge_ioctl_ght(struct bridge_softc , void* *);
542	static int bridge_ioctl_sht(struct bridge_softc , void* *);
543	static int bridge_ioctl_gfd(struct bridge_softc , void* *);
544	static int bridge_ioctl_sfd(struct bridge_softc , void* *);
545	static int bridge_ioctl_gma(struct bridge_softc , void* *);
546	static int bridge_ioctl_sma(struct bridge_softc , void* *);
547	static int bridge_ioctl_sifprio(struct bridge_softc , void* *);
548	static int bridge_ioctl_sifcost(struct bridge_softc , void* *);
549	static int bridge_ioctl_sifmaxaddr(struct bridge_softc , void* *);
550	static int bridge_ioctl_addspan(struct bridge_softc , void* *);
551	static int bridge_ioctl_delspan(struct bridge_softc , void* *);
552	static int bridge_ioctl_gbparam32(struct bridge_softc , void* *);
553	static int bridge_ioctl_gbparam64(struct bridge_softc , void* *);
554	static int bridge_ioctl_grte(struct bridge_softc , void* *);
555	static int bridge_ioctl_gifsstp32(struct bridge_softc , void* *);
556	static int bridge_ioctl_gifsstp64(struct bridge_softc , void* *);
557	static int bridge_ioctl_sproto(struct bridge_softc , void* *);
558	static int bridge_ioctl_stxhc(struct bridge_softc , void* *);
559	static int bridge_ioctl_purge(struct bridge_softc sc, void* *);
560	static int bridge_ioctl_gfilt(struct bridge_softc , void* *);
561	static int bridge_ioctl_sfilt(struct bridge_softc , void* *);
562	static int bridge_ioctl_ghostfilter(struct bridge_softc , void* *);
563	static int bridge_ioctl_shostfilter(struct bridge_softc , void* *);
564	#ifdef PFIL_HOOKS
565	static int bridge_pfil(struct mbuf , struct** ifnet , struct* ifnet *,
566	int);
567	static int bridge_ip_checkbasic(struct mbuf **);
568	#ifdef INET6
569	static int bridge_ip6_checkbasic(struct mbuf **);
570	#endif /* INET6 */
571	static int bridge_fragment(struct ifnet , struct* mbuf *,
572	struct ether_header , int, struct* llc *);
573	#endif /* PFIL_HOOKS */
574
575	static errno_t bridge_set_bpf_tap(ifnet_t, bpf_tap_mode, bpf_packet_func);
576	__private_extern__ errno_t bridge_bpf_input(ifnet_t, struct mbuf *);
577	__private_extern__ errno_t bridge_bpf_output(ifnet_t, struct mbuf *);
578
579	static void bridge_detach(ifnet_t);
580	static void bridge_link_event(struct ifnet *, u_int32_t);
581	static void bridge_iflinkevent(struct ifnet *);
582	static u_int32_t bridge_updatelinkstatus(struct bridge_softc *);
583	static int interface_media_active(struct ifnet *);
584	static void bridge_schedule_delayed_call(struct bridge_delayed_call *);
585	static void bridge_cancel_delayed_call(struct bridge_delayed_call *);
586	static void bridge_cleanup_delayed_call(struct bridge_delayed_call *);
587	static int bridge_host_filter(struct bridge_iflist , struct* mbuf *);
588
589
590	#define m_copypacket(m, how) m_copym(m, 0, M_COPYALL, how)
591
592	/ The default bridge vlan is 1 (IEEE 802.1Q-2003 Table 9-2) /
593	#define VLANTAGOF(_m) 0
594
595	u_int8_t bstp_etheraddr[ETHER_ADDR_LEN] =
596	{ `0x01`, `0x80`, `0xc2`, `0x00`, `0x00`, `0x00` };
597
598	static u_int8_t ethernulladdr[ETHER_ADDR_LEN] =
599	{ `0x00`, `0x00`, `0x00`, `0x00`, `0x00`, `0x00` };
600
601	#if BRIDGESTP
602	static struct bstp_cb_ops bridge_ops = {
603	.bcb_state = bridge_state_change,
604	.bcb_rtage = bridge_rtable_expire
605	};
606	#endif /* BRIDGESTP */
607
608	SYSCTL_DECL(_net_link);
609	SYSCTL_NODE(_net_link, IFT_BRIDGE, bridge, CTLFLAG_RW\|CTLFLAG_LOCKED, `0`,
610	"Bridge");
611
612	static int bridge_inherit_mac = `0`; / share MAC with first bridge member /
613	SYSCTL_INT(_net_link_bridge, OID_AUTO, inherit_mac,
614	CTLFLAG_RW\|CTLFLAG_LOCKED,
615	&bridge_inherit_mac, `0`,
616	"Inherit MAC address from the first bridge member");
617
618	SYSCTL_INT(_net_link_bridge, OID_AUTO, rtable_prune_period,
619	CTLFLAG_RW\|CTLFLAG_LOCKED,
620	&bridge_rtable_prune_period, `0`,
621	"Interval between pruning of routing table");
622
623	static unsigned int bridge_rtable_hash_size_max = BRIDGE_RTHASH_SIZE_MAX;
624	SYSCTL_UINT(_net_link_bridge, OID_AUTO, rtable_hash_size_max,
625	CTLFLAG_RW\|CTLFLAG_LOCKED,
626	&bridge_rtable_hash_size_max, `0`,
627	"Maximum size of the routing hash table");
628
629	#if BRIDGE_DEBUG_DELAYED_CALLBACK
630	static int bridge_delayed_callback_delay = `0`;
631	SYSCTL_INT(_net_link_bridge, OID_AUTO, delayed_callback_delay,
632	CTLFLAG_RW\|CTLFLAG_LOCKED,
633	&bridge_delayed_callback_delay, `0`,
634	"Delay before calling delayed function");
635	#endif
636
637	static int bridge_bsd_mode = `1`;
638	#if (DEVELOPMENT \|\| DEBUG)
639	SYSCTL_INT(_net_link_bridge, OID_AUTO, bsd_mode,
640	CTLFLAG_RW\|CTLFLAG_LOCKED,
641	&bridge_bsd_mode, `0`,
642	"Bridge using bsd mode");
643	#endif /* (DEVELOPMENT \|\| DEBUG) */
644
645	SYSCTL_STRUCT(_net_link_bridge, OID_AUTO,
646	hostfilterstats, CTLFLAG_RD \| CTLFLAG_LOCKED,
647	&bridge_hostfilter_stats, bridge_hostfilter_stats, "");
648
649	#if defined(PFIL_HOOKS)
650	static int pfil_onlyip = `1`; / only pass IP[46] packets when pfil is enabled /
651	static int pfil_bridge = `1`; / run pfil hooks on the bridge interface /
652	static int pfil_member = `1`; / run pfil hooks on the member interface /
653	static int pfil_ipfw = `0`; / layer2 filter with ipfw /
654	static int pfil_ipfw_arp = `0`; / layer2 filter with ipfw /
655	static int pfil_local_phys = `0`; / run pfil hooks on the physical interface /
656	/ for locally destined packets /
657	SYSCTL_INT(_net_link_bridge, OID_AUTO, pfil_onlyip, CTLFLAG_RW\|CTLFLAG_LOCKED,
658	&pfil_onlyip, `0`, "Only pass IP packets when pfil is enabled");
659	SYSCTL_INT(_net_link_bridge, OID_AUTO, ipfw_arp, CTLFLAG_RW\|CTLFLAG_LOCKED,
660	&pfil_ipfw_arp, `0`, "Filter ARP packets through IPFW layer2");
661	SYSCTL_INT(_net_link_bridge, OID_AUTO, pfil_bridge, CTLFLAG_RW\|CTLFLAG_LOCKED,
662	&pfil_bridge, `0`, "Packet filter on the bridge interface");
663	SYSCTL_INT(_net_link_bridge, OID_AUTO, pfil_member, CTLFLAG_RW\|CTLFLAG_LOCKED,
664	&pfil_member, `0`, "Packet filter on the member interface");
665	SYSCTL_INT(_net_link_bridge, OID_AUTO, pfil_local_phys,
666	CTLFLAG_RW\|CTLFLAG_LOCKED, &pfil_local_phys, `0`,
667	"Packet filter on the physical interface for locally destined packets");
668	#endif /* PFIL_HOOKS */
669
670	#if BRIDGESTP
671	static int log_stp = `0`; / log STP state changes /
672	SYSCTL_INT(_net_link_bridge, OID_AUTO, log_stp, CTLFLAG_RW,
673	&log_stp, `0`, "Log STP state changes");
674	#endif /* BRIDGESTP */
675
676	struct bridge_control {
677	int (bc_func)(struct* bridge_softc , void* *);
678	unsigned int bc_argsize;
679	unsigned int bc_flags;
680	};
681
682	#define BC_F_COPYIN 0x01 /* copy arguments in */
683	#define BC_F_COPYOUT 0x02 /* copy arguments out */
684	#define BC_F_SUSER 0x04 /* do super-user check */
685
686	static const struct bridge_control bridge_control_table32[] = {
687	{ bridge_ioctl_add, sizeof (struct ifbreq), / 0 /
688	BC_F_COPYIN\|BC_F_SUSER },
689	{ bridge_ioctl_del, sizeof (struct ifbreq),
690	BC_F_COPYIN\|BC_F_SUSER },
691
692	{ bridge_ioctl_gifflags, sizeof (struct ifbreq),
693	BC_F_COPYIN\|BC_F_COPYOUT },
694	{ bridge_ioctl_sifflags, sizeof (struct ifbreq),
695	BC_F_COPYIN\|BC_F_SUSER },
696
697	{ bridge_ioctl_scache, sizeof (struct ifbrparam),
698	BC_F_COPYIN\|BC_F_SUSER },
699	{ bridge_ioctl_gcache, sizeof (struct ifbrparam),
700	BC_F_COPYOUT },
701
702	{ bridge_ioctl_gifs32, sizeof (struct ifbifconf32),
703	BC_F_COPYIN\|BC_F_COPYOUT },
704	{ bridge_ioctl_rts32, sizeof (struct ifbaconf32),
705	BC_F_COPYIN\|BC_F_COPYOUT },
706
707	{ bridge_ioctl_saddr32, sizeof (struct ifbareq32),
708	BC_F_COPYIN\|BC_F_SUSER },
709
710	{ bridge_ioctl_sto, sizeof (struct ifbrparam),
711	BC_F_COPYIN\|BC_F_SUSER },
712	{ bridge_ioctl_gto, sizeof (struct ifbrparam), / 10 /
713	BC_F_COPYOUT },
714
715	{ bridge_ioctl_daddr32, sizeof (struct ifbareq32),
716	BC_F_COPYIN\|BC_F_SUSER },
717
718	{ bridge_ioctl_flush, sizeof (struct ifbreq),
719	BC_F_COPYIN\|BC_F_SUSER },
720
721	{ bridge_ioctl_gpri, sizeof (struct ifbrparam),
722	BC_F_COPYOUT },
723	{ bridge_ioctl_spri, sizeof (struct ifbrparam),
724	BC_F_COPYIN\|BC_F_SUSER },
725
726	{ bridge_ioctl_ght, sizeof (struct ifbrparam),
727	BC_F_COPYOUT },
728	{ bridge_ioctl_sht, sizeof (struct ifbrparam),
729	BC_F_COPYIN\|BC_F_SUSER },
730
731	{ bridge_ioctl_gfd, sizeof (struct ifbrparam),
732	BC_F_COPYOUT },
733	{ bridge_ioctl_sfd, sizeof (struct ifbrparam),
734	BC_F_COPYIN\|BC_F_SUSER },
735
736	{ bridge_ioctl_gma, sizeof (struct ifbrparam),
737	BC_F_COPYOUT },
738	{ bridge_ioctl_sma, sizeof (struct ifbrparam), / 20 /
739	BC_F_COPYIN\|BC_F_SUSER },
740
741	{ bridge_ioctl_sifprio, sizeof (struct ifbreq),
742	BC_F_COPYIN\|BC_F_SUSER },
743
744	{ bridge_ioctl_sifcost, sizeof (struct ifbreq),
745	BC_F_COPYIN\|BC_F_SUSER },
746
747	{ bridge_ioctl_gfilt, sizeof (struct ifbrparam),
748	BC_F_COPYOUT },
749	{ bridge_ioctl_sfilt, sizeof (struct ifbrparam),
750	BC_F_COPYIN\|BC_F_SUSER },
751
752	{ bridge_ioctl_purge, sizeof (struct ifbreq),
753	BC_F_COPYIN\|BC_F_SUSER },
754
755	{ bridge_ioctl_addspan, sizeof (struct ifbreq),
756	BC_F_COPYIN\|BC_F_SUSER },
757	{ bridge_ioctl_delspan, sizeof (struct ifbreq),
758	BC_F_COPYIN\|BC_F_SUSER },
759
760	{ bridge_ioctl_gbparam32, sizeof (struct ifbropreq32),
761	BC_F_COPYOUT },
762
763	{ bridge_ioctl_grte, sizeof (struct ifbrparam),
764	BC_F_COPYOUT },
765
766	{ bridge_ioctl_gifsstp32, sizeof (struct ifbpstpconf32), / 30 /
767	BC_F_COPYIN\|BC_F_COPYOUT },
768
769	{ bridge_ioctl_sproto, sizeof (struct ifbrparam),
770	BC_F_COPYIN\|BC_F_SUSER },
771
772	{ bridge_ioctl_stxhc, sizeof (struct ifbrparam),
773	BC_F_COPYIN\|BC_F_SUSER },
774
775	{ bridge_ioctl_sifmaxaddr, sizeof (struct ifbreq),
776	BC_F_COPYIN\|BC_F_SUSER },
777
778	{ bridge_ioctl_ghostfilter, sizeof (struct ifbrhostfilter),
779	BC_F_COPYIN\|BC_F_COPYOUT },
780	{ bridge_ioctl_shostfilter, sizeof (struct ifbrhostfilter),
781	BC_F_COPYIN\|BC_F_SUSER },
782	};
783
784	static const struct bridge_control bridge_control_table64[] = {
785	{ bridge_ioctl_add, sizeof (struct ifbreq), / 0 /
786	BC_F_COPYIN\|BC_F_SUSER },
787	{ bridge_ioctl_del, sizeof (struct ifbreq),
788	BC_F_COPYIN\|BC_F_SUSER },
789
790	{ bridge_ioctl_gifflags, sizeof (struct ifbreq),
791	BC_F_COPYIN\|BC_F_COPYOUT },
792	{ bridge_ioctl_sifflags, sizeof (struct ifbreq),
793	BC_F_COPYIN\|BC_F_SUSER },
794
795	{ bridge_ioctl_scache, sizeof (struct ifbrparam),
796	BC_F_COPYIN\|BC_F_SUSER },
797	{ bridge_ioctl_gcache, sizeof (struct ifbrparam),
798	BC_F_COPYOUT },
799
800	{ bridge_ioctl_gifs64, sizeof (struct ifbifconf64),
801	BC_F_COPYIN\|BC_F_COPYOUT },
802	{ bridge_ioctl_rts64, sizeof (struct ifbaconf64),
803	BC_F_COPYIN\|BC_F_COPYOUT },
804
805	{ bridge_ioctl_saddr64, sizeof (struct ifbareq64),
806	BC_F_COPYIN\|BC_F_SUSER },
807
808	{ bridge_ioctl_sto, sizeof (struct ifbrparam),
809	BC_F_COPYIN\|BC_F_SUSER },
810	{ bridge_ioctl_gto, sizeof (struct ifbrparam), / 10 /
811	BC_F_COPYOUT },
812
813	{ bridge_ioctl_daddr64, sizeof (struct ifbareq64),
814	BC_F_COPYIN\|BC_F_SUSER },
815
816	{ bridge_ioctl_flush, sizeof (struct ifbreq),
817	BC_F_COPYIN\|BC_F_SUSER },
818
819	{ bridge_ioctl_gpri, sizeof (struct ifbrparam),
820	BC_F_COPYOUT },
821	{ bridge_ioctl_spri, sizeof (struct ifbrparam),
822	BC_F_COPYIN\|BC_F_SUSER },
823
824	{ bridge_ioctl_ght, sizeof (struct ifbrparam),
825	BC_F_COPYOUT },
826	{ bridge_ioctl_sht, sizeof (struct ifbrparam),
827	BC_F_COPYIN\|BC_F_SUSER },
828
829	{ bridge_ioctl_gfd, sizeof (struct ifbrparam),
830	BC_F_COPYOUT },
831	{ bridge_ioctl_sfd, sizeof (struct ifbrparam),
832	BC_F_COPYIN\|BC_F_SUSER },
833
834	{ bridge_ioctl_gma, sizeof (struct ifbrparam),
835	BC_F_COPYOUT },
836	{ bridge_ioctl_sma, sizeof (struct ifbrparam), / 20 /
837	BC_F_COPYIN\|BC_F_SUSER },
838
839	{ bridge_ioctl_sifprio, sizeof (struct ifbreq),
840	BC_F_COPYIN\|BC_F_SUSER },
841
842	{ bridge_ioctl_sifcost, sizeof (struct ifbreq),
843	BC_F_COPYIN\|BC_F_SUSER },
844
845	{ bridge_ioctl_gfilt, sizeof (struct ifbrparam),
846	BC_F_COPYOUT },
847	{ bridge_ioctl_sfilt, sizeof (struct ifbrparam),
848	BC_F_COPYIN\|BC_F_SUSER },
849
850	{ bridge_ioctl_purge, sizeof (struct ifbreq),
851	BC_F_COPYIN\|BC_F_SUSER },
852
853	{ bridge_ioctl_addspan, sizeof (struct ifbreq),
854	BC_F_COPYIN\|BC_F_SUSER },
855	{ bridge_ioctl_delspan, sizeof (struct ifbreq),
856	BC_F_COPYIN\|BC_F_SUSER },
857
858	{ bridge_ioctl_gbparam64, sizeof (struct ifbropreq64),
859	BC_F_COPYOUT },
860
861	{ bridge_ioctl_grte, sizeof (struct ifbrparam),
862	BC_F_COPYOUT },
863
864	{ bridge_ioctl_gifsstp64, sizeof (struct ifbpstpconf64), / 30 /
865	BC_F_COPYIN\|BC_F_COPYOUT },
866
867	{ bridge_ioctl_sproto, sizeof (struct ifbrparam),
868	BC_F_COPYIN\|BC_F_SUSER },
869
870	{ bridge_ioctl_stxhc, sizeof (struct ifbrparam),
871	BC_F_COPYIN\|BC_F_SUSER },
872
873	{ bridge_ioctl_sifmaxaddr, sizeof (struct ifbreq),
874	BC_F_COPYIN\|BC_F_SUSER },
875
876	{ bridge_ioctl_ghostfilter, sizeof (struct ifbrhostfilter),
877	BC_F_COPYIN\|BC_F_COPYOUT },
878	{ bridge_ioctl_shostfilter, sizeof (struct ifbrhostfilter),
879	BC_F_COPYIN\|BC_F_SUSER },
880	};
881
882	static const unsigned int bridge_control_table_size =
883	sizeof (bridge_control_table32) / sizeof (bridge_control_table32[`0`]);
884
885	static LIST_HEAD(, bridge_softc) bridge_list =
886	LIST_HEAD_INITIALIZER(bridge_list);
887
888	static lck_grp_t *bridge_lock_grp = NULL;
889	static lck_attr_t *bridge_lock_attr = NULL;
890
891	#define BRIDGENAME "bridge"
892	#define BRIDGES_MAX IF_MAXUNIT
893	#define BRIDGE_ZONE_MAX_ELEM MIN(IFNETS_MAX, BRIDGES_MAX)
894
895	static struct if_clone bridge_cloner =
896	IF_CLONE_INITIALIZER(BRIDGENAME, bridge_clone_create, bridge_clone_destroy,
897	`0`, BRIDGES_MAX, BRIDGE_ZONE_MAX_ELEM, sizeof(struct bridge_softc));
898
899	static int if_bridge_txstart = `0`;
900	SYSCTL_INT(_net_link_bridge, OID_AUTO, txstart, CTLFLAG_RW \| CTLFLAG_LOCKED,
901	&if_bridge_txstart, `0`, "Bridge interface uses TXSTART model");
902
903	#if BRIDGE_DEBUG
904	static int if_bridge_debug = `0`;
905	SYSCTL_INT(_net_link_bridge, OID_AUTO, debug, CTLFLAG_RW \| CTLFLAG_LOCKED,
906	&if_bridge_debug, `0`, "Bridge debug");
907
908	static void printf_ether_header(struct ether_header *);
909	static void printf_mbuf_data(mbuf_t, size_t, size_t);
910	static void printf_mbuf_pkthdr(mbuf_t, const char , const* char *);
911	static void printf_mbuf(mbuf_t, const char , const* char *);
912	static void link_print(struct bridge_softc * sc);
913
914	static void bridge_lock(struct bridge_softc *);
915	static void bridge_unlock(struct bridge_softc *);
916	static int bridge_lock2ref(struct bridge_softc *);
917	static void bridge_unref(struct bridge_softc *);
918	static void bridge_xlock(struct bridge_softc *);
919	static void bridge_xdrop(struct bridge_softc *);
920
921	static void
922	bridge_lock(struct bridge_softc *sc)
923	{
924	void *lr_saved = __builtin_return_address(`0`);
925
926	BRIDGE_LOCK_ASSERT_NOTHELD(sc);
927
928	_BRIDGE_LOCK(sc);
929
930	sc->lock_lr[sc->next_lock_lr] = lr_saved;
931	sc->next_lock_lr = (sc->next_lock_lr+`1`) % SO_LCKDBG_MAX;
932	}
933
934	static void
935	bridge_unlock(struct bridge_softc *sc)
936	{
937	void *lr_saved = __builtin_return_address(`0`);
938
939	BRIDGE_LOCK_ASSERT_HELD(sc);
940
941	sc->unlock_lr[sc->next_unlock_lr] = lr_saved;
942	sc->next_unlock_lr = (sc->next_unlock_lr+`1`) % SO_LCKDBG_MAX;
943
944	_BRIDGE_UNLOCK(sc);
945	}
946
947	static int
948	bridge_lock2ref(struct bridge_softc *sc)
949	{
950	int error = `0`;
951	void *lr_saved = __builtin_return_address(`0`);
952
953	BRIDGE_LOCK_ASSERT_HELD(sc);
954
955	if (sc->sc_iflist_xcnt > `0`)
956	error = EBUSY;
957	else
958	sc->sc_iflist_ref++;
959
960	sc->unlock_lr[sc->next_unlock_lr] = lr_saved;
961	sc->next_unlock_lr = (sc->next_unlock_lr+`1`) % SO_LCKDBG_MAX;
962
963	_BRIDGE_UNLOCK(sc);
964
965	return (error);
966	}
967
968	static void
969	bridge_unref(struct bridge_softc *sc)
970	{
971	void *lr_saved = __builtin_return_address(`0`);
972
973	BRIDGE_LOCK_ASSERT_NOTHELD(sc);
974
975	_BRIDGE_LOCK(sc);
976	sc->lock_lr[sc->next_lock_lr] = lr_saved;
977	sc->next_lock_lr = (sc->next_lock_lr+`1`) % SO_LCKDBG_MAX;
978
979	sc->sc_iflist_ref--;
980
981	sc->unlock_lr[sc->next_unlock_lr] = lr_saved;
982	sc->next_unlock_lr = (sc->next_unlock_lr+`1`) % SO_LCKDBG_MAX;
983	if ((sc->sc_iflist_xcnt > `0`) && (sc->sc_iflist_ref == `0`)) {
984	_BRIDGE_UNLOCK(sc);
985	wakeup(&sc->sc_cv);
986	} else
987	_BRIDGE_UNLOCK(sc);
988	}
989
990	static void
991	bridge_xlock(struct bridge_softc *sc)
992	{
993	void *lr_saved = __builtin_return_address(`0`);
994
995	BRIDGE_LOCK_ASSERT_HELD(sc);
996
997	sc->sc_iflist_xcnt++;
998	while (sc->sc_iflist_ref > `0`) {
999	sc->unlock_lr[sc->next_unlock_lr] = lr_saved;
1000	sc->next_unlock_lr = (sc->next_unlock_lr+`1`) % SO_LCKDBG_MAX;
1001
1002	msleep(&sc->sc_cv, &sc->sc_mtx, PZERO, "BRIDGE_XLOCK", NULL);
1003
1004	sc->lock_lr[sc->next_lock_lr] = lr_saved;
1005	sc->next_lock_lr = (sc->next_lock_lr+`1`) % SO_LCKDBG_MAX;
1006	}
1007	}
1008
1009	static void
1010	bridge_xdrop(struct bridge_softc *sc)
1011	{
1012	BRIDGE_LOCK_ASSERT_HELD(sc);
1013
1014	sc->sc_iflist_xcnt--;
1015	}
1016
1017	void
1018	printf_mbuf_pkthdr(mbuf_t m, const char prefix, const* char *suffix)
1019	{
1020	if (m)
1021	printf("%spktlen: %u rcvif: 0x%llx header: 0x%llx "
1022	"nextpkt: 0x%llx%s",
1023	prefix ? prefix : "", (unsigned int)mbuf_pkthdr_len(m),
1024	(uint64_t)VM_KERNEL_ADDRPERM(mbuf_pkthdr_rcvif(m)),
1025	(uint64_t)VM_KERNEL_ADDRPERM(mbuf_pkthdr_header(m)),
1026	(uint64_t)VM_KERNEL_ADDRPERM(mbuf_nextpkt(m)),
1027	suffix ? suffix : "");
1028	else
1029	printf("%s<NULL>%s\n", prefix, suffix);
1030	}
1031
1032	void
1033	printf_mbuf(mbuf_t m, const char prefix, const* char *suffix)
1034	{
1035	if (m) {
1036	printf("%s0x%llx type: %u flags: 0x%x len: %u data: 0x%llx "
1037	"maxlen: %u datastart: 0x%llx next: 0x%llx%s",
1038	prefix ? prefix : "", (uint64_t)VM_KERNEL_ADDRPERM(m),
1039	mbuf_type(m), mbuf_flags(m), (unsigned int)mbuf_len(m),
1040	(uint64_t)VM_KERNEL_ADDRPERM(mbuf_data(m)),
1041	(unsigned int)mbuf_maxlen(m),
1042	(uint64_t)VM_KERNEL_ADDRPERM(mbuf_datastart(m)),
1043	(uint64_t)VM_KERNEL_ADDRPERM(mbuf_next(m)),
1044	!suffix \|\| (mbuf_flags(m) & MBUF_PKTHDR) ? "" : suffix);
1045	if ((mbuf_flags(m) & MBUF_PKTHDR))
1046	printf_mbuf_pkthdr(m, " ", suffix);
1047	} else
1048	printf("%s<NULL>%s\n", prefix, suffix);
1049	}
1050
1051	void
1052	printf_mbuf_data(mbuf_t m, size_t offset, size_t len)
1053	{
1054	mbuf_t n;
1055	size_t i, j;
1056	size_t pktlen, mlen, maxlen;
1057	unsigned char *ptr;
1058
1059	pktlen = mbuf_pkthdr_len(m);
1060
1061	if (offset > pktlen)
1062	return;
1063
1064	maxlen = (pktlen - offset > len) ? len : pktlen - offset;
1065	n = m;
1066	mlen = mbuf_len(n);
1067	ptr = mbuf_data(n);
1068	for (i = `0`, j = `0`; i < maxlen; i++, j++) {
1069	if (j >= mlen) {
1070	n = mbuf_next(n);
1071	if (n == `0`)
1072	break;
1073	ptr = mbuf_data(n);
1074	mlen = mbuf_len(n);
1075	j = `0`;
1076	}
1077	if (i >= offset) {
1078	printf("%02x%s", ptr[j], i % `2` ? " " : "");
1079	}
1080	}
1081	}
1082
1083	static void
1084	printf_ether_header(struct ether_header *eh)
1085	{
1086	printf("%02x:%02x:%02x:%02x:%02x:%02x > "
1087	"%02x:%02x:%02x:%02x:%02x:%02x 0x%04x ",
1088	eh->ether_shost[`0`], eh->ether_shost[`1`], eh->ether_shost[`2`],
1089	eh->ether_shost[`3`], eh->ether_shost[`4`], eh->ether_shost[`5`],
1090	eh->ether_dhost[`0`], eh->ether_dhost[`1`], eh->ether_dhost[`2`],
1091	eh->ether_dhost[`3`], eh->ether_dhost[`4`], eh->ether_dhost[`5`],
1092	ntohs(eh->ether_type));
1093	}
1094
1095	static void
1096	link_print(struct bridge_softc * sc)
1097	{
1098	int i;
1099	uint32_t sdl_buffer[offsetof(struct sockaddr_dl, sdl_data) +
1100	IFNAMSIZ + ETHER_ADDR_LEN];
1101	struct sockaddr_dl sdl = (struct* sockaddr_dl *)sdl_buffer;
1102
1103	memset(sdl, `0`, sizeof (sdl_buffer));
1104	sdl->sdl_family = AF_LINK;
1105	sdl->sdl_nlen = strlen(sc->sc_if_xname);
1106	sdl->sdl_alen = ETHER_ADDR_LEN;
1107	sdl->sdl_len = offsetof(struct sockaddr_dl, sdl_data);
1108	memcpy(sdl->sdl_data, sc->sc_if_xname, sdl->sdl_nlen);
1109	memcpy(LLADDR(sdl), sc->sc_defaddr, ETHER_ADDR_LEN);
1110
1111	#if 1
1112	printf("sdl len %d index %d family %d type 0x%x nlen %d alen %d"
1113	" slen %d addr ", sdl->sdl_len, sdl->sdl_index,
1114	sdl->sdl_family, sdl->sdl_type, sdl->sdl_nlen,
1115	sdl->sdl_alen, sdl->sdl_slen);
1116	#endif
1117	for (i = `0`; i < sdl->sdl_alen; i++)
1118	printf("%s%x", i ? ":" : "", (CONST_LLADDR(sdl))[i]);
1119	printf("\n");
1120	}
1121
1122	#endif /* BRIDGE_DEBUG */
1123
1124	/*
1125	* bridgeattach:
1126	*
1127	* Pseudo-device attach routine.
1128	*/
1129	__private_extern__ int
1130	bridgeattach(int n)
1131	{
1132	#pragma unused(n)
1133	int error;
1134	lck_grp_attr_t *lck_grp_attr = NULL;
1135
1136	bridge_rtnode_pool = zinit(sizeof (struct bridge_rtnode),
1137	`1024` * sizeof (struct bridge_rtnode), `0`, "bridge_rtnode");
1138	zone_change(bridge_rtnode_pool, Z_CALLERACCT, FALSE);
1139
1140	lck_grp_attr = lck_grp_attr_alloc_init();
1141
1142	bridge_lock_grp = lck_grp_alloc_init("if_bridge", lck_grp_attr);
1143
1144	bridge_lock_attr = lck_attr_alloc_init();
1145
1146	#if BRIDGE_DEBUG
1147	lck_attr_setdebug(bridge_lock_attr);
1148	#endif
1149
1150	lck_mtx_init(&bridge_list_mtx, bridge_lock_grp, bridge_lock_attr);
1151
1152	/ can free the attributes once we've allocated the group lock /
1153	lck_grp_attr_free(lck_grp_attr);
1154
1155	LIST_INIT(&bridge_list);
1156
1157	#if BRIDGESTP
1158	bstp_sys_init();
1159	#endif /* BRIDGESTP */
1160
1161	error = if_clone_attach(&bridge_cloner);
1162	if (error != `0`)
1163	printf("%s: ifnet_clone_attach failed %d\n", __func__, error);
1164
1165	return (error);
1166	}
1167
1168	#if defined(PFIL_HOOKS)
1169	/*
1170	* handler for net.link.bridge.pfil_ipfw
1171	*/
1172	static int
1173	sysctl_pfil_ipfw SYSCTL_HANDLER_ARGS
1174	{
1175	#pragma unused(arg1, arg2)
1176	int enable = pfil_ipfw;
1177	int error;
1178
1179	error = sysctl_handle_int(oidp, &enable, `0`, req);
1180	enable = (enable) ? `1` : `0`;
1181
1182	if (enable != pfil_ipfw) {
1183	pfil_ipfw = enable;
1184
1185	/*
1186	* Disable pfil so that ipfw doesnt run twice, if the user
1187	* really wants both then they can re-enable pfil_bridge and/or
1188	* pfil_member. Also allow non-ip packets as ipfw can filter by
1189	* layer2 type.
1190	*/
1191	if (pfil_ipfw) {
1192	pfil_onlyip = `0`;
1193	pfil_bridge = `0`;
1194	pfil_member = `0`;
1195	}
1196	}
1197
1198	return (error);
1199	}
1200
1201	SYSCTL_PROC(_net_link_bridge, OID_AUTO, ipfw, CTLTYPE_INT\|CTLFLAG_RW,
1202	&pfil_ipfw, `0`, &sysctl_pfil_ipfw, "I", "Layer2 filter with IPFW");
1203	#endif /* PFIL_HOOKS */
1204
1205	static errno_t
1206	bridge_ifnet_set_attrs(struct ifnet * ifp)
1207	{
1208	errno_t error;
1209
1210	error = ifnet_set_mtu(ifp, ETHERMTU);
1211	if (error != `0`) {
1212	printf("%s: ifnet_set_mtu failed %d\n", __func__, error);
1213	goto done;
1214	}
1215	error = ifnet_set_addrlen(ifp, ETHER_ADDR_LEN);
1216	if (error != `0`) {
1217	printf("%s: ifnet_set_addrlen failed %d\n", __func__, error);
1218	goto done;
1219	}
1220	error = ifnet_set_hdrlen(ifp, ETHER_HDR_LEN);
1221	if (error != `0`) {
1222	printf("%s: ifnet_set_hdrlen failed %d\n", __func__, error);
1223	goto done;
1224	}
1225	error = ifnet_set_flags(ifp,
1226	IFF_BROADCAST \| IFF_SIMPLEX \| IFF_NOTRAILERS \| IFF_MULTICAST,
1227	`0xffff`);
1228
1229	if (error != `0`) {
1230	printf("%s: ifnet_set_flags failed %d\n", __func__, error);
1231	goto done;
1232	}
1233	done:
1234	return (error);
1235	}
1236
1237	/*
1238	* bridge_clone_create:
1239	*
1240	* Create a new bridge instance.
1241	*/
1242	static int
1243	bridge_clone_create(struct if_clone ifc, uint32_t unit, void* *params)
1244	{
1245	#pragma unused(params)
1246	struct ifnet *ifp = NULL;
1247	struct bridge_softc *sc = NULL;
1248	struct bridge_softc *sc2 = NULL;
1249	struct ifnet_init_eparams init_params;
1250	errno_t error = `0`;
1251	uint8_t eth_hostid[ETHER_ADDR_LEN];
1252	int fb, retry, has_hostid;
1253
1254	sc = if_clone_softc_allocate(&bridge_cloner);
1255	if (sc == NULL) {
1256	error = ENOMEM;
1257	goto done;
1258	}
1259
1260	lck_mtx_init(&sc->sc_mtx, bridge_lock_grp, bridge_lock_attr);
1261	sc->sc_brtmax = BRIDGE_RTABLE_MAX;
1262	sc->sc_brttimeout = BRIDGE_RTABLE_TIMEOUT;
1263	sc->sc_filter_flags = IFBF_FILT_DEFAULT;
1264	#ifndef BRIDGE_IPF
1265	/*
1266	* For backwards compatibility with previous behaviour...
1267	* Switch off filtering on the bridge itself if BRIDGE_IPF is
1268	* not defined.
1269	*/
1270	sc->sc_filter_flags &= ~IFBF_FILT_USEIPF;
1271	#endif
1272
1273	if (bridge_bsd_mode != `0`) {
1274	bridge_set_bsd_mode(sc);
1275	}
1276
1277	TAILQ_INIT(&sc->sc_iflist);
1278
1279	/ use the interface name as the unique id for ifp recycle /
1280	snprintf(sc->sc_if_xname, sizeof (sc->sc_if_xname), "%s%d",
1281	ifc->ifc_name, unit);
1282	bzero(&init_params, sizeof (init_params));
1283	init_params.ver = IFNET_INIT_CURRENT_VERSION;
1284	init_params.len = sizeof (init_params);
1285	if (bridge_in_bsd_mode(sc)) {
1286	/ Initialize our routing table. /
1287	error = bridge_rtable_init(sc);
1288	if (error != `0`) {
1289	printf("%s: bridge_rtable_init failed %d\n",
1290	__func__, error);
1291	goto done;
1292	}
1293	TAILQ_INIT(&sc->sc_spanlist);
1294	if (if_bridge_txstart) {
1295	init_params.start = bridge_start;
1296	} else {
1297	init_params.flags = IFNET_INIT_LEGACY;
1298	init_params.output = bridge_output;
1299	}
1300	init_params.set_bpf_tap = bridge_set_bpf_tap;
1301	}
1302	init_params.uniqueid = sc->sc_if_xname;
1303	init_params.uniqueid_len = strlen(sc->sc_if_xname);
1304	init_params.sndq_maxlen = IFQ_MAXLEN;
1305	init_params.name = ifc->ifc_name;
1306	init_params.unit = unit;
1307	init_params.family = IFNET_FAMILY_ETHERNET;
1308	init_params.type = IFT_BRIDGE;
1309	init_params.demux = ether_demux;
1310	init_params.add_proto = ether_add_proto;
1311	init_params.del_proto = ether_del_proto;
1312	init_params.check_multi = ether_check_multi;
1313	init_params.framer_extended = ether_frameout_extended;
1314	init_params.softc = sc;
1315	init_params.ioctl = bridge_ioctl;
1316	init_params.detach = bridge_detach;
1317	init_params.broadcast_addr = etherbroadcastaddr;
1318	init_params.broadcast_len = ETHER_ADDR_LEN;
1319
1320	if (bridge_in_bsd_mode(sc)) {
1321	error = ifnet_allocate_extended(&init_params, &ifp);
1322	if (error != `0`) {
1323	printf("%s: ifnet_allocate failed %d\n",
1324	__func__, error);
1325	goto done;
1326	}
1327	sc->sc_ifp = ifp;
1328	error = bridge_ifnet_set_attrs(ifp);
1329	if (error != `0`) {
1330	printf("%s: bridge_ifnet_set_attrs failed %d\n",
1331	__func__, error);
1332	goto done;
1333	}
1334	}
1335
1336	/*
1337	* Generate an ethernet address with a locally administered address.
1338	*
1339	* Since we are using random ethernet addresses for the bridge, it is
1340	* possible that we might have address collisions, so make sure that
1341	* this hardware address isn't already in use on another bridge.
1342	* The first try uses the "hostid" and falls back to read_frandom();
1343	* for "hostid", we use the MAC address of the first-encountered
1344	* Ethernet-type interface that is currently configured.
1345	*/
1346	fb = `0`;
1347	has_hostid = (uuid_get_ethernet(&eth_hostid[`0`]) == `0`);
1348	for (retry = `1`; retry != `0`; ) {
1349	if (fb \|\| has_hostid == `0`) {
1350	read_frandom(&sc->sc_defaddr, ETHER_ADDR_LEN);
1351	sc->sc_defaddr[`0`] &= ~`1`; / clear multicast bit /
1352	sc->sc_defaddr[`0`] \|= `2`; / set the LAA bit /
1353	} else {
1354	bcopy(&eth_hostid[`0`], &sc->sc_defaddr,
1355	ETHER_ADDR_LEN);
1356	sc->sc_defaddr[`0`] &= ~`1`; / clear multicast bit /
1357	sc->sc_defaddr[`0`] \|= `2`; / set the LAA bit /
1358	sc->sc_defaddr[`3`] = / stir it up a bit /
1359	((sc->sc_defaddr[`3`] & `0x0f`) << `4`) \|
1360	((sc->sc_defaddr[`3`] & `0xf0`) >> `4`);
1361	/*
1362	* Mix in the LSB as it's actually pretty significant,
1363	* see rdar://14076061
1364	*/
1365	sc->sc_defaddr[`4`] =
1366	(((sc->sc_defaddr[`4`] & `0x0f`) << `4`) \|
1367	((sc->sc_defaddr[`4`] & `0xf0`) >> `4`)) ^
1368	sc->sc_defaddr[`5`];
1369	sc->sc_defaddr[`5`] = ifp->if_unit & `0xff`;
1370	}
1371
1372	fb = `1`;
1373	retry = `0`;
1374	lck_mtx_lock(&bridge_list_mtx);
1375	LIST_FOREACH(sc2, &bridge_list, sc_list) {
1376	if (memcmp(sc->sc_defaddr,
1377	IF_LLADDR(sc2->sc_ifp), ETHER_ADDR_LEN) == `0`)
1378	retry = `1`;
1379	}
1380	lck_mtx_unlock(&bridge_list_mtx);
1381	}
1382
1383	sc->sc_flags &= ~SCF_MEDIA_ACTIVE;
1384
1385	#if BRIDGE_DEBUG
1386	if (if_bridge_debug & BR_DBGF_LIFECYCLE)
1387	link_print(sc);
1388	#endif
1389	if (bridge_in_bsd_mode(sc)) {
1390	error = ifnet_attach(ifp, NULL);
1391	if (error != `0`) {
1392	printf("%s: ifnet_attach failed %d\n", __func__, error);
1393	goto done;
1394	}
1395	}
1396
1397	error = ifnet_set_lladdr_and_type(ifp, sc->sc_defaddr, ETHER_ADDR_LEN,
1398	IFT_ETHER);
1399	if (error != `0`) {
1400	printf("%s: ifnet_set_lladdr_and_type failed %d\n", __func__,
1401	error);
1402	goto done;
1403	}
1404
1405	if (bridge_in_bsd_mode(sc)) {
1406	ifnet_set_offload(ifp,
1407	IFNET_CSUM_IP \| IFNET_CSUM_TCP \| IFNET_CSUM_UDP \|
1408	IFNET_CSUM_TCPIPV6 \| IFNET_CSUM_UDPIPV6 \| IFNET_MULTIPAGES);
1409	error = bridge_set_tso(sc);
1410	if (error != `0`) {
1411	printf("%s: bridge_set_tso failed %d\n",
1412	__func__, error);
1413	goto done;
1414	}
1415	#if BRIDGESTP
1416	bstp_attach(&sc->sc_stp, &bridge_ops);
1417	#endif /* BRIDGESTP */
1418	}
1419
1420	lck_mtx_lock(&bridge_list_mtx);
1421	LIST_INSERT_HEAD(&bridge_list, sc, sc_list);
1422	lck_mtx_unlock(&bridge_list_mtx);
1423
1424	/ attach as ethernet /
1425	error = bpf_attach(ifp, DLT_EN10MB, sizeof (struct ether_header),
1426	NULL, NULL);
1427
1428	done:
1429	if (error != `0`) {
1430	printf("%s failed error %d\n", __func__, error);
1431	/ TBD: Clean up: sc, sc_rthash etc /
1432	}
1433
1434	return (error);
1435	}
1436
1437	/*
1438	* bridge_clone_destroy:
1439	*
1440	* Destroy a bridge instance.
1441	*/
1442	static int
1443	bridge_clone_destroy(struct ifnet *ifp)
1444	{
1445	struct bridge_softc *sc = ifp->if_softc;
1446	struct bridge_iflist *bif;
1447	errno_t error;
1448
1449	BRIDGE_LOCK(sc);
1450	if ((sc->sc_flags & SCF_DETACHING)) {
1451	BRIDGE_UNLOCK(sc);
1452	return (`0`);
1453	}
1454	sc->sc_flags \|= SCF_DETACHING;
1455
1456	bridge_ifstop(ifp, `1`);
1457
1458	if (bridge_in_bsd_mode(sc)) {
1459	bridge_cancel_delayed_call(&sc->sc_resize_call);
1460
1461	bridge_cleanup_delayed_call(&sc->sc_resize_call);
1462	bridge_cleanup_delayed_call(&sc->sc_aging_timer);
1463	}
1464
1465	error = ifnet_set_flags(ifp, `0`, IFF_UP);
1466	if (error != `0`) {
1467	printf("%s: ifnet_set_flags failed %d\n", __func__, error);
1468	}
1469
1470	while ((bif = TAILQ_FIRST(&sc->sc_iflist)) != NULL)
1471	bridge_delete_member(sc, bif, `0`);
1472
1473	if (bridge_in_bsd_mode(sc)) {
1474	while ((bif = TAILQ_FIRST(&sc->sc_spanlist)) != NULL) {
1475	bridge_delete_span(sc, bif);
1476	}
1477	BRIDGE_UNLOCK(sc);
1478	}
1479
1480	error = ifnet_detach(ifp);
1481	if (error != `0`) {
1482	panic("%s: ifnet_detach(%p) failed %d\n",
1483	__func__, ifp, error);
1484	}
1485	return (`0`);
1486	}
1487
1488	#define DRVSPEC do { \
1489	if (ifd->ifd_cmd >= bridge_control_table_size) { \
1490	error = EINVAL; \
1491	break; \
1492	} \
1493	bc = &bridge_control_table[ifd->ifd_cmd]; \
1494	\
1495	if (cmd == SIOCGDRVSPEC && \
1496	(bc->bc_flags & BC_F_COPYOUT) == 0) { \
1497	error = EINVAL; \
1498	break; \
1499	} else if (cmd == SIOCSDRVSPEC && \
1500	(bc->bc_flags & BC_F_COPYOUT) != 0) { \
1501	error = EINVAL; \
1502	break; \
1503	} \
1504	\
1505	if (bc->bc_flags & BC_F_SUSER) { \
1506	error = kauth_authorize_generic(kauth_cred_get(), \
1507	KAUTH_GENERIC_ISSUSER); \
1508	if (error) \
1509	break; \
1510	} \
1511	\
1512	if (ifd->ifd_len != bc->bc_argsize \|\| \
1513	ifd->ifd_len > sizeof (args)) { \
1514	error = EINVAL; \
1515	break; \
1516	} \
1517	\
1518	bzero(&args, sizeof (args)); \
1519	if (bc->bc_flags & BC_F_COPYIN) { \
1520	error = copyin(ifd->ifd_data, &args, ifd->ifd_len); \
1521	if (error) \
1522	break; \
1523	} \
1524	\
1525	BRIDGE_LOCK(sc); \
1526	error = (*bc->bc_func)(sc, &args); \
1527	BRIDGE_UNLOCK(sc); \
1528	if (error) \
1529	break; \
1530	\
1531	if (bc->bc_flags & BC_F_COPYOUT) \
1532	error = copyout(&args, ifd->ifd_data, ifd->ifd_len); \
1533	} while (0)
1534
1535	/*
1536	* bridge_ioctl:
1537	*
1538	* Handle a control request from the operator.
1539	*/
1540	static errno_t
1541	bridge_ioctl(struct ifnet ifp, u_long cmd, void* *data)
1542	{
1543	struct bridge_softc *sc = ifp->if_softc;
1544	struct ifreq ifr = (struct* ifreq *)data;
1545	struct bridge_iflist *bif;
1546	int error = `0`;
1547
1548	BRIDGE_LOCK_ASSERT_NOTHELD(sc);
1549
1550	#if BRIDGE_DEBUG
1551	if (if_bridge_debug & BR_DBGF_IOCTL)
1552	printf("%s: ifp %s cmd 0x%08lx (%c%c [%lu] %c %lu)\n",
1553	__func__, ifp->if_xname, cmd, (cmd & IOC_IN) ? `'I'` : `' '`,
1554	(cmd & IOC_OUT) ? `'O'` : `' '`, IOCPARM_LEN(cmd),
1555	(char)IOCGROUP(cmd), cmd & `0xff`);
1556	#endif /* BRIDGE_DEBUG */
1557
1558	switch (cmd) {
1559
1560	case SIOCSIFADDR:
1561	case SIOCAIFADDR:
1562	ifnet_set_flags(ifp, IFF_UP, IFF_UP);
1563	break;
1564
1565	case SIOCGIFMEDIA32:
1566	case SIOCGIFMEDIA64: {
1567	struct ifmediareq ifmr = (struct* ifmediareq *)data;
1568	user_addr_t user_addr;
1569
1570	user_addr = (cmd == SIOCGIFMEDIA64) ?
1571	((struct ifmediareq64 *)ifmr)->ifmu_ulist :
1572	CAST_USER_ADDR_T(((struct ifmediareq32 *)ifmr)->ifmu_ulist);
1573
1574	ifmr->ifm_status = IFM_AVALID;
1575	ifmr->ifm_mask = `0`;
1576	ifmr->ifm_count = `1`;
1577
1578	BRIDGE_LOCK(sc);
1579	if (!(sc->sc_flags & SCF_DETACHING) &&
1580	(sc->sc_flags & SCF_MEDIA_ACTIVE)) {
1581	ifmr->ifm_status \|= IFM_ACTIVE;
1582	ifmr->ifm_active = ifmr->ifm_current =
1583	IFM_ETHER \| IFM_AUTO;
1584	} else {
1585	ifmr->ifm_active = ifmr->ifm_current = IFM_NONE;
1586	}
1587	BRIDGE_UNLOCK(sc);
1588
1589	if (user_addr != USER_ADDR_NULL) {
1590	error = copyout(&ifmr->ifm_current, user_addr,
1591	sizeof (int));
1592	}
1593	break;
1594	}
1595
1596	case SIOCADDMULTI:
1597	case SIOCDELMULTI:
1598	break;
1599
1600	case SIOCSDRVSPEC32:
1601	case SIOCGDRVSPEC32: {
1602	union {
1603	struct ifbreq ifbreq;
1604	struct ifbifconf32 ifbifconf;
1605	struct ifbareq32 ifbareq;
1606	struct ifbaconf32 ifbaconf;
1607	struct ifbrparam ifbrparam;
1608	struct ifbropreq32 ifbropreq;
1609	} args;
1610	struct ifdrv32 ifd = (struct* ifdrv32 *)data;
1611	const struct bridge_control *bridge_control_table =
1612	bridge_control_table32, *bc;
1613
1614	DRVSPEC;
1615
1616	break;
1617	}
1618	case SIOCSDRVSPEC64:
1619	case SIOCGDRVSPEC64: {
1620	union {
1621	struct ifbreq ifbreq;
1622	struct ifbifconf64 ifbifconf;
1623	struct ifbareq64 ifbareq;
1624	struct ifbaconf64 ifbaconf;
1625	struct ifbrparam ifbrparam;
1626	struct ifbropreq64 ifbropreq;
1627	} args;
1628	struct ifdrv64 ifd = (struct* ifdrv64 *)data;
1629	const struct bridge_control *bridge_control_table =
1630	bridge_control_table64, *bc;
1631
1632	DRVSPEC;
1633
1634	break;
1635	}
1636
1637	case SIOCSIFFLAGS:
1638	if (!(ifp->if_flags & IFF_UP) &&
1639	(ifp->if_flags & IFF_RUNNING)) {
1640	/*
1641	* If interface is marked down and it is running,
1642	* then stop and disable it.
1643	*/
1644	BRIDGE_LOCK(sc);
1645	bridge_ifstop(ifp, `1`);
1646	BRIDGE_UNLOCK(sc);
1647	} else if ((ifp->if_flags & IFF_UP) &&
1648	!(ifp->if_flags & IFF_RUNNING)) {
1649	/*
1650	* If interface is marked up and it is stopped, then
1651	* start it.
1652	*/
1653	BRIDGE_LOCK(sc);
1654	error = bridge_init(ifp);
1655	BRIDGE_UNLOCK(sc);
1656	}
1657	break;
1658
1659	case SIOCSIFLLADDR:
1660	error = ifnet_set_lladdr(ifp, ifr->ifr_addr.sa_data,
1661	ifr->ifr_addr.sa_len);
1662	if (error != `0`)
1663	printf("%s: SIOCSIFLLADDR error %d\n", ifp->if_xname,
1664	error);
1665	break;
1666
1667	case SIOCSIFMTU:
1668	if (ifr->ifr_mtu < `576`) {
1669	error = EINVAL;
1670	break;
1671	}
1672	BRIDGE_LOCK(sc);
1673	if (TAILQ_EMPTY(&sc->sc_iflist)) {
1674	sc->sc_ifp->if_mtu = ifr->ifr_mtu;
1675	BRIDGE_UNLOCK(sc);
1676	break;
1677	}
1678	TAILQ_FOREACH(bif, &sc->sc_iflist, bif_next) {
1679	if (bif->bif_ifp->if_mtu != (unsigned)ifr->ifr_mtu) {
1680	printf("%s: invalid MTU: %u(%s) != %d\n",
1681	sc->sc_ifp->if_xname,
1682	bif->bif_ifp->if_mtu,
1683	bif->bif_ifp->if_xname, ifr->ifr_mtu);
1684	error = EINVAL;
1685	break;
1686	}
1687	}
1688	if (!error)
1689	sc->sc_ifp->if_mtu = ifr->ifr_mtu;
1690	BRIDGE_UNLOCK(sc);
1691	break;
1692
1693	default:
1694	error = ether_ioctl(ifp, cmd, data);
1695	#if BRIDGE_DEBUG
1696	if (error != `0` && error != EOPNOTSUPP)
1697	printf("%s: ifp %s cmd 0x%08lx "
1698	"(%c%c [%lu] %c %lu) failed error: %d\n",
1699	__func__, ifp->if_xname, cmd,
1700	(cmd & IOC_IN) ? `'I'` : `' '`,
1701	(cmd & IOC_OUT) ? `'O'` : `' '`,
1702	IOCPARM_LEN(cmd), (char)IOCGROUP(cmd),
1703	cmd & `0xff`, error);
1704	#endif /* BRIDGE_DEBUG */
1705	break;
1706	}
1707	BRIDGE_LOCK_ASSERT_NOTHELD(sc);
1708
1709	return (error);
1710	}
1711
1712	#if HAS_IF_CAP
1713	/*
1714	* bridge_mutecaps:
1715	*
1716	* Clear or restore unwanted capabilities on the member interface
1717	*/
1718	static void
1719	bridge_mutecaps(struct bridge_softc *sc)
1720	{
1721	struct bridge_iflist *bif;
1722	int enabled, mask;
1723
1724	/ Initial bitmask of capabilities to test /
1725	mask = BRIDGE_IFCAPS_MASK;
1726
1727	TAILQ_FOREACH(bif, &sc->sc_iflist, bif_next) {
1728	/ Every member must support it or its disabled /
1729	mask &= bif->bif_savedcaps;
1730	}
1731
1732	TAILQ_FOREACH(bif, &sc->sc_iflist, bif_next) {
1733	enabled = bif->bif_ifp->if_capenable;
1734	enabled &= ~BRIDGE_IFCAPS_STRIP;
1735	/ strip off mask bits and enable them again if allowed /
1736	enabled &= ~BRIDGE_IFCAPS_MASK;
1737	enabled \|= mask;
1738
1739	bridge_set_ifcap(sc, bif, enabled);
1740	}
1741
1742	}
1743
1744	static void
1745	bridge_set_ifcap(struct bridge_softc sc, struct* bridge_iflist bif, int* set)
1746	{
1747	struct ifnet *ifp = bif->bif_ifp;
1748	struct ifreq ifr;
1749	int error;
1750
1751	bzero(&ifr, sizeof (ifr));
1752	ifr.ifr_reqcap = set;
1753
1754	if (ifp->if_capenable != set) {
1755	IFF_LOCKGIANT(ifp);
1756	error = (*ifp->if_ioctl)(ifp, SIOCSIFCAP, (caddr_t)&ifr);
1757	IFF_UNLOCKGIANT(ifp);
1758	if (error)
1759	printf("%s: %s error setting interface capabilities "
1760	"on %s\n", __func__, sc->sc_ifp->if_xname,
1761	ifp->if_xname);
1762	}
1763	}
1764	#endif /* HAS_IF_CAP */
1765
1766	static errno_t
1767	bridge_set_tso(struct bridge_softc *sc)
1768	{
1769	struct bridge_iflist *bif;
1770	u_int32_t tso_v4_mtu;
1771	u_int32_t tso_v6_mtu;
1772	ifnet_offload_t offload;
1773	errno_t error = `0`;
1774
1775	/ By default, support TSO /
1776	offload = sc->sc_ifp->if_hwassist \| IFNET_TSO_IPV4 \| IFNET_TSO_IPV6;
1777	tso_v4_mtu = IP_MAXPACKET;
1778	tso_v6_mtu = IP_MAXPACKET;
1779
1780	/ Use the lowest common denominator of the members /
1781	TAILQ_FOREACH(bif, &sc->sc_iflist, bif_next) {
1782	ifnet_t ifp = bif->bif_ifp;
1783
1784	if (ifp == NULL)
1785	continue;
1786
1787	if (offload & IFNET_TSO_IPV4) {
1788	if (ifp->if_hwassist & IFNET_TSO_IPV4) {
1789	if (tso_v4_mtu > ifp->if_tso_v4_mtu)
1790	tso_v4_mtu = ifp->if_tso_v4_mtu;
1791	} else {
1792	offload &= ~IFNET_TSO_IPV4;
1793	tso_v4_mtu = `0`;
1794	}
1795	}
1796	if (offload & IFNET_TSO_IPV6) {
1797	if (ifp->if_hwassist & IFNET_TSO_IPV6) {
1798	if (tso_v6_mtu > ifp->if_tso_v6_mtu)
1799	tso_v6_mtu = ifp->if_tso_v6_mtu;
1800	} else {
1801	offload &= ~IFNET_TSO_IPV6;
1802	tso_v6_mtu = `0`;
1803	}
1804	}
1805	}
1806
1807	if (offload != sc->sc_ifp->if_hwassist) {
1808	error = ifnet_set_offload(sc->sc_ifp, offload);
1809	if (error != `0`) {
1810	#if BRIDGE_DEBUG
1811	if (if_bridge_debug & BR_DBGF_LIFECYCLE)
1812	printf("%s: ifnet_set_offload(%s, 0x%x) "
1813	"failed %d\n", __func__,
1814	sc->sc_ifp->if_xname, offload, error);
1815	#endif /* BRIDGE_DEBUG */
1816	goto done;
1817	}
1818	/*
1819	* For ifnet_set_tso_mtu() sake, the TSO MTU must be at least
1820	* as large as the interface MTU
1821	*/
1822	if (sc->sc_ifp->if_hwassist & IFNET_TSO_IPV4) {
1823	if (tso_v4_mtu < sc->sc_ifp->if_mtu)
1824	tso_v4_mtu = sc->sc_ifp->if_mtu;
1825	error = ifnet_set_tso_mtu(sc->sc_ifp, AF_INET,
1826	tso_v4_mtu);
1827	if (error != `0`) {
1828	#if BRIDGE_DEBUG
1829	if (if_bridge_debug & BR_DBGF_LIFECYCLE)
1830	printf("%s: ifnet_set_tso_mtu(%s, "
1831	"AF_INET, %u) failed %d\n",
1832	__func__, sc->sc_ifp->if_xname,
1833	tso_v4_mtu, error);
1834	#endif /* BRIDGE_DEBUG */
1835	goto done;
1836	}
1837	}
1838	if (sc->sc_ifp->if_hwassist & IFNET_TSO_IPV6) {
1839	if (tso_v6_mtu < sc->sc_ifp->if_mtu)
1840	tso_v6_mtu = sc->sc_ifp->if_mtu;
1841	error = ifnet_set_tso_mtu(sc->sc_ifp, AF_INET6,
1842	tso_v6_mtu);
1843	if (error != `0`) {
1844	#if BRIDGE_DEBUG
1845	if (if_bridge_debug & BR_DBGF_LIFECYCLE)
1846	printf("%s: ifnet_set_tso_mtu(%s, "
1847	"AF_INET6, %u) failed %d\n",
1848	__func__, sc->sc_ifp->if_xname,
1849	tso_v6_mtu, error);
1850	#endif /* BRIDGE_DEBUG */
1851	goto done;
1852	}
1853	}
1854	}
1855	done:
1856	return (error);
1857	}
1858
1859	/*
1860	* bridge_lookup_member:
1861	*
1862	* Lookup a bridge member interface.
1863	*/
1864	static struct bridge_iflist *
1865	bridge_lookup_member(struct bridge_softc sc, const* char *name)
1866	{
1867	struct bridge_iflist *bif;
1868	struct ifnet *ifp;
1869
1870	BRIDGE_LOCK_ASSERT_HELD(sc);
1871
1872	TAILQ_FOREACH(bif, &sc->sc_iflist, bif_next) {
1873	ifp = bif->bif_ifp;
1874	if (strcmp(ifp->if_xname, name) == `0`)
1875	return (bif);
1876	}
1877
1878	return (NULL);
1879	}
1880
1881	/*
1882	* bridge_lookup_member_if:
1883	*
1884	* Lookup a bridge member interface by ifnet*.
1885	*/
1886	static struct bridge_iflist *
1887	bridge_lookup_member_if(struct bridge_softc sc, struct* ifnet *member_ifp)
1888	{
1889	struct bridge_iflist *bif;
1890
1891	BRIDGE_LOCK_ASSERT_HELD(sc);
1892
1893	TAILQ_FOREACH(bif, &sc->sc_iflist, bif_next) {
1894	if (bif->bif_ifp == member_ifp)
1895	return (bif);
1896	}
1897
1898	return (NULL);
1899	}
1900
1901	static errno_t
1902	bridge_iff_input(void *cookie, ifnet_t ifp, protocol_family_t protocol,
1903	mbuf_t data, char* **frame_ptr)
1904	{
1905	#pragma unused(protocol)
1906	errno_t error = `0`;
1907	struct bridge_iflist bif = (struct* bridge_iflist *)cookie;
1908	struct bridge_softc *sc = bif->bif_sc;
1909	int included = `0`;
1910	size_t frmlen = `0`;
1911	mbuf_t m = *data;
1912
1913	if ((m->m_flags & M_PROTO1))
1914	goto out;
1915
1916	if (frame_ptr >= (char* *)mbuf_datastart(m) &&
1917	frame_ptr <= (char* *)mbuf_data(m)) {
1918	included = `1`;
1919	frmlen = (char )mbuf_data(m) - frame_ptr;
1920	}
1921	#if BRIDGE_DEBUG
1922	if (if_bridge_debug & BR_DBGF_INPUT) {
1923	printf("%s: %s from %s m 0x%llx data 0x%llx frame 0x%llx %s "
1924	"frmlen %lu\n", __func__, sc->sc_ifp->if_xname,
1925	ifp->if_xname, (uint64_t)VM_KERNEL_ADDRPERM(m),
1926	(uint64_t)VM_KERNEL_ADDRPERM(mbuf_data(m)),
1927	(uint64_t)VM_KERNEL_ADDRPERM(*frame_ptr),
1928	included ? "inside" : "outside", frmlen);
1929
1930	if (if_bridge_debug & BR_DBGF_MBUF) {
1931	printf_mbuf(m, "bridge_iff_input[", "\n");
1932	printf_ether_header((struct ether_header *)
1933	(void )frame_ptr);
1934	printf_mbuf_data(m, `0`, `20`);
1935	printf("\n");
1936	}
1937	}
1938	#endif /* BRIDGE_DEBUG */
1939
1940	/ Move data pointer to start of frame to the link layer header /
1941	if (included) {
1942	(void) mbuf_setdata(m, (char *)mbuf_data(m) - frmlen,
1943	mbuf_len(m) + frmlen);
1944	(void) mbuf_pkthdr_adjustlen(m, frmlen);
1945	} else {
1946	printf("%s: frame_ptr outside mbuf\n", __func__);
1947	goto out;
1948	}
1949
1950	error = bridge_input(ifp, m, *frame_ptr);
1951
1952	/ Adjust packet back to original /
1953	if (error == `0`) {
1954	(void) mbuf_setdata(m, (char *)mbuf_data(m) + frmlen,
1955	mbuf_len(m) - frmlen);
1956	(void) mbuf_pkthdr_adjustlen(m, -frmlen);
1957	}
1958	#if BRIDGE_DEBUG
1959	if ((if_bridge_debug & BR_DBGF_INPUT) &&
1960	(if_bridge_debug & BR_DBGF_MBUF)) {
1961	printf("\n");
1962	printf_mbuf(m, "bridge_iff_input]", "\n");
1963	}
1964	#endif /* BRIDGE_DEBUG */
1965
1966	out:
1967	BRIDGE_LOCK_ASSERT_NOTHELD(sc);
1968
1969	return (error);
1970	}
1971
1972	#if BRIDGE_MEMBER_OUT_FILTER
1973	static errno_t
1974	bridge_iff_output(void *cookie, ifnet_t ifp, protocol_family_t protocol,
1975	mbuf_t *data)
1976	{
1977	#pragma unused(protocol)
1978	errno_t error = `0`;
1979	struct bridge_iflist bif = (struct* bridge_iflist *)cookie;
1980	struct bridge_softc *sc = bif->bif_sc;
1981	mbuf_t m = *data;
1982
1983	if ((m->m_flags & M_PROTO1))
1984	goto out;
1985
1986	#if BRIDGE_DEBUG
1987	if (if_bridge_debug & BR_DBGF_OUTPUT) {
1988	printf("%s: %s from %s m 0x%llx data 0x%llx\n", __func__,
1989	sc->sc_ifp->if_xname, ifp->if_xname,
1990	(uint64_t)VM_KERNEL_ADDRPERM(m),
1991	(uint64_t)VM_KERNEL_ADDRPERM(mbuf_data(m)));
1992	}
1993	#endif /* BRIDGE_DEBUG */
1994
1995	error = bridge_member_output(sc, ifp, m);
1996	if (error != `0`) {
1997	printf("%s: bridge_member_output failed error %d\n", __func__,
1998	error);
1999	}
2000
2001	out:
2002	BRIDGE_LOCK_ASSERT_NOTHELD(sc);
2003
2004	return (error);
2005	}
2006	#endif /* BRIDGE_MEMBER_OUT_FILTER */
2007
2008	static void
2009	bridge_iff_event(void *cookie, ifnet_t ifp, protocol_family_t protocol,
2010	const struct kev_msg *event_msg)
2011	{
2012	#pragma unused(protocol)
2013	struct bridge_iflist bif = (struct* bridge_iflist *)cookie;
2014	struct bridge_softc *sc = bif->bif_sc;
2015
2016	if (event_msg->vendor_code == KEV_VENDOR_APPLE &&
2017	event_msg->kev_class == KEV_NETWORK_CLASS &&
2018	event_msg->kev_subclass == KEV_DL_SUBCLASS) {
2019	#if BRIDGE_DEBUG
2020	if (if_bridge_debug & BR_DBGF_LIFECYCLE)
2021	printf("%s: %s event_code %u - %s\n", __func__,
2022	ifp->if_xname, event_msg->event_code,
2023	dlil_kev_dl_code_str(event_msg->event_code));
2024	#endif /* BRIDGE_DEBUG */
2025
2026	switch (event_msg->event_code) {
2027	case KEV_DL_IF_DETACHING:
2028	case KEV_DL_IF_DETACHED: {
2029	bridge_ifdetach(bif, ifp);
2030	break;
2031	}
2032	case KEV_DL_LINK_OFF:
2033	case KEV_DL_LINK_ON: {
2034	bridge_iflinkevent(ifp);
2035	#if BRIDGESTP
2036	bstp_linkstate(ifp, event_msg->event_code);
2037	#endif /* BRIDGESTP */
2038	break;
2039	}
2040	case KEV_DL_SIFFLAGS: {
2041	if ((bif->bif_flags & BIFF_PROMISC) == `0` &&
2042	(ifp->if_flags & IFF_UP)) {
2043	errno_t error;
2044
2045	error = ifnet_set_promiscuous(ifp, `1`);
2046	if (error != `0`) {
2047	printf("%s: "
2048	"ifnet_set_promiscuous (%s)"
2049	" failed %d\n",
2050	__func__, ifp->if_xname,
2051	error);
2052	} else {
2053	bif->bif_flags \|= BIFF_PROMISC;
2054	}
2055	}
2056	break;
2057	}
2058	case KEV_DL_IFCAP_CHANGED: {
2059	BRIDGE_LOCK(sc);
2060	bridge_set_tso(sc);
2061	BRIDGE_UNLOCK(sc);
2062	break;
2063	}
2064	default:
2065	break;
2066	}
2067	}
2068	}
2069
2070	/*
2071	* bridge_iff_detached:
2072	*
2073	* Detach an interface from a bridge. Called when a member
2074	* interface is detaching.
2075	*/
2076	static void
2077	bridge_iff_detached(void *cookie, ifnet_t ifp)
2078	{
2079	struct bridge_iflist bif = (struct* bridge_iflist *)cookie;
2080
2081	#if BRIDGE_DEBUG
2082	if (if_bridge_debug & BR_DBGF_LIFECYCLE)
2083	printf("%s: %s\n", __func__, ifp->if_xname);
2084	#endif /* BRIDGE_DEBUG */
2085
2086	bridge_ifdetach(bif, ifp);
2087
2088	_FREE(bif, M_DEVBUF);
2089	}
2090
2091	static errno_t
2092	bridge_proto_input(ifnet_t ifp, protocol_family_t protocol, mbuf_t packet,
2093	char *header)
2094	{
2095	#pragma unused(protocol, packet, header)
2096	#if BRIDGE_DEBUG
2097	printf("%s: unexpected packet from %s\n", __func__,
2098	ifp->if_xname);
2099	#endif /* BRIDGE_DEBUG */
2100	return (`0`);
2101	}
2102
2103	static int
2104	bridge_attach_protocol(struct ifnet *ifp)
2105	{
2106	int error;
2107	struct ifnet_attach_proto_param reg;
2108
2109	#if BRIDGE_DEBUG
2110	if (if_bridge_debug & BR_DBGF_LIFECYCLE)
2111	printf("%s: %s\n", __func__, ifp->if_xname);
2112	#endif /* BRIDGE_DEBUG */
2113
2114	bzero(&reg, sizeof (reg));
2115	reg.input = bridge_proto_input;
2116
2117	error = ifnet_attach_protocol(ifp, PF_BRIDGE, &reg);
2118	if (error)
2119	printf("%s: ifnet_attach_protocol(%s) failed, %d\n",
2120	__func__, ifp->if_xname, error);
2121
2122	return (error);
2123	}
2124
2125	static int
2126	bridge_detach_protocol(struct ifnet *ifp)
2127	{
2128	int error;
2129
2130	#if BRIDGE_DEBUG
2131	if (if_bridge_debug & BR_DBGF_LIFECYCLE)
2132	printf("%s: %s\n", __func__, ifp->if_xname);
2133	#endif /* BRIDGE_DEBUG */
2134	error = ifnet_detach_protocol(ifp, PF_BRIDGE);
2135	if (error)
2136	printf("%s: ifnet_detach_protocol(%s) failed, %d\n",
2137	__func__, ifp->if_xname, error);
2138
2139	return (error);
2140	}
2141
2142	/*
2143	* bridge_delete_member:
2144	*
2145	* Delete the specified member interface.
2146	*/
2147	static void
2148	bridge_delete_member(struct bridge_softc sc, struct* bridge_iflist *bif,
2149	int gone)
2150	{
2151	struct ifnet ifs = bif->bif_ifp, bifp = sc->sc_ifp;
2152	int lladdr_changed = `0`, error, filt_attached;
2153	uint8_t eaddr[ETHER_ADDR_LEN];
2154	u_int32_t event_code = `0`;
2155	boolean_t bsd_mode;
2156
2157	BRIDGE_LOCK_ASSERT_HELD(sc);
2158	VERIFY(ifs != NULL);
2159
2160	bsd_mode = bridge_in_bsd_mode(sc);
2161
2162	/*
2163	* First, remove the member from the list first so it cannot be found anymore
2164	* when we release the bridge lock below
2165	*/
2166	BRIDGE_XLOCK(sc);
2167	TAILQ_REMOVE(&sc->sc_iflist, bif, bif_next);
2168	BRIDGE_XDROP(sc);
2169
2170	if (!gone) {
2171	switch (ifs->if_type) {
2172	case IFT_ETHER:
2173	case IFT_L2VLAN:
2174	/*
2175	* Take the interface out of promiscuous mode.
2176	*/
2177	if (bif->bif_flags & BIFF_PROMISC) {
2178	/*
2179	* Unlock to prevent deadlock with bridge_iff_event() in
2180	* case the driver generates an interface event
2181	*/
2182	BRIDGE_UNLOCK(sc);
2183	(void) ifnet_set_promiscuous(ifs, `0`);
2184	BRIDGE_LOCK(sc);
2185	}
2186	break;
2187
2188	case IFT_GIF:
2189	/ currently not supported /
2190	/ FALLTHRU /
2191	default:
2192	VERIFY(`0`);
2193	/ NOTREACHED /
2194	}
2195
2196	#if HAS_IF_CAP
2197	/ reneable any interface capabilities /
2198	bridge_set_ifcap(sc, bif, bif->bif_savedcaps);
2199	#endif
2200	}
2201
2202	if (bif->bif_flags & BIFF_PROTO_ATTACHED) {
2203	/ Respect lock ordering with DLIL lock /
2204	BRIDGE_UNLOCK(sc);
2205	(void) bridge_detach_protocol(ifs);
2206	BRIDGE_LOCK(sc);
2207	}
2208	#if BRIDGESTP
2209	if (bsd_mode && (bif->bif_ifflags & IFBIF_STP) != `0`) {
2210	bstp_disable(&bif->bif_stp);
2211	}
2212	#endif /* BRIDGESTP */
2213
2214	/*
2215	* If removing the interface that gave the bridge its mac address, set
2216	* the mac address of the bridge to the address of the next member, or
2217	* to its default address if no members are left.
2218	*/
2219	if (bridge_inherit_mac && sc->sc_ifaddr == ifs) {
2220	ifnet_release(sc->sc_ifaddr);
2221	if (TAILQ_EMPTY(&sc->sc_iflist)) {
2222	bcopy(sc->sc_defaddr, eaddr, ETHER_ADDR_LEN);
2223	sc->sc_ifaddr = NULL;
2224	} else {
2225	struct ifnet *fif =
2226	TAILQ_FIRST(&sc->sc_iflist)->bif_ifp;
2227	bcopy(IF_LLADDR(fif), eaddr, ETHER_ADDR_LEN);
2228	sc->sc_ifaddr = fif;
2229	ifnet_reference(fif); / for sc_ifaddr /
2230	}
2231	lladdr_changed = `1`;
2232	}
2233
2234	#if HAS_IF_CAP
2235	bridge_mutecaps(sc); / recalculate now this interface is removed /
2236	#endif /* HAS_IF_CAP */
2237
2238	error = bridge_set_tso(sc);
2239	if (error != `0`) {
2240	printf("%s: bridge_set_tso failed %d\n", __func__, error);
2241	}
2242
2243	if (bsd_mode) {
2244	bridge_rtdelete(sc, ifs, IFBF_FLUSHALL);
2245	}
2246
2247	KASSERT(bif->bif_addrcnt == `0`,
2248	("%s: %d bridge routes referenced", __func__, bif->bif_addrcnt));
2249
2250	filt_attached = bif->bif_flags & BIFF_FILTER_ATTACHED;
2251
2252	/*
2253	* Update link status of the bridge based on its remaining members
2254	*/
2255	event_code = bridge_updatelinkstatus(sc);
2256
2257	if (bsd_mode) {
2258	BRIDGE_UNLOCK(sc);
2259	}
2260
2261	if (lladdr_changed &&
2262	(error = ifnet_set_lladdr(bifp, eaddr, ETHER_ADDR_LEN)) != `0`)
2263	printf("%s: ifnet_set_lladdr failed %d\n", __func__, error);
2264
2265	if (event_code != `0`)
2266	bridge_link_event(bifp, event_code);
2267
2268	#if BRIDGESTP
2269	if (bsd_mode) {
2270	bstp_destroy(&bif->bif_stp); / prepare to free /
2271	}
2272	#endif /* BRIDGESTP */
2273
2274	if (filt_attached)
2275	iflt_detach(bif->bif_iff_ref);
2276	else
2277	_FREE(bif, M_DEVBUF);
2278
2279	ifs->if_bridge = NULL;
2280	ifnet_release(ifs);
2281
2282	BRIDGE_LOCK(sc);
2283	}
2284
2285	/*
2286	* bridge_delete_span:
2287	*
2288	* Delete the specified span interface.
2289	*/
2290	static void
2291	bridge_delete_span(struct bridge_softc sc, struct* bridge_iflist *bif)
2292	{
2293	BRIDGE_LOCK_ASSERT_HELD(sc);
2294
2295	KASSERT(bif->bif_ifp->if_bridge == NULL,
2296	("%s: not a span interface", __func__));
2297
2298	ifnet_release(bif->bif_ifp);
2299
2300	TAILQ_REMOVE(&sc->sc_spanlist, bif, bif_next);
2301	_FREE(bif, M_DEVBUF);
2302	}
2303
2304	static int
2305	bridge_ioctl_add(struct bridge_softc sc, void* *arg)
2306	{
2307	struct ifbreq *req = arg;
2308	struct bridge_iflist *bif = NULL;
2309	struct ifnet ifs, bifp = sc->sc_ifp;
2310	int error = `0`, lladdr_changed = `0`;
2311	uint8_t eaddr[ETHER_ADDR_LEN];
2312	struct iff_filter iff;
2313	u_int32_t event_code = `0`;
2314	boolean_t bsd_mode = bridge_in_bsd_mode(sc);
2315
2316	ifs = ifunit(req->ifbr_ifsname);
2317	if (ifs == NULL)
2318	return (ENOENT);
2319	if (ifs->if_ioctl == NULL) / must be supported /
2320	return (EINVAL);
2321
2322	if (IFNET_IS_INTCOPROC(ifs)) {
2323	return (EINVAL);
2324	}
2325
2326	if (bsd_mode) {
2327	/ If it's in the span list, it can't be a member. /
2328	TAILQ_FOREACH(bif, &sc->sc_spanlist, bif_next)
2329	if (ifs == bif->bif_ifp)
2330	return (EBUSY);
2331	}
2332
2333	if (ifs->if_bridge == sc)
2334	return (EEXIST);
2335
2336	if (ifs->if_bridge != NULL)
2337	return (EBUSY);
2338
2339	switch (ifs->if_type) {
2340	case IFT_ETHER:
2341	case IFT_L2VLAN:
2342	/ permitted interface types /
2343	break;
2344	case IFT_GIF:
2345	/ currently not supported /
2346	/ FALLTHRU /
2347	default:
2348	return (EINVAL);
2349	}
2350
2351	bif = _MALLOC(sizeof (*bif), M_DEVBUF, M_WAITOK \| M_ZERO);
2352	if (bif == NULL)
2353	return (ENOMEM);
2354
2355	bif->bif_ifp = ifs;
2356	ifnet_reference(ifs);
2357	bif->bif_ifflags = IFBIF_LEARNING \| IFBIF_DISCOVER;
2358	#if HAS_IF_CAP
2359	bif->bif_savedcaps = ifs->if_capenable;
2360	#endif /* HAS_IF_CAP */
2361	bif->bif_sc = sc;
2362
2363	/ Allow the first Ethernet member to define the MTU /
2364	if (TAILQ_EMPTY(&sc->sc_iflist))
2365	sc->sc_ifp->if_mtu = ifs->if_mtu;
2366	else if (sc->sc_ifp->if_mtu != ifs->if_mtu) {
2367	printf("%s: %s: invalid MTU for %s", __func__,
2368	sc->sc_ifp->if_xname,
2369	ifs->if_xname);
2370	return (EINVAL);
2371	}
2372
2373	/*
2374	* Assign the interface's MAC address to the bridge if it's the first
2375	* member and the MAC address of the bridge has not been changed from
2376	* the default (randomly) generated one.
2377	*/
2378	if (bridge_inherit_mac && TAILQ_EMPTY(&sc->sc_iflist) &&
2379	!memcmp(IF_LLADDR(sc->sc_ifp), sc->sc_defaddr, ETHER_ADDR_LEN)) {
2380	bcopy(IF_LLADDR(ifs), eaddr, ETHER_ADDR_LEN);
2381	sc->sc_ifaddr = ifs;
2382	ifnet_reference(ifs); / for sc_ifaddr /
2383	lladdr_changed = `1`;
2384	}
2385
2386	ifs->if_bridge = sc;
2387	#if BRIDGESTP
2388	if (bsd_mode) {
2389	bstp_create(&sc->sc_stp, &bif->bif_stp, bif->bif_ifp);
2390	}
2391	#endif /* BRIDGESTP */
2392
2393	/*
2394	* XXX: XLOCK HERE!?!
2395	*/
2396	TAILQ_INSERT_TAIL(&sc->sc_iflist, bif, bif_next);
2397
2398	#if HAS_IF_CAP
2399	/ Set interface capabilities to the intersection set of all members /
2400	bridge_mutecaps(sc);
2401	#endif /* HAS_IF_CAP */
2402
2403	bridge_set_tso(sc);
2404
2405
2406	/*
2407	* Place the interface into promiscuous mode.
2408	*/
2409	switch (ifs->if_type) {
2410	case IFT_ETHER:
2411	case IFT_L2VLAN:
2412	error = ifnet_set_promiscuous(ifs, `1`);
2413	if (error) {
2414	/ Ignore error when device is not up /
2415	if (error != ENETDOWN)
2416	goto out;
2417	error = `0`;
2418	} else {
2419	bif->bif_flags \|= BIFF_PROMISC;
2420	}
2421	break;
2422
2423	default:
2424	break;
2425	}
2426
2427	/*
2428	* The new member may change the link status of the bridge interface
2429	*/
2430	if (interface_media_active(ifs))
2431	bif->bif_flags \|= BIFF_MEDIA_ACTIVE;
2432	else
2433	bif->bif_flags &= ~BIFF_MEDIA_ACTIVE;
2434
2435	event_code = bridge_updatelinkstatus(sc);
2436
2437	/*
2438	* Respect lock ordering with DLIL lock for the following operations
2439	*/
2440	if (bsd_mode) {
2441	BRIDGE_UNLOCK(sc);
2442	}
2443
2444	/*
2445	* install an interface filter
2446	*/
2447	memset(&iff, `0`, sizeof (struct iff_filter));
2448	iff.iff_cookie = bif;
2449	iff.iff_name = "com.apple.kernel.bsd.net.if_bridge";
2450	if (bsd_mode) {
2451	iff.iff_input = bridge_iff_input;
2452	#if BRIDGE_MEMBER_OUT_FILTER
2453	iff.iff_output = bridge_iff_output;
2454	#endif /* BRIDGE_MEMBER_OUT_FILTER */
2455	}
2456	iff.iff_event = bridge_iff_event;
2457	iff.iff_detached = bridge_iff_detached;
2458	error = dlil_attach_filter(ifs, &iff, &bif->bif_iff_ref,
2459	DLIL_IFF_TSO \| DLIL_IFF_INTERNAL);
2460	if (error != `0`) {
2461	printf("%s: iflt_attach failed %d\n", __func__, error);
2462	BRIDGE_LOCK(sc);
2463	goto out;
2464	}
2465	bif->bif_flags \|= BIFF_FILTER_ATTACHED;
2466
2467	/*
2468	* install an dummy "bridge" protocol
2469	*/
2470	if ((error = bridge_attach_protocol(ifs)) != `0`) {
2471	if (error != `0`) {
2472	printf("%s: bridge_attach_protocol failed %d\n",
2473	__func__, error);
2474	BRIDGE_LOCK(sc);
2475	goto out;
2476	}
2477	}
2478	bif->bif_flags \|= BIFF_PROTO_ATTACHED;
2479
2480	if (lladdr_changed &&
2481	(error = ifnet_set_lladdr(bifp, eaddr, ETHER_ADDR_LEN)) != `0`)
2482	printf("%s: ifnet_set_lladdr failed %d\n", __func__, error);
2483
2484	if (event_code != `0`)
2485	bridge_link_event(bifp, event_code);
2486
2487	BRIDGE_LOCK(sc);
2488
2489	out:
2490	if (error && bif != NULL)
2491	bridge_delete_member(sc, bif, `1`);
2492
2493	return (error);
2494	}
2495
2496	static int
2497	bridge_ioctl_del(struct bridge_softc sc, void* *arg)
2498	{
2499	struct ifbreq *req = arg;
2500	struct bridge_iflist *bif;
2501
2502	bif = bridge_lookup_member(sc, req->ifbr_ifsname);
2503	if (bif == NULL)
2504	return (ENOENT);
2505
2506	bridge_delete_member(sc, bif, `0`);
2507
2508	return (`0`);
2509	}
2510
2511	static int
2512	bridge_ioctl_purge(struct bridge_softc sc, void* *arg)
2513	{
2514	#pragma unused(sc, arg)
2515	return (`0`);
2516	}
2517
2518	static int
2519	bridge_ioctl_gifflags(struct bridge_softc sc, void* *arg)
2520	{
2521	struct ifbreq *req = arg;
2522	struct bridge_iflist *bif;
2523
2524	bif = bridge_lookup_member(sc, req->ifbr_ifsname);
2525	if (bif == NULL)
2526	return (ENOENT);
2527
2528	if (bridge_in_bsd_mode(sc)) {
2529	struct bstp_port *bp;
2530
2531	bp = &bif->bif_stp;
2532	req->ifbr_state = bp->bp_state;
2533	req->ifbr_priority = bp->bp_priority;
2534	req->ifbr_path_cost = bp->bp_path_cost;
2535	req->ifbr_proto = bp->bp_protover;
2536	req->ifbr_role = bp->bp_role;
2537	req->ifbr_stpflags = bp->bp_flags;
2538	/ Copy STP state options as flags /
2539	if (bp->bp_operedge)
2540	req->ifbr_ifsflags \|= IFBIF_BSTP_EDGE;
2541	if (bp->bp_flags & BSTP_PORT_AUTOEDGE)
2542	req->ifbr_ifsflags \|= IFBIF_BSTP_AUTOEDGE;
2543	if (bp->bp_ptp_link)
2544	req->ifbr_ifsflags \|= IFBIF_BSTP_PTP;
2545	if (bp->bp_flags & BSTP_PORT_AUTOPTP)
2546	req->ifbr_ifsflags \|= IFBIF_BSTP_AUTOPTP;
2547	if (bp->bp_flags & BSTP_PORT_ADMEDGE)
2548	req->ifbr_ifsflags \|= IFBIF_BSTP_ADMEDGE;
2549	if (bp->bp_flags & BSTP_PORT_ADMCOST)
2550	req->ifbr_ifsflags \|= IFBIF_BSTP_ADMCOST;
2551	}
2552	req->ifbr_ifsflags = bif->bif_ifflags;
2553	req->ifbr_portno = bif->bif_ifp->if_index & `0xfff`;
2554	req->ifbr_addrcnt = bif->bif_addrcnt;
2555	req->ifbr_addrmax = bif->bif_addrmax;
2556	req->ifbr_addrexceeded = bif->bif_addrexceeded;
2557
2558	return (`0`);
2559	}
2560
2561	static int
2562	bridge_ioctl_sifflags(struct bridge_softc sc, void* *arg)
2563	{
2564	struct ifbreq *req = arg;
2565	struct bridge_iflist *bif;
2566	#if BRIDGESTP
2567	struct bstp_port *bp;
2568	int error;
2569	#endif /* BRIDGESTP */
2570
2571	if (!bridge_in_bsd_mode(sc)) {
2572	return (EINVAL);
2573	}
2574
2575	bif = bridge_lookup_member(sc, req->ifbr_ifsname);
2576	if (bif == NULL)
2577	return (ENOENT);
2578
2579	if (req->ifbr_ifsflags & IFBIF_SPAN)
2580	/ SPAN is readonly /
2581	return (EINVAL);
2582
2583
2584	#if BRIDGESTP
2585	if (req->ifbr_ifsflags & IFBIF_STP) {
2586	if ((bif->bif_ifflags & IFBIF_STP) == `0`) {
2587	error = bstp_enable(&bif->bif_stp);
2588	if (error)
2589	return (error);
2590	}
2591	} else {
2592	if ((bif->bif_ifflags & IFBIF_STP) != `0`)
2593	bstp_disable(&bif->bif_stp);
2594	}
2595
2596	/ Pass on STP flags /
2597	bp = &bif->bif_stp;
2598	bstp_set_edge(bp, req->ifbr_ifsflags & IFBIF_BSTP_EDGE ? `1` : `0`);
2599	bstp_set_autoedge(bp, req->ifbr_ifsflags & IFBIF_BSTP_AUTOEDGE ? `1` : `0`);
2600	bstp_set_ptp(bp, req->ifbr_ifsflags & IFBIF_BSTP_PTP ? `1` : `0`);
2601	bstp_set_autoptp(bp, req->ifbr_ifsflags & IFBIF_BSTP_AUTOPTP ? `1` : `0`);
2602	#else /* !BRIDGESTP */
2603	if (req->ifbr_ifsflags & IFBIF_STP)
2604	return (EOPNOTSUPP);
2605	#endif /* !BRIDGESTP */
2606
2607	/ Save the bits relating to the bridge /
2608	bif->bif_ifflags = req->ifbr_ifsflags & IFBIFMASK;
2609
2610
2611	return (`0`);
2612	}
2613
2614	static int
2615	bridge_ioctl_scache(struct bridge_softc sc, void* *arg)
2616	{
2617	struct ifbrparam *param = arg;
2618
2619	sc->sc_brtmax = param->ifbrp_csize;
2620	if (bridge_in_bsd_mode(sc)) {
2621	bridge_rttrim(sc);
2622	}
2623	return (`0`);
2624	}
2625
2626	static int
2627	bridge_ioctl_gcache(struct bridge_softc sc, void* *arg)
2628	{
2629	struct ifbrparam *param = arg;
2630
2631	param->ifbrp_csize = sc->sc_brtmax;
2632
2633	return (`0`);
2634	}
2635
2636	#define BRIDGE_IOCTL_GIFS do { \
2637	struct bridge_iflist *bif; \
2638	struct ifbreq breq; \
2639	char buf, outbuf; \
2640	unsigned int count, buflen, len; \
2641	\
2642	count = 0; \
2643	TAILQ_FOREACH(bif, &sc->sc_iflist, bif_next) \
2644	count++; \
2645	if (bridge_in_bsd_mode(sc)) { \
2646	TAILQ_FOREACH(bif, &sc->sc_spanlist, bif_next) \
2647	count++; \
2648	} \
2649	\
2650	buflen = sizeof (breq) * count; \
2651	if (bifc->ifbic_len == 0) { \
2652	bifc->ifbic_len = buflen; \
2653	return (0); \
2654	} \
2655	BRIDGE_UNLOCK(sc); \
2656	outbuf = _MALLOC(buflen, M_TEMP, M_WAITOK \| M_ZERO); \
2657	BRIDGE_LOCK(sc); \
2658	\
2659	count = 0; \
2660	buf = outbuf; \
2661	len = min(bifc->ifbic_len, buflen); \
2662	bzero(&breq, sizeof (breq)); \
2663	TAILQ_FOREACH(bif, &sc->sc_iflist, bif_next) { \
2664	if (len < sizeof (breq)) \
2665	break; \
2666	\
2667	snprintf(breq.ifbr_ifsname, sizeof (breq.ifbr_ifsname), \
2668	"%s", bif->bif_ifp->if_xname); \
2669	/* Fill in the ifbreq structure */ \
2670	error = bridge_ioctl_gifflags(sc, &breq); \
2671	if (error) \
2672	break; \
2673	memcpy(buf, &breq, sizeof (breq)); \
2674	count++; \
2675	buf += sizeof (breq); \
2676	len -= sizeof (breq); \
2677	} \
2678	if (bridge_in_bsd_mode(sc)) { \
2679	TAILQ_FOREACH(bif, &sc->sc_spanlist, bif_next) { \
2680	if (len < sizeof (breq)) \
2681	break; \
2682	\
2683	snprintf(breq.ifbr_ifsname, \
2684	sizeof (breq.ifbr_ifsname), \
2685	"%s", bif->bif_ifp->if_xname); \
2686	breq.ifbr_ifsflags = bif->bif_ifflags; \
2687	breq.ifbr_portno \
2688	= bif->bif_ifp->if_index & 0xfff; \
2689	memcpy(buf, &breq, sizeof (breq)); \
2690	count++; \
2691	buf += sizeof (breq); \
2692	len -= sizeof (breq); \
2693	} \
2694	} \
2695	\
2696	BRIDGE_UNLOCK(sc); \
2697	bifc->ifbic_len = sizeof (breq) * count; \
2698	error = copyout(outbuf, bifc->ifbic_req, bifc->ifbic_len); \
2699	BRIDGE_LOCK(sc); \
2700	_FREE(outbuf, M_TEMP); \
2701	} while (0)
2702
2703	static int
2704	bridge_ioctl_gifs64(struct bridge_softc sc, void* *arg)
2705	{
2706	struct ifbifconf64 *bifc = arg;
2707	int error = `0`;
2708
2709	BRIDGE_IOCTL_GIFS;
2710
2711	return (error);
2712	}
2713
2714	static int
2715	bridge_ioctl_gifs32(struct bridge_softc sc, void* *arg)
2716	{
2717	struct ifbifconf32 *bifc = arg;
2718	int error = `0`;
2719
2720	BRIDGE_IOCTL_GIFS;
2721
2722	return (error);
2723	}
2724
2725	#define BRIDGE_IOCTL_RTS do { \
2726	struct bridge_rtnode *brt; \
2727	char *buf; \
2728	char *outbuf = NULL; \
2729	unsigned int count, buflen, len; \
2730	unsigned long now; \
2731	\
2732	if (bac->ifbac_len == 0) \
2733	return (0); \
2734	\
2735	bzero(&bareq, sizeof (bareq)); \
2736	count = 0; \
2737	if (!bridge_in_bsd_mode(sc)) { \
2738	goto out; \
2739	} \
2740	LIST_FOREACH(brt, &sc->sc_rtlist, brt_list) \
2741	count++; \
2742	buflen = sizeof (bareq) * count; \
2743	\
2744	BRIDGE_UNLOCK(sc); \
2745	outbuf = _MALLOC(buflen, M_TEMP, M_WAITOK \| M_ZERO); \
2746	BRIDGE_LOCK(sc); \
2747	\
2748	count = 0; \
2749	buf = outbuf; \
2750	len = min(bac->ifbac_len, buflen); \
2751	LIST_FOREACH(brt, &sc->sc_rtlist, brt_list) { \
2752	if (len < sizeof (bareq)) \
2753	goto out; \
2754	snprintf(bareq.ifba_ifsname, sizeof (bareq.ifba_ifsname), \
2755	"%s", brt->brt_ifp->if_xname); \
2756	memcpy(bareq.ifba_dst, brt->brt_addr, sizeof (brt->brt_addr)); \
2757	bareq.ifba_vlan = brt->brt_vlan; \
2758	if ((brt->brt_flags & IFBAF_TYPEMASK) == IFBAF_DYNAMIC) { \
2759	now = (unsigned long) net_uptime(); \
2760	if (now < brt->brt_expire) \
2761	bareq.ifba_expire = \
2762	brt->brt_expire - now; \
2763	} else \
2764	bareq.ifba_expire = 0; \
2765	bareq.ifba_flags = brt->brt_flags; \
2766	\
2767	memcpy(buf, &bareq, sizeof (bareq)); \
2768	count++; \
2769	buf += sizeof (bareq); \
2770	len -= sizeof (bareq); \
2771	} \
2772	out: \
2773	bac->ifbac_len = sizeof (bareq) * count; \
2774	if (outbuf != NULL) { \
2775	BRIDGE_UNLOCK(sc); \
2776	error = copyout(outbuf, bac->ifbac_req, bac->ifbac_len); \
2777	_FREE(outbuf, M_TEMP); \
2778	BRIDGE_LOCK(sc); \
2779	} \
2780	return (error); \
2781	} while (0)
2782
2783	static int
2784	bridge_ioctl_rts64(struct bridge_softc sc, void* *arg)
2785	{
2786	struct ifbaconf64 *bac = arg;
2787	struct ifbareq64 bareq;
2788	int error = `0`;
2789
2790	BRIDGE_IOCTL_RTS;
2791	return (error);
2792	}
2793
2794	static int
2795	bridge_ioctl_rts32(struct bridge_softc sc, void* *arg)
2796	{
2797	struct ifbaconf32 *bac = arg;
2798	struct ifbareq32 bareq;
2799	int error = `0`;
2800
2801	BRIDGE_IOCTL_RTS;
2802	return (error);
2803	}
2804
2805	static int
2806	bridge_ioctl_saddr32(struct bridge_softc sc, void* *arg)
2807	{
2808	struct ifbareq32 *req = arg;
2809	struct bridge_iflist *bif;
2810	int error;
2811
2812	if (!bridge_in_bsd_mode(sc)) {
2813	return (`0`);
2814	}
2815
2816	bif = bridge_lookup_member(sc, req->ifba_ifsname);
2817	if (bif == NULL)
2818	return (ENOENT);
2819
2820	error = bridge_rtupdate(sc, req->ifba_dst, req->ifba_vlan, bif, `1`,
2821	req->ifba_flags);
2822
2823	return (error);
2824	}
2825
2826	static int
2827	bridge_ioctl_saddr64(struct bridge_softc sc, void* *arg)
2828	{
2829	struct ifbareq64 *req = arg;
2830	struct bridge_iflist *bif;
2831	int error;
2832
2833	if (!bridge_in_bsd_mode(sc)) {
2834	return (`0`);
2835	}
2836
2837	bif = bridge_lookup_member(sc, req->ifba_ifsname);
2838	if (bif == NULL)
2839	return (ENOENT);
2840
2841	error = bridge_rtupdate(sc, req->ifba_dst, req->ifba_vlan, bif, `1`,
2842	req->ifba_flags);
2843
2844	return (error);
2845	}
2846
2847	static int
2848	bridge_ioctl_sto(struct bridge_softc sc, void* *arg)
2849	{
2850	struct ifbrparam *param = arg;
2851
2852	sc->sc_brttimeout = param->ifbrp_ctime;
2853	return (`0`);
2854	}
2855
2856	static int
2857	bridge_ioctl_gto(struct bridge_softc sc, void* *arg)
2858	{
2859	struct ifbrparam *param = arg;
2860
2861	param->ifbrp_ctime = sc->sc_brttimeout;
2862	return (`0`);
2863	}
2864
2865	static int
2866	bridge_ioctl_daddr32(struct bridge_softc sc, void* *arg)
2867	{
2868	struct ifbareq32 *req = arg;
2869
2870	if (!bridge_in_bsd_mode(sc)) {
2871	return (`0`);
2872	}
2873	return (bridge_rtdaddr(sc, req->ifba_dst, req->ifba_vlan));
2874	}
2875
2876	static int
2877	bridge_ioctl_daddr64(struct bridge_softc sc, void* *arg)
2878	{
2879	struct ifbareq64 *req = arg;
2880
2881	if (!bridge_in_bsd_mode(sc)) {
2882	return (`0`);
2883	}
2884	return (bridge_rtdaddr(sc, req->ifba_dst, req->ifba_vlan));
2885	}
2886
2887	static int
2888	bridge_ioctl_flush(struct bridge_softc sc, void* *arg)
2889	{
2890	struct ifbreq *req = arg;
2891
2892	if (!bridge_in_bsd_mode(sc)) {
2893	return (`0`);
2894	}
2895	bridge_rtflush(sc, req->ifbr_ifsflags);
2896	return (`0`);
2897	}
2898
2899	static int
2900	bridge_ioctl_gpri(struct bridge_softc sc, void* *arg)
2901	{
2902	struct ifbrparam *param = arg;
2903	struct bstp_state *bs = &sc->sc_stp;
2904
2905	if (!bridge_in_bsd_mode(sc)) {
2906	return (`0`);
2907	}
2908	param->ifbrp_prio = bs->bs_bridge_priority;
2909	return (`0`);
2910	}
2911
2912	static int
2913	bridge_ioctl_spri(struct bridge_softc sc, void* *arg)
2914	{
2915	#if BRIDGESTP
2916	struct ifbrparam *param = arg;
2917
2918	if (!bridge_in_bsd_mode(sc)) {
2919	return (EOPNOTSUPP);
2920	}
2921	return (bstp_set_priority(&sc->sc_stp, param->ifbrp_prio));
2922	#else /* !BRIDGESTP */
2923	#pragma unused(sc, arg)
2924	return (EOPNOTSUPP);
2925	#endif /* !BRIDGESTP */
2926	}
2927
2928	static int
2929	bridge_ioctl_ght(struct bridge_softc sc, void* *arg)
2930	{
2931	struct ifbrparam *param = arg;
2932	struct bstp_state *bs = &sc->sc_stp;
2933
2934	if (!bridge_in_bsd_mode(sc)) {
2935	return (`0`);
2936	}
2937	param->ifbrp_hellotime = bs->bs_bridge_htime >> `8`;
2938	return (`0`);
2939	}
2940
2941	static int
2942	bridge_ioctl_sht(struct bridge_softc sc, void* *arg)
2943	{
2944	#if BRIDGESTP
2945	struct ifbrparam *param = arg;
2946
2947	if (!bridge_in_bsd_mode(sc)) {
2948	return (EOPNOTSUPP);
2949	}
2950	return (bstp_set_htime(&sc->sc_stp, param->ifbrp_hellotime));
2951	#else /* !BRIDGESTP */
2952	#pragma unused(sc, arg)
2953	return (EOPNOTSUPP);
2954	#endif /* !BRIDGESTP */
2955	}
2956
2957	static int
2958	bridge_ioctl_gfd(struct bridge_softc sc, void* *arg)
2959	{
2960	struct ifbrparam *param;
2961	struct bstp_state *bs;
2962
2963	if (!bridge_in_bsd_mode(sc)) {
2964	return (`0`);
2965	}
2966	param = arg;
2967	bs = &sc->sc_stp;
2968	param->ifbrp_fwddelay = bs->bs_bridge_fdelay >> `8`;
2969	return (`0`);
2970	}
2971
2972	static int
2973	bridge_ioctl_sfd(struct bridge_softc sc, void* *arg)
2974	{
2975	#if BRIDGESTP
2976	struct ifbrparam *param = arg;
2977
2978	if (!bridge_in_bsd_mode(sc)) {
2979	return (EOPNOTSUPP);
2980	}
2981	return (bstp_set_fdelay(&sc->sc_stp, param->ifbrp_fwddelay));
2982	#else /* !BRIDGESTP */
2983	#pragma unused(sc, arg)
2984	return (EOPNOTSUPP);
2985	#endif /* !BRIDGESTP */
2986	}
2987
2988	static int
2989	bridge_ioctl_gma(struct bridge_softc sc, void* *arg)
2990	{
2991	struct ifbrparam *param;
2992	struct bstp_state *bs;
2993
2994	if (!bridge_in_bsd_mode(sc)) {
2995	return (EOPNOTSUPP);
2996	}
2997	param = arg;
2998	bs = &sc->sc_stp;
2999	param->ifbrp_maxage = bs->bs_bridge_max_age >> `8`;
3000	return (`0`);
3001	}
3002
3003	static int
3004	bridge_ioctl_sma(struct bridge_softc sc, void* *arg)
3005	{
3006	#if BRIDGESTP
3007	struct ifbrparam *param = arg;
3008
3009	if (!bridge_in_bsd_mode(sc)) {
3010	return (EOPNOTSUPP);
3011	}
3012	return (bstp_set_maxage(&sc->sc_stp, param->ifbrp_maxage));
3013	#else /* !BRIDGESTP */
3014	#pragma unused(sc, arg)
3015	return (EOPNOTSUPP);
3016	#endif /* !BRIDGESTP */
3017	}
3018
3019	static int
3020	bridge_ioctl_sifprio(struct bridge_softc sc, void* *arg)
3021	{
3022	#if BRIDGESTP
3023	struct ifbreq *req = arg;
3024	struct bridge_iflist *bif;
3025
3026	if (!bridge_in_bsd_mode(sc)) {
3027	return (EOPNOTSUPP);
3028	}
3029	bif = bridge_lookup_member(sc, req->ifbr_ifsname);
3030	if (bif == NULL)
3031	return (ENOENT);
3032
3033	return (bstp_set_port_priority(&bif->bif_stp, req->ifbr_priority));
3034	#else /* !BRIDGESTP */
3035	#pragma unused(sc, arg)
3036	return (EOPNOTSUPP);
3037	#endif /* !BRIDGESTP */
3038	}
3039
3040	static int
3041	bridge_ioctl_sifcost(struct bridge_softc sc, void* *arg)
3042	{
3043	#if BRIDGESTP
3044	struct ifbreq *req = arg;
3045	struct bridge_iflist *bif;
3046
3047	if (!bridge_in_bsd_mode(sc)) {
3048	return (EOPNOTSUPP);
3049	}
3050	bif = bridge_lookup_member(sc, req->ifbr_ifsname);
3051	if (bif == NULL)
3052	return (ENOENT);
3053
3054	return (bstp_set_path_cost(&bif->bif_stp, req->ifbr_path_cost));
3055	#else /* !BRIDGESTP */
3056	#pragma unused(sc, arg)
3057	return (EOPNOTSUPP);
3058	#endif /* !BRIDGESTP */
3059	}
3060
3061	static int
3062	bridge_ioctl_gfilt(struct bridge_softc sc, void* *arg)
3063	{
3064	struct ifbrparam *param = arg;
3065
3066	param->ifbrp_filter = sc->sc_filter_flags;
3067
3068	return (`0`);
3069	}
3070
3071	static int
3072	bridge_ioctl_sfilt(struct bridge_softc sc, void* *arg)
3073	{
3074	struct ifbrparam *param = arg;
3075
3076	if (param->ifbrp_filter & ~IFBF_FILT_MASK)
3077	return (EINVAL);
3078
3079	#ifndef BRIDGE_IPF
3080	if (param->ifbrp_filter & IFBF_FILT_USEIPF)
3081	return (EINVAL);
3082	#endif
3083
3084	sc->sc_filter_flags = param->ifbrp_filter;
3085
3086	return (`0`);
3087	}
3088
3089	static int
3090	bridge_ioctl_sifmaxaddr(struct bridge_softc sc, void* *arg)
3091	{
3092	struct ifbreq *req = arg;
3093	struct bridge_iflist *bif;
3094
3095	bif = bridge_lookup_member(sc, req->ifbr_ifsname);
3096	if (bif == NULL)
3097	return (ENOENT);
3098
3099	bif->bif_addrmax = req->ifbr_addrmax;
3100	return (`0`);
3101	}
3102
3103	static int
3104	bridge_ioctl_addspan(struct bridge_softc sc, void* *arg)
3105	{
3106	struct ifbreq *req = arg;
3107	struct bridge_iflist *bif = NULL;
3108	struct ifnet *ifs;
3109
3110	if (!bridge_in_bsd_mode(sc)) {
3111	return (EOPNOTSUPP);
3112	}
3113	ifs = ifunit(req->ifbr_ifsname);
3114	if (ifs == NULL)
3115	return (ENOENT);
3116
3117	if (IFNET_IS_INTCOPROC(ifs)) {
3118	return (EINVAL);
3119	}
3120
3121	TAILQ_FOREACH(bif, &sc->sc_spanlist, bif_next)
3122	if (ifs == bif->bif_ifp)
3123	return (EBUSY);
3124
3125	if (ifs->if_bridge != NULL)
3126	return (EBUSY);
3127
3128	switch (ifs->if_type) {
3129	case IFT_ETHER:
3130	case IFT_L2VLAN:
3131	break;
3132	case IFT_GIF:
3133	/ currently not supported /
3134	/ FALLTHRU /
3135	default:
3136	return (EINVAL);
3137	}
3138
3139	bif = _MALLOC(sizeof (*bif), M_DEVBUF, M_WAITOK \| M_ZERO);
3140	if (bif == NULL)
3141	return (ENOMEM);
3142
3143	bif->bif_ifp = ifs;
3144	bif->bif_ifflags = IFBIF_SPAN;
3145
3146	ifnet_reference(bif->bif_ifp);
3147
3148	TAILQ_INSERT_HEAD(&sc->sc_spanlist, bif, bif_next);
3149
3150	return (`0`);
3151	}
3152
3153	static int
3154	bridge_ioctl_delspan(struct bridge_softc sc, void* *arg)
3155	{
3156	struct ifbreq *req = arg;
3157	struct bridge_iflist *bif;
3158	struct ifnet *ifs;
3159
3160	if (!bridge_in_bsd_mode(sc)) {
3161	return (EOPNOTSUPP);
3162	}
3163	ifs = ifunit(req->ifbr_ifsname);
3164	if (ifs == NULL)
3165	return (ENOENT);
3166
3167	TAILQ_FOREACH(bif, &sc->sc_spanlist, bif_next)
3168	if (ifs == bif->bif_ifp)
3169	break;
3170
3171	if (bif == NULL)
3172	return (ENOENT);
3173
3174	bridge_delete_span(sc, bif);
3175
3176	return (`0`);
3177	}
3178
3179	#define BRIDGE_IOCTL_GBPARAM do { \
3180	struct bstp_state *bs = &sc->sc_stp; \
3181	struct bstp_port *root_port; \
3182	\
3183	req->ifbop_maxage = bs->bs_bridge_max_age >> 8; \
3184	req->ifbop_hellotime = bs->bs_bridge_htime >> 8; \
3185	req->ifbop_fwddelay = bs->bs_bridge_fdelay >> 8; \
3186	\
3187	root_port = bs->bs_root_port; \
3188	if (root_port == NULL) \
3189	req->ifbop_root_port = 0; \
3190	else \
3191	req->ifbop_root_port = root_port->bp_ifp->if_index; \
3192	\
3193	req->ifbop_holdcount = bs->bs_txholdcount; \
3194	req->ifbop_priority = bs->bs_bridge_priority; \
3195	req->ifbop_protocol = bs->bs_protover; \
3196	req->ifbop_root_path_cost = bs->bs_root_pv.pv_cost; \
3197	req->ifbop_bridgeid = bs->bs_bridge_pv.pv_dbridge_id; \
3198	req->ifbop_designated_root = bs->bs_root_pv.pv_root_id; \
3199	req->ifbop_designated_bridge = bs->bs_root_pv.pv_dbridge_id; \
3200	req->ifbop_last_tc_time.tv_sec = bs->bs_last_tc_time.tv_sec; \
3201	req->ifbop_last_tc_time.tv_usec = bs->bs_last_tc_time.tv_usec; \
3202	} while (0)
3203
3204	static int
3205	bridge_ioctl_gbparam32(struct bridge_softc sc, void* *arg)
3206	{
3207	struct ifbropreq32 *req = arg;
3208
3209	if (bridge_in_bsd_mode(sc)) {
3210	BRIDGE_IOCTL_GBPARAM;
3211	}
3212	return (`0`);
3213	}
3214
3215	static int
3216	bridge_ioctl_gbparam64(struct bridge_softc sc, void* *arg)
3217	{
3218	struct ifbropreq64 *req = arg;
3219
3220	if (bridge_in_bsd_mode(sc)) {
3221	BRIDGE_IOCTL_GBPARAM;
3222	}
3223	return (`0`);
3224	}
3225
3226	static int
3227	bridge_ioctl_grte(struct bridge_softc sc, void* *arg)
3228	{
3229	struct ifbrparam *param = arg;
3230
3231	param->ifbrp_cexceeded = sc->sc_brtexceeded;
3232	return (`0`);
3233	}
3234
3235	#define BRIDGE_IOCTL_GIFSSTP do { \
3236	struct bridge_iflist *bif; \
3237	struct bstp_port *bp; \
3238	struct ifbpstpreq bpreq; \
3239	char buf, outbuf; \
3240	unsigned int count, buflen, len; \
3241	\
3242	count = 0; \
3243	TAILQ_FOREACH(bif, &sc->sc_iflist, bif_next) { \
3244	if ((bif->bif_ifflags & IFBIF_STP) != 0) \
3245	count++; \
3246	} \
3247	\
3248	buflen = sizeof (bpreq) * count; \
3249	if (bifstp->ifbpstp_len == 0) { \
3250	bifstp->ifbpstp_len = buflen; \
3251	return (0); \
3252	} \
3253	\
3254	BRIDGE_UNLOCK(sc); \
3255	outbuf = _MALLOC(buflen, M_TEMP, M_WAITOK \| M_ZERO); \
3256	BRIDGE_LOCK(sc); \
3257	\
3258	count = 0; \
3259	buf = outbuf; \
3260	len = min(bifstp->ifbpstp_len, buflen); \
3261	bzero(&bpreq, sizeof (bpreq)); \
3262	TAILQ_FOREACH(bif, &sc->sc_iflist, bif_next) { \
3263	if (len < sizeof (bpreq)) \
3264	break; \
3265	\
3266	if ((bif->bif_ifflags & IFBIF_STP) == 0) \
3267	continue; \
3268	\
3269	bp = &bif->bif_stp; \
3270	bpreq.ifbp_portno = bif->bif_ifp->if_index & 0xfff; \
3271	bpreq.ifbp_fwd_trans = bp->bp_forward_transitions; \
3272	bpreq.ifbp_design_cost = bp->bp_desg_pv.pv_cost; \
3273	bpreq.ifbp_design_port = bp->bp_desg_pv.pv_port_id; \
3274	bpreq.ifbp_design_bridge = bp->bp_desg_pv.pv_dbridge_id; \
3275	bpreq.ifbp_design_root = bp->bp_desg_pv.pv_root_id; \
3276	\
3277	memcpy(buf, &bpreq, sizeof (bpreq)); \
3278	count++; \
3279	buf += sizeof (bpreq); \
3280	len -= sizeof (bpreq); \
3281	} \
3282	\
3283	BRIDGE_UNLOCK(sc); \
3284	bifstp->ifbpstp_len = sizeof (bpreq) * count; \
3285	error = copyout(outbuf, bifstp->ifbpstp_req, bifstp->ifbpstp_len); \
3286	BRIDGE_LOCK(sc); \
3287	_FREE(outbuf, M_TEMP); \
3288	return (error); \
3289	} while (0)
3290
3291	static int
3292	bridge_ioctl_gifsstp32(struct bridge_softc sc, void* *arg)
3293	{
3294	struct ifbpstpconf32 *bifstp = arg;
3295	int error = `0`;
3296
3297	if (bridge_in_bsd_mode(sc)) {
3298	BRIDGE_IOCTL_GIFSSTP;
3299	}
3300	return (error);
3301	}
3302
3303	static int
3304	bridge_ioctl_gifsstp64(struct bridge_softc sc, void* *arg)
3305	{
3306	struct ifbpstpconf64 *bifstp = arg;
3307	int error = `0`;
3308
3309	if (bridge_in_bsd_mode(sc)) {
3310	BRIDGE_IOCTL_GIFSSTP;
3311	}
3312	return (error);
3313	}
3314
3315	static int
3316	bridge_ioctl_sproto(struct bridge_softc sc, void* *arg)
3317	{
3318	#if BRIDGESTP
3319	struct ifbrparam *param = arg;
3320
3321	if (!bridge_in_bsd_mode(sc)) {
3322	return (EOPNOTSUPP);
3323	}
3324	return (bstp_set_protocol(&sc->sc_stp, param->ifbrp_proto));
3325	#else /* !BRIDGESTP */
3326	#pragma unused(sc, arg)
3327	return (EOPNOTSUPP);
3328	#endif /* !BRIDGESTP */
3329	}
3330
3331	static int
3332	bridge_ioctl_stxhc(struct bridge_softc sc, void* *arg)
3333	{
3334	#if BRIDGESTP
3335	struct ifbrparam *param = arg;
3336
3337	if (!bridge_in_bsd_mode(sc)) {
3338	return (EOPNOTSUPP);
3339	}
3340	return (bstp_set_holdcount(&sc->sc_stp, param->ifbrp_txhc));
3341	#else /* !BRIDGESTP */
3342	#pragma unused(sc, arg)
3343	return (EOPNOTSUPP);
3344	#endif /* !BRIDGESTP */
3345	}
3346
3347
3348	static int
3349	bridge_ioctl_ghostfilter(struct bridge_softc sc, void* *arg)
3350	{
3351	struct ifbrhostfilter *req = arg;
3352	struct bridge_iflist *bif;
3353
3354	bif = bridge_lookup_member(sc, req->ifbrhf_ifsname);
3355	if (bif == NULL)
3356	return (ENOENT);
3357
3358	bzero(req, sizeof(struct ifbrhostfilter));
3359	if (bif->bif_flags & BIFF_HOST_FILTER) {
3360	req->ifbrhf_flags \|= IFBRHF_ENABLED;
3361	bcopy(bif->bif_hf_hwsrc, req->ifbrhf_hwsrca,
3362	ETHER_ADDR_LEN);
3363	req->ifbrhf_ipsrc = bif->bif_hf_ipsrc.s_addr;
3364	}
3365	return (`0`);
3366	}
3367
3368	static int
3369	bridge_ioctl_shostfilter(struct bridge_softc sc, void* *arg)
3370	{
3371	struct ifbrhostfilter *req = arg;
3372	struct bridge_iflist *bif;
3373
3374	bif = bridge_lookup_member(sc, req->ifbrhf_ifsname);
3375	if (bif == NULL)
3376	return (ENOENT);
3377
3378	INC_ATOMIC_INT64_LIM(net_api_stats.nas_vmnet_total);
3379
3380	if (req->ifbrhf_flags & IFBRHF_ENABLED) {
3381	bif->bif_flags \|= BIFF_HOST_FILTER;
3382
3383	if (req->ifbrhf_flags & IFBRHF_HWSRC) {
3384	bcopy(req->ifbrhf_hwsrca, bif->bif_hf_hwsrc,
3385	ETHER_ADDR_LEN);
3386	if (bcmp(req->ifbrhf_hwsrca, ethernulladdr,
3387	ETHER_ADDR_LEN) != `0`)
3388	bif->bif_flags \|= BIFF_HF_HWSRC;
3389	else
3390	bif->bif_flags &= ~BIFF_HF_HWSRC;
3391	}
3392	if (req->ifbrhf_flags & IFBRHF_IPSRC) {
3393	bif->bif_hf_ipsrc.s_addr = req->ifbrhf_ipsrc;
3394	if (bif->bif_hf_ipsrc.s_addr != INADDR_ANY)
3395	bif->bif_flags \|= BIFF_HF_IPSRC;
3396	else
3397	bif->bif_flags &= ~BIFF_HF_IPSRC;
3398	}
3399	} else {
3400	bif->bif_flags &= ~(BIFF_HOST_FILTER \| BIFF_HF_HWSRC \|
3401	BIFF_HF_IPSRC);
3402	bzero(bif->bif_hf_hwsrc, ETHER_ADDR_LEN);
3403	bif->bif_hf_ipsrc.s_addr = INADDR_ANY;
3404	}
3405
3406	return (`0`);
3407	}
3408
3409
3410	/*
3411	* bridge_ifdetach:
3412	*
3413	* Detach an interface from a bridge. Called when a member
3414	* interface is detaching.
3415	*/
3416	__private_extern__ void
3417	bridge_ifdetach(struct bridge_iflist bif, struct* ifnet *ifp)
3418	{
3419	struct bridge_softc *sc = ifp->if_bridge;
3420
3421	#if BRIDGE_DEBUG
3422	if (if_bridge_debug & BR_DBGF_LIFECYCLE)
3423	printf("%s: %s\n", __func__, ifp->if_xname);
3424	#endif /* BRIDGE_DEBUG */
3425
3426	/ Check if the interface is a bridge member /
3427	if (sc != NULL) {
3428	BRIDGE_LOCK(sc);
3429	bif = bridge_lookup_member_if(sc, ifp);
3430	if (bif != NULL)
3431	bridge_delete_member(sc, bif, `1`);
3432	BRIDGE_UNLOCK(sc);
3433	return;
3434	}
3435	/ Check if the interface is a span port /
3436	lck_mtx_lock(&bridge_list_mtx);
3437	LIST_FOREACH(sc, &bridge_list, sc_list) {
3438	if (bridge_in_bsd_mode(sc)) {
3439	BRIDGE_LOCK(sc);
3440	TAILQ_FOREACH(bif, &sc->sc_spanlist, bif_next)
3441	if (ifp == bif->bif_ifp) {
3442	bridge_delete_span(sc, bif);
3443	break;
3444	}
3445	BRIDGE_UNLOCK(sc);
3446	}
3447	}
3448	lck_mtx_unlock(&bridge_list_mtx);
3449	}
3450
3451	/*
3452	* interface_media_active:
3453	*
3454	* Tells if an interface media is active.
3455	*/
3456	static int
3457	interface_media_active(struct ifnet *ifp)
3458	{
3459	struct ifmediareq ifmr;
3460	int status = `0`;
3461
3462	bzero(&ifmr, sizeof(ifmr));
3463	if (ifnet_ioctl(ifp, `0`, SIOCGIFMEDIA, &ifmr) == `0`) {
3464	if ((ifmr.ifm_status & IFM_AVALID) && ifmr.ifm_count > `0`)
3465	status = ifmr.ifm_status & IFM_ACTIVE ? `1` : `0`;
3466	}
3467
3468	return (status);
3469	}
3470
3471	/*
3472	* bridge_updatelinkstatus:
3473	*
3474	* Update the media active status of the bridge based on the
3475	* media active status of its member.
3476	* If changed, return the corresponding onf/off link event.
3477	*/
3478	static u_int32_t
3479	bridge_updatelinkstatus(struct bridge_softc *sc)
3480	{
3481	struct bridge_iflist *bif;
3482	int active_member = `0`;
3483	u_int32_t event_code = `0`;
3484
3485	BRIDGE_LOCK_ASSERT_HELD(sc);
3486
3487	/*
3488	* Find out if we have an active interface
3489	*/
3490	TAILQ_FOREACH(bif, &sc->sc_iflist, bif_next) {
3491	if (bif->bif_flags & BIFF_MEDIA_ACTIVE) {
3492	active_member = `1`;
3493	break;
3494	}
3495	}
3496
3497	if (active_member && !(sc->sc_flags & SCF_MEDIA_ACTIVE)) {
3498	sc->sc_flags \|= SCF_MEDIA_ACTIVE;
3499	event_code = KEV_DL_LINK_ON;
3500	} else if (!active_member && (sc->sc_flags & SCF_MEDIA_ACTIVE)) {
3501	sc->sc_flags &= ~SCF_MEDIA_ACTIVE;
3502	event_code = KEV_DL_LINK_OFF;
3503	}
3504
3505	return (event_code);
3506	}
3507
3508	/*
3509	* bridge_iflinkevent:
3510	*/
3511	static void
3512	bridge_iflinkevent(struct ifnet *ifp)
3513	{
3514	struct bridge_softc *sc = ifp->if_bridge;
3515	struct bridge_iflist *bif;
3516	u_int32_t event_code = `0`;
3517
3518	#if BRIDGE_DEBUG
3519	if (if_bridge_debug & BR_DBGF_LIFECYCLE)
3520	printf("%s: %s\n", __func__, ifp->if_xname);
3521	#endif /* BRIDGE_DEBUG */
3522
3523	/ Check if the interface is a bridge member /
3524	if (sc == NULL)
3525	return;
3526
3527	BRIDGE_LOCK(sc);
3528	bif = bridge_lookup_member_if(sc, ifp);
3529	if (bif != NULL) {
3530	if (interface_media_active(ifp))
3531	bif->bif_flags \|= BIFF_MEDIA_ACTIVE;
3532	else
3533	bif->bif_flags &= ~BIFF_MEDIA_ACTIVE;
3534
3535	event_code = bridge_updatelinkstatus(sc);
3536	}
3537	BRIDGE_UNLOCK(sc);
3538
3539	if (event_code != `0`)
3540	bridge_link_event(sc->sc_ifp, event_code);
3541	}
3542
3543	/*
3544	* bridge_delayed_callback:
3545	*
3546	* Makes a delayed call
3547	*/
3548	static void
3549	bridge_delayed_callback(void *param)
3550	{
3551	struct bridge_delayed_call call = (struct* bridge_delayed_call *)param;
3552	struct bridge_softc *sc = call->bdc_sc;
3553
3554	#if BRIDGE_DEBUG_DELAYED_CALLBACK
3555	if (bridge_delayed_callback_delay > `0`) {
3556	struct timespec ts;
3557
3558	ts.tv_sec = bridge_delayed_callback_delay;
3559	ts.tv_nsec = `0`;
3560
3561	printf("%s: sleeping for %d seconds\n",
3562	__func__, bridge_delayed_callback_delay);
3563
3564	msleep(&bridge_delayed_callback_delay, NULL, PZERO,
3565	__func__, &ts);
3566
3567	printf("%s: awoken\n", __func__);
3568	}
3569	#endif /* BRIDGE_DEBUG_DELAYED_CALLBACK */
3570
3571	BRIDGE_LOCK(sc);
3572
3573	#if BRIDGE_DEBUG_DELAYED_CALLBACK
3574	if (if_bridge_debug & BR_DBGF_DELAYED_CALL)
3575	printf("%s: %s call 0x%llx flags 0x%x\n", __func__,
3576	sc->sc_if_xname, (uint64_t)VM_KERNEL_ADDRPERM(call),
3577	call->bdc_flags);
3578	#endif /* BRIDGE_DEBUG_DELAYED_CALLBACK */
3579
3580	if (call->bdc_flags & BDCF_CANCELLING) {
3581	wakeup(call);
3582	} else {
3583	if ((sc->sc_flags & SCF_DETACHING) == `0`)
3584	(*call->bdc_func)(sc);
3585	}
3586	call->bdc_flags &= ~BDCF_OUTSTANDING;
3587	BRIDGE_UNLOCK(sc);
3588	}
3589
3590	/*
3591	* bridge_schedule_delayed_call:
3592	*
3593	* Schedule a function to be called on a separate thread
3594	* The actual call may be scheduled to run at a given time or ASAP.
3595	*/
3596	static void
3597	bridge_schedule_delayed_call(struct bridge_delayed_call *call)
3598	{
3599	uint64_t deadline = `0`;
3600	struct bridge_softc *sc = call->bdc_sc;
3601
3602	BRIDGE_LOCK_ASSERT_HELD(sc);
3603
3604	if ((sc->sc_flags & SCF_DETACHING) \|\|
3605	(call->bdc_flags & (BDCF_OUTSTANDING \| BDCF_CANCELLING)))
3606	return;
3607
3608	if (call->bdc_ts.tv_sec \|\| call->bdc_ts.tv_nsec) {
3609	nanoseconds_to_absolutetime(
3610	(uint64_t)call->bdc_ts.tv_sec * NSEC_PER_SEC +
3611	call->bdc_ts.tv_nsec, &deadline);
3612	clock_absolutetime_interval_to_deadline(deadline, &deadline);
3613	}
3614
3615	call->bdc_flags = BDCF_OUTSTANDING;
3616
3617	#if BRIDGE_DEBUG_DELAYED_CALLBACK
3618	if (if_bridge_debug & BR_DBGF_DELAYED_CALL)
3619	printf("%s: %s call 0x%llx flags 0x%x\n", __func__,
3620	sc->sc_if_xname, (uint64_t)VM_KERNEL_ADDRPERM(call),
3621	call->bdc_flags);
3622	#endif /* BRIDGE_DEBUG_DELAYED_CALLBACK */
3623
3624	if (call->bdc_ts.tv_sec \|\| call->bdc_ts.tv_nsec)
3625	thread_call_func_delayed(
3626	(thread_call_func_t)bridge_delayed_callback,
3627	call, deadline);
3628	else {
3629	if (call->bdc_thread_call == NULL)
3630	call->bdc_thread_call = thread_call_allocate(
3631	(thread_call_func_t)bridge_delayed_callback,
3632	call);
3633	thread_call_enter(call->bdc_thread_call);
3634	}
3635	}
3636
3637	/*
3638	* bridge_cancel_delayed_call:
3639	*
3640	* Cancel a queued or running delayed call.
3641	* If call is running, does not return until the call is done to
3642	* prevent race condition with the brigde interface getting destroyed
3643	*/
3644	static void
3645	bridge_cancel_delayed_call(struct bridge_delayed_call *call)
3646	{
3647	boolean_t result;
3648	struct bridge_softc *sc = call->bdc_sc;
3649
3650	/*
3651	* The call was never scheduled
3652	*/
3653	if (sc == NULL)
3654	return;
3655
3656	BRIDGE_LOCK_ASSERT_HELD(sc);
3657
3658	call->bdc_flags \|= BDCF_CANCELLING;
3659
3660	while (call->bdc_flags & BDCF_OUTSTANDING) {
3661	#if BRIDGE_DEBUG
3662	if (if_bridge_debug & BR_DBGF_DELAYED_CALL)
3663	printf("%s: %s call 0x%llx flags 0x%x\n", __func__,
3664	sc->sc_if_xname, (uint64_t)VM_KERNEL_ADDRPERM(call),
3665	call->bdc_flags);
3666	#endif /* BRIDGE_DEBUG */
3667	result = thread_call_func_cancel(
3668	(thread_call_func_t)bridge_delayed_callback, call, FALSE);
3669
3670	if (result) {
3671	/*
3672	* We managed to dequeue the delayed call
3673	*/
3674	call->bdc_flags &= ~BDCF_OUTSTANDING;
3675	} else {
3676	/*
3677	* Wait for delayed call do be done running
3678	*/
3679	msleep(call, &sc->sc_mtx, PZERO, __func__, NULL);
3680	}
3681	}
3682	call->bdc_flags &= ~BDCF_CANCELLING;
3683	}
3684
3685	/*
3686	* bridge_cleanup_delayed_call:
3687	*
3688	* Dispose resource allocated for a delayed call
3689	* Assume the delayed call is not queued or running .
3690	*/
3691	static void
3692	bridge_cleanup_delayed_call(struct bridge_delayed_call *call)
3693	{
3694	boolean_t result;
3695	struct bridge_softc *sc = call->bdc_sc;
3696
3697	/*
3698	* The call was never scheduled
3699	*/
3700	if (sc == NULL)
3701	return;
3702
3703	BRIDGE_LOCK_ASSERT_HELD(sc);
3704
3705	VERIFY((call->bdc_flags & BDCF_OUTSTANDING) == `0`);
3706	VERIFY((call->bdc_flags & BDCF_CANCELLING) == `0`);
3707
3708	if (call->bdc_thread_call != NULL) {
3709	result = thread_call_free(call->bdc_thread_call);
3710	if (result == FALSE)
3711	panic("%s thread_call_free() failed for call %p",
3712	__func__, call);
3713	call->bdc_thread_call = NULL;
3714	}
3715	}
3716
3717	/*
3718	* bridge_init:
3719	*
3720	* Initialize a bridge interface.
3721	*/
3722	static int
3723	bridge_init(struct ifnet *ifp)
3724	{
3725	struct bridge_softc sc = (struct* bridge_softc *)ifp->if_softc;
3726	errno_t error;
3727
3728	BRIDGE_LOCK_ASSERT_HELD(sc);
3729
3730	if ((ifnet_flags(ifp) & IFF_RUNNING))
3731	return (`0`);
3732
3733	error = ifnet_set_flags(ifp, IFF_RUNNING, IFF_RUNNING);
3734
3735	if (bridge_in_bsd_mode(sc)) {
3736	/*
3737	* Calling bridge_aging_timer() is OK as there are no entries to
3738	* age so we're just going to arm the timer
3739	*/
3740	bridge_aging_timer(sc);
3741	#if BRIDGESTP
3742	if (error == `0`)
3743	bstp_init(&sc->sc_stp); / Initialize Spanning Tree /
3744	#endif /* BRIDGESTP */
3745	}
3746	return (error);
3747	}
3748
3749	/*
3750	* bridge_ifstop:
3751	*
3752	* Stop the bridge interface.
3753	*/
3754	static void
3755	bridge_ifstop(struct ifnet ifp, int* disable)
3756	{
3757	#pragma unused(disable)
3758	struct bridge_softc *sc = ifp->if_softc;
3759
3760	BRIDGE_LOCK_ASSERT_HELD(sc);
3761
3762	if ((ifnet_flags(ifp) & IFF_RUNNING) == `0`)
3763	return;
3764
3765	if (bridge_in_bsd_mode(sc)) {
3766	bridge_cancel_delayed_call(&sc->sc_aging_timer);
3767
3768	#if BRIDGESTP
3769	bstp_stop(&sc->sc_stp);
3770	#endif /* BRIDGESTP */
3771
3772	bridge_rtflush(sc, IFBF_FLUSHDYN);
3773	}
3774	(void) ifnet_set_flags(ifp, `0`, IFF_RUNNING);
3775	}
3776
3777	/*
3778	* bridge_enqueue:
3779	*
3780	* Enqueue a packet on a bridge member interface.
3781	*
3782	*/
3783	static int
3784	bridge_enqueue(struct bridge_softc sc, struct* ifnet dst_ifp, struct* mbuf *m)
3785	{
3786	int len, error = `0`;
3787	short mflags;
3788	struct mbuf *m0;
3789
3790	VERIFY(dst_ifp != NULL);
3791
3792	/*
3793	* We may be sending a fragment so traverse the mbuf
3794	*
3795	* NOTE: bridge_fragment() is called only when PFIL_HOOKS is enabled.
3796	*/
3797	for (; m; m = m0) {
3798	errno_t _error;
3799	struct flowadv adv = { FADV_SUCCESS };
3800
3801	m0 = m->m_nextpkt;
3802	m->m_nextpkt = NULL;
3803
3804	len = m->m_pkthdr.len;
3805	mflags = m->m_flags;
3806	m->m_flags \|= M_PROTO1; / set to avoid loops /
3807
3808	bridge_finalize_cksum(dst_ifp, m);
3809
3810	#if HAS_IF_CAP
3811	/*
3812	* If underlying interface can not do VLAN tag insertion itself
3813	* then attach a packet tag that holds it.
3814	*/
3815	if ((m->m_flags & M_VLANTAG) &&
3816	(dst_ifp->if_capenable & IFCAP_VLAN_HWTAGGING) == `0`) {
3817	m = ether_vlanencap(m, m->m_pkthdr.ether_vtag);
3818	if (m == NULL) {
3819	printf("%s: %s: unable to prepend VLAN "
3820	"header\n", __func__, dst_ifp->if_xname);
3821	(void) ifnet_stat_increment_out(dst_ifp,
3822	`0`, `0`, `1`);
3823	continue;
3824	}
3825	m->m_flags &= ~M_VLANTAG;
3826	}
3827	#endif /* HAS_IF_CAP */
3828
3829	_error = dlil_output(dst_ifp, `0`, m, NULL, NULL, `1`, &adv);
3830
3831	/ Preserve existing error value /
3832	if (error == `0`) {
3833	if (_error != `0`)
3834	error = _error;
3835	else if (adv.code == FADV_FLOW_CONTROLLED)
3836	error = EQFULL;
3837	else if (adv.code == FADV_SUSPENDED)
3838	error = EQSUSPENDED;
3839	}
3840
3841	if (_error == `0`) {
3842	(void) ifnet_stat_increment_out(sc->sc_ifp, `1`, len, `0`);
3843	} else {
3844	(void) ifnet_stat_increment_out(sc->sc_ifp, `0`, `0`, `1`);
3845	}
3846	}
3847
3848	return (error);
3849	}
3850
3851	#if HAS_BRIDGE_DUMMYNET
3852	/*
3853	* bridge_dummynet:
3854	*
3855	* Receive a queued packet from dummynet and pass it on to the output
3856	* interface.
3857	*
3858	* The mbuf has the Ethernet header already attached.
3859	*/
3860	static void
3861	bridge_dummynet(struct mbuf m, struct* ifnet *ifp)
3862	{
3863	struct bridge_softc *sc;
3864
3865	sc = ifp->if_bridge;
3866
3867	/*
3868	* The packet didnt originate from a member interface. This should only
3869	* ever happen if a member interface is removed while packets are
3870	* queued for it.
3871	*/
3872	if (sc == NULL) {
3873	m_freem(m);
3874	return;
3875	}
3876
3877	if (PFIL_HOOKED(&inet_pfil_hook) \|\| PFIL_HOOKED_INET6) {
3878	if (bridge_pfil(&m, sc->sc_ifp, ifp, PFIL_OUT) != `0`)
3879	return;
3880	if (m == NULL)
3881	return;
3882	}
3883
3884	(void) bridge_enqueue(sc, ifp, m);
3885	}
3886	#endif /* HAS_BRIDGE_DUMMYNET */
3887
3888	#if BRIDGE_MEMBER_OUT_FILTER
3889	/*
3890	* bridge_member_output:
3891	*
3892	* Send output from a bridge member interface. This
3893	* performs the bridging function for locally originated
3894	* packets.
3895	*
3896	* The mbuf has the Ethernet header already attached. We must
3897	* enqueue or free the mbuf before returning.
3898	*/
3899	static int
3900	bridge_member_output(struct ifnet ifp, struct* mbuf m, struct* sockaddr *sa,
3901	struct rtentry *rt)
3902	{
3903	#pragma unused(sa, rt)
3904	struct ether_header *eh;
3905	struct ifnet *dst_if;
3906	struct bridge_softc *sc;
3907	uint16_t vlan;
3908
3909	#if BRIDGE_DEBUG
3910	if (if_bridge_debug & BR_DBGF_OUTPUT)
3911	printf("%s: ifp %s\n", __func__, ifp->if_xname);
3912	#endif /* BRIDGE_DEBUG */
3913
3914	if (m->m_len < ETHER_HDR_LEN) {
3915	m = m_pullup(m, ETHER_HDR_LEN);
3916	if (m == NULL)
3917	return (`0`);
3918	}
3919
3920	eh = mtod(m, struct ether_header *);
3921	sc = ifp->if_bridge;
3922	vlan = VLANTAGOF(m);
3923
3924	BRIDGE_LOCK(sc);
3925
3926	/*
3927	* APPLE MODIFICATION
3928	* If the packet is an 802.1X ethertype, then only send on the
3929	* original output interface.
3930	*/
3931	if (eh->ether_type == htons(ETHERTYPE_PAE)) {
3932	dst_if = ifp;
3933	goto sendunicast;
3934	}
3935
3936	/*
3937	* If bridge is down, but the original output interface is up,
3938	* go ahead and send out that interface. Otherwise, the packet
3939	* is dropped below.
3940	*/
3941	if ((sc->sc_ifp->if_flags & IFF_RUNNING) == `0`) {
3942	dst_if = ifp;
3943	goto sendunicast;
3944	}
3945
3946	/*
3947	* If the packet is a multicast, or we don't know a better way to
3948	* get there, send to all interfaces.
3949	*/
3950	if (ETHER_IS_MULTICAST(eh->ether_dhost))
3951	dst_if = NULL;
3952	else
3953	dst_if = bridge_rtlookup(sc, eh->ether_dhost, vlan);
3954	if (dst_if == NULL) {
3955	struct bridge_iflist *bif;
3956	struct mbuf *mc;
3957	int error = `0`, used = `0`;
3958
3959	bridge_span(sc, m);
3960
3961	BRIDGE_LOCK2REF(sc, error);
3962	if (error) {
3963	m_freem(m);
3964	return (`0`);
3965	}
3966
3967	TAILQ_FOREACH(bif, &sc->sc_iflist, bif_next) {
3968	dst_if = bif->bif_ifp;
3969
3970	if (dst_if->if_type == IFT_GIF)
3971	continue;
3972	if ((dst_if->if_flags & IFF_RUNNING) == `0`)
3973	continue;
3974
3975	/*
3976	* If this is not the original output interface,
3977	* and the interface is participating in spanning
3978	* tree, make sure the port is in a state that
3979	* allows forwarding.
3980	*/
3981	if (dst_if != ifp && (bif->bif_ifflags & IFBIF_STP) &&
3982	bif->bif_stp.bp_state == BSTP_IFSTATE_DISCARDING)
3983	continue;
3984
3985	if (LIST_NEXT(bif, bif_next) == NULL) {
3986	used = `1`;
3987	mc = m;
3988	} else {
3989	mc = m_copypacket(m, M_DONTWAIT);
3990	if (mc == NULL) {
3991	(void) ifnet_stat_increment_out(
3992	sc->sc_ifp, `0`, `0`, `1`);
3993	continue;
3994	}
3995	}
3996
3997	(void) bridge_enqueue(sc, dst_if, mc);
3998	}
3999	if (used == `0`)
4000	m_freem(m);
4001	BRIDGE_UNREF(sc);
4002	return (`0`);
4003	}
4004
4005	sendunicast:
4006	/*
4007	* XXX Spanning tree consideration here?
4008	*/
4009
4010	bridge_span(sc, m);
4011	if ((dst_if->if_flags & IFF_RUNNING) == `0`) {
4012	m_freem(m);
4013	BRIDGE_UNLOCK(sc);
4014	return (`0`);
4015	}
4016
4017	BRIDGE_UNLOCK(sc);
4018	(void) bridge_enqueue(sc, dst_if, m);
4019	return (`0`);
4020	}
4021	#endif /* BRIDGE_MEMBER_OUT_FILTER */
4022
4023	/*
4024	* Output callback.
4025	*
4026	* This routine is called externally from above only when if_bridge_txstart
4027	* is disabled; otherwise it is called internally by bridge_start().
4028	*/
4029	static int
4030	bridge_output(struct ifnet ifp, struct* mbuf *m)
4031	{
4032	struct bridge_softc *sc = ifnet_softc(ifp);
4033	struct ether_header *eh;
4034	struct ifnet *dst_if;
4035	int error = `0`;
4036
4037	eh = mtod(m, struct ether_header *);
4038	dst_if = NULL;
4039
4040	BRIDGE_LOCK(sc);
4041	ASSERT(bridge_in_bsd_mode(sc));
4042
4043	if (!(m->m_flags & (M_BCAST\|M_MCAST)))
4044	dst_if = bridge_rtlookup(sc, eh->ether_dhost, `0`);
4045
4046	(void) ifnet_stat_increment_out(ifp, `1`, m->m_pkthdr.len, `0`);
4047
4048	#if NBPFILTER > 0
4049	if (sc->sc_bpf_output)
4050	bridge_bpf_output(ifp, m);
4051	#endif
4052
4053	if (dst_if == NULL) {
4054	/ callee will unlock /
4055	bridge_broadcast(sc, ifp, m, `0`);
4056	} else {
4057	BRIDGE_UNLOCK(sc);
4058	error = bridge_enqueue(sc, dst_if, m);
4059	}
4060
4061	return (error);
4062	}
4063
4064	static void
4065	bridge_finalize_cksum(struct ifnet ifp, struct* mbuf *m)
4066	{
4067	struct ether_header eh = mtod(m, struct* ether_header *);
4068	uint32_t sw_csum, hwcap;
4069
4070	if (ifp != NULL)
4071	hwcap = (ifp->if_hwassist \| CSUM_DATA_VALID);
4072	else
4073	hwcap = `0`;
4074
4075	/ do in software what the hardware cannot /
4076	sw_csum = m->m_pkthdr.csum_flags & ~IF_HWASSIST_CSUM_FLAGS(hwcap);
4077	sw_csum &= IF_HWASSIST_CSUM_MASK;
4078
4079	switch (ntohs(eh->ether_type)) {
4080	case ETHERTYPE_IP:
4081	if ((hwcap & CSUM_PARTIAL) && !(sw_csum & CSUM_DELAY_DATA) &&
4082	(m->m_pkthdr.csum_flags & CSUM_DELAY_DATA)) {
4083	if (m->m_pkthdr.csum_flags & CSUM_TCP) {
4084	uint16_t start =
4085	sizeof (eh) + sizeof* (struct ip);
4086	uint16_t ulpoff =
4087	m->m_pkthdr.csum_data & `0xffff`;
4088	m->m_pkthdr.csum_flags \|=
4089	(CSUM_DATA_VALID \| CSUM_PARTIAL);
4090	m->m_pkthdr.csum_tx_stuff = (ulpoff + start);
4091	m->m_pkthdr.csum_tx_start = start;
4092	} else {
4093	sw_csum \|= (CSUM_DELAY_DATA &
4094	m->m_pkthdr.csum_flags);
4095	}
4096	}
4097	(void) in_finalize_cksum(m, sizeof (*eh), sw_csum);
4098	break;
4099
4100	#if INET6
4101	case ETHERTYPE_IPV6:
4102	if ((hwcap & CSUM_PARTIAL) &&
4103	!(sw_csum & CSUM_DELAY_IPV6_DATA) &&
4104	(m->m_pkthdr.csum_flags & CSUM_DELAY_IPV6_DATA)) {
4105	if (m->m_pkthdr.csum_flags & CSUM_TCPIPV6) {
4106	uint16_t start =
4107	sizeof (eh) + sizeof* (struct ip6_hdr);
4108	uint16_t ulpoff =
4109	m->m_pkthdr.csum_data & `0xffff`;
4110	m->m_pkthdr.csum_flags \|=
4111	(CSUM_DATA_VALID \| CSUM_PARTIAL);
4112	m->m_pkthdr.csum_tx_stuff = (ulpoff + start);
4113	m->m_pkthdr.csum_tx_start = start;
4114	} else {
4115	sw_csum \|= (CSUM_DELAY_IPV6_DATA &
4116	m->m_pkthdr.csum_flags);
4117	}
4118	}
4119	(void) in6_finalize_cksum(m, sizeof (*eh), -`1`, -`1`, sw_csum);
4120	break;
4121	#endif /* INET6 */
4122	}
4123	}
4124
4125	/*
4126	* bridge_start:
4127	*
4128	* Start output on a bridge.
4129	*
4130	* This routine is invoked by the start worker thread; because we never call
4131	* it directly, there is no need do deploy any serialization mechanism other
4132	* than what's already used by the worker thread, i.e. this is already single
4133	* threaded.
4134	*
4135	* This routine is called only when if_bridge_txstart is enabled.
4136	*/
4137	static void
4138	bridge_start(struct ifnet *ifp)
4139	{
4140	struct mbuf *m;
4141
4142	for (;;) {
4143	if (ifnet_dequeue(ifp, &m) != `0`)
4144	break;
4145
4146	(void) bridge_output(ifp, m);
4147	}
4148	}
4149
4150	/*
4151	* bridge_forward:
4152	*
4153	* The forwarding function of the bridge.
4154	*
4155	* NOTE: Releases the lock on return.
4156	*/
4157	static void
4158	bridge_forward(struct bridge_softc sc, struct* bridge_iflist *sbif,
4159	struct mbuf *m)
4160	{
4161	struct bridge_iflist *dbif;
4162	struct ifnet src_if, dst_if, *ifp;
4163	struct ether_header *eh;
4164	uint16_t vlan;
4165	uint8_t *dst;
4166	int error;
4167
4168	BRIDGE_LOCK_ASSERT_HELD(sc);
4169	ASSERT(bridge_in_bsd_mode(sc));
4170
4171	#if BRIDGE_DEBUG
4172	if (if_bridge_debug & BR_DBGF_OUTPUT)
4173	printf("%s: %s m 0x%llx\n", __func__, sc->sc_ifp->if_xname,
4174	(uint64_t)VM_KERNEL_ADDRPERM(m));
4175	#endif /* BRIDGE_DEBUG */
4176
4177	src_if = m->m_pkthdr.rcvif;
4178	ifp = sc->sc_ifp;
4179
4180	(void) ifnet_stat_increment_in(ifp, `1`, m->m_pkthdr.len, `0`);
4181	vlan = VLANTAGOF(m);
4182
4183
4184	if ((sbif->bif_ifflags & IFBIF_STP) &&
4185	sbif->bif_stp.bp_state == BSTP_IFSTATE_DISCARDING)
4186	goto drop;
4187
4188	eh = mtod(m, struct ether_header *);
4189	dst = eh->ether_dhost;
4190
4191	/ If the interface is learning, record the address. /
4192	if (sbif->bif_ifflags & IFBIF_LEARNING) {
4193	error = bridge_rtupdate(sc, eh->ether_shost, vlan,
4194	sbif, `0`, IFBAF_DYNAMIC);
4195	/*
4196	* If the interface has addresses limits then deny any source
4197	* that is not in the cache.
4198	*/
4199	if (error && sbif->bif_addrmax)
4200	goto drop;
4201	}
4202
4203	if ((sbif->bif_ifflags & IFBIF_STP) != `0` &&
4204	sbif->bif_stp.bp_state == BSTP_IFSTATE_LEARNING)
4205	goto drop;
4206
4207	/*
4208	* At this point, the port either doesn't participate
4209	* in spanning tree or it is in the forwarding state.
4210	*/
4211
4212	/*
4213	* If the packet is unicast, destined for someone on
4214	* "this" side of the bridge, drop it.
4215	*/
4216	if ((m->m_flags & (M_BCAST\|M_MCAST)) == `0`) {
4217	dst_if = bridge_rtlookup(sc, dst, vlan);
4218	if (src_if == dst_if)
4219	goto drop;
4220	} else {
4221	/*
4222	* Check if its a reserved multicast address, any address
4223	* listed in 802.1D section 7.12.6 may not be forwarded by the
4224	* bridge.
4225	* This is currently 01-80-C2-00-00-00 to 01-80-C2-00-00-0F
4226	*/
4227	if (dst[`0`] == `0x01` && dst[`1`] == `0x80` &&
4228	dst[`2`] == `0xc2` && dst[`3`] == `0x00` &&
4229	dst[`4`] == `0x00` && dst[`5`] <= `0x0f`)
4230	goto drop;
4231
4232
4233	/ ...forward it to all interfaces. /
4234	atomic_add_64(&ifp->if_imcasts, `1`);
4235	dst_if = NULL;
4236	}
4237
4238	/*
4239	* If we have a destination interface which is a member of our bridge,
4240	* OR this is a unicast packet, push it through the bpf(4) machinery.
4241	* For broadcast or multicast packets, don't bother because it will
4242	* be reinjected into ether_input. We do this before we pass the packets
4243	* through the pfil(9) framework, as it is possible that pfil(9) will
4244	* drop the packet, or possibly modify it, making it difficult to debug
4245	* firewall issues on the bridge.
4246	*/
4247	#if NBPFILTER > 0
4248	if (eh->ether_type == htons(ETHERTYPE_RSN_PREAUTH) \|\|
4249	dst_if != NULL \|\| (m->m_flags & (M_BCAST \| M_MCAST)) == `0`) {
4250	m->m_pkthdr.rcvif = ifp;
4251	if (sc->sc_bpf_input)
4252	bridge_bpf_input(ifp, m);
4253	}
4254	#endif /* NBPFILTER */
4255
4256	#if defined(PFIL_HOOKS)
4257	/ run the packet filter /
4258	if (PFIL_HOOKED(&inet_pfil_hook) \|\| PFIL_HOOKED_INET6) {
4259	BRIDGE_UNLOCK(sc);
4260	if (bridge_pfil(&m, ifp, src_if, PFIL_IN) != `0`)
4261	return;
4262	if (m == NULL)
4263	return;
4264	BRIDGE_LOCK(sc);
4265	}
4266	#endif /* PFIL_HOOKS */
4267
4268	if (dst_if == NULL) {
4269	bridge_broadcast(sc, src_if, m, `1`);
4270	return;
4271	}
4272
4273	/*
4274	* At this point, we're dealing with a unicast frame
4275	* going to a different interface.
4276	*/
4277	if ((dst_if->if_flags & IFF_RUNNING) == `0`)
4278	goto drop;
4279
4280	dbif = bridge_lookup_member_if(sc, dst_if);
4281	if (dbif == NULL)
4282	/ Not a member of the bridge (anymore?) /
4283	goto drop;
4284
4285	/ Private segments can not talk to each other /
4286	if (sbif->bif_ifflags & dbif->bif_ifflags & IFBIF_PRIVATE)
4287	goto drop;
4288
4289	if ((dbif->bif_ifflags & IFBIF_STP) &&
4290	dbif->bif_stp.bp_state == BSTP_IFSTATE_DISCARDING)
4291	goto drop;
4292
4293	#if HAS_DHCPRA_MASK
4294	/ APPLE MODIFICATION <rdar:6985737> /
4295	if ((dst_if->if_extflags & IFEXTF_DHCPRA_MASK) != `0`) {
4296	m = ip_xdhcpra_output(dst_if, m);
4297	if (!m) {
4298	++sc->sc_sc.sc_ifp.if_xdhcpra;
4299	return;
4300	}
4301	}
4302	#endif /* HAS_DHCPRA_MASK */
4303
4304	BRIDGE_UNLOCK(sc);
4305
4306	#if defined(PFIL_HOOKS)
4307	if (PFIL_HOOKED(&inet_pfil_hook) \|\| PFIL_HOOKED_INET6) {
4308	if (bridge_pfil(&m, ifp, dst_if, PFIL_OUT) != `0`)
4309	return;
4310	if (m == NULL)
4311	return;
4312	}
4313	#endif /* PFIL_HOOKS */
4314
4315	(void) bridge_enqueue(sc, dst_if, m);
4316	return;
4317
4318	drop:
4319	BRIDGE_UNLOCK(sc);
4320	m_freem(m);
4321	}
4322
4323	#if BRIDGE_DEBUG
4324
4325	char ether_ntop(char* , size_t, const* u_char *);
4326
4327	__private_extern__ char *
4328	ether_ntop(char buf, size_t len, const* u_char *ap)
4329	{
4330	snprintf(buf, len, "%02x:%02x:%02x:%02x:%02x:%02x",
4331	ap[`0`], ap[`1`], ap[`2`], ap[`3`], ap[`4`], ap[`5`]);
4332
4333	return (buf);
4334	}
4335
4336	#endif /* BRIDGE_DEBUG */
4337
4338	/*
4339	* bridge_input:
4340	*
4341	* Filter input from a member interface. Queue the packet for
4342	* bridging if it is not for us.
4343	*/
4344	__private_extern__ errno_t
4345	bridge_input(struct ifnet ifp, struct* mbuf m, void* *frame_header)
4346	{
4347	struct bridge_softc *sc = ifp->if_bridge;
4348	struct bridge_iflist bif, bif2;
4349	struct ifnet *bifp;
4350	struct ether_header *eh;
4351	struct mbuf mc, mc2;
4352	uint16_t vlan;
4353	int error;
4354
4355	ASSERT(bridge_in_bsd_mode(sc));
4356	#if BRIDGE_DEBUG
4357	if (if_bridge_debug & BR_DBGF_INPUT)
4358	printf("%s: %s from %s m 0x%llx data 0x%llx\n", __func__,
4359	sc->sc_ifp->if_xname, ifp->if_xname,
4360	(uint64_t)VM_KERNEL_ADDRPERM(m),
4361	(uint64_t)VM_KERNEL_ADDRPERM(mbuf_data(m)));
4362	#endif /* BRIDGE_DEBUG */
4363
4364	if ((sc->sc_ifp->if_flags & IFF_RUNNING) == `0`) {
4365	#if BRIDGE_DEBUG
4366	if (if_bridge_debug & BR_DBGF_INPUT)
4367	printf("%s: %s not running passing along\n",
4368	__func__, sc->sc_ifp->if_xname);
4369	#endif /* BRIDGE_DEBUG */
4370	return (`0`);
4371	}
4372
4373	bifp = sc->sc_ifp;
4374	vlan = VLANTAGOF(m);
4375
4376	#ifdef IFF_MONITOR
4377	/*
4378	* Implement support for bridge monitoring. If this flag has been
4379	* set on this interface, discard the packet once we push it through
4380	* the bpf(4) machinery, but before we do, increment the byte and
4381	* packet counters associated with this interface.
4382	*/
4383	if ((bifp->if_flags & IFF_MONITOR) != `0`) {
4384	m->m_pkthdr.rcvif = bifp;
4385	BRIDGE_BPF_MTAP_INPUT(sc, m);
4386	(void) ifnet_stat_increment_in(bifp, `1`, m->m_pkthdr.len, `0`);
4387	m_freem(m);
4388	return (EJUSTRETURN);
4389	}
4390	#endif /* IFF_MONITOR */
4391
4392	/*
4393	* Need to clear the promiscous flags otherwise it will be
4394	* dropped by DLIL after processing filters
4395	*/
4396	if ((mbuf_flags(m) & MBUF_PROMISC))
4397	mbuf_setflags_mask(m, `0`, MBUF_PROMISC);
4398
4399	BRIDGE_LOCK(sc);
4400	bif = bridge_lookup_member_if(sc, ifp);
4401	if (bif == NULL) {
4402	BRIDGE_UNLOCK(sc);
4403	#if BRIDGE_DEBUG
4404	if (if_bridge_debug & BR_DBGF_INPUT)
4405	printf("%s: %s bridge_lookup_member_if failed\n",
4406	__func__, sc->sc_ifp->if_xname);
4407	#endif /* BRIDGE_DEBUG */
4408	return (`0`);
4409	}
4410
4411	if (bif->bif_flags & BIFF_HOST_FILTER) {
4412	error = bridge_host_filter(bif, m);
4413	if (error != `0`) {
4414	if (if_bridge_debug & BR_DBGF_INPUT)
4415	printf("%s: %s bridge_host_filter failed\n",
4416	__func__, bif->bif_ifp->if_xname);
4417	BRIDGE_UNLOCK(sc);
4418	return (EJUSTRETURN);
4419	}
4420	}
4421
4422	eh = mtod(m, struct ether_header *);
4423
4424	bridge_span(sc, m);
4425
4426	if (m->m_flags & (M_BCAST\|M_MCAST)) {
4427
4428	#if BRIDGE_DEBUG
4429	if (if_bridge_debug & BR_DBGF_MCAST)
4430	if ((m->m_flags & M_MCAST))
4431	printf("%s: multicast: "
4432	"%02x:%02x:%02x:%02x:%02x:%02x\n",
4433	__func__,
4434	eh->ether_dhost[`0`], eh->ether_dhost[`1`],
4435	eh->ether_dhost[`2`], eh->ether_dhost[`3`],
4436	eh->ether_dhost[`4`], eh->ether_dhost[`5`]);
4437	#endif /* BRIDGE_DEBUG */
4438
4439	/ Tap off 802.1D packets; they do not get forwarded. /
4440	if (memcmp(eh->ether_dhost, bstp_etheraddr,
4441	ETHER_ADDR_LEN) == `0`) {
4442	#if BRIDGESTP
4443	m = bstp_input(&bif->bif_stp, ifp, m);
4444	#else /* !BRIDGESTP */
4445	m_freem(m);
4446	m = NULL;
4447	#endif /* !BRIDGESTP */
4448	if (m == NULL) {
4449	BRIDGE_UNLOCK(sc);
4450	return (EJUSTRETURN);
4451	}
4452	}
4453
4454	if ((bif->bif_ifflags & IFBIF_STP) &&
4455	bif->bif_stp.bp_state == BSTP_IFSTATE_DISCARDING) {
4456	BRIDGE_UNLOCK(sc);
4457	return (`0`);
4458	}
4459
4460	/*
4461	* Make a deep copy of the packet and enqueue the copy
4462	* for bridge processing; return the original packet for
4463	* local processing.
4464	*/
4465	mc = m_dup(m, M_DONTWAIT);
4466	if (mc == NULL) {
4467	BRIDGE_UNLOCK(sc);
4468	return (`0`);
4469	}
4470
4471	/*
4472	* Perform the bridge forwarding function with the copy.
4473	*
4474	* Note that bridge_forward calls BRIDGE_UNLOCK
4475	*/
4476	bridge_forward(sc, bif, mc);
4477
4478	/*
4479	* Reinject the mbuf as arriving on the bridge so we have a
4480	* chance at claiming multicast packets. We can not loop back
4481	* here from ether_input as a bridge is never a member of a
4482	* bridge.
4483	*/
4484	VERIFY(bifp->if_bridge == NULL);
4485	mc2 = m_dup(m, M_DONTWAIT);
4486	if (mc2 != NULL) {
4487	/ Keep the layer3 header aligned /
4488	int i = min(mc2->m_pkthdr.len, max_protohdr);
4489	mc2 = m_copyup(mc2, i, ETHER_ALIGN);
4490	}
4491	if (mc2 != NULL) {
4492	/ mark packet as arriving on the bridge /
4493	mc2->m_pkthdr.rcvif = bifp;
4494	mc2->m_pkthdr.pkt_hdr = mbuf_data(mc2);
4495
4496	#if NBPFILTER > 0
4497	if (sc->sc_bpf_input)
4498	bridge_bpf_input(bifp, mc2);
4499	#endif /* NBPFILTER */
4500	(void) mbuf_setdata(mc2,
4501	(char *)mbuf_data(mc2) + ETHER_HDR_LEN,
4502	mbuf_len(mc2) - ETHER_HDR_LEN);
4503	(void) mbuf_pkthdr_adjustlen(mc2, - ETHER_HDR_LEN);
4504
4505	(void) ifnet_stat_increment_in(bifp, `1`,
4506	mbuf_pkthdr_len(mc2), `0`);
4507
4508	#if BRIDGE_DEBUG
4509	if (if_bridge_debug & BR_DBGF_MCAST)
4510	printf("%s: %s mcast for us\n", __func__,
4511	sc->sc_ifp->if_xname);
4512	#endif /* BRIDGE_DEBUG */
4513
4514	dlil_input_packet_list(bifp, mc2);
4515	}
4516
4517	/ Return the original packet for local processing. /
4518	return (`0`);
4519	}
4520
4521	if ((bif->bif_ifflags & IFBIF_STP) &&
4522	bif->bif_stp.bp_state == BSTP_IFSTATE_DISCARDING) {
4523	BRIDGE_UNLOCK(sc);
4524	return (`0`);
4525	}
4526
4527	#ifdef DEV_CARP
4528	#define CARP_CHECK_WE_ARE_DST(iface) \
4529	((iface)->if_carp &&\
4530	carp_forus((iface)->if_carp, eh->ether_dhost))
4531	#define CARP_CHECK_WE_ARE_SRC(iface) \
4532	((iface)->if_carp &&\
4533	carp_forus((iface)->if_carp, eh->ether_shost))
4534	#else
4535	#define CARP_CHECK_WE_ARE_DST(iface) 0
4536	#define CARP_CHECK_WE_ARE_SRC(iface) 0
4537	#endif
4538
4539	#ifdef INET6
4540	#define PFIL_HOOKED_INET6 PFIL_HOOKED(&inet6_pfil_hook)
4541	#else
4542	#define PFIL_HOOKED_INET6 0
4543	#endif
4544
4545	#if defined(PFIL_HOOKS)
4546	#define PFIL_PHYS(sc, ifp, m) do { \
4547	if (pfil_local_phys && \
4548	(PFIL_HOOKED(&inet_pfil_hook) \|\| PFIL_HOOKED_INET6)) { \
4549	if (bridge_pfil(&m, NULL, ifp, \
4550	PFIL_IN) != 0 \|\| m == NULL) { \
4551	BRIDGE_UNLOCK(sc); \
4552	return (NULL); \
4553	} \
4554	} \
4555	} while (0)
4556	#else /* PFIL_HOOKS */
4557	#define PFIL_PHYS(sc, ifp, m)
4558	#endif /* PFIL_HOOKS */
4559
4560	#define GRAB_OUR_PACKETS(iface) \
4561	if ((iface)->if_type == IFT_GIF) \
4562	continue; \
4563	/* It is destined for us. */ \
4564	if (memcmp(IF_LLADDR((iface)), eh->ether_dhost, \
4565	ETHER_ADDR_LEN) == 0 \|\| CARP_CHECK_WE_ARE_DST((iface))) { \
4566	if ((iface)->if_type == IFT_BRIDGE) { \
4567	BRIDGE_BPF_MTAP_INPUT(sc, m); \
4568	/* Filter on the physical interface. */ \
4569	PFIL_PHYS(sc, iface, m); \
4570	} \
4571	if (bif->bif_ifflags & IFBIF_LEARNING) { \
4572	error = bridge_rtupdate(sc, eh->ether_shost, \
4573	vlan, bif, 0, IFBAF_DYNAMIC); \
4574	if (error && bif->bif_addrmax) { \
4575	BRIDGE_UNLOCK(sc); \
4576	return (EJUSTRETURN); \
4577	} \
4578	} \
4579	m->m_pkthdr.rcvif = iface; \
4580	BRIDGE_UNLOCK(sc); \
4581	return (0); \
4582	} \
4583	\
4584	/* We just received a packet that we sent out. */ \
4585	if (memcmp(IF_LLADDR((iface)), eh->ether_shost, \
4586	ETHER_ADDR_LEN) == 0 \|\| CARP_CHECK_WE_ARE_SRC((iface))) { \
4587	BRIDGE_UNLOCK(sc); \
4588	return (EJUSTRETURN); \
4589	}
4590
4591	/*
4592	* Unicast.
4593	*/
4594	/*
4595	* If the packet is for us, set the packets source as the
4596	* bridge, and return the packet back to ether_input for
4597	* local processing.
4598	*/
4599	if (memcmp(eh->ether_dhost, IF_LLADDR(bifp),
4600	ETHER_ADDR_LEN) == `0` \|\| CARP_CHECK_WE_ARE_DST(bifp)) {
4601
4602	/ Mark the packet as arriving on the bridge interface /
4603	(void) mbuf_pkthdr_setrcvif(m, bifp);
4604	mbuf_pkthdr_setheader(m, frame_header);
4605
4606	/*
4607	* If the interface is learning, and the source
4608	* address is valid and not multicast, record
4609	* the address.
4610	*/
4611	if (bif->bif_ifflags & IFBIF_LEARNING)
4612	(void) bridge_rtupdate(sc, eh->ether_shost,
4613	vlan, bif, `0`, IFBAF_DYNAMIC);
4614
4615	BRIDGE_BPF_MTAP_INPUT(sc, m);
4616
4617	(void) mbuf_setdata(m, (char *)mbuf_data(m) + ETHER_HDR_LEN,
4618	mbuf_len(m) - ETHER_HDR_LEN);
4619	(void) mbuf_pkthdr_adjustlen(m, - ETHER_HDR_LEN);
4620
4621	(void) ifnet_stat_increment_in(bifp, `1`, mbuf_pkthdr_len(m), `0`);
4622
4623	BRIDGE_UNLOCK(sc);
4624
4625	#if BRIDGE_DEBUG
4626	if (if_bridge_debug & BR_DBGF_INPUT)
4627	printf("%s: %s packet for bridge\n", __func__,
4628	sc->sc_ifp->if_xname);
4629	#endif /* BRIDGE_DEBUG */
4630
4631	dlil_input_packet_list(bifp, m);
4632
4633	return (EJUSTRETURN);
4634	}
4635
4636	/*
4637	* if the destination of the packet is for the MAC address of
4638	* the member interface itself, then we don't need to forward
4639	* it -- just pass it back. Note that it'll likely just be
4640	* dropped by the stack, but if something else is bound to
4641	* the interface directly (for example, the wireless stats
4642	* protocol -- although that actually uses BPF right now),
4643	* then it will consume the packet
4644	*
4645	* ALSO, note that we do this check AFTER checking for the
4646	* bridge's own MAC address, because the bridge may be
4647	* using the SAME MAC address as one of its interfaces
4648	*/
4649	if (memcmp(eh->ether_dhost, IF_LLADDR(ifp), ETHER_ADDR_LEN) == `0`) {
4650
4651	#ifdef VERY_VERY_VERY_DIAGNOSTIC
4652	printf("%s: not forwarding packet bound for member "
4653	"interface\n", __func__);
4654	#endif
4655	BRIDGE_UNLOCK(sc);
4656	return (`0`);
4657	}
4658
4659	/ Now check the all bridge members. /
4660	TAILQ_FOREACH(bif2, &sc->sc_iflist, bif_next) {
4661	GRAB_OUR_PACKETS(bif2->bif_ifp)
4662	}
4663
4664	#undef CARP_CHECK_WE_ARE_DST
4665	#undef CARP_CHECK_WE_ARE_SRC
4666	#undef GRAB_OUR_PACKETS
4667
4668	/*
4669	* Perform the bridge forwarding function.
4670	*
4671	* Note that bridge_forward calls BRIDGE_UNLOCK
4672	*/
4673	bridge_forward(sc, bif, m);
4674
4675	return (EJUSTRETURN);
4676	}
4677
4678	/*
4679	* bridge_broadcast:
4680	*
4681	* Send a frame to all interfaces that are members of
4682	* the bridge, except for the one on which the packet
4683	* arrived.
4684	*
4685	* NOTE: Releases the lock on return.
4686	*/
4687	static void
4688	bridge_broadcast(struct bridge_softc sc, struct* ifnet *src_if,
4689	struct mbuf m, int* runfilt)
4690	{
4691	#ifndef PFIL_HOOKS
4692	#pragma unused(runfilt)
4693	#endif
4694	struct bridge_iflist dbif, sbif;
4695	struct mbuf *mc;
4696	struct ifnet *dst_if;
4697	int error = `0`, used = `0`;
4698
4699	sbif = bridge_lookup_member_if(sc, src_if);
4700
4701	BRIDGE_LOCK2REF(sc, error);
4702	if (error) {
4703	m_freem(m);
4704	return;
4705	}
4706
4707	#ifdef PFIL_HOOKS
4708	/ Filter on the bridge interface before broadcasting /
4709	if (runfilt && (PFIL_HOOKED(&inet_pfil_hook) \|\| PFIL_HOOKED_INET6)) {
4710	if (bridge_pfil(&m, sc->sc_ifp, NULL, PFIL_OUT) != `0`)
4711	goto out;
4712	if (m == NULL)
4713	goto out;
4714	}
4715	#endif /* PFIL_HOOKS */
4716
4717	TAILQ_FOREACH(dbif, &sc->sc_iflist, bif_next) {
4718	dst_if = dbif->bif_ifp;
4719	if (dst_if == src_if)
4720	continue;
4721
4722	/ Private segments can not talk to each other /
4723	if (sbif &&
4724	(sbif->bif_ifflags & dbif->bif_ifflags & IFBIF_PRIVATE))
4725	continue;
4726
4727	if ((dbif->bif_ifflags & IFBIF_STP) &&
4728	dbif->bif_stp.bp_state == BSTP_IFSTATE_DISCARDING)
4729	continue;
4730
4731	if ((dbif->bif_ifflags & IFBIF_DISCOVER) == `0` &&
4732	(m->m_flags & (M_BCAST\|M_MCAST)) == `0`)
4733	continue;
4734
4735	if ((dst_if->if_flags & IFF_RUNNING) == `0`)
4736	continue;
4737
4738	if (!(dbif->bif_flags & BIFF_MEDIA_ACTIVE)) {
4739	continue;
4740	}
4741
4742	if (TAILQ_NEXT(dbif, bif_next) == NULL) {
4743	mc = m;
4744	used = `1`;
4745	} else {
4746	mc = m_dup(m, M_DONTWAIT);
4747	if (mc == NULL) {
4748	(void) ifnet_stat_increment_out(sc->sc_ifp,
4749	`0`, `0`, `1`);
4750	continue;
4751	}
4752	}
4753
4754	#ifdef PFIL_HOOKS
4755	/*
4756	* Filter on the output interface. Pass a NULL bridge interface
4757	* pointer so we do not redundantly filter on the bridge for
4758	* each interface we broadcast on.
4759	*/
4760	if (runfilt &&
4761	(PFIL_HOOKED(&inet_pfil_hook) \|\| PFIL_HOOKED_INET6)) {
4762	if (used == `0`) {
4763	/ Keep the layer3 header aligned /
4764	int i = min(mc->m_pkthdr.len, max_protohdr);
4765	mc = m_copyup(mc, i, ETHER_ALIGN);
4766	if (mc == NULL) {
4767	(void) ifnet_stat_increment_out(
4768	sc->sc_ifp, `0`, `0`, `1`);
4769	continue;
4770	}
4771	}
4772	if (bridge_pfil(&mc, NULL, dst_if, PFIL_OUT) != `0`)
4773	continue;
4774	if (mc == NULL)
4775	continue;
4776	}
4777	#endif /* PFIL_HOOKS */
4778
4779	(void) bridge_enqueue(sc, dst_if, mc);
4780	}
4781	if (used == `0`)
4782	m_freem(m);
4783
4784	#ifdef PFIL_HOOKS
4785	out:
4786	#endif /* PFIL_HOOKS */
4787
4788	BRIDGE_UNREF(sc);
4789	}
4790
4791	/*
4792	* bridge_span:
4793	*
4794	* Duplicate a packet out one or more interfaces that are in span mode,
4795	* the original mbuf is unmodified.
4796	*/
4797	static void
4798	bridge_span(struct bridge_softc sc, struct* mbuf *m)
4799	{
4800	struct bridge_iflist *bif;
4801	struct ifnet *dst_if;
4802	struct mbuf *mc;
4803
4804	if (TAILQ_EMPTY(&sc->sc_spanlist))
4805	return;
4806
4807	TAILQ_FOREACH(bif, &sc->sc_spanlist, bif_next) {
4808	dst_if = bif->bif_ifp;
4809
4810	if ((dst_if->if_flags & IFF_RUNNING) == `0`)
4811	continue;
4812
4813	mc = m_copypacket(m, M_DONTWAIT);
4814	if (mc == NULL) {
4815	(void) ifnet_stat_increment_out(sc->sc_ifp, `0`, `0`, `1`);
4816	continue;
4817	}
4818
4819	(void) bridge_enqueue(sc, dst_if, mc);
4820	}
4821	}
4822
4823
4824	/*
4825	* bridge_rtupdate:
4826	*
4827	* Add a bridge routing entry.
4828	*/
4829	static int
4830	bridge_rtupdate(struct bridge_softc sc, const* uint8_t *dst, uint16_t vlan,
4831	struct bridge_iflist bif, int* setflags, uint8_t flags)
4832	{
4833	struct bridge_rtnode *brt;
4834	int error;
4835
4836	BRIDGE_LOCK_ASSERT_HELD(sc);
4837	ASSERT(bridge_in_bsd_mode(sc));
4838
4839	/ Check the source address is valid and not multicast. /
4840	if (ETHER_IS_MULTICAST(dst) \|\|
4841	(dst[`0`] == `0` && dst[`1`] == `0` && dst[`2`] == `0` &&
4842	dst[`3`] == `0` && dst[`4`] == `0` && dst[`5`] == `0`) != `0`)
4843	return (EINVAL);
4844
4845
4846	/ 802.1p frames map to vlan 1 /
4847	if (vlan == `0`)
4848	vlan = `1`;
4849
4850	/*
4851	* A route for this destination might already exist. If so,
4852	* update it, otherwise create a new one.
4853	*/
4854	if ((brt = bridge_rtnode_lookup(sc, dst, vlan)) == NULL) {
4855	if (sc->sc_brtcnt >= sc->sc_brtmax) {
4856	sc->sc_brtexceeded++;
4857	return (ENOSPC);
4858	}
4859	/ Check per interface address limits (if enabled) /
4860	if (bif->bif_addrmax && bif->bif_addrcnt >= bif->bif_addrmax) {
4861	bif->bif_addrexceeded++;
4862	return (ENOSPC);
4863	}
4864
4865	/*
4866	* Allocate a new bridge forwarding node, and
4867	* initialize the expiration time and Ethernet
4868	* address.
4869	*/
4870	brt = zalloc_noblock(bridge_rtnode_pool);
4871	if (brt == NULL)
4872	return (ENOMEM);
4873	bzero(brt, sizeof(struct bridge_rtnode));
4874
4875	if (bif->bif_ifflags & IFBIF_STICKY)
4876	brt->brt_flags = IFBAF_STICKY;
4877	else
4878	brt->brt_flags = IFBAF_DYNAMIC;
4879
4880	memcpy(brt->brt_addr, dst, ETHER_ADDR_LEN);
4881	brt->brt_vlan = vlan;
4882
4883
4884	if ((error = bridge_rtnode_insert(sc, brt)) != `0`) {
4885	zfree(bridge_rtnode_pool, brt);
4886	return (error);
4887	}
4888	brt->brt_dst = bif;
4889	bif->bif_addrcnt++;
4890	#if BRIDGE_DEBUG
4891	if (if_bridge_debug & BR_DBGF_RT_TABLE)
4892	printf("%s: added %02x:%02x:%02x:%02x:%02x:%02x "
4893	"on %s count %u hashsize %u\n", __func__,
4894	dst[`0`], dst[`1`], dst[`2`], dst[`3`], dst[`4`], dst[`5`],
4895	sc->sc_ifp->if_xname, sc->sc_brtcnt,
4896	sc->sc_rthash_size);
4897	#endif
4898	}
4899
4900	if ((brt->brt_flags & IFBAF_TYPEMASK) == IFBAF_DYNAMIC &&
4901	brt->brt_dst != bif) {
4902	brt->brt_dst->bif_addrcnt--;
4903	brt->brt_dst = bif;
4904	brt->brt_dst->bif_addrcnt++;
4905	}
4906
4907	if ((flags & IFBAF_TYPEMASK) == IFBAF_DYNAMIC) {
4908	unsigned long now;
4909
4910	now = (unsigned long) net_uptime();
4911	brt->brt_expire = now + sc->sc_brttimeout;
4912	}
4913	if (setflags)
4914	brt->brt_flags = flags;
4915
4916
4917	return (`0`);
4918	}
4919
4920	/*
4921	* bridge_rtlookup:
4922	*
4923	* Lookup the destination interface for an address.
4924	*/
4925	static struct ifnet *
4926	bridge_rtlookup(struct bridge_softc sc, const* uint8_t *addr, uint16_t vlan)
4927	{
4928	struct bridge_rtnode *brt;
4929
4930	BRIDGE_LOCK_ASSERT_HELD(sc);
4931
4932	if ((brt = bridge_rtnode_lookup(sc, addr, vlan)) == NULL)
4933	return (NULL);
4934
4935	return (brt->brt_ifp);
4936	}
4937
4938	/*
4939	* bridge_rttrim:
4940	*
4941	* Trim the routine table so that we have a number
4942	* of routing entries less than or equal to the
4943	* maximum number.
4944	*/
4945	static void
4946	bridge_rttrim(struct bridge_softc *sc)
4947	{
4948	struct bridge_rtnode brt, nbrt;
4949
4950	BRIDGE_LOCK_ASSERT_HELD(sc);
4951
4952	/ Make sure we actually need to do this. /
4953	if (sc->sc_brtcnt <= sc->sc_brtmax)
4954	return;
4955
4956	/ Force an aging cycle; this might trim enough addresses. /
4957	bridge_rtage(sc);
4958	if (sc->sc_brtcnt <= sc->sc_brtmax)
4959	return;
4960
4961	LIST_FOREACH_SAFE(brt, &sc->sc_rtlist, brt_list, nbrt) {
4962	if ((brt->brt_flags & IFBAF_TYPEMASK) == IFBAF_DYNAMIC) {
4963	bridge_rtnode_destroy(sc, brt);
4964	if (sc->sc_brtcnt <= sc->sc_brtmax)
4965	return;
4966	}
4967	}
4968	}
4969
4970	/*
4971	* bridge_aging_timer:
4972	*
4973	* Aging periodic timer for the bridge routing table.
4974	*/
4975	static void
4976	bridge_aging_timer(struct bridge_softc *sc)
4977	{
4978	BRIDGE_LOCK_ASSERT_HELD(sc);
4979
4980	bridge_rtage(sc);
4981
4982	if ((sc->sc_ifp->if_flags & IFF_RUNNING) &&
4983	(sc->sc_flags & SCF_DETACHING) == `0`) {
4984	sc->sc_aging_timer.bdc_sc = sc;
4985	sc->sc_aging_timer.bdc_func = bridge_aging_timer;
4986	sc->sc_aging_timer.bdc_ts.tv_sec = bridge_rtable_prune_period;
4987	bridge_schedule_delayed_call(&sc->sc_aging_timer);
4988	}
4989	}
4990
4991	/*
4992	* bridge_rtage:
4993	*
4994	* Perform an aging cycle.
4995	*/
4996	static void
4997	bridge_rtage(struct bridge_softc *sc)
4998	{
4999	struct bridge_rtnode brt, nbrt;
5000	unsigned long now;
5001
5002	BRIDGE_LOCK_ASSERT_HELD(sc);
5003
5004	now = (unsigned long) net_uptime();
5005
5006	LIST_FOREACH_SAFE(brt, &sc->sc_rtlist, brt_list, nbrt) {
5007	if ((brt->brt_flags & IFBAF_TYPEMASK) == IFBAF_DYNAMIC) {
5008	if (now >= brt->brt_expire)
5009	bridge_rtnode_destroy(sc, brt);
5010	}
5011	}
5012	}
5013
5014	/*
5015	* bridge_rtflush:
5016	*
5017	* Remove all dynamic addresses from the bridge.
5018	*/
5019	static void
5020	bridge_rtflush(struct bridge_softc sc, int* full)
5021	{
5022	struct bridge_rtnode brt, nbrt;
5023
5024	BRIDGE_LOCK_ASSERT_HELD(sc);
5025
5026	LIST_FOREACH_SAFE(brt, &sc->sc_rtlist, brt_list, nbrt) {
5027	if (full \|\| (brt->brt_flags & IFBAF_TYPEMASK) == IFBAF_DYNAMIC)
5028	bridge_rtnode_destroy(sc, brt);
5029	}
5030	}
5031
5032	/*
5033	* bridge_rtdaddr:
5034	*
5035	* Remove an address from the table.
5036	*/
5037	static int
5038	bridge_rtdaddr(struct bridge_softc sc, const* uint8_t *addr, uint16_t vlan)
5039	{
5040	struct bridge_rtnode *brt;
5041	int found = `0`;
5042
5043	BRIDGE_LOCK_ASSERT_HELD(sc);
5044
5045	/*
5046	* If vlan is zero then we want to delete for all vlans so the lookup
5047	* may return more than one.
5048	*/
5049	while ((brt = bridge_rtnode_lookup(sc, addr, vlan)) != NULL) {
5050	bridge_rtnode_destroy(sc, brt);
5051	found = `1`;
5052	}
5053
5054	return (found ? `0` : ENOENT);
5055	}
5056
5057	/*
5058	* bridge_rtdelete:
5059	*
5060	* Delete routes to a speicifc member interface.
5061	*/
5062	static void
5063	bridge_rtdelete(struct bridge_softc sc, struct* ifnet ifp, int* full)
5064	{
5065	struct bridge_rtnode brt, nbrt;
5066
5067	BRIDGE_LOCK_ASSERT_HELD(sc);
5068
5069	LIST_FOREACH_SAFE(brt, &sc->sc_rtlist, brt_list, nbrt) {
5070	if (brt->brt_ifp == ifp && (full \|\|
5071	(brt->brt_flags & IFBAF_TYPEMASK) == IFBAF_DYNAMIC))
5072	bridge_rtnode_destroy(sc, brt);
5073	}
5074	}
5075
5076	/*
5077	* bridge_rtable_init:
5078	*
5079	* Initialize the route table for this bridge.
5080	*/
5081	static int
5082	bridge_rtable_init(struct bridge_softc *sc)
5083	{
5084	u_int32_t i;
5085
5086	ASSERT(bridge_in_bsd_mode(sc));
5087
5088	sc->sc_rthash = _MALLOC(sizeof (sc->sc_rthash) BRIDGE_RTHASH_SIZE,
5089	M_DEVBUF, M_WAITOK \| M_ZERO);
5090	if (sc->sc_rthash == NULL) {
5091	printf("%s: no memory\n", __func__);
5092	return (ENOMEM);
5093	}
5094	sc->sc_rthash_size = BRIDGE_RTHASH_SIZE;
5095
5096	for (i = `0`; i < sc->sc_rthash_size; i++)
5097	LIST_INIT(&sc->sc_rthash[i]);
5098
5099	sc->sc_rthash_key = RandomULong();
5100
5101	LIST_INIT(&sc->sc_rtlist);
5102
5103	return (`0`);
5104	}
5105
5106	/*
5107	* bridge_rthash_delayed_resize:
5108	*
5109	* Resize the routing table hash on a delayed thread call.
5110	*/
5111	static void
5112	bridge_rthash_delayed_resize(struct bridge_softc *sc)
5113	{
5114	u_int32_t new_rthash_size;
5115	struct _bridge_rtnode_list *new_rthash = NULL;
5116	struct _bridge_rtnode_list *old_rthash = NULL;
5117	u_int32_t i;
5118	struct bridge_rtnode *brt;
5119	int error = `0`;
5120
5121	BRIDGE_LOCK_ASSERT_HELD(sc);
5122
5123	/*
5124	* Four entries per hash bucket is our ideal load factor
5125	*/
5126	if (sc->sc_brtcnt < sc->sc_rthash_size * `4`)
5127	goto out;
5128
5129	/*
5130	* Doubling the number of hash buckets may be too simplistic
5131	* especially when facing a spike of new entries
5132	*/
5133	new_rthash_size = sc->sc_rthash_size * `2`;
5134
5135	sc->sc_flags \|= SCF_RESIZING;
5136	BRIDGE_UNLOCK(sc);
5137
5138	new_rthash = _MALLOC(sizeof (sc->sc_rthash) new_rthash_size,
5139	M_DEVBUF, M_WAITOK \| M_ZERO);
5140
5141	BRIDGE_LOCK(sc);
5142	sc->sc_flags &= ~SCF_RESIZING;
5143
5144	if (new_rthash == NULL) {
5145	error = ENOMEM;
5146	goto out;
5147	}
5148	if ((sc->sc_flags & SCF_DETACHING)) {
5149	error = ENODEV;
5150	goto out;
5151	}
5152	/*
5153	* Fail safe from here on
5154	*/
5155	old_rthash = sc->sc_rthash;
5156	sc->sc_rthash = new_rthash;
5157	sc->sc_rthash_size = new_rthash_size;
5158
5159	/*
5160	* Get a new key to force entries to be shuffled around to reduce
5161	* the likelihood they will land in the same buckets
5162	*/
5163	sc->sc_rthash_key = RandomULong();
5164
5165	for (i = `0`; i < sc->sc_rthash_size; i++)
5166	LIST_INIT(&sc->sc_rthash[i]);
5167
5168	LIST_FOREACH(brt, &sc->sc_rtlist, brt_list) {
5169	LIST_REMOVE(brt, brt_hash);
5170	(void) bridge_rtnode_hash(sc, brt);
5171	}
5172	out:
5173	if (error == `0`) {
5174	#if BRIDGE_DEBUG
5175	if (if_bridge_debug & BR_DBGF_RT_TABLE)
5176	printf("%s: %s new size %u\n", __func__,
5177	sc->sc_ifp->if_xname, sc->sc_rthash_size);
5178	#endif /* BRIDGE_DEBUG */
5179	if (old_rthash)
5180	_FREE(old_rthash, M_DEVBUF);
5181	} else {
5182	#if BRIDGE_DEBUG
5183	printf("%s: %s failed %d\n", __func__,
5184	sc->sc_ifp->if_xname, error);
5185	#endif /* BRIDGE_DEBUG */
5186	if (new_rthash != NULL)
5187	_FREE(new_rthash, M_DEVBUF);
5188	}
5189	}
5190
5191	/*
5192	* Resize the number of hash buckets based on the load factor
5193	* Currently only grow
5194	* Failing to resize the hash table is not fatal
5195	*/
5196	static void
5197	bridge_rthash_resize(struct bridge_softc *sc)
5198	{
5199	BRIDGE_LOCK_ASSERT_HELD(sc);
5200
5201	if ((sc->sc_flags & SCF_DETACHING) \|\| (sc->sc_flags & SCF_RESIZING))
5202	return;
5203
5204	/*
5205	* Four entries per hash bucket is our ideal load factor
5206	*/
5207	if (sc->sc_brtcnt < sc->sc_rthash_size * `4`)
5208	return;
5209	/*
5210	* Hard limit on the size of the routing hash table
5211	*/
5212	if (sc->sc_rthash_size >= bridge_rtable_hash_size_max)
5213	return;
5214
5215	sc->sc_resize_call.bdc_sc = sc;
5216	sc->sc_resize_call.bdc_func = bridge_rthash_delayed_resize;
5217	bridge_schedule_delayed_call(&sc->sc_resize_call);
5218	}
5219
5220	/*
5221	* bridge_rtable_fini:
5222	*
5223	* Deconstruct the route table for this bridge.
5224	*/
5225	static void
5226	bridge_rtable_fini(struct bridge_softc *sc)
5227	{
5228	KASSERT(sc->sc_brtcnt == `0`,
5229	("%s: %d bridge routes referenced", __func__, sc->sc_brtcnt));
5230	if (sc->sc_rthash) {
5231	_FREE(sc->sc_rthash, M_DEVBUF);
5232	sc->sc_rthash = NULL;
5233	}
5234	}
5235
5236	/*
5237	* The following hash function is adapted from "Hash Functions" by Bob Jenkins
5238	* ("Algorithm Alley", Dr. Dobbs Journal, September 1997).
5239	*/
5240	#define mix(a, b, c) \
5241	do { \
5242	a -= b; a -= c; a ^= (c >> 13); \
5243	b -= c; b -= a; b ^= (a << 8); \
5244	c -= a; c -= b; c ^= (b >> 13); \
5245	a -= b; a -= c; a ^= (c >> 12); \
5246	b -= c; b -= a; b ^= (a << 16); \
5247	c -= a; c -= b; c ^= (b >> 5); \
5248	a -= b; a -= c; a ^= (c >> 3); \
5249	b -= c; b -= a; b ^= (a << 10); \
5250	c -= a; c -= b; c ^= (b >> 15); \
5251	} while (/CONSTCOND/0)
5252
5253	static __inline uint32_t
5254	bridge_rthash(struct bridge_softc sc, const* uint8_t *addr)
5255	{
5256	uint32_t a = `0x9e3779b9`, b = `0x9e3779b9`, c = sc->sc_rthash_key;
5257
5258	b += addr[`5`] << `8`;
5259	b += addr[`4`];
5260	a += addr[`3`] << `24`;
5261	a += addr[`2`] << `16`;
5262	a += addr[`1`] << `8`;
5263	a += addr[`0`];
5264
5265	mix(a, b, c);
5266
5267	return (c & BRIDGE_RTHASH_MASK(sc));
5268	}
5269
5270	#undef mix
5271
5272	static int
5273	bridge_rtnode_addr_cmp(const uint8_t a, const* uint8_t *b)
5274	{
5275	int i, d;
5276
5277	for (i = `0`, d = `0`; i < ETHER_ADDR_LEN && d == `0`; i++) {
5278	d = ((int)a[i]) - ((int)b[i]);
5279	}
5280
5281	return (d);
5282	}
5283
5284	/*
5285	* bridge_rtnode_lookup:
5286	*
5287	* Look up a bridge route node for the specified destination. Compare the
5288	* vlan id or if zero then just return the first match.
5289	*/
5290	static struct bridge_rtnode *
5291	bridge_rtnode_lookup(struct bridge_softc sc, const* uint8_t *addr,
5292	uint16_t vlan)
5293	{
5294	struct bridge_rtnode *brt;
5295	uint32_t hash;
5296	int dir;
5297
5298	BRIDGE_LOCK_ASSERT_HELD(sc);
5299	ASSERT(bridge_in_bsd_mode(sc));
5300
5301	hash = bridge_rthash(sc, addr);
5302	LIST_FOREACH(brt, &sc->sc_rthash[hash], brt_hash) {
5303	dir = bridge_rtnode_addr_cmp(addr, brt->brt_addr);
5304	if (dir == `0` && (brt->brt_vlan == vlan \|\| vlan == `0`))
5305	return (brt);
5306	if (dir > `0`)
5307	return (NULL);
5308	}
5309
5310	return (NULL);
5311	}
5312
5313	/*
5314	* bridge_rtnode_hash:
5315	*
5316	* Insert the specified bridge node into the route hash table.
5317	* This is used when adding a new node or to rehash when resizing
5318	* the hash table
5319	*/
5320	static int
5321	bridge_rtnode_hash(struct bridge_softc sc, struct* bridge_rtnode *brt)
5322	{
5323	struct bridge_rtnode *lbrt;
5324	uint32_t hash;
5325	int dir;
5326
5327	BRIDGE_LOCK_ASSERT_HELD(sc);
5328
5329	hash = bridge_rthash(sc, brt->brt_addr);
5330
5331	lbrt = LIST_FIRST(&sc->sc_rthash[hash]);
5332	if (lbrt == NULL) {
5333	LIST_INSERT_HEAD(&sc->sc_rthash[hash], brt, brt_hash);
5334	goto out;
5335	}
5336
5337	do {
5338	dir = bridge_rtnode_addr_cmp(brt->brt_addr, lbrt->brt_addr);
5339	if (dir == `0` && brt->brt_vlan == lbrt->brt_vlan) {
5340	#if BRIDGE_DEBUG
5341	if (if_bridge_debug & BR_DBGF_RT_TABLE)
5342	printf("%s: %s EEXIST "
5343	"%02x:%02x:%02x:%02x:%02x:%02x\n",
5344	__func__, sc->sc_ifp->if_xname,
5345	brt->brt_addr[`0`], brt->brt_addr[`1`],
5346	brt->brt_addr[`2`], brt->brt_addr[`3`],
5347	brt->brt_addr[`4`], brt->brt_addr[`5`]);
5348	#endif
5349	return (EEXIST);
5350	}
5351	if (dir > `0`) {
5352	LIST_INSERT_BEFORE(lbrt, brt, brt_hash);
5353	goto out;
5354	}
5355	if (LIST_NEXT(lbrt, brt_hash) == NULL) {
5356	LIST_INSERT_AFTER(lbrt, brt, brt_hash);
5357	goto out;
5358	}
5359	lbrt = LIST_NEXT(lbrt, brt_hash);
5360	} while (lbrt != NULL);
5361
5362	#if BRIDGE_DEBUG
5363	if (if_bridge_debug & BR_DBGF_RT_TABLE)
5364	printf("%s: %s impossible %02x:%02x:%02x:%02x:%02x:%02x\n",
5365	__func__, sc->sc_ifp->if_xname,
5366	brt->brt_addr[`0`], brt->brt_addr[`1`], brt->brt_addr[`2`],
5367	brt->brt_addr[`3`], brt->brt_addr[`4`], brt->brt_addr[`5`]);
5368	#endif
5369
5370	out:
5371	return (`0`);
5372	}
5373
5374	/*
5375	* bridge_rtnode_insert:
5376	*
5377	* Insert the specified bridge node into the route table. We
5378	* assume the entry is not already in the table.
5379	*/
5380	static int
5381	bridge_rtnode_insert(struct bridge_softc sc, struct* bridge_rtnode *brt)
5382	{
5383	int error;
5384
5385	error = bridge_rtnode_hash(sc, brt);
5386	if (error != `0`)
5387	return (error);
5388
5389	LIST_INSERT_HEAD(&sc->sc_rtlist, brt, brt_list);
5390	sc->sc_brtcnt++;
5391
5392	bridge_rthash_resize(sc);
5393
5394	return (`0`);
5395	}
5396
5397	/*
5398	* bridge_rtnode_destroy:
5399	*
5400	* Destroy a bridge rtnode.
5401	*/
5402	static void
5403	bridge_rtnode_destroy(struct bridge_softc sc, struct* bridge_rtnode *brt)
5404	{
5405	BRIDGE_LOCK_ASSERT_HELD(sc);
5406
5407	LIST_REMOVE(brt, brt_hash);
5408
5409	LIST_REMOVE(brt, brt_list);
5410	sc->sc_brtcnt--;
5411	brt->brt_dst->bif_addrcnt--;
5412	zfree(bridge_rtnode_pool, brt);
5413	}
5414
5415	#if BRIDGESTP
5416	/*
5417	* bridge_rtable_expire:
5418	*
5419	* Set the expiry time for all routes on an interface.
5420	*/
5421	static void
5422	bridge_rtable_expire(struct ifnet ifp, int* age)
5423	{
5424	struct bridge_softc *sc = ifp->if_bridge;
5425	struct bridge_rtnode *brt;
5426
5427	BRIDGE_LOCK(sc);
5428
5429	/*
5430	* If the age is zero then flush, otherwise set all the expiry times to
5431	* age for the interface
5432	*/
5433	if (age == `0`) {
5434	bridge_rtdelete(sc, ifp, IFBF_FLUSHDYN);
5435	} else {
5436	unsigned long now;
5437
5438	now = (unsigned long) net_uptime();
5439
5440	LIST_FOREACH(brt, &sc->sc_rtlist, brt_list) {
5441	/ Cap the expiry time to 'age' /
5442	if (brt->brt_ifp == ifp &&
5443	brt->brt_expire > now + age &&
5444	(brt->brt_flags & IFBAF_TYPEMASK) == IFBAF_DYNAMIC)
5445	brt->brt_expire = now + age;
5446	}
5447	}
5448	BRIDGE_UNLOCK(sc);
5449	}
5450
5451	/*
5452	* bridge_state_change:
5453	*
5454	* Callback from the bridgestp code when a port changes states.
5455	*/
5456	static void
5457	bridge_state_change(struct ifnet ifp, int* state)
5458	{
5459	struct bridge_softc *sc = ifp->if_bridge;
5460	static const char *stpstates[] = {
5461	"disabled",
5462	"listening",
5463	"learning",
5464	"forwarding",
5465	"blocking",
5466	"discarding"
5467	};
5468
5469	if (log_stp)
5470	log(LOG_NOTICE, "%s: state changed to %s on %s\n",
5471	sc->sc_ifp->if_xname,
5472	stpstates[state], ifp->if_xname);
5473	}
5474	#endif /* BRIDGESTP */
5475
5476	#ifdef PFIL_HOOKS
5477	/*
5478	* Send bridge packets through pfil if they are one of the types pfil can deal
5479	* with, or if they are ARP or REVARP. (pfil will pass ARP and REVARP without
5480	* question.) If bifp or ifp are NULL then packet filtering is skipped for
5481	* that interface.
5482	*/
5483	static int
5484	bridge_pfil(struct mbuf mp, struct** ifnet bifp, struct* ifnet ifp, int* dir)
5485	{
5486	int snap, error, i, hlen;
5487	struct ether_header *eh1, eh2;
5488	struct ip_fw_args args;
5489	struct ip *ip;
5490	struct llc llc1;
5491	u_int16_t ether_type;
5492
5493	snap = `0`;
5494	error = -`1`; / Default error if not error == 0 /
5495
5496	#if 0
5497	/ we may return with the IP fields swapped, ensure its not shared /
5498	KASSERT(M_WRITABLE(mp), ("%s: modifying a shared mbuf", __func__*));
5499	#endif
5500
5501	if (pfil_bridge == `0` && pfil_member == `0` && pfil_ipfw == `0`)
5502	return (`0`); / filtering is disabled /
5503
5504	i = min((*mp)->m_pkthdr.len, max_protohdr);
5505	if ((*mp)->m_len < i) {
5506	mp = m_pullup(mp, i);
5507	if (*mp == NULL) {
5508	printf("%s: m_pullup failed\n", __func__);
5509	return (-`1`);
5510	}
5511	}
5512
5513	eh1 = mtod(mp, struct* ether_header *);
5514	ether_type = ntohs(eh1->ether_type);
5515
5516	/*
5517	* Check for SNAP/LLC.
5518	*/
5519	if (ether_type < ETHERMTU) {
5520	struct llc llc2 = (struct* llc *)(eh1 + `1`);
5521
5522	if ((*mp)->m_len >= ETHER_HDR_LEN + `8` &&
5523	llc2->llc_dsap == LLC_SNAP_LSAP &&
5524	llc2->llc_ssap == LLC_SNAP_LSAP &&
5525	llc2->llc_control == LLC_UI) {
5526	ether_type = htons(llc2->llc_un.type_snap.ether_type);
5527	snap = `1`;
5528	}
5529	}
5530
5531	/*
5532	* If we're trying to filter bridge traffic, don't look at anything
5533	* other than IP and ARP traffic. If the filter doesn't understand
5534	* IPv6, don't allow IPv6 through the bridge either. This is lame
5535	* since if we really wanted, say, an AppleTalk filter, we are hosed,
5536	* but of course we don't have an AppleTalk filter to begin with.
5537	* (Note that since pfil doesn't understand ARP it will pass ALL
5538	* ARP traffic.)
5539	*/
5540	switch (ether_type) {
5541	case ETHERTYPE_ARP:
5542	case ETHERTYPE_REVARP:
5543	if (pfil_ipfw_arp == `0`)
5544	return (`0`); / Automatically pass /
5545	break;
5546
5547	case ETHERTYPE_IP:
5548	#if INET6
5549	case ETHERTYPE_IPV6:
5550	#endif /* INET6 */
5551	break;
5552	default:
5553	/*
5554	* Check to see if the user wants to pass non-ip
5555	* packets, these will not be checked by pfil(9) and
5556	* passed unconditionally so the default is to drop.
5557	*/
5558	if (pfil_onlyip)
5559	goto bad;
5560	}
5561
5562	/ Strip off the Ethernet header and keep a copy. /
5563	m_copydata(*mp, `0`, ETHER_HDR_LEN, (caddr_t)&eh2);
5564	m_adj(*mp, ETHER_HDR_LEN);
5565
5566	/ Strip off snap header, if present /
5567	if (snap) {
5568	m_copydata(mp, `0`, sizeof* (struct llc), (caddr_t)&llc1);
5569	m_adj(mp, sizeof* (struct llc));
5570	}
5571
5572	/*
5573	* Check the IP header for alignment and errors
5574	*/
5575	if (dir == PFIL_IN) {
5576	switch (ether_type) {
5577	case ETHERTYPE_IP:
5578	error = bridge_ip_checkbasic(mp);
5579	break;
5580	#if INET6
5581	case ETHERTYPE_IPV6:
5582	error = bridge_ip6_checkbasic(mp);
5583	break;
5584	#endif /* INET6 */
5585	default:
5586	error = `0`;
5587	}
5588	if (error)
5589	goto bad;
5590	}
5591
5592	if (IPFW_LOADED && pfil_ipfw != `0` && dir == PFIL_OUT && ifp != NULL) {
5593	error = -`1`;
5594	args.rule = ip_dn_claim_rule(*mp);
5595	if (args.rule != NULL && fw_one_pass)
5596	goto ipfwpass; / packet already partially processed /
5597
5598	args.m = *mp;
5599	args.oif = ifp;
5600	args.next_hop = NULL;
5601	args.eh = &eh2;
5602	args.inp = NULL; / used by ipfw uid/gid/jail rules /
5603	i = ip_fw_chk_ptr(&args);
5604	*mp = args.m;
5605
5606	if (*mp == NULL)
5607	return (error);
5608
5609	if (DUMMYNET_LOADED && (i == IP_FW_DUMMYNET)) {
5610
5611	/ put the Ethernet header back on /
5612	M_PREPEND(*mp, ETHER_HDR_LEN, M_DONTWAIT, `0`);
5613	if (*mp == NULL)
5614	return (error);
5615	bcopy(&eh2, mtod(*mp, caddr_t), ETHER_HDR_LEN);
5616
5617	/*
5618	* Pass the pkt to dummynet, which consumes it. The
5619	* packet will return to us via bridge_dummynet().
5620	*/
5621	args.oif = ifp;
5622	ip_dn_io_ptr(mp, DN_TO_IFB_FWD, &args, DN_CLIENT_IPFW);
5623	return (error);
5624	}
5625
5626	if (i != IP_FW_PASS) / drop /
5627	goto bad;
5628	}
5629
5630	ipfwpass:
5631	error = `0`;
5632
5633	/*
5634	* Run the packet through pfil
5635	*/
5636	switch (ether_type) {
5637	case ETHERTYPE_IP:
5638	/*
5639	* before calling the firewall, swap fields the same as
5640	* IP does. here we assume the header is contiguous
5641	*/
5642	ip = mtod(mp, struct* ip *);
5643
5644	ip->ip_len = ntohs(ip->ip_len);
5645	ip->ip_off = ntohs(ip->ip_off);
5646
5647	/*
5648	* Run pfil on the member interface and the bridge, both can
5649	* be skipped by clearing pfil_member or pfil_bridge.
5650	*
5651	* Keep the order:
5652	* in_if -> bridge_if -> out_if
5653	*/
5654	if (pfil_bridge && dir == PFIL_OUT && bifp != NULL)
5655	error = pfil_run_hooks(&inet_pfil_hook, mp, bifp,
5656	dir, NULL);
5657
5658	if (mp == NULL \|\| error != `0`) /* filter may consume /
5659	break;
5660
5661	if (pfil_member && ifp != NULL)
5662	error = pfil_run_hooks(&inet_pfil_hook, mp, ifp,
5663	dir, NULL);
5664
5665	if (mp == NULL \|\| error != `0`) /* filter may consume /
5666	break;
5667
5668	if (pfil_bridge && dir == PFIL_IN && bifp != NULL)
5669	error = pfil_run_hooks(&inet_pfil_hook, mp, bifp,
5670	dir, NULL);
5671
5672	if (mp == NULL \|\| error != `0`) /* filter may consume /
5673	break;
5674
5675	/ check if we need to fragment the packet /
5676	if (pfil_member && ifp != NULL && dir == PFIL_OUT) {
5677	i = (*mp)->m_pkthdr.len;
5678	if (i > ifp->if_mtu) {
5679	error = bridge_fragment(ifp, *mp, &eh2, snap,
5680	&llc1);
5681	return (error);
5682	}
5683	}
5684
5685	/ Recalculate the ip checksum and restore byte ordering /
5686	ip = mtod(mp, struct* ip *);
5687	hlen = ip->ip_hl << `2`;
5688	if (hlen < sizeof (struct ip))
5689	goto bad;
5690	if (hlen > (*mp)->m_len) {
5691	if ((mp = m_pullup(mp, hlen)) == `0`)
5692	goto bad;
5693	ip = mtod(mp, struct* ip *);
5694	if (ip == NULL)
5695	goto bad;
5696	}
5697	ip->ip_len = htons(ip->ip_len);
5698	ip->ip_off = htons(ip->ip_off);
5699	ip->ip_sum = `0`;
5700	if (hlen == sizeof (struct ip))
5701	ip->ip_sum = in_cksum_hdr(ip);
5702	else
5703	ip->ip_sum = in_cksum(*mp, hlen);
5704
5705	break;
5706	#if INET6
5707	case ETHERTYPE_IPV6:
5708	if (pfil_bridge && dir == PFIL_OUT && bifp != NULL)
5709	error = pfil_run_hooks(&inet6_pfil_hook, mp, bifp,
5710	dir, NULL);
5711
5712	if (mp == NULL \|\| error != `0`) /* filter may consume /
5713	break;
5714
5715	if (pfil_member && ifp != NULL)
5716	error = pfil_run_hooks(&inet6_pfil_hook, mp, ifp,
5717	dir, NULL);
5718
5719	if (mp == NULL \|\| error != `0`) /* filter may consume /
5720	break;
5721
5722	if (pfil_bridge && dir == PFIL_IN && bifp != NULL)
5723	error = pfil_run_hooks(&inet6_pfil_hook, mp, bifp,
5724	dir, NULL);
5725	break;
5726	#endif
5727	default:
5728	error = `0`;
5729	break;
5730	}
5731
5732	if (*mp == NULL)
5733	return (error);
5734	if (error != `0`)
5735	goto bad;
5736
5737	error = -`1`;
5738
5739	/*
5740	* Finally, put everything back the way it was and return
5741	*/
5742	if (snap) {
5743	M_PREPEND(mp, sizeof* (struct llc), M_DONTWAIT, `0`);
5744	if (*mp == NULL)
5745	return (error);
5746	bcopy(&llc1, mtod(mp, caddr_t), sizeof* (struct llc));
5747	}
5748
5749	M_PREPEND(*mp, ETHER_HDR_LEN, M_DONTWAIT, `0`);
5750	if (*mp == NULL)
5751	return (error);
5752	bcopy(&eh2, mtod(*mp, caddr_t), ETHER_HDR_LEN);
5753
5754	return (`0`);
5755
5756	bad:
5757	m_freem(*mp);
5758	*mp = NULL;
5759	return (error);
5760	}
5761
5762	/*
5763	* Perform basic checks on header size since
5764	* pfil assumes ip_input has already processed
5765	* it for it. Cut-and-pasted from ip_input.c.
5766	* Given how simple the IPv6 version is,
5767	* does the IPv4 version really need to be
5768	* this complicated?
5769	*
5770	* XXX Should we update ipstat here, or not?
5771	* XXX Right now we update ipstat but not
5772	* XXX csum_counter.
5773	*/
5774	static int
5775	bridge_ip_checkbasic(struct mbuf **mp)
5776	{
5777	struct mbuf m = mp;
5778	struct ip *ip;
5779	int len, hlen;
5780	u_short sum;
5781
5782	if (*mp == NULL)
5783	return (-`1`);
5784
5785	if (IP_HDR_ALIGNED_P(mtod(m, caddr_t)) == `0`) {
5786	/ max_linkhdr is already rounded up to nearest 4-byte /
5787	if ((m = m_copyup(m, sizeof (struct ip),
5788	max_linkhdr)) == NULL) {
5789	/ XXXJRT new stat, please /
5790	ipstat.ips_toosmall++;
5791	goto bad;
5792	}
5793	} else if (__predict_false(m->m_len < sizeof (struct ip))) {
5794	if ((m = m_pullup(m, sizeof (struct ip))) == NULL) {
5795	ipstat.ips_toosmall++;
5796	goto bad;
5797	}
5798	}
5799	ip = mtod(m, struct ip *);
5800	if (ip == NULL) goto bad;
5801
5802	if (ip->ip_v != IPVERSION) {
5803	ipstat.ips_badvers++;
5804	goto bad;
5805	}
5806	hlen = ip->ip_hl << `2`;
5807	if (hlen < sizeof (struct ip)) { / minimum header length /
5808	ipstat.ips_badhlen++;
5809	goto bad;
5810	}
5811	if (hlen > m->m_len) {
5812	if ((m = m_pullup(m, hlen)) == `0`) {
5813	ipstat.ips_badhlen++;
5814	goto bad;
5815	}
5816	ip = mtod(m, struct ip *);
5817	if (ip == NULL) goto bad;
5818	}
5819
5820	if (m->m_pkthdr.csum_flags & CSUM_IP_CHECKED) {
5821	sum = !(m->m_pkthdr.csum_flags & CSUM_IP_VALID);
5822	} else {
5823	if (hlen == sizeof (struct ip)) {
5824	sum = in_cksum_hdr(ip);
5825	} else {
5826	sum = in_cksum(m, hlen);
5827	}
5828	}
5829	if (sum) {
5830	ipstat.ips_badsum++;
5831	goto bad;
5832	}
5833
5834	/ Retrieve the packet length. /
5835	len = ntohs(ip->ip_len);
5836
5837	/*
5838	* Check for additional length bogosity
5839	*/
5840	if (len < hlen) {
5841	ipstat.ips_badlen++;
5842	goto bad;
5843	}
5844
5845	/*
5846	* Check that the amount of data in the buffers
5847	* is as at least much as the IP header would have us expect.
5848	* Drop packet if shorter than we expect.
5849	*/
5850	if (m->m_pkthdr.len < len) {
5851	ipstat.ips_tooshort++;
5852	goto bad;
5853	}
5854
5855	/ Checks out, proceed /
5856	*mp = m;
5857	return (`0`);
5858
5859	bad:
5860	*mp = m;
5861	return (-`1`);
5862	}
5863
5864	#if INET6
5865	/*
5866	* Same as above, but for IPv6.
5867	* Cut-and-pasted from ip6_input.c.
5868	* XXX Should we update ip6stat, or not?
5869	*/
5870	static int
5871	bridge_ip6_checkbasic(struct mbuf **mp)
5872	{
5873	struct mbuf m = mp;
5874	struct ip6_hdr *ip6;
5875
5876	/*
5877	* If the IPv6 header is not aligned, slurp it up into a new
5878	* mbuf with space for link headers, in the event we forward
5879	* it. Otherwise, if it is aligned, make sure the entire base
5880	* IPv6 header is in the first mbuf of the chain.
5881	*/
5882	if (IP6_HDR_ALIGNED_P(mtod(m, caddr_t)) == `0`) {
5883	struct ifnet *inifp = m->m_pkthdr.rcvif;
5884	/ max_linkhdr is already rounded up to nearest 4-byte /
5885	if ((m = m_copyup(m, sizeof (struct ip6_hdr),
5886	max_linkhdr)) == NULL) {
5887	/ XXXJRT new stat, please /
5888	ip6stat.ip6s_toosmall++;
5889	in6_ifstat_inc(inifp, ifs6_in_hdrerr);
5890	goto bad;
5891	}
5892	} else if (__predict_false(m->m_len < sizeof (struct ip6_hdr))) {
5893	struct ifnet *inifp = m->m_pkthdr.rcvif;
5894	if ((m = m_pullup(m, sizeof (struct ip6_hdr))) == NULL) {
5895	ip6stat.ip6s_toosmall++;
5896	in6_ifstat_inc(inifp, ifs6_in_hdrerr);
5897	goto bad;
5898	}
5899	}
5900
5901	ip6 = mtod(m, struct ip6_hdr *);
5902
5903	if ((ip6->ip6_vfc & IPV6_VERSION_MASK) != IPV6_VERSION) {
5904	ip6stat.ip6s_badvers++;
5905	in6_ifstat_inc(m->m_pkthdr.rcvif, ifs6_in_hdrerr);
5906	goto bad;
5907	}
5908
5909	/ Checks out, proceed /
5910	*mp = m;
5911	return (`0`);
5912
5913	bad:
5914	*mp = m;
5915	return (-`1`);
5916	}
5917	#endif /* INET6 */
5918
5919	/*
5920	* bridge_fragment:
5921	*
5922	* Return a fragmented mbuf chain.
5923	*/
5924	static int
5925	bridge_fragment(struct ifnet ifp, struct* mbuf m, struct* ether_header *eh,
5926	int snap, struct llc *llc)
5927	{
5928	struct mbuf *m0;
5929	struct ip *ip;
5930	int error = -`1`;
5931
5932	if (m->m_len < sizeof (struct ip) &&
5933	(m = m_pullup(m, sizeof (struct ip))) == NULL)
5934	goto out;
5935	ip = mtod(m, struct ip *);
5936
5937	error = ip_fragment(ip, &m, ifp->if_mtu, ifp->if_hwassist,
5938	CSUM_DELAY_IP);
5939	if (error)
5940	goto out;
5941
5942	/ walk the chain and re-add the Ethernet header /
5943	for (m0 = m; m0; m0 = m0->m_nextpkt) {
5944	if (error == `0`) {
5945	if (snap) {
5946	M_PREPEND(m0, sizeof (struct llc), M_DONTWAIT, `0`);
5947	if (m0 == NULL) {
5948	error = ENOBUFS;
5949	continue;
5950	}
5951	bcopy(llc, mtod(m0, caddr_t),
5952	sizeof (struct llc));
5953	}
5954	M_PREPEND(m0, ETHER_HDR_LEN, M_DONTWAIT, `0`);
5955	if (m0 == NULL) {
5956	error = ENOBUFS;
5957	continue;
5958	}
5959	bcopy(eh, mtod(m0, caddr_t), ETHER_HDR_LEN);
5960	} else {
5961	m_freem(m);
5962	}
5963	}
5964
5965	if (error == `0`)
5966	ipstat.ips_fragmented++;
5967
5968	return (error);
5969
5970	out:
5971	if (m != NULL)
5972	m_freem(m);
5973	return (error);
5974	}
5975	#endif /* PFIL_HOOKS */
5976
5977	/*
5978	* bridge_set_bpf_tap:
5979	*
5980	* Sets ups the BPF callbacks.
5981	*/
5982	static errno_t
5983	bridge_set_bpf_tap(ifnet_t ifp, bpf_tap_mode mode, bpf_packet_func bpf_callback)
5984	{
5985	struct bridge_softc sc = (struct* bridge_softc *)ifnet_softc(ifp);
5986
5987	/ TBD locking /
5988	if (sc == NULL \|\| (sc->sc_flags & SCF_DETACHING)) {
5989	return (ENODEV);
5990	}
5991	ASSERT(bridge_in_bsd_mode(sc));
5992	switch (mode) {
5993	case BPF_TAP_DISABLE:
5994	sc->sc_bpf_input = sc->sc_bpf_output = NULL;
5995	break;
5996
5997	case BPF_TAP_INPUT:
5998	sc->sc_bpf_input = bpf_callback;
5999	break;
6000
6001	case BPF_TAP_OUTPUT:
6002	sc->sc_bpf_output = bpf_callback;
6003	break;
6004
6005	case BPF_TAP_INPUT_OUTPUT:
6006	sc->sc_bpf_input = sc->sc_bpf_output = bpf_callback;
6007	break;
6008
6009	default:
6010	break;
6011	}
6012
6013	return (`0`);
6014	}
6015
6016	/*
6017	* bridge_detach:
6018	*
6019	* Callback when interface has been detached.
6020	*/
6021	static void
6022	bridge_detach(ifnet_t ifp)
6023	{
6024	struct bridge_softc sc = (struct* bridge_softc *)ifnet_softc(ifp);
6025
6026	#if BRIDGESTP
6027	bstp_detach(&sc->sc_stp);
6028	#endif /* BRIDGESTP */
6029
6030	if (bridge_in_bsd_mode(sc)) {
6031	/ Tear down the routing table. /
6032	bridge_rtable_fini(sc);
6033	}
6034
6035	lck_mtx_lock(&bridge_list_mtx);
6036	LIST_REMOVE(sc, sc_list);
6037	lck_mtx_unlock(&bridge_list_mtx);
6038
6039	ifnet_release(ifp);
6040
6041	lck_mtx_destroy(&sc->sc_mtx, bridge_lock_grp);
6042	if_clone_softc_deallocate(&bridge_cloner, sc);
6043	}
6044
6045	/*
6046	* bridge_bpf_input:
6047	*
6048	* Invoke the input BPF callback if enabled
6049	*/
6050	__private_extern__ errno_t
6051	bridge_bpf_input(ifnet_t ifp, struct mbuf *m)
6052	{
6053	struct bridge_softc sc = (struct* bridge_softc *)ifnet_softc(ifp);
6054
6055	ASSERT(bridge_in_bsd_mode(sc));
6056	if (sc->sc_bpf_input) {
6057	if (mbuf_pkthdr_rcvif(m) != ifp) {
6058	printf("%s: rcvif: 0x%llx != ifp 0x%llx\n", __func__,
6059	(uint64_t)VM_KERNEL_ADDRPERM(mbuf_pkthdr_rcvif(m)),
6060	(uint64_t)VM_KERNEL_ADDRPERM(ifp));
6061	}
6062	(*sc->sc_bpf_input)(ifp, m);
6063	}
6064	return (`0`);
6065	}
6066
6067	/*
6068	* bridge_bpf_output:
6069	*
6070	* Invoke the output BPF callback if enabled
6071	*/
6072	__private_extern__ errno_t
6073	bridge_bpf_output(ifnet_t ifp, struct mbuf *m)
6074	{
6075	struct bridge_softc sc = (struct* bridge_softc *)ifnet_softc(ifp);
6076
6077	ASSERT(bridge_in_bsd_mode(sc));
6078	if (sc->sc_bpf_output) {
6079	(*sc->sc_bpf_output)(ifp, m);
6080	}
6081	return (`0`);
6082	}
6083
6084	/*
6085	* bridge_link_event:
6086	*
6087	* Report a data link event on an interface
6088	*/
6089	static void
6090	bridge_link_event(struct ifnet *ifp, u_int32_t event_code)
6091	{
6092	struct {
6093	struct kern_event_msg header;
6094	u_int32_t unit;
6095	char if_name[IFNAMSIZ];
6096	} event;
6097
6098	#if BRIDGE_DEBUG
6099	if (if_bridge_debug & BR_DBGF_LIFECYCLE)
6100	printf("%s: %s event_code %u - %s\n", __func__, ifp->if_xname,
6101	event_code, dlil_kev_dl_code_str(event_code));
6102	#endif /* BRIDGE_DEBUG */
6103
6104	bzero(&event, sizeof (event));
6105	event.header.total_size = sizeof (event);
6106	event.header.vendor_code = KEV_VENDOR_APPLE;
6107	event.header.kev_class = KEV_NETWORK_CLASS;
6108	event.header.kev_subclass = KEV_DL_SUBCLASS;
6109	event.header.event_code = event_code;
6110	event.header.event_data[`0`] = ifnet_family(ifp);
6111	event.unit = (u_int32_t)ifnet_unit(ifp);
6112	strlcpy(event.if_name, ifnet_name(ifp), IFNAMSIZ);
6113	ifnet_event(ifp, &event.header);
6114	}
6115
6116	#define BRIDGE_HF_DROP(reason, func, line) { \
6117	bridge_hostfilter_stats.reason++; \
6118	if (if_bridge_debug & BR_DBGF_HOSTFILTER) \
6119	printf("%s.%d" #reason, func, line); \
6120	error = EINVAL; \
6121	}
6122
6123	/*
6124	* Make sure this is a DHCP or Bootp request that match the host filter
6125	*/
6126	static int
6127	bridge_dhcp_filter(struct bridge_iflist bif, struct* mbuf *m, size_t offset)
6128	{
6129	int error = EINVAL;
6130	struct dhcp dhcp;
6131
6132	/*
6133	* Note: We use the dhcp structure because bootp structure definition
6134	* is larger and some vendors do not pad the request
6135	*/
6136	error = mbuf_copydata(m, offset, sizeof(struct dhcp), &dhcp);
6137	if (error != `0`) {
6138	BRIDGE_HF_DROP(brhf_dhcp_too_small, __func__, __LINE__);
6139	goto done;
6140	}
6141	if (dhcp.dp_op != BOOTREQUEST) {
6142	BRIDGE_HF_DROP(brhf_dhcp_bad_op, __func__, __LINE__);
6143	goto done;
6144	}
6145	/*
6146	* The hardware address must be an exact match
6147	*/
6148	if (dhcp.dp_htype != ARPHRD_ETHER) {
6149	BRIDGE_HF_DROP(brhf_dhcp_bad_htype, __func__, __LINE__);
6150	goto done;
6151	}
6152	if (dhcp.dp_hlen != ETHER_ADDR_LEN) {
6153	BRIDGE_HF_DROP(brhf_dhcp_bad_hlen, __func__, __LINE__);
6154	goto done;
6155	}
6156	if (bcmp(dhcp.dp_chaddr, bif->bif_hf_hwsrc,
6157	ETHER_ADDR_LEN) != `0`) {
6158	BRIDGE_HF_DROP(brhf_dhcp_bad_chaddr, __func__, __LINE__);
6159	goto done;
6160	}
6161	/*
6162	* Client address must match the host address or be not specified
6163	*/
6164	if (dhcp.dp_ciaddr.s_addr != bif->bif_hf_ipsrc.s_addr &&
6165	dhcp.dp_ciaddr.s_addr != INADDR_ANY) {
6166	BRIDGE_HF_DROP(brhf_dhcp_bad_ciaddr, __func__, __LINE__);
6167	goto done;
6168	}
6169	error = `0`;
6170	done:
6171	return (error);
6172	}
6173
6174	static int
6175	bridge_host_filter(struct bridge_iflist bif, struct* mbuf *m)
6176	{
6177	int error = EINVAL;
6178	struct ether_header *eh;
6179	static struct in_addr inaddr_any = { .s_addr = INADDR_ANY };
6180
6181	/*
6182	* Check the Ethernet header is large enough
6183	*/
6184	if (mbuf_pkthdr_len(m) < sizeof(struct ether_header)) {
6185	BRIDGE_HF_DROP(brhf_ether_too_small, __func__, __LINE__);
6186	goto done;
6187	}
6188	if (mbuf_len(m) < sizeof(struct ether_header) &&
6189	mbuf_pullup(&m, sizeof(struct ether_header)) != `0`) {
6190	BRIDGE_HF_DROP(brhf_ether_pullup_failed, __func__, __LINE__);
6191	goto done;
6192	}
6193	eh = mtod(m, struct ether_header *);
6194
6195	/*
6196	* Restrict the source hardware address
6197	*/
6198	if ((bif->bif_flags & BIFF_HF_HWSRC) == `0` \|\|
6199	bcmp(eh->ether_shost, bif->bif_hf_hwsrc,
6200	ETHER_ADDR_LEN) != `0`) {
6201	BRIDGE_HF_DROP(brhf_bad_ether_srchw_addr, __func__, __LINE__);
6202	goto done;
6203	}
6204
6205	/*
6206	* Restrict Ethernet protocols to ARP and IP
6207	*/
6208	if (eh->ether_type == htons(ETHERTYPE_ARP)) {
6209	struct ether_arp *ea;
6210	size_t minlen = sizeof(struct ether_header) +
6211	sizeof(struct ether_arp);
6212
6213	/*
6214	* Make the Ethernet and ARP headers contiguous
6215	*/
6216	if (mbuf_pkthdr_len(m) < minlen) {
6217	BRIDGE_HF_DROP(brhf_arp_too_small, __func__, __LINE__);
6218	goto done;
6219	}
6220	if (mbuf_len(m) < minlen && mbuf_pullup(&m, minlen) != `0`) {
6221	BRIDGE_HF_DROP(brhf_arp_pullup_failed,
6222	__func__, __LINE__);
6223	goto done;
6224	}
6225	/*
6226	* Verify this is an ethernet/ip arp
6227	*/
6228	eh = mtod(m, struct ether_header *);
6229	ea = (struct ether_arp *)(eh + `1`);
6230	if (ea->arp_hrd != htons(ARPHRD_ETHER)) {
6231	BRIDGE_HF_DROP(brhf_arp_bad_hw_type,
6232	__func__, __LINE__);
6233	goto done;
6234	}
6235	if (ea->arp_pro != htons(ETHERTYPE_IP)) {
6236	BRIDGE_HF_DROP(brhf_arp_bad_pro_type,
6237	__func__, __LINE__);
6238	goto done;
6239	}
6240	/*
6241	* Verify the address lengths are correct
6242	*/
6243	if (ea->arp_hln != ETHER_ADDR_LEN) {
6244	BRIDGE_HF_DROP(brhf_arp_bad_hw_len, __func__, __LINE__);
6245	goto done;
6246	}
6247	if (ea->arp_pln != sizeof(struct in_addr)) {
6248	BRIDGE_HF_DROP(brhf_arp_bad_pro_len,
6249	__func__, __LINE__);
6250	goto done;
6251	}
6252
6253	/*
6254	* Allow only ARP request or ARP reply
6255	*/
6256	if (ea->arp_op != htons(ARPOP_REQUEST) &&
6257	ea->arp_op != htons(ARPOP_REPLY)) {
6258	BRIDGE_HF_DROP(brhf_arp_bad_op, __func__, __LINE__);
6259	goto done;
6260	}
6261	/*
6262	* Verify source hardware address matches
6263	*/
6264	if (bcmp(ea->arp_sha, bif->bif_hf_hwsrc,
6265	ETHER_ADDR_LEN) != `0`) {
6266	BRIDGE_HF_DROP(brhf_arp_bad_sha, __func__, __LINE__);
6267	goto done;
6268	}
6269	/*
6270	* Verify source protocol address:
6271	* May be null for an ARP probe
6272	*/
6273	if (bcmp(ea->arp_spa, &bif->bif_hf_ipsrc.s_addr,
6274	sizeof(struct in_addr)) != `0` &&
6275	bcmp(ea->arp_spa, &inaddr_any,
6276	sizeof(struct in_addr)) != `0`) {
6277	BRIDGE_HF_DROP(brhf_arp_bad_spa, __func__, __LINE__);
6278	goto done;
6279	}
6280	/*
6281	*
6282	*/
6283	bridge_hostfilter_stats.brhf_arp_ok += `1`;
6284	error = `0`;
6285	} else if (eh->ether_type == htons(ETHERTYPE_IP)) {
6286	size_t minlen = sizeof(struct ether_header) + sizeof(struct ip);
6287	struct ip iphdr;
6288	size_t offset;
6289
6290	/*
6291	* Make the Ethernet and IP headers contiguous
6292	*/
6293	if (mbuf_pkthdr_len(m) < minlen) {
6294	BRIDGE_HF_DROP(brhf_ip_too_small, __func__, __LINE__);
6295	goto done;
6296	}
6297	offset = sizeof(struct ether_header);
6298	error = mbuf_copydata(m, offset, sizeof(struct ip), &iphdr);
6299	if (error != `0`) {
6300	BRIDGE_HF_DROP(brhf_ip_too_small, __func__, __LINE__);
6301	goto done;
6302	}
6303	/*
6304	* Verify the source IP address
6305	*/
6306	if (iphdr.ip_p == IPPROTO_UDP) {
6307	struct udphdr udp;
6308
6309	minlen += sizeof(struct udphdr);
6310	if (mbuf_pkthdr_len(m) < minlen) {
6311	BRIDGE_HF_DROP(brhf_ip_too_small,
6312	__func__, __LINE__);
6313	goto done;
6314	}
6315
6316	/*
6317	* Allow all zero addresses for DHCP requests
6318	*/
6319	if (iphdr.ip_src.s_addr != bif->bif_hf_ipsrc.s_addr &&
6320	iphdr.ip_src.s_addr != INADDR_ANY) {
6321	BRIDGE_HF_DROP(brhf_ip_bad_srcaddr,
6322	__func__, __LINE__);
6323	goto done;
6324	}
6325	offset = sizeof(struct ether_header) +
6326	(IP_VHL_HL(iphdr.ip_vhl) << `2`);
6327	error = mbuf_copydata(m, offset,
6328	sizeof(struct udphdr), &udp);
6329	if (error != `0`) {
6330	BRIDGE_HF_DROP(brhf_ip_too_small,
6331	__func__, __LINE__);
6332	goto done;
6333	}
6334	/*
6335	* Either it's a Bootp/DHCP packet that we like or
6336	* it's a UDP packet from the host IP as source address
6337	*/
6338	if (udp.uh_sport == htons(IPPORT_BOOTPC) &&
6339	udp.uh_dport == htons(IPPORT_BOOTPS)) {
6340	minlen += sizeof(struct dhcp);
6341	if (mbuf_pkthdr_len(m) < minlen) {
6342	BRIDGE_HF_DROP(brhf_ip_too_small,
6343	__func__, __LINE__);
6344	goto done;
6345	}
6346	offset += sizeof(struct udphdr);
6347	error = bridge_dhcp_filter(bif, m, offset);
6348	if (error != `0`)
6349	goto done;
6350	} else if (iphdr.ip_src.s_addr == INADDR_ANY) {
6351	BRIDGE_HF_DROP(brhf_ip_bad_srcaddr,
6352	__func__, __LINE__);
6353	goto done;
6354	}
6355	} else if (iphdr.ip_src.s_addr != bif->bif_hf_ipsrc.s_addr \|\|
6356	bif->bif_hf_ipsrc.s_addr == INADDR_ANY) {
6357
6358	BRIDGE_HF_DROP(brhf_ip_bad_srcaddr, __func__, __LINE__);
6359	goto done;
6360	}
6361	/*
6362	* Allow only boring IP protocols
6363	*/
6364	if (iphdr.ip_p != IPPROTO_TCP &&
6365	iphdr.ip_p != IPPROTO_UDP &&
6366	iphdr.ip_p != IPPROTO_ICMP &&
6367	iphdr.ip_p != IPPROTO_ESP &&
6368	iphdr.ip_p != IPPROTO_AH &&
6369	iphdr.ip_p != IPPROTO_GRE) {
6370	BRIDGE_HF_DROP(brhf_ip_bad_proto, __func__, __LINE__);
6371	goto done;
6372	}
6373	bridge_hostfilter_stats.brhf_ip_ok += `1`;
6374	error = `0`;
6375	} else {
6376	BRIDGE_HF_DROP(brhf_bad_ether_type, __func__, __LINE__);
6377	goto done;
6378	}
6379	done:
6380	if (error != `0`) {
6381	if (if_bridge_debug & BR_DBGF_HOSTFILTER) {
6382	if (m) {
6383	printf_mbuf_data(m, `0`,
6384	sizeof(struct ether_header) +
6385	sizeof(struct ip));
6386	}
6387	printf("\n");
6388	}
6389
6390	if (m != NULL)
6391	m_freem(m);
6392	}
6393	return (error);
6394	}
6395
6396
6397

Browse the source code of codebrowser/bsd/net/if_bridge.c