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