mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-23 00:06:51 +07:00
31a4562d74
With 802.1ad support the vlan_ingress code started checking for vlan
protocol mismatch which causes the current tag to be inserted and the
bridge vlan protocol & pvid to be set. The vlan tag insertion changes
the skb mac_header and thus the lookup mac dest pointer which was loaded
prior to calling br_allowed_ingress in br_handle_frame_finish is VLAN_HLEN
bytes off now, pointing to the last two bytes of the destination mac and
the first four of the source mac causing lookups to always fail and
broadcasting all such packets to all ports. Same thing happens for locally
originated packets when passing via br_dev_xmit. So load the dest pointer
after the vlan checks and possible skb change.
Fixes: 8580e2117c
("bridge: Prepare for 802.1ad vlan filtering support")
Reported-by: Anitha Narasimha Murthy <anitha@cumulusnetworks.com>
Signed-off-by: Nikolay Aleksandrov <nikolay@cumulusnetworks.com>
Acked-by: Toshiaki Makita <makita.toshiaki@lab.ntt.co.jp>
Signed-off-by: David S. Miller <davem@davemloft.net>
353 lines
8.7 KiB
C
353 lines
8.7 KiB
C
/*
|
|
* Handle incoming frames
|
|
* 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/slab.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/netdevice.h>
|
|
#include <linux/etherdevice.h>
|
|
#include <linux/netfilter_bridge.h>
|
|
#include <linux/neighbour.h>
|
|
#include <net/arp.h>
|
|
#include <linux/export.h>
|
|
#include <linux/rculist.h>
|
|
#include "br_private.h"
|
|
#include "br_private_tunnel.h"
|
|
|
|
/* Hook for brouter */
|
|
br_should_route_hook_t __rcu *br_should_route_hook __read_mostly;
|
|
EXPORT_SYMBOL(br_should_route_hook);
|
|
|
|
static int
|
|
br_netif_receive_skb(struct net *net, struct sock *sk, struct sk_buff *skb)
|
|
{
|
|
br_drop_fake_rtable(skb);
|
|
return netif_receive_skb(skb);
|
|
}
|
|
|
|
static int br_pass_frame_up(struct sk_buff *skb)
|
|
{
|
|
struct net_device *indev, *brdev = BR_INPUT_SKB_CB(skb)->brdev;
|
|
struct net_bridge *br = netdev_priv(brdev);
|
|
struct net_bridge_vlan_group *vg;
|
|
struct pcpu_sw_netstats *brstats = this_cpu_ptr(br->stats);
|
|
|
|
u64_stats_update_begin(&brstats->syncp);
|
|
brstats->rx_packets++;
|
|
brstats->rx_bytes += skb->len;
|
|
u64_stats_update_end(&brstats->syncp);
|
|
|
|
vg = br_vlan_group_rcu(br);
|
|
/* Bridge is just like any other port. Make sure the
|
|
* packet is allowed except in promisc modue when someone
|
|
* may be running packet capture.
|
|
*/
|
|
if (!(brdev->flags & IFF_PROMISC) &&
|
|
!br_allowed_egress(vg, skb)) {
|
|
kfree_skb(skb);
|
|
return NET_RX_DROP;
|
|
}
|
|
|
|
indev = skb->dev;
|
|
skb->dev = brdev;
|
|
skb = br_handle_vlan(br, NULL, vg, skb);
|
|
if (!skb)
|
|
return NET_RX_DROP;
|
|
/* update the multicast stats if the packet is IGMP/MLD */
|
|
br_multicast_count(br, NULL, skb, br_multicast_igmp_type(skb),
|
|
BR_MCAST_DIR_TX);
|
|
|
|
return NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_IN,
|
|
dev_net(indev), NULL, skb, indev, NULL,
|
|
br_netif_receive_skb);
|
|
}
|
|
|
|
static void br_do_proxy_arp(struct sk_buff *skb, struct net_bridge *br,
|
|
u16 vid, struct net_bridge_port *p)
|
|
{
|
|
struct net_device *dev = br->dev;
|
|
struct neighbour *n;
|
|
struct arphdr *parp;
|
|
u8 *arpptr, *sha;
|
|
__be32 sip, tip;
|
|
|
|
BR_INPUT_SKB_CB(skb)->proxyarp_replied = false;
|
|
|
|
if ((dev->flags & IFF_NOARP) ||
|
|
!pskb_may_pull(skb, arp_hdr_len(dev)))
|
|
return;
|
|
|
|
parp = arp_hdr(skb);
|
|
|
|
if (parp->ar_pro != htons(ETH_P_IP) ||
|
|
parp->ar_op != htons(ARPOP_REQUEST) ||
|
|
parp->ar_hln != dev->addr_len ||
|
|
parp->ar_pln != 4)
|
|
return;
|
|
|
|
arpptr = (u8 *)parp + sizeof(struct arphdr);
|
|
sha = arpptr;
|
|
arpptr += dev->addr_len; /* sha */
|
|
memcpy(&sip, arpptr, sizeof(sip));
|
|
arpptr += sizeof(sip);
|
|
arpptr += dev->addr_len; /* tha */
|
|
memcpy(&tip, arpptr, sizeof(tip));
|
|
|
|
if (ipv4_is_loopback(tip) ||
|
|
ipv4_is_multicast(tip))
|
|
return;
|
|
|
|
n = neigh_lookup(&arp_tbl, &tip, dev);
|
|
if (n) {
|
|
struct net_bridge_fdb_entry *f;
|
|
|
|
if (!(n->nud_state & NUD_VALID)) {
|
|
neigh_release(n);
|
|
return;
|
|
}
|
|
|
|
f = br_fdb_find_rcu(br, n->ha, vid);
|
|
if (f && ((p->flags & BR_PROXYARP) ||
|
|
(f->dst && (f->dst->flags & BR_PROXYARP_WIFI)))) {
|
|
arp_send(ARPOP_REPLY, ETH_P_ARP, sip, skb->dev, tip,
|
|
sha, n->ha, sha);
|
|
BR_INPUT_SKB_CB(skb)->proxyarp_replied = true;
|
|
}
|
|
|
|
neigh_release(n);
|
|
}
|
|
}
|
|
|
|
/* note: already called with rcu_read_lock */
|
|
int br_handle_frame_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
|
|
{
|
|
struct net_bridge_port *p = br_port_get_rcu(skb->dev);
|
|
enum br_pkt_type pkt_type = BR_PKT_UNICAST;
|
|
struct net_bridge_fdb_entry *dst = NULL;
|
|
struct net_bridge_mdb_entry *mdst;
|
|
bool local_rcv, mcast_hit = false;
|
|
const unsigned char *dest;
|
|
struct net_bridge *br;
|
|
u16 vid = 0;
|
|
|
|
if (!p || p->state == BR_STATE_DISABLED)
|
|
goto drop;
|
|
|
|
if (!br_allowed_ingress(p->br, nbp_vlan_group_rcu(p), skb, &vid))
|
|
goto out;
|
|
|
|
nbp_switchdev_frame_mark(p, skb);
|
|
|
|
/* insert into forwarding database after filtering to avoid spoofing */
|
|
br = p->br;
|
|
if (p->flags & BR_LEARNING)
|
|
br_fdb_update(br, p, eth_hdr(skb)->h_source, vid, false);
|
|
|
|
local_rcv = !!(br->dev->flags & IFF_PROMISC);
|
|
dest = eth_hdr(skb)->h_dest;
|
|
if (is_multicast_ether_addr(dest)) {
|
|
/* by definition the broadcast is also a multicast address */
|
|
if (is_broadcast_ether_addr(dest)) {
|
|
pkt_type = BR_PKT_BROADCAST;
|
|
local_rcv = true;
|
|
} else {
|
|
pkt_type = BR_PKT_MULTICAST;
|
|
if (br_multicast_rcv(br, p, skb, vid))
|
|
goto drop;
|
|
}
|
|
}
|
|
|
|
if (p->state == BR_STATE_LEARNING)
|
|
goto drop;
|
|
|
|
BR_INPUT_SKB_CB(skb)->brdev = br->dev;
|
|
|
|
if (IS_ENABLED(CONFIG_INET) && skb->protocol == htons(ETH_P_ARP))
|
|
br_do_proxy_arp(skb, br, vid, p);
|
|
|
|
switch (pkt_type) {
|
|
case BR_PKT_MULTICAST:
|
|
mdst = br_mdb_get(br, skb, vid);
|
|
if ((mdst || BR_INPUT_SKB_CB_MROUTERS_ONLY(skb)) &&
|
|
br_multicast_querier_exists(br, eth_hdr(skb))) {
|
|
if ((mdst && mdst->mglist) ||
|
|
br_multicast_is_router(br)) {
|
|
local_rcv = true;
|
|
br->dev->stats.multicast++;
|
|
}
|
|
mcast_hit = true;
|
|
} else {
|
|
local_rcv = true;
|
|
br->dev->stats.multicast++;
|
|
}
|
|
break;
|
|
case BR_PKT_UNICAST:
|
|
dst = br_fdb_find_rcu(br, dest, vid);
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (dst) {
|
|
unsigned long now = jiffies;
|
|
|
|
if (dst->is_local)
|
|
return br_pass_frame_up(skb);
|
|
|
|
if (now != dst->used)
|
|
dst->used = now;
|
|
br_forward(dst->dst, skb, local_rcv, false);
|
|
} else {
|
|
if (!mcast_hit)
|
|
br_flood(br, skb, pkt_type, local_rcv, false);
|
|
else
|
|
br_multicast_flood(mdst, skb, local_rcv, false);
|
|
}
|
|
|
|
if (local_rcv)
|
|
return br_pass_frame_up(skb);
|
|
|
|
out:
|
|
return 0;
|
|
drop:
|
|
kfree_skb(skb);
|
|
goto out;
|
|
}
|
|
EXPORT_SYMBOL_GPL(br_handle_frame_finish);
|
|
|
|
static void __br_handle_local_finish(struct sk_buff *skb)
|
|
{
|
|
struct net_bridge_port *p = br_port_get_rcu(skb->dev);
|
|
u16 vid = 0;
|
|
|
|
/* check if vlan is allowed, to avoid spoofing */
|
|
if (p->flags & BR_LEARNING && br_should_learn(p, skb, &vid))
|
|
br_fdb_update(p->br, p, eth_hdr(skb)->h_source, vid, false);
|
|
}
|
|
|
|
/* note: already called with rcu_read_lock */
|
|
static int br_handle_local_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
|
|
{
|
|
struct net_bridge_port *p = br_port_get_rcu(skb->dev);
|
|
|
|
__br_handle_local_finish(skb);
|
|
|
|
BR_INPUT_SKB_CB(skb)->brdev = p->br->dev;
|
|
br_pass_frame_up(skb);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Return NULL if skb is handled
|
|
* note: already called with rcu_read_lock
|
|
*/
|
|
rx_handler_result_t br_handle_frame(struct sk_buff **pskb)
|
|
{
|
|
struct net_bridge_port *p;
|
|
struct sk_buff *skb = *pskb;
|
|
const unsigned char *dest = eth_hdr(skb)->h_dest;
|
|
br_should_route_hook_t *rhook;
|
|
|
|
if (unlikely(skb->pkt_type == PACKET_LOOPBACK))
|
|
return RX_HANDLER_PASS;
|
|
|
|
if (!is_valid_ether_addr(eth_hdr(skb)->h_source))
|
|
goto drop;
|
|
|
|
skb = skb_share_check(skb, GFP_ATOMIC);
|
|
if (!skb)
|
|
return RX_HANDLER_CONSUMED;
|
|
|
|
p = br_port_get_rcu(skb->dev);
|
|
if (p->flags & BR_VLAN_TUNNEL) {
|
|
if (br_handle_ingress_vlan_tunnel(skb, p,
|
|
nbp_vlan_group_rcu(p)))
|
|
goto drop;
|
|
}
|
|
|
|
if (unlikely(is_link_local_ether_addr(dest))) {
|
|
u16 fwd_mask = p->br->group_fwd_mask_required;
|
|
|
|
/*
|
|
* See IEEE 802.1D Table 7-10 Reserved addresses
|
|
*
|
|
* Assignment Value
|
|
* Bridge Group Address 01-80-C2-00-00-00
|
|
* (MAC Control) 802.3 01-80-C2-00-00-01
|
|
* (Link Aggregation) 802.3 01-80-C2-00-00-02
|
|
* 802.1X PAE address 01-80-C2-00-00-03
|
|
*
|
|
* 802.1AB LLDP 01-80-C2-00-00-0E
|
|
*
|
|
* Others reserved for future standardization
|
|
*/
|
|
switch (dest[5]) {
|
|
case 0x00: /* Bridge Group Address */
|
|
/* If STP is turned off,
|
|
then must forward to keep loop detection */
|
|
if (p->br->stp_enabled == BR_NO_STP ||
|
|
fwd_mask & (1u << dest[5]))
|
|
goto forward;
|
|
*pskb = skb;
|
|
__br_handle_local_finish(skb);
|
|
return RX_HANDLER_PASS;
|
|
|
|
case 0x01: /* IEEE MAC (Pause) */
|
|
goto drop;
|
|
|
|
case 0x0E: /* 802.1AB LLDP */
|
|
fwd_mask |= p->br->group_fwd_mask;
|
|
if (fwd_mask & (1u << dest[5]))
|
|
goto forward;
|
|
*pskb = skb;
|
|
__br_handle_local_finish(skb);
|
|
return RX_HANDLER_PASS;
|
|
|
|
default:
|
|
/* Allow selective forwarding for most other protocols */
|
|
fwd_mask |= p->br->group_fwd_mask;
|
|
if (fwd_mask & (1u << dest[5]))
|
|
goto forward;
|
|
}
|
|
|
|
/* Deliver packet to local host only */
|
|
NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_IN, dev_net(skb->dev),
|
|
NULL, skb, skb->dev, NULL, br_handle_local_finish);
|
|
return RX_HANDLER_CONSUMED;
|
|
}
|
|
|
|
forward:
|
|
switch (p->state) {
|
|
case BR_STATE_FORWARDING:
|
|
rhook = rcu_dereference(br_should_route_hook);
|
|
if (rhook) {
|
|
if ((*rhook)(skb)) {
|
|
*pskb = skb;
|
|
return RX_HANDLER_PASS;
|
|
}
|
|
dest = eth_hdr(skb)->h_dest;
|
|
}
|
|
/* fall through */
|
|
case BR_STATE_LEARNING:
|
|
if (ether_addr_equal(p->br->dev->dev_addr, dest))
|
|
skb->pkt_type = PACKET_HOST;
|
|
|
|
NF_HOOK(NFPROTO_BRIDGE, NF_BR_PRE_ROUTING,
|
|
dev_net(skb->dev), NULL, skb, skb->dev, NULL,
|
|
br_handle_frame_finish);
|
|
break;
|
|
default:
|
|
drop:
|
|
kfree_skb(skb);
|
|
}
|
|
return RX_HANDLER_CONSUMED;
|
|
}
|