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