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