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