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