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