Version:  2.0.40 2.2.26 2.4.37 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8

Linux/net/bridge/br_forward.c

  1 /*
  2  *      Forwarding decision
  3  *      Linux ethernet bridge
  4  *
  5  *      Authors:
  6  *      Lennert Buytenhek               <buytenh@gnu.org>
  7  *
  8  *      This program is free software; you can redistribute it and/or
  9  *      modify it under the terms of the GNU General Public License
 10  *      as published by the Free Software Foundation; either version
 11  *      2 of the License, or (at your option) any later version.
 12  */
 13 
 14 #include <linux/err.h>
 15 #include <linux/slab.h>
 16 #include <linux/kernel.h>
 17 #include <linux/netdevice.h>
 18 #include <linux/netpoll.h>
 19 #include <linux/skbuff.h>
 20 #include <linux/if_vlan.h>
 21 #include <linux/netfilter_bridge.h>
 22 #include "br_private.h"
 23 
 24 /* Don't forward packets to originating port or forwarding disabled */
 25 static inline int should_deliver(const struct net_bridge_port *p,
 26                                  const struct sk_buff *skb)
 27 {
 28         struct net_bridge_vlan_group *vg;
 29 
 30         vg = nbp_vlan_group_rcu(p);
 31         return ((p->flags & BR_HAIRPIN_MODE) || skb->dev != p->dev) &&
 32                 br_allowed_egress(vg, skb) && p->state == BR_STATE_FORWARDING;
 33 }
 34 
 35 int br_dev_queue_push_xmit(struct net *net, struct sock *sk, struct sk_buff *skb)
 36 {
 37         if (!is_skb_forwardable(skb->dev, skb))
 38                 goto drop;
 39 
 40         skb_push(skb, ETH_HLEN);
 41         br_drop_fake_rtable(skb);
 42 
 43         if (skb->ip_summed == CHECKSUM_PARTIAL &&
 44             (skb->protocol == htons(ETH_P_8021Q) ||
 45              skb->protocol == htons(ETH_P_8021AD))) {
 46                 int depth;
 47 
 48                 if (!__vlan_get_protocol(skb, skb->protocol, &depth))
 49                         goto drop;
 50 
 51                 skb_set_network_header(skb, depth);
 52         }
 53 
 54         dev_queue_xmit(skb);
 55 
 56         return 0;
 57 
 58 drop:
 59         kfree_skb(skb);
 60         return 0;
 61 }
 62 EXPORT_SYMBOL_GPL(br_dev_queue_push_xmit);
 63 
 64 int br_forward_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
 65 {
 66         return NF_HOOK(NFPROTO_BRIDGE, NF_BR_POST_ROUTING,
 67                        net, sk, skb, NULL, skb->dev,
 68                        br_dev_queue_push_xmit);
 69 
 70 }
 71 EXPORT_SYMBOL_GPL(br_forward_finish);
 72 
 73 static void __br_forward(const struct net_bridge_port *to,
 74                          struct sk_buff *skb, bool local_orig)
 75 {
 76         struct net_bridge_vlan_group *vg;
 77         struct net_device *indev;
 78         struct net *net;
 79         int br_hook;
 80 
 81         vg = nbp_vlan_group_rcu(to);
 82         skb = br_handle_vlan(to->br, vg, skb);
 83         if (!skb)
 84                 return;
 85 
 86         indev = skb->dev;
 87         skb->dev = to->dev;
 88         if (!local_orig) {
 89                 if (skb_warn_if_lro(skb)) {
 90                         kfree_skb(skb);
 91                         return;
 92                 }
 93                 br_hook = NF_BR_FORWARD;
 94                 skb_forward_csum(skb);
 95                 net = dev_net(indev);
 96         } else {
 97                 if (unlikely(netpoll_tx_running(to->br->dev))) {
 98                         if (!is_skb_forwardable(skb->dev, skb)) {
 99                                 kfree_skb(skb);
100                         } else {
101                                 skb_push(skb, ETH_HLEN);
102                                 br_netpoll_send_skb(to, skb);
103                         }
104                         return;
105                 }
106                 br_hook = NF_BR_LOCAL_OUT;
107                 net = dev_net(skb->dev);
108                 indev = NULL;
109         }
110 
111         NF_HOOK(NFPROTO_BRIDGE, br_hook,
112                 net, NULL, skb, indev, skb->dev,
113                 br_forward_finish);
114 }
115 
116 static int deliver_clone(const struct net_bridge_port *prev,
117                          struct sk_buff *skb, bool local_orig)
118 {
119         struct net_device *dev = BR_INPUT_SKB_CB(skb)->brdev;
120 
121         skb = skb_clone(skb, GFP_ATOMIC);
122         if (!skb) {
123                 dev->stats.tx_dropped++;
124                 return -ENOMEM;
125         }
126 
127         __br_forward(prev, skb, local_orig);
128         return 0;
129 }
130 
131 /**
132  * br_forward - forward a packet to a specific port
133  * @to: destination port
134  * @skb: packet being forwarded
135  * @local_rcv: packet will be received locally after forwarding
136  * @local_orig: packet is locally originated
137  *
138  * Should be called with rcu_read_lock.
139  */
140 void br_forward(const struct net_bridge_port *to,
141                 struct sk_buff *skb, bool local_rcv, bool local_orig)
142 {
143         if (to && should_deliver(to, skb)) {
144                 if (local_rcv)
145                         deliver_clone(to, skb, local_orig);
146                 else
147                         __br_forward(to, skb, local_orig);
148                 return;
149         }
150 
151         if (!local_rcv)
152                 kfree_skb(skb);
153 }
154 EXPORT_SYMBOL_GPL(br_forward);
155 
156 static struct net_bridge_port *maybe_deliver(
157         struct net_bridge_port *prev, struct net_bridge_port *p,
158         struct sk_buff *skb, bool local_orig)
159 {
160         int err;
161 
162         if (!should_deliver(p, skb))
163                 return prev;
164 
165         if (!prev)
166                 goto out;
167 
168         err = deliver_clone(prev, skb, local_orig);
169         if (err)
170                 return ERR_PTR(err);
171 
172 out:
173         return p;
174 }
175 
176 /* called under rcu_read_lock */
177 void br_flood(struct net_bridge *br, struct sk_buff *skb,
178               bool unicast, bool local_rcv, bool local_orig)
179 {
180         u8 igmp_type = br_multicast_igmp_type(skb);
181         struct net_bridge_port *prev = NULL;
182         struct net_bridge_port *p;
183 
184         list_for_each_entry_rcu(p, &br->port_list, list) {
185                 /* Do not flood unicast traffic to ports that turn it off */
186                 if (unicast && !(p->flags & BR_FLOOD))
187                         continue;
188 
189                 /* Do not flood to ports that enable proxy ARP */
190                 if (p->flags & BR_PROXYARP)
191                         continue;
192                 if ((p->flags & BR_PROXYARP_WIFI) &&
193                     BR_INPUT_SKB_CB(skb)->proxyarp_replied)
194                         continue;
195 
196                 prev = maybe_deliver(prev, p, skb, local_orig);
197                 if (IS_ERR(prev))
198                         goto out;
199                 if (prev == p)
200                         br_multicast_count(p->br, p, skb, igmp_type,
201                                            BR_MCAST_DIR_TX);
202         }
203 
204         if (!prev)
205                 goto out;
206 
207         if (local_rcv)
208                 deliver_clone(prev, skb, local_orig);
209         else
210                 __br_forward(prev, skb, local_orig);
211         return;
212 
213 out:
214         if (!local_rcv)
215                 kfree_skb(skb);
216 }
217 
218 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
219 /* called with rcu_read_lock */
220 void br_multicast_flood(struct net_bridge_mdb_entry *mdst,
221                         struct sk_buff *skb,
222                         bool local_rcv, bool local_orig)
223 {
224         struct net_device *dev = BR_INPUT_SKB_CB(skb)->brdev;
225         u8 igmp_type = br_multicast_igmp_type(skb);
226         struct net_bridge *br = netdev_priv(dev);
227         struct net_bridge_port *prev = NULL;
228         struct net_bridge_port_group *p;
229         struct hlist_node *rp;
230 
231         rp = rcu_dereference(hlist_first_rcu(&br->router_list));
232         p = mdst ? rcu_dereference(mdst->ports) : NULL;
233         while (p || rp) {
234                 struct net_bridge_port *port, *lport, *rport;
235 
236                 lport = p ? p->port : NULL;
237                 rport = rp ? hlist_entry(rp, struct net_bridge_port, rlist) :
238                              NULL;
239 
240                 port = (unsigned long)lport > (unsigned long)rport ?
241                        lport : rport;
242 
243                 prev = maybe_deliver(prev, port, skb, local_orig);
244                 if (IS_ERR(prev))
245                         goto out;
246                 if (prev == port)
247                         br_multicast_count(port->br, port, skb, igmp_type,
248                                            BR_MCAST_DIR_TX);
249 
250                 if ((unsigned long)lport >= (unsigned long)port)
251                         p = rcu_dereference(p->next);
252                 if ((unsigned long)rport >= (unsigned long)port)
253                         rp = rcu_dereference(hlist_next_rcu(rp));
254         }
255 
256         if (!prev)
257                 goto out;
258 
259         if (local_rcv)
260                 deliver_clone(prev, skb, local_orig);
261         else
262                 __br_forward(prev, skb, local_orig);
263         return;
264 
265 out:
266         if (!local_rcv)
267                 kfree_skb(skb);
268 }
269 #endif
270 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us