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