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