net/ipv6/ndisc.c

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