1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Handle bridge arp/nd proxy/suppress 4 * 5 * Copyright (C) 2017 Cumulus Networks 6 * Copyright (c) 2017 Roopa Prabhu <roopa@cumulusnetworks.com> 7 * 8 * Authors: 9 * Roopa Prabhu <roopa@cumulusnetworks.com> 10 */ 11 12 #include <linux/kernel.h> 13 #include <linux/netdevice.h> 14 #include <linux/etherdevice.h> 15 #include <linux/neighbour.h> 16 #include <net/arp.h> 17 #include <linux/if_vlan.h> 18 #include <linux/inetdevice.h> 19 #include <net/addrconf.h> 20 #include <net/ipv6_stubs.h> 21 #if IS_ENABLED(CONFIG_IPV6) 22 #include <net/ip6_checksum.h> 23 #endif 24 25 #include "br_private.h" 26 27 void br_recalculate_neigh_suppress_enabled(struct net_bridge *br) 28 { 29 struct net_bridge_port *p; 30 bool neigh_suppress = false; 31 32 list_for_each_entry(p, &br->port_list, list) { 33 if (p->flags & (BR_NEIGH_SUPPRESS | BR_NEIGH_VLAN_SUPPRESS)) { 34 neigh_suppress = true; 35 break; 36 } 37 } 38 39 br_opt_toggle(br, BROPT_NEIGH_SUPPRESS_ENABLED, neigh_suppress); 40 } 41 42 #if IS_ENABLED(CONFIG_INET) 43 static void br_arp_send(struct net_bridge *br, struct net_bridge_port *p, 44 struct net_device *dev, __be32 dest_ip, __be32 src_ip, 45 const unsigned char *dest_hw, 46 const unsigned char *src_hw, 47 const unsigned char *target_hw, 48 __be16 vlan_proto, u16 vlan_tci) 49 { 50 struct net_bridge_vlan_group *vg; 51 struct sk_buff *skb; 52 u16 pvid; 53 54 netdev_dbg(dev, "arp send dev %s dst %pI4 dst_hw %pM src %pI4 src_hw %pM\n", 55 dev->name, &dest_ip, dest_hw, &src_ip, src_hw); 56 57 if (!vlan_tci) { 58 arp_send(ARPOP_REPLY, ETH_P_ARP, dest_ip, dev, src_ip, 59 dest_hw, src_hw, target_hw); 60 return; 61 } 62 63 skb = arp_create(ARPOP_REPLY, ETH_P_ARP, dest_ip, dev, src_ip, 64 dest_hw, src_hw, target_hw); 65 if (!skb) 66 return; 67 68 if (p) 69 vg = nbp_vlan_group_rcu(p); 70 else 71 vg = br_vlan_group_rcu(br); 72 pvid = br_get_pvid(vg); 73 if (pvid == (vlan_tci & VLAN_VID_MASK)) 74 vlan_tci = 0; 75 76 if (vlan_tci) 77 __vlan_hwaccel_put_tag(skb, vlan_proto, vlan_tci); 78 79 if (p) { 80 arp_xmit(skb); 81 } else { 82 skb_reset_mac_header(skb); 83 __skb_pull(skb, skb_network_offset(skb)); 84 skb->ip_summed = CHECKSUM_UNNECESSARY; 85 skb->pkt_type = PACKET_HOST; 86 87 netif_rx(skb); 88 } 89 } 90 91 static int br_chk_addr_ip(struct net_device *dev, 92 struct netdev_nested_priv *priv) 93 { 94 __be32 ip = *(__be32 *)priv->data; 95 struct in_device *in_dev; 96 __be32 addr = 0; 97 98 in_dev = __in_dev_get_rcu(dev); 99 if (in_dev) 100 addr = inet_confirm_addr(dev_net(dev), in_dev, 0, ip, 101 RT_SCOPE_HOST); 102 103 if (addr == ip) 104 return 1; 105 106 return 0; 107 } 108 109 static bool br_is_local_ip(struct net_device *dev, __be32 ip) 110 { 111 struct netdev_nested_priv priv = { 112 .data = (void *)&ip, 113 }; 114 115 if (br_chk_addr_ip(dev, &priv)) 116 return true; 117 118 /* check if ip is configured on upper dev */ 119 if (netdev_walk_all_upper_dev_rcu(dev, br_chk_addr_ip, &priv)) 120 return true; 121 122 return false; 123 } 124 125 void br_do_proxy_suppress_arp(struct sk_buff *skb, struct net_bridge *br, 126 u16 vid, struct net_bridge_port *p) 127 { 128 struct net_device *dev = br->dev; 129 struct net_device *vlandev = dev; 130 struct neighbour *n; 131 struct arphdr *parp; 132 u8 *arpptr, *sha; 133 __be32 sip, tip; 134 135 BR_INPUT_SKB_CB(skb)->proxyarp_replied = 0; 136 137 if ((dev->flags & IFF_NOARP) || 138 !pskb_may_pull(skb, arp_hdr_len(dev))) 139 return; 140 141 parp = arp_hdr(skb); 142 143 if (parp->ar_pro != htons(ETH_P_IP) || 144 parp->ar_hln != dev->addr_len || 145 parp->ar_pln != 4) 146 return; 147 148 arpptr = (u8 *)parp + sizeof(struct arphdr); 149 sha = arpptr; 150 arpptr += dev->addr_len; /* sha */ 151 memcpy(&sip, arpptr, sizeof(sip)); 152 arpptr += sizeof(sip); 153 arpptr += dev->addr_len; /* tha */ 154 memcpy(&tip, arpptr, sizeof(tip)); 155 156 if (ipv4_is_loopback(tip) || 157 ipv4_is_multicast(tip)) 158 return; 159 160 if (br_opt_get(br, BROPT_NEIGH_SUPPRESS_ENABLED)) { 161 if (br_is_neigh_suppress_enabled(p, vid)) 162 return; 163 if (is_unicast_ether_addr(eth_hdr(skb)->h_dest) && 164 parp->ar_op == htons(ARPOP_REQUEST)) 165 return; 166 if (parp->ar_op != htons(ARPOP_RREQUEST) && 167 parp->ar_op != htons(ARPOP_RREPLY) && 168 (ipv4_is_zeronet(sip) || sip == tip)) { 169 /* prevent flooding to neigh suppress ports */ 170 BR_INPUT_SKB_CB(skb)->proxyarp_replied = 1; 171 return; 172 } 173 } 174 175 if (parp->ar_op != htons(ARPOP_REQUEST)) 176 return; 177 178 if (vid != 0) { 179 vlandev = __vlan_find_dev_deep_rcu(br->dev, skb->vlan_proto, 180 vid); 181 if (!vlandev) 182 return; 183 } 184 185 if (br_opt_get(br, BROPT_NEIGH_SUPPRESS_ENABLED) && 186 br_is_local_ip(vlandev, tip)) { 187 /* its our local ip, so don't proxy reply 188 * and don't forward to neigh suppress ports 189 */ 190 BR_INPUT_SKB_CB(skb)->proxyarp_replied = 1; 191 return; 192 } 193 194 n = neigh_lookup(&arp_tbl, &tip, vlandev); 195 if (n) { 196 struct net_bridge_fdb_entry *f; 197 198 if (!(READ_ONCE(n->nud_state) & NUD_VALID)) { 199 neigh_release(n); 200 return; 201 } 202 203 f = br_fdb_find_rcu(br, n->ha, vid); 204 if (f) { 205 bool replied = false; 206 207 if ((p && (p->flags & BR_PROXYARP)) || 208 (f->dst && (f->dst->flags & BR_PROXYARP_WIFI)) || 209 br_is_neigh_suppress_enabled(f->dst, vid)) { 210 if (!vid) 211 br_arp_send(br, p, skb->dev, sip, tip, 212 sha, n->ha, sha, 0, 0); 213 else 214 br_arp_send(br, p, skb->dev, sip, tip, 215 sha, n->ha, sha, 216 skb->vlan_proto, 217 skb_vlan_tag_get(skb)); 218 replied = true; 219 } 220 221 /* If we have replied or as long as we know the 222 * mac, indicate to arp replied 223 */ 224 if (replied || 225 br_opt_get(br, BROPT_NEIGH_SUPPRESS_ENABLED)) 226 BR_INPUT_SKB_CB(skb)->proxyarp_replied = 1; 227 } 228 229 neigh_release(n); 230 } 231 } 232 #endif 233 234 #if IS_ENABLED(CONFIG_IPV6) 235 struct nd_msg *br_is_nd_neigh_msg(const struct sk_buff *skb, struct nd_msg *msg) 236 { 237 struct nd_msg *m; 238 239 m = skb_header_pointer(skb, skb_network_offset(skb) + 240 sizeof(struct ipv6hdr), sizeof(*msg), msg); 241 if (!m) 242 return NULL; 243 244 if (m->icmph.icmp6_code != 0 || 245 (m->icmph.icmp6_type != NDISC_NEIGHBOUR_SOLICITATION && 246 m->icmph.icmp6_type != NDISC_NEIGHBOUR_ADVERTISEMENT)) 247 return NULL; 248 249 return m; 250 } 251 252 static void br_nd_send(struct net_bridge *br, struct net_bridge_port *p, 253 struct sk_buff *request, struct neighbour *n, 254 __be16 vlan_proto, u16 vlan_tci) 255 { 256 struct net_device *dev = request->dev; 257 struct net_bridge_vlan_group *vg; 258 struct nd_msg *na, *ns; 259 struct sk_buff *reply; 260 struct ipv6hdr *pip6; 261 int na_olen = 8; /* opt hdr + ETH_ALEN for target */ 262 int ns_olen; 263 int i, len; 264 u8 *daddr; 265 u16 pvid; 266 267 if (!dev || skb_linearize(request)) 268 return; 269 270 len = LL_RESERVED_SPACE(dev) + sizeof(struct ipv6hdr) + 271 sizeof(*na) + na_olen + dev->needed_tailroom; 272 273 reply = alloc_skb(len, GFP_ATOMIC); 274 if (!reply) 275 return; 276 277 reply->protocol = htons(ETH_P_IPV6); 278 reply->dev = dev; 279 skb_reserve(reply, LL_RESERVED_SPACE(dev)); 280 skb_push(reply, sizeof(struct ethhdr)); 281 skb_set_mac_header(reply, 0); 282 283 daddr = eth_hdr(request)->h_source; 284 ns = (struct nd_msg *)(skb_network_header(request) + 285 sizeof(struct ipv6hdr)); 286 287 /* Do we need option processing ? */ 288 ns_olen = request->len - (skb_network_offset(request) + 289 sizeof(struct ipv6hdr)) - sizeof(*ns); 290 for (i = 0; i < ns_olen - 1; i += (ns->opt[i + 1] << 3)) { 291 if (!ns->opt[i + 1] || i + (ns->opt[i + 1] << 3) > ns_olen) { 292 kfree_skb(reply); 293 return; 294 } 295 if (ns->opt[i] == ND_OPT_SOURCE_LL_ADDR) { 296 if ((ns->opt[i + 1] << 3) >= 297 sizeof(struct nd_opt_hdr) + ETH_ALEN) 298 daddr = ns->opt + i + sizeof(struct nd_opt_hdr); 299 break; 300 } 301 } 302 303 /* Ethernet header */ 304 ether_addr_copy(eth_hdr(reply)->h_dest, daddr); 305 ether_addr_copy(eth_hdr(reply)->h_source, n->ha); 306 eth_hdr(reply)->h_proto = htons(ETH_P_IPV6); 307 reply->protocol = htons(ETH_P_IPV6); 308 309 skb_pull(reply, sizeof(struct ethhdr)); 310 skb_set_network_header(reply, 0); 311 skb_put(reply, sizeof(struct ipv6hdr)); 312 313 /* IPv6 header */ 314 pip6 = ipv6_hdr(reply); 315 memset(pip6, 0, sizeof(struct ipv6hdr)); 316 pip6->version = 6; 317 pip6->priority = ipv6_hdr(request)->priority; 318 pip6->nexthdr = IPPROTO_ICMPV6; 319 pip6->hop_limit = 255; 320 pip6->daddr = ipv6_hdr(request)->saddr; 321 pip6->saddr = *(struct in6_addr *)n->primary_key; 322 323 skb_pull(reply, sizeof(struct ipv6hdr)); 324 skb_set_transport_header(reply, 0); 325 326 na = (struct nd_msg *)skb_put(reply, sizeof(*na) + na_olen); 327 328 /* Neighbor Advertisement */ 329 memset(na, 0, sizeof(*na) + na_olen); 330 na->icmph.icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT; 331 na->icmph.icmp6_router = (n->flags & NTF_ROUTER) ? 1 : 0; 332 na->icmph.icmp6_override = 1; 333 na->icmph.icmp6_solicited = 1; 334 na->target = ns->target; 335 ether_addr_copy(&na->opt[2], n->ha); 336 na->opt[0] = ND_OPT_TARGET_LL_ADDR; 337 na->opt[1] = na_olen >> 3; 338 339 na->icmph.icmp6_cksum = csum_ipv6_magic(&pip6->saddr, 340 &pip6->daddr, 341 sizeof(*na) + na_olen, 342 IPPROTO_ICMPV6, 343 csum_partial(na, sizeof(*na) + na_olen, 0)); 344 345 pip6->payload_len = htons(sizeof(*na) + na_olen); 346 347 skb_push(reply, sizeof(struct ipv6hdr)); 348 skb_push(reply, sizeof(struct ethhdr)); 349 350 reply->ip_summed = CHECKSUM_UNNECESSARY; 351 352 if (p) 353 vg = nbp_vlan_group_rcu(p); 354 else 355 vg = br_vlan_group_rcu(br); 356 pvid = br_get_pvid(vg); 357 if (pvid == (vlan_tci & VLAN_VID_MASK)) 358 vlan_tci = 0; 359 360 if (vlan_tci) 361 __vlan_hwaccel_put_tag(reply, vlan_proto, vlan_tci); 362 363 netdev_dbg(dev, "nd send dev %s dst %pI6 dst_hw %pM src %pI6 src_hw %pM\n", 364 dev->name, &pip6->daddr, daddr, &pip6->saddr, n->ha); 365 366 if (p) { 367 dev_queue_xmit(reply); 368 } else { 369 skb_reset_mac_header(reply); 370 __skb_pull(reply, skb_network_offset(reply)); 371 reply->ip_summed = CHECKSUM_UNNECESSARY; 372 reply->pkt_type = PACKET_HOST; 373 374 netif_rx(reply); 375 } 376 } 377 378 static int br_chk_addr_ip6(struct net_device *dev, 379 struct netdev_nested_priv *priv) 380 { 381 struct in6_addr *addr = (struct in6_addr *)priv->data; 382 383 if (ipv6_chk_addr(dev_net(dev), addr, dev, 0)) 384 return 1; 385 386 return 0; 387 } 388 389 static bool br_is_local_ip6(struct net_device *dev, struct in6_addr *addr) 390 391 { 392 struct netdev_nested_priv priv = { 393 .data = (void *)addr, 394 }; 395 396 if (br_chk_addr_ip6(dev, &priv)) 397 return true; 398 399 /* check if ip is configured on upper dev */ 400 if (netdev_walk_all_upper_dev_rcu(dev, br_chk_addr_ip6, &priv)) 401 return true; 402 403 return false; 404 } 405 406 void br_do_suppress_nd(struct sk_buff *skb, struct net_bridge *br, 407 u16 vid, struct net_bridge_port *p, struct nd_msg *msg) 408 { 409 struct net_device *dev = br->dev; 410 struct net_device *vlandev = NULL; 411 struct in6_addr *saddr, *daddr; 412 struct ipv6hdr *iphdr; 413 struct neighbour *n; 414 415 BR_INPUT_SKB_CB(skb)->proxyarp_replied = 0; 416 417 if (br_is_neigh_suppress_enabled(p, vid)) 418 return; 419 420 if (is_unicast_ether_addr(eth_hdr(skb)->h_dest) && 421 msg->icmph.icmp6_type == NDISC_NEIGHBOUR_SOLICITATION) 422 return; 423 424 if (msg->icmph.icmp6_type == NDISC_NEIGHBOUR_ADVERTISEMENT && 425 !msg->icmph.icmp6_solicited) { 426 /* prevent flooding to neigh suppress ports */ 427 BR_INPUT_SKB_CB(skb)->proxyarp_replied = 1; 428 return; 429 } 430 431 if (msg->icmph.icmp6_type != NDISC_NEIGHBOUR_SOLICITATION) 432 return; 433 434 iphdr = ipv6_hdr(skb); 435 saddr = &iphdr->saddr; 436 daddr = &iphdr->daddr; 437 438 if (ipv6_addr_any(saddr) || !ipv6_addr_cmp(saddr, daddr)) { 439 /* prevent flooding to neigh suppress ports */ 440 BR_INPUT_SKB_CB(skb)->proxyarp_replied = 1; 441 return; 442 } 443 444 if (vid != 0) { 445 /* build neigh table lookup on the vlan device */ 446 vlandev = __vlan_find_dev_deep_rcu(br->dev, skb->vlan_proto, 447 vid); 448 if (!vlandev) 449 return; 450 } else { 451 vlandev = dev; 452 } 453 454 if (br_is_local_ip6(vlandev, &msg->target)) { 455 /* its our own ip, so don't proxy reply 456 * and don't forward to arp suppress ports 457 */ 458 BR_INPUT_SKB_CB(skb)->proxyarp_replied = 1; 459 return; 460 } 461 462 n = neigh_lookup(ipv6_stub->nd_tbl, &msg->target, vlandev); 463 if (n) { 464 struct net_bridge_fdb_entry *f; 465 466 if (!(READ_ONCE(n->nud_state) & NUD_VALID)) { 467 neigh_release(n); 468 return; 469 } 470 471 f = br_fdb_find_rcu(br, n->ha, vid); 472 if (f) { 473 bool replied = false; 474 475 if (br_is_neigh_suppress_enabled(f->dst, vid)) { 476 if (vid != 0) 477 br_nd_send(br, p, skb, n, 478 skb->vlan_proto, 479 skb_vlan_tag_get(skb)); 480 else 481 br_nd_send(br, p, skb, n, 0, 0); 482 replied = true; 483 } 484 485 /* If we have replied or as long as we know the 486 * mac, indicate to NEIGH_SUPPRESS ports that we 487 * have replied 488 */ 489 if (replied || 490 br_opt_get(br, BROPT_NEIGH_SUPPRESS_ENABLED)) 491 BR_INPUT_SKB_CB(skb)->proxyarp_replied = 1; 492 } 493 neigh_release(n); 494 } 495 } 496 #endif 497 498 bool br_is_neigh_suppress_enabled(const struct net_bridge_port *p, u16 vid) 499 { 500 if (!p) 501 return false; 502 503 if (!vid) 504 return !!(p->flags & BR_NEIGH_SUPPRESS); 505 506 if (p->flags & BR_NEIGH_VLAN_SUPPRESS) { 507 struct net_bridge_vlan_group *vg = nbp_vlan_group_rcu(p); 508 struct net_bridge_vlan *v; 509 510 v = br_vlan_find(vg, vid); 511 if (!v) 512 return false; 513 return !!(v->priv_flags & BR_VLFLAG_NEIGH_SUPPRESS_ENABLED); 514 } else { 515 return !!(p->flags & BR_NEIGH_SUPPRESS); 516 } 517 } 518