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