?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[NETNS][IPV6] ndisc - make ndisc handle multiple network namespaces
[linux-2.6/cjktty.git] / net / ipv6 / ndisc.c
bloba539b9ea53fdfbfb6f420788e8cac72577181c46
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 __func__,
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 __func__,
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 static void __ndisc_send(struct net_device *dev,
445 struct neighbour *neigh,
446 struct in6_addr *daddr, struct in6_addr *saddr,
447 struct icmp6hdr *icmp6h, struct in6_addr *target,
448 int llinfo)
449 {
450 struct flowi fl;
451 struct dst_entry *dst;
452 struct sock *sk = ndisc_socket->sk;
453 struct sk_buff *skb;
454 struct icmp6hdr *hdr;
455 struct inet6_dev *idev;
456 int len;
457 int err;
458 u8 *opt, type;
459
460 type = icmp6h->icmp6_type;
461
462 icmpv6_flow_init(ndisc_socket->sk, &fl, type,
463 saddr, daddr, dev->ifindex);
464
465 dst = icmp6_dst_alloc(dev, neigh, daddr);
466 if (!dst)
467 return;
468
469 err = xfrm_lookup(&dst, &fl, NULL, 0);
470 if (err < 0)
471 return;
472
473 if (!dev->addr_len)
474 llinfo = 0;
475
476 len = sizeof(struct icmp6hdr) + (target ? sizeof(*target) : 0);
477 if (llinfo)
478 len += ndisc_opt_addr_space(dev);
479
480 skb = sock_alloc_send_skb(sk,
481 (MAX_HEADER + sizeof(struct ipv6hdr) +
482 len + LL_RESERVED_SPACE(dev)),
483 1, &err);
484 if (!skb) {
485 ND_PRINTK0(KERN_ERR
486 "ICMPv6 ND: %s() failed to allocate an skb.\n",
487 __func__);
488 dst_release(dst);
489 return;
490 }
491
492 skb_reserve(skb, LL_RESERVED_SPACE(dev));
493 ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);
494
495 skb->transport_header = skb->tail;
496 skb_put(skb, len);
497
498 hdr = (struct icmp6hdr *)skb_transport_header(skb);
499 memcpy(hdr, icmp6h, sizeof(*hdr));
500
501 opt = skb_transport_header(skb) + sizeof(struct icmp6hdr);
502 if (target) {
503 ipv6_addr_copy((struct in6_addr *)opt, target);
504 opt += sizeof(*target);
505 }
506
507 if (llinfo)
508 ndisc_fill_addr_option(opt, llinfo, dev->dev_addr,
509 dev->addr_len, dev->type);
510
511 hdr->icmp6_cksum = csum_ipv6_magic(saddr, daddr, len,
512 IPPROTO_ICMPV6,
513 csum_partial((__u8 *) hdr,
514 len, 0));
515
516 skb->dst = dst;
517
518 idev = in6_dev_get(dst->dev);
519 IP6_INC_STATS(idev, IPSTATS_MIB_OUTREQUESTS);
520
521 err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev,
522 dst_output);
523 if (!err) {
524 ICMP6MSGOUT_INC_STATS(idev, type);
525 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);
526 }
527
528 if (likely(idev != NULL))
529 in6_dev_put(idev);
530 }
531
532 static void ndisc_send_na(struct net_device *dev, struct neighbour *neigh,
533 struct in6_addr *daddr, struct in6_addr *solicited_addr,
534 int router, int solicited, int override, int inc_opt)
535 {
536 struct in6_addr tmpaddr;
537 struct inet6_ifaddr *ifp;
538 struct in6_addr *src_addr;
539 struct icmp6hdr icmp6h = {
540 .icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT,
541 };
542
543 /* for anycast or proxy, solicited_addr != src_addr */
544 ifp = ipv6_get_ifaddr(dev->nd_net, solicited_addr, dev, 1);
545 if (ifp) {
546 src_addr = solicited_addr;
547 if (ifp->flags & IFA_F_OPTIMISTIC)
548 override = 0;
549 in6_ifa_put(ifp);
550 } else {
551 if (ipv6_dev_get_saddr(dev, daddr, &tmpaddr))
552 return;
553 src_addr = &tmpaddr;
554 }
555
556 icmp6h.icmp6_router = router;
557 icmp6h.icmp6_solicited = solicited;
558 icmp6h.icmp6_override = override;
559
560 __ndisc_send(dev, neigh, daddr, src_addr,
561 &icmp6h, solicited_addr,
562 inc_opt ? ND_OPT_TARGET_LL_ADDR : 0);
563 }
564
565 void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh,
566 struct in6_addr *solicit,
567 struct in6_addr *daddr, struct in6_addr *saddr)
568 {
569 struct in6_addr addr_buf;
570 struct icmp6hdr icmp6h = {
571 .icmp6_type = NDISC_NEIGHBOUR_SOLICITATION,
572 };
573
574 if (saddr == NULL) {
575 if (ipv6_get_lladdr(dev, &addr_buf,
576 (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
577 return;
578 saddr = &addr_buf;
579 }
580
581 __ndisc_send(dev, neigh, daddr, saddr,
582 &icmp6h, solicit,
583 !ipv6_addr_any(saddr) ? ND_OPT_SOURCE_LL_ADDR : 0);
584 }
585
586 void ndisc_send_rs(struct net_device *dev, struct in6_addr *saddr,
587 struct in6_addr *daddr)
588 {
589 struct icmp6hdr icmp6h = {
590 .icmp6_type = NDISC_ROUTER_SOLICITATION,
591 };
592 int send_sllao = dev->addr_len;
593
594 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
595 /*
596 * According to section 2.2 of RFC 4429, we must not
597 * send router solicitations with a sllao from
598 * optimistic addresses, but we may send the solicitation
599 * if we don't include the sllao. So here we check
600 * if our address is optimistic, and if so, we
601 * suppress the inclusion of the sllao.
602 */
603 if (send_sllao) {
604 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev->nd_net, saddr,
605 dev, 1);
606 if (ifp) {
607 if (ifp->flags & IFA_F_OPTIMISTIC) {
608 send_sllao = 0;
609 }
610 in6_ifa_put(ifp);
611 } else {
612 send_sllao = 0;
613 }
614 }
615 #endif
616 __ndisc_send(dev, NULL, daddr, saddr,
617 &icmp6h, NULL,
618 send_sllao ? ND_OPT_SOURCE_LL_ADDR : 0);
619 }
620
621
622 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
623 {
624 /*
625 * "The sender MUST return an ICMP
626 * destination unreachable"
627 */
628 dst_link_failure(skb);
629 kfree_skb(skb);
630 }
631
632 /* Called with locked neigh: either read or both */
633
634 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
635 {
636 struct in6_addr *saddr = NULL;
637 struct in6_addr mcaddr;
638 struct net_device *dev = neigh->dev;
639 struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
640 int probes = atomic_read(&neigh->probes);
641
642 if (skb && ipv6_chk_addr(dev->nd_net, &ipv6_hdr(skb)->saddr, dev, 1))
643 saddr = &ipv6_hdr(skb)->saddr;
644
645 if ((probes -= neigh->parms->ucast_probes) < 0) {
646 if (!(neigh->nud_state & NUD_VALID)) {
647 ND_PRINTK1(KERN_DEBUG
648 "%s(): trying to ucast probe in NUD_INVALID: "
649 NIP6_FMT "\n",
650 __func__,
651 NIP6(*target));
652 }
653 ndisc_send_ns(dev, neigh, target, target, saddr);
654 } else if ((probes -= neigh->parms->app_probes) < 0) {
655 #ifdef CONFIG_ARPD
656 neigh_app_ns(neigh);
657 #endif
658 } else {
659 addrconf_addr_solict_mult(target, &mcaddr);
660 ndisc_send_ns(dev, NULL, target, &mcaddr, saddr);
661 }
662 }
663
664 static void ndisc_recv_ns(struct sk_buff *skb)
665 {
666 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
667 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
668 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
669 u8 *lladdr = NULL;
670 u32 ndoptlen = skb->tail - (skb->transport_header +
671 offsetof(struct nd_msg, opt));
672 struct ndisc_options ndopts;
673 struct net_device *dev = skb->dev;
674 struct inet6_ifaddr *ifp;
675 struct inet6_dev *idev = NULL;
676 struct neighbour *neigh;
677 struct pneigh_entry *pneigh = NULL;
678 int dad = ipv6_addr_any(saddr);
679 int inc;
680 int is_router;
681
682 if (ipv6_addr_is_multicast(&msg->target)) {
683 ND_PRINTK2(KERN_WARNING
684 "ICMPv6 NS: multicast target address");
685 return;
686 }
687
688 /*
689 * RFC2461 7.1.1:
690 * DAD has to be destined for solicited node multicast address.
691 */
692 if (dad &&
693 !(daddr->s6_addr32[0] == htonl(0xff020000) &&
694 daddr->s6_addr32[1] == htonl(0x00000000) &&
695 daddr->s6_addr32[2] == htonl(0x00000001) &&
696 daddr->s6_addr [12] == 0xff )) {
697 ND_PRINTK2(KERN_WARNING
698 "ICMPv6 NS: bad DAD packet (wrong destination)\n");
699 return;
700 }
701
702 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
703 ND_PRINTK2(KERN_WARNING
704 "ICMPv6 NS: invalid ND options\n");
705 return;
706 }
707
708 if (ndopts.nd_opts_src_lladdr) {
709 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
710 if (!lladdr) {
711 ND_PRINTK2(KERN_WARNING
712 "ICMPv6 NS: invalid link-layer address length\n");
713 return;
714 }
715
716 /* RFC2461 7.1.1:
717 * If the IP source address is the unspecified address,
718 * there MUST NOT be source link-layer address option
719 * in the message.
720 */
721 if (dad) {
722 ND_PRINTK2(KERN_WARNING
723 "ICMPv6 NS: bad DAD packet (link-layer address option)\n");
724 return;
725 }
726 }
727
728 inc = ipv6_addr_is_multicast(daddr);
729
730 ifp = ipv6_get_ifaddr(dev->nd_net, &msg->target, dev, 1);
731 if (ifp) {
732
733 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
734 if (dad) {
735 if (dev->type == ARPHRD_IEEE802_TR) {
736 const unsigned char *sadr;
737 sadr = skb_mac_header(skb);
738 if (((sadr[8] ^ dev->dev_addr[0]) & 0x7f) == 0 &&
739 sadr[9] == dev->dev_addr[1] &&
740 sadr[10] == dev->dev_addr[2] &&
741 sadr[11] == dev->dev_addr[3] &&
742 sadr[12] == dev->dev_addr[4] &&
743 sadr[13] == dev->dev_addr[5]) {
744 /* looped-back to us */
745 goto out;
746 }
747 }
748
749 /*
750 * We are colliding with another node
751 * who is doing DAD
752 * so fail our DAD process
753 */
754 addrconf_dad_failure(ifp);
755 return;
756 } else {
757 /*
758 * This is not a dad solicitation.
759 * If we are an optimistic node,
760 * we should respond.
761 * Otherwise, we should ignore it.
762 */
763 if (!(ifp->flags & IFA_F_OPTIMISTIC))
764 goto out;
765 }
766 }
767
768 idev = ifp->idev;
769 } else {
770 idev = in6_dev_get(dev);
771 if (!idev) {
772 /* XXX: count this drop? */
773 return;
774 }
775
776 if (ipv6_chk_acast_addr(dev, &msg->target) ||
777 (idev->cnf.forwarding &&
778 (ipv6_devconf.proxy_ndp || idev->cnf.proxy_ndp) &&
779 (pneigh = pneigh_lookup(&nd_tbl, dev->nd_net,
780 &msg->target, dev, 0)) != NULL)) {
781 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
782 skb->pkt_type != PACKET_HOST &&
783 inc != 0 &&
784 idev->nd_parms->proxy_delay != 0) {
785 /*
786 * for anycast or proxy,
787 * sender should delay its response
788 * by a random time between 0 and
789 * MAX_ANYCAST_DELAY_TIME seconds.
790 * (RFC2461) -- yoshfuji
791 */
792 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
793 if (n)
794 pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
795 goto out;
796 }
797 } else
798 goto out;
799 }
800
801 is_router = !!(pneigh ? pneigh->flags & NTF_ROUTER : idev->cnf.forwarding);
802
803 if (dad) {
804 struct in6_addr maddr;
805
806 ipv6_addr_all_nodes(&maddr);
807 ndisc_send_na(dev, NULL, &maddr, &msg->target,
808 is_router, 0, (ifp != NULL), 1);
809 goto out;
810 }
811
812 if (inc)
813 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
814 else
815 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
816
817 /*
818 * update / create cache entry
819 * for the source address
820 */
821 neigh = __neigh_lookup(&nd_tbl, saddr, dev,
822 !inc || lladdr || !dev->addr_len);
823 if (neigh)
824 neigh_update(neigh, lladdr, NUD_STALE,
825 NEIGH_UPDATE_F_WEAK_OVERRIDE|
826 NEIGH_UPDATE_F_OVERRIDE);
827 if (neigh || !dev->header_ops) {
828 ndisc_send_na(dev, neigh, saddr, &msg->target,
829 is_router,
830 1, (ifp != NULL && inc), inc);
831 if (neigh)
832 neigh_release(neigh);
833 }
834
835 out:
836 if (ifp)
837 in6_ifa_put(ifp);
838 else
839 in6_dev_put(idev);
840
841 return;
842 }
843
844 static void ndisc_recv_na(struct sk_buff *skb)
845 {
846 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
847 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
848 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
849 u8 *lladdr = NULL;
850 u32 ndoptlen = skb->tail - (skb->transport_header +
851 offsetof(struct nd_msg, opt));
852 struct ndisc_options ndopts;
853 struct net_device *dev = skb->dev;
854 struct inet6_ifaddr *ifp;
855 struct neighbour *neigh;
856
857 if (skb->len < sizeof(struct nd_msg)) {
858 ND_PRINTK2(KERN_WARNING
859 "ICMPv6 NA: packet too short\n");
860 return;
861 }
862
863 if (ipv6_addr_is_multicast(&msg->target)) {
864 ND_PRINTK2(KERN_WARNING
865 "ICMPv6 NA: target address is multicast.\n");
866 return;
867 }
868
869 if (ipv6_addr_is_multicast(daddr) &&
870 msg->icmph.icmp6_solicited) {
871 ND_PRINTK2(KERN_WARNING
872 "ICMPv6 NA: solicited NA is multicasted.\n");
873 return;
874 }
875
876 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
877 ND_PRINTK2(KERN_WARNING
878 "ICMPv6 NS: invalid ND option\n");
879 return;
880 }
881 if (ndopts.nd_opts_tgt_lladdr) {
882 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
883 if (!lladdr) {
884 ND_PRINTK2(KERN_WARNING
885 "ICMPv6 NA: invalid link-layer address length\n");
886 return;
887 }
888 }
889 ifp = ipv6_get_ifaddr(dev->nd_net, &msg->target, dev, 1);
890 if (ifp) {
891 if (ifp->flags & IFA_F_TENTATIVE) {
892 addrconf_dad_failure(ifp);
893 return;
894 }
895 /* What should we make now? The advertisement
896 is invalid, but ndisc specs say nothing
897 about it. It could be misconfiguration, or
898 an smart proxy agent tries to help us :-)
899 */
900 ND_PRINTK1(KERN_WARNING
901 "ICMPv6 NA: someone advertises our address on %s!\n",
902 ifp->idev->dev->name);
903 in6_ifa_put(ifp);
904 return;
905 }
906 neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
907
908 if (neigh) {
909 u8 old_flags = neigh->flags;
910
911 if (neigh->nud_state & NUD_FAILED)
912 goto out;
913
914 /*
915 * Don't update the neighbor cache entry on a proxy NA from
916 * ourselves because either the proxied node is off link or it
917 * has already sent a NA to us.
918 */
919 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
920 ipv6_devconf.forwarding && ipv6_devconf.proxy_ndp &&
921 pneigh_lookup(&nd_tbl, dev->nd_net, &msg->target, dev, 0)) {
922 /* XXX: idev->cnf.prixy_ndp */
923 goto out;
924 }
925
926 neigh_update(neigh, lladdr,
927 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
928 NEIGH_UPDATE_F_WEAK_OVERRIDE|
929 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
930 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
931 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));
932
933 if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
934 /*
935 * Change: router to host
936 */
937 struct rt6_info *rt;
938 rt = rt6_get_dflt_router(saddr, dev);
939 if (rt)
940 ip6_del_rt(rt);
941 }
942
943 out:
944 neigh_release(neigh);
945 }
946 }
947
948 static void ndisc_recv_rs(struct sk_buff *skb)
949 {
950 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
951 unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
952 struct neighbour *neigh;
953 struct inet6_dev *idev;
954 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
955 struct ndisc_options ndopts;
956 u8 *lladdr = NULL;
957
958 if (skb->len < sizeof(*rs_msg))
959 return;
960
961 idev = in6_dev_get(skb->dev);
962 if (!idev) {
963 if (net_ratelimit())
964 ND_PRINTK1("ICMP6 RS: can't find in6 device\n");
965 return;
966 }
967
968 /* Don't accept RS if we're not in router mode */
969 if (!idev->cnf.forwarding)
970 goto out;
971
972 /*
973 * Don't update NCE if src = ::;
974 * this implies that the source node has no ip address assigned yet.
975 */
976 if (ipv6_addr_any(saddr))
977 goto out;
978
979 /* Parse ND options */
980 if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {
981 if (net_ratelimit())
982 ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n");
983 goto out;
984 }
985
986 if (ndopts.nd_opts_src_lladdr) {
987 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
988 skb->dev);
989 if (!lladdr)
990 goto out;
991 }
992
993 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
994 if (neigh) {
995 neigh_update(neigh, lladdr, NUD_STALE,
996 NEIGH_UPDATE_F_WEAK_OVERRIDE|
997 NEIGH_UPDATE_F_OVERRIDE|
998 NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
999 neigh_release(neigh);
1000 }
1001 out:
1002 in6_dev_put(idev);
1003 }
1004
1005 static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt)
1006 {
1007 struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra);
1008 struct sk_buff *skb;
1009 struct nlmsghdr *nlh;
1010 struct nduseroptmsg *ndmsg;
1011 struct net *net = ra->dev->nd_net;
1012 int err;
1013 int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg)
1014 + (opt->nd_opt_len << 3));
1015 size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr));
1016
1017 skb = nlmsg_new(msg_size, GFP_ATOMIC);
1018 if (skb == NULL) {
1019 err = -ENOBUFS;
1020 goto errout;
1021 }
1022
1023 nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0);
1024 if (nlh == NULL) {
1025 goto nla_put_failure;
1026 }
1027
1028 ndmsg = nlmsg_data(nlh);
1029 ndmsg->nduseropt_family = AF_INET6;
1030 ndmsg->nduseropt_ifindex = ra->dev->ifindex;
1031 ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type;
1032 ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code;
1033 ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3;
1034
1035 memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3);
1036
1037 NLA_PUT(skb, NDUSEROPT_SRCADDR, sizeof(struct in6_addr),
1038 &ipv6_hdr(ra)->saddr);
1039 nlmsg_end(skb, nlh);
1040
1041 err = rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL,
1042 GFP_ATOMIC);
1043 if (err < 0)
1044 goto errout;
1045
1046 return;
1047
1048 nla_put_failure:
1049 nlmsg_free(skb);
1050 err = -EMSGSIZE;
1051 errout:
1052 rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err);
1053 }
1054
1055 static void ndisc_router_discovery(struct sk_buff *skb)
1056 {
1057 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
1058 struct neighbour *neigh = NULL;
1059 struct inet6_dev *in6_dev;
1060 struct rt6_info *rt = NULL;
1061 int lifetime;
1062 struct ndisc_options ndopts;
1063 int optlen;
1064 unsigned int pref = 0;
1065
1066 __u8 * opt = (__u8 *)(ra_msg + 1);
1067
1068 optlen = (skb->tail - skb->transport_header) - sizeof(struct ra_msg);
1069
1070 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1071 ND_PRINTK2(KERN_WARNING
1072 "ICMPv6 RA: source address is not link-local.\n");
1073 return;
1074 }
1075 if (optlen < 0) {
1076 ND_PRINTK2(KERN_WARNING
1077 "ICMPv6 RA: packet too short\n");
1078 return;
1079 }
1080
1081 /*
1082 * set the RA_RECV flag in the interface
1083 */
1084
1085 in6_dev = in6_dev_get(skb->dev);
1086 if (in6_dev == NULL) {
1087 ND_PRINTK0(KERN_ERR
1088 "ICMPv6 RA: can't find inet6 device for %s.\n",
1089 skb->dev->name);
1090 return;
1091 }
1092 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_ra) {
1093 in6_dev_put(in6_dev);
1094 return;
1095 }
1096
1097 if (!ndisc_parse_options(opt, optlen, &ndopts)) {
1098 in6_dev_put(in6_dev);
1099 ND_PRINTK2(KERN_WARNING
1100 "ICMP6 RA: invalid ND options\n");
1101 return;
1102 }
1103
1104 if (in6_dev->if_flags & IF_RS_SENT) {
1105 /*
1106 * flag that an RA was received after an RS was sent
1107 * out on this interface.
1108 */
1109 in6_dev->if_flags |= IF_RA_RCVD;
1110 }
1111
1112 /*
1113 * Remember the managed/otherconf flags from most recently
1114 * received RA message (RFC 2462) -- yoshfuji
1115 */
1116 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1117 IF_RA_OTHERCONF)) |
1118 (ra_msg->icmph.icmp6_addrconf_managed ?
1119 IF_RA_MANAGED : 0) |
1120 (ra_msg->icmph.icmp6_addrconf_other ?
1121 IF_RA_OTHERCONF : 0);
1122
1123 if (!in6_dev->cnf.accept_ra_defrtr)
1124 goto skip_defrtr;
1125
1126 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1127
1128 #ifdef CONFIG_IPV6_ROUTER_PREF
1129 pref = ra_msg->icmph.icmp6_router_pref;
1130 /* 10b is handled as if it were 00b (medium) */
1131 if (pref == ICMPV6_ROUTER_PREF_INVALID ||
1132 !in6_dev->cnf.accept_ra_rtr_pref)
1133 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1134 #endif
1135
1136 rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
1137
1138 if (rt)
1139 neigh = rt->rt6i_nexthop;
1140
1141 if (rt && lifetime == 0) {
1142 neigh_clone(neigh);
1143 ip6_del_rt(rt);
1144 rt = NULL;
1145 }
1146
1147 if (rt == NULL && lifetime) {
1148 ND_PRINTK3(KERN_DEBUG
1149 "ICMPv6 RA: adding default router.\n");
1150
1151 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
1152 if (rt == NULL) {
1153 ND_PRINTK0(KERN_ERR
1154 "ICMPv6 RA: %s() failed to add default route.\n",
1155 __func__);
1156 in6_dev_put(in6_dev);
1157 return;
1158 }
1159
1160 neigh = rt->rt6i_nexthop;
1161 if (neigh == NULL) {
1162 ND_PRINTK0(KERN_ERR
1163 "ICMPv6 RA: %s() got default router without neighbour.\n",
1164 __func__);
1165 dst_release(&rt->u.dst);
1166 in6_dev_put(in6_dev);
1167 return;
1168 }
1169 neigh->flags |= NTF_ROUTER;
1170 } else if (rt) {
1171 rt->rt6i_flags |= (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
1172 }
1173
1174 if (rt)
1175 rt->rt6i_expires = jiffies + (HZ * lifetime);
1176
1177 if (ra_msg->icmph.icmp6_hop_limit) {
1178 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1179 if (rt)
1180 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = ra_msg->icmph.icmp6_hop_limit;
1181 }
1182
1183 skip_defrtr:
1184
1185 /*
1186 * Update Reachable Time and Retrans Timer
1187 */
1188
1189 if (in6_dev->nd_parms) {
1190 unsigned long rtime = ntohl(ra_msg->retrans_timer);
1191
1192 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1193 rtime = (rtime*HZ)/1000;
1194 if (rtime < HZ/10)
1195 rtime = HZ/10;
1196 in6_dev->nd_parms->retrans_time = rtime;
1197 in6_dev->tstamp = jiffies;
1198 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1199 }
1200
1201 rtime = ntohl(ra_msg->reachable_time);
1202 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1203 rtime = (rtime*HZ)/1000;
1204
1205 if (rtime < HZ/10)
1206 rtime = HZ/10;
1207
1208 if (rtime != in6_dev->nd_parms->base_reachable_time) {
1209 in6_dev->nd_parms->base_reachable_time = rtime;
1210 in6_dev->nd_parms->gc_staletime = 3 * rtime;
1211 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1212 in6_dev->tstamp = jiffies;
1213 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1214 }
1215 }
1216 }
1217
1218 /*
1219 * Process options.
1220 */
1221
1222 if (!neigh)
1223 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
1224 skb->dev, 1);
1225 if (neigh) {
1226 u8 *lladdr = NULL;
1227 if (ndopts.nd_opts_src_lladdr) {
1228 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1229 skb->dev);
1230 if (!lladdr) {
1231 ND_PRINTK2(KERN_WARNING
1232 "ICMPv6 RA: invalid link-layer address length\n");
1233 goto out;
1234 }
1235 }
1236 neigh_update(neigh, lladdr, NUD_STALE,
1237 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1238 NEIGH_UPDATE_F_OVERRIDE|
1239 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1240 NEIGH_UPDATE_F_ISROUTER);
1241 }
1242
1243 #ifdef CONFIG_IPV6_ROUTE_INFO
1244 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
1245 struct nd_opt_hdr *p;
1246 for (p = ndopts.nd_opts_ri;
1247 p;
1248 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
1249 if (((struct route_info *)p)->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
1250 continue;
1251 rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3,
1252 &ipv6_hdr(skb)->saddr);
1253 }
1254 }
1255 #endif
1256
1257 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
1258 struct nd_opt_hdr *p;
1259 for (p = ndopts.nd_opts_pi;
1260 p;
1261 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1262 addrconf_prefix_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3);
1263 }
1264 }
1265
1266 if (ndopts.nd_opts_mtu) {
1267 __be32 n;
1268 u32 mtu;
1269
1270 memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1271 mtu = ntohl(n);
1272
1273 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1274 ND_PRINTK2(KERN_WARNING
1275 "ICMPv6 RA: invalid mtu: %d\n",
1276 mtu);
1277 } else if (in6_dev->cnf.mtu6 != mtu) {
1278 in6_dev->cnf.mtu6 = mtu;
1279
1280 if (rt)
1281 rt->u.dst.metrics[RTAX_MTU-1] = mtu;
1282
1283 rt6_mtu_change(skb->dev, mtu);
1284 }
1285 }
1286
1287 if (ndopts.nd_useropts) {
1288 struct nd_opt_hdr *p;
1289 for (p = ndopts.nd_useropts;
1290 p;
1291 p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) {
1292 ndisc_ra_useropt(skb, p);
1293 }
1294 }
1295
1296 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1297 ND_PRINTK2(KERN_WARNING
1298 "ICMPv6 RA: invalid RA options");
1299 }
1300 out:
1301 if (rt)
1302 dst_release(&rt->u.dst);
1303 else if (neigh)
1304 neigh_release(neigh);
1305 in6_dev_put(in6_dev);
1306 }
1307
1308 static void ndisc_redirect_rcv(struct sk_buff *skb)
1309 {
1310 struct inet6_dev *in6_dev;
1311 struct icmp6hdr *icmph;
1312 struct in6_addr *dest;
1313 struct in6_addr *target; /* new first hop to destination */
1314 struct neighbour *neigh;
1315 int on_link = 0;
1316 struct ndisc_options ndopts;
1317 int optlen;
1318 u8 *lladdr = NULL;
1319
1320 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1321 ND_PRINTK2(KERN_WARNING
1322 "ICMPv6 Redirect: source address is not link-local.\n");
1323 return;
1324 }
1325
1326 optlen = skb->tail - skb->transport_header;
1327 optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1328
1329 if (optlen < 0) {
1330 ND_PRINTK2(KERN_WARNING
1331 "ICMPv6 Redirect: packet too short\n");
1332 return;
1333 }
1334
1335 icmph = icmp6_hdr(skb);
1336 target = (struct in6_addr *) (icmph + 1);
1337 dest = target + 1;
1338
1339 if (ipv6_addr_is_multicast(dest)) {
1340 ND_PRINTK2(KERN_WARNING
1341 "ICMPv6 Redirect: destination address is multicast.\n");
1342 return;
1343 }
1344
1345 if (ipv6_addr_equal(dest, target)) {
1346 on_link = 1;
1347 } else if (ipv6_addr_type(target) !=
1348 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1349 ND_PRINTK2(KERN_WARNING
1350 "ICMPv6 Redirect: target address is not link-local unicast.\n");
1351 return;
1352 }
1353
1354 in6_dev = in6_dev_get(skb->dev);
1355 if (!in6_dev)
1356 return;
1357 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects) {
1358 in6_dev_put(in6_dev);
1359 return;
1360 }
1361
1362 /* RFC2461 8.1:
1363 * The IP source address of the Redirect MUST be the same as the current
1364 * first-hop router for the specified ICMP Destination Address.
1365 */
1366
1367 if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) {
1368 ND_PRINTK2(KERN_WARNING
1369 "ICMPv6 Redirect: invalid ND options\n");
1370 in6_dev_put(in6_dev);
1371 return;
1372 }
1373 if (ndopts.nd_opts_tgt_lladdr) {
1374 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1375 skb->dev);
1376 if (!lladdr) {
1377 ND_PRINTK2(KERN_WARNING
1378 "ICMPv6 Redirect: invalid link-layer address length\n");
1379 in6_dev_put(in6_dev);
1380 return;
1381 }
1382 }
1383
1384 neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1);
1385 if (neigh) {
1386 rt6_redirect(dest, &ipv6_hdr(skb)->daddr,
1387 &ipv6_hdr(skb)->saddr, neigh, lladdr,
1388 on_link);
1389 neigh_release(neigh);
1390 }
1391 in6_dev_put(in6_dev);
1392 }
1393
1394 void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh,
1395 struct in6_addr *target)
1396 {
1397 struct sock *sk = ndisc_socket->sk;
1398 int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1399 struct sk_buff *buff;
1400 struct icmp6hdr *icmph;
1401 struct in6_addr saddr_buf;
1402 struct in6_addr *addrp;
1403 struct net_device *dev;
1404 struct rt6_info *rt;
1405 struct dst_entry *dst;
1406 struct inet6_dev *idev;
1407 struct flowi fl;
1408 u8 *opt;
1409 int rd_len;
1410 int err;
1411 int hlen;
1412 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1413
1414 dev = skb->dev;
1415
1416 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
1417 ND_PRINTK2(KERN_WARNING
1418 "ICMPv6 Redirect: no link-local address on %s\n",
1419 dev->name);
1420 return;
1421 }
1422
1423 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
1424 ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1425 ND_PRINTK2(KERN_WARNING
1426 "ICMPv6 Redirect: target address is not link-local unicast.\n");
1427 return;
1428 }
1429
1430 icmpv6_flow_init(ndisc_socket->sk, &fl, NDISC_REDIRECT,
1431 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex);
1432
1433 dst = ip6_route_output(&init_net, NULL, &fl);
1434 if (dst == NULL)
1435 return;
1436
1437 err = xfrm_lookup(&dst, &fl, NULL, 0);
1438 if (err)
1439 return;
1440
1441 rt = (struct rt6_info *) dst;
1442
1443 if (rt->rt6i_flags & RTF_GATEWAY) {
1444 ND_PRINTK2(KERN_WARNING
1445 "ICMPv6 Redirect: destination is not a neighbour.\n");
1446 dst_release(dst);
1447 return;
1448 }
1449 if (!xrlim_allow(dst, 1*HZ)) {
1450 dst_release(dst);
1451 return;
1452 }
1453
1454 if (dev->addr_len) {
1455 read_lock_bh(&neigh->lock);
1456 if (neigh->nud_state & NUD_VALID) {
1457 memcpy(ha_buf, neigh->ha, dev->addr_len);
1458 read_unlock_bh(&neigh->lock);
1459 ha = ha_buf;
1460 len += ndisc_opt_addr_space(dev);
1461 } else
1462 read_unlock_bh(&neigh->lock);
1463 }
1464
1465 rd_len = min_t(unsigned int,
1466 IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8);
1467 rd_len &= ~0x7;
1468 len += rd_len;
1469
1470 buff = sock_alloc_send_skb(sk,
1471 (MAX_HEADER + sizeof(struct ipv6hdr) +
1472 len + LL_RESERVED_SPACE(dev)),
1473 1, &err);
1474 if (buff == NULL) {
1475 ND_PRINTK0(KERN_ERR
1476 "ICMPv6 Redirect: %s() failed to allocate an skb.\n",
1477 __func__);
1478 dst_release(dst);
1479 return;
1480 }
1481
1482 hlen = 0;
1483
1484 skb_reserve(buff, LL_RESERVED_SPACE(dev));
1485 ip6_nd_hdr(sk, buff, dev, &saddr_buf, &ipv6_hdr(skb)->saddr,
1486 IPPROTO_ICMPV6, len);
1487
1488 skb_set_transport_header(buff, skb_tail_pointer(buff) - buff->data);
1489 skb_put(buff, len);
1490 icmph = icmp6_hdr(buff);
1491
1492 memset(icmph, 0, sizeof(struct icmp6hdr));
1493 icmph->icmp6_type = NDISC_REDIRECT;
1494
1495 /*
1496 * copy target and destination addresses
1497 */
1498
1499 addrp = (struct in6_addr *)(icmph + 1);
1500 ipv6_addr_copy(addrp, target);
1501 addrp++;
1502 ipv6_addr_copy(addrp, &ipv6_hdr(skb)->daddr);
1503
1504 opt = (u8*) (addrp + 1);
1505
1506 /*
1507 * include target_address option
1508 */
1509
1510 if (ha)
1511 opt = ndisc_fill_addr_option(opt, ND_OPT_TARGET_LL_ADDR, ha,
1512 dev->addr_len, dev->type);
1513
1514 /*
1515 * build redirect option and copy skb over to the new packet.
1516 */
1517
1518 memset(opt, 0, 8);
1519 *(opt++) = ND_OPT_REDIRECT_HDR;
1520 *(opt++) = (rd_len >> 3);
1521 opt += 6;
1522
1523 memcpy(opt, ipv6_hdr(skb), rd_len - 8);
1524
1525 icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &ipv6_hdr(skb)->saddr,
1526 len, IPPROTO_ICMPV6,
1527 csum_partial((u8 *) icmph, len, 0));
1528
1529 buff->dst = dst;
1530 idev = in6_dev_get(dst->dev);
1531 IP6_INC_STATS(idev, IPSTATS_MIB_OUTREQUESTS);
1532 err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, buff, NULL, dst->dev,
1533 dst_output);
1534 if (!err) {
1535 ICMP6MSGOUT_INC_STATS(idev, NDISC_REDIRECT);
1536 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);
1537 }
1538
1539 if (likely(idev != NULL))
1540 in6_dev_put(idev);
1541 }
1542
1543 static void pndisc_redo(struct sk_buff *skb)
1544 {
1545 ndisc_recv_ns(skb);
1546 kfree_skb(skb);
1547 }
1548
1549 int ndisc_rcv(struct sk_buff *skb)
1550 {
1551 struct nd_msg *msg;
1552
1553 if (!pskb_may_pull(skb, skb->len))
1554 return 0;
1555
1556 msg = (struct nd_msg *)skb_transport_header(skb);
1557
1558 __skb_push(skb, skb->data - skb_transport_header(skb));
1559
1560 if (ipv6_hdr(skb)->hop_limit != 255) {
1561 ND_PRINTK2(KERN_WARNING
1562 "ICMPv6 NDISC: invalid hop-limit: %d\n",
1563 ipv6_hdr(skb)->hop_limit);
1564 return 0;
1565 }
1566
1567 if (msg->icmph.icmp6_code != 0) {
1568 ND_PRINTK2(KERN_WARNING
1569 "ICMPv6 NDISC: invalid ICMPv6 code: %d\n",
1570 msg->icmph.icmp6_code);
1571 return 0;
1572 }
1573
1574 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1575
1576 switch (msg->icmph.icmp6_type) {
1577 case NDISC_NEIGHBOUR_SOLICITATION:
1578 ndisc_recv_ns(skb);
1579 break;
1580
1581 case NDISC_NEIGHBOUR_ADVERTISEMENT:
1582 ndisc_recv_na(skb);
1583 break;
1584
1585 case NDISC_ROUTER_SOLICITATION:
1586 ndisc_recv_rs(skb);
1587 break;
1588
1589 case NDISC_ROUTER_ADVERTISEMENT:
1590 ndisc_router_discovery(skb);
1591 break;
1592
1593 case NDISC_REDIRECT:
1594 ndisc_redirect_rcv(skb);
1595 break;
1596 }
1597
1598 return 0;
1599 }
1600
1601 static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1602 {
1603 struct net_device *dev = ptr;
1604 struct net *net = dev->nd_net;
1605
1606 switch (event) {
1607 case NETDEV_CHANGEADDR:
1608 neigh_changeaddr(&nd_tbl, dev);
1609 fib6_run_gc(~0UL, net);
1610 break;
1611 case NETDEV_DOWN:
1612 neigh_ifdown(&nd_tbl, dev);
1613 fib6_run_gc(~0UL, net);
1614 break;
1615 default:
1616 break;
1617 }
1618
1619 return NOTIFY_DONE;
1620 }
1621
1622 static struct notifier_block ndisc_netdev_notifier = {
1623 .notifier_call = ndisc_netdev_event,
1624 };
1625
1626 #ifdef CONFIG_SYSCTL
1627 static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1628 const char *func, const char *dev_name)
1629 {
1630 static char warncomm[TASK_COMM_LEN];
1631 static int warned;
1632 if (strcmp(warncomm, current->comm) && warned < 5) {
1633 strcpy(warncomm, current->comm);
1634 printk(KERN_WARNING
1635 "process `%s' is using deprecated sysctl (%s) "
1636 "net.ipv6.neigh.%s.%s; "
1637 "Use net.ipv6.neigh.%s.%s_ms "
1638 "instead.\n",
1639 warncomm, func,
1640 dev_name, ctl->procname,
1641 dev_name, ctl->procname);
1642 warned++;
1643 }
1644 }
1645
1646 int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, struct file * filp, void __user *buffer, size_t *lenp, loff_t *ppos)
1647 {
1648 struct net_device *dev = ctl->extra1;
1649 struct inet6_dev *idev;
1650 int ret;
1651
1652 if ((strcmp(ctl->procname, "retrans_time") == 0) ||
1653 (strcmp(ctl->procname, "base_reachable_time") == 0))
1654 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1655
1656 if (strcmp(ctl->procname, "retrans_time") == 0)
1657 ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1658
1659 else if (strcmp(ctl->procname, "base_reachable_time") == 0)
1660 ret = proc_dointvec_jiffies(ctl, write,
1661 filp, buffer, lenp, ppos);
1662
1663 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
1664 (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
1665 ret = proc_dointvec_ms_jiffies(ctl, write,
1666 filp, buffer, lenp, ppos);
1667 else
1668 ret = -1;
1669
1670 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
1671 if (ctl->data == &idev->nd_parms->base_reachable_time)
1672 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1673 idev->tstamp = jiffies;
1674 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1675 in6_dev_put(idev);
1676 }
1677 return ret;
1678 }
1679
1680 static int ndisc_ifinfo_sysctl_strategy(ctl_table *ctl, int __user *name,
1681 int nlen, void __user *oldval,
1682 size_t __user *oldlenp,
1683 void __user *newval, size_t newlen)
1684 {
1685 struct net_device *dev = ctl->extra1;
1686 struct inet6_dev *idev;
1687 int ret;
1688
1689 if (ctl->ctl_name == NET_NEIGH_RETRANS_TIME ||
1690 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME)
1691 ndisc_warn_deprecated_sysctl(ctl, "procfs", dev ? dev->name : "default");
1692
1693 switch (ctl->ctl_name) {
1694 case NET_NEIGH_REACHABLE_TIME:
1695 ret = sysctl_jiffies(ctl, name, nlen,
1696 oldval, oldlenp, newval, newlen);
1697 break;
1698 case NET_NEIGH_RETRANS_TIME_MS:
1699 case NET_NEIGH_REACHABLE_TIME_MS:
1700 ret = sysctl_ms_jiffies(ctl, name, nlen,
1701 oldval, oldlenp, newval, newlen);
1702 break;
1703 default:
1704 ret = 0;
1705 }
1706
1707 if (newval && newlen && ret > 0 &&
1708 dev && (idev = in6_dev_get(dev)) != NULL) {
1709 if (ctl->ctl_name == NET_NEIGH_REACHABLE_TIME ||
1710 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME_MS)
1711 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1712 idev->tstamp = jiffies;
1713 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1714 in6_dev_put(idev);
1715 }
1716
1717 return ret;
1718 }
1719
1720 #endif
1721
1722 int __init ndisc_init(void)
1723 {
1724 struct ipv6_pinfo *np;
1725 struct sock *sk;
1726 int err;
1727
1728 err = sock_create_kern(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6, &ndisc_socket);
1729 if (err < 0) {
1730 ND_PRINTK0(KERN_ERR
1731 "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",
1732 err);
1733 ndisc_socket = NULL; /* For safety. */
1734 return err;
1735 }
1736
1737 sk = ndisc_socket->sk;
1738 np = inet6_sk(sk);
1739 sk->sk_allocation = GFP_ATOMIC;
1740 np->hop_limit = 255;
1741 /* Do not loopback ndisc messages */
1742 np->mc_loop = 0;
1743 sk->sk_prot->unhash(sk);
1744
1745 /*
1746 * Initialize the neighbour table
1747 */
1748
1749 neigh_table_init(&nd_tbl);
1750
1751 #ifdef CONFIG_SYSCTL
1752 neigh_sysctl_register(NULL, &nd_tbl.parms, NET_IPV6, NET_IPV6_NEIGH,
1753 "ipv6",
1754 &ndisc_ifinfo_sysctl_change,
1755 &ndisc_ifinfo_sysctl_strategy);
1756 #endif
1757
1758 register_netdevice_notifier(&ndisc_netdev_notifier);
1759 return 0;
1760 }
1761
1762 void ndisc_cleanup(void)
1763 {
1764 unregister_netdevice_notifier(&ndisc_netdev_notifier);
1765 #ifdef CONFIG_SYSCTL
1766 neigh_sysctl_unregister(&nd_tbl.parms);
1767 #endif
1768 neigh_table_clear(&nd_tbl);
1769 sock_release(ndisc_socket);
1770 ndisc_socket = NULL; /* For safety. */
1771 }
CJK support for tty framebuffer vt