net/ipv6/ndisc.c

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