net/ipv6/ndisc.c

   1 /*
   2  *      Neighbour Discovery for IPv6
   3  *      Linux INET6 implementation
   4  *
   5  *      Authors:
   6  *      Pedro Roque             <[email protected]>
   7  *      Mike Shaver             <[email protected]>
   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                    struct sk_buff *oskb)
 561 {
 562         struct sk_buff *skb;
 563         struct in6_addr addr_buf;
 564         int inc_opt = dev->addr_len;
 565         int optlen = 0;
 566         struct nd_msg *msg;
 567
 568         if (!saddr) {
 569                 if (ipv6_get_lladdr(dev, &addr_buf,
 570                                    (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
 571                         return;
 572                 saddr = &addr_buf;
 573         }
 574
 575         if (ipv6_addr_any(saddr))
 576                 inc_opt = false;
 577         if (inc_opt)
 578                 optlen += ndisc_opt_addr_space(dev);
 579
 580         skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
 581         if (!skb)
 582                 return;
 583
 584         msg = (struct nd_msg *)skb_put(skb, sizeof(*msg));
 585         *msg = (struct nd_msg) {
 586                 .icmph = {
 587                         .icmp6_type = NDISC_NEIGHBOUR_SOLICITATION,
 588                 },
 589                 .target = *solicit,
 590         };
 591
 592         if (inc_opt)
 593                 ndisc_fill_addr_option(skb, ND_OPT_SOURCE_LL_ADDR,
 594                                        dev->dev_addr);
 595
 596         if (!(dev->priv_flags & IFF_XMIT_DST_RELEASE) && oskb)
 597                 skb_dst_copy(skb, oskb);
 598
 599         ndisc_send_skb(skb, daddr, saddr);
 600 }
 601
 602 void ndisc_send_rs(struct net_device *dev, const struct in6_addr *saddr,
 603                    const struct in6_addr *daddr)
 604 {
 605         struct sk_buff *skb;
 606         struct rs_msg *msg;
 607         int send_sllao = dev->addr_len;
 608         int optlen = 0;
 609
 610 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
 611         /*
 612          * According to section 2.2 of RFC 4429, we must not
 613          * send router solicitations with a sllao from
 614          * optimistic addresses, but we may send the solicitation
 615          * if we don't include the sllao.  So here we check
 616          * if our address is optimistic, and if so, we
 617          * suppress the inclusion of the sllao.
 618          */
 619         if (send_sllao) {
 620                 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev_net(dev), saddr,
 621                                                            dev, 1);
 622                 if (ifp) {
 623                         if (ifp->flags & IFA_F_OPTIMISTIC)  {
 624                                 send_sllao = 0;
 625                         }
 626                         in6_ifa_put(ifp);
 627                 } else {
 628                         send_sllao = 0;
 629                 }
 630         }
 631 #endif
 632         if (send_sllao)
 633                 optlen += ndisc_opt_addr_space(dev);
 634
 635         skb = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
 636         if (!skb)
 637                 return;
 638
 639         msg = (struct rs_msg *)skb_put(skb, sizeof(*msg));
 640         *msg = (struct rs_msg) {
 641                 .icmph = {
 642                         .icmp6_type = NDISC_ROUTER_SOLICITATION,
 643                 },
 644         };
 645
 646         if (send_sllao)
 647                 ndisc_fill_addr_option(skb, ND_OPT_SOURCE_LL_ADDR,
 648                                        dev->dev_addr);
 649
 650         ndisc_send_skb(skb, daddr, saddr);
 651 }
 652
 653
 654 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
 655 {
 656         /*
 657          *      "The sender MUST return an ICMP
 658          *       destination unreachable"
 659          */
 660         dst_link_failure(skb);
 661         kfree_skb(skb);
 662 }
 663
 664 /* Called with locked neigh: either read or both */
 665
 666 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
 667 {
 668         struct in6_addr *saddr = NULL;
 669         struct in6_addr mcaddr;
 670         struct net_device *dev = neigh->dev;
 671         struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
 672         int probes = atomic_read(&neigh->probes);
 673
 674         if (skb && ipv6_chk_addr_and_flags(dev_net(dev), &ipv6_hdr(skb)->saddr,
 675                                            dev, 1,
 676                                            IFA_F_TENTATIVE|IFA_F_OPTIMISTIC))
 677                 saddr = &ipv6_hdr(skb)->saddr;
 678         probes -= NEIGH_VAR(neigh->parms, UCAST_PROBES);
 679         if (probes < 0) {
 680                 if (!(neigh->nud_state & NUD_VALID)) {
 681                         ND_PRINTK(1, dbg,
 682                                   "%s: trying to ucast probe in NUD_INVALID: %pI6\n",
 683                                   __func__, target);
 684                 }
 685                 ndisc_send_ns(dev, target, target, saddr, skb);
 686         } else if ((probes -= NEIGH_VAR(neigh->parms, APP_PROBES)) < 0) {
 687                 neigh_app_ns(neigh);
 688         } else {
 689                 addrconf_addr_solict_mult(target, &mcaddr);
 690                 ndisc_send_ns(dev, target, &mcaddr, saddr, skb);
 691         }
 692 }
 693
 694 static int pndisc_is_router(const void *pkey,
 695                             struct net_device *dev)
 696 {
 697         struct pneigh_entry *n;
 698         int ret = -1;
 699
 700         read_lock_bh(&nd_tbl.lock);
 701         n = __pneigh_lookup(&nd_tbl, dev_net(dev), pkey, dev);
 702         if (n)
 703                 ret = !!(n->flags & NTF_ROUTER);
 704         read_unlock_bh(&nd_tbl.lock);
 705
 706         return ret;
 707 }
 708
 709 static void ndisc_recv_ns(struct sk_buff *skb)
 710 {
 711         struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
 712         const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
 713         const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
 714         u8 *lladdr = NULL;
 715         u32 ndoptlen = skb_tail_pointer(skb) - (skb_transport_header(skb) +
 716                                     offsetof(struct nd_msg, opt));
 717         struct ndisc_options ndopts;
 718         struct net_device *dev = skb->dev;
 719         struct inet6_ifaddr *ifp;
 720         struct inet6_dev *idev = NULL;
 721         struct neighbour *neigh;
 722         int dad = ipv6_addr_any(saddr);
 723         bool inc;
 724         int is_router = -1;
 725
 726         if (skb->len < sizeof(struct nd_msg)) {
 727                 ND_PRINTK(2, warn, "NS: packet too short\n");
 728                 return;
 729         }
 730
 731         if (ipv6_addr_is_multicast(&msg->target)) {
 732                 ND_PRINTK(2, warn, "NS: multicast target address\n");
 733                 return;
 734         }
 735
 736         /*
 737          * RFC2461 7.1.1:
 738          * DAD has to be destined for solicited node multicast address.
 739          */
 740         if (dad && !ipv6_addr_is_solict_mult(daddr)) {
 741                 ND_PRINTK(2, warn, "NS: bad DAD packet (wrong destination)\n");
 742                 return;
 743         }
 744
 745         if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
 746                 ND_PRINTK(2, warn, "NS: invalid ND options\n");
 747                 return;
 748         }
 749
 750         if (ndopts.nd_opts_src_lladdr) {
 751                 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
 752                 if (!lladdr) {
 753                         ND_PRINTK(2, warn,
 754                                   "NS: invalid link-layer address length\n");
 755                         return;
 756                 }
 757
 758                 /* RFC2461 7.1.1:
 759                  *      If the IP source address is the unspecified address,
 760                  *      there MUST NOT be source link-layer address option
 761                  *      in the message.
 762                  */
 763                 if (dad) {
 764                         ND_PRINTK(2, warn,
 765                                   "NS: bad DAD packet (link-layer address option)\n");
 766                         return;
 767                 }
 768         }
 769
 770         inc = ipv6_addr_is_multicast(daddr);
 771
 772         ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
 773         if (ifp) {
 774 have_ifp:
 775                 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
 776                         if (dad) {
 777                                 /*
 778                                  * We are colliding with another node
 779                                  * who is doing DAD
 780                                  * so fail our DAD process
 781                                  */
 782                                 addrconf_dad_failure(ifp);
 783                                 return;
 784                         } else {
 785                                 /*
 786                                  * This is not a dad solicitation.
 787                                  * If we are an optimistic node,
 788                                  * we should respond.
 789                                  * Otherwise, we should ignore it.
 790                                  */
 791                                 if (!(ifp->flags & IFA_F_OPTIMISTIC))
 792                                         goto out;
 793                         }
 794                 }
 795
 796                 idev = ifp->idev;
 797         } else {
 798                 struct net *net = dev_net(dev);
 799
 800                 /* perhaps an address on the master device */
 801                 if (netif_is_l3_slave(dev)) {
 802                         struct net_device *mdev;
 803
 804                         mdev = netdev_master_upper_dev_get_rcu(dev);
 805                         if (mdev) {
 806                                 ifp = ipv6_get_ifaddr(net, &msg->target, mdev, 1);
 807                                 if (ifp)
 808                                         goto have_ifp;
 809                         }
 810                 }
 811
 812                 idev = in6_dev_get(dev);
 813                 if (!idev) {
 814                         /* XXX: count this drop? */
 815                         return;
 816                 }
 817
 818                 if (ipv6_chk_acast_addr(net, dev, &msg->target) ||
 819                     (idev->cnf.forwarding &&
 820                      (net->ipv6.devconf_all->proxy_ndp || idev->cnf.proxy_ndp) &&
 821                      (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) {
 822                         if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
 823                             skb->pkt_type != PACKET_HOST &&
 824                             inc &&
 825                             NEIGH_VAR(idev->nd_parms, PROXY_DELAY) != 0) {
 826                                 /*
 827                                  * for anycast or proxy,
 828                                  * sender should delay its response
 829                                  * by a random time between 0 and
 830                                  * MAX_ANYCAST_DELAY_TIME seconds.
 831                                  * (RFC2461) -- yoshfuji
 832                                  */
 833                                 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
 834                                 if (n)
 835                                         pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
 836                                 goto out;
 837                         }
 838                 } else
 839                         goto out;
 840         }
 841
 842         if (is_router < 0)
 843                 is_router = idev->cnf.forwarding;
 844
 845         if (dad) {
 846                 ndisc_send_na(dev, &in6addr_linklocal_allnodes, &msg->target,
 847                               !!is_router, false, (ifp != NULL), true);
 848                 goto out;
 849         }
 850
 851         if (inc)
 852                 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
 853         else
 854                 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
 855
 856         /*
 857          *      update / create cache entry
 858          *      for the source address
 859          */
 860         neigh = __neigh_lookup(&nd_tbl, saddr, dev,
 861                                !inc || lladdr || !dev->addr_len);
 862         if (neigh)
 863                 neigh_update(neigh, lladdr, NUD_STALE,
 864                              NEIGH_UPDATE_F_WEAK_OVERRIDE|
 865                              NEIGH_UPDATE_F_OVERRIDE);
 866         if (neigh || !dev->header_ops) {
 867                 ndisc_send_na(dev, saddr, &msg->target, !!is_router,
 868                               true, (ifp != NULL && inc), inc);
 869                 if (neigh)
 870                         neigh_release(neigh);
 871         }
 872
 873 out:
 874         if (ifp)
 875                 in6_ifa_put(ifp);
 876         else
 877                 in6_dev_put(idev);
 878 }
 879
 880 static void ndisc_recv_na(struct sk_buff *skb)
 881 {
 882         struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
 883         struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
 884         const struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
 885         u8 *lladdr = NULL;
 886         u32 ndoptlen = skb_tail_pointer(skb) - (skb_transport_header(skb) +
 887                                     offsetof(struct nd_msg, opt));
 888         struct ndisc_options ndopts;
 889         struct net_device *dev = skb->dev;
 890         struct inet6_ifaddr *ifp;
 891         struct neighbour *neigh;
 892
 893         if (skb->len < sizeof(struct nd_msg)) {
 894                 ND_PRINTK(2, warn, "NA: packet too short\n");
 895                 return;
 896         }
 897
 898         if (ipv6_addr_is_multicast(&msg->target)) {
 899                 ND_PRINTK(2, warn, "NA: target address is multicast\n");
 900                 return;
 901         }
 902
 903         if (ipv6_addr_is_multicast(daddr) &&
 904             msg->icmph.icmp6_solicited) {
 905                 ND_PRINTK(2, warn, "NA: solicited NA is multicasted\n");
 906                 return;
 907         }
 908
 909         if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
 910                 ND_PRINTK(2, warn, "NS: invalid ND option\n");
 911                 return;
 912         }
 913         if (ndopts.nd_opts_tgt_lladdr) {
 914                 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
 915                 if (!lladdr) {
 916                         ND_PRINTK(2, warn,
 917                                   "NA: invalid link-layer address length\n");
 918                         return;
 919                 }
 920         }
 921         ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
 922         if (ifp) {
 923                 if (skb->pkt_type != PACKET_LOOPBACK
 924                     && (ifp->flags & IFA_F_TENTATIVE)) {
 925                                 addrconf_dad_failure(ifp);
 926                                 return;
 927                 }
 928                 /* What should we make now? The advertisement
 929                    is invalid, but ndisc specs say nothing
 930                    about it. It could be misconfiguration, or
 931                    an smart proxy agent tries to help us :-)
 932
 933                    We should not print the error if NA has been
 934                    received from loopback - it is just our own
 935                    unsolicited advertisement.
 936                  */
 937                 if (skb->pkt_type != PACKET_LOOPBACK)
 938                         ND_PRINTK(1, warn,
 939                                   "NA: someone advertises our address %pI6 on %s!\n",
 940                                   &ifp->addr, ifp->idev->dev->name);
 941                 in6_ifa_put(ifp);
 942                 return;
 943         }
 944         neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
 945
 946         if (neigh) {
 947                 u8 old_flags = neigh->flags;
 948                 struct net *net = dev_net(dev);
 949
 950                 if (neigh->nud_state & NUD_FAILED)
 951                         goto out;
 952
 953                 /*
 954                  * Don't update the neighbor cache entry on a proxy NA from
 955                  * ourselves because either the proxied node is off link or it
 956                  * has already sent a NA to us.
 957                  */
 958                 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
 959                     net->ipv6.devconf_all->forwarding && net->ipv6.devconf_all->proxy_ndp &&
 960                     pneigh_lookup(&nd_tbl, net, &msg->target, dev, 0)) {
 961                         /* XXX: idev->cnf.proxy_ndp */
 962                         goto out;
 963                 }
 964
 965                 neigh_update(neigh, lladdr,
 966                              msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
 967                              NEIGH_UPDATE_F_WEAK_OVERRIDE|
 968                              (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
 969                              NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
 970                              (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));
 971
 972                 if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
 973                         /*
 974                          * Change: router to host
 975                          */
 976                         rt6_clean_tohost(dev_net(dev),  saddr);
 977                 }
 978
 979 out:
 980                 neigh_release(neigh);
 981         }
 982 }
 983
 984 static void ndisc_recv_rs(struct sk_buff *skb)
 985 {
 986         struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
 987         unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
 988         struct neighbour *neigh;
 989         struct inet6_dev *idev;
 990         const struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
 991         struct ndisc_options ndopts;
 992         u8 *lladdr = NULL;
 993
 994         if (skb->len < sizeof(*rs_msg))
 995                 return;
 996
 997         idev = __in6_dev_get(skb->dev);
 998         if (!idev) {
 999                 ND_PRINTK(1, err, "RS: can't find in6 device\n");
1000                 return;
1001         }
1002
1003         /* Don't accept RS if we're not in router mode */
1004         if (!idev->cnf.forwarding)
1005                 goto out;
1006
1007         /*
1008          * Don't update NCE if src = ::;
1009          * this implies that the source node has no ip address assigned yet.
1010          */
1011         if (ipv6_addr_any(saddr))
1012                 goto out;
1013
1014         /* Parse ND options */
1015         if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {
1016                 ND_PRINTK(2, notice, "NS: invalid ND option, ignored\n");
1017                 goto out;
1018         }
1019
1020         if (ndopts.nd_opts_src_lladdr) {
1021                 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1022                                              skb->dev);
1023                 if (!lladdr)
1024                         goto out;
1025         }
1026
1027         neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
1028         if (neigh) {
1029                 neigh_update(neigh, lladdr, NUD_STALE,
1030                              NEIGH_UPDATE_F_WEAK_OVERRIDE|
1031                              NEIGH_UPDATE_F_OVERRIDE|
1032                              NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
1033                 neigh_release(neigh);
1034         }
1035 out:
1036         return;
1037 }
1038
1039 static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt)
1040 {
1041         struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra);
1042         struct sk_buff *skb;
1043         struct nlmsghdr *nlh;
1044         struct nduseroptmsg *ndmsg;
1045         struct net *net = dev_net(ra->dev);
1046         int err;
1047         int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg)
1048                                     + (opt->nd_opt_len << 3));
1049         size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr));
1050
1051         skb = nlmsg_new(msg_size, GFP_ATOMIC);
1052         if (!skb) {
1053                 err = -ENOBUFS;
1054                 goto errout;
1055         }
1056
1057         nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0);
1058         if (!nlh) {
1059                 goto nla_put_failure;
1060         }
1061
1062         ndmsg = nlmsg_data(nlh);
1063         ndmsg->nduseropt_family = AF_INET6;
1064         ndmsg->nduseropt_ifindex = ra->dev->ifindex;
1065         ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type;
1066         ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code;
1067         ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3;
1068
1069         memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3);
1070
1071         if (nla_put_in6_addr(skb, NDUSEROPT_SRCADDR, &ipv6_hdr(ra)->saddr))
1072                 goto nla_put_failure;
1073         nlmsg_end(skb, nlh);
1074
1075         rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL, GFP_ATOMIC);
1076         return;
1077
1078 nla_put_failure:
1079         nlmsg_free(skb);
1080         err = -EMSGSIZE;
1081 errout:
1082         rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err);
1083 }
1084
1085 static void ndisc_router_discovery(struct sk_buff *skb)
1086 {
1087         struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
1088         struct neighbour *neigh = NULL;
1089         struct inet6_dev *in6_dev;
1090         struct rt6_info *rt = NULL;
1091         int lifetime;
1092         struct ndisc_options ndopts;
1093         int optlen;
1094         unsigned int pref = 0;
1095         __u32 old_if_flags;
1096         bool send_ifinfo_notify = false;
1097
1098         __u8 *opt = (__u8 *)(ra_msg + 1);
1099
1100         optlen = (skb_tail_pointer(skb) - skb_transport_header(skb)) -
1101                 sizeof(struct ra_msg);
1102
1103         ND_PRINTK(2, info,
1104                   "RA: %s, dev: %s\n",
1105                   __func__, skb->dev->name);
1106         if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1107                 ND_PRINTK(2, warn, "RA: source address is not link-local\n");
1108                 return;
1109         }
1110         if (optlen < 0) {
1111                 ND_PRINTK(2, warn, "RA: packet too short\n");
1112                 return;
1113         }
1114
1115 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1116         if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) {
1117                 ND_PRINTK(2, warn, "RA: from host or unauthorized router\n");
1118                 return;
1119         }
1120 #endif
1121
1122         /*
1123          *      set the RA_RECV flag in the interface
1124          */
1125
1126         in6_dev = __in6_dev_get(skb->dev);
1127         if (!in6_dev) {
1128                 ND_PRINTK(0, err, "RA: can't find inet6 device for %s\n",
1129                           skb->dev->name);
1130                 return;
1131         }
1132
1133         if (!ndisc_parse_options(opt, optlen, &ndopts)) {
1134                 ND_PRINTK(2, warn, "RA: invalid ND options\n");
1135                 return;
1136         }
1137
1138         if (!ipv6_accept_ra(in6_dev)) {
1139                 ND_PRINTK(2, info,
1140                           "RA: %s, did not accept ra for dev: %s\n",
1141                           __func__, skb->dev->name);
1142                 goto skip_linkparms;
1143         }
1144
1145 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1146         /* skip link-specific parameters from interior routers */
1147         if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT) {
1148                 ND_PRINTK(2, info,
1149                           "RA: %s, nodetype is NODEFAULT, dev: %s\n",
1150                           __func__, skb->dev->name);
1151                 goto skip_linkparms;
1152         }
1153 #endif
1154
1155         if (in6_dev->if_flags & IF_RS_SENT) {
1156                 /*
1157                  *      flag that an RA was received after an RS was sent
1158                  *      out on this interface.
1159                  */
1160                 in6_dev->if_flags |= IF_RA_RCVD;
1161         }
1162
1163         /*
1164          * Remember the managed/otherconf flags from most recently
1165          * received RA message (RFC 2462) -- yoshfuji
1166          */
1167         old_if_flags = in6_dev->if_flags;
1168         in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1169                                 IF_RA_OTHERCONF)) |
1170                                 (ra_msg->icmph.icmp6_addrconf_managed ?
1171                                         IF_RA_MANAGED : 0) |
1172                                 (ra_msg->icmph.icmp6_addrconf_other ?
1173                                         IF_RA_OTHERCONF : 0);
1174
1175         if (old_if_flags != in6_dev->if_flags)
1176                 send_ifinfo_notify = true;
1177
1178         if (!in6_dev->cnf.accept_ra_defrtr) {
1179                 ND_PRINTK(2, info,
1180                           "RA: %s, defrtr is false for dev: %s\n",
1181                           __func__, skb->dev->name);
1182                 goto skip_defrtr;
1183         }
1184
1185         /* Do not accept RA with source-addr found on local machine unless
1186          * accept_ra_from_local is set to true.
1187          */
1188         if (!in6_dev->cnf.accept_ra_from_local &&
1189             ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr,
1190                           NULL, 0)) {
1191                 ND_PRINTK(2, info,
1192                           "RA from local address detected on dev: %s: default router ignored\n",
1193                           skb->dev->name);
1194                 goto skip_defrtr;
1195         }
1196
1197         lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1198
1199 #ifdef CONFIG_IPV6_ROUTER_PREF
1200         pref = ra_msg->icmph.icmp6_router_pref;
1201         /* 10b is handled as if it were 00b (medium) */
1202         if (pref == ICMPV6_ROUTER_PREF_INVALID ||
1203             !in6_dev->cnf.accept_ra_rtr_pref)
1204                 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1205 #endif
1206
1207         rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
1208
1209         if (rt) {
1210                 neigh = dst_neigh_lookup(&rt->dst, &ipv6_hdr(skb)->saddr);
1211                 if (!neigh) {
1212                         ND_PRINTK(0, err,
1213                                   "RA: %s got default router without neighbour\n",
1214                                   __func__);
1215                         ip6_rt_put(rt);
1216                         return;
1217                 }
1218         }
1219         if (rt && lifetime == 0) {
1220                 ip6_del_rt(rt);
1221                 rt = NULL;
1222         }
1223
1224         ND_PRINTK(3, info, "RA: rt: %p  lifetime: %d, for dev: %s\n",
1225                   rt, lifetime, skb->dev->name);
1226         if (!rt && lifetime) {
1227                 ND_PRINTK(3, info, "RA: adding default router\n");
1228
1229                 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
1230                 if (!rt) {
1231                         ND_PRINTK(0, err,
1232                                   "RA: %s failed to add default route\n",
1233                                   __func__);
1234                         return;
1235                 }
1236
1237                 neigh = dst_neigh_lookup(&rt->dst, &ipv6_hdr(skb)->saddr);
1238                 if (!neigh) {
1239                         ND_PRINTK(0, err,
1240                                   "RA: %s got default router without neighbour\n",
1241                                   __func__);
1242                         ip6_rt_put(rt);
1243                         return;
1244                 }
1245                 neigh->flags |= NTF_ROUTER;
1246         } else if (rt) {
1247                 rt->rt6i_flags = (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
1248         }
1249
1250         if (rt)
1251                 rt6_set_expires(rt, jiffies + (HZ * lifetime));
1252         if (in6_dev->cnf.accept_ra_min_hop_limit < 256 &&
1253             ra_msg->icmph.icmp6_hop_limit) {
1254                 if (in6_dev->cnf.accept_ra_min_hop_limit <= ra_msg->icmph.icmp6_hop_limit) {
1255                         in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1256                         if (rt)
1257                                 dst_metric_set(&rt->dst, RTAX_HOPLIMIT,
1258                                                ra_msg->icmph.icmp6_hop_limit);
1259                 } else {
1260                         ND_PRINTK(2, warn, "RA: Got route advertisement with lower hop_limit than minimum\n");
1261                 }
1262         }
1263
1264 skip_defrtr:
1265
1266         /*
1267          *      Update Reachable Time and Retrans Timer
1268          */
1269
1270         if (in6_dev->nd_parms) {
1271                 unsigned long rtime = ntohl(ra_msg->retrans_timer);
1272
1273                 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1274                         rtime = (rtime*HZ)/1000;
1275                         if (rtime < HZ/10)
1276                                 rtime = HZ/10;
1277                         NEIGH_VAR_SET(in6_dev->nd_parms, RETRANS_TIME, rtime);
1278                         in6_dev->tstamp = jiffies;
1279                         send_ifinfo_notify = true;
1280                 }
1281
1282                 rtime = ntohl(ra_msg->reachable_time);
1283                 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1284                         rtime = (rtime*HZ)/1000;
1285
1286                         if (rtime < HZ/10)
1287                                 rtime = HZ/10;
1288
1289                         if (rtime != NEIGH_VAR(in6_dev->nd_parms, BASE_REACHABLE_TIME)) {
1290                                 NEIGH_VAR_SET(in6_dev->nd_parms,
1291                                               BASE_REACHABLE_TIME, rtime);
1292                                 NEIGH_VAR_SET(in6_dev->nd_parms,
1293                                               GC_STALETIME, 3 * rtime);
1294                                 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1295                                 in6_dev->tstamp = jiffies;
1296                                 send_ifinfo_notify = true;
1297                         }
1298                 }
1299         }
1300
1301         /*
1302          *      Send a notify if RA changed managed/otherconf flags or timer settings
1303          */
1304         if (send_ifinfo_notify)
1305                 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1306
1307 skip_linkparms:
1308
1309         /*
1310          *      Process options.
1311          */
1312
1313         if (!neigh)
1314                 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
1315                                        skb->dev, 1);
1316         if (neigh) {
1317                 u8 *lladdr = NULL;
1318                 if (ndopts.nd_opts_src_lladdr) {
1319                         lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1320                                                      skb->dev);
1321                         if (!lladdr) {
1322                                 ND_PRINTK(2, warn,
1323                                           "RA: invalid link-layer address length\n");
1324                                 goto out;
1325                         }
1326                 }
1327                 neigh_update(neigh, lladdr, NUD_STALE,
1328                              NEIGH_UPDATE_F_WEAK_OVERRIDE|
1329                              NEIGH_UPDATE_F_OVERRIDE|
1330                              NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1331                              NEIGH_UPDATE_F_ISROUTER);
1332         }
1333
1334         if (!ipv6_accept_ra(in6_dev)) {
1335                 ND_PRINTK(2, info,
1336                           "RA: %s, accept_ra is false for dev: %s\n",
1337                           __func__, skb->dev->name);
1338                 goto out;
1339         }
1340
1341 #ifdef CONFIG_IPV6_ROUTE_INFO
1342         if (!in6_dev->cnf.accept_ra_from_local &&
1343             ipv6_chk_addr(dev_net(in6_dev->dev), &ipv6_hdr(skb)->saddr,
1344                           NULL, 0)) {
1345                 ND_PRINTK(2, info,
1346                           "RA from local address detected on dev: %s: router info ignored.\n",
1347                           skb->dev->name);
1348                 goto skip_routeinfo;
1349         }
1350
1351         if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
1352                 struct nd_opt_hdr *p;
1353                 for (p = ndopts.nd_opts_ri;
1354                      p;
1355                      p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
1356                         struct route_info *ri = (struct route_info *)p;
1357 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1358                         if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT &&
1359                             ri->prefix_len == 0)
1360                                 continue;
1361 #endif
1362                         if (ri->prefix_len == 0 &&
1363                             !in6_dev->cnf.accept_ra_defrtr)
1364                                 continue;
1365                         if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
1366                                 continue;
1367                         rt6_route_rcv(skb->dev, (u8 *)p, (p->nd_opt_len) << 3,
1368                                       &ipv6_hdr(skb)->saddr);
1369                 }
1370         }
1371
1372 skip_routeinfo:
1373 #endif
1374
1375 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1376         /* skip link-specific ndopts from interior routers */
1377         if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT) {
1378                 ND_PRINTK(2, info,
1379                           "RA: %s, nodetype is NODEFAULT (interior routes), dev: %s\n",
1380                           __func__, skb->dev->name);
1381                 goto out;
1382         }
1383 #endif
1384
1385         if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
1386                 struct nd_opt_hdr *p;
1387                 for (p = ndopts.nd_opts_pi;
1388                      p;
1389                      p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1390                         addrconf_prefix_rcv(skb->dev, (u8 *)p,
1391                                             (p->nd_opt_len) << 3,
1392                                             ndopts.nd_opts_src_lladdr != NULL);
1393                 }
1394         }
1395
1396         if (ndopts.nd_opts_mtu && in6_dev->cnf.accept_ra_mtu) {
1397                 __be32 n;
1398                 u32 mtu;
1399
1400                 memcpy(&n, ((u8 *)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1401                 mtu = ntohl(n);
1402
1403                 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1404                         ND_PRINTK(2, warn, "RA: invalid mtu: %d\n", mtu);
1405                 } else if (in6_dev->cnf.mtu6 != mtu) {
1406                         in6_dev->cnf.mtu6 = mtu;
1407
1408                         if (rt)
1409                                 dst_metric_set(&rt->dst, RTAX_MTU, mtu);
1410
1411                         rt6_mtu_change(skb->dev, mtu);
1412                 }
1413         }
1414
1415         if (ndopts.nd_useropts) {
1416                 struct nd_opt_hdr *p;
1417                 for (p = ndopts.nd_useropts;
1418                      p;
1419                      p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) {
1420                         ndisc_ra_useropt(skb, p);
1421                 }
1422         }
1423
1424         if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1425                 ND_PRINTK(2, warn, "RA: invalid RA options\n");
1426         }
1427 out:
1428         ip6_rt_put(rt);
1429         if (neigh)
1430                 neigh_release(neigh);
1431 }
1432
1433 static void ndisc_redirect_rcv(struct sk_buff *skb)
1434 {
1435         u8 *hdr;
1436         struct ndisc_options ndopts;
1437         struct rd_msg *msg = (struct rd_msg *)skb_transport_header(skb);
1438         u32 ndoptlen = skb_tail_pointer(skb) - (skb_transport_header(skb) +
1439                                     offsetof(struct rd_msg, opt));
1440
1441 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1442         switch (skb->ndisc_nodetype) {
1443         case NDISC_NODETYPE_HOST:
1444         case NDISC_NODETYPE_NODEFAULT:
1445                 ND_PRINTK(2, warn,
1446                           "Redirect: from host or unauthorized router\n");
1447                 return;
1448         }
1449 #endif
1450
1451         if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1452                 ND_PRINTK(2, warn,
1453                           "Redirect: source address is not link-local\n");
1454                 return;
1455         }
1456
1457         if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts))
1458                 return;
1459
1460         if (!ndopts.nd_opts_rh) {
1461                 ip6_redirect_no_header(skb, dev_net(skb->dev),
1462                                         skb->dev->ifindex, 0);
1463                 return;
1464         }
1465
1466         hdr = (u8 *)ndopts.nd_opts_rh;
1467         hdr += 8;
1468         if (!pskb_pull(skb, hdr - skb_transport_header(skb)))
1469                 return;
1470
1471         icmpv6_notify(skb, NDISC_REDIRECT, 0, 0);
1472 }
1473
1474 static void ndisc_fill_redirect_hdr_option(struct sk_buff *skb,
1475                                            struct sk_buff *orig_skb,
1476                                            int rd_len)
1477 {
1478         u8 *opt = skb_put(skb, rd_len);
1479
1480         memset(opt, 0, 8);
1481         *(opt++) = ND_OPT_REDIRECT_HDR;
1482         *(opt++) = (rd_len >> 3);
1483         opt += 6;
1484
1485         memcpy(opt, ipv6_hdr(orig_skb), rd_len - 8);
1486 }
1487
1488 void ndisc_send_redirect(struct sk_buff *skb, const struct in6_addr *target)
1489 {
1490         struct net_device *dev = skb->dev;
1491         struct net *net = dev_net(dev);
1492         struct sock *sk = net->ipv6.ndisc_sk;
1493         int optlen = 0;
1494         struct inet_peer *peer;
1495         struct sk_buff *buff;
1496         struct rd_msg *msg;
1497         struct in6_addr saddr_buf;
1498         struct rt6_info *rt;
1499         struct dst_entry *dst;
1500         struct flowi6 fl6;
1501         int rd_len;
1502         u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1503         int oif = l3mdev_fib_oif(dev);
1504         bool ret;
1505
1506         if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
1507                 ND_PRINTK(2, warn, "Redirect: no link-local address on %s\n",
1508                           dev->name);
1509                 return;
1510         }
1511
1512         if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
1513             ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1514                 ND_PRINTK(2, warn,
1515                           "Redirect: target address is not link-local unicast\n");
1516                 return;
1517         }
1518
1519         icmpv6_flow_init(sk, &fl6, NDISC_REDIRECT,
1520                          &saddr_buf, &ipv6_hdr(skb)->saddr, oif);
1521
1522         if (oif != skb->dev->ifindex)
1523                 fl6.flowi6_flags |= FLOWI_FLAG_L3MDEV_SRC;
1524
1525         dst = ip6_route_output(net, NULL, &fl6);
1526         if (dst->error) {
1527                 dst_release(dst);
1528                 return;
1529         }
1530         dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), NULL, 0);
1531         if (IS_ERR(dst))
1532                 return;
1533
1534         rt = (struct rt6_info *) dst;
1535
1536         if (rt->rt6i_flags & RTF_GATEWAY) {
1537                 ND_PRINTK(2, warn,
1538                           "Redirect: destination is not a neighbour\n");
1539                 goto release;
1540         }
1541         peer = inet_getpeer_v6(net->ipv6.peers, &ipv6_hdr(skb)->saddr, 1);
1542         ret = inet_peer_xrlim_allow(peer, 1*HZ);
1543         if (peer)
1544                 inet_putpeer(peer);
1545         if (!ret)
1546                 goto release;
1547
1548         if (dev->addr_len) {
1549                 struct neighbour *neigh = dst_neigh_lookup(skb_dst(skb), target);
1550                 if (!neigh) {
1551                         ND_PRINTK(2, warn,
1552                                   "Redirect: no neigh for target address\n");
1553                         goto release;
1554                 }
1555
1556                 read_lock_bh(&neigh->lock);
1557                 if (neigh->nud_state & NUD_VALID) {
1558                         memcpy(ha_buf, neigh->ha, dev->addr_len);
1559                         read_unlock_bh(&neigh->lock);
1560                         ha = ha_buf;
1561                         optlen += ndisc_opt_addr_space(dev);
1562                 } else
1563                         read_unlock_bh(&neigh->lock);
1564
1565                 neigh_release(neigh);
1566         }
1567
1568         rd_len = min_t(unsigned int,
1569                        IPV6_MIN_MTU - sizeof(struct ipv6hdr) - sizeof(*msg) - optlen,
1570                        skb->len + 8);
1571         rd_len &= ~0x7;
1572         optlen += rd_len;
1573
1574         buff = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
1575         if (!buff)
1576                 goto release;
1577
1578         msg = (struct rd_msg *)skb_put(buff, sizeof(*msg));
1579         *msg = (struct rd_msg) {
1580                 .icmph = {
1581                         .icmp6_type = NDISC_REDIRECT,
1582                 },
1583                 .target = *target,
1584                 .dest = ipv6_hdr(skb)->daddr,
1585         };
1586
1587         /*
1588          *      include target_address option
1589          */
1590
1591         if (ha)
1592                 ndisc_fill_addr_option(buff, ND_OPT_TARGET_LL_ADDR, ha);
1593
1594         /*
1595          *      build redirect option and copy skb over to the new packet.
1596          */
1597
1598         if (rd_len)
1599                 ndisc_fill_redirect_hdr_option(buff, skb, rd_len);
1600
1601         skb_dst_set(buff, dst);
1602         ndisc_send_skb(buff, &ipv6_hdr(skb)->saddr, &saddr_buf);
1603         return;
1604
1605 release:
1606         dst_release(dst);
1607 }
1608
1609 static void pndisc_redo(struct sk_buff *skb)
1610 {
1611         ndisc_recv_ns(skb);
1612         kfree_skb(skb);
1613 }
1614
1615 static bool ndisc_suppress_frag_ndisc(struct sk_buff *skb)
1616 {
1617         struct inet6_dev *idev = __in6_dev_get(skb->dev);
1618
1619         if (!idev)
1620                 return true;
1621         if (IP6CB(skb)->flags & IP6SKB_FRAGMENTED &&
1622             idev->cnf.suppress_frag_ndisc) {
1623                 net_warn_ratelimited("Received fragmented ndisc packet. Carefully consider disabling suppress_frag_ndisc.\n");
1624                 return true;
1625         }
1626         return false;
1627 }
1628
1629 int ndisc_rcv(struct sk_buff *skb)
1630 {
1631         struct nd_msg *msg;
1632
1633         if (ndisc_suppress_frag_ndisc(skb))
1634                 return 0;
1635
1636         if (skb_linearize(skb))
1637                 return 0;
1638
1639         msg = (struct nd_msg *)skb_transport_header(skb);
1640
1641         __skb_push(skb, skb->data - skb_transport_header(skb));
1642
1643         if (ipv6_hdr(skb)->hop_limit != 255) {
1644                 ND_PRINTK(2, warn, "NDISC: invalid hop-limit: %d\n",
1645                           ipv6_hdr(skb)->hop_limit);
1646                 return 0;
1647         }
1648
1649         if (msg->icmph.icmp6_code != 0) {
1650                 ND_PRINTK(2, warn, "NDISC: invalid ICMPv6 code: %d\n",
1651                           msg->icmph.icmp6_code);
1652                 return 0;
1653         }
1654
1655         memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1656
1657         switch (msg->icmph.icmp6_type) {
1658         case NDISC_NEIGHBOUR_SOLICITATION:
1659                 ndisc_recv_ns(skb);
1660                 break;
1661
1662         case NDISC_NEIGHBOUR_ADVERTISEMENT:
1663                 ndisc_recv_na(skb);
1664                 break;
1665
1666         case NDISC_ROUTER_SOLICITATION:
1667                 ndisc_recv_rs(skb);
1668                 break;
1669
1670         case NDISC_ROUTER_ADVERTISEMENT:
1671                 ndisc_router_discovery(skb);
1672                 break;
1673
1674         case NDISC_REDIRECT:
1675                 ndisc_redirect_rcv(skb);
1676                 break;
1677         }
1678
1679         return 0;
1680 }
1681
1682 static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1683 {
1684         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1685         struct netdev_notifier_change_info *change_info;
1686         struct net *net = dev_net(dev);
1687         struct inet6_dev *idev;
1688
1689         switch (event) {
1690         case NETDEV_CHANGEADDR:
1691                 neigh_changeaddr(&nd_tbl, dev);
1692                 fib6_run_gc(0, net, false);
1693                 idev = in6_dev_get(dev);
1694                 if (!idev)
1695                         break;
1696                 if (idev->cnf.ndisc_notify)
1697                         ndisc_send_unsol_na(dev);
1698                 in6_dev_put(idev);
1699                 break;
1700         case NETDEV_CHANGE:
1701                 change_info = ptr;
1702                 if (change_info->flags_changed & IFF_NOARP)
1703                         neigh_changeaddr(&nd_tbl, dev);
1704                 break;
1705         case NETDEV_DOWN:
1706                 neigh_ifdown(&nd_tbl, dev);
1707                 fib6_run_gc(0, net, false);
1708                 break;
1709         case NETDEV_NOTIFY_PEERS:
1710                 ndisc_send_unsol_na(dev);
1711                 break;
1712         default:
1713                 break;
1714         }
1715
1716         return NOTIFY_DONE;
1717 }
1718
1719 static struct notifier_block ndisc_netdev_notifier = {
1720         .notifier_call = ndisc_netdev_event,
1721 };
1722
1723 #ifdef CONFIG_SYSCTL
1724 static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1725                                          const char *func, const char *dev_name)
1726 {
1727         static char warncomm[TASK_COMM_LEN];
1728         static int warned;
1729         if (strcmp(warncomm, current->comm) && warned < 5) {
1730                 strcpy(warncomm, current->comm);
1731                 pr_warn("process `%s' is using deprecated sysctl (%s) net.ipv6.neigh.%s.%s - use net.ipv6.neigh.%s.%s_ms instead\n",
1732                         warncomm, func,
1733                         dev_name, ctl->procname,
1734                         dev_name, ctl->procname);
1735                 warned++;
1736         }
1737 }
1738
1739 int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, void __user *buffer, size_t *lenp, loff_t *ppos)
1740 {
1741         struct net_device *dev = ctl->extra1;
1742         struct inet6_dev *idev;
1743         int ret;
1744
1745         if ((strcmp(ctl->procname, "retrans_time") == 0) ||
1746             (strcmp(ctl->procname, "base_reachable_time") == 0))
1747                 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1748
1749         if (strcmp(ctl->procname, "retrans_time") == 0)
1750                 ret = neigh_proc_dointvec(ctl, write, buffer, lenp, ppos);
1751
1752         else if (strcmp(ctl->procname, "base_reachable_time") == 0)
1753                 ret = neigh_proc_dointvec_jiffies(ctl, write,
1754                                                   buffer, lenp, ppos);
1755
1756         else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
1757                  (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
1758                 ret = neigh_proc_dointvec_ms_jiffies(ctl, write,
1759                                                      buffer, lenp, ppos);
1760         else
1761                 ret = -1;
1762
1763         if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
1764                 if (ctl->data == &NEIGH_VAR(idev->nd_parms, BASE_REACHABLE_TIME))
1765                         idev->nd_parms->reachable_time =
1766                                         neigh_rand_reach_time(NEIGH_VAR(idev->nd_parms, BASE_REACHABLE_TIME));
1767                 idev->tstamp = jiffies;
1768                 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1769                 in6_dev_put(idev);
1770         }
1771         return ret;
1772 }
1773
1774
1775 #endif
1776
1777 static int __net_init ndisc_net_init(struct net *net)
1778 {
1779         struct ipv6_pinfo *np;
1780         struct sock *sk;
1781         int err;
1782
1783         err = inet_ctl_sock_create(&sk, PF_INET6,
1784                                    SOCK_RAW, IPPROTO_ICMPV6, net);
1785         if (err < 0) {
1786                 ND_PRINTK(0, err,
1787                           "NDISC: Failed to initialize the control socket (err %d)\n",
1788                           err);
1789                 return err;
1790         }
1791
1792         net->ipv6.ndisc_sk = sk;
1793
1794         np = inet6_sk(sk);
1795         np->hop_limit = 255;
1796         /* Do not loopback ndisc messages */
1797         np->mc_loop = 0;
1798
1799         return 0;
1800 }
1801
1802 static void __net_exit ndisc_net_exit(struct net *net)
1803 {
1804         inet_ctl_sock_destroy(net->ipv6.ndisc_sk);
1805 }
1806
1807 static struct pernet_operations ndisc_net_ops = {
1808         .init = ndisc_net_init,
1809         .exit = ndisc_net_exit,
1810 };
1811
1812 int __init ndisc_init(void)
1813 {
1814         int err;
1815
1816         err = register_pernet_subsys(&ndisc_net_ops);
1817         if (err)
1818                 return err;
1819         /*
1820          * Initialize the neighbour table
1821          */
1822         neigh_table_init(NEIGH_ND_TABLE, &nd_tbl);
1823
1824 #ifdef CONFIG_SYSCTL
1825         err = neigh_sysctl_register(NULL, &nd_tbl.parms,
1826                                     ndisc_ifinfo_sysctl_change);
1827         if (err)
1828                 goto out_unregister_pernet;
1829 out:
1830 #endif
1831         return err;
1832
1833 #ifdef CONFIG_SYSCTL
1834 out_unregister_pernet:
1835         unregister_pernet_subsys(&ndisc_net_ops);
1836         goto out;
1837 #endif
1838 }
1839
1840 int __init ndisc_late_init(void)
1841 {
1842         return register_netdevice_notifier(&ndisc_netdev_notifier);
1843 }
1844
1845 void ndisc_late_cleanup(void)
1846 {
1847         unregister_netdevice_notifier(&ndisc_netdev_notifier);
1848 }
1849
1850 void ndisc_cleanup(void)
1851 {
1852 #ifdef CONFIG_SYSCTL
1853         neigh_sysctl_unregister(&nd_tbl.parms);
1854 #endif
1855         neigh_table_clear(NEIGH_ND_TABLE, &nd_tbl);
1856         unregister_pernet_subsys(&ndisc_net_ops);
1857 }