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