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_min_plen)
1362                                 continue;
1363                         if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
1364                                 continue;
1365                         rt6_route_rcv(skb->dev, (u8 *)p, (p->nd_opt_len) << 3,
1366                                       &ipv6_hdr(skb)->saddr);
1367                 }
1368         }
1369
1370 skip_routeinfo:
1371 #endif
1372
1373 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1374         /* skip link-specific ndopts from interior routers */
1375         if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT) {
1376                 ND_PRINTK(2, info,
1377                           "RA: %s, nodetype is NODEFAULT (interior routes), dev: %s\n",
1378                           __func__, skb->dev->name);
1379                 goto out;
1380         }
1381 #endif
1382
1383         if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
1384                 struct nd_opt_hdr *p;
1385                 for (p = ndopts.nd_opts_pi;
1386                      p;
1387                      p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1388                         addrconf_prefix_rcv(skb->dev, (u8 *)p,
1389                                             (p->nd_opt_len) << 3,
1390                                             ndopts.nd_opts_src_lladdr != NULL);
1391                 }
1392         }
1393
1394         if (ndopts.nd_opts_mtu && in6_dev->cnf.accept_ra_mtu) {
1395                 __be32 n;
1396                 u32 mtu;
1397
1398                 memcpy(&n, ((u8 *)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1399                 mtu = ntohl(n);
1400
1401                 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1402                         ND_PRINTK(2, warn, "RA: invalid mtu: %d\n", mtu);
1403                 } else if (in6_dev->cnf.mtu6 != mtu) {
1404                         in6_dev->cnf.mtu6 = mtu;
1405
1406                         if (rt)
1407                                 dst_metric_set(&rt->dst, RTAX_MTU, mtu);
1408
1409                         rt6_mtu_change(skb->dev, mtu);
1410                 }
1411         }
1412
1413         if (ndopts.nd_useropts) {
1414                 struct nd_opt_hdr *p;
1415                 for (p = ndopts.nd_useropts;
1416                      p;
1417                      p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) {
1418                         ndisc_ra_useropt(skb, p);
1419                 }
1420         }
1421
1422         if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1423                 ND_PRINTK(2, warn, "RA: invalid RA options\n");
1424         }
1425 out:
1426         ip6_rt_put(rt);
1427         if (neigh)
1428                 neigh_release(neigh);
1429 }
1430
1431 static void ndisc_redirect_rcv(struct sk_buff *skb)
1432 {
1433         u8 *hdr;
1434         struct ndisc_options ndopts;
1435         struct rd_msg *msg = (struct rd_msg *)skb_transport_header(skb);
1436         u32 ndoptlen = skb_tail_pointer(skb) - (skb_transport_header(skb) +
1437                                     offsetof(struct rd_msg, opt));
1438
1439 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1440         switch (skb->ndisc_nodetype) {
1441         case NDISC_NODETYPE_HOST:
1442         case NDISC_NODETYPE_NODEFAULT:
1443                 ND_PRINTK(2, warn,
1444                           "Redirect: from host or unauthorized router\n");
1445                 return;
1446         }
1447 #endif
1448
1449         if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1450                 ND_PRINTK(2, warn,
1451                           "Redirect: source address is not link-local\n");
1452                 return;
1453         }
1454
1455         if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts))
1456                 return;
1457
1458         if (!ndopts.nd_opts_rh) {
1459                 ip6_redirect_no_header(skb, dev_net(skb->dev),
1460                                         skb->dev->ifindex, 0);
1461                 return;
1462         }
1463
1464         hdr = (u8 *)ndopts.nd_opts_rh;
1465         hdr += 8;
1466         if (!pskb_pull(skb, hdr - skb_transport_header(skb)))
1467                 return;
1468
1469         icmpv6_notify(skb, NDISC_REDIRECT, 0, 0);
1470 }
1471
1472 static void ndisc_fill_redirect_hdr_option(struct sk_buff *skb,
1473                                            struct sk_buff *orig_skb,
1474                                            int rd_len)
1475 {
1476         u8 *opt = skb_put(skb, rd_len);
1477
1478         memset(opt, 0, 8);
1479         *(opt++) = ND_OPT_REDIRECT_HDR;
1480         *(opt++) = (rd_len >> 3);
1481         opt += 6;
1482
1483         skb_copy_bits(orig_skb, skb_network_offset(orig_skb), opt,
1484                       rd_len - 8);
1485 }
1486
1487 void ndisc_send_redirect(struct sk_buff *skb, const struct in6_addr *target)
1488 {
1489         struct net_device *dev = skb->dev;
1490         struct net *net = dev_net(dev);
1491         struct sock *sk = net->ipv6.ndisc_sk;
1492         int optlen = 0;
1493         struct inet_peer *peer;
1494         struct sk_buff *buff;
1495         struct rd_msg *msg;
1496         struct in6_addr saddr_buf;
1497         struct rt6_info *rt;
1498         struct dst_entry *dst;
1499         struct flowi6 fl6;
1500         int rd_len;
1501         u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1502         int oif = l3mdev_fib_oif(dev);
1503         bool ret;
1504
1505         if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
1506                 ND_PRINTK(2, warn, "Redirect: no link-local address on %s\n",
1507                           dev->name);
1508                 return;
1509         }
1510
1511         if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
1512             ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1513                 ND_PRINTK(2, warn,
1514                           "Redirect: target address is not link-local unicast\n");
1515                 return;
1516         }
1517
1518         icmpv6_flow_init(sk, &fl6, NDISC_REDIRECT,
1519                          &saddr_buf, &ipv6_hdr(skb)->saddr, oif);
1520
1521         if (oif != skb->dev->ifindex)
1522                 fl6.flowi6_flags |= FLOWI_FLAG_L3MDEV_SRC;
1523
1524         dst = ip6_route_output(net, NULL, &fl6);
1525         if (dst->error) {
1526                 dst_release(dst);
1527                 return;
1528         }
1529         dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), NULL, 0);
1530         if (IS_ERR(dst))
1531                 return;
1532
1533         rt = (struct rt6_info *) dst;
1534
1535         if (rt->rt6i_flags & RTF_GATEWAY) {
1536                 ND_PRINTK(2, warn,
1537                           "Redirect: destination is not a neighbour\n");
1538                 goto release;
1539         }
1540         peer = inet_getpeer_v6(net->ipv6.peers, &ipv6_hdr(skb)->saddr, 1);
1541         ret = inet_peer_xrlim_allow(peer, 1*HZ);
1542         if (peer)
1543                 inet_putpeer(peer);
1544         if (!ret)
1545                 goto release;
1546
1547         if (dev->addr_len) {
1548                 struct neighbour *neigh = dst_neigh_lookup(skb_dst(skb), target);
1549                 if (!neigh) {
1550                         ND_PRINTK(2, warn,
1551                                   "Redirect: no neigh for target address\n");
1552                         goto release;
1553                 }
1554
1555                 read_lock_bh(&neigh->lock);
1556                 if (neigh->nud_state & NUD_VALID) {
1557                         memcpy(ha_buf, neigh->ha, dev->addr_len);
1558                         read_unlock_bh(&neigh->lock);
1559                         ha = ha_buf;
1560                         optlen += ndisc_opt_addr_space(dev);
1561                 } else
1562                         read_unlock_bh(&neigh->lock);
1563
1564                 neigh_release(neigh);
1565         }
1566
1567         rd_len = min_t(unsigned int,
1568                        IPV6_MIN_MTU - sizeof(struct ipv6hdr) - sizeof(*msg) - optlen,
1569                        skb->len + 8);
1570         rd_len &= ~0x7;
1571         optlen += rd_len;
1572
1573         buff = ndisc_alloc_skb(dev, sizeof(*msg) + optlen);
1574         if (!buff)
1575                 goto release;
1576
1577         msg = (struct rd_msg *)skb_put(buff, sizeof(*msg));
1578         *msg = (struct rd_msg) {
1579                 .icmph = {
1580                         .icmp6_type = NDISC_REDIRECT,
1581                 },
1582                 .target = *target,
1583                 .dest = ipv6_hdr(skb)->daddr,
1584         };
1585
1586         /*
1587          *      include target_address option
1588          */
1589
1590         if (ha)
1591                 ndisc_fill_addr_option(buff, ND_OPT_TARGET_LL_ADDR, ha);
1592
1593         /*
1594          *      build redirect option and copy skb over to the new packet.
1595          */
1596
1597         if (rd_len)
1598                 ndisc_fill_redirect_hdr_option(buff, skb, rd_len);
1599
1600         skb_dst_set(buff, dst);
1601         ndisc_send_skb(buff, &ipv6_hdr(skb)->saddr, &saddr_buf);
1602         return;
1603
1604 release:
1605         dst_release(dst);
1606 }
1607
1608 static void pndisc_redo(struct sk_buff *skb)
1609 {
1610         ndisc_recv_ns(skb);
1611         kfree_skb(skb);
1612 }
1613
1614 static bool ndisc_suppress_frag_ndisc(struct sk_buff *skb)
1615 {
1616         struct inet6_dev *idev = __in6_dev_get(skb->dev);
1617
1618         if (!idev)
1619                 return true;
1620         if (IP6CB(skb)->flags & IP6SKB_FRAGMENTED &&
1621             idev->cnf.suppress_frag_ndisc) {
1622                 net_warn_ratelimited("Received fragmented ndisc packet. Carefully consider disabling suppress_frag_ndisc.\n");
1623                 return true;
1624         }
1625         return false;
1626 }
1627
1628 int ndisc_rcv(struct sk_buff *skb)
1629 {
1630         struct nd_msg *msg;
1631
1632         if (ndisc_suppress_frag_ndisc(skb))
1633                 return 0;
1634
1635         if (skb_linearize(skb))
1636                 return 0;
1637
1638         msg = (struct nd_msg *)skb_transport_header(skb);
1639
1640         __skb_push(skb, skb->data - skb_transport_header(skb));
1641
1642         if (ipv6_hdr(skb)->hop_limit != 255) {
1643                 ND_PRINTK(2, warn, "NDISC: invalid hop-limit: %d\n",
1644                           ipv6_hdr(skb)->hop_limit);
1645                 return 0;
1646         }
1647
1648         if (msg->icmph.icmp6_code != 0) {
1649                 ND_PRINTK(2, warn, "NDISC: invalid ICMPv6 code: %d\n",
1650                           msg->icmph.icmp6_code);
1651                 return 0;
1652         }
1653
1654         switch (msg->icmph.icmp6_type) {
1655         case NDISC_NEIGHBOUR_SOLICITATION:
1656                 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1657                 ndisc_recv_ns(skb);
1658                 break;
1659
1660         case NDISC_NEIGHBOUR_ADVERTISEMENT:
1661                 ndisc_recv_na(skb);
1662                 break;
1663
1664         case NDISC_ROUTER_SOLICITATION:
1665                 ndisc_recv_rs(skb);
1666                 break;
1667
1668         case NDISC_ROUTER_ADVERTISEMENT:
1669                 ndisc_router_discovery(skb);
1670                 break;
1671
1672         case NDISC_REDIRECT:
1673                 ndisc_redirect_rcv(skb);
1674                 break;
1675         }
1676
1677         return 0;
1678 }
1679
1680 static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1681 {
1682         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1683         struct netdev_notifier_change_info *change_info;
1684         struct net *net = dev_net(dev);
1685         struct inet6_dev *idev;
1686
1687         switch (event) {
1688         case NETDEV_CHANGEADDR:
1689                 neigh_changeaddr(&nd_tbl, dev);
1690                 fib6_run_gc(0, net, false);
1691                 /* fallthrough */
1692         case NETDEV_UP:
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 }