| /* |
| * Forwarding decision |
| * Linux ethernet bridge |
| * |
| * Authors: |
| * Lennert Buytenhek <buytenh@gnu.org> |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU General Public License |
| * as published by the Free Software Foundation; either version |
| * 2 of the License, or (at your option) any later version. |
| */ |
| |
| #include <linux/err.h> |
| #include <linux/kernel.h> |
| #include <linux/netdevice.h> |
| #include <linux/skbuff.h> |
| #include <linux/if_vlan.h> |
| #include <linux/netfilter_bridge.h> |
| #include "br_private.h" |
| |
| /* Don't forward packets to originating port or forwarding diasabled */ |
| static inline int should_deliver(const struct net_bridge_port *p, |
| const struct sk_buff *skb) |
| { |
| return (((p->flags & BR_HAIRPIN_MODE) || skb->dev != p->dev) && |
| p->state == BR_STATE_FORWARDING); |
| } |
| |
| static inline unsigned packet_length(const struct sk_buff *skb) |
| { |
| return skb->len - (skb->protocol == htons(ETH_P_8021Q) ? VLAN_HLEN : 0); |
| } |
| |
| int br_dev_queue_push_xmit(struct sk_buff *skb) |
| { |
| /* drop mtu oversized packets except gso */ |
| if (packet_length(skb) > skb->dev->mtu && !skb_is_gso(skb)) |
| kfree_skb(skb); |
| else { |
| /* ip_refrag calls ip_fragment, doesn't copy the MAC header. */ |
| if (nf_bridge_maybe_copy_header(skb)) |
| kfree_skb(skb); |
| else { |
| skb_push(skb, ETH_HLEN); |
| |
| dev_queue_xmit(skb); |
| } |
| } |
| |
| return 0; |
| } |
| |
| int br_forward_finish(struct sk_buff *skb) |
| { |
| return NF_HOOK(PF_BRIDGE, NF_BR_POST_ROUTING, skb, NULL, skb->dev, |
| br_dev_queue_push_xmit); |
| |
| } |
| |
| static void __br_deliver(const struct net_bridge_port *to, struct sk_buff *skb) |
| { |
| skb->dev = to->dev; |
| NF_HOOK(PF_BRIDGE, NF_BR_LOCAL_OUT, skb, NULL, skb->dev, |
| br_forward_finish); |
| } |
| |
| static void __br_forward(const struct net_bridge_port *to, struct sk_buff *skb) |
| { |
| struct net_device *indev; |
| |
| if (skb_warn_if_lro(skb)) { |
| kfree_skb(skb); |
| return; |
| } |
| |
| indev = skb->dev; |
| skb->dev = to->dev; |
| skb_forward_csum(skb); |
| |
| NF_HOOK(PF_BRIDGE, NF_BR_FORWARD, skb, indev, skb->dev, |
| br_forward_finish); |
| } |
| |
| /* called with rcu_read_lock */ |
| void br_deliver(const struct net_bridge_port *to, struct sk_buff *skb) |
| { |
| if (should_deliver(to, skb)) { |
| __br_deliver(to, skb); |
| return; |
| } |
| |
| kfree_skb(skb); |
| } |
| |
| /* called with rcu_read_lock */ |
| void br_forward(const struct net_bridge_port *to, struct sk_buff *skb) |
| { |
| if (should_deliver(to, skb)) { |
| __br_forward(to, skb); |
| return; |
| } |
| |
| kfree_skb(skb); |
| } |
| |
| static int deliver_clone(struct net_bridge_port *prev, struct sk_buff *skb, |
| void (*__packet_hook)(const struct net_bridge_port *p, |
| struct sk_buff *skb)) |
| { |
| skb = skb_clone(skb, GFP_ATOMIC); |
| if (!skb) { |
| struct net_device *dev = BR_INPUT_SKB_CB(skb)->brdev; |
| |
| dev->stats.tx_dropped++; |
| return -ENOMEM; |
| } |
| |
| __packet_hook(prev, skb); |
| return 0; |
| } |
| |
| static struct net_bridge_port *maybe_deliver( |
| struct net_bridge_port *prev, struct net_bridge_port *p, |
| struct sk_buff *skb, |
| void (*__packet_hook)(const struct net_bridge_port *p, |
| struct sk_buff *skb)) |
| { |
| int err; |
| |
| if (!should_deliver(p, skb)) |
| return prev; |
| |
| if (!prev) |
| goto out; |
| |
| err = deliver_clone(prev, skb, __packet_hook); |
| if (err) |
| return ERR_PTR(err); |
| |
| out: |
| return p; |
| } |
| |
| /* called under bridge lock */ |
| static void br_flood(struct net_bridge *br, struct sk_buff *skb, |
| struct sk_buff *skb0, |
| void (*__packet_hook)(const struct net_bridge_port *p, |
| struct sk_buff *skb)) |
| { |
| struct net_bridge_port *p; |
| struct net_bridge_port *prev; |
| |
| prev = NULL; |
| |
| list_for_each_entry_rcu(p, &br->port_list, list) { |
| prev = maybe_deliver(prev, p, skb, __packet_hook); |
| if (IS_ERR(prev)) |
| goto out; |
| } |
| |
| if (!prev) |
| goto out; |
| |
| if (skb0) |
| deliver_clone(prev, skb, __packet_hook); |
| else |
| __packet_hook(prev, skb); |
| return; |
| |
| out: |
| if (!skb0) |
| kfree_skb(skb); |
| } |
| |
| |
| /* called with rcu_read_lock */ |
| void br_flood_deliver(struct net_bridge *br, struct sk_buff *skb) |
| { |
| br_flood(br, skb, NULL, __br_deliver); |
| } |
| |
| /* called under bridge lock */ |
| void br_flood_forward(struct net_bridge *br, struct sk_buff *skb, |
| struct sk_buff *skb2) |
| { |
| br_flood(br, skb, skb2, __br_forward); |
| } |