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