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