tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/*
2 * Handle incoming frames
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/slab.h>
15#include <linux/kernel.h>
16#include <linux/netdevice.h>
17#include <linux/etherdevice.h>
18#include <linux/netfilter_bridge.h>
19#include <linux/neighbour.h>
20#include <net/arp.h>
21#include <linux/export.h>
22#include <linux/rculist.h>
23#include "br_private.h"
24
25/* Hook for brouter */
26br_should_route_hook_t __rcu *br_should_route_hook __read_mostly;
27EXPORT_SYMBOL(br_should_route_hook);
28
29static int br_pass_frame_up(struct sk_buff *skb)
30{
31 struct net_device *indev, *brdev = BR_INPUT_SKB_CB(skb)->brdev;
32 struct net_bridge *br = netdev_priv(brdev);
33 struct pcpu_sw_netstats *brstats = this_cpu_ptr(br->stats);
34 struct net_port_vlans *pv;
35
36 u64_stats_update_begin(&brstats->syncp);
37 brstats->rx_packets++;
38 brstats->rx_bytes += skb->len;
39 u64_stats_update_end(&brstats->syncp);
40
41 /* Bridge is just like any other port. Make sure the
42 * packet is allowed except in promisc modue when someone
43 * may be running packet capture.
44 */
45 pv = br_get_vlan_info(br);
46 if (!(brdev->flags & IFF_PROMISC) &&
47 !br_allowed_egress(br, pv, skb)) {
48 kfree_skb(skb);
49 return NET_RX_DROP;
50 }
51
52 indev = skb->dev;
53 skb->dev = brdev;
54 skb = br_handle_vlan(br, pv, skb);
55 if (!skb)
56 return NET_RX_DROP;
57
58 return NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_IN, skb, indev, NULL,
59 netif_receive_skb);
60}
61
62static void br_do_proxy_arp(struct sk_buff *skb, struct net_bridge *br,
63 u16 vid)
64{
65 struct net_device *dev = br->dev;
66 struct neighbour *n;
67 struct arphdr *parp;
68 u8 *arpptr, *sha;
69 __be32 sip, tip;
70
71 if (dev->flags & IFF_NOARP)
72 return;
73
74 if (!pskb_may_pull(skb, arp_hdr_len(dev))) {
75 dev->stats.tx_dropped++;
76 return;
77 }
78 parp = arp_hdr(skb);
79
80 if (parp->ar_pro != htons(ETH_P_IP) ||
81 parp->ar_op != htons(ARPOP_REQUEST) ||
82 parp->ar_hln != dev->addr_len ||
83 parp->ar_pln != 4)
84 return;
85
86 arpptr = (u8 *)parp + sizeof(struct arphdr);
87 sha = arpptr;
88 arpptr += dev->addr_len; /* sha */
89 memcpy(&sip, arpptr, sizeof(sip));
90 arpptr += sizeof(sip);
91 arpptr += dev->addr_len; /* tha */
92 memcpy(&tip, arpptr, sizeof(tip));
93
94 if (ipv4_is_loopback(tip) ||
95 ipv4_is_multicast(tip))
96 return;
97
98 n = neigh_lookup(&arp_tbl, &tip, dev);
99 if (n) {
100 struct net_bridge_fdb_entry *f;
101
102 if (!(n->nud_state & NUD_VALID)) {
103 neigh_release(n);
104 return;
105 }
106
107 f = __br_fdb_get(br, n->ha, vid);
108 if (f)
109 arp_send(ARPOP_REPLY, ETH_P_ARP, sip, skb->dev, tip,
110 sha, n->ha, sha);
111
112 neigh_release(n);
113 }
114}
115
116/* note: already called with rcu_read_lock */
117int br_handle_frame_finish(struct sk_buff *skb)
118{
119 const unsigned char *dest = eth_hdr(skb)->h_dest;
120 struct net_bridge_port *p = br_port_get_rcu(skb->dev);
121 struct net_bridge *br;
122 struct net_bridge_fdb_entry *dst;
123 struct net_bridge_mdb_entry *mdst;
124 struct sk_buff *skb2;
125 bool unicast = true;
126 u16 vid = 0;
127
128 if (!p || p->state == BR_STATE_DISABLED)
129 goto drop;
130
131 if (!br_allowed_ingress(p->br, nbp_get_vlan_info(p), skb, &vid))
132 goto out;
133
134 /* insert into forwarding database after filtering to avoid spoofing */
135 br = p->br;
136 if (p->flags & BR_LEARNING)
137 br_fdb_update(br, p, eth_hdr(skb)->h_source, vid, false);
138
139 if (!is_broadcast_ether_addr(dest) && is_multicast_ether_addr(dest) &&
140 br_multicast_rcv(br, p, skb, vid))
141 goto drop;
142
143 if (p->state == BR_STATE_LEARNING)
144 goto drop;
145
146 BR_INPUT_SKB_CB(skb)->brdev = br->dev;
147
148 /* The packet skb2 goes to the local host (NULL to skip). */
149 skb2 = NULL;
150
151 if (br->dev->flags & IFF_PROMISC)
152 skb2 = skb;
153
154 dst = NULL;
155
156 if (is_broadcast_ether_addr(dest)) {
157 if (p->flags & BR_PROXYARP &&
158 skb->protocol == htons(ETH_P_ARP))
159 br_do_proxy_arp(skb, br, vid);
160
161 skb2 = skb;
162 unicast = false;
163 } else if (is_multicast_ether_addr(dest)) {
164 mdst = br_mdb_get(br, skb, vid);
165 if ((mdst || BR_INPUT_SKB_CB_MROUTERS_ONLY(skb)) &&
166 br_multicast_querier_exists(br, eth_hdr(skb))) {
167 if ((mdst && mdst->mglist) ||
168 br_multicast_is_router(br))
169 skb2 = skb;
170 br_multicast_forward(mdst, skb, skb2);
171 skb = NULL;
172 if (!skb2)
173 goto out;
174 } else
175 skb2 = skb;
176
177 unicast = false;
178 br->dev->stats.multicast++;
179 } else if ((dst = __br_fdb_get(br, dest, vid)) &&
180 dst->is_local) {
181 skb2 = skb;
182 /* Do not forward the packet since it's local. */
183 skb = NULL;
184 }
185
186 if (skb) {
187 if (dst) {
188 dst->used = jiffies;
189 br_forward(dst->dst, skb, skb2);
190 } else
191 br_flood_forward(br, skb, skb2, unicast);
192 }
193
194 if (skb2)
195 return br_pass_frame_up(skb2);
196
197out:
198 return 0;
199drop:
200 kfree_skb(skb);
201 goto out;
202}
203EXPORT_SYMBOL_GPL(br_handle_frame_finish);
204
205/* note: already called with rcu_read_lock */
206static int br_handle_local_finish(struct sk_buff *skb)
207{
208 struct net_bridge_port *p = br_port_get_rcu(skb->dev);
209 u16 vid = 0;
210
211 /* check if vlan is allowed, to avoid spoofing */
212 if (p->flags & BR_LEARNING && br_should_learn(p, skb, &vid))
213 br_fdb_update(p->br, p, eth_hdr(skb)->h_source, vid, false);
214 return 0; /* process further */
215}
216
217/*
218 * Return NULL if skb is handled
219 * note: already called with rcu_read_lock
220 */
221rx_handler_result_t br_handle_frame(struct sk_buff **pskb)
222{
223 struct net_bridge_port *p;
224 struct sk_buff *skb = *pskb;
225 const unsigned char *dest = eth_hdr(skb)->h_dest;
226 br_should_route_hook_t *rhook;
227
228 if (unlikely(skb->pkt_type == PACKET_LOOPBACK))
229 return RX_HANDLER_PASS;
230
231 if (!is_valid_ether_addr(eth_hdr(skb)->h_source))
232 goto drop;
233
234 skb = skb_share_check(skb, GFP_ATOMIC);
235 if (!skb)
236 return RX_HANDLER_CONSUMED;
237
238 p = br_port_get_rcu(skb->dev);
239
240 if (unlikely(is_link_local_ether_addr(dest))) {
241 u16 fwd_mask = p->br->group_fwd_mask_required;
242
243 /*
244 * See IEEE 802.1D Table 7-10 Reserved addresses
245 *
246 * Assignment Value
247 * Bridge Group Address 01-80-C2-00-00-00
248 * (MAC Control) 802.3 01-80-C2-00-00-01
249 * (Link Aggregation) 802.3 01-80-C2-00-00-02
250 * 802.1X PAE address 01-80-C2-00-00-03
251 *
252 * 802.1AB LLDP 01-80-C2-00-00-0E
253 *
254 * Others reserved for future standardization
255 */
256 switch (dest[5]) {
257 case 0x00: /* Bridge Group Address */
258 /* If STP is turned off,
259 then must forward to keep loop detection */
260 if (p->br->stp_enabled == BR_NO_STP ||
261 fwd_mask & (1u << dest[5]))
262 goto forward;
263 break;
264
265 case 0x01: /* IEEE MAC (Pause) */
266 goto drop;
267
268 default:
269 /* Allow selective forwarding for most other protocols */
270 fwd_mask |= p->br->group_fwd_mask;
271 if (fwd_mask & (1u << dest[5]))
272 goto forward;
273 }
274
275 /* Deliver packet to local host only */
276 if (NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_IN, skb, skb->dev,
277 NULL, br_handle_local_finish)) {
278 return RX_HANDLER_CONSUMED; /* consumed by filter */
279 } else {
280 *pskb = skb;
281 return RX_HANDLER_PASS; /* continue processing */
282 }
283 }
284
285forward:
286 switch (p->state) {
287 case BR_STATE_FORWARDING:
288 rhook = rcu_dereference(br_should_route_hook);
289 if (rhook) {
290 if ((*rhook)(skb)) {
291 *pskb = skb;
292 return RX_HANDLER_PASS;
293 }
294 dest = eth_hdr(skb)->h_dest;
295 }
296 /* fall through */
297 case BR_STATE_LEARNING:
298 if (ether_addr_equal(p->br->dev->dev_addr, dest))
299 skb->pkt_type = PACKET_HOST;
300
301 NF_HOOK(NFPROTO_BRIDGE, NF_BR_PRE_ROUTING, skb, skb->dev, NULL,
302 br_handle_frame_finish);
303 break;
304 default:
305drop:
306 kfree_skb(skb);
307 }
308 return RX_HANDLER_CONSUMED;
309}