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