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