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 diasabled */ 30 static inline int should_deliver(const struct net_bridge_port *p, 31 const struct sk_buff *skb) 32 { 33 return (((p->flags & BR_HAIRPIN_MODE) || skb->dev != p->dev) && 34 p->state == BR_STATE_FORWARDING); 35 } 36 37 static inline unsigned packet_length(const struct sk_buff *skb) 38 { 39 return skb->len - (skb->protocol == htons(ETH_P_8021Q) ? VLAN_HLEN : 0); 40 } 41 42 int br_dev_queue_push_xmit(struct sk_buff *skb) 43 { 44 /* drop mtu oversized packets except gso */ 45 if (packet_length(skb) > skb->dev->mtu && !skb_is_gso(skb)) 46 kfree_skb(skb); 47 else { 48 /* ip_fragment doesn't copy the MAC header */ 49 if (nf_bridge_maybe_copy_header(skb)) 50 kfree_skb(skb); 51 else { 52 skb_push(skb, ETH_HLEN); 53 54 #ifdef CONFIG_NET_POLL_CONTROLLER 55 if (unlikely(skb->dev->priv_flags & IFF_IN_NETPOLL)) { 56 netpoll_send_skb(skb->dev->npinfo->netpoll, skb); 57 skb->dev->priv_flags &= ~IFF_IN_NETPOLL; 58 } else 59 #endif 60 dev_queue_xmit(skb); 61 } 62 } 63 64 return 0; 65 } 66 67 int br_forward_finish(struct sk_buff *skb) 68 { 69 return NF_HOOK(NFPROTO_BRIDGE, NF_BR_POST_ROUTING, skb, NULL, skb->dev, 70 br_dev_queue_push_xmit); 71 72 } 73 74 static void __br_deliver(const struct net_bridge_port *to, struct sk_buff *skb) 75 { 76 #ifdef CONFIG_NET_POLL_CONTROLLER 77 struct net_bridge *br = to->br; 78 if (unlikely(br->dev->priv_flags & IFF_IN_NETPOLL)) { 79 struct netpoll *np; 80 to->dev->npinfo = skb->dev->npinfo; 81 np = skb->dev->npinfo->netpoll; 82 np->real_dev = np->dev = to->dev; 83 to->dev->priv_flags |= IFF_IN_NETPOLL; 84 } 85 #endif 86 skb->dev = to->dev; 87 NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_OUT, skb, NULL, skb->dev, 88 br_forward_finish); 89 #ifdef CONFIG_NET_POLL_CONTROLLER 90 if (skb->dev->npinfo) 91 skb->dev->npinfo->netpoll->dev = br->dev; 92 #endif 93 } 94 95 static void __br_forward(const struct net_bridge_port *to, struct sk_buff *skb) 96 { 97 struct net_device *indev; 98 99 if (skb_warn_if_lro(skb)) { 100 kfree_skb(skb); 101 return; 102 } 103 104 indev = skb->dev; 105 skb->dev = to->dev; 106 skb_forward_csum(skb); 107 108 NF_HOOK(NFPROTO_BRIDGE, NF_BR_FORWARD, skb, indev, skb->dev, 109 br_forward_finish); 110 } 111 112 /* called with rcu_read_lock */ 113 void br_deliver(const struct net_bridge_port *to, struct sk_buff *skb) 114 { 115 if (should_deliver(to, skb)) { 116 __br_deliver(to, skb); 117 return; 118 } 119 120 kfree_skb(skb); 121 } 122 123 /* called with rcu_read_lock */ 124 void br_forward(const struct net_bridge_port *to, struct sk_buff *skb, struct sk_buff *skb0) 125 { 126 if (should_deliver(to, skb)) { 127 if (skb0) 128 deliver_clone(to, skb, __br_forward); 129 else 130 __br_forward(to, skb); 131 return; 132 } 133 134 if (!skb0) 135 kfree_skb(skb); 136 } 137 138 static int deliver_clone(const struct net_bridge_port *prev, 139 struct sk_buff *skb, 140 void (*__packet_hook)(const struct net_bridge_port *p, 141 struct sk_buff *skb)) 142 { 143 struct net_device *dev = BR_INPUT_SKB_CB(skb)->brdev; 144 145 skb = skb_clone(skb, GFP_ATOMIC); 146 if (!skb) { 147 dev->stats.tx_dropped++; 148 return -ENOMEM; 149 } 150 151 __packet_hook(prev, skb); 152 return 0; 153 } 154 155 static struct net_bridge_port *maybe_deliver( 156 struct net_bridge_port *prev, struct net_bridge_port *p, 157 struct sk_buff *skb, 158 void (*__packet_hook)(const struct net_bridge_port *p, 159 struct sk_buff *skb)) 160 { 161 int err; 162 163 if (!should_deliver(p, skb)) 164 return prev; 165 166 if (!prev) 167 goto out; 168 169 err = deliver_clone(prev, skb, __packet_hook); 170 if (err) 171 return ERR_PTR(err); 172 173 out: 174 return p; 175 } 176 177 /* called under bridge lock */ 178 static void br_flood(struct net_bridge *br, struct sk_buff *skb, 179 struct sk_buff *skb0, 180 void (*__packet_hook)(const struct net_bridge_port *p, 181 struct sk_buff *skb)) 182 { 183 struct net_bridge_port *p; 184 struct net_bridge_port *prev; 185 186 prev = NULL; 187 188 list_for_each_entry_rcu(p, &br->port_list, list) { 189 prev = maybe_deliver(prev, p, skb, __packet_hook); 190 if (IS_ERR(prev)) 191 goto out; 192 } 193 194 if (!prev) 195 goto out; 196 197 if (skb0) 198 deliver_clone(prev, skb, __packet_hook); 199 else 200 __packet_hook(prev, skb); 201 return; 202 203 out: 204 if (!skb0) 205 kfree_skb(skb); 206 } 207 208 209 /* called with rcu_read_lock */ 210 void br_flood_deliver(struct net_bridge *br, struct sk_buff *skb) 211 { 212 br_flood(br, skb, NULL, __br_deliver); 213 } 214 215 /* called under bridge lock */ 216 void br_flood_forward(struct net_bridge *br, struct sk_buff *skb, 217 struct sk_buff *skb2) 218 { 219 br_flood(br, skb, skb2, __br_forward); 220 } 221 222 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING 223 /* called with rcu_read_lock */ 224 static void br_multicast_flood(struct net_bridge_mdb_entry *mdst, 225 struct sk_buff *skb, struct sk_buff *skb0, 226 void (*__packet_hook)( 227 const struct net_bridge_port *p, 228 struct sk_buff *skb)) 229 { 230 struct net_device *dev = BR_INPUT_SKB_CB(skb)->brdev; 231 struct net_bridge *br = netdev_priv(dev); 232 struct net_bridge_port *prev = NULL; 233 struct net_bridge_port_group *p; 234 struct hlist_node *rp; 235 236 rp = rcu_dereference(br->router_list.first); 237 p = mdst ? rcu_dereference(mdst->ports) : NULL; 238 while (p || rp) { 239 struct net_bridge_port *port, *lport, *rport; 240 241 lport = p ? p->port : NULL; 242 rport = rp ? hlist_entry(rp, struct net_bridge_port, rlist) : 243 NULL; 244 245 port = (unsigned long)lport > (unsigned long)rport ? 246 lport : rport; 247 248 prev = maybe_deliver(prev, port, skb, __packet_hook); 249 if (IS_ERR(prev)) 250 goto out; 251 252 if ((unsigned long)lport >= (unsigned long)port) 253 p = rcu_dereference(p->next); 254 if ((unsigned long)rport >= (unsigned long)port) 255 rp = rcu_dereference(rp->next); 256 } 257 258 if (!prev) 259 goto out; 260 261 if (skb0) 262 deliver_clone(prev, skb, __packet_hook); 263 else 264 __packet_hook(prev, skb); 265 return; 266 267 out: 268 if (!skb0) 269 kfree_skb(skb); 270 } 271 272 /* called with rcu_read_lock */ 273 void br_multicast_deliver(struct net_bridge_mdb_entry *mdst, 274 struct sk_buff *skb) 275 { 276 br_multicast_flood(mdst, skb, NULL, __br_deliver); 277 } 278 279 /* called with rcu_read_lock */ 280 void br_multicast_forward(struct net_bridge_mdb_entry *mdst, 281 struct sk_buff *skb, struct sk_buff *skb2) 282 { 283 br_multicast_flood(mdst, skb, skb2, __br_forward); 284 } 285 #endif 286