Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Handle incoming frames |
| 3 | * Linux ethernet bridge |
| 4 | * |
| 5 | * Authors: |
| 6 | * Lennert Buytenhek <buytenh@gnu.org> |
| 7 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 14 | #include <linux/slab.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | #include <linux/kernel.h> |
| 16 | #include <linux/netdevice.h> |
| 17 | #include <linux/etherdevice.h> |
| 18 | #include <linux/netfilter_bridge.h> |
Kyeyoon Park | 9585011 | 2014-10-23 14:49:17 -0700 | [diff] [blame] | 19 | #include <linux/neighbour.h> |
| 20 | #include <net/arp.h> |
Paul Gortmaker | bc3b2d7 | 2011-07-15 11:47:34 -0400 | [diff] [blame] | 21 | #include <linux/export.h> |
Vlad Yasevich | a37b85c | 2013-02-13 12:00:10 +0000 | [diff] [blame] | 22 | #include <linux/rculist.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 23 | #include "br_private.h" |
| 24 | |
Eric Dumazet | a386f99 | 2010-11-15 06:38:11 +0000 | [diff] [blame] | 25 | /* Hook for brouter */ |
| 26 | br_should_route_hook_t __rcu *br_should_route_hook __read_mostly; |
| 27 | EXPORT_SYMBOL(br_should_route_hook); |
| 28 | |
Eric W. Biederman | 0c4b51f | 2015-09-15 20:04:18 -0500 | [diff] [blame] | 29 | static int |
| 30 | br_netif_receive_skb(struct net *net, struct sock *sk, struct sk_buff *skb) |
Eric W. Biederman | 04eb448 | 2015-09-15 20:04:15 -0500 | [diff] [blame] | 31 | { |
| 32 | return netif_receive_skb(skb); |
| 33 | } |
| 34 | |
Herbert Xu | 68b7c89 | 2010-02-27 19:41:40 +0000 | [diff] [blame] | 35 | static int br_pass_frame_up(struct sk_buff *skb) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 36 | { |
Herbert Xu | 68b7c89 | 2010-02-27 19:41:40 +0000 | [diff] [blame] | 37 | struct net_device *indev, *brdev = BR_INPUT_SKB_CB(skb)->brdev; |
stephen hemminger | 14bb478 | 2010-03-02 13:32:09 +0000 | [diff] [blame] | 38 | struct net_bridge *br = netdev_priv(brdev); |
Nikolay Aleksandrov | 2594e90 | 2015-09-25 19:00:11 +0200 | [diff] [blame] | 39 | struct net_bridge_vlan_group *vg; |
Li RongQing | 8f84985 | 2014-01-04 13:57:59 +0800 | [diff] [blame] | 40 | struct pcpu_sw_netstats *brstats = this_cpu_ptr(br->stats); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 41 | |
Eric Dumazet | 406818f | 2010-06-23 13:00:48 -0700 | [diff] [blame] | 42 | u64_stats_update_begin(&brstats->syncp); |
stephen hemminger | 14bb478 | 2010-03-02 13:32:09 +0000 | [diff] [blame] | 43 | brstats->rx_packets++; |
| 44 | brstats->rx_bytes += skb->len; |
Eric Dumazet | 406818f | 2010-06-23 13:00:48 -0700 | [diff] [blame] | 45 | u64_stats_update_end(&brstats->syncp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 46 | |
Nikolay Aleksandrov | 907b1e6 | 2015-10-12 21:47:02 +0200 | [diff] [blame] | 47 | vg = br_vlan_group_rcu(br); |
Vlad Yasevich | 85f46c6 | 2013-02-13 12:00:11 +0000 | [diff] [blame] | 48 | /* Bridge is just like any other port. Make sure the |
| 49 | * packet is allowed except in promisc modue when someone |
| 50 | * may be running packet capture. |
| 51 | */ |
| 52 | if (!(brdev->flags & IFF_PROMISC) && |
Nikolay Aleksandrov | 2594e90 | 2015-09-25 19:00:11 +0200 | [diff] [blame] | 53 | !br_allowed_egress(vg, skb)) { |
Vlad Yasevich | 85f46c6 | 2013-02-13 12:00:11 +0000 | [diff] [blame] | 54 | kfree_skb(skb); |
| 55 | return NET_RX_DROP; |
| 56 | } |
| 57 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 58 | indev = skb->dev; |
Pavel Emelyanov | a339f1c | 2008-05-21 14:13:47 -0700 | [diff] [blame] | 59 | skb->dev = brdev; |
Nikolay Aleksandrov | 2594e90 | 2015-09-25 19:00:11 +0200 | [diff] [blame] | 60 | skb = br_handle_vlan(br, vg, skb); |
Vlad Yasevich | fc92f74 | 2014-03-27 21:51:18 -0400 | [diff] [blame] | 61 | if (!skb) |
| 62 | return NET_RX_DROP; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 63 | |
Eric W. Biederman | 29a26a5 | 2015-09-15 20:04:16 -0500 | [diff] [blame] | 64 | return NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_IN, |
| 65 | dev_net(indev), NULL, skb, indev, NULL, |
Eric W. Biederman | 04eb448 | 2015-09-15 20:04:15 -0500 | [diff] [blame] | 66 | br_netif_receive_skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 67 | } |
| 68 | |
Kyeyoon Park | 9585011 | 2014-10-23 14:49:17 -0700 | [diff] [blame] | 69 | static void br_do_proxy_arp(struct sk_buff *skb, struct net_bridge *br, |
Jouni Malinen | 842a9ae | 2015-03-04 12:54:21 +0200 | [diff] [blame] | 70 | u16 vid, struct net_bridge_port *p) |
Kyeyoon Park | 9585011 | 2014-10-23 14:49:17 -0700 | [diff] [blame] | 71 | { |
| 72 | struct net_device *dev = br->dev; |
| 73 | struct neighbour *n; |
| 74 | struct arphdr *parp; |
| 75 | u8 *arpptr, *sha; |
| 76 | __be32 sip, tip; |
| 77 | |
Jouni Malinen | 842a9ae | 2015-03-04 12:54:21 +0200 | [diff] [blame] | 78 | BR_INPUT_SKB_CB(skb)->proxyarp_replied = false; |
| 79 | |
Kyeyoon Park | 9585011 | 2014-10-23 14:49:17 -0700 | [diff] [blame] | 80 | if (dev->flags & IFF_NOARP) |
| 81 | return; |
| 82 | |
| 83 | if (!pskb_may_pull(skb, arp_hdr_len(dev))) { |
| 84 | dev->stats.tx_dropped++; |
| 85 | return; |
| 86 | } |
| 87 | parp = arp_hdr(skb); |
| 88 | |
| 89 | if (parp->ar_pro != htons(ETH_P_IP) || |
| 90 | parp->ar_op != htons(ARPOP_REQUEST) || |
| 91 | parp->ar_hln != dev->addr_len || |
| 92 | parp->ar_pln != 4) |
| 93 | return; |
| 94 | |
| 95 | arpptr = (u8 *)parp + sizeof(struct arphdr); |
| 96 | sha = arpptr; |
| 97 | arpptr += dev->addr_len; /* sha */ |
| 98 | memcpy(&sip, arpptr, sizeof(sip)); |
| 99 | arpptr += sizeof(sip); |
| 100 | arpptr += dev->addr_len; /* tha */ |
| 101 | memcpy(&tip, arpptr, sizeof(tip)); |
| 102 | |
| 103 | if (ipv4_is_loopback(tip) || |
| 104 | ipv4_is_multicast(tip)) |
| 105 | return; |
| 106 | |
| 107 | n = neigh_lookup(&arp_tbl, &tip, dev); |
| 108 | if (n) { |
| 109 | struct net_bridge_fdb_entry *f; |
| 110 | |
| 111 | if (!(n->nud_state & NUD_VALID)) { |
| 112 | neigh_release(n); |
| 113 | return; |
| 114 | } |
| 115 | |
| 116 | f = __br_fdb_get(br, n->ha, vid); |
Jouni Malinen | 842a9ae | 2015-03-04 12:54:21 +0200 | [diff] [blame] | 117 | if (f && ((p->flags & BR_PROXYARP) || |
| 118 | (f->dst && (f->dst->flags & BR_PROXYARP_WIFI)))) { |
Kyeyoon Park | 9585011 | 2014-10-23 14:49:17 -0700 | [diff] [blame] | 119 | arp_send(ARPOP_REPLY, ETH_P_ARP, sip, skb->dev, tip, |
| 120 | sha, n->ha, sha); |
Jouni Malinen | 842a9ae | 2015-03-04 12:54:21 +0200 | [diff] [blame] | 121 | BR_INPUT_SKB_CB(skb)->proxyarp_replied = true; |
| 122 | } |
Kyeyoon Park | 9585011 | 2014-10-23 14:49:17 -0700 | [diff] [blame] | 123 | |
| 124 | neigh_release(n); |
| 125 | } |
| 126 | } |
| 127 | |
stephen hemminger | eeaf61d | 2010-07-27 08:26:30 +0000 | [diff] [blame] | 128 | /* note: already called with rcu_read_lock */ |
Eric W. Biederman | 0c4b51f | 2015-09-15 20:04:18 -0500 | [diff] [blame] | 129 | int br_handle_frame_finish(struct net *net, struct sock *sk, struct sk_buff *skb) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 130 | { |
| 131 | const unsigned char *dest = eth_hdr(skb)->h_dest; |
Jiri Pirko | f350a0a8 | 2010-06-15 06:50:45 +0000 | [diff] [blame] | 132 | struct net_bridge_port *p = br_port_get_rcu(skb->dev); |
Stephen Hemminger | b3f1be4 | 2006-02-09 17:08:52 -0800 | [diff] [blame] | 133 | struct net_bridge *br; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 134 | struct net_bridge_fdb_entry *dst; |
Herbert Xu | c4fcb78 | 2010-02-27 19:41:48 +0000 | [diff] [blame] | 135 | struct net_bridge_mdb_entry *mdst; |
Herbert Xu | e081e1e | 2007-09-16 16:20:48 -0700 | [diff] [blame] | 136 | struct sk_buff *skb2; |
Vlad Yasevich | 867a594 | 2013-06-05 10:08:01 -0400 | [diff] [blame] | 137 | bool unicast = true; |
Vlad Yasevich | 7885198 | 2013-02-13 12:00:14 +0000 | [diff] [blame] | 138 | u16 vid = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 139 | |
Stephen Hemminger | b3f1be4 | 2006-02-09 17:08:52 -0800 | [diff] [blame] | 140 | if (!p || p->state == BR_STATE_DISABLED) |
| 141 | goto drop; |
Stephen Hemminger | 85967bb | 2005-05-29 14:15:55 -0700 | [diff] [blame] | 142 | |
Nikolay Aleksandrov | 907b1e6 | 2015-10-12 21:47:02 +0200 | [diff] [blame] | 143 | if (!br_allowed_ingress(p->br, nbp_vlan_group_rcu(p), skb, &vid)) |
Toshiaki Makita | eb70761 | 2014-04-09 17:00:30 +0900 | [diff] [blame] | 144 | goto out; |
Vlad Yasevich | a37b85c | 2013-02-13 12:00:10 +0000 | [diff] [blame] | 145 | |
Stephen Hemminger | b3f1be4 | 2006-02-09 17:08:52 -0800 | [diff] [blame] | 146 | /* insert into forwarding database after filtering to avoid spoofing */ |
| 147 | br = p->br; |
Vlad Yasevich | 9ba1889 | 2013-06-05 10:08:00 -0400 | [diff] [blame] | 148 | if (p->flags & BR_LEARNING) |
Toshiaki Makita | a5642ab | 2014-02-07 16:48:18 +0900 | [diff] [blame] | 149 | br_fdb_update(br, p, eth_hdr(skb)->h_source, vid, false); |
Stephen Hemminger | b3f1be4 | 2006-02-09 17:08:52 -0800 | [diff] [blame] | 150 | |
Herbert Xu | 4466146 | 2011-07-05 13:58:33 +0000 | [diff] [blame] | 151 | if (!is_broadcast_ether_addr(dest) && is_multicast_ether_addr(dest) && |
Vlad Yasevich | 0649909 | 2013-10-28 15:45:07 -0400 | [diff] [blame] | 152 | br_multicast_rcv(br, p, skb, vid)) |
Herbert Xu | c4fcb78 | 2010-02-27 19:41:48 +0000 | [diff] [blame] | 153 | goto drop; |
| 154 | |
Stephen Hemminger | b3f1be4 | 2006-02-09 17:08:52 -0800 | [diff] [blame] | 155 | if (p->state == BR_STATE_LEARNING) |
| 156 | goto drop; |
Stephen Hemminger | 0e5eaba | 2005-12-21 19:00:18 -0800 | [diff] [blame] | 157 | |
Herbert Xu | 68b7c89 | 2010-02-27 19:41:40 +0000 | [diff] [blame] | 158 | BR_INPUT_SKB_CB(skb)->brdev = br->dev; |
| 159 | |
Herbert Xu | e081e1e | 2007-09-16 16:20:48 -0700 | [diff] [blame] | 160 | /* The packet skb2 goes to the local host (NULL to skip). */ |
| 161 | skb2 = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 162 | |
Herbert Xu | e081e1e | 2007-09-16 16:20:48 -0700 | [diff] [blame] | 163 | if (br->dev->flags & IFF_PROMISC) |
| 164 | skb2 = skb; |
| 165 | |
| 166 | dst = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 167 | |
Jouni Malinen | 842a9ae | 2015-03-04 12:54:21 +0200 | [diff] [blame] | 168 | if (IS_ENABLED(CONFIG_INET) && skb->protocol == htons(ETH_P_ARP)) |
| 169 | br_do_proxy_arp(skb, br, vid, p); |
Kyeyoon Park | 9585011 | 2014-10-23 14:49:17 -0700 | [diff] [blame] | 170 | |
Jouni Malinen | 842a9ae | 2015-03-04 12:54:21 +0200 | [diff] [blame] | 171 | if (is_broadcast_ether_addr(dest)) { |
Herbert Xu | 4466146 | 2011-07-05 13:58:33 +0000 | [diff] [blame] | 172 | skb2 = skb; |
Vlad Yasevich | 867a594 | 2013-06-05 10:08:01 -0400 | [diff] [blame] | 173 | unicast = false; |
| 174 | } else if (is_multicast_ether_addr(dest)) { |
Cong Wang | fbca58a | 2013-03-07 03:05:33 +0000 | [diff] [blame] | 175 | mdst = br_mdb_get(br, skb, vid); |
Linus Lüssing | b00589a | 2013-08-01 01:06:20 +0200 | [diff] [blame] | 176 | if ((mdst || BR_INPUT_SKB_CB_MROUTERS_ONLY(skb)) && |
Linus Lüssing | cc0fdd8 | 2013-08-30 17:28:17 +0200 | [diff] [blame] | 177 | br_multicast_querier_exists(br, eth_hdr(skb))) { |
Herbert Xu | 8a87017 | 2011-02-12 01:05:42 -0800 | [diff] [blame] | 178 | if ((mdst && mdst->mglist) || |
Herbert Xu | c4fcb78 | 2010-02-27 19:41:48 +0000 | [diff] [blame] | 179 | br_multicast_is_router(br)) |
| 180 | skb2 = skb; |
| 181 | br_multicast_forward(mdst, skb, skb2); |
| 182 | skb = NULL; |
| 183 | if (!skb2) |
| 184 | goto out; |
| 185 | } else |
| 186 | skb2 = skb; |
| 187 | |
Vlad Yasevich | 867a594 | 2013-06-05 10:08:01 -0400 | [diff] [blame] | 188 | unicast = false; |
Pavel Emelyanov | a339f1c | 2008-05-21 14:13:47 -0700 | [diff] [blame] | 189 | br->dev->stats.multicast++; |
Vlad Yasevich | 2ba071e | 2013-02-13 12:00:16 +0000 | [diff] [blame] | 190 | } else if ((dst = __br_fdb_get(br, dest, vid)) && |
| 191 | dst->is_local) { |
Herbert Xu | e081e1e | 2007-09-16 16:20:48 -0700 | [diff] [blame] | 192 | skb2 = skb; |
| 193 | /* Do not forward the packet since it's local. */ |
| 194 | skb = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 195 | } |
| 196 | |
Herbert Xu | e081e1e | 2007-09-16 16:20:48 -0700 | [diff] [blame] | 197 | if (skb) { |
stephen hemminger | 7cd8861 | 2011-04-04 14:03:28 +0000 | [diff] [blame] | 198 | if (dst) { |
| 199 | dst->used = jiffies; |
Michael Braun | 7f7708f | 2010-03-16 00:26:22 -0700 | [diff] [blame] | 200 | br_forward(dst->dst, skb, skb2); |
stephen hemminger | 7cd8861 | 2011-04-04 14:03:28 +0000 | [diff] [blame] | 201 | } else |
Vlad Yasevich | 867a594 | 2013-06-05 10:08:01 -0400 | [diff] [blame] | 202 | br_flood_forward(br, skb, skb2, unicast); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 203 | } |
| 204 | |
Herbert Xu | 87557c1 | 2010-02-27 19:41:39 +0000 | [diff] [blame] | 205 | if (skb2) |
Herbert Xu | 68b7c89 | 2010-02-27 19:41:40 +0000 | [diff] [blame] | 206 | return br_pass_frame_up(skb2); |
Herbert Xu | 87557c1 | 2010-02-27 19:41:39 +0000 | [diff] [blame] | 207 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 208 | out: |
| 209 | return 0; |
Stephen Hemminger | b3f1be4 | 2006-02-09 17:08:52 -0800 | [diff] [blame] | 210 | drop: |
| 211 | kfree_skb(skb); |
| 212 | goto out; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 213 | } |
Pablo Neira Ayuso | 34666d4 | 2014-09-18 11:29:03 +0200 | [diff] [blame] | 214 | EXPORT_SYMBOL_GPL(br_handle_frame_finish); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 215 | |
stephen hemminger | eeaf61d | 2010-07-27 08:26:30 +0000 | [diff] [blame] | 216 | /* note: already called with rcu_read_lock */ |
Eric W. Biederman | 0c4b51f | 2015-09-15 20:04:18 -0500 | [diff] [blame] | 217 | static int br_handle_local_finish(struct net *net, struct sock *sk, struct sk_buff *skb) |
Stephen Hemminger | cf0f02d | 2006-03-20 22:59:06 -0800 | [diff] [blame] | 218 | { |
Jiri Pirko | f350a0a8 | 2010-06-15 06:50:45 +0000 | [diff] [blame] | 219 | struct net_bridge_port *p = br_port_get_rcu(skb->dev); |
Vlad Yasevich | 2ba071e | 2013-02-13 12:00:16 +0000 | [diff] [blame] | 220 | u16 vid = 0; |
Stephen Hemminger | cf0f02d | 2006-03-20 22:59:06 -0800 | [diff] [blame] | 221 | |
Toshiaki Makita | e0d7968 | 2014-05-26 15:15:53 +0900 | [diff] [blame] | 222 | /* check if vlan is allowed, to avoid spoofing */ |
| 223 | if (p->flags & BR_LEARNING && br_should_learn(p, skb, &vid)) |
Toshiaki Makita | a5642ab | 2014-02-07 16:48:18 +0900 | [diff] [blame] | 224 | br_fdb_update(p->br, p, eth_hdr(skb)->h_source, vid, false); |
Stephen Hemminger | cf0f02d | 2006-03-20 22:59:06 -0800 | [diff] [blame] | 225 | return 0; /* process further */ |
| 226 | } |
| 227 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 228 | /* |
Stephen Hemminger | 6229e36 | 2007-03-21 13:38:47 -0700 | [diff] [blame] | 229 | * Return NULL if skb is handled |
stephen hemminger | eeaf61d | 2010-07-27 08:26:30 +0000 | [diff] [blame] | 230 | * note: already called with rcu_read_lock |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 231 | */ |
Jiri Pirko | 8a4eb57 | 2011-03-12 03:14:39 +0000 | [diff] [blame] | 232 | rx_handler_result_t br_handle_frame(struct sk_buff **pskb) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 233 | { |
Jiri Pirko | ab95bfe | 2010-06-01 21:52:08 +0000 | [diff] [blame] | 234 | struct net_bridge_port *p; |
Jiri Pirko | 8a4eb57 | 2011-03-12 03:14:39 +0000 | [diff] [blame] | 235 | struct sk_buff *skb = *pskb; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 236 | const unsigned char *dest = eth_hdr(skb)->h_dest; |
Eric Dumazet | a386f99 | 2010-11-15 06:38:11 +0000 | [diff] [blame] | 237 | br_should_route_hook_t *rhook; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 238 | |
Simon Horman | c2368e7 | 2010-08-22 17:35:32 +0000 | [diff] [blame] | 239 | if (unlikely(skb->pkt_type == PACKET_LOOPBACK)) |
Jiri Pirko | 8a4eb57 | 2011-03-12 03:14:39 +0000 | [diff] [blame] | 240 | return RX_HANDLER_PASS; |
Jiri Pirko | ab95bfe | 2010-06-01 21:52:08 +0000 | [diff] [blame] | 241 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 242 | if (!is_valid_ether_addr(eth_hdr(skb)->h_source)) |
Stephen Hemminger | 467aea0 | 2007-03-21 13:42:06 -0700 | [diff] [blame] | 243 | goto drop; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 244 | |
Herbert Xu | 7b99565 | 2007-10-14 00:39:01 -0700 | [diff] [blame] | 245 | skb = skb_share_check(skb, GFP_ATOMIC); |
| 246 | if (!skb) |
Jiri Pirko | 8a4eb57 | 2011-03-12 03:14:39 +0000 | [diff] [blame] | 247 | return RX_HANDLER_CONSUMED; |
Herbert Xu | 7b99565 | 2007-10-14 00:39:01 -0700 | [diff] [blame] | 248 | |
Jiri Pirko | f350a0a8 | 2010-06-15 06:50:45 +0000 | [diff] [blame] | 249 | p = br_port_get_rcu(skb->dev); |
Jiri Pirko | ab95bfe | 2010-06-01 21:52:08 +0000 | [diff] [blame] | 250 | |
Ben Hutchings | 46acc46 | 2012-11-01 09:11:11 +0000 | [diff] [blame] | 251 | if (unlikely(is_link_local_ether_addr(dest))) { |
Toshiaki Makita | f2808d2 | 2014-06-10 20:59:24 +0900 | [diff] [blame] | 252 | u16 fwd_mask = p->br->group_fwd_mask_required; |
| 253 | |
stephen hemminger | 515853c | 2011-10-03 18:14:46 +0000 | [diff] [blame] | 254 | /* |
| 255 | * See IEEE 802.1D Table 7-10 Reserved addresses |
| 256 | * |
| 257 | * Assignment Value |
| 258 | * Bridge Group Address 01-80-C2-00-00-00 |
| 259 | * (MAC Control) 802.3 01-80-C2-00-00-01 |
| 260 | * (Link Aggregation) 802.3 01-80-C2-00-00-02 |
| 261 | * 802.1X PAE address 01-80-C2-00-00-03 |
| 262 | * |
| 263 | * 802.1AB LLDP 01-80-C2-00-00-0E |
| 264 | * |
| 265 | * Others reserved for future standardization |
| 266 | */ |
| 267 | switch (dest[5]) { |
| 268 | case 0x00: /* Bridge Group Address */ |
| 269 | /* If STP is turned off, |
| 270 | then must forward to keep loop detection */ |
Toshiaki Makita | f2808d2 | 2014-06-10 20:59:24 +0900 | [diff] [blame] | 271 | if (p->br->stp_enabled == BR_NO_STP || |
| 272 | fwd_mask & (1u << dest[5])) |
stephen hemminger | 515853c | 2011-10-03 18:14:46 +0000 | [diff] [blame] | 273 | goto forward; |
| 274 | break; |
| 275 | |
| 276 | case 0x01: /* IEEE MAC (Pause) */ |
Stephen Hemminger | 2111f8b | 2007-04-25 22:05:55 -0700 | [diff] [blame] | 277 | goto drop; |
| 278 | |
stephen hemminger | 515853c | 2011-10-03 18:14:46 +0000 | [diff] [blame] | 279 | default: |
| 280 | /* Allow selective forwarding for most other protocols */ |
Toshiaki Makita | f2808d2 | 2014-06-10 20:59:24 +0900 | [diff] [blame] | 281 | fwd_mask |= p->br->group_fwd_mask; |
| 282 | if (fwd_mask & (1u << dest[5])) |
stephen hemminger | 515853c | 2011-10-03 18:14:46 +0000 | [diff] [blame] | 283 | goto forward; |
| 284 | } |
Stephen Hemminger | a598f6a | 2009-05-15 06:10:13 +0000 | [diff] [blame] | 285 | |
stephen hemminger | 515853c | 2011-10-03 18:14:46 +0000 | [diff] [blame] | 286 | /* Deliver packet to local host only */ |
Eric W. Biederman | 29a26a5 | 2015-09-15 20:04:16 -0500 | [diff] [blame] | 287 | if (NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_IN, |
| 288 | dev_net(skb->dev), NULL, skb, skb->dev, NULL, |
| 289 | br_handle_local_finish)) { |
Jiri Pirko | 8a4eb57 | 2011-03-12 03:14:39 +0000 | [diff] [blame] | 290 | return RX_HANDLER_CONSUMED; /* consumed by filter */ |
| 291 | } else { |
| 292 | *pskb = skb; |
| 293 | return RX_HANDLER_PASS; /* continue processing */ |
| 294 | } |
Stephen Hemminger | 2111f8b | 2007-04-25 22:05:55 -0700 | [diff] [blame] | 295 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 296 | |
Stephen Hemminger | a598f6a | 2009-05-15 06:10:13 +0000 | [diff] [blame] | 297 | forward: |
Stephen Hemminger | 467aea0 | 2007-03-21 13:42:06 -0700 | [diff] [blame] | 298 | switch (p->state) { |
| 299 | case BR_STATE_FORWARDING: |
Pavel Emelyanov | 82de382 | 2007-11-29 23:58:58 +1100 | [diff] [blame] | 300 | rhook = rcu_dereference(br_should_route_hook); |
Eric Dumazet | a386f99 | 2010-11-15 06:38:11 +0000 | [diff] [blame] | 301 | if (rhook) { |
Jiri Pirko | 8a4eb57 | 2011-03-12 03:14:39 +0000 | [diff] [blame] | 302 | if ((*rhook)(skb)) { |
| 303 | *pskb = skb; |
| 304 | return RX_HANDLER_PASS; |
| 305 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 306 | dest = eth_hdr(skb)->h_dest; |
| 307 | } |
Stephen Hemminger | 467aea0 | 2007-03-21 13:42:06 -0700 | [diff] [blame] | 308 | /* fall through */ |
| 309 | case BR_STATE_LEARNING: |
Joe Perches | 9a7b6ef9 | 2012-05-08 18:56:49 +0000 | [diff] [blame] | 310 | if (ether_addr_equal(p->br->dev->dev_addr, dest)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 311 | skb->pkt_type = PACKET_HOST; |
| 312 | |
Eric W. Biederman | 29a26a5 | 2015-09-15 20:04:16 -0500 | [diff] [blame] | 313 | NF_HOOK(NFPROTO_BRIDGE, NF_BR_PRE_ROUTING, |
| 314 | dev_net(skb->dev), NULL, skb, skb->dev, NULL, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 315 | br_handle_frame_finish); |
Stephen Hemminger | 467aea0 | 2007-03-21 13:42:06 -0700 | [diff] [blame] | 316 | break; |
| 317 | default: |
| 318 | drop: |
| 319 | kfree_skb(skb); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 320 | } |
Jiri Pirko | 8a4eb57 | 2011-03-12 03:14:39 +0000 | [diff] [blame] | 321 | return RX_HANDLER_CONSUMED; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 322 | } |