net/ipv6/ndisc.c

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