SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 <linux/proc_fs.h>
  88
  89 #include <linux/netfilter.h>
  90 #include <linux/netfilter_ipv6.h>
  91
  92 static u32 ndisc_hash(const void *pkey, const struct net_device *dev);
  93 static int ndisc_constructor(struct neighbour *neigh);
  94 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb);
  95 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb);
  96 static int pndisc_constructor(struct pneigh_entry *n);
  97 static void pndisc_destructor(struct pneigh_entry *n);
  98 static void pndisc_redo(struct sk_buff *skb);
  99
 100 static struct neigh_ops ndisc_generic_ops = {
 101         .family =               AF_INET6,
 102         .solicit =              ndisc_solicit,
 103         .error_report =         ndisc_error_report,
 104         .output =               neigh_resolve_output,
 105         .connected_output =     neigh_connected_output,
 106         .hh_output =            dev_queue_xmit,
 107         .queue_xmit =           dev_queue_xmit,
 108 };
 109
 110 static struct neigh_ops ndisc_hh_ops = {
 111         .family =               AF_INET6,
 112         .solicit =              ndisc_solicit,
 113         .error_report =         ndisc_error_report,
 114         .output =               neigh_resolve_output,
 115         .connected_output =     neigh_resolve_output,
 116         .hh_output =            dev_queue_xmit,
 117         .queue_xmit =           dev_queue_xmit,
 118 };
 119
 120
 121 static struct neigh_ops ndisc_direct_ops = {
 122         .family =               AF_INET6,
 123         .output =               dev_queue_xmit,
 124         .connected_output =     dev_queue_xmit,
 125         .hh_output =            dev_queue_xmit,
 126         .queue_xmit =           dev_queue_xmit,
 127 };
 128
 129 struct neigh_table nd_tbl = {
 130         .family =       AF_INET6,
 131         .entry_size =   sizeof(struct neighbour) + sizeof(struct in6_addr),
 132         .key_len =      sizeof(struct in6_addr),
 133         .hash =         ndisc_hash,
 134         .constructor =  ndisc_constructor,
 135         .pconstructor = pndisc_constructor,
 136         .pdestructor =  pndisc_destructor,
 137         .proxy_redo =   pndisc_redo,
 138         .id =           "ndisc_cache",
 139         .parms = {
 140                 .tbl =                  &nd_tbl,
 141                 .base_reachable_time =  30 * HZ,
 142                 .retrans_time =  1 * HZ,
 143                 .gc_staletime = 60 * HZ,
 144                 .reachable_time =               30 * HZ,
 145                 .delay_probe_time =      5 * HZ,
 146                 .queue_len =             3,
 147                 .ucast_probes =  3,
 148                 .mcast_probes =  3,
 149                 .anycast_delay =         1 * HZ,
 150                 .proxy_delay =          (8 * HZ) / 10,
 151                 .proxy_qlen =           64,
 152         },
 153         .gc_interval =    30 * HZ,
 154         .gc_thresh1 =    128,
 155         .gc_thresh2 =    512,
 156         .gc_thresh3 =   1024,
 157 };
 158
 159 /* ND options */
 160 struct ndisc_options {
 161         struct nd_opt_hdr *nd_opt_array[__ND_OPT_ARRAY_MAX];
 162 #ifdef CONFIG_IPV6_ROUTE_INFO
 163         struct nd_opt_hdr *nd_opts_ri;
 164         struct nd_opt_hdr *nd_opts_ri_end;
 165 #endif
 166         struct nd_opt_hdr *nd_useropts;
 167         struct nd_opt_hdr *nd_useropts_end;
 168 };
 169
 170 #define nd_opts_src_lladdr      nd_opt_array[ND_OPT_SOURCE_LL_ADDR]
 171 #define nd_opts_tgt_lladdr      nd_opt_array[ND_OPT_TARGET_LL_ADDR]
 172 #define nd_opts_pi              nd_opt_array[ND_OPT_PREFIX_INFO]
 173 #define nd_opts_pi_end          nd_opt_array[__ND_OPT_PREFIX_INFO_END]
 174 #define nd_opts_rh              nd_opt_array[ND_OPT_REDIRECT_HDR]
 175 #define nd_opts_mtu             nd_opt_array[ND_OPT_MTU]
 176
 177 #define NDISC_OPT_SPACE(len) (((len)+2+7)&~7)
 178
 179 /*
 180  * Return the padding between the option length and the start of the
 181  * link addr.  Currently only IP-over-InfiniBand needs this, although
 182  * if RFC 3831 IPv6-over-Fibre Channel is ever implemented it may
 183  * also need a pad of 2.
 184  */
 185 static int ndisc_addr_option_pad(unsigned short type)
 186 {
 187         switch (type) {
 188         case ARPHRD_INFINIBAND: return 2;
 189         default:                return 0;
 190         }
 191 }
 192
 193 static inline int ndisc_opt_addr_space(struct net_device *dev)
 194 {
 195         return NDISC_OPT_SPACE(dev->addr_len + ndisc_addr_option_pad(dev->type));
 196 }
 197
 198 static u8 *ndisc_fill_addr_option(u8 *opt, int type, void *data, int data_len,
 199                                   unsigned short addr_type)
 200 {
 201         int space = NDISC_OPT_SPACE(data_len);
 202         int pad   = ndisc_addr_option_pad(addr_type);
 203
 204         opt[0] = type;
 205         opt[1] = space>>3;
 206
 207         memset(opt + 2, 0, pad);
 208         opt   += pad;
 209         space -= pad;
 210
 211         memcpy(opt+2, data, data_len);
 212         data_len += 2;
 213         opt += data_len;
 214         if ((space -= data_len) > 0)
 215                 memset(opt, 0, space);
 216         return opt + space;
 217 }
 218
 219 static struct nd_opt_hdr *ndisc_next_option(struct nd_opt_hdr *cur,
 220                                             struct nd_opt_hdr *end)
 221 {
 222         int type;
 223         if (!cur || !end || cur >= end)
 224                 return NULL;
 225         type = cur->nd_opt_type;
 226         do {
 227                 cur = ((void *)cur) + (cur->nd_opt_len << 3);
 228         } while(cur < end && cur->nd_opt_type != type);
 229         return (cur <= end && cur->nd_opt_type == type ? cur : NULL);
 230 }
 231
 232 static inline int ndisc_is_useropt(struct nd_opt_hdr *opt)
 233 {
 234         return (opt->nd_opt_type == ND_OPT_RDNSS);
 235 }
 236
 237 static struct nd_opt_hdr *ndisc_next_useropt(struct nd_opt_hdr *cur,
 238                                              struct nd_opt_hdr *end)
 239 {
 240         if (!cur || !end || cur >= end)
 241                 return NULL;
 242         do {
 243                 cur = ((void *)cur) + (cur->nd_opt_len << 3);
 244         } while(cur < end && !ndisc_is_useropt(cur));
 245         return (cur <= end && ndisc_is_useropt(cur) ? cur : NULL);
 246 }
 247
 248 static struct ndisc_options *ndisc_parse_options(u8 *opt, int opt_len,
 249                                                  struct ndisc_options *ndopts)
 250 {
 251         struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)opt;
 252
 253         if (!nd_opt || opt_len < 0 || !ndopts)
 254                 return NULL;
 255         memset(ndopts, 0, sizeof(*ndopts));
 256         while (opt_len) {
 257                 int l;
 258                 if (opt_len < sizeof(struct nd_opt_hdr))
 259                         return NULL;
 260                 l = nd_opt->nd_opt_len << 3;
 261                 if (opt_len < l || l == 0)
 262                         return NULL;
 263                 switch (nd_opt->nd_opt_type) {
 264                 case ND_OPT_SOURCE_LL_ADDR:
 265                 case ND_OPT_TARGET_LL_ADDR:
 266                 case ND_OPT_MTU:
 267                 case ND_OPT_REDIRECT_HDR:
 268                         if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) {
 269                                 ND_PRINTK2(KERN_WARNING
 270                                            "%s(): duplicated ND6 option found: type=%d\n",
 271                                            __func__,
 272                                            nd_opt->nd_opt_type);
 273                         } else {
 274                                 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
 275                         }
 276                         break;
 277                 case ND_OPT_PREFIX_INFO:
 278                         ndopts->nd_opts_pi_end = nd_opt;
 279                         if (!ndopts->nd_opt_array[nd_opt->nd_opt_type])
 280                                 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
 281                         break;
 282 #ifdef CONFIG_IPV6_ROUTE_INFO
 283                 case ND_OPT_ROUTE_INFO:
 284                         ndopts->nd_opts_ri_end = nd_opt;
 285                         if (!ndopts->nd_opts_ri)
 286                                 ndopts->nd_opts_ri = nd_opt;
 287                         break;
 288 #endif
 289                 default:
 290                         if (ndisc_is_useropt(nd_opt)) {
 291                                 ndopts->nd_useropts_end = nd_opt;
 292                                 if (!ndopts->nd_useropts)
 293                                         ndopts->nd_useropts = nd_opt;
 294                         } else {
 295                                 /*
 296                                  * Unknown options must be silently ignored,
 297                                  * to accommodate future extension to the
 298                                  * protocol.
 299                                  */
 300                                 ND_PRINTK2(KERN_NOTICE
 301                                            "%s(): ignored unsupported option; type=%d, len=%d\n",
 302                                            __func__,
 303                                            nd_opt->nd_opt_type, nd_opt->nd_opt_len);
 304                         }
 305                 }
 306                 opt_len -= l;
 307                 nd_opt = ((void *)nd_opt) + l;
 308         }
 309         return ndopts;
 310 }
 311
 312 static inline u8 *ndisc_opt_addr_data(struct nd_opt_hdr *p,
 313                                       struct net_device *dev)
 314 {
 315         u8 *lladdr = (u8 *)(p + 1);
 316         int lladdrlen = p->nd_opt_len << 3;
 317         int prepad = ndisc_addr_option_pad(dev->type);
 318         if (lladdrlen != NDISC_OPT_SPACE(dev->addr_len + prepad))
 319                 return NULL;
 320         return (lladdr + prepad);
 321 }
 322
 323 int ndisc_mc_map(struct in6_addr *addr, char *buf, struct net_device *dev, int dir)
 324 {
 325         switch (dev->type) {
 326         case ARPHRD_ETHER:
 327         case ARPHRD_IEEE802:    /* Not sure. Check it later. --ANK */
 328         case ARPHRD_FDDI:
 329                 ipv6_eth_mc_map(addr, buf);
 330                 return 0;
 331         case ARPHRD_IEEE802_TR:
 332                 ipv6_tr_mc_map(addr,buf);
 333                 return 0;
 334         case ARPHRD_ARCNET:
 335                 ipv6_arcnet_mc_map(addr, buf);
 336                 return 0;
 337         case ARPHRD_INFINIBAND:
 338                 ipv6_ib_mc_map(addr, dev->broadcast, buf);
 339                 return 0;
 340         default:
 341                 if (dir) {
 342                         memcpy(buf, dev->broadcast, dev->addr_len);
 343                         return 0;
 344                 }
 345         }
 346         return -EINVAL;
 347 }
 348
 349 EXPORT_SYMBOL(ndisc_mc_map);
 350
 351 static u32 ndisc_hash(const void *pkey, const struct net_device *dev)
 352 {
 353         const u32 *p32 = pkey;
 354         u32 addr_hash, i;
 355
 356         addr_hash = 0;
 357         for (i = 0; i < (sizeof(struct in6_addr) / sizeof(u32)); i++)
 358                 addr_hash ^= *p32++;
 359
 360         return jhash_2words(addr_hash, dev->ifindex, nd_tbl.hash_rnd);
 361 }
 362
 363 static int ndisc_constructor(struct neighbour *neigh)
 364 {
 365         struct in6_addr *addr = (struct in6_addr*)&neigh->primary_key;
 366         struct net_device *dev = neigh->dev;
 367         struct inet6_dev *in6_dev;
 368         struct neigh_parms *parms;
 369         int is_multicast = ipv6_addr_is_multicast(addr);
 370
 371         rcu_read_lock();
 372         in6_dev = in6_dev_get(dev);
 373         if (in6_dev == NULL) {
 374                 rcu_read_unlock();
 375                 return -EINVAL;
 376         }
 377
 378         parms = in6_dev->nd_parms;
 379         __neigh_parms_put(neigh->parms);
 380         neigh->parms = neigh_parms_clone(parms);
 381         rcu_read_unlock();
 382
 383         neigh->type = is_multicast ? RTN_MULTICAST : RTN_UNICAST;
 384         if (!dev->header_ops) {
 385                 neigh->nud_state = NUD_NOARP;
 386                 neigh->ops = &ndisc_direct_ops;
 387                 neigh->output = neigh->ops->queue_xmit;
 388         } else {
 389                 if (is_multicast) {
 390                         neigh->nud_state = NUD_NOARP;
 391                         ndisc_mc_map(addr, neigh->ha, dev, 1);
 392                 } else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {
 393                         neigh->nud_state = NUD_NOARP;
 394                         memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
 395                         if (dev->flags&IFF_LOOPBACK)
 396                                 neigh->type = RTN_LOCAL;
 397                 } else if (dev->flags&IFF_POINTOPOINT) {
 398                         neigh->nud_state = NUD_NOARP;
 399                         memcpy(neigh->ha, dev->broadcast, dev->addr_len);
 400                 }
 401                 if (dev->header_ops->cache)
 402                         neigh->ops = &ndisc_hh_ops;
 403                 else
 404                         neigh->ops = &ndisc_generic_ops;
 405                 if (neigh->nud_state&NUD_VALID)
 406                         neigh->output = neigh->ops->connected_output;
 407                 else
 408                         neigh->output = neigh->ops->output;
 409         }
 410         in6_dev_put(in6_dev);
 411         return 0;
 412 }
 413
 414 static int pndisc_constructor(struct pneigh_entry *n)
 415 {
 416         struct in6_addr *addr = (struct in6_addr*)&n->key;
 417         struct in6_addr maddr;
 418         struct net_device *dev = n->dev;
 419
 420         if (dev == NULL || __in6_dev_get(dev) == NULL)
 421                 return -EINVAL;
 422         addrconf_addr_solict_mult(addr, &maddr);
 423         ipv6_dev_mc_inc(dev, &maddr);
 424         return 0;
 425 }
 426
 427 static void pndisc_destructor(struct pneigh_entry *n)
 428 {
 429         struct in6_addr *addr = (struct in6_addr*)&n->key;
 430         struct in6_addr maddr;
 431         struct net_device *dev = n->dev;
 432
 433         if (dev == NULL || __in6_dev_get(dev) == NULL)
 434                 return;
 435         addrconf_addr_solict_mult(addr, &maddr);
 436         ipv6_dev_mc_dec(dev, &maddr);
 437 }
 438
 439 /*
 440  *      Send a Neighbour Advertisement
 441  */
 442 static void __ndisc_send(struct net_device *dev,
 443                          struct neighbour *neigh,
 444                          struct in6_addr *daddr, struct in6_addr *saddr,
 445                          struct icmp6hdr *icmp6h, struct in6_addr *target,
 446                          int llinfo)
 447 {
 448         struct flowi fl;
 449         struct dst_entry *dst;
 450         struct net *net = dev_net(dev);
 451         struct sock *sk = net->ipv6.ndisc_sk;
 452         struct sk_buff *skb;
 453         struct icmp6hdr *hdr;
 454         struct inet6_dev *idev;
 455         int len;
 456         int err;
 457         u8 *opt, type;
 458
 459         type = icmp6h->icmp6_type;
 460
 461         icmpv6_flow_init(sk, &fl, type, saddr, daddr, dev->ifindex);
 462
 463         dst = icmp6_dst_alloc(dev, neigh, daddr);
 464         if (!dst)
 465                 return;
 466
 467         err = xfrm_lookup(&dst, &fl, NULL, 0);
 468         if (err < 0)
 469                 return;
 470
 471         if (!dev->addr_len)
 472                 llinfo = 0;
 473
 474         len = sizeof(struct icmp6hdr) + (target ? sizeof(*target) : 0);
 475         if (llinfo)
 476                 len += ndisc_opt_addr_space(dev);
 477
 478         skb = sock_alloc_send_skb(sk,
 479                                   (MAX_HEADER + sizeof(struct ipv6hdr) +
 480                                    len + LL_RESERVED_SPACE(dev)),
 481                                   1, &err);
 482         if (!skb) {
 483                 ND_PRINTK0(KERN_ERR
 484                            "ICMPv6 ND: %s() failed to allocate an skb.\n",
 485                            __func__);
 486                 dst_release(dst);
 487                 return;
 488         }
 489
 490         skb_reserve(skb, LL_RESERVED_SPACE(dev));
 491         ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);
 492
 493         skb->transport_header = skb->tail;
 494         skb_put(skb, len);
 495
 496         hdr = (struct icmp6hdr *)skb_transport_header(skb);
 497         memcpy(hdr, icmp6h, sizeof(*hdr));
 498
 499         opt = skb_transport_header(skb) + sizeof(struct icmp6hdr);
 500         if (target) {
 501                 ipv6_addr_copy((struct in6_addr *)opt, target);
 502                 opt += sizeof(*target);
 503         }
 504
 505         if (llinfo)
 506                 ndisc_fill_addr_option(opt, llinfo, dev->dev_addr,
 507                                        dev->addr_len, dev->type);
 508
 509         hdr->icmp6_cksum = csum_ipv6_magic(saddr, daddr, len,
 510                                            IPPROTO_ICMPV6,
 511                                            csum_partial((__u8 *) hdr,
 512                                                         len, 0));
 513
 514         skb->dst = dst;
 515
 516         idev = in6_dev_get(dst->dev);
 517         IP6_INC_STATS(idev, IPSTATS_MIB_OUTREQUESTS);
 518
 519         err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev,
 520                       dst_output);
 521         if (!err) {
 522                 ICMP6MSGOUT_INC_STATS(idev, type);
 523                 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);
 524         }
 525
 526         if (likely(idev != NULL))
 527                 in6_dev_put(idev);
 528 }
 529
 530 static void ndisc_send_na(struct net_device *dev, struct neighbour *neigh,
 531                    struct in6_addr *daddr, struct in6_addr *solicited_addr,
 532                    int router, int solicited, int override, int inc_opt)
 533 {
 534         struct in6_addr tmpaddr;
 535         struct inet6_ifaddr *ifp;
 536         struct in6_addr *src_addr;
 537         struct icmp6hdr icmp6h = {
 538                 .icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT,
 539         };
 540
 541         /* for anycast or proxy, solicited_addr != src_addr */
 542         ifp = ipv6_get_ifaddr(dev_net(dev), solicited_addr, dev, 1);
 543         if (ifp) {
 544                 src_addr = solicited_addr;
 545                 if (ifp->flags & IFA_F_OPTIMISTIC)
 546                         override = 0;
 547                 in6_ifa_put(ifp);
 548         } else {
 549                 if (ipv6_dev_get_saddr(dev, daddr,
 550                                        inet6_sk(dev_net(dev)->ipv6.ndisc_sk)->srcprefs,
 551                                        &tmpaddr))
 552                         return;
 553                 src_addr = &tmpaddr;
 554         }
 555
 556         icmp6h.icmp6_router = router;
 557         icmp6h.icmp6_solicited = solicited;
 558         icmp6h.icmp6_override = override;
 559
 560         __ndisc_send(dev, neigh, daddr, src_addr,
 561                      &icmp6h, solicited_addr,
 562                      inc_opt ? ND_OPT_TARGET_LL_ADDR : 0);
 563 }
 564
 565 void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh,
 566                    struct in6_addr *solicit,
 567                    struct in6_addr *daddr, struct in6_addr *saddr)
 568 {
 569         struct in6_addr addr_buf;
 570         struct icmp6hdr icmp6h = {
 571                 .icmp6_type = NDISC_NEIGHBOUR_SOLICITATION,
 572         };
 573
 574         if (saddr == NULL) {
 575                 if (ipv6_get_lladdr(dev, &addr_buf,
 576                                    (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
 577                         return;
 578                 saddr = &addr_buf;
 579         }
 580
 581         __ndisc_send(dev, neigh, daddr, saddr,
 582                      &icmp6h, solicit,
 583                      !ipv6_addr_any(saddr) ? ND_OPT_SOURCE_LL_ADDR : 0);
 584 }
 585
 586 void ndisc_send_rs(struct net_device *dev, struct in6_addr *saddr,
 587                    struct in6_addr *daddr)
 588 {
 589         struct icmp6hdr icmp6h = {
 590                 .icmp6_type = NDISC_ROUTER_SOLICITATION,
 591         };
 592         int send_sllao = dev->addr_len;
 593
 594 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
 595         /*
 596          * According to section 2.2 of RFC 4429, we must not
 597          * send router solicitations with a sllao from
 598          * optimistic addresses, but we may send the solicitation
 599          * if we don't include the sllao.  So here we check
 600          * if our address is optimistic, and if so, we
 601          * suppress the inclusion of the sllao.
 602          */
 603         if (send_sllao) {
 604                 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev_net(dev), saddr,
 605                                                            dev, 1);
 606                 if (ifp) {
 607                         if (ifp->flags & IFA_F_OPTIMISTIC)  {
 608                                 send_sllao = 0;
 609                         }
 610                         in6_ifa_put(ifp);
 611                 } else {
 612                         send_sllao = 0;
 613                 }
 614         }
 615 #endif
 616         __ndisc_send(dev, NULL, daddr, saddr,
 617                      &icmp6h, NULL,
 618                      send_sllao ? ND_OPT_SOURCE_LL_ADDR : 0);
 619 }
 620
 621
 622 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
 623 {
 624         /*
 625          *      "The sender MUST return an ICMP
 626          *       destination unreachable"
 627          */
 628         dst_link_failure(skb);
 629         kfree_skb(skb);
 630 }
 631
 632 /* Called with locked neigh: either read or both */
 633
 634 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
 635 {
 636         struct in6_addr *saddr = NULL;
 637         struct in6_addr mcaddr;
 638         struct net_device *dev = neigh->dev;
 639         struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
 640         int probes = atomic_read(&neigh->probes);
 641
 642         if (skb && ipv6_chk_addr(dev_net(dev), &ipv6_hdr(skb)->saddr, dev, 1))
 643                 saddr = &ipv6_hdr(skb)->saddr;
 644
 645         if ((probes -= neigh->parms->ucast_probes) < 0) {
 646                 if (!(neigh->nud_state & NUD_VALID)) {
 647                         ND_PRINTK1(KERN_DEBUG
 648                                    "%s(): trying to ucast probe in NUD_INVALID: "
 649                                    NIP6_FMT "\n",
 650                                    __func__,
 651                                    NIP6(*target));
 652                 }
 653                 ndisc_send_ns(dev, neigh, target, target, saddr);
 654         } else if ((probes -= neigh->parms->app_probes) < 0) {
 655 #ifdef CONFIG_ARPD
 656                 neigh_app_ns(neigh);
 657 #endif
 658         } else {
 659                 addrconf_addr_solict_mult(target, &mcaddr);
 660                 ndisc_send_ns(dev, NULL, target, &mcaddr, saddr);
 661         }
 662 }
 663
 664 static int pndisc_is_router(const void *pkey,
 665                             struct net_device *dev)
 666 {
 667         struct pneigh_entry *n;
 668         int ret = -1;
 669
 670         read_lock_bh(&nd_tbl.lock);
 671         n = __pneigh_lookup(&nd_tbl, dev_net(dev), pkey, dev);
 672         if (n)
 673                 ret = !!(n->flags & NTF_ROUTER);
 674         read_unlock_bh(&nd_tbl.lock);
 675
 676         return ret;
 677 }
 678
 679 static void ndisc_recv_ns(struct sk_buff *skb)
 680 {
 681         struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
 682         struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
 683         struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
 684         u8 *lladdr = NULL;
 685         u32 ndoptlen = skb->tail - (skb->transport_header +
 686                                     offsetof(struct nd_msg, opt));
 687         struct ndisc_options ndopts;
 688         struct net_device *dev = skb->dev;
 689         struct inet6_ifaddr *ifp;
 690         struct inet6_dev *idev = NULL;
 691         struct neighbour *neigh;
 692         int dad = ipv6_addr_any(saddr);
 693         int inc;
 694         int is_router = -1;
 695
 696         if (ipv6_addr_is_multicast(&msg->target)) {
 697                 ND_PRINTK2(KERN_WARNING
 698                            "ICMPv6 NS: multicast target address");
 699                 return;
 700         }
 701
 702         /*
 703          * RFC2461 7.1.1:
 704          * DAD has to be destined for solicited node multicast address.
 705          */
 706         if (dad &&
 707             !(daddr->s6_addr32[0] == htonl(0xff020000) &&
 708               daddr->s6_addr32[1] == htonl(0x00000000) &&
 709               daddr->s6_addr32[2] == htonl(0x00000001) &&
 710               daddr->s6_addr [12] == 0xff )) {
 711                 ND_PRINTK2(KERN_WARNING
 712                            "ICMPv6 NS: bad DAD packet (wrong destination)\n");
 713                 return;
 714         }
 715
 716         if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
 717                 ND_PRINTK2(KERN_WARNING
 718                            "ICMPv6 NS: invalid ND options\n");
 719                 return;
 720         }
 721
 722         if (ndopts.nd_opts_src_lladdr) {
 723                 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
 724                 if (!lladdr) {
 725                         ND_PRINTK2(KERN_WARNING
 726                                    "ICMPv6 NS: invalid link-layer address length\n");
 727                         return;
 728                 }
 729
 730                 /* RFC2461 7.1.1:
 731                  *      If the IP source address is the unspecified address,
 732                  *      there MUST NOT be source link-layer address option
 733                  *      in the message.
 734                  */
 735                 if (dad) {
 736                         ND_PRINTK2(KERN_WARNING
 737                                    "ICMPv6 NS: bad DAD packet (link-layer address option)\n");
 738                         return;
 739                 }
 740         }
 741
 742         inc = ipv6_addr_is_multicast(daddr);
 743
 744         ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
 745         if (ifp) {
 746
 747                 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
 748                         if (dad) {
 749                                 if (dev->type == ARPHRD_IEEE802_TR) {
 750                                         const unsigned char *sadr;
 751                                         sadr = skb_mac_header(skb);
 752                                         if (((sadr[8] ^ dev->dev_addr[0]) & 0x7f) == 0 &&
 753                                             sadr[9] == dev->dev_addr[1] &&
 754                                             sadr[10] == dev->dev_addr[2] &&
 755                                             sadr[11] == dev->dev_addr[3] &&
 756                                             sadr[12] == dev->dev_addr[4] &&
 757                                             sadr[13] == dev->dev_addr[5]) {
 758                                                 /* looped-back to us */
 759                                                 goto out;
 760                                         }
 761                                 }
 762
 763                                 /*
 764                                  * We are colliding with another node
 765                                  * who is doing DAD
 766                                  * so fail our DAD process
 767                                  */
 768                                 addrconf_dad_failure(ifp);
 769                                 return;
 770                         } else {
 771                                 /*
 772                                  * This is not a dad solicitation.
 773                                  * If we are an optimistic node,
 774                                  * we should respond.
 775                                  * Otherwise, we should ignore it.
 776                                  */
 777                                 if (!(ifp->flags & IFA_F_OPTIMISTIC))
 778                                         goto out;
 779                         }
 780                 }
 781
 782                 idev = ifp->idev;
 783         } else {
 784                 idev = in6_dev_get(dev);
 785                 if (!idev) {
 786                         /* XXX: count this drop? */
 787                         return;
 788                 }
 789
 790                 if (ipv6_chk_acast_addr(dev_net(dev), dev, &msg->target) ||
 791                     (idev->cnf.forwarding &&
 792                      (ipv6_devconf.proxy_ndp || idev->cnf.proxy_ndp) &&
 793                      (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) {
 794                         if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
 795                             skb->pkt_type != PACKET_HOST &&
 796                             inc != 0 &&
 797                             idev->nd_parms->proxy_delay != 0) {
 798                                 /*
 799                                  * for anycast or proxy,
 800                                  * sender should delay its response
 801                                  * by a random time between 0 and
 802                                  * MAX_ANYCAST_DELAY_TIME seconds.
 803                                  * (RFC2461) -- yoshfuji
 804                                  */
 805                                 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
 806                                 if (n)
 807                                         pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
 808                                 goto out;
 809                         }
 810                 } else
 811                         goto out;
 812         }
 813
 814         if (is_router < 0)
 815                 is_router = !!idev->cnf.forwarding;
 816
 817         if (dad) {
 818                 struct in6_addr maddr;
 819
 820                 ipv6_addr_all_nodes(&maddr);
 821                 ndisc_send_na(dev, NULL, &maddr, &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                          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 socket *sock;
1775         struct ipv6_pinfo *np;
1776         struct sock *sk;
1777         int err;
1778
1779         err = sock_create_kern(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6, &sock);
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 = sock->sk;
1788         sk_change_net(sk, net);
1789
1790         np = inet6_sk(sk);
1791         sk->sk_allocation = GFP_ATOMIC;
1792         np->hop_limit = 255;
1793         /* Do not loopback ndisc messages */
1794         np->mc_loop = 0;
1795         sk->sk_prot->unhash(sk);
1796
1797         return 0;
1798 }
1799
1800 static void ndisc_net_exit(struct net *net)
1801 {
1802         sk_release_kernel(net->ipv6.ndisc_sk);
1803 }
1804
1805 static struct pernet_operations ndisc_net_ops = {
1806         .init = ndisc_net_init,
1807         .exit = ndisc_net_exit,
1808 };
1809
1810 int __init ndisc_init(void)
1811 {
1812         int err;
1813
1814         err = register_pernet_subsys(&ndisc_net_ops);
1815         if (err)
1816                 return err;
1817         /*
1818          * Initialize the neighbour table
1819          */
1820         neigh_table_init(&nd_tbl);
1821
1822 #ifdef CONFIG_SYSCTL
1823         err = neigh_sysctl_register(NULL, &nd_tbl.parms, NET_IPV6,
1824                                     NET_IPV6_NEIGH, "ipv6",
1825                                     &ndisc_ifinfo_sysctl_change,
1826                                     &ndisc_ifinfo_sysctl_strategy);
1827         if (err)
1828                 goto out_unregister_pernet;
1829 #endif
1830         err = register_netdevice_notifier(&ndisc_netdev_notifier);
1831         if (err)
1832                 goto out_unregister_sysctl;
1833 out:
1834         return err;
1835
1836 out_unregister_sysctl:
1837 #ifdef CONFIG_SYSCTL
1838         neigh_sysctl_unregister(&nd_tbl.parms);
1839 out_unregister_pernet:
1840 #endif
1841         unregister_pernet_subsys(&ndisc_net_ops);
1842         goto out;
1843 }
1844
1845 void ndisc_cleanup(void)
1846 {
1847         unregister_netdevice_notifier(&ndisc_netdev_notifier);
1848 #ifdef CONFIG_SYSCTL
1849         neigh_sysctl_unregister(&nd_tbl.parms);
1850 #endif
1851         neigh_table_clear(&nd_tbl);
1852         unregister_pernet_subsys(&ndisc_net_ops);
1853 }