Version:  2.0.40 2.2.26 2.4.37 3.8 3.9 3.10 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

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 static int deliver_clone(const struct net_bridge_port *prev,
 25                          struct sk_buff *skb,
 26                          void (*__packet_hook)(const struct net_bridge_port *p,
 27                                                struct sk_buff *skb));
 28 
 29 /* Don't forward packets to originating port or forwarding disabled */
 30 static inline int should_deliver(const struct net_bridge_port *p,
 31                                  const struct sk_buff *skb)
 32 {
 33         struct net_bridge_vlan_group *vg;
 34 
 35         vg = nbp_vlan_group_rcu(p);
 36         return ((p->flags & BR_HAIRPIN_MODE) || skb->dev != p->dev) &&
 37                 br_allowed_egress(vg, skb) && p->state == BR_STATE_FORWARDING;
 38 }
 39 
 40 int br_dev_queue_push_xmit(struct net *net, struct sock *sk, struct sk_buff *skb)
 41 {
 42         if (!is_skb_forwardable(skb->dev, skb))
 43                 goto drop;
 44 
 45         skb_push(skb, ETH_HLEN);
 46         br_drop_fake_rtable(skb);
 47         skb_sender_cpu_clear(skb);
 48 
 49         if (skb->ip_summed == CHECKSUM_PARTIAL &&
 50             (skb->protocol == htons(ETH_P_8021Q) ||
 51              skb->protocol == htons(ETH_P_8021AD))) {
 52                 int depth;
 53 
 54                 if (!__vlan_get_protocol(skb, skb->protocol, &depth))
 55                         goto drop;
 56 
 57                 skb_set_network_header(skb, depth);
 58         }
 59 
 60         dev_queue_xmit(skb);
 61 
 62         return 0;
 63 
 64 drop:
 65         kfree_skb(skb);
 66         return 0;
 67 }
 68 EXPORT_SYMBOL_GPL(br_dev_queue_push_xmit);
 69 
 70 int br_forward_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
 71 {
 72         return NF_HOOK(NFPROTO_BRIDGE, NF_BR_POST_ROUTING,
 73                        net, sk, skb, NULL, skb->dev,
 74                        br_dev_queue_push_xmit);
 75 
 76 }
 77 EXPORT_SYMBOL_GPL(br_forward_finish);
 78 
 79 static void __br_deliver(const struct net_bridge_port *to, struct sk_buff *skb)
 80 {
 81         struct net_bridge_vlan_group *vg;
 82 
 83         vg = nbp_vlan_group_rcu(to);
 84         skb = br_handle_vlan(to->br, vg, skb);
 85         if (!skb)
 86                 return;
 87 
 88         skb->dev = to->dev;
 89 
 90         if (unlikely(netpoll_tx_running(to->br->dev))) {
 91                 if (!is_skb_forwardable(skb->dev, skb))
 92                         kfree_skb(skb);
 93                 else {
 94                         skb_push(skb, ETH_HLEN);
 95                         br_netpoll_send_skb(to, skb);
 96                 }
 97                 return;
 98         }
 99 
100         NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_OUT,
101                 dev_net(skb->dev), NULL, skb,NULL, skb->dev,
102                 br_forward_finish);
103 }
104 
105 static void __br_forward(const struct net_bridge_port *to, struct sk_buff *skb)
106 {
107         struct net_bridge_vlan_group *vg;
108         struct net_device *indev;
109 
110         if (skb_warn_if_lro(skb)) {
111                 kfree_skb(skb);
112                 return;
113         }
114 
115         vg = nbp_vlan_group_rcu(to);
116         skb = br_handle_vlan(to->br, vg, skb);
117         if (!skb)
118                 return;
119 
120         indev = skb->dev;
121         skb->dev = to->dev;
122         skb_forward_csum(skb);
123 
124         NF_HOOK(NFPROTO_BRIDGE, NF_BR_FORWARD,
125                 dev_net(indev), NULL, skb, indev, skb->dev,
126                 br_forward_finish);
127 }
128 
129 /* called with rcu_read_lock */
130 void br_deliver(const struct net_bridge_port *to, struct sk_buff *skb)
131 {
132         if (to && should_deliver(to, skb)) {
133                 __br_deliver(to, skb);
134                 return;
135         }
136 
137         kfree_skb(skb);
138 }
139 EXPORT_SYMBOL_GPL(br_deliver);
140 
141 /* called with rcu_read_lock */
142 void br_forward(const struct net_bridge_port *to, struct sk_buff *skb, struct sk_buff *skb0)
143 {
144         if (to && should_deliver(to, skb)) {
145                 if (skb0)
146                         deliver_clone(to, skb, __br_forward);
147                 else
148                         __br_forward(to, skb);
149                 return;
150         }
151 
152         if (!skb0)
153                 kfree_skb(skb);
154 }
155 
156 static int deliver_clone(const struct net_bridge_port *prev,
157                          struct sk_buff *skb,
158                          void (*__packet_hook)(const struct net_bridge_port *p,
159                                                struct sk_buff *skb))
160 {
161         struct net_device *dev = BR_INPUT_SKB_CB(skb)->brdev;
162 
163         skb = skb_clone(skb, GFP_ATOMIC);
164         if (!skb) {
165                 dev->stats.tx_dropped++;
166                 return -ENOMEM;
167         }
168 
169         __packet_hook(prev, skb);
170         return 0;
171 }
172 
173 static struct net_bridge_port *maybe_deliver(
174         struct net_bridge_port *prev, struct net_bridge_port *p,
175         struct sk_buff *skb,
176         void (*__packet_hook)(const struct net_bridge_port *p,
177                               struct sk_buff *skb))
178 {
179         int err;
180 
181         if (!should_deliver(p, skb))
182                 return prev;
183 
184         if (!prev)
185                 goto out;
186 
187         err = deliver_clone(prev, skb, __packet_hook);
188         if (err)
189                 return ERR_PTR(err);
190 
191 out:
192         return p;
193 }
194 
195 /* called under bridge lock */
196 static void br_flood(struct net_bridge *br, struct sk_buff *skb,
197                      struct sk_buff *skb0,
198                      void (*__packet_hook)(const struct net_bridge_port *p,
199                                            struct sk_buff *skb),
200                      bool unicast)
201 {
202         struct net_bridge_port *p;
203         struct net_bridge_port *prev;
204 
205         prev = NULL;
206 
207         list_for_each_entry_rcu(p, &br->port_list, list) {
208                 /* Do not flood unicast traffic to ports that turn it off */
209                 if (unicast && !(p->flags & BR_FLOOD))
210                         continue;
211 
212                 /* Do not flood to ports that enable proxy ARP */
213                 if (p->flags & BR_PROXYARP)
214                         continue;
215                 if ((p->flags & BR_PROXYARP_WIFI) &&
216                     BR_INPUT_SKB_CB(skb)->proxyarp_replied)
217                         continue;
218 
219                 prev = maybe_deliver(prev, p, skb, __packet_hook);
220                 if (IS_ERR(prev))
221                         goto out;
222         }
223 
224         if (!prev)
225                 goto out;
226 
227         if (skb0)
228                 deliver_clone(prev, skb, __packet_hook);
229         else
230                 __packet_hook(prev, skb);
231         return;
232 
233 out:
234         if (!skb0)
235                 kfree_skb(skb);
236 }
237 
238 
239 /* called with rcu_read_lock */
240 void br_flood_deliver(struct net_bridge *br, struct sk_buff *skb, bool unicast)
241 {
242         br_flood(br, skb, NULL, __br_deliver, unicast);
243 }
244 
245 /* called under bridge lock */
246 void br_flood_forward(struct net_bridge *br, struct sk_buff *skb,
247                       struct sk_buff *skb2, bool unicast)
248 {
249         br_flood(br, skb, skb2, __br_forward, unicast);
250 }
251 
252 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
253 /* called with rcu_read_lock */
254 static void br_multicast_flood(struct net_bridge_mdb_entry *mdst,
255                                struct sk_buff *skb, struct sk_buff *skb0,
256                                void (*__packet_hook)(
257                                         const struct net_bridge_port *p,
258                                         struct sk_buff *skb))
259 {
260         struct net_device *dev = BR_INPUT_SKB_CB(skb)->brdev;
261         struct net_bridge *br = netdev_priv(dev);
262         struct net_bridge_port *prev = NULL;
263         struct net_bridge_port_group *p;
264         struct hlist_node *rp;
265 
266         rp = rcu_dereference(hlist_first_rcu(&br->router_list));
267         p = mdst ? rcu_dereference(mdst->ports) : NULL;
268         while (p || rp) {
269                 struct net_bridge_port *port, *lport, *rport;
270 
271                 lport = p ? p->port : NULL;
272                 rport = rp ? hlist_entry(rp, struct net_bridge_port, rlist) :
273                              NULL;
274 
275                 port = (unsigned long)lport > (unsigned long)rport ?
276                        lport : rport;
277 
278                 prev = maybe_deliver(prev, port, skb, __packet_hook);
279                 if (IS_ERR(prev))
280                         goto out;
281 
282                 if ((unsigned long)lport >= (unsigned long)port)
283                         p = rcu_dereference(p->next);
284                 if ((unsigned long)rport >= (unsigned long)port)
285                         rp = rcu_dereference(hlist_next_rcu(rp));
286         }
287 
288         if (!prev)
289                 goto out;
290 
291         if (skb0)
292                 deliver_clone(prev, skb, __packet_hook);
293         else
294                 __packet_hook(prev, skb);
295         return;
296 
297 out:
298         if (!skb0)
299                 kfree_skb(skb);
300 }
301 
302 /* called with rcu_read_lock */
303 void br_multicast_deliver(struct net_bridge_mdb_entry *mdst,
304                           struct sk_buff *skb)
305 {
306         br_multicast_flood(mdst, skb, NULL, __br_deliver);
307 }
308 
309 /* called with rcu_read_lock */
310 void br_multicast_forward(struct net_bridge_mdb_entry *mdst,
311                           struct sk_buff *skb, struct sk_buff *skb2)
312 {
313         br_multicast_flood(mdst, skb, skb2, __br_forward);
314 }
315 #endif
316 

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