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