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 u8 new_state; 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_untracked_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 1045 neigh = neigh_lookup(&nd_tbl, &msg->target, dev); 1046 1047 /* RFC 9131 updates original Neighbour Discovery RFC 4861. 1048 * NAs with Target LL Address option without a corresponding 1049 * entry in the neighbour cache can now create a STALE neighbour 1050 * cache entry on routers. 1051 * 1052 * entry accept fwding solicited behaviour 1053 * ------- ------ ------ --------- ---------------------- 1054 * present X X 0 Set state to STALE 1055 * present X X 1 Set state to REACHABLE 1056 * absent 0 X X Do nothing 1057 * absent 1 0 X Do nothing 1058 * absent 1 1 X Add a new STALE entry 1059 * 1060 * Note that we don't do a (daddr == all-routers-mcast) check. 1061 */ 1062 new_state = msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE; 1063 if (!neigh && lladdr && 1064 idev && idev->cnf.forwarding && 1065 idev->cnf.accept_untracked_na) { 1066 neigh = neigh_create(&nd_tbl, &msg->target, dev); 1067 new_state = NUD_STALE; 1068 } 1069 1070 if (neigh && !IS_ERR(neigh)) { 1071 u8 old_flags = neigh->flags; 1072 struct net *net = dev_net(dev); 1073 1074 if (neigh->nud_state & NUD_FAILED) 1075 goto out; 1076 1077 /* 1078 * Don't update the neighbor cache entry on a proxy NA from 1079 * ourselves because either the proxied node is off link or it 1080 * has already sent a NA to us. 1081 */ 1082 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) && 1083 net->ipv6.devconf_all->forwarding && net->ipv6.devconf_all->proxy_ndp && 1084 pneigh_lookup(&nd_tbl, net, &msg->target, dev, 0)) { 1085 /* XXX: idev->cnf.proxy_ndp */ 1086 goto out; 1087 } 1088 1089 ndisc_update(dev, neigh, lladdr, 1090 new_state, 1091 NEIGH_UPDATE_F_WEAK_OVERRIDE| 1092 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)| 1093 NEIGH_UPDATE_F_OVERRIDE_ISROUTER| 1094 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0), 1095 NDISC_NEIGHBOUR_ADVERTISEMENT, &ndopts); 1096 1097 if ((old_flags & ~neigh->flags) & NTF_ROUTER) { 1098 /* 1099 * Change: router to host 1100 */ 1101 rt6_clean_tohost(dev_net(dev), saddr); 1102 } 1103 1104 out: 1105 neigh_release(neigh); 1106 } 1107 } 1108 1109 static void ndisc_recv_rs(struct sk_buff *skb) 1110 { 1111 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb); 1112 unsigned long ndoptlen = skb->len - sizeof(*rs_msg); 1113 struct neighbour *neigh; 1114 struct inet6_dev *idev; 1115 const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr; 1116 struct ndisc_options ndopts; 1117 u8 *lladdr = NULL; 1118 1119 if (skb->len < sizeof(*rs_msg)) 1120 return; 1121 1122 idev = __in6_dev_get(skb->dev); 1123 if (!idev) { 1124 ND_PRINTK(1, err, "RS: can't find in6 device\n"); 1125 return; 1126 } 1127 1128 /* Don't accept RS if we're not in router mode */ 1129 if (!idev->cnf.forwarding) 1130 goto out; 1131 1132 /* 1133 * Don't update NCE if src = ::; 1134 * this implies that the source node has no ip address assigned yet. 1135 */ 1136 if (ipv6_addr_any(saddr)) 1137 goto out; 1138 1139 /* Parse ND options */ 1140 if (!ndisc_parse_options(skb->dev, rs_msg->opt, ndoptlen, &ndopts)) { 1141 ND_PRINTK(2, notice, "NS: invalid ND option, ignored\n"); 1142 goto out; 1143 } 1144 1145 if (ndopts.nd_opts_src_lladdr) { 1146 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, 1147 skb->dev); 1148 if (!lladdr) 1149 goto out; 1150 } 1151 1152 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1); 1153 if (neigh) { 1154 ndisc_update(skb->dev, neigh, lladdr, NUD_STALE, 1155 NEIGH_UPDATE_F_WEAK_OVERRIDE| 1156 NEIGH_UPDATE_F_OVERRIDE| 1157 NEIGH_UPDATE_F_OVERRIDE_ISROUTER, 1158 NDISC_ROUTER_SOLICITATION, &ndopts); 1159 neigh_release(neigh); 1160 } 1161 out: 1162 return; 1163 } 1164 1165 static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt) 1166 { 1167 struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra); 1168 struct sk_buff *skb; 1169 struct nlmsghdr *nlh; 1170 struct nduseroptmsg *ndmsg; 1171 struct net *net = dev_net(ra->dev); 1172 int err; 1173 int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg) 1174 + (opt->nd_opt_len << 3)); 1175 size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr)); 1176 1177 skb = nlmsg_new(msg_size, GFP_ATOMIC); 1178 if (!skb) { 1179 err = -ENOBUFS; 1180 goto errout; 1181 } 1182 1183 nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0); 1184 if (!nlh) { 1185 goto nla_put_failure; 1186 } 1187 1188 ndmsg = nlmsg_data(nlh); 1189 ndmsg->nduseropt_family = AF_INET6; 1190 ndmsg->nduseropt_ifindex = ra->dev->ifindex; 1191 ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type; 1192 ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code; 1193 ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3; 1194 1195 memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3); 1196 1197 if (nla_put_in6_addr(skb, NDUSEROPT_SRCADDR, &ipv6_hdr(ra)->saddr)) 1198 goto nla_put_failure; 1199 nlmsg_end(skb, nlh); 1200 1201 rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL, GFP_ATOMIC); 1202 return; 1203 1204 nla_put_failure: 1205 nlmsg_free(skb); 1206 err = -EMSGSIZE; 1207 errout: 1208 rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err); 1209 } 1210 1211 static void ndisc_router_discovery(struct sk_buff *skb) 1212 { 1213 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb); 1214 struct neighbour *neigh = NULL; 1215 struct inet6_dev *in6_dev; 1216 struct fib6_info *rt = NULL; 1217 u32 defrtr_usr_metric; 1218 struct net *net; 1219 int lifetime; 1220 struct ndisc_options ndopts; 1221 int optlen; 1222 unsigned int pref = 0; 1223 __u32 old_if_flags; 1224 bool send_ifinfo_notify = false; 1225 1226 __u8 *opt = (__u8 *)(ra_msg + 1); 1227 1228 optlen = (skb_tail_pointer(skb) - skb_transport_header(skb)) - 1229 sizeof(struct ra_msg); 1230 1231 ND_PRINTK(2, info, 1232 "RA: %s, dev: %s\n", 1233 __func__, skb->dev->name); 1234 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) { 1235 ND_PRINTK(2, warn, "RA: source address is not link-local\n"); 1236 return; 1237 } 1238 if (optlen < 0) { 1239 ND_PRINTK(2, warn, "RA: packet too short\n"); 1240 return; 1241 } 1242 1243 #ifdef CONFIG_IPV6_NDISC_NODETYPE 1244 if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) { 1245 ND_PRINTK(2, warn, "RA: from host or unauthorized router\n"); 1246 return; 1247 } 1248 #endif 1249 1250 /* 1251 * set the RA_RECV flag in the interface 1252 */ 1253 1254 in6_dev = __in6_dev_get(skb->dev); 1255 if (!in6_dev) { 1256 ND_PRINTK(0, err, "RA: can't find inet6 device for %s\n", 1257 skb->dev->name); 1258 return; 1259 } 1260 1261 if (!ndisc_parse_options(skb->dev, opt, optlen, &ndopts)) { 1262 ND_PRINTK(2, warn, "RA: invalid ND options\n"); 1263 return; 1264 } 1265 1266 if (!ipv6_accept_ra(in6_dev)) { 1267 ND_PRINTK(2, info, 1268 "RA: %s, did not accept ra for dev: %s\n", 1269 __func__, skb->dev->name); 1270 goto skip_linkparms; 1271 } 1272 1273 #ifdef CONFIG_IPV6_NDISC_NODETYPE 1274 /* skip link-specific parameters from interior routers */ 1275 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT) { 1276 ND_PRINTK(2, info, 1277 "RA: %s, nodetype is NODEFAULT, dev: %s\n", 1278 __func__, skb->dev->name); 1279 goto skip_linkparms; 1280 } 1281 #endif 1282 1283 if (in6_dev->if_flags & IF_RS_SENT) { 1284 /* 1285 * flag that an RA was received after an RS was sent 1286 * out on this interface. 1287 */ 1288 in6_dev->if_flags |= IF_RA_RCVD; 1289 } 1290 1291 /* 1292 * Remember the managed/otherconf flags from most recently 1293 * received RA message (RFC 2462) -- yoshfuji 1294 */ 1295 old_if_flags = in6_dev->if_flags; 1296 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED | 1297 IF_RA_OTHERCONF)) | 1298 (ra_msg->icmph.icmp6_addrconf_managed ? 1299 IF_RA_MANAGED : 0) | 1300 (ra_msg->icmph.icmp6_addrconf_other ? 1301 IF_RA_OTHERCONF : 0); 1302 1303 if (old_if_flags != in6_dev->if_flags) 1304 send_ifinfo_notify = true; 1305 1306 if (!in6_dev->cnf.accept_ra_defrtr) { 1307 ND_PRINTK(2, info, 1308 "RA: %s, defrtr is false for dev: %s\n", 1309 __func__, skb->dev->name); 1310 goto skip_defrtr; 1311 } 1312 1313 /* Do not accept RA with source-addr found on local machine unless 1314 * accept_ra_from_local is set to true. 1315 */ 1316 net = dev_net(in6_dev->dev); 1317 if (!in6_dev->cnf.accept_ra_from_local && 1318 ipv6_chk_addr(net, &ipv6_hdr(skb)->saddr, in6_dev->dev, 0)) { 1319 ND_PRINTK(2, info, 1320 "RA from local address detected on dev: %s: default router ignored\n", 1321 skb->dev->name); 1322 goto skip_defrtr; 1323 } 1324 1325 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime); 1326 1327 #ifdef CONFIG_IPV6_ROUTER_PREF 1328 pref = ra_msg->icmph.icmp6_router_pref; 1329 /* 10b is handled as if it were 00b (medium) */ 1330 if (pref == ICMPV6_ROUTER_PREF_INVALID || 1331 !in6_dev->cnf.accept_ra_rtr_pref) 1332 pref = ICMPV6_ROUTER_PREF_MEDIUM; 1333 #endif 1334 /* routes added from RAs do not use nexthop objects */ 1335 rt = rt6_get_dflt_router(net, &ipv6_hdr(skb)->saddr, skb->dev); 1336 if (rt) { 1337 neigh = ip6_neigh_lookup(&rt->fib6_nh->fib_nh_gw6, 1338 rt->fib6_nh->fib_nh_dev, NULL, 1339 &ipv6_hdr(skb)->saddr); 1340 if (!neigh) { 1341 ND_PRINTK(0, err, 1342 "RA: %s got default router without neighbour\n", 1343 __func__); 1344 fib6_info_release(rt); 1345 return; 1346 } 1347 } 1348 /* Set default route metric as specified by user */ 1349 defrtr_usr_metric = in6_dev->cnf.ra_defrtr_metric; 1350 /* delete the route if lifetime is 0 or if metric needs change */ 1351 if (rt && (lifetime == 0 || rt->fib6_metric != defrtr_usr_metric)) { 1352 ip6_del_rt(net, rt, false); 1353 rt = NULL; 1354 } 1355 1356 ND_PRINTK(3, info, "RA: rt: %p lifetime: %d, metric: %d, for dev: %s\n", 1357 rt, lifetime, defrtr_usr_metric, skb->dev->name); 1358 if (!rt && lifetime) { 1359 ND_PRINTK(3, info, "RA: adding default router\n"); 1360 1361 rt = rt6_add_dflt_router(net, &ipv6_hdr(skb)->saddr, 1362 skb->dev, pref, defrtr_usr_metric); 1363 if (!rt) { 1364 ND_PRINTK(0, err, 1365 "RA: %s failed to add default route\n", 1366 __func__); 1367 return; 1368 } 1369 1370 neigh = ip6_neigh_lookup(&rt->fib6_nh->fib_nh_gw6, 1371 rt->fib6_nh->fib_nh_dev, NULL, 1372 &ipv6_hdr(skb)->saddr); 1373 if (!neigh) { 1374 ND_PRINTK(0, err, 1375 "RA: %s got default router without neighbour\n", 1376 __func__); 1377 fib6_info_release(rt); 1378 return; 1379 } 1380 neigh->flags |= NTF_ROUTER; 1381 } else if (rt && IPV6_EXTRACT_PREF(rt->fib6_flags) != pref) { 1382 struct nl_info nlinfo = { 1383 .nl_net = net, 1384 }; 1385 rt->fib6_flags = (rt->fib6_flags & ~RTF_PREF_MASK) | RTF_PREF(pref); 1386 inet6_rt_notify(RTM_NEWROUTE, rt, &nlinfo, NLM_F_REPLACE); 1387 } 1388 1389 if (rt) 1390 fib6_set_expires(rt, jiffies + (HZ * lifetime)); 1391 if (in6_dev->cnf.accept_ra_min_hop_limit < 256 && 1392 ra_msg->icmph.icmp6_hop_limit) { 1393 if (in6_dev->cnf.accept_ra_min_hop_limit <= ra_msg->icmph.icmp6_hop_limit) { 1394 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit; 1395 fib6_metric_set(rt, RTAX_HOPLIMIT, 1396 ra_msg->icmph.icmp6_hop_limit); 1397 } else { 1398 ND_PRINTK(2, warn, "RA: Got route advertisement with lower hop_limit than minimum\n"); 1399 } 1400 } 1401 1402 skip_defrtr: 1403 1404 /* 1405 * Update Reachable Time and Retrans Timer 1406 */ 1407 1408 if (in6_dev->nd_parms) { 1409 unsigned long rtime = ntohl(ra_msg->retrans_timer); 1410 1411 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) { 1412 rtime = (rtime*HZ)/1000; 1413 if (rtime < HZ/100) 1414 rtime = HZ/100; 1415 NEIGH_VAR_SET(in6_dev->nd_parms, RETRANS_TIME, rtime); 1416 in6_dev->tstamp = jiffies; 1417 send_ifinfo_notify = true; 1418 } 1419 1420 rtime = ntohl(ra_msg->reachable_time); 1421 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) { 1422 rtime = (rtime*HZ)/1000; 1423 1424 if (rtime < HZ/10) 1425 rtime = HZ/10; 1426 1427 if (rtime != NEIGH_VAR(in6_dev->nd_parms, BASE_REACHABLE_TIME)) { 1428 NEIGH_VAR_SET(in6_dev->nd_parms, 1429 BASE_REACHABLE_TIME, rtime); 1430 NEIGH_VAR_SET(in6_dev->nd_parms, 1431 GC_STALETIME, 3 * rtime); 1432 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime); 1433 in6_dev->tstamp = jiffies; 1434 send_ifinfo_notify = true; 1435 } 1436 } 1437 } 1438 1439 skip_linkparms: 1440 1441 /* 1442 * Process options. 1443 */ 1444 1445 if (!neigh) 1446 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr, 1447 skb->dev, 1); 1448 if (neigh) { 1449 u8 *lladdr = NULL; 1450 if (ndopts.nd_opts_src_lladdr) { 1451 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, 1452 skb->dev); 1453 if (!lladdr) { 1454 ND_PRINTK(2, warn, 1455 "RA: invalid link-layer address length\n"); 1456 goto out; 1457 } 1458 } 1459 ndisc_update(skb->dev, neigh, lladdr, NUD_STALE, 1460 NEIGH_UPDATE_F_WEAK_OVERRIDE| 1461 NEIGH_UPDATE_F_OVERRIDE| 1462 NEIGH_UPDATE_F_OVERRIDE_ISROUTER| 1463 NEIGH_UPDATE_F_ISROUTER, 1464 NDISC_ROUTER_ADVERTISEMENT, &ndopts); 1465 } 1466 1467 if (!ipv6_accept_ra(in6_dev)) { 1468 ND_PRINTK(2, info, 1469 "RA: %s, accept_ra is false for dev: %s\n", 1470 __func__, skb->dev->name); 1471 goto out; 1472 } 1473 1474 #ifdef CONFIG_IPV6_ROUTE_INFO 1475 if (!in6_dev->cnf.accept_ra_from_local && 1476 ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr, 1477 in6_dev->dev, 0)) { 1478 ND_PRINTK(2, info, 1479 "RA from local address detected on dev: %s: router info ignored.\n", 1480 skb->dev->name); 1481 goto skip_routeinfo; 1482 } 1483 1484 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) { 1485 struct nd_opt_hdr *p; 1486 for (p = ndopts.nd_opts_ri; 1487 p; 1488 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) { 1489 struct route_info *ri = (struct route_info *)p; 1490 #ifdef CONFIG_IPV6_NDISC_NODETYPE 1491 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT && 1492 ri->prefix_len == 0) 1493 continue; 1494 #endif 1495 if (ri->prefix_len == 0 && 1496 !in6_dev->cnf.accept_ra_defrtr) 1497 continue; 1498 if (ri->prefix_len < in6_dev->cnf.accept_ra_rt_info_min_plen) 1499 continue; 1500 if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen) 1501 continue; 1502 rt6_route_rcv(skb->dev, (u8 *)p, (p->nd_opt_len) << 3, 1503 &ipv6_hdr(skb)->saddr); 1504 } 1505 } 1506 1507 skip_routeinfo: 1508 #endif 1509 1510 #ifdef CONFIG_IPV6_NDISC_NODETYPE 1511 /* skip link-specific ndopts from interior routers */ 1512 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT) { 1513 ND_PRINTK(2, info, 1514 "RA: %s, nodetype is NODEFAULT (interior routes), dev: %s\n", 1515 __func__, skb->dev->name); 1516 goto out; 1517 } 1518 #endif 1519 1520 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) { 1521 struct nd_opt_hdr *p; 1522 for (p = ndopts.nd_opts_pi; 1523 p; 1524 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) { 1525 addrconf_prefix_rcv(skb->dev, (u8 *)p, 1526 (p->nd_opt_len) << 3, 1527 ndopts.nd_opts_src_lladdr != NULL); 1528 } 1529 } 1530 1531 if (ndopts.nd_opts_mtu && in6_dev->cnf.accept_ra_mtu) { 1532 __be32 n; 1533 u32 mtu; 1534 1535 memcpy(&n, ((u8 *)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu)); 1536 mtu = ntohl(n); 1537 1538 if (in6_dev->ra_mtu != mtu) { 1539 in6_dev->ra_mtu = mtu; 1540 send_ifinfo_notify = true; 1541 } 1542 1543 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) { 1544 ND_PRINTK(2, warn, "RA: invalid mtu: %d\n", mtu); 1545 } else if (in6_dev->cnf.mtu6 != mtu) { 1546 in6_dev->cnf.mtu6 = mtu; 1547 fib6_metric_set(rt, RTAX_MTU, mtu); 1548 rt6_mtu_change(skb->dev, mtu); 1549 } 1550 } 1551 1552 if (ndopts.nd_useropts) { 1553 struct nd_opt_hdr *p; 1554 for (p = ndopts.nd_useropts; 1555 p; 1556 p = ndisc_next_useropt(skb->dev, p, 1557 ndopts.nd_useropts_end)) { 1558 ndisc_ra_useropt(skb, p); 1559 } 1560 } 1561 1562 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) { 1563 ND_PRINTK(2, warn, "RA: invalid RA options\n"); 1564 } 1565 out: 1566 /* Send a notify if RA changed managed/otherconf flags or 1567 * timer settings or ra_mtu value 1568 */ 1569 if (send_ifinfo_notify) 1570 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev); 1571 1572 fib6_info_release(rt); 1573 if (neigh) 1574 neigh_release(neigh); 1575 } 1576 1577 static void ndisc_redirect_rcv(struct sk_buff *skb) 1578 { 1579 u8 *hdr; 1580 struct ndisc_options ndopts; 1581 struct rd_msg *msg = (struct rd_msg *)skb_transport_header(skb); 1582 u32 ndoptlen = skb_tail_pointer(skb) - (skb_transport_header(skb) + 1583 offsetof(struct rd_msg, opt)); 1584 1585 #ifdef CONFIG_IPV6_NDISC_NODETYPE 1586 switch (skb->ndisc_nodetype) { 1587 case NDISC_NODETYPE_HOST: 1588 case NDISC_NODETYPE_NODEFAULT: 1589 ND_PRINTK(2, warn, 1590 "Redirect: from host or unauthorized router\n"); 1591 return; 1592 } 1593 #endif 1594 1595 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) { 1596 ND_PRINTK(2, warn, 1597 "Redirect: source address is not link-local\n"); 1598 return; 1599 } 1600 1601 if (!ndisc_parse_options(skb->dev, msg->opt, ndoptlen, &ndopts)) 1602 return; 1603 1604 if (!ndopts.nd_opts_rh) { 1605 ip6_redirect_no_header(skb, dev_net(skb->dev), 1606 skb->dev->ifindex); 1607 return; 1608 } 1609 1610 hdr = (u8 *)ndopts.nd_opts_rh; 1611 hdr += 8; 1612 if (!pskb_pull(skb, hdr - skb_transport_header(skb))) 1613 return; 1614 1615 icmpv6_notify(skb, NDISC_REDIRECT, 0, 0); 1616 } 1617 1618 static void ndisc_fill_redirect_hdr_option(struct sk_buff *skb, 1619 struct sk_buff *orig_skb, 1620 int rd_len) 1621 { 1622 u8 *opt = skb_put(skb, rd_len); 1623 1624 memset(opt, 0, 8); 1625 *(opt++) = ND_OPT_REDIRECT_HDR; 1626 *(opt++) = (rd_len >> 3); 1627 opt += 6; 1628 1629 skb_copy_bits(orig_skb, skb_network_offset(orig_skb), opt, 1630 rd_len - 8); 1631 } 1632 1633 void ndisc_send_redirect(struct sk_buff *skb, const struct in6_addr *target) 1634 { 1635 struct net_device *dev = skb->dev; 1636 struct net *net = dev_net(dev); 1637 struct sock *sk = net->ipv6.ndisc_sk; 1638 int optlen = 0; 1639 struct inet_peer *peer; 1640 struct sk_buff *buff; 1641 struct rd_msg *msg; 1642 struct in6_addr saddr_buf; 1643 struct rt6_info *rt; 1644 struct dst_entry *dst; 1645 struct flowi6 fl6; 1646 int rd_len; 1647 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL, 1648 ops_data_buf[NDISC_OPS_REDIRECT_DATA_SPACE], *ops_data = NULL; 1649 bool ret; 1650 1651 if (netif_is_l3_master(skb->dev)) { 1652 dev = __dev_get_by_index(dev_net(skb->dev), IPCB(skb)->iif); 1653 if (!dev) 1654 return; 1655 } 1656 1657 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) { 1658 ND_PRINTK(2, warn, "Redirect: no link-local address on %s\n", 1659 dev->name); 1660 return; 1661 } 1662 1663 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) && 1664 ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) { 1665 ND_PRINTK(2, warn, 1666 "Redirect: target address is not link-local unicast\n"); 1667 return; 1668 } 1669 1670 icmpv6_flow_init(sk, &fl6, NDISC_REDIRECT, 1671 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex); 1672 1673 dst = ip6_route_output(net, NULL, &fl6); 1674 if (dst->error) { 1675 dst_release(dst); 1676 return; 1677 } 1678 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), NULL, 0); 1679 if (IS_ERR(dst)) 1680 return; 1681 1682 rt = (struct rt6_info *) dst; 1683 1684 if (rt->rt6i_flags & RTF_GATEWAY) { 1685 ND_PRINTK(2, warn, 1686 "Redirect: destination is not a neighbour\n"); 1687 goto release; 1688 } 1689 peer = inet_getpeer_v6(net->ipv6.peers, &ipv6_hdr(skb)->saddr, 1); 1690 ret = inet_peer_xrlim_allow(peer, 1*HZ); 1691 if (peer) 1692 inet_putpeer(peer); 1693 if (!ret) 1694 goto release; 1695 1696 if (dev->addr_len) { 1697 struct neighbour *neigh = dst_neigh_lookup(skb_dst(skb), target); 1698 if (!neigh) { 1699 ND_PRINTK(2, warn, 1700 "Redirect: no neigh for target address\n"); 1701 goto release; 1702 } 1703 1704 read_lock_bh(&neigh->lock); 1705 if (neigh->nud_state & NUD_VALID) { 1706 memcpy(ha_buf, neigh->ha, dev->addr_len); 1707 read_unlock_bh(&neigh->lock); 1708 ha = ha_buf; 1709 optlen += ndisc_redirect_opt_addr_space(dev, neigh, 1710 ops_data_buf, 1711 &ops_data); 1712 } else 1713 read_unlock_bh(&neigh->lock); 1714 1715 neigh_release(neigh); 1716 } 1717 1718 rd_len = min_t(unsigned int, 1719 IPV6_MIN_MTU - sizeof(struct ipv6hdr) - sizeof(*msg) - optlen, 1720 skb->len + 8); 1721 rd_len &= ~0x7; 1722 optlen += rd_len; 1723 1724 buff = ndisc_alloc_skb(dev, sizeof(*msg) + optlen); 1725 if (!buff) 1726 goto release; 1727 1728 msg = skb_put(buff, sizeof(*msg)); 1729 *msg = (struct rd_msg) { 1730 .icmph = { 1731 .icmp6_type = NDISC_REDIRECT, 1732 }, 1733 .target = *target, 1734 .dest = ipv6_hdr(skb)->daddr, 1735 }; 1736 1737 /* 1738 * include target_address option 1739 */ 1740 1741 if (ha) 1742 ndisc_fill_redirect_addr_option(buff, ha, ops_data); 1743 1744 /* 1745 * build redirect option and copy skb over to the new packet. 1746 */ 1747 1748 if (rd_len) 1749 ndisc_fill_redirect_hdr_option(buff, skb, rd_len); 1750 1751 skb_dst_set(buff, dst); 1752 ndisc_send_skb(buff, &ipv6_hdr(skb)->saddr, &saddr_buf); 1753 return; 1754 1755 release: 1756 dst_release(dst); 1757 } 1758 1759 static void pndisc_redo(struct sk_buff *skb) 1760 { 1761 ndisc_recv_ns(skb); 1762 kfree_skb(skb); 1763 } 1764 1765 static int ndisc_is_multicast(const void *pkey) 1766 { 1767 return ipv6_addr_is_multicast((struct in6_addr *)pkey); 1768 } 1769 1770 static bool ndisc_suppress_frag_ndisc(struct sk_buff *skb) 1771 { 1772 struct inet6_dev *idev = __in6_dev_get(skb->dev); 1773 1774 if (!idev) 1775 return true; 1776 if (IP6CB(skb)->flags & IP6SKB_FRAGMENTED && 1777 idev->cnf.suppress_frag_ndisc) { 1778 net_warn_ratelimited("Received fragmented ndisc packet. Carefully consider disabling suppress_frag_ndisc.\n"); 1779 return true; 1780 } 1781 return false; 1782 } 1783 1784 int ndisc_rcv(struct sk_buff *skb) 1785 { 1786 struct nd_msg *msg; 1787 1788 if (ndisc_suppress_frag_ndisc(skb)) 1789 return 0; 1790 1791 if (skb_linearize(skb)) 1792 return 0; 1793 1794 msg = (struct nd_msg *)skb_transport_header(skb); 1795 1796 __skb_push(skb, skb->data - skb_transport_header(skb)); 1797 1798 if (ipv6_hdr(skb)->hop_limit != 255) { 1799 ND_PRINTK(2, warn, "NDISC: invalid hop-limit: %d\n", 1800 ipv6_hdr(skb)->hop_limit); 1801 return 0; 1802 } 1803 1804 if (msg->icmph.icmp6_code != 0) { 1805 ND_PRINTK(2, warn, "NDISC: invalid ICMPv6 code: %d\n", 1806 msg->icmph.icmp6_code); 1807 return 0; 1808 } 1809 1810 switch (msg->icmph.icmp6_type) { 1811 case NDISC_NEIGHBOUR_SOLICITATION: 1812 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb)); 1813 ndisc_recv_ns(skb); 1814 break; 1815 1816 case NDISC_NEIGHBOUR_ADVERTISEMENT: 1817 ndisc_recv_na(skb); 1818 break; 1819 1820 case NDISC_ROUTER_SOLICITATION: 1821 ndisc_recv_rs(skb); 1822 break; 1823 1824 case NDISC_ROUTER_ADVERTISEMENT: 1825 ndisc_router_discovery(skb); 1826 break; 1827 1828 case NDISC_REDIRECT: 1829 ndisc_redirect_rcv(skb); 1830 break; 1831 } 1832 1833 return 0; 1834 } 1835 1836 static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr) 1837 { 1838 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 1839 struct netdev_notifier_change_info *change_info; 1840 struct net *net = dev_net(dev); 1841 struct inet6_dev *idev; 1842 bool evict_nocarrier; 1843 1844 switch (event) { 1845 case NETDEV_CHANGEADDR: 1846 neigh_changeaddr(&nd_tbl, dev); 1847 fib6_run_gc(0, net, false); 1848 fallthrough; 1849 case NETDEV_UP: 1850 idev = in6_dev_get(dev); 1851 if (!idev) 1852 break; 1853 if (idev->cnf.ndisc_notify || 1854 net->ipv6.devconf_all->ndisc_notify) 1855 ndisc_send_unsol_na(dev); 1856 in6_dev_put(idev); 1857 break; 1858 case NETDEV_CHANGE: 1859 idev = in6_dev_get(dev); 1860 if (!idev) 1861 evict_nocarrier = true; 1862 else { 1863 evict_nocarrier = idev->cnf.ndisc_evict_nocarrier && 1864 net->ipv6.devconf_all->ndisc_evict_nocarrier; 1865 in6_dev_put(idev); 1866 } 1867 1868 change_info = ptr; 1869 if (change_info->flags_changed & IFF_NOARP) 1870 neigh_changeaddr(&nd_tbl, dev); 1871 if (evict_nocarrier && !netif_carrier_ok(dev)) 1872 neigh_carrier_down(&nd_tbl, dev); 1873 break; 1874 case NETDEV_DOWN: 1875 neigh_ifdown(&nd_tbl, dev); 1876 fib6_run_gc(0, net, false); 1877 break; 1878 case NETDEV_NOTIFY_PEERS: 1879 ndisc_send_unsol_na(dev); 1880 break; 1881 default: 1882 break; 1883 } 1884 1885 return NOTIFY_DONE; 1886 } 1887 1888 static struct notifier_block ndisc_netdev_notifier = { 1889 .notifier_call = ndisc_netdev_event, 1890 .priority = ADDRCONF_NOTIFY_PRIORITY - 5, 1891 }; 1892 1893 #ifdef CONFIG_SYSCTL 1894 static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl, 1895 const char *func, const char *dev_name) 1896 { 1897 static char warncomm[TASK_COMM_LEN]; 1898 static int warned; 1899 if (strcmp(warncomm, current->comm) && warned < 5) { 1900 strcpy(warncomm, current->comm); 1901 pr_warn("process `%s' is using deprecated sysctl (%s) net.ipv6.neigh.%s.%s - use net.ipv6.neigh.%s.%s_ms instead\n", 1902 warncomm, func, 1903 dev_name, ctl->procname, 1904 dev_name, ctl->procname); 1905 warned++; 1906 } 1907 } 1908 1909 int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, void *buffer, 1910 size_t *lenp, loff_t *ppos) 1911 { 1912 struct net_device *dev = ctl->extra1; 1913 struct inet6_dev *idev; 1914 int ret; 1915 1916 if ((strcmp(ctl->procname, "retrans_time") == 0) || 1917 (strcmp(ctl->procname, "base_reachable_time") == 0)) 1918 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default"); 1919 1920 if (strcmp(ctl->procname, "retrans_time") == 0) 1921 ret = neigh_proc_dointvec(ctl, write, buffer, lenp, ppos); 1922 1923 else if (strcmp(ctl->procname, "base_reachable_time") == 0) 1924 ret = neigh_proc_dointvec_jiffies(ctl, write, 1925 buffer, lenp, ppos); 1926 1927 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) || 1928 (strcmp(ctl->procname, "base_reachable_time_ms") == 0)) 1929 ret = neigh_proc_dointvec_ms_jiffies(ctl, write, 1930 buffer, lenp, ppos); 1931 else 1932 ret = -1; 1933 1934 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) { 1935 if (ctl->data == &NEIGH_VAR(idev->nd_parms, BASE_REACHABLE_TIME)) 1936 idev->nd_parms->reachable_time = 1937 neigh_rand_reach_time(NEIGH_VAR(idev->nd_parms, BASE_REACHABLE_TIME)); 1938 idev->tstamp = jiffies; 1939 inet6_ifinfo_notify(RTM_NEWLINK, idev); 1940 in6_dev_put(idev); 1941 } 1942 return ret; 1943 } 1944 1945 1946 #endif 1947 1948 static int __net_init ndisc_net_init(struct net *net) 1949 { 1950 struct ipv6_pinfo *np; 1951 struct sock *sk; 1952 int err; 1953 1954 err = inet_ctl_sock_create(&sk, PF_INET6, 1955 SOCK_RAW, IPPROTO_ICMPV6, net); 1956 if (err < 0) { 1957 ND_PRINTK(0, err, 1958 "NDISC: Failed to initialize the control socket (err %d)\n", 1959 err); 1960 return err; 1961 } 1962 1963 net->ipv6.ndisc_sk = sk; 1964 1965 np = inet6_sk(sk); 1966 np->hop_limit = 255; 1967 /* Do not loopback ndisc messages */ 1968 np->mc_loop = 0; 1969 1970 return 0; 1971 } 1972 1973 static void __net_exit ndisc_net_exit(struct net *net) 1974 { 1975 inet_ctl_sock_destroy(net->ipv6.ndisc_sk); 1976 } 1977 1978 static struct pernet_operations ndisc_net_ops = { 1979 .init = ndisc_net_init, 1980 .exit = ndisc_net_exit, 1981 }; 1982 1983 int __init ndisc_init(void) 1984 { 1985 int err; 1986 1987 err = register_pernet_subsys(&ndisc_net_ops); 1988 if (err) 1989 return err; 1990 /* 1991 * Initialize the neighbour table 1992 */ 1993 neigh_table_init(NEIGH_ND_TABLE, &nd_tbl); 1994 1995 #ifdef CONFIG_SYSCTL 1996 err = neigh_sysctl_register(NULL, &nd_tbl.parms, 1997 ndisc_ifinfo_sysctl_change); 1998 if (err) 1999 goto out_unregister_pernet; 2000 out: 2001 #endif 2002 return err; 2003 2004 #ifdef CONFIG_SYSCTL 2005 out_unregister_pernet: 2006 unregister_pernet_subsys(&ndisc_net_ops); 2007 goto out; 2008 #endif 2009 } 2010 2011 int __init ndisc_late_init(void) 2012 { 2013 return register_netdevice_notifier(&ndisc_netdev_notifier); 2014 } 2015 2016 void ndisc_late_cleanup(void) 2017 { 2018 unregister_netdevice_notifier(&ndisc_netdev_notifier); 2019 } 2020 2021 void ndisc_cleanup(void) 2022 { 2023 #ifdef CONFIG_SYSCTL 2024 neigh_sysctl_unregister(&nd_tbl.parms); 2025 #endif 2026 neigh_table_clear(NEIGH_ND_TABLE, &nd_tbl); 2027 unregister_pernet_subsys(&ndisc_net_ops); 2028 } 2029