net/ipv6/ndisc.c

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