1
2
3
4
5
6
7
8
9
10
11
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
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
42
43
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;
89 memcpy(&sip, arpptr, sizeof(sip));
90 arpptr += sizeof(sip);
91 arpptr += dev->addr_len;
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
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
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
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 (IS_ENABLED(CONFIG_INET) &&
158 p->flags & BR_PROXYARP &&
159 skb->protocol == htons(ETH_P_ARP))
160 br_do_proxy_arp(skb, br, vid);
161
162 skb2 = skb;
163 unicast = false;
164 } else if (is_multicast_ether_addr(dest)) {
165 mdst = br_mdb_get(br, skb, vid);
166 if ((mdst || BR_INPUT_SKB_CB_MROUTERS_ONLY(skb)) &&
167 br_multicast_querier_exists(br, eth_hdr(skb))) {
168 if ((mdst && mdst->mglist) ||
169 br_multicast_is_router(br))
170 skb2 = skb;
171 br_multicast_forward(mdst, skb, skb2);
172 skb = NULL;
173 if (!skb2)
174 goto out;
175 } else
176 skb2 = skb;
177
178 unicast = false;
179 br->dev->stats.multicast++;
180 } else if ((dst = __br_fdb_get(br, dest, vid)) &&
181 dst->is_local) {
182 skb2 = skb;
183
184 skb = NULL;
185 }
186
187 if (skb) {
188 if (dst) {
189 dst->used = jiffies;
190 br_forward(dst->dst, skb, skb2);
191 } else
192 br_flood_forward(br, skb, skb2, unicast);
193 }
194
195 if (skb2)
196 return br_pass_frame_up(skb2);
197
198out:
199 return 0;
200drop:
201 kfree_skb(skb);
202 goto out;
203}
204EXPORT_SYMBOL_GPL(br_handle_frame_finish);
205
206
207static int br_handle_local_finish(struct sk_buff *skb)
208{
209 struct net_bridge_port *p = br_port_get_rcu(skb->dev);
210 u16 vid = 0;
211
212
213 if (p->flags & BR_LEARNING && br_should_learn(p, skb, &vid))
214 br_fdb_update(p->br, p, eth_hdr(skb)->h_source, vid, false);
215 return 0;
216}
217
218
219
220
221
222rx_handler_result_t br_handle_frame(struct sk_buff **pskb)
223{
224 struct net_bridge_port *p;
225 struct sk_buff *skb = *pskb;
226 const unsigned char *dest = eth_hdr(skb)->h_dest;
227 br_should_route_hook_t *rhook;
228
229 if (unlikely(skb->pkt_type == PACKET_LOOPBACK))
230 return RX_HANDLER_PASS;
231
232 if (!is_valid_ether_addr(eth_hdr(skb)->h_source))
233 goto drop;
234
235 skb = skb_share_check(skb, GFP_ATOMIC);
236 if (!skb)
237 return RX_HANDLER_CONSUMED;
238
239 p = br_port_get_rcu(skb->dev);
240
241 if (unlikely(is_link_local_ether_addr(dest))) {
242 u16 fwd_mask = p->br->group_fwd_mask_required;
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257 switch (dest[5]) {
258 case 0x00:
259
260
261 if (p->br->stp_enabled == BR_NO_STP ||
262 fwd_mask & (1u << dest[5]))
263 goto forward;
264 break;
265
266 case 0x01:
267 goto drop;
268
269 default:
270
271 fwd_mask |= p->br->group_fwd_mask;
272 if (fwd_mask & (1u << dest[5]))
273 goto forward;
274 }
275
276
277 if (NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_IN, skb, skb->dev,
278 NULL, br_handle_local_finish)) {
279 return RX_HANDLER_CONSUMED;
280 } else {
281 *pskb = skb;
282 return RX_HANDLER_PASS;
283 }
284 }
285
286forward:
287 switch (p->state) {
288 case BR_STATE_FORWARDING:
289 rhook = rcu_dereference(br_should_route_hook);
290 if (rhook) {
291 if ((*rhook)(skb)) {
292 *pskb = skb;
293 return RX_HANDLER_PASS;
294 }
295 dest = eth_hdr(skb)->h_dest;
296 }
297
298 case BR_STATE_LEARNING:
299 if (ether_addr_equal(p->br->dev->dev_addr, dest))
300 skb->pkt_type = PACKET_HOST;
301
302 NF_HOOK(NFPROTO_BRIDGE, NF_BR_PRE_ROUTING, skb, skb->dev, NULL,
303 br_handle_frame_finish);
304 break;
305 default:
306drop:
307 kfree_skb(skb);
308 }
309 return RX_HANDLER_CONSUMED;
310}
311