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