br_forward.c 5.8 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13
/*
 *	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.
 */

14
#include <linux/err.h>
L
Linus Torvalds 已提交
15 16 17
#include <linux/kernel.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
18
#include <linux/if_vlan.h>
L
Linus Torvalds 已提交
19 20 21
#include <linux/netfilter_bridge.h>
#include "br_private.h"

22 23
static int deliver_clone(const struct net_bridge_port *prev,
			 struct sk_buff *skb,
24 25 26
			 void (*__packet_hook)(const struct net_bridge_port *p,
					       struct sk_buff *skb));

27
/* Don't forward packets to originating port or forwarding diasabled */
28
static inline int should_deliver(const struct net_bridge_port *p,
L
Linus Torvalds 已提交
29 30
				 const struct sk_buff *skb)
{
31 32
	return (((p->flags & BR_HAIRPIN_MODE) || skb->dev != p->dev) &&
		p->state == BR_STATE_FORWARDING);
L
Linus Torvalds 已提交
33 34
}

35 36 37 38 39
static inline unsigned packet_length(const struct sk_buff *skb)
{
	return skb->len - (skb->protocol == htons(ETH_P_8021Q) ? VLAN_HLEN : 0);
}

L
Linus Torvalds 已提交
40 41
int br_dev_queue_push_xmit(struct sk_buff *skb)
{
42
	/* drop mtu oversized packets except gso */
H
Herbert Xu 已提交
43
	if (packet_length(skb) > skb->dev->mtu && !skb_is_gso(skb))
L
Linus Torvalds 已提交
44 45 46
		kfree_skb(skb);
	else {
		/* ip_refrag calls ip_fragment, doesn't copy the MAC header. */
47 48
		if (nf_bridge_maybe_copy_header(skb))
			kfree_skb(skb);
49
		else {
50
			skb_push(skb, ETH_HLEN);
L
Linus Torvalds 已提交
51

52 53
			dev_queue_xmit(skb);
		}
L
Linus Torvalds 已提交
54 55 56 57 58 59 60
	}

	return 0;
}

int br_forward_finish(struct sk_buff *skb)
{
61 62
	return NF_HOOK(PF_BRIDGE, NF_BR_POST_ROUTING, skb, NULL, skb->dev,
		       br_dev_queue_push_xmit);
L
Linus Torvalds 已提交
63 64 65 66 67 68 69 70 71 72 73 74 75 76

}

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;

H
Herbert Xu 已提交
77 78 79 80 81
	if (skb_warn_if_lro(skb)) {
		kfree_skb(skb);
		return;
	}

L
Linus Torvalds 已提交
82 83
	indev = skb->dev;
	skb->dev = to->dev;
84
	skb_forward_csum(skb);
L
Linus Torvalds 已提交
85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101

	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 */
102
void br_forward(const struct net_bridge_port *to, struct sk_buff *skb, struct sk_buff *skb0)
L
Linus Torvalds 已提交
103
{
H
Herbert Xu 已提交
104
	if (should_deliver(to, skb)) {
105 106 107 108
		if (skb0)
			deliver_clone(to, skb, __br_forward);
		else
			__br_forward(to, skb);
L
Linus Torvalds 已提交
109 110 111
		return;
	}

112 113
	if (!skb0)
		kfree_skb(skb);
L
Linus Torvalds 已提交
114 115
}

116 117
static int deliver_clone(const struct net_bridge_port *prev,
			 struct sk_buff *skb,
118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
			 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;
}

L
Linus Torvalds 已提交
155
/* called under bridge lock */
156
static void br_flood(struct net_bridge *br, struct sk_buff *skb,
157 158 159
		     struct sk_buff *skb0,
		     void (*__packet_hook)(const struct net_bridge_port *p,
					   struct sk_buff *skb))
L
Linus Torvalds 已提交
160 161 162 163 164 165 166
{
	struct net_bridge_port *p;
	struct net_bridge_port *prev;

	prev = NULL;

	list_for_each_entry_rcu(p, &br->port_list, list) {
167 168 169
		prev = maybe_deliver(prev, p, skb, __packet_hook);
		if (IS_ERR(prev))
			goto out;
L
Linus Torvalds 已提交
170 171
	}

172 173 174
	if (!prev)
		goto out;

175 176 177 178
	if (skb0)
		deliver_clone(prev, skb, __packet_hook);
	else
		__packet_hook(prev, skb);
179
	return;
L
Linus Torvalds 已提交
180

181 182 183
out:
	if (!skb0)
		kfree_skb(skb);
L
Linus Torvalds 已提交
184 185 186 187
}


/* called with rcu_read_lock */
188
void br_flood_deliver(struct net_bridge *br, struct sk_buff *skb)
L
Linus Torvalds 已提交
189
{
190
	br_flood(br, skb, NULL, __br_deliver);
L
Linus Torvalds 已提交
191 192 193
}

/* called under bridge lock */
194 195
void br_flood_forward(struct net_bridge *br, struct sk_buff *skb,
		      struct sk_buff *skb2)
L
Linus Torvalds 已提交
196
{
197
	br_flood(br, skb, skb2, __br_forward);
L
Linus Torvalds 已提交
198
}
199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265

#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
/* called with rcu_read_lock */
static void br_multicast_flood(struct net_bridge_mdb_entry *mdst,
			       struct sk_buff *skb, struct sk_buff *skb0,
			       void (*__packet_hook)(
					const struct net_bridge_port *p,
					struct sk_buff *skb))
{
	struct net_device *dev = BR_INPUT_SKB_CB(skb)->brdev;
	struct net_bridge *br = netdev_priv(dev);
	struct net_bridge_port *port;
	struct net_bridge_port *lport, *rport;
	struct net_bridge_port *prev;
	struct net_bridge_port_group *p;
	struct hlist_node *rp;

	prev = NULL;

	rp = br->router_list.first;
	p = mdst ? mdst->ports : NULL;
	while (p || rp) {
		lport = p ? p->port : NULL;
		rport = rp ? hlist_entry(rp, struct net_bridge_port, rlist) :
			     NULL;

		port = (unsigned long)lport > (unsigned long)rport ?
		       lport : rport;

		prev = maybe_deliver(prev, port, skb, __packet_hook);
		if (IS_ERR(prev))
			goto out;

		if ((unsigned long)lport >= (unsigned long)port)
			p = p->next;
		if ((unsigned long)rport >= (unsigned long)port)
			rp = rp->next;
	}

	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_multicast_deliver(struct net_bridge_mdb_entry *mdst,
			  struct sk_buff *skb)
{
	br_multicast_flood(mdst, skb, NULL, __br_deliver);
}

/* called with rcu_read_lock */
void br_multicast_forward(struct net_bridge_mdb_entry *mdst,
			  struct sk_buff *skb, struct sk_buff *skb2)
{
	br_multicast_flood(mdst, skb, skb2, __br_forward);
}
#endif