1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Neighbour Discovery for IPv6 4 * Linux INET6 implementation 5 * 6 * Authors: 7 * Pedro Roque <roque@di.fc.ul.pt> 8 * Mike Shaver <shaver@ingenia.com> 9 */ 10 11 /* 12 * Changes: 13 * 14 * Alexey I. Froloff : RFC6106 (DNSSL) support 15 * Pierre Ynard : export userland ND options 16 * through netlink (RDNSS support) 17 * Lars Fenneberg : fixed MTU setting on receipt 18 * of an RA. 19 * Janos Farkas : kmalloc failure checks 20 * Alexey Kuznetsov : state machine reworked 21 * and moved to net/core. 22 * Pekka Savola : RFC2461 validation 23 * YOSHIFUJI Hideaki @USAGI : Verify ND options properly 24 */ 25 26 #define pr_fmt(fmt) "ICMPv6: " fmt 27 28 #include <linux/module.h> 29 #include <linux/errno.h> 30 #include <linux/types.h> 31 #include <linux/socket.h> 32 #include <linux/sockios.h> 33 #include <linux/sched.h> 34 #include <linux/net.h> 35 #include <linux/in6.h> 36 #include <linux/route.h> 37 #include <linux/init.h> 38 #include <linux/rcupdate.h> 39 #include <linux/slab.h> 40 #ifdef CONFIG_SYSCTL 41 #include <linux/sysctl.h> 42 #endif 43 44 #include <linux/if_addr.h> 45 #include <linux/if_ether.h> 46 #include <linux/if_arp.h> 47 #include <linux/ipv6.h> 48 #include <linux/icmpv6.h> 49 #include <linux/jhash.h> 50 51 #include <net/sock.h> 52 #include <net/snmp.h> 53 54 #include <net/ipv6.h> 55 #include <net/protocol.h> 56 #include <net/ndisc.h> 57 #include <net/ip6_route.h> 58 #include <net/addrconf.h> 59 #include <net/icmp.h> 60 61 #include <net/netlink.h> 62 #include <linux/rtnetlink.h> 63 64 #include <net/flow.h> 65 #include <net/ip6_checksum.h> 66 #include <net/inet_common.h> 67 #include <linux/proc_fs.h> 68 69 #include <linux/netfilter.h> 70 #include <linux/netfilter_ipv6.h> 71 72 static u32 ndisc_hash(const void *pkey, 73 const struct net_device *dev, 74 __u32 *hash_rnd); 75 static bool ndisc_key_eq(const struct neighbour *neigh, const void *pkey); 76 static bool ndisc_allow_add(const struct net_device *dev, 77 struct netlink_ext_ack *extack); 78 static int ndisc_constructor(struct neighbour *neigh); 79 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb); 80 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb); 81 static int pndisc_constructor(struct pneigh_entry *n); 82 static void pndisc_destructor(struct pneigh_entry *n); 83 static void pndisc_redo(struct sk_buff *skb); 84 static int ndisc_is_multicast(const void *pkey); 85 86 static const struct neigh_ops ndisc_generic_ops = { 87 .family = AF_INET6, 88 .solicit = ndisc_solicit, 89 .error_report = ndisc_error_report, 90 .output = neigh_resolve_output, 91 .connected_output = neigh_connected_output, 92 }; 93 94 static const struct neigh_ops ndisc_hh_ops = { 95 .family = AF_INET6, 96 .solicit = ndisc_solicit, 97 .error_report = ndisc_error_report, 98 .output = neigh_resolve_output, 99 .connected_output = neigh_resolve_output, 100 }; 101 102 103 static const struct neigh_ops ndisc_direct_ops = { 104 .family = AF_INET6, 105 .output = neigh_direct_output, 106 .connected_output = neigh_direct_output, 107 }; 108 109 struct neigh_table nd_tbl = { 110 .family = AF_INET6, 111 .key_len = sizeof(struct in6_addr), 112 .protocol = cpu_to_be16(ETH_P_IPV6), 113 .hash = ndisc_hash, 114 .key_eq = ndisc_key_eq, 115 .constructor = ndisc_constructor, 116 .pconstructor = pndisc_constructor, 117 .pdestructor = pndisc_destructor, 118 .proxy_redo = pndisc_redo, 119 .is_multicast = ndisc_is_multicast, 120 .allow_add = ndisc_allow_add, 121 .id = "ndisc_cache", 122 .parms = { 123 .tbl = &nd_tbl, 124 .reachable_time = ND_REACHABLE_TIME, 125 .data = { 126 [NEIGH_VAR_MCAST_PROBES] = 3, 127 [NEIGH_VAR_UCAST_PROBES] = 3, 128 [NEIGH_VAR_RETRANS_TIME] = ND_RETRANS_TIMER, 129 [NEIGH_VAR_BASE_REACHABLE_TIME] = ND_REACHABLE_TIME, 130 [NEIGH_VAR_DELAY_PROBE_TIME] = 5 * HZ, 131 [NEIGH_VAR_GC_STALETIME] = 60 * HZ, 132 [NEIGH_VAR_QUEUE_LEN_BYTES] = SK_WMEM_MAX, 133 [NEIGH_VAR_PROXY_QLEN] = 64, 134 [NEIGH_VAR_ANYCAST_DELAY] = 1 * HZ, 135 [NEIGH_VAR_PROXY_DELAY] = (8 * HZ) / 10, 136 }, 137 }, 138 .gc_interval = 30 * HZ, 139 .gc_thresh1 = 128, 140 .gc_thresh2 = 512, 141 .gc_thresh3 = 1024, 142 }; 143 EXPORT_SYMBOL_GPL(nd_tbl); 144 145 void __ndisc_fill_addr_option(struct sk_buff *skb, int type, const void *data, 146 int data_len, int pad) 147 { 148 int space = __ndisc_opt_addr_space(data_len, pad); 149 u8 *opt = skb_put(skb, space); 150 151 opt[0] = type; 152 opt[1] = space>>3; 153 154 memset(opt + 2, 0, pad); 155 opt += pad; 156 space -= pad; 157 158 memcpy(opt+2, data, data_len); 159 data_len += 2; 160 opt += data_len; 161 space -= data_len; 162 if (space > 0) 163 memset(opt, 0, space); 164 } 165 EXPORT_SYMBOL_GPL(__ndisc_fill_addr_option); 166 167 static inline void ndisc_fill_addr_option(struct sk_buff *skb, int type, 168 const void *data, u8 icmp6_type) 169 { 170 __ndisc_fill_addr_option(skb, type, data, skb->dev->addr_len, 171 ndisc_addr_option_pad(skb->dev->type)); 172 ndisc_ops_fill_addr_option(skb->dev, skb, icmp6_type); 173 } 174 175 static inline void ndisc_fill_redirect_addr_option(struct sk_buff *skb, 176 void *ha, 177 const u8 *ops_data) 178 { 179 ndisc_fill_addr_option(skb, ND_OPT_TARGET_LL_ADDR, ha, NDISC_REDIRECT); 180 ndisc_ops_fill_redirect_addr_option(skb->dev, skb, ops_data); 181 } 182 183 static struct nd_opt_hdr *ndisc_next_option(struct nd_opt_hdr *cur, 184 struct nd_opt_hdr *end) 185 { 186 int type; 187 if (!cur || !end || cur >= end) 188 return NULL; 189 type = cur->nd_opt_type; 190 do { 191 cur = ((void *)cur) + (cur->nd_opt_len << 3); 192 } while (cur < end && cur->nd_opt_type != type); 193 return cur <= end && cur->nd_opt_type == type ? cur : NULL; 194 } 195 196 static inline int ndisc_is_useropt(const struct net_device *dev, 197 struct nd_opt_hdr *opt) 198 { 199 return opt->nd_opt_type == ND_OPT_RDNSS || 200 opt->nd_opt_type == ND_OPT_DNSSL || 201 opt->nd_opt_type == ND_OPT_CAPTIVE_PORTAL || 202 opt->nd_opt_type == ND_OPT_PREF64 || 203 ndisc_ops_is_useropt(dev, opt->nd_opt_type); 204 } 205 206 static struct nd_opt_hdr *ndisc_next_useropt(const struct net_device *dev, 207 struct nd_opt_hdr *cur, 208 struct nd_opt_hdr *end) 209 { 210 if (!cur || !end || cur >= end) 211 return NULL; 212 do { 213 cur = ((void *)cur) + (cur->nd_opt_len << 3); 214 } while (cur < end && !ndisc_is_useropt(dev, cur)); 215 return cur <= end && ndisc_is_useropt(dev, cur) ? cur : NULL; 216 } 217 218 struct ndisc_options *ndisc_parse_options(const struct net_device *dev, 219 u8 *opt, int opt_len, 220 struct ndisc_options *ndopts) 221 { 222 struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)opt; 223 224 if (!nd_opt || opt_len < 0 || !ndopts) 225 return NULL; 226 memset(ndopts, 0, sizeof(*ndopts)); 227 while (opt_len) { 228 int l; 229 if (opt_len < sizeof(struct nd_opt_hdr)) 230 return NULL; 231 l = nd_opt->nd_opt_len << 3; 232 if (opt_len < l || l == 0) 233 return NULL; 234 if (ndisc_ops_parse_options(dev, nd_opt, ndopts)) 235 goto next_opt; 236 switch (nd_opt->nd_opt_type) { 237 case ND_OPT_SOURCE_LL_ADDR: 238 case ND_OPT_TARGET_LL_ADDR: 239 case ND_OPT_MTU: 240 case ND_OPT_NONCE: 241 case ND_OPT_REDIRECT_HDR: 242 if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) { 243 ND_PRINTK(2, warn, 244 "%s: duplicated ND6 option found: type=%d\n", 245 __func__, nd_opt->nd_opt_type); 246 } else { 247 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt; 248 } 249 break; 250 case ND_OPT_PREFIX_INFO: 251 ndopts->nd_opts_pi_end = nd_opt; 252 if (!ndopts->nd_opt_array[nd_opt->nd_opt_type]) 253 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt; 254 break; 255 #ifdef CONFIG_IPV6_ROUTE_INFO 256 case ND_OPT_ROUTE_INFO: 257 ndopts->nd_opts_ri_end = nd_opt; 258 if (!ndopts->nd_opts_ri) 259 ndopts->nd_opts_ri = nd_opt; 260 break; 261 #endif 262 default: 263 if (ndisc_is_useropt(dev, nd_opt)) { 264 ndopts->nd_useropts_end = nd_opt; 265 if (!ndopts->nd_useropts) 266 ndopts->nd_useropts = nd_opt; 267 } else { 268 /* 269 * Unknown options must be silently ignored, 270 * to accommodate future extension to the 271 * protocol. 272 */ 273 ND_PRINTK(2, notice, 274 "%s: ignored unsupported option; type=%d, len=%d\n", 275 __func__, 276 nd_opt->nd_opt_type, 277 nd_opt->nd_opt_len); 278 } 279 } 280 next_opt: 281 opt_len -= l; 282 nd_opt = ((void *)nd_opt) + l; 283 } 284 return ndopts; 285 } 286 287 int ndisc_mc_map(const struct in6_addr *addr, char *buf, struct net_device *dev, int dir) 288 { 289 switch (dev->type) { 290 case ARPHRD_ETHER: 291 case ARPHRD_IEEE802: /* Not sure. Check it later. --ANK */ 292 case ARPHRD_FDDI: 293 ipv6_eth_mc_map(addr, buf); 294 return 0; 295 case ARPHRD_ARCNET: 296 ipv6_arcnet_mc_map(addr, buf); 297 return 0; 298 case ARPHRD_INFINIBAND: 299 ipv6_ib_mc_map(addr, dev->broadcast, buf); 300 return 0; 301 case ARPHRD_IPGRE: 302 return ipv6_ipgre_mc_map(addr, dev->broadcast, buf); 303 default: 304 if (dir) { 305 memcpy(buf, dev->broadcast, dev->addr_len); 306 return 0; 307 } 308 } 309 return -EINVAL; 310 } 311 EXPORT_SYMBOL(ndisc_mc_map); 312 313 static u32 ndisc_hash(const void *pkey, 314 const struct net_device *dev, 315 __u32 *hash_rnd) 316 { 317 return ndisc_hashfn(pkey, dev, hash_rnd); 318 } 319 320 static bool ndisc_key_eq(const struct neighbour *n, const void *pkey) 321 { 322 return neigh_key_eq128(n, pkey); 323 } 324 325 static int ndisc_constructor(struct neighbour *neigh) 326 { 327 struct in6_addr *addr = (struct in6_addr *)&neigh->primary_key; 328 struct net_device *dev = neigh->dev; 329 struct inet6_dev *in6_dev; 330 struct neigh_parms *parms; 331 bool is_multicast = ipv6_addr_is_multicast(addr); 332 333 in6_dev = in6_dev_get(dev); 334 if (!in6_dev) { 335 return -EINVAL; 336 } 337 338 parms = in6_dev->nd_parms; 339 __neigh_parms_put(neigh->parms); 340 neigh->parms = neigh_parms_clone(parms); 341 342 neigh->type = is_multicast ? RTN_MULTICAST : RTN_UNICAST; 343 if (!dev->header_ops) { 344 neigh->nud_state = NUD_NOARP; 345 neigh->ops = &ndisc_direct_ops; 346 neigh->output = neigh_direct_output; 347 } else { 348 if (is_multicast) { 349 neigh->nud_state = NUD_NOARP; 350 ndisc_mc_map(addr, neigh->ha, dev, 1); 351 } else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) { 352 neigh->nud_state = NUD_NOARP; 353 memcpy(neigh->ha, dev->dev_addr, dev->addr_len); 354 if (dev->flags&IFF_LOOPBACK) 355 neigh->type = RTN_LOCAL; 356 } else if (dev->flags&IFF_POINTOPOINT) { 357 neigh->nud_state = NUD_NOARP; 358 memcpy(neigh->ha, dev->broadcast, dev->addr_len); 359 } 360 if (dev->header_ops->cache) 361 neigh->ops = &ndisc_hh_ops; 362 else 363 neigh->ops = &ndisc_generic_ops; 364 if (neigh->nud_state&NUD_VALID) 365 neigh->output = neigh->ops->connected_output; 366 else 367 neigh->output = neigh->ops->output; 368 } 369 in6_dev_put(in6_dev); 370 return 0; 371 } 372 373 static int pndisc_constructor(struct pneigh_entry *n) 374 { 375 struct in6_addr *addr = (struct in6_addr *)&n->key; 376 struct in6_addr maddr; 377 struct net_device *dev = n->dev; 378 379 if (!dev || !__in6_dev_get(dev)) 380 return -EINVAL; 381 addrconf_addr_solict_mult(addr, &maddr); 382 ipv6_dev_mc_inc(dev, &maddr); 383 return 0; 384 } 385 386 static void pndisc_destructor(struct pneigh_entry *n) 387 { 388 struct in6_addr *addr = (struct in6_addr *)&n->key; 389 struct in6_addr maddr; 390 struct net_device *dev = n->dev; 391 392 if (!dev || !__in6_dev_get(dev)) 393 return; 394 addrconf_addr_solict_mult(addr, &maddr); 395 ipv6_dev_mc_dec(dev, &maddr); 396 } 397 398 /* called with rtnl held */ 399 static bool ndisc_allow_add(const struct net_device *dev, 400 struct netlink_ext_ack *extack) 401 { 402 struct inet6_dev *idev = __in6_dev_get(dev); 403 404 if (!idev || idev->cnf.disable_ipv6) { 405 NL_SET_ERR_MSG(extack, "IPv6 is disabled on this device"); 406 return false; 407 } 408 409 return true; 410 } 411 412 static struct sk_buff *ndisc_alloc_skb(struct net_device *dev, 413 int len) 414 { 415 int hlen = LL_RESERVED_SPACE(dev); 416 int tlen = dev->needed_tailroom; 417 struct sock *sk = dev_net(dev)->ipv6.ndisc_sk; 418 struct sk_buff *skb; 419 420 skb = alloc_skb(hlen + sizeof(struct ipv6hdr) + len + tlen, GFP_ATOMIC); 421 if (!skb) { 422 ND_PRINTK(0, err, "ndisc: %s failed to allocate an skb\n", 423 __func__); 424 return NULL; 425 } 426 427 skb->protocol = htons(ETH_P_IPV6); 428 skb->dev = dev; 429 430 skb_reserve(skb, hlen + sizeof(struct ipv6hdr)); 431 skb_reset_transport_header(skb); 432 433 /* Manually assign socket ownership as we avoid calling 434 * sock_alloc_send_pskb() to bypass wmem buffer limits 435 */ 436 skb_set_owner_w(skb, sk); 437 438 return skb; 439 } 440 441 static void ip6_nd_hdr(struct sk_buff *skb, 442 const struct in6_addr *saddr, 443 const struct in6_addr *daddr, 444 int hop_limit, int len) 445 { 446 struct ipv6hdr *hdr; 447 struct inet6_dev *idev; 448 unsigned tclass; 449 450 rcu_read_lock(); 451 idev = __in6_dev_get(skb->dev); 452 tclass = idev ? idev->cnf.ndisc_tclass : 0; 453 rcu_read_unlock(); 454 455 skb_push(skb, sizeof(*hdr)); 456 skb_reset_network_header(skb); 457 hdr = ipv6_hdr(skb); 458 459 ip6_flow_hdr(hdr, tclass, 0); 460 461 hdr->payload_len = htons(len); 462 hdr->nexthdr = IPPROTO_ICMPV6; 463 hdr->hop_limit = hop_limit; 464 465 hdr->saddr = *saddr; 466 hdr->daddr = *daddr; 467 } 468 469 void ndisc_send_skb(struct sk_buff *skb, const struct in6_addr *daddr, 470 const struct in6_addr *saddr) 471 { 472 struct dst_entry *dst = skb_dst(skb); 473 struct net *net = dev_net(skb->dev); 474 struct sock *sk = net->ipv6.ndisc_sk; 475 struct inet6_dev *idev; 476 int err; 477 struct icmp6hdr *icmp6h = icmp6_hdr(skb); 478 u8 type; 479 480 type = icmp6h->icmp6_type; 481 482 if (!dst) { 483 struct flowi6 fl6; 484 int oif = skb->dev->ifindex; 485 486 icmpv6_flow_init(sk, &fl6, type, saddr, daddr, oif); 487 dst = icmp6_dst_alloc(skb->dev, &fl6); 488 if (IS_ERR(dst)) { 489 kfree_skb(skb); 490 return; 491 } 492 493 skb_dst_set(skb, dst); 494 } 495 496 icmp6h->icmp6_cksum = csum_ipv6_magic(saddr, daddr, skb->len, 497 IPPROTO_ICMPV6, 498 csum_partial(icmp6h, 499 skb->len, 0)); 500 501 ip6_nd_hdr(skb, saddr, daddr, inet6_sk(sk)->hop_limit, skb->len); 502 503 rcu_read_lock(); 504 idev = __in6_dev_get(dst->dev); 505 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len); 506 507 err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, 508 net, sk, skb, NULL, dst->dev, 509 dst_output); 510 if (!err) { 511 ICMP6MSGOUT_INC_STATS(net, idev, type); 512 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS); 513 } 514 515 rcu_read_unlock(); 516 } 517 EXPORT_SYMBOL(ndisc_send_skb); 518 519 void ndisc_send_na(struct net_device *dev, const struct in6_addr *daddr, 520 const struct in6_addr *solicited_addr, 521 bool router, bool solicited, bool override, bool inc_opt) 522 { 523 struct sk_buff *skb; 524 struct in6_addr tmpaddr; 525 struct inet6_ifaddr *ifp; 526 const struct in6_addr *src_addr; 527 struct nd_msg *msg; 528 int optlen = 0; 529 530 /* for anycast or proxy, solicited_addr != src_addr */ 531 ifp = ipv6_get_ifaddr(dev_net(dev), solicited_addr, dev, 1); 532 if (ifp) { 533 src_addr = solicited_addr; 534 if (ifp->flags & IFA_F_OPTIMISTIC) 535 override = false; 536 inc_opt |= ifp->idev->cnf.force_tllao; 537 in6_ifa_put(ifp); 538 } else { 539 if (ipv6_dev_get_saddr(dev_net(dev), dev, daddr, 540 inet6_sk(dev_net(dev)->ipv6.ndisc_sk)->srcprefs, 541 &tmpaddr)) 542 return; 543 src_addr = &tmpaddr; 544 } 545 546 if (!dev->addr_len) 547 inc_opt = false; 548 if (inc_opt) 549 optlen += ndisc_opt_addr_space(dev, 550 NDISC_NEIGHBOUR_ADVERTISEMENT); 551 552 skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen); 553 if (!skb) 554 return; 555 556 msg = skb_put(skb, sizeof(*msg)); 557 *msg = (struct nd_msg) { 558 .icmph = { 559 .icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT, 560 .icmp6_router = router, 561 .icmp6_solicited = solicited, 562 .icmp6_override = override, 563 }, 564 .target = *solicited_addr, 565 }; 566 567 if (inc_opt) 568 ndisc_fill_addr_option(skb, ND_OPT_TARGET_LL_ADDR, 569 dev->dev_addr, 570 NDISC_NEIGHBOUR_ADVERTISEMENT); 571 572 ndisc_send_skb(skb, daddr, src_addr); 573 } 574 575 static void ndisc_send_unsol_na(struct net_device *dev) 576 { 577 struct inet6_dev *idev; 578 struct inet6_ifaddr *ifa; 579 580 idev = in6_dev_get(dev); 581 if (!idev) 582 return; 583 584 read_lock_bh(&idev->lock); 585 list_for_each_entry(ifa, &idev->addr_list, if_list) { 586 /* skip tentative addresses until dad completes */ 587 if (ifa->flags & IFA_F_TENTATIVE && 588 !(ifa->flags & IFA_F_OPTIMISTIC)) 589 continue; 590 591 ndisc_send_na(dev, &in6addr_linklocal_allnodes, &ifa->addr, 592 /*router=*/ !!idev->cnf.forwarding, 593 /*solicited=*/ false, /*override=*/ true, 594 /*inc_opt=*/ true); 595 } 596 read_unlock_bh(&idev->lock); 597 598 in6_dev_put(idev); 599 } 600 601 struct sk_buff *ndisc_ns_create(struct net_device *dev, const struct in6_addr *solicit, 602 const struct in6_addr *saddr, u64 nonce) 603 { 604 int inc_opt = dev->addr_len; 605 struct sk_buff *skb; 606 struct nd_msg *msg; 607 int optlen = 0; 608 609 if (!saddr) 610 return NULL; 611 612 if (ipv6_addr_any(saddr)) 613 inc_opt = false; 614 if (inc_opt) 615 optlen += ndisc_opt_addr_space(dev, 616 NDISC_NEIGHBOUR_SOLICITATION); 617 if (nonce != 0) 618 optlen += 8; 619 620 skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen); 621 if (!skb) 622 return NULL; 623 624 msg = skb_put(skb, sizeof(*msg)); 625 *msg = (struct nd_msg) { 626 .icmph = { 627 .icmp6_type = NDISC_NEIGHBOUR_SOLICITATION, 628 }, 629 .target = *solicit, 630 }; 631 632 if (inc_opt) 633 ndisc_fill_addr_option(skb, ND_OPT_SOURCE_LL_ADDR, 634 dev->dev_addr, 635 NDISC_NEIGHBOUR_SOLICITATION); 636 if (nonce != 0) { 637 u8 *opt = skb_put(skb, 8); 638 639 opt[0] = ND_OPT_NONCE; 640 opt[1] = 8 >> 3; 641 memcpy(opt + 2, &nonce, 6); 642 } 643 644 return skb; 645 } 646 EXPORT_SYMBOL(ndisc_ns_create); 647 648 void ndisc_send_ns(struct net_device *dev, const struct in6_addr *solicit, 649 const struct in6_addr *daddr, const struct in6_addr *saddr, 650 u64 nonce) 651 { 652 struct in6_addr addr_buf; 653 struct sk_buff *skb; 654 655 if (!saddr) { 656 if (ipv6_get_lladdr(dev, &addr_buf, 657 (IFA_F_TENTATIVE | IFA_F_OPTIMISTIC))) 658 return; 659 saddr = &addr_buf; 660 } 661 662 skb = ndisc_ns_create(dev, solicit, saddr, nonce); 663 664 if (skb) 665 ndisc_send_skb(skb, daddr, saddr); 666 } 667 668 void ndisc_send_rs(struct net_device *dev, const struct in6_addr *saddr, 669 const struct in6_addr *daddr) 670 { 671 struct sk_buff *skb; 672 struct rs_msg *msg; 673 int send_sllao = dev->addr_len; 674 int optlen = 0; 675 676 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD 677 /* 678 * According to section 2.2 of RFC 4429, we must not 679 * send router solicitations with a sllao from 680 * optimistic addresses, but we may send the solicitation 681 * if we don't include the sllao. So here we check 682 * if our address is optimistic, and if so, we 683 * suppress the inclusion of the sllao. 684 */ 685 if (send_sllao) { 686 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev_net(dev), saddr, 687 dev, 1); 688 if (ifp) { 689 if (ifp->flags & IFA_F_OPTIMISTIC) { 690 send_sllao = 0; 691 } 692 in6_ifa_put(ifp); 693 } else { 694 send_sllao = 0; 695 } 696 } 697 #endif 698 if (send_sllao) 699 optlen += ndisc_opt_addr_space(dev, NDISC_ROUTER_SOLICITATION); 700 701 skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen); 702 if (!skb) 703 return; 704 705 msg = skb_put(skb, sizeof(*msg)); 706 *msg = (struct rs_msg) { 707 .icmph = { 708 .icmp6_type = NDISC_ROUTER_SOLICITATION, 709 }, 710 }; 711 712 if (send_sllao) 713 ndisc_fill_addr_option(skb, ND_OPT_SOURCE_LL_ADDR, 714 dev->dev_addr, 715 NDISC_ROUTER_SOLICITATION); 716 717 ndisc_send_skb(skb, daddr, saddr); 718 } 719 720 721 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb) 722 { 723 /* 724 * "The sender MUST return an ICMP 725 * destination unreachable" 726 */ 727 dst_link_failure(skb); 728 kfree_skb(skb); 729 } 730 731 /* Called with locked neigh: either read or both */ 732 733 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb) 734 { 735 struct in6_addr *saddr = NULL; 736 struct in6_addr mcaddr; 737 struct net_device *dev = neigh->dev; 738 struct in6_addr *target = (struct in6_addr *)&neigh->primary_key; 739 int probes = atomic_read(&neigh->probes); 740 741 if (skb && ipv6_chk_addr_and_flags(dev_net(dev), &ipv6_hdr(skb)->saddr, 742 dev, false, 1, 743 IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) 744 saddr = &ipv6_hdr(skb)->saddr; 745 probes -= NEIGH_VAR(neigh->parms, UCAST_PROBES); 746 if (probes < 0) { 747 if (!(neigh->nud_state & NUD_VALID)) { 748 ND_PRINTK(1, dbg, 749 "%s: trying to ucast probe in NUD_INVALID: %pI6\n", 750 __func__, target); 751 } 752 ndisc_send_ns(dev, target, target, saddr, 0); 753 } else if ((probes -= NEIGH_VAR(neigh->parms, APP_PROBES)) < 0) { 754 neigh_app_ns(neigh); 755 } else { 756 addrconf_addr_solict_mult(target, &mcaddr); 757 ndisc_send_ns(dev, target, &mcaddr, saddr, 0); 758 } 759 } 760 761 static int pndisc_is_router(const void *pkey, 762 struct net_device *dev) 763 { 764 struct pneigh_entry *n; 765 int ret = -1; 766 767 read_lock_bh(&nd_tbl.lock); 768 n = __pneigh_lookup(&nd_tbl, dev_net(dev), pkey, dev); 769 if (n) 770 ret = !!(n->flags & NTF_ROUTER); 771 read_unlock_bh(&nd_tbl.lock); 772 773 return ret; 774 } 775 776 void ndisc_update(const struct net_device *dev, struct neighbour *neigh, 777 const u8 *lladdr, u8 new, u32 flags, u8 icmp6_type, 778 struct ndisc_options *ndopts) 779 { 780 neigh_update(neigh, lladdr, new, flags, 0); 781 /* report ndisc ops about neighbour update */ 782 ndisc_ops_update(dev, neigh, flags, icmp6_type, ndopts); 783 } 784 785 static void ndisc_recv_ns(struct sk_buff *skb) 786 { 787 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb); 788 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr; 789 const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr; 790 u8 *lladdr = NULL; 791 u32 ndoptlen = skb_tail_pointer(skb) - (skb_transport_header(skb) + 792 offsetof(struct nd_msg, opt)); 793 struct ndisc_options ndopts; 794 struct net_device *dev = skb->dev; 795 struct inet6_ifaddr *ifp; 796 struct inet6_dev *idev = NULL; 797 struct neighbour *neigh; 798 int dad = ipv6_addr_any(saddr); 799 bool inc; 800 int is_router = -1; 801 u64 nonce = 0; 802 803 if (skb->len < sizeof(struct nd_msg)) { 804 ND_PRINTK(2, warn, "NS: packet too short\n"); 805 return; 806 } 807 808 if (ipv6_addr_is_multicast(&msg->target)) { 809 ND_PRINTK(2, warn, "NS: multicast target address\n"); 810 return; 811 } 812 813 /* 814 * RFC2461 7.1.1: 815 * DAD has to be destined for solicited node multicast address. 816 */ 817 if (dad && !ipv6_addr_is_solict_mult(daddr)) { 818 ND_PRINTK(2, warn, "NS: bad DAD packet (wrong destination)\n"); 819 return; 820 } 821 822 if (!ndisc_parse_options(dev, msg->opt, ndoptlen, &ndopts)) { 823 ND_PRINTK(2, warn, "NS: invalid ND options\n"); 824 return; 825 } 826 827 if (ndopts.nd_opts_src_lladdr) { 828 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev); 829 if (!lladdr) { 830 ND_PRINTK(2, warn, 831 "NS: invalid link-layer address length\n"); 832 return; 833 } 834 835 /* RFC2461 7.1.1: 836 * If the IP source address is the unspecified address, 837 * there MUST NOT be source link-layer address option 838 * in the message. 839 */ 840 if (dad) { 841 ND_PRINTK(2, warn, 842 "NS: bad DAD packet (link-layer address option)\n"); 843 return; 844 } 845 } 846 if (ndopts.nd_opts_nonce && ndopts.nd_opts_nonce->nd_opt_len == 1) 847 memcpy(&nonce, (u8 *)(ndopts.nd_opts_nonce + 1), 6); 848 849 inc = ipv6_addr_is_multicast(daddr); 850 851 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1); 852 if (ifp) { 853 have_ifp: 854 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) { 855 if (dad) { 856 if (nonce != 0 && ifp->dad_nonce == nonce) { 857 u8 *np = (u8 *)&nonce; 858 /* Matching nonce if looped back */ 859 ND_PRINTK(2, notice, 860 "%s: IPv6 DAD loopback for address %pI6c nonce %pM ignored\n", 861 ifp->idev->dev->name, 862 &ifp->addr, np); 863 goto out; 864 } 865 /* 866 * We are colliding with another node 867 * who is doing DAD 868 * so fail our DAD process 869 */ 870 addrconf_dad_failure(skb, ifp); 871 return; 872 } else { 873 /* 874 * This is not a dad solicitation. 875 * If we are an optimistic node, 876 * we should respond. 877 * Otherwise, we should ignore it. 878 */ 879 if (!(ifp->flags & IFA_F_OPTIMISTIC)) 880 goto out; 881 } 882 } 883 884 idev = ifp->idev; 885 } else { 886 struct net *net = dev_net(dev); 887 888 /* perhaps an address on the master device */ 889 if (netif_is_l3_slave(dev)) { 890 struct net_device *mdev; 891 892 mdev = netdev_master_upper_dev_get_rcu(dev); 893 if (mdev) { 894 ifp = ipv6_get_ifaddr(net, &msg->target, mdev, 1); 895 if (ifp) 896 goto have_ifp; 897 } 898 } 899 900 idev = in6_dev_get(dev); 901 if (!idev) { 902 /* XXX: count this drop? */ 903 return; 904 } 905 906 if (ipv6_chk_acast_addr(net, dev, &msg->target) || 907 (idev->cnf.forwarding && 908 (net->ipv6.devconf_all->proxy_ndp || idev->cnf.proxy_ndp) && 909 (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) { 910 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) && 911 skb->pkt_type != PACKET_HOST && 912 inc && 913 NEIGH_VAR(idev->nd_parms, PROXY_DELAY) != 0) { 914 /* 915 * for anycast or proxy, 916 * sender should delay its response 917 * by a random time between 0 and 918 * MAX_ANYCAST_DELAY_TIME seconds. 919 * (RFC2461) -- yoshfuji 920 */ 921 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC); 922 if (n) 923 pneigh_enqueue(&nd_tbl, idev->nd_parms, n); 924 goto out; 925 } 926 } else 927 goto out; 928 } 929 930 if (is_router < 0) 931 is_router = idev->cnf.forwarding; 932 933 if (dad) { 934 ndisc_send_na(dev, &in6addr_linklocal_allnodes, &msg->target, 935 !!is_router, false, (ifp != NULL), true); 936 goto out; 937 } 938 939 if (inc) 940 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast); 941 else 942 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast); 943 944 /* 945 * update / create cache entry 946 * for the source address 947 */ 948 neigh = __neigh_lookup(&nd_tbl, saddr, dev, 949 !inc || lladdr || !dev->addr_len); 950 if (neigh) 951 ndisc_update(dev, neigh, lladdr, NUD_STALE, 952 NEIGH_UPDATE_F_WEAK_OVERRIDE| 953 NEIGH_UPDATE_F_OVERRIDE, 954 NDISC_NEIGHBOUR_SOLICITATION, &ndopts); 955 if (neigh || !dev->header_ops) { 956 ndisc_send_na(dev, saddr, &msg->target, !!is_router, 957 true, (ifp != NULL && inc), inc); 958 if (neigh) 959 neigh_release(neigh); 960 } 961 962 out: 963 if (ifp) 964 in6_ifa_put(ifp); 965 else 966 in6_dev_put(idev); 967 } 968 969 static void ndisc_recv_na(struct sk_buff *skb) 970 { 971 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb); 972 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr; 973 const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr; 974 u8 *lladdr = NULL; 975 u32 ndoptlen = skb_tail_pointer(skb) - (skb_transport_header(skb) + 976 offsetof(struct nd_msg, opt)); 977 struct ndisc_options ndopts; 978 struct net_device *dev = skb->dev; 979 struct inet6_dev *idev = __in6_dev_get(dev); 980 struct inet6_ifaddr *ifp; 981 struct neighbour *neigh; 982 bool create_neigh; 983 984 if (skb->len < sizeof(struct nd_msg)) { 985 ND_PRINTK(2, warn, "NA: packet too short\n"); 986 return; 987 } 988 989 if (ipv6_addr_is_multicast(&msg->target)) { 990 ND_PRINTK(2, warn, "NA: target address is multicast\n"); 991 return; 992 } 993 994 if (ipv6_addr_is_multicast(daddr) && 995 msg->icmph.icmp6_solicited) { 996 ND_PRINTK(2, warn, "NA: solicited NA is multicasted\n"); 997 return; 998 } 999 1000 /* For some 802.11 wireless deployments (and possibly other networks), 1001 * there will be a NA proxy and unsolicitd packets are attacks 1002 * and thus should not be accepted. 1003 * drop_unsolicited_na takes precedence over accept_unsolicited_na 1004 */ 1005 if (!msg->icmph.icmp6_solicited && idev && 1006 idev->cnf.drop_unsolicited_na) 1007 return; 1008 1009 if (!ndisc_parse_options(dev, msg->opt, ndoptlen, &ndopts)) { 1010 ND_PRINTK(2, warn, "NS: invalid ND option\n"); 1011 return; 1012 } 1013 if (ndopts.nd_opts_tgt_lladdr) { 1014 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev); 1015 if (!lladdr) { 1016 ND_PRINTK(2, warn, 1017 "NA: invalid link-layer address length\n"); 1018 return; 1019 } 1020 } 1021 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1); 1022 if (ifp) { 1023 if (skb->pkt_type != PACKET_LOOPBACK 1024 && (ifp->flags & IFA_F_TENTATIVE)) { 1025 addrconf_dad_failure(skb, ifp); 1026 return; 1027 } 1028 /* What should we make now? The advertisement 1029 is invalid, but ndisc specs say nothing 1030 about it. It could be misconfiguration, or 1031 an smart proxy agent tries to help us :-) 1032 1033 We should not print the error if NA has been 1034 received from loopback - it is just our own 1035 unsolicited advertisement. 1036 */ 1037 if (skb->pkt_type != PACKET_LOOPBACK) 1038 ND_PRINTK(1, warn, 1039 "NA: %pM advertised our address %pI6c on %s!\n", 1040 eth_hdr(skb)->h_source, &ifp->addr, ifp->idev->dev->name); 1041 in6_ifa_put(ifp); 1042 return; 1043 } 1044 /* RFC 9131 updates original Neighbour Discovery RFC 4861. 1045 * An unsolicited NA can now create a neighbour cache entry 1046 * on routers if it has Target LL Address option. 1047 * 1048 * drop accept fwding behaviour 1049 * ---- ------ ------ ---------------------------------------------- 1050 * 1 X X Drop NA packet and don't pass up the stack 1051 * 0 0 X Pass NA packet up the stack, don't update NC 1052 * 0 1 0 Pass NA packet up the stack, don't update NC 1053 * 0 1 1 Pass NA packet up the stack, and add a STALE 1054 * NC entry 1055 * Note that we don't do a (daddr == all-routers-mcast) check. 1056 */ 1057 create_neigh = !msg->icmph.icmp6_solicited && lladdr && 1058 idev && idev->cnf.forwarding && 1059 idev->cnf.accept_unsolicited_na; 1060 neigh = __neigh_lookup(&nd_tbl, &msg->target, dev, create_neigh); 1061 1062 if (neigh) { 1063 u8 old_flags = neigh->flags; 1064 struct net *net = dev_net(dev); 1065 1066 if (neigh->nud_state & NUD_FAILED) 1067 goto out; 1068 1069 /* 1070 * Don't update the neighbor cache entry on a proxy NA from 1071 * ourselves because either the proxied node is off link or it 1072 * has already sent a NA to us. 1073 */ 1074 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) && 1075 net->ipv6.devconf_all->forwarding && net->ipv6.devconf_all->proxy_ndp && 1076 pneigh_lookup(&nd_tbl, net, &msg->target, dev, 0)) { 1077 /* XXX: idev->cnf.proxy_ndp */ 1078 goto out; 1079 } 1080 1081 ndisc_update(dev, neigh, lladdr, 1082 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE, 1083 NEIGH_UPDATE_F_WEAK_OVERRIDE| 1084 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)| 1085 NEIGH_UPDATE_F_OVERRIDE_ISROUTER| 1086 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0), 1087 NDISC_NEIGHBOUR_ADVERTISEMENT, &ndopts); 1088 1089 if ((old_flags & ~neigh->flags) & NTF_ROUTER) { 1090 /* 1091 * Change: router to host 1092 */ 1093 rt6_clean_tohost(dev_net(dev), saddr); 1094 } 1095 1096 out: 1097 neigh_release(neigh); 1098 } 1099 } 1100 1101 static void ndisc_recv_rs(struct sk_buff *skb) 1102 { 1103 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb); 1104 unsigned long ndoptlen = skb->len - sizeof(*rs_msg); 1105 struct neighbour *neigh; 1106 struct inet6_dev *idev; 1107 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr; 1108 struct ndisc_options ndopts; 1109 u8 *lladdr = NULL; 1110 1111 if (skb->len < sizeof(*rs_msg)) 1112 return; 1113 1114 idev = __in6_dev_get(skb->dev); 1115 if (!idev) { 1116 ND_PRINTK(1, err, "RS: can't find in6 device\n"); 1117 return; 1118 } 1119 1120 /* Don't accept RS if we're not in router mode */ 1121 if (!idev->cnf.forwarding) 1122 goto out; 1123 1124 /* 1125 * Don't update NCE if src = ::; 1126 * this implies that the source node has no ip address assigned yet. 1127 */ 1128 if (ipv6_addr_any(saddr)) 1129 goto out; 1130 1131 /* Parse ND options */ 1132 if (!ndisc_parse_options(skb->dev, rs_msg->opt, ndoptlen, &ndopts)) { 1133 ND_PRINTK(2, notice, "NS: invalid ND option, ignored\n"); 1134 goto out; 1135 } 1136 1137 if (ndopts.nd_opts_src_lladdr) { 1138 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, 1139 skb->dev); 1140 if (!lladdr) 1141 goto out; 1142 } 1143 1144 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1); 1145 if (neigh) { 1146 ndisc_update(skb->dev, neigh, lladdr, NUD_STALE, 1147 NEIGH_UPDATE_F_WEAK_OVERRIDE| 1148 NEIGH_UPDATE_F_OVERRIDE| 1149 NEIGH_UPDATE_F_OVERRIDE_ISROUTER, 1150 NDISC_ROUTER_SOLICITATION, &ndopts); 1151 neigh_release(neigh); 1152 } 1153 out: 1154 return; 1155 } 1156 1157 static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt) 1158 { 1159 struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra); 1160 struct sk_buff *skb; 1161 struct nlmsghdr *nlh; 1162 struct nduseroptmsg *ndmsg; 1163 struct net *net = dev_net(ra->dev); 1164 int err; 1165 int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg) 1166 + (opt->nd_opt_len << 3)); 1167 size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr)); 1168 1169 skb = nlmsg_new(msg_size, GFP_ATOMIC); 1170 if (!skb) { 1171 err = -ENOBUFS; 1172 goto errout; 1173 } 1174 1175 nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0); 1176 if (!nlh) { 1177 goto nla_put_failure; 1178 } 1179 1180 ndmsg = nlmsg_data(nlh); 1181 ndmsg->nduseropt_family = AF_INET6; 1182 ndmsg->nduseropt_ifindex = ra->dev->ifindex; 1183 ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type; 1184 ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code; 1185 ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3; 1186 1187 memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3); 1188 1189 if (nla_put_in6_addr(skb, NDUSEROPT_SRCADDR, &ipv6_hdr(ra)->saddr)) 1190 goto nla_put_failure; 1191 nlmsg_end(skb, nlh); 1192 1193 rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL, GFP_ATOMIC); 1194 return; 1195 1196 nla_put_failure: 1197 nlmsg_free(skb); 1198 err = -EMSGSIZE; 1199 errout: 1200 rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err); 1201 } 1202 1203 static void ndisc_router_discovery(struct sk_buff *skb) 1204 { 1205 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb); 1206 struct neighbour *neigh = NULL; 1207 struct inet6_dev *in6_dev; 1208 struct fib6_info *rt = NULL; 1209 u32 defrtr_usr_metric; 1210 struct net *net; 1211 int lifetime; 1212 struct ndisc_options ndopts; 1213 int optlen; 1214 unsigned int pref = 0; 1215 __u32 old_if_flags; 1216 bool send_ifinfo_notify = false; 1217 1218 __u8 *opt = (__u8 *)(ra_msg + 1); 1219 1220 optlen = (skb_tail_pointer(skb) - skb_transport_header(skb)) - 1221 sizeof(struct ra_msg); 1222 1223 ND_PRINTK(2, info, 1224 "RA: %s, dev: %s\n", 1225 __func__, skb->dev->name); 1226 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) { 1227 ND_PRINTK(2, warn, "RA: source address is not link-local\n"); 1228 return; 1229 } 1230 if (optlen < 0) { 1231 ND_PRINTK(2, warn, "RA: packet too short\n"); 1232 return; 1233 } 1234 1235 #ifdef CONFIG_IPV6_NDISC_NODETYPE 1236 if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) { 1237 ND_PRINTK(2, warn, "RA: from host or unauthorized router\n"); 1238 return; 1239 } 1240 #endif 1241 1242 /* 1243 * set the RA_RECV flag in the interface 1244 */ 1245 1246 in6_dev = __in6_dev_get(skb->dev); 1247 if (!in6_dev) { 1248 ND_PRINTK(0, err, "RA: can't find inet6 device for %s\n", 1249 skb->dev->name); 1250 return; 1251 } 1252 1253 if (!ndisc_parse_options(skb->dev, opt, optlen, &ndopts)) { 1254 ND_PRINTK(2, warn, "RA: invalid ND options\n"); 1255 return; 1256 } 1257 1258 if (!ipv6_accept_ra(in6_dev)) { 1259 ND_PRINTK(2, info, 1260 "RA: %s, did not accept ra for dev: %s\n", 1261 __func__, skb->dev->name); 1262 goto skip_linkparms; 1263 } 1264 1265 #ifdef CONFIG_IPV6_NDISC_NODETYPE 1266 /* skip link-specific parameters from interior routers */ 1267 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT) { 1268 ND_PRINTK(2, info, 1269 "RA: %s, nodetype is NODEFAULT, dev: %s\n", 1270 __func__, skb->dev->name); 1271 goto skip_linkparms; 1272 } 1273 #endif 1274 1275 if (in6_dev->if_flags & IF_RS_SENT) { 1276 /* 1277 * flag that an RA was received after an RS was sent 1278 * out on this interface. 1279 */ 1280 in6_dev->if_flags |= IF_RA_RCVD; 1281 } 1282 1283 /* 1284 * Remember the managed/otherconf flags from most recently 1285 * received RA message (RFC 2462) -- yoshfuji 1286 */ 1287 old_if_flags = in6_dev->if_flags; 1288 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED | 1289 IF_RA_OTHERCONF)) | 1290 (ra_msg->icmph.icmp6_addrconf_managed ? 1291 IF_RA_MANAGED : 0) | 1292 (ra_msg->icmph.icmp6_addrconf_other ? 1293 IF_RA_OTHERCONF : 0); 1294 1295 if (old_if_flags != in6_dev->if_flags) 1296 send_ifinfo_notify = true; 1297 1298 if (!in6_dev->cnf.accept_ra_defrtr) { 1299 ND_PRINTK(2, info, 1300 "RA: %s, defrtr is false for dev: %s\n", 1301 __func__, skb->dev->name); 1302 goto skip_defrtr; 1303 } 1304 1305 /* Do not accept RA with source-addr found on local machine unless 1306 * accept_ra_from_local is set to true. 1307 */ 1308 net = dev_net(in6_dev->dev); 1309 if (!in6_dev->cnf.accept_ra_from_local && 1310 ipv6_chk_addr(net, &ipv6_hdr(skb)->saddr, in6_dev->dev, 0)) { 1311 ND_PRINTK(2, info, 1312 "RA from local address detected on dev: %s: default router ignored\n", 1313 skb->dev->name); 1314 goto skip_defrtr; 1315 } 1316 1317 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime); 1318 1319 #ifdef CONFIG_IPV6_ROUTER_PREF 1320 pref = ra_msg->icmph.icmp6_router_pref; 1321 /* 10b is handled as if it were 00b (medium) */ 1322 if (pref == ICMPV6_ROUTER_PREF_INVALID || 1323 !in6_dev->cnf.accept_ra_rtr_pref) 1324 pref = ICMPV6_ROUTER_PREF_MEDIUM; 1325 #endif 1326 /* routes added from RAs do not use nexthop objects */ 1327 rt = rt6_get_dflt_router(net, &ipv6_hdr(skb)->saddr, skb->dev); 1328 if (rt) { 1329 neigh = ip6_neigh_lookup(&rt->fib6_nh->fib_nh_gw6, 1330 rt->fib6_nh->fib_nh_dev, NULL, 1331 &ipv6_hdr(skb)->saddr); 1332 if (!neigh) { 1333 ND_PRINTK(0, err, 1334 "RA: %s got default router without neighbour\n", 1335 __func__); 1336 fib6_info_release(rt); 1337 return; 1338 } 1339 } 1340 /* Set default route metric as specified by user */ 1341 defrtr_usr_metric = in6_dev->cnf.ra_defrtr_metric; 1342 /* delete the route if lifetime is 0 or if metric needs change */ 1343 if (rt && (lifetime == 0 || rt->fib6_metric != defrtr_usr_metric)) { 1344 ip6_del_rt(net, rt, false); 1345 rt = NULL; 1346 } 1347 1348 ND_PRINTK(3, info, "RA: rt: %p lifetime: %d, metric: %d, for dev: %s\n", 1349 rt, lifetime, defrtr_usr_metric, skb->dev->name); 1350 if (!rt && lifetime) { 1351 ND_PRINTK(3, info, "RA: adding default router\n"); 1352 1353 rt = rt6_add_dflt_router(net, &ipv6_hdr(skb)->saddr, 1354 skb->dev, pref, defrtr_usr_metric); 1355 if (!rt) { 1356 ND_PRINTK(0, err, 1357 "RA: %s failed to add default route\n", 1358 __func__); 1359 return; 1360 } 1361 1362 neigh = ip6_neigh_lookup(&rt->fib6_nh->fib_nh_gw6, 1363 rt->fib6_nh->fib_nh_dev, NULL, 1364 &ipv6_hdr(skb)->saddr); 1365 if (!neigh) { 1366 ND_PRINTK(0, err, 1367 "RA: %s got default router without neighbour\n", 1368 __func__); 1369 fib6_info_release(rt); 1370 return; 1371 } 1372 neigh->flags |= NTF_ROUTER; 1373 } else if (rt && IPV6_EXTRACT_PREF(rt->fib6_flags) != pref) { 1374 struct nl_info nlinfo = { 1375 .nl_net = net, 1376 }; 1377 rt->fib6_flags = (rt->fib6_flags & ~RTF_PREF_MASK) | RTF_PREF(pref); 1378 inet6_rt_notify(RTM_NEWROUTE, rt, &nlinfo, NLM_F_REPLACE); 1379 } 1380 1381 if (rt) 1382 fib6_set_expires(rt, jiffies + (HZ * lifetime)); 1383 if (in6_dev->cnf.accept_ra_min_hop_limit < 256 && 1384 ra_msg->icmph.icmp6_hop_limit) { 1385 if (in6_dev->cnf.accept_ra_min_hop_limit <= ra_msg->icmph.icmp6_hop_limit) { 1386 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit; 1387 fib6_metric_set(rt, RTAX_HOPLIMIT, 1388 ra_msg->icmph.icmp6_hop_limit); 1389 } else { 1390 ND_PRINTK(2, warn, "RA: Got route advertisement with lower hop_limit than minimum\n"); 1391 } 1392 } 1393 1394 skip_defrtr: 1395 1396 /* 1397 * Update Reachable Time and Retrans Timer 1398 */ 1399 1400 if (in6_dev->nd_parms) { 1401 unsigned long rtime = ntohl(ra_msg->retrans_timer); 1402 1403 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) { 1404 rtime = (rtime*HZ)/1000; 1405 if (rtime < HZ/100) 1406 rtime = HZ/100; 1407 NEIGH_VAR_SET(in6_dev->nd_parms, RETRANS_TIME, rtime); 1408 in6_dev->tstamp = jiffies; 1409 send_ifinfo_notify = true; 1410 } 1411 1412 rtime = ntohl(ra_msg->reachable_time); 1413 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) { 1414 rtime = (rtime*HZ)/1000; 1415 1416 if (rtime < HZ/10) 1417 rtime = HZ/10; 1418 1419 if (rtime != NEIGH_VAR(in6_dev->nd_parms, BASE_REACHABLE_TIME)) { 1420 NEIGH_VAR_SET(in6_dev->nd_parms, 1421 BASE_REACHABLE_TIME, rtime); 1422 NEIGH_VAR_SET(in6_dev->nd_parms, 1423 GC_STALETIME, 3 * rtime); 1424 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime); 1425 in6_dev->tstamp = jiffies; 1426 send_ifinfo_notify = true; 1427 } 1428 } 1429 } 1430 1431 skip_linkparms: 1432 1433 /* 1434 * Process options. 1435 */ 1436 1437 if (!neigh) 1438 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr, 1439 skb->dev, 1); 1440 if (neigh) { 1441 u8 *lladdr = NULL; 1442 if (ndopts.nd_opts_src_lladdr) { 1443 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, 1444 skb->dev); 1445 if (!lladdr) { 1446 ND_PRINTK(2, warn, 1447 "RA: invalid link-layer address length\n"); 1448 goto out; 1449 } 1450 } 1451 ndisc_update(skb->dev, neigh, lladdr, NUD_STALE, 1452 NEIGH_UPDATE_F_WEAK_OVERRIDE| 1453 NEIGH_UPDATE_F_OVERRIDE| 1454 NEIGH_UPDATE_F_OVERRIDE_ISROUTER| 1455 NEIGH_UPDATE_F_ISROUTER, 1456 NDISC_ROUTER_ADVERTISEMENT, &ndopts); 1457 } 1458 1459 if (!ipv6_accept_ra(in6_dev)) { 1460 ND_PRINTK(2, info, 1461 "RA: %s, accept_ra is false for dev: %s\n", 1462 __func__, skb->dev->name); 1463 goto out; 1464 } 1465 1466 #ifdef CONFIG_IPV6_ROUTE_INFO 1467 if (!in6_dev->cnf.accept_ra_from_local && 1468 ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr, 1469 in6_dev->dev, 0)) { 1470 ND_PRINTK(2, info, 1471 "RA from local address detected on dev: %s: router info ignored.\n", 1472 skb->dev->name); 1473 goto skip_routeinfo; 1474 } 1475 1476 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) { 1477 struct nd_opt_hdr *p; 1478 for (p = ndopts.nd_opts_ri; 1479 p; 1480 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) { 1481 struct route_info *ri = (struct route_info *)p; 1482 #ifdef CONFIG_IPV6_NDISC_NODETYPE 1483 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT && 1484 ri->prefix_len == 0) 1485 continue; 1486 #endif 1487 if (ri->prefix_len == 0 && 1488 !in6_dev->cnf.accept_ra_defrtr) 1489 continue; 1490 if (ri->prefix_len < in6_dev->cnf.accept_ra_rt_info_min_plen) 1491 continue; 1492 if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen) 1493 continue; 1494 rt6_route_rcv(skb->dev, (u8 *)p, (p->nd_opt_len) << 3, 1495 &ipv6_hdr(skb)->saddr); 1496 } 1497 } 1498 1499 skip_routeinfo: 1500 #endif 1501 1502 #ifdef CONFIG_IPV6_NDISC_NODETYPE 1503 /* skip link-specific ndopts from interior routers */ 1504 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT) { 1505 ND_PRINTK(2, info, 1506 "RA: %s, nodetype is NODEFAULT (interior routes), dev: %s\n", 1507 __func__, skb->dev->name); 1508 goto out; 1509 } 1510 #endif 1511 1512 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) { 1513 struct nd_opt_hdr *p; 1514 for (p = ndopts.nd_opts_pi; 1515 p; 1516 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) { 1517 addrconf_prefix_rcv(skb->dev, (u8 *)p, 1518 (p->nd_opt_len) << 3, 1519 ndopts.nd_opts_src_lladdr != NULL); 1520 } 1521 } 1522 1523 if (ndopts.nd_opts_mtu && in6_dev->cnf.accept_ra_mtu) { 1524 __be32 n; 1525 u32 mtu; 1526 1527 memcpy(&n, ((u8 *)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu)); 1528 mtu = ntohl(n); 1529 1530 if (in6_dev->ra_mtu != mtu) { 1531 in6_dev->ra_mtu = mtu; 1532 send_ifinfo_notify = true; 1533 } 1534 1535 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) { 1536 ND_PRINTK(2, warn, "RA: invalid mtu: %d\n", mtu); 1537 } else if (in6_dev->cnf.mtu6 != mtu) { 1538 in6_dev->cnf.mtu6 = mtu; 1539 fib6_metric_set(rt, RTAX_MTU, mtu); 1540 rt6_mtu_change(skb->dev, mtu); 1541 } 1542 } 1543 1544 if (ndopts.nd_useropts) { 1545 struct nd_opt_hdr *p; 1546 for (p = ndopts.nd_useropts; 1547 p; 1548 p = ndisc_next_useropt(skb->dev, p, 1549 ndopts.nd_useropts_end)) { 1550 ndisc_ra_useropt(skb, p); 1551 } 1552 } 1553 1554 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) { 1555 ND_PRINTK(2, warn, "RA: invalid RA options\n"); 1556 } 1557 out: 1558 /* Send a notify if RA changed managed/otherconf flags or 1559 * timer settings or ra_mtu value 1560 */ 1561 if (send_ifinfo_notify) 1562 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev); 1563 1564 fib6_info_release(rt); 1565 if (neigh) 1566 neigh_release(neigh); 1567 } 1568 1569 static void ndisc_redirect_rcv(struct sk_buff *skb) 1570 { 1571 u8 *hdr; 1572 struct ndisc_options ndopts; 1573 struct rd_msg *msg = (struct rd_msg *)skb_transport_header(skb); 1574 u32 ndoptlen = skb_tail_pointer(skb) - (skb_transport_header(skb) + 1575 offsetof(struct rd_msg, opt)); 1576 1577 #ifdef CONFIG_IPV6_NDISC_NODETYPE 1578 switch (skb->ndisc_nodetype) { 1579 case NDISC_NODETYPE_HOST: 1580 case NDISC_NODETYPE_NODEFAULT: 1581 ND_PRINTK(2, warn, 1582 "Redirect: from host or unauthorized router\n"); 1583 return; 1584 } 1585 #endif 1586 1587 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) { 1588 ND_PRINTK(2, warn, 1589 "Redirect: source address is not link-local\n"); 1590 return; 1591 } 1592 1593 if (!ndisc_parse_options(skb->dev, msg->opt, ndoptlen, &ndopts)) 1594 return; 1595 1596 if (!ndopts.nd_opts_rh) { 1597 ip6_redirect_no_header(skb, dev_net(skb->dev), 1598 skb->dev->ifindex); 1599 return; 1600 } 1601 1602 hdr = (u8 *)ndopts.nd_opts_rh; 1603 hdr += 8; 1604 if (!pskb_pull(skb, hdr - skb_transport_header(skb))) 1605 return; 1606 1607 icmpv6_notify(skb, NDISC_REDIRECT, 0, 0); 1608 } 1609 1610 static void ndisc_fill_redirect_hdr_option(struct sk_buff *skb, 1611 struct sk_buff *orig_skb, 1612 int rd_len) 1613 { 1614 u8 *opt = skb_put(skb, rd_len); 1615 1616 memset(opt, 0, 8); 1617 *(opt++) = ND_OPT_REDIRECT_HDR; 1618 *(opt++) = (rd_len >> 3); 1619 opt += 6; 1620 1621 skb_copy_bits(orig_skb, skb_network_offset(orig_skb), opt, 1622 rd_len - 8); 1623 } 1624 1625 void ndisc_send_redirect(struct sk_buff *skb, const struct in6_addr *target) 1626 { 1627 struct net_device *dev = skb->dev; 1628 struct net *net = dev_net(dev); 1629 struct sock *sk = net->ipv6.ndisc_sk; 1630 int optlen = 0; 1631 struct inet_peer *peer; 1632 struct sk_buff *buff; 1633 struct rd_msg *msg; 1634 struct in6_addr saddr_buf; 1635 struct rt6_info *rt; 1636 struct dst_entry *dst; 1637 struct flowi6 fl6; 1638 int rd_len; 1639 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL, 1640 ops_data_buf[NDISC_OPS_REDIRECT_DATA_SPACE], *ops_data = NULL; 1641 bool ret; 1642 1643 if (netif_is_l3_master(skb->dev)) { 1644 dev = __dev_get_by_index(dev_net(skb->dev), IPCB(skb)->iif); 1645 if (!dev) 1646 return; 1647 } 1648 1649 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) { 1650 ND_PRINTK(2, warn, "Redirect: no link-local address on %s\n", 1651 dev->name); 1652 return; 1653 } 1654 1655 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) && 1656 ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) { 1657 ND_PRINTK(2, warn, 1658 "Redirect: target address is not link-local unicast\n"); 1659 return; 1660 } 1661 1662 icmpv6_flow_init(sk, &fl6, NDISC_REDIRECT, 1663 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex); 1664 1665 dst = ip6_route_output(net, NULL, &fl6); 1666 if (dst->error) { 1667 dst_release(dst); 1668 return; 1669 } 1670 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), NULL, 0); 1671 if (IS_ERR(dst)) 1672 return; 1673 1674 rt = (struct rt6_info *) dst; 1675 1676 if (rt->rt6i_flags & RTF_GATEWAY) { 1677 ND_PRINTK(2, warn, 1678 "Redirect: destination is not a neighbour\n"); 1679 goto release; 1680 } 1681 peer = inet_getpeer_v6(net->ipv6.peers, &ipv6_hdr(skb)->saddr, 1); 1682 ret = inet_peer_xrlim_allow(peer, 1*HZ); 1683 if (peer) 1684 inet_putpeer(peer); 1685 if (!ret) 1686 goto release; 1687 1688 if (dev->addr_len) { 1689 struct neighbour *neigh = dst_neigh_lookup(skb_dst(skb), target); 1690 if (!neigh) { 1691 ND_PRINTK(2, warn, 1692 "Redirect: no neigh for target address\n"); 1693 goto release; 1694 } 1695 1696 read_lock_bh(&neigh->lock); 1697 if (neigh->nud_state & NUD_VALID) { 1698 memcpy(ha_buf, neigh->ha, dev->addr_len); 1699 read_unlock_bh(&neigh->lock); 1700 ha = ha_buf; 1701 optlen += ndisc_redirect_opt_addr_space(dev, neigh, 1702 ops_data_buf, 1703 &ops_data); 1704 } else 1705 read_unlock_bh(&neigh->lock); 1706 1707 neigh_release(neigh); 1708 } 1709 1710 rd_len = min_t(unsigned int, 1711 IPV6_MIN_MTU - sizeof(struct ipv6hdr) - sizeof(*msg) - optlen, 1712 skb->len + 8); 1713 rd_len &= ~0x7; 1714 optlen += rd_len; 1715 1716 buff = ndisc_alloc_skb(dev, sizeof(*msg) + optlen); 1717 if (!buff) 1718 goto release; 1719 1720 msg = skb_put(buff, sizeof(*msg)); 1721 *msg = (struct rd_msg) { 1722 .icmph = { 1723 .icmp6_type = NDISC_REDIRECT, 1724 }, 1725 .target = *target, 1726 .dest = ipv6_hdr(skb)->daddr, 1727 }; 1728 1729 /* 1730 * include target_address option 1731 */ 1732 1733 if (ha) 1734 ndisc_fill_redirect_addr_option(buff, ha, ops_data); 1735 1736 /* 1737 * build redirect option and copy skb over to the new packet. 1738 */ 1739 1740 if (rd_len) 1741 ndisc_fill_redirect_hdr_option(buff, skb, rd_len); 1742 1743 skb_dst_set(buff, dst); 1744 ndisc_send_skb(buff, &ipv6_hdr(skb)->saddr, &saddr_buf); 1745 return; 1746 1747 release: 1748 dst_release(dst); 1749 } 1750 1751 static void pndisc_redo(struct sk_buff *skb) 1752 { 1753 ndisc_recv_ns(skb); 1754 kfree_skb(skb); 1755 } 1756 1757 static int ndisc_is_multicast(const void *pkey) 1758 { 1759 return ipv6_addr_is_multicast((struct in6_addr *)pkey); 1760 } 1761 1762 static bool ndisc_suppress_frag_ndisc(struct sk_buff *skb) 1763 { 1764 struct inet6_dev *idev = __in6_dev_get(skb->dev); 1765 1766 if (!idev) 1767 return true; 1768 if (IP6CB(skb)->flags & IP6SKB_FRAGMENTED && 1769 idev->cnf.suppress_frag_ndisc) { 1770 net_warn_ratelimited("Received fragmented ndisc packet. Carefully consider disabling suppress_frag_ndisc.\n"); 1771 return true; 1772 } 1773 return false; 1774 } 1775 1776 int ndisc_rcv(struct sk_buff *skb) 1777 { 1778 struct nd_msg *msg; 1779 1780 if (ndisc_suppress_frag_ndisc(skb)) 1781 return 0; 1782 1783 if (skb_linearize(skb)) 1784 return 0; 1785 1786 msg = (struct nd_msg *)skb_transport_header(skb); 1787 1788 __skb_push(skb, skb->data - skb_transport_header(skb)); 1789 1790 if (ipv6_hdr(skb)->hop_limit != 255) { 1791 ND_PRINTK(2, warn, "NDISC: invalid hop-limit: %d\n", 1792 ipv6_hdr(skb)->hop_limit); 1793 return 0; 1794 } 1795 1796 if (msg->icmph.icmp6_code != 0) { 1797 ND_PRINTK(2, warn, "NDISC: invalid ICMPv6 code: %d\n", 1798 msg->icmph.icmp6_code); 1799 return 0; 1800 } 1801 1802 switch (msg->icmph.icmp6_type) { 1803 case NDISC_NEIGHBOUR_SOLICITATION: 1804 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb)); 1805 ndisc_recv_ns(skb); 1806 break; 1807 1808 case NDISC_NEIGHBOUR_ADVERTISEMENT: 1809 ndisc_recv_na(skb); 1810 break; 1811 1812 case NDISC_ROUTER_SOLICITATION: 1813 ndisc_recv_rs(skb); 1814 break; 1815 1816 case NDISC_ROUTER_ADVERTISEMENT: 1817 ndisc_router_discovery(skb); 1818 break; 1819 1820 case NDISC_REDIRECT: 1821 ndisc_redirect_rcv(skb); 1822 break; 1823 } 1824 1825 return 0; 1826 } 1827 1828 static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr) 1829 { 1830 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 1831 struct netdev_notifier_change_info *change_info; 1832 struct net *net = dev_net(dev); 1833 struct inet6_dev *idev; 1834 bool evict_nocarrier; 1835 1836 switch (event) { 1837 case NETDEV_CHANGEADDR: 1838 neigh_changeaddr(&nd_tbl, dev); 1839 fib6_run_gc(0, net, false); 1840 fallthrough; 1841 case NETDEV_UP: 1842 idev = in6_dev_get(dev); 1843 if (!idev) 1844 break; 1845 if (idev->cnf.ndisc_notify || 1846 net->ipv6.devconf_all->ndisc_notify) 1847 ndisc_send_unsol_na(dev); 1848 in6_dev_put(idev); 1849 break; 1850 case NETDEV_CHANGE: 1851 idev = in6_dev_get(dev); 1852 if (!idev) 1853 evict_nocarrier = true; 1854 else { 1855 evict_nocarrier = idev->cnf.ndisc_evict_nocarrier && 1856 net->ipv6.devconf_all->ndisc_evict_nocarrier; 1857 in6_dev_put(idev); 1858 } 1859 1860 change_info = ptr; 1861 if (change_info->flags_changed & IFF_NOARP) 1862 neigh_changeaddr(&nd_tbl, dev); 1863 if (evict_nocarrier && !netif_carrier_ok(dev)) 1864 neigh_carrier_down(&nd_tbl, dev); 1865 break; 1866 case NETDEV_DOWN: 1867 neigh_ifdown(&nd_tbl, dev); 1868 fib6_run_gc(0, net, false); 1869 break; 1870 case NETDEV_NOTIFY_PEERS: 1871 ndisc_send_unsol_na(dev); 1872 break; 1873 default: 1874 break; 1875 } 1876 1877 return NOTIFY_DONE; 1878 } 1879 1880 static struct notifier_block ndisc_netdev_notifier = { 1881 .notifier_call = ndisc_netdev_event, 1882 .priority = ADDRCONF_NOTIFY_PRIORITY - 5, 1883 }; 1884 1885 #ifdef CONFIG_SYSCTL 1886 static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl, 1887 const char *func, const char *dev_name) 1888 { 1889 static char warncomm[TASK_COMM_LEN]; 1890 static int warned; 1891 if (strcmp(warncomm, current->comm) && warned < 5) { 1892 strcpy(warncomm, current->comm); 1893 pr_warn("process `%s' is using deprecated sysctl (%s) net.ipv6.neigh.%s.%s - use net.ipv6.neigh.%s.%s_ms instead\n", 1894 warncomm, func, 1895 dev_name, ctl->procname, 1896 dev_name, ctl->procname); 1897 warned++; 1898 } 1899 } 1900 1901 int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, void *buffer, 1902 size_t *lenp, loff_t *ppos) 1903 { 1904 struct net_device *dev = ctl->extra1; 1905 struct inet6_dev *idev; 1906 int ret; 1907 1908 if ((strcmp(ctl->procname, "retrans_time") == 0) || 1909 (strcmp(ctl->procname, "base_reachable_time") == 0)) 1910 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default"); 1911 1912 if (strcmp(ctl->procname, "retrans_time") == 0) 1913 ret = neigh_proc_dointvec(ctl, write, buffer, lenp, ppos); 1914 1915 else if (strcmp(ctl->procname, "base_reachable_time") == 0) 1916 ret = neigh_proc_dointvec_jiffies(ctl, write, 1917 buffer, lenp, ppos); 1918 1919 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) || 1920 (strcmp(ctl->procname, "base_reachable_time_ms") == 0)) 1921 ret = neigh_proc_dointvec_ms_jiffies(ctl, write, 1922 buffer, lenp, ppos); 1923 else 1924 ret = -1; 1925 1926 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) { 1927 if (ctl->data == &NEIGH_VAR(idev->nd_parms, BASE_REACHABLE_TIME)) 1928 idev->nd_parms->reachable_time = 1929 neigh_rand_reach_time(NEIGH_VAR(idev->nd_parms, BASE_REACHABLE_TIME)); 1930 idev->tstamp = jiffies; 1931 inet6_ifinfo_notify(RTM_NEWLINK, idev); 1932 in6_dev_put(idev); 1933 } 1934 return ret; 1935 } 1936 1937 1938 #endif 1939 1940 static int __net_init ndisc_net_init(struct net *net) 1941 { 1942 struct ipv6_pinfo *np; 1943 struct sock *sk; 1944 int err; 1945 1946 err = inet_ctl_sock_create(&sk, PF_INET6, 1947 SOCK_RAW, IPPROTO_ICMPV6, net); 1948 if (err < 0) { 1949 ND_PRINTK(0, err, 1950 "NDISC: Failed to initialize the control socket (err %d)\n", 1951 err); 1952 return err; 1953 } 1954 1955 net->ipv6.ndisc_sk = sk; 1956 1957 np = inet6_sk(sk); 1958 np->hop_limit = 255; 1959 /* Do not loopback ndisc messages */ 1960 np->mc_loop = 0; 1961 1962 return 0; 1963 } 1964 1965 static void __net_exit ndisc_net_exit(struct net *net) 1966 { 1967 inet_ctl_sock_destroy(net->ipv6.ndisc_sk); 1968 } 1969 1970 static struct pernet_operations ndisc_net_ops = { 1971 .init = ndisc_net_init, 1972 .exit = ndisc_net_exit, 1973 }; 1974 1975 int __init ndisc_init(void) 1976 { 1977 int err; 1978 1979 err = register_pernet_subsys(&ndisc_net_ops); 1980 if (err) 1981 return err; 1982 /* 1983 * Initialize the neighbour table 1984 */ 1985 neigh_table_init(NEIGH_ND_TABLE, &nd_tbl); 1986 1987 #ifdef CONFIG_SYSCTL 1988 err = neigh_sysctl_register(NULL, &nd_tbl.parms, 1989 ndisc_ifinfo_sysctl_change); 1990 if (err) 1991 goto out_unregister_pernet; 1992 out: 1993 #endif 1994 return err; 1995 1996 #ifdef CONFIG_SYSCTL 1997 out_unregister_pernet: 1998 unregister_pernet_subsys(&ndisc_net_ops); 1999 goto out; 2000 #endif 2001 } 2002 2003 int __init ndisc_late_init(void) 2004 { 2005 return register_netdevice_notifier(&ndisc_netdev_notifier); 2006 } 2007 2008 void ndisc_late_cleanup(void) 2009 { 2010 unregister_netdevice_notifier(&ndisc_netdev_notifier); 2011 } 2012 2013 void ndisc_cleanup(void) 2014 { 2015 #ifdef CONFIG_SYSCTL 2016 neigh_sysctl_unregister(&nd_tbl.parms); 2017 #endif 2018 neigh_table_clear(NEIGH_ND_TABLE, &nd_tbl); 2019 unregister_pernet_subsys(&ndisc_net_ops); 2020 } 2021