source: S-port/trunk/Middlewares/Third_Party/LwIP/src/netif/bridgeif.c

Last change on this file was 1, checked in by AlexLir, 3 years ago
File size: 19.4 KB
Line 
1/**
2 * @file
3 * lwIP netif implementing an IEEE 802.1D MAC Bridge
4 */
5
6/*
7 * Copyright (c) 2017 Simon Goldschmidt.
8 * All rights reserved.
9 *
10 * Redistribution and use in source and binary forms, with or without modification,
11 * are permitted provided that the following conditions are met:
12 *
13 * 1. Redistributions of source code must retain the above copyright notice,
14 * this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright notice,
16 * this list of conditions and the following disclaimer in the documentation
17 * and/or other materials provided with the distribution.
18 * 3. The name of the author may not be used to endorse or promote products
19 * derived from this software without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
22 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
23 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
24 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
26 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
29 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
30 * OF SUCH DAMAGE.
31 *
32 * This file is part of the lwIP TCP/IP stack.
33 *
34 * Author: Simon Goldschmidt <goldsimon@gmx.de>
35 *
36 */
37
38/**
39 * @defgroup bridgeif IEEE 802.1D bridge
40 * @ingroup netifs
41 * This file implements an IEEE 802.1D bridge by using a multilayer netif approach
42 * (one hardware-independent netif for the bridge that uses hardware netifs for its ports).
43 * On transmit, the bridge selects the outgoing port(s).
44 * On receive, the port netif calls into the bridge (via its netif->input function) and
45 * the bridge selects the port(s) (and/or its netif->input function) to pass the received pbuf to.
46 *
47 * Usage:
48 * - add the port netifs just like you would when using them as dedicated netif without a bridge
49 * - only NETIF_FLAG_ETHARP/NETIF_FLAG_ETHERNET netifs are supported as bridge ports
50 * - add the bridge port netifs without IPv4 addresses (i.e. pass 'NULL, NULL, NULL')
51 * - don't add IPv6 addresses to the port netifs!
52 * - set up the bridge configuration in a global variable of type 'bridgeif_initdata_t' that contains
53 * - the MAC address of the bridge
54 * - some configuration options controlling the memory consumption (maximum number of ports
55 * and FDB entries)
56 * - e.g. for a bridge MAC address 00-01-02-03-04-05, 2 bridge ports, 1024 FDB entries + 16 static MAC entries:
57 * bridgeif_initdata_t mybridge_initdata = BRIDGEIF_INITDATA1(2, 1024, 16, ETH_ADDR(0, 1, 2, 3, 4, 5));
58 * - add the bridge netif (with IPv4 config):
59 * struct netif bridge_netif;
60 * netif_add(&bridge_netif, &my_ip, &my_netmask, &my_gw, &mybridge_initdata, bridgeif_init, tcpip_input);
61 * NOTE: the passed 'input' function depends on BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT setting,
62 * which controls where the forwarding is done (netif low level input context vs. tcpip_thread)
63 * - set up all ports netifs and the bridge netif
64 *
65 * - When adding a port netif, NETIF_FLAG_ETHARP flag will be removed from a port
66 * to prevent ETHARP working on that port netif (we only want one IP per bridge not per port).
67 * - When adding a port netif, its input function is changed to call into the bridge.
68 *
69 *
70 * @todo:
71 * - compact static FDB entries (instead of walking the whole array)
72 * - add FDB query/read access
73 * - add FDB change callback (when learning or dropping auto-learned entries)
74 * - prefill FDB with MAC classes that should never be forwarded
75 * - multicast snooping? (and only forward group addresses to interested ports)
76 * - support removing ports
77 * - check SNMP integration
78 * - VLAN handling / trunk ports
79 * - priority handling? (although that largely depends on TX queue limitations and lwIP doesn't provide tx-done handling)
80 */
81
82#include "netif/bridgeif.h"
83#include "lwip/netif.h"
84#include "lwip/sys.h"
85#include "lwip/etharp.h"
86#include "lwip/ethip6.h"
87#include "lwip/snmp.h"
88#include "lwip/timeouts.h"
89#include <string.h>
90
91#if LWIP_NUM_NETIF_CLIENT_DATA
92
93/* Define those to better describe your network interface. */
94#define IFNAME0 'b'
95#define IFNAME1 'r'
96
97struct bridgeif_private_s;
98typedef struct bridgeif_port_private_s {
99 struct bridgeif_private_s *bridge;
100 struct netif *port_netif;
101 u8_t port_num;
102} bridgeif_port_t;
103
104typedef struct bridgeif_fdb_static_entry_s {
105 u8_t used;
106 bridgeif_portmask_t dst_ports;
107 struct eth_addr addr;
108} bridgeif_fdb_static_entry_t;
109
110typedef struct bridgeif_private_s {
111 struct netif *netif;
112 struct eth_addr ethaddr;
113 u8_t max_ports;
114 u8_t num_ports;
115 bridgeif_port_t *ports;
116 u16_t max_fdbs_entries;
117 bridgeif_fdb_static_entry_t *fdbs;
118 u16_t max_fdbd_entries;
119 void *fdbd;
120} bridgeif_private_t;
121
122/* netif data index to get the bridge on input */
123u8_t bridgeif_netif_client_id = 0xff;
124
125/**
126 * @ingroup bridgeif
127 * Add a static entry to the forwarding database.
128 * A static entry marks where frames to a specific eth address (unicast or group address) are
129 * forwarded.
130 * bits [0..(BRIDGEIF_MAX_PORTS-1)]: hw ports
131 * bit [BRIDGEIF_MAX_PORTS]: cpu port
132 * 0: drop
133 */
134err_t
135bridgeif_fdb_add(struct netif *bridgeif, const struct eth_addr *addr, bridgeif_portmask_t ports)
136{
137 int i;
138 bridgeif_private_t *br;
139 BRIDGEIF_DECL_PROTECT(lev);
140 LWIP_ASSERT("invalid netif", bridgeif != NULL);
141 br = (bridgeif_private_t *)bridgeif->state;
142 LWIP_ASSERT("invalid state", br != NULL);
143
144 BRIDGEIF_READ_PROTECT(lev);
145 for (i = 0; i < br->max_fdbs_entries; i++) {
146 if (!br->fdbs[i].used) {
147 BRIDGEIF_WRITE_PROTECT(lev);
148 if (!br->fdbs[i].used) {
149 br->fdbs[i].used = 1;
150 br->fdbs[i].dst_ports = ports;
151 memcpy(&br->fdbs[i].addr, addr, sizeof(struct eth_addr));
152 BRIDGEIF_WRITE_UNPROTECT(lev);
153 BRIDGEIF_READ_UNPROTECT(lev);
154 return ERR_OK;
155 }
156 BRIDGEIF_WRITE_UNPROTECT(lev);
157 }
158 }
159 BRIDGEIF_READ_UNPROTECT(lev);
160 return ERR_MEM;
161}
162
163/**
164 * @ingroup bridgeif
165 * Remove a static entry from the forwarding database
166 */
167err_t
168bridgeif_fdb_remove(struct netif *bridgeif, const struct eth_addr *addr)
169{
170 int i;
171 bridgeif_private_t *br;
172 BRIDGEIF_DECL_PROTECT(lev);
173 LWIP_ASSERT("invalid netif", bridgeif != NULL);
174 br = (bridgeif_private_t *)bridgeif->state;
175 LWIP_ASSERT("invalid state", br != NULL);
176
177 BRIDGEIF_READ_PROTECT(lev);
178 for (i = 0; i < br->max_fdbs_entries; i++) {
179 if (br->fdbs[i].used && !memcmp(&br->fdbs[i].addr, addr, sizeof(struct eth_addr))) {
180 BRIDGEIF_WRITE_PROTECT(lev);
181 if (br->fdbs[i].used && !memcmp(&br->fdbs[i].addr, addr, sizeof(struct eth_addr))) {
182 memset(&br->fdbs[i], 0, sizeof(bridgeif_fdb_static_entry_t));
183 BRIDGEIF_WRITE_UNPROTECT(lev);
184 BRIDGEIF_READ_UNPROTECT(lev);
185 return ERR_OK;
186 }
187 BRIDGEIF_WRITE_UNPROTECT(lev);
188 }
189 }
190 BRIDGEIF_READ_UNPROTECT(lev);
191 return ERR_VAL;
192}
193
194/** Get the forwarding port(s) (as bit mask) for the specified destination mac address */
195static bridgeif_portmask_t
196bridgeif_find_dst_ports(bridgeif_private_t *br, struct eth_addr *dst_addr)
197{
198 int i;
199 BRIDGEIF_DECL_PROTECT(lev);
200 BRIDGEIF_READ_PROTECT(lev);
201 /* first check for static entries */
202 for (i = 0; i < br->max_fdbs_entries; i++) {
203 if (br->fdbs[i].used) {
204 if (!memcmp(&br->fdbs[i].addr, dst_addr, sizeof(struct eth_addr))) {
205 bridgeif_portmask_t ret = br->fdbs[i].dst_ports;
206 BRIDGEIF_READ_UNPROTECT(lev);
207 return ret;
208 }
209 }
210 }
211 if (dst_addr->addr[0] & 1) {
212 /* no match found: flood remaining group address */
213 BRIDGEIF_READ_UNPROTECT(lev);
214 return BR_FLOOD;
215 }
216 BRIDGEIF_READ_UNPROTECT(lev);
217 /* no match found: check dynamic fdb for port or fall back to flooding */
218 return bridgeif_fdb_get_dst_ports(br->fdbd, dst_addr);
219}
220
221/** Helper function to see if a destination mac belongs to the bridge
222 * (bridge netif or one of the port netifs), in which case the frame
223 * is sent to the cpu only.
224 */
225static int
226bridgeif_is_local_mac(bridgeif_private_t *br, struct eth_addr *addr)
227{
228 int i;
229 BRIDGEIF_DECL_PROTECT(lev);
230 if (!memcmp(br->netif->hwaddr, addr, sizeof(struct eth_addr))) {
231 return 1;
232 }
233 BRIDGEIF_READ_PROTECT(lev);
234 for (i = 0; i < br->num_ports; i++) {
235 struct netif *portif = br->ports[i].port_netif;
236 if (portif != NULL) {
237 if (!memcmp(portif->hwaddr, addr, sizeof(struct eth_addr))) {
238 BRIDGEIF_READ_UNPROTECT(lev);
239 return 1;
240 }
241 }
242 }
243 BRIDGEIF_READ_UNPROTECT(lev);
244 return 0;
245}
246
247/* Output helper function */
248static err_t
249bridgeif_send_to_port(bridgeif_private_t *br, struct pbuf *p, u8_t dstport_idx)
250{
251 if (dstport_idx < BRIDGEIF_MAX_PORTS) {
252 /* possibly an external port */
253 if (dstport_idx < br->max_ports) {
254 struct netif *portif = br->ports[dstport_idx].port_netif;
255 if ((portif != NULL) && (portif->linkoutput != NULL)) {
256 /* prevent sending out to rx port */
257 if (netif_get_index(portif) != p->if_idx) {
258 if (netif_is_link_up(portif)) {
259 LWIP_DEBUGF(BRIDGEIF_FW_DEBUG, ("br -> flood(%p:%d) -> %d\n", (void *)p, p->if_idx, netif_get_index(portif)));
260 return portif->linkoutput(portif, p);
261 }
262 }
263 }
264 }
265 } else {
266 LWIP_ASSERT("invalid port index", dstport_idx == BRIDGEIF_MAX_PORTS);
267 }
268 return ERR_OK;
269}
270
271/** Helper function to pass a pbuf to all ports marked in 'dstports'
272 */
273static err_t
274bridgeif_send_to_ports(bridgeif_private_t *br, struct pbuf *p, bridgeif_portmask_t dstports)
275{
276 err_t err, ret_err = ERR_OK;
277 u8_t i;
278 bridgeif_portmask_t mask = 1;
279 BRIDGEIF_DECL_PROTECT(lev);
280 BRIDGEIF_READ_PROTECT(lev);
281 for (i = 0; i < BRIDGEIF_MAX_PORTS; i++, mask = (bridgeif_portmask_t)(mask << 1)) {
282 if (dstports & mask) {
283 err = bridgeif_send_to_port(br, p, i);
284 if (err != ERR_OK) {
285 ret_err = err;
286 }
287 }
288 }
289 BRIDGEIF_READ_UNPROTECT(lev);
290 return ret_err;
291}
292
293/** Output function of the application port of the bridge (the one with an ip address).
294 * The forwarding port(s) where this pbuf is sent on is/are automatically selected
295 * from the FDB.
296 */
297static err_t
298bridgeif_output(struct netif *netif, struct pbuf *p)
299{
300 err_t err;
301 bridgeif_private_t *br = (bridgeif_private_t *)netif->state;
302 struct eth_addr *dst = (struct eth_addr *)(p->payload);
303
304 bridgeif_portmask_t dstports = bridgeif_find_dst_ports(br, dst);
305 err = bridgeif_send_to_ports(br, p, dstports);
306
307 MIB2_STATS_NETIF_ADD(netif, ifoutoctets, p->tot_len);
308 if (((u8_t *)p->payload)[0] & 1) {
309 /* broadcast or multicast packet*/
310 MIB2_STATS_NETIF_INC(netif, ifoutnucastpkts);
311 } else {
312 /* unicast packet */
313 MIB2_STATS_NETIF_INC(netif, ifoutucastpkts);
314 }
315 /* increase ifoutdiscards or ifouterrors on error */
316
317 LINK_STATS_INC(link.xmit);
318
319 return err;
320}
321
322/** The actual bridge input function. Port netif's input is changed to call
323 * here. This function decides where the frame is forwarded.
324 */
325static err_t
326bridgeif_input(struct pbuf *p, struct netif *netif)
327{
328 u8_t rx_idx;
329 bridgeif_portmask_t dstports;
330 struct eth_addr *src, *dst;
331 bridgeif_private_t *br;
332 bridgeif_port_t *port;
333 if (p == NULL || netif == NULL) {
334 return ERR_VAL;
335 }
336 port = (bridgeif_port_t *)netif_get_client_data(netif, bridgeif_netif_client_id);
337 LWIP_ASSERT("port data not set", port != NULL);
338 if (port == NULL || port->bridge == NULL) {
339 return ERR_VAL;
340 }
341 br = (bridgeif_private_t *)port->bridge;
342 rx_idx = netif_get_index(netif);
343 /* store receive index in pbuf */
344 p->if_idx = rx_idx;
345
346 dst = (struct eth_addr *)p->payload;
347 src = (struct eth_addr *)(((u8_t *)p->payload) + sizeof(struct eth_addr));
348
349 if ((src->addr[0] & 1) == 0) {
350 /* update src for all non-group addresses */
351 bridgeif_fdb_update_src(br->fdbd, src, port->port_num);
352 }
353
354 if (dst->addr[0] & 1) {
355 /* group address -> flood + cpu? */
356 dstports = bridgeif_find_dst_ports(br, dst);
357 bridgeif_send_to_ports(br, p, dstports);
358 if (dstports & (1 << BRIDGEIF_MAX_PORTS)) {
359 /* we pass the reference to ->input or have to free it */
360 LWIP_DEBUGF(BRIDGEIF_FW_DEBUG, ("br -> input(%p)\n", (void *)p));
361 if (br->netif->input(p, br->netif) != ERR_OK) {
362 pbuf_free(p);
363 }
364 } else {
365 /* all references done */
366 pbuf_free(p);
367 }
368 /* always return ERR_OK here to prevent the caller freeing the pbuf */
369 return ERR_OK;
370 } else {
371 /* is this for one of the local ports? */
372 if (bridgeif_is_local_mac(br, dst)) {
373 /* yes, send to cpu port only */
374 LWIP_DEBUGF(BRIDGEIF_FW_DEBUG, ("br -> input(%p)\n", (void *)p));
375 return br->netif->input(p, br->netif);
376 }
377
378 /* get dst port */
379 dstports = bridgeif_find_dst_ports(br, dst);
380 bridgeif_send_to_ports(br, p, dstports);
381 /* no need to send to cpu, flooding is for external ports only */
382 /* by this, we consumed the pbuf */
383 pbuf_free(p);
384 /* always return ERR_OK here to prevent the caller freeing the pbuf */
385 return ERR_OK;
386 }
387}
388
389#if !BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT
390/** Input function for port netifs used to synchronize into tcpip_thread.
391 */
392static err_t
393bridgeif_tcpip_input(struct pbuf *p, struct netif *netif)
394{
395 return tcpip_inpkt(p, netif, bridgeif_input);
396}
397#endif /* BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT */
398
399/**
400 * @ingroup bridgeif
401 * Initialization function passed to netif_add().
402 *
403 * ATTENTION: A pointer to a @ref bridgeif_initdata_t must be passed as 'state'
404 * to @ref netif_add when adding the bridge. I supplies MAC address
405 * and controls memory allocation (number of ports, FDB size).
406 *
407 * @param netif the lwip network interface structure for this ethernetif
408 * @return ERR_OK if the loopif is initialized
409 * ERR_MEM if private data couldn't be allocated
410 * any other err_t on error
411 */
412err_t
413bridgeif_init(struct netif *netif)
414{
415 bridgeif_initdata_t *init_data;
416 bridgeif_private_t *br;
417 size_t alloc_len_sizet;
418 mem_size_t alloc_len;
419
420 LWIP_ASSERT("netif != NULL", (netif != NULL));
421 LWIP_ASSERT("bridgeif needs an input callback", (netif->input != NULL));
422#if !BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT
423 if (netif->input == tcpip_input) {
424 LWIP_DEBUGF(BRIDGEIF_DEBUG | LWIP_DBG_ON, ("bridgeif does not need tcpip_input, use netif_input/ethernet_input instead"));
425 }
426#endif
427
428 if (bridgeif_netif_client_id == 0xFF) {
429 bridgeif_netif_client_id = netif_alloc_client_data_id();
430 }
431
432 init_data = (bridgeif_initdata_t *)netif->state;
433 LWIP_ASSERT("init_data != NULL", (init_data != NULL));
434 LWIP_ASSERT("init_data->max_ports <= BRIDGEIF_MAX_PORTS",
435 init_data->max_ports <= BRIDGEIF_MAX_PORTS);
436
437 alloc_len_sizet = sizeof(bridgeif_private_t) + (init_data->max_ports * sizeof(bridgeif_port_t) + (init_data->max_fdb_static_entries * sizeof(bridgeif_fdb_static_entry_t)));
438 alloc_len = (mem_size_t)alloc_len_sizet;
439 LWIP_ASSERT("alloc_len == alloc_len_sizet", alloc_len == alloc_len_sizet);
440 LWIP_DEBUGF(BRIDGEIF_DEBUG, ("bridgeif_init: allocating %d bytes for private data\n", (int)alloc_len));
441 br = (bridgeif_private_t *)mem_calloc(1, alloc_len);
442 if (br == NULL) {
443 LWIP_DEBUGF(NETIF_DEBUG, ("bridgeif_init: out of memory\n"));
444 return ERR_MEM;
445 }
446 memcpy(&br->ethaddr, &init_data->ethaddr, sizeof(br->ethaddr));
447 br->netif = netif;
448
449 br->max_ports = init_data->max_ports;
450 br->ports = (bridgeif_port_t *)(br + 1);
451
452 br->max_fdbs_entries = init_data->max_fdb_static_entries;
453 br->fdbs = (bridgeif_fdb_static_entry_t *)(((u8_t *)(br + 1)) + (init_data->max_ports * sizeof(bridgeif_port_t)));
454
455 br->max_fdbd_entries = init_data->max_fdb_dynamic_entries;
456 br->fdbd = bridgeif_fdb_init(init_data->max_fdb_dynamic_entries);
457 if (br->fdbd == NULL) {
458 LWIP_DEBUGF(NETIF_DEBUG, ("bridgeif_init: out of memory in fdb_init\n"));
459 mem_free(br);
460 return ERR_MEM;
461 }
462
463#if LWIP_NETIF_HOSTNAME
464 /* Initialize interface hostname */
465 netif->hostname = "lwip";
466#endif /* LWIP_NETIF_HOSTNAME */
467
468 /*
469 * Initialize the snmp variables and counters inside the struct netif.
470 * The last argument should be replaced with your link speed, in units
471 * of bits per second.
472 */
473 MIB2_INIT_NETIF(netif, snmp_ifType_ethernet_csmacd, 0);
474
475 netif->state = br;
476 netif->name[0] = IFNAME0;
477 netif->name[1] = IFNAME1;
478 /* We directly use etharp_output() here to save a function call.
479 * You can instead declare your own function an call etharp_output()
480 * from it if you have to do some checks before sending (e.g. if link
481 * is available...) */
482#if LWIP_IPV4
483 netif->output = etharp_output;
484#endif /* LWIP_IPV4 */
485#if LWIP_IPV6
486 netif->output_ip6 = ethip6_output;
487#endif /* LWIP_IPV6 */
488 netif->linkoutput = bridgeif_output;
489
490 /* set MAC hardware address length */
491 netif->hwaddr_len = ETH_HWADDR_LEN;
492
493 /* set MAC hardware address */
494 memcpy(netif->hwaddr, &br->ethaddr, ETH_HWADDR_LEN);
495
496 /* maximum transfer unit */
497 netif->mtu = 1500;
498
499 /* device capabilities */
500 /* don't set NETIF_FLAG_ETHARP if this device is not an ethernet one */
501 netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET | NETIF_FLAG_IGMP | NETIF_FLAG_MLD6 | NETIF_FLAG_LINK_UP;
502
503#if LWIP_IPV6 && LWIP_IPV6_MLD
504 /*
505 * For hardware/netifs that implement MAC filtering.
506 * All-nodes link-local is handled by default, so we must let the hardware know
507 * to allow multicast packets in.
508 * Should set mld_mac_filter previously. */
509 if (netif->mld_mac_filter != NULL) {
510 ip6_addr_t ip6_allnodes_ll;
511 ip6_addr_set_allnodes_linklocal(&ip6_allnodes_ll);
512 netif->mld_mac_filter(netif, &ip6_allnodes_ll, NETIF_ADD_MAC_FILTER);
513 }
514#endif /* LWIP_IPV6 && LWIP_IPV6_MLD */
515
516 return ERR_OK;
517}
518
519/**
520 * @ingroup bridgeif
521 * Add a port to the bridge
522 */
523err_t
524bridgeif_add_port(struct netif *bridgeif, struct netif *portif)
525{
526 bridgeif_private_t *br;
527 bridgeif_port_t *port;
528
529 LWIP_ASSERT("bridgeif != NULL", bridgeif != NULL);
530 LWIP_ASSERT("bridgeif->state != NULL", bridgeif->state != NULL);
531 LWIP_ASSERT("portif != NULL", portif != NULL);
532
533 if (!(portif->flags & NETIF_FLAG_ETHARP) || !(portif->flags & NETIF_FLAG_ETHERNET)) {
534 /* can only add ETHERNET/ETHARP interfaces */
535 return ERR_VAL;
536 }
537
538 br = (bridgeif_private_t *)bridgeif->state;
539
540 if (br->num_ports >= br->max_ports) {
541 return ERR_VAL;
542 }
543 port = &br->ports[br->num_ports];
544 port->port_netif = portif;
545 port->port_num = br->num_ports;
546 port->bridge = br;
547 br->num_ports++;
548
549 /* let the port call us on input */
550#if BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT
551 portif->input = bridgeif_input;
552#else
553 portif->input = bridgeif_tcpip_input;
554#endif
555 /* store pointer to bridge in netif */
556 netif_set_client_data(portif, bridgeif_netif_client_id, port);
557 /* remove ETHARP flag to prevent sending report events on netif-up */
558 netif_clear_flags(portif, NETIF_FLAG_ETHARP);
559
560 return ERR_OK;
561}
562
563#endif /* LWIP_NUM_NETIF_CLIENT_DATA */
Note: See TracBrowser for help on using the repository browser.