blob: eb322959a3e1a41457bd0b88688068d18b12c0ec [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Neighbour Discovery for IPv6
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09003 * Linux INET6 implementation
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
5 * Authors:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09006 * Pedro Roque <roque@di.fc.ul.pt>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * 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 *
Pierre Ynard31910572007-10-10 21:22:05 -070018 * Pierre Ynard : export userland ND options
19 * through netlink (RDNSS support)
Linus Torvalds1da177e2005-04-16 15:20:36 -070020 * Lars Fenneberg : fixed MTU setting on receipt
21 * of an RA.
Linus Torvalds1da177e2005-04-16 15:20:36 -070022 * 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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070052#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
Thomas Graf18237302006-08-04 23:04:54 -070066#include <linux/if_addr.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070067#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
Pierre Ynard31910572007-10-10 21:22:05 -070082#include <net/netlink.h>
83#include <linux/rtnetlink.h>
84
Linus Torvalds1da177e2005-04-16 15:20:36 -070085#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
92static struct socket *ndisc_socket;
93
94static u32 ndisc_hash(const void *pkey, const struct net_device *dev);
95static int ndisc_constructor(struct neighbour *neigh);
96static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb);
97static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb);
98static int pndisc_constructor(struct pneigh_entry *n);
99static void pndisc_destructor(struct pneigh_entry *n);
100static void pndisc_redo(struct sk_buff *skb);
101
102static 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
112static 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
123static 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
131struct 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 */
162struct ndisc_options {
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800163 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
Pierre Ynard31910572007-10-10 21:22:05 -0700168 struct nd_opt_hdr *nd_useropts;
169 struct nd_opt_hdr *nd_useropts_end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170};
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 */
187static 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
195static 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
200static 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
221static 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
Pierre Ynard31910572007-10-10 21:22:05 -0700234static inline int ndisc_is_useropt(struct nd_opt_hdr *opt)
235{
236 return (opt->nd_opt_type == ND_OPT_RDNSS);
237}
238
239static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250static struct ndisc_options *ndisc_parse_options(u8 *opt, int opt_len,
251 struct ndisc_options *ndopts)
252{
253 struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)opt;
254
255 if (!nd_opt || opt_len < 0 || !ndopts)
256 return NULL;
257 memset(ndopts, 0, sizeof(*ndopts));
258 while (opt_len) {
259 int l;
260 if (opt_len < sizeof(struct nd_opt_hdr))
261 return NULL;
262 l = nd_opt->nd_opt_len << 3;
263 if (opt_len < l || l == 0)
264 return NULL;
265 switch (nd_opt->nd_opt_type) {
266 case ND_OPT_SOURCE_LL_ADDR:
267 case ND_OPT_TARGET_LL_ADDR:
268 case ND_OPT_MTU:
269 case ND_OPT_REDIRECT_HDR:
270 if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) {
271 ND_PRINTK2(KERN_WARNING
272 "%s(): duplicated ND6 option found: type=%d\n",
273 __FUNCTION__,
274 nd_opt->nd_opt_type);
275 } else {
276 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
277 }
278 break;
279 case ND_OPT_PREFIX_INFO:
280 ndopts->nd_opts_pi_end = nd_opt;
Stephen Hemmingercfcabdc2007-10-09 01:59:42 -0700281 if (!ndopts->nd_opt_array[nd_opt->nd_opt_type])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
283 break;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800284#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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 default:
Pierre Ynard31910572007-10-10 21:22:05 -0700292 if (ndisc_is_useropt(nd_opt)) {
293 ndopts->nd_useropts_end = nd_opt;
294 if (!ndopts->nd_useropts)
295 ndopts->nd_useropts = nd_opt;
296 } else {
297 /*
298 * Unknown options must be silently ignored,
299 * to accommodate future extension to the
300 * protocol.
301 */
302 ND_PRINTK2(KERN_NOTICE
303 "%s(): ignored unsupported option; type=%d, len=%d\n",
304 __FUNCTION__,
305 nd_opt->nd_opt_type, nd_opt->nd_opt_len);
306 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 }
308 opt_len -= l;
309 nd_opt = ((void *)nd_opt) + l;
310 }
311 return ndopts;
312}
313
314static 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
325int 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:
Rolf Manderscheida9e527e2007-12-10 13:38:41 -0700340 ipv6_ib_mc_map(addr, dev->broadcast, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 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
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900351EXPORT_SYMBOL(ndisc_mc_map);
352
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353static 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
365static 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;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700386 if (!dev->header_ops) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 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 }
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700403 if (dev->header_ops->cache)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 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
416static 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
429static 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 */
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900444static 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,
David L Stevens14878f72007-09-16 16:52:35 -0700448 int llinfo)
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900449{
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;
David L Stevens14878f72007-09-16 16:52:35 -0700458 u8 *opt, type;
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900459
David L Stevens14878f72007-09-16 16:52:35 -0700460 type = icmp6h->icmp6_type;
461
YOSHIFUJI Hideaki95e41e92007-12-06 15:43:30 -0800462 icmpv6_flow_init(ndisc_socket->sk, &fl, type,
463 saddr, daddr, dev->ifindex);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900464
YOSHIFUJI Hideaki3b009442007-12-06 16:11:48 -0800465 dst = icmp6_dst_alloc(dev, neigh, daddr);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900466 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 __FUNCTION__);
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
Patrick McHardy6e23ae22007-11-19 18:53:30 -0800521 err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev,
522 dst_output);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900523 if (!err) {
David L Stevens14878f72007-09-16 16:52:35 -0700524 ICMP6MSGOUT_INC_STATS(idev, type);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900525 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);
526 }
527
528 if (likely(idev != NULL))
529 in6_dev_put(idev);
530}
531
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532static void ndisc_send_na(struct net_device *dev, struct neighbour *neigh,
533 struct in6_addr *daddr, struct in6_addr *solicited_addr,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900534 int router, int solicited, int override, int inc_opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535{
536 struct in6_addr tmpaddr;
537 struct inet6_ifaddr *ifp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 struct in6_addr *src_addr;
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900539 struct icmp6hdr icmp6h = {
540 .icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT,
541 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542
543 /* for anycast or proxy, solicited_addr != src_addr */
Daniel Lezcano1cab3da2008-01-10 22:44:09 -0800544 ifp = ipv6_get_ifaddr(&init_net, solicited_addr, dev, 1);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900545 if (ifp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 src_addr = solicited_addr;
Neil Horman95c385b2007-04-25 17:08:10 -0700547 if (ifp->flags & IFA_F_OPTIMISTIC)
548 override = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 in6_ifa_put(ifp);
550 } else {
551 if (ipv6_dev_get_saddr(dev, daddr, &tmpaddr))
552 return;
553 src_addr = &tmpaddr;
554 }
555
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900556 icmp6h.icmp6_router = router;
557 icmp6h.icmp6_solicited = solicited;
558 icmp6h.icmp6_override = override;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900560 __ndisc_send(dev, neigh, daddr, src_addr,
561 &icmp6h, solicited_addr,
David L Stevens14878f72007-09-16 16:52:35 -0700562 inc_opt ? ND_OPT_TARGET_LL_ADDR : 0);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900563}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564
565void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh,
566 struct in6_addr *solicit,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900567 struct in6_addr *daddr, struct in6_addr *saddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 struct in6_addr addr_buf;
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900570 struct icmp6hdr icmp6h = {
571 .icmp6_type = NDISC_NEIGHBOUR_SOLICITATION,
572 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573
574 if (saddr == NULL) {
Neil Horman95c385b2007-04-25 17:08:10 -0700575 if (ipv6_get_lladdr(dev, &addr_buf,
576 (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 return;
578 saddr = &addr_buf;
579 }
580
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900581 __ndisc_send(dev, neigh, daddr, saddr,
582 &icmp6h, solicit,
David L Stevens14878f72007-09-16 16:52:35 -0700583 !ipv6_addr_any(saddr) ? ND_OPT_SOURCE_LL_ADDR : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584}
585
586void ndisc_send_rs(struct net_device *dev, struct in6_addr *saddr,
587 struct in6_addr *daddr)
588{
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900589 struct icmp6hdr icmp6h = {
590 .icmp6_type = NDISC_ROUTER_SOLICITATION,
591 };
Neil Horman95c385b2007-04-25 17:08:10 -0700592 int send_sllao = dev->addr_len;
Neil Horman95c385b2007-04-25 17:08:10 -0700593
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
Joe Perchesbea85192007-12-20 14:01:35 -0800601 * suppress the inclusion of the sllao.
Neil Horman95c385b2007-04-25 17:08:10 -0700602 */
603 if (send_sllao) {
Daniel Lezcano1cab3da2008-01-10 22:44:09 -0800604 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(&init_net, saddr,
605 dev, 1);
Neil Horman95c385b2007-04-25 17:08:10 -0700606 if (ifp) {
607 if (ifp->flags & IFA_F_OPTIMISTIC) {
YOSHIFUJI Hideakica043562007-02-28 23:13:20 +0900608 send_sllao = 0;
Neil Horman95c385b2007-04-25 17:08:10 -0700609 }
YOSHIFUJI Hideakica043562007-02-28 23:13:20 +0900610 in6_ifa_put(ifp);
Neil Horman95c385b2007-04-25 17:08:10 -0700611 } else {
612 send_sllao = 0;
613 }
614 }
615#endif
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900616 __ndisc_send(dev, NULL, daddr, saddr,
617 &icmp6h, NULL,
David L Stevens14878f72007-09-16 16:52:35 -0700618 send_sllao ? ND_OPT_SOURCE_LL_ADDR : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619}
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900620
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621
622static 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
634static 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
Daniel Lezcanobfeade02008-01-10 22:43:18 -0800642 if (skb && ipv6_chk_addr(&init_net, &ipv6_hdr(skb)->saddr, dev, 1))
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700643 saddr = &ipv6_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644
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: "
Joe Perches46b86a22006-01-13 14:29:07 -0800649 NIP6_FMT "\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 __FUNCTION__,
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
664static void ndisc_recv_ns(struct sk_buff *skb)
665{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700666 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700667 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
668 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 u8 *lladdr = NULL;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700670 u32 ndoptlen = skb->tail - (skb->transport_header +
671 offsetof(struct nd_msg, opt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 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;
Ville Nuorvala62dd9312006-09-22 14:43:19 -0700677 struct pneigh_entry *pneigh = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 int dad = ipv6_addr_any(saddr);
679 int inc;
Ville Nuorvala62dd9312006-09-22 14:43:19 -0700680 int is_router;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681
682 if (ipv6_addr_is_multicast(&msg->target)) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900683 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 "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)) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900703 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 "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:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900717 * If the IP source address is the unspecified address,
718 * there MUST NOT be source link-layer address option
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 * in the message.
720 */
721 if (dad) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900722 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 "ICMPv6 NS: bad DAD packet (link-layer address option)\n");
724 return;
725 }
726 }
727
728 inc = ipv6_addr_is_multicast(daddr);
729
Daniel Lezcano1cab3da2008-01-10 22:44:09 -0800730 if ((ifp = ipv6_get_ifaddr(&init_net, &msg->target, dev, 1)) != NULL) {
Neil Horman95c385b2007-04-25 17:08:10 -0700731
732 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
733 if (dad) {
734 if (dev->type == ARPHRD_IEEE802_TR) {
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -0700735 const unsigned char *sadr;
736 sadr = skb_mac_header(skb);
Neil Horman95c385b2007-04-25 17:08:10 -0700737 if (((sadr[8] ^ dev->dev_addr[0]) & 0x7f) == 0 &&
738 sadr[9] == dev->dev_addr[1] &&
739 sadr[10] == dev->dev_addr[2] &&
740 sadr[11] == dev->dev_addr[3] &&
741 sadr[12] == dev->dev_addr[4] &&
742 sadr[13] == dev->dev_addr[5]) {
743 /* looped-back to us */
744 goto out;
745 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 }
Neil Horman95c385b2007-04-25 17:08:10 -0700747
748 /*
749 * We are colliding with another node
750 * who is doing DAD
751 * so fail our DAD process
752 */
753 addrconf_dad_failure(ifp);
Denis V. Lunev9e3be4b2007-09-11 11:04:49 +0200754 return;
Neil Horman95c385b2007-04-25 17:08:10 -0700755 } else {
756 /*
757 * This is not a dad solicitation.
758 * If we are an optimistic node,
759 * we should respond.
760 * Otherwise, we should ignore it.
761 */
762 if (!(ifp->flags & IFA_F_OPTIMISTIC))
763 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 }
766
767 idev = ifp->idev;
768 } else {
769 idev = in6_dev_get(dev);
770 if (!idev) {
771 /* XXX: count this drop? */
772 return;
773 }
774
775 if (ipv6_chk_acast_addr(dev, &msg->target) ||
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900776 (idev->cnf.forwarding &&
YOSHIFUJI Hideakifbea49e2006-09-22 14:43:49 -0700777 (ipv6_devconf.proxy_ndp || idev->cnf.proxy_ndp) &&
Eric W. Biederman426b5302008-01-24 00:13:18 -0800778 (pneigh = pneigh_lookup(&nd_tbl, &init_net,
Ville Nuorvala62dd9312006-09-22 14:43:19 -0700779 &msg->target, dev, 0)) != NULL)) {
Patrick McHardya61bbcf2005-08-14 17:24:31 -0700780 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 skb->pkt_type != PACKET_HOST &&
782 inc != 0 &&
783 idev->nd_parms->proxy_delay != 0) {
784 /*
785 * for anycast or proxy,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900786 * sender should delay its response
787 * by a random time between 0 and
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 * MAX_ANYCAST_DELAY_TIME seconds.
789 * (RFC2461) -- yoshfuji
790 */
791 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
792 if (n)
793 pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
794 goto out;
795 }
796 } else
797 goto out;
798 }
799
YOSHIFUJI Hideakifc26d0a2006-09-22 14:44:53 -0700800 is_router = !!(pneigh ? pneigh->flags & NTF_ROUTER : idev->cnf.forwarding);
Ville Nuorvala62dd9312006-09-22 14:43:19 -0700801
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 if (dad) {
803 struct in6_addr maddr;
804
805 ipv6_addr_all_nodes(&maddr);
806 ndisc_send_na(dev, NULL, &maddr, &msg->target,
Ville Nuorvala62dd9312006-09-22 14:43:19 -0700807 is_router, 0, (ifp != NULL), 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 goto out;
809 }
810
811 if (inc)
812 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
813 else
814 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
815
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900816 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 * update / create cache entry
818 * for the source address
819 */
820 neigh = __neigh_lookup(&nd_tbl, saddr, dev,
821 !inc || lladdr || !dev->addr_len);
822 if (neigh)
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900823 neigh_update(neigh, lladdr, NUD_STALE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 NEIGH_UPDATE_F_WEAK_OVERRIDE|
825 NEIGH_UPDATE_F_OVERRIDE);
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700826 if (neigh || !dev->header_ops) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 ndisc_send_na(dev, neigh, saddr, &msg->target,
Ville Nuorvala62dd9312006-09-22 14:43:19 -0700828 is_router,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 1, (ifp != NULL && inc), inc);
830 if (neigh)
831 neigh_release(neigh);
832 }
833
834out:
835 if (ifp)
836 in6_ifa_put(ifp);
837 else
838 in6_dev_put(idev);
839
840 return;
841}
842
843static void ndisc_recv_na(struct sk_buff *skb)
844{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700845 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700846 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
847 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 u8 *lladdr = NULL;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700849 u32 ndoptlen = skb->tail - (skb->transport_header +
850 offsetof(struct nd_msg, opt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 struct ndisc_options ndopts;
852 struct net_device *dev = skb->dev;
853 struct inet6_ifaddr *ifp;
854 struct neighbour *neigh;
855
856 if (skb->len < sizeof(struct nd_msg)) {
857 ND_PRINTK2(KERN_WARNING
858 "ICMPv6 NA: packet too short\n");
859 return;
860 }
861
862 if (ipv6_addr_is_multicast(&msg->target)) {
863 ND_PRINTK2(KERN_WARNING
864 "ICMPv6 NA: target address is multicast.\n");
865 return;
866 }
867
868 if (ipv6_addr_is_multicast(daddr) &&
869 msg->icmph.icmp6_solicited) {
870 ND_PRINTK2(KERN_WARNING
871 "ICMPv6 NA: solicited NA is multicasted.\n");
872 return;
873 }
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900874
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
876 ND_PRINTK2(KERN_WARNING
877 "ICMPv6 NS: invalid ND option\n");
878 return;
879 }
880 if (ndopts.nd_opts_tgt_lladdr) {
881 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
882 if (!lladdr) {
883 ND_PRINTK2(KERN_WARNING
884 "ICMPv6 NA: invalid link-layer address length\n");
885 return;
886 }
887 }
Daniel Lezcano1cab3da2008-01-10 22:44:09 -0800888 if ((ifp = ipv6_get_ifaddr(&init_net, &msg->target, dev, 1))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 if (ifp->flags & IFA_F_TENTATIVE) {
890 addrconf_dad_failure(ifp);
891 return;
892 }
893 /* What should we make now? The advertisement
894 is invalid, but ndisc specs say nothing
895 about it. It could be misconfiguration, or
896 an smart proxy agent tries to help us :-)
897 */
898 ND_PRINTK1(KERN_WARNING
899 "ICMPv6 NA: someone advertises our address on %s!\n",
900 ifp->idev->dev->name);
901 in6_ifa_put(ifp);
902 return;
903 }
904 neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
905
906 if (neigh) {
907 u8 old_flags = neigh->flags;
908
909 if (neigh->nud_state & NUD_FAILED)
910 goto out;
911
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -0700912 /*
913 * Don't update the neighbor cache entry on a proxy NA from
914 * ourselves because either the proxied node is off link or it
915 * has already sent a NA to us.
916 */
917 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
YOSHIFUJI Hideakifbea49e2006-09-22 14:43:49 -0700918 ipv6_devconf.forwarding && ipv6_devconf.proxy_ndp &&
Eric W. Biederman426b5302008-01-24 00:13:18 -0800919 pneigh_lookup(&nd_tbl, &init_net, &msg->target, dev, 0)) {
YOSHIFUJI Hideakifbea49e2006-09-22 14:43:49 -0700920 /* XXX: idev->cnf.prixy_ndp */
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -0700921 goto out;
YOSHIFUJI Hideakifbea49e2006-09-22 14:43:49 -0700922 }
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -0700923
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 neigh_update(neigh, lladdr,
925 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
926 NEIGH_UPDATE_F_WEAK_OVERRIDE|
927 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
928 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
929 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));
930
931 if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
932 /*
933 * Change: router to host
934 */
935 struct rt6_info *rt;
936 rt = rt6_get_dflt_router(saddr, dev);
937 if (rt)
Thomas Grafe0a1ad732006-08-22 00:00:21 -0700938 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 }
940
941out:
942 neigh_release(neigh);
943 }
944}
945
946static void ndisc_recv_rs(struct sk_buff *skb)
947{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700948 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
950 struct neighbour *neigh;
951 struct inet6_dev *idev;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700952 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953 struct ndisc_options ndopts;
954 u8 *lladdr = NULL;
955
956 if (skb->len < sizeof(*rs_msg))
957 return;
958
959 idev = in6_dev_get(skb->dev);
960 if (!idev) {
961 if (net_ratelimit())
962 ND_PRINTK1("ICMP6 RS: can't find in6 device\n");
963 return;
964 }
965
966 /* Don't accept RS if we're not in router mode */
967 if (!idev->cnf.forwarding)
968 goto out;
969
970 /*
971 * Don't update NCE if src = ::;
972 * this implies that the source node has no ip address assigned yet.
973 */
974 if (ipv6_addr_any(saddr))
975 goto out;
976
977 /* Parse ND options */
978 if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {
979 if (net_ratelimit())
980 ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n");
981 goto out;
982 }
983
984 if (ndopts.nd_opts_src_lladdr) {
985 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
986 skb->dev);
987 if (!lladdr)
988 goto out;
989 }
990
991 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
992 if (neigh) {
993 neigh_update(neigh, lladdr, NUD_STALE,
994 NEIGH_UPDATE_F_WEAK_OVERRIDE|
995 NEIGH_UPDATE_F_OVERRIDE|
996 NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
997 neigh_release(neigh);
998 }
999out:
1000 in6_dev_put(idev);
1001}
1002
Pierre Ynard31910572007-10-10 21:22:05 -07001003static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt)
1004{
1005 struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra);
1006 struct sk_buff *skb;
1007 struct nlmsghdr *nlh;
1008 struct nduseroptmsg *ndmsg;
1009 int err;
1010 int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg)
1011 + (opt->nd_opt_len << 3));
1012 size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr));
1013
1014 skb = nlmsg_new(msg_size, GFP_ATOMIC);
1015 if (skb == NULL) {
1016 err = -ENOBUFS;
1017 goto errout;
1018 }
1019
1020 nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0);
1021 if (nlh == NULL) {
1022 goto nla_put_failure;
1023 }
1024
1025 ndmsg = nlmsg_data(nlh);
1026 ndmsg->nduseropt_family = AF_INET6;
Pierre Ynarddbb2ed22007-11-12 17:58:35 -08001027 ndmsg->nduseropt_ifindex = ra->dev->ifindex;
Pierre Ynard31910572007-10-10 21:22:05 -07001028 ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type;
1029 ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code;
1030 ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3;
1031
1032 memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3);
1033
1034 NLA_PUT(skb, NDUSEROPT_SRCADDR, sizeof(struct in6_addr),
1035 &ipv6_hdr(ra)->saddr);
1036 nlmsg_end(skb, nlh);
1037
Denis V. Lunev97c53ca2007-11-19 22:26:51 -08001038 err = rtnl_notify(skb, &init_net, 0, RTNLGRP_ND_USEROPT, NULL,
1039 GFP_ATOMIC);
Pierre Ynard31910572007-10-10 21:22:05 -07001040 if (err < 0)
1041 goto errout;
1042
1043 return;
1044
1045nla_put_failure:
1046 nlmsg_free(skb);
1047 err = -EMSGSIZE;
1048errout:
Denis V. Lunev97c53ca2007-11-19 22:26:51 -08001049 rtnl_set_sk_err(&init_net, RTNLGRP_ND_USEROPT, err);
Pierre Ynard31910572007-10-10 21:22:05 -07001050}
1051
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052static void ndisc_router_discovery(struct sk_buff *skb)
1053{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001054 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 struct neighbour *neigh = NULL;
1056 struct inet6_dev *in6_dev;
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001057 struct rt6_info *rt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058 int lifetime;
1059 struct ndisc_options ndopts;
1060 int optlen;
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001061 unsigned int pref = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062
1063 __u8 * opt = (__u8 *)(ra_msg + 1);
1064
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001065 optlen = (skb->tail - skb->transport_header) - sizeof(struct ra_msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001067 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 ND_PRINTK2(KERN_WARNING
1069 "ICMPv6 RA: source address is not link-local.\n");
1070 return;
1071 }
1072 if (optlen < 0) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001073 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 "ICMPv6 RA: packet too short\n");
1075 return;
1076 }
1077
1078 /*
1079 * set the RA_RECV flag in the interface
1080 */
1081
1082 in6_dev = in6_dev_get(skb->dev);
1083 if (in6_dev == NULL) {
1084 ND_PRINTK0(KERN_ERR
1085 "ICMPv6 RA: can't find inet6 device for %s.\n",
1086 skb->dev->name);
1087 return;
1088 }
1089 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_ra) {
1090 in6_dev_put(in6_dev);
1091 return;
1092 }
1093
1094 if (!ndisc_parse_options(opt, optlen, &ndopts)) {
1095 in6_dev_put(in6_dev);
1096 ND_PRINTK2(KERN_WARNING
1097 "ICMP6 RA: invalid ND options\n");
1098 return;
1099 }
1100
1101 if (in6_dev->if_flags & IF_RS_SENT) {
1102 /*
1103 * flag that an RA was received after an RS was sent
1104 * out on this interface.
1105 */
1106 in6_dev->if_flags |= IF_RA_RCVD;
1107 }
1108
1109 /*
1110 * Remember the managed/otherconf flags from most recently
1111 * received RA message (RFC 2462) -- yoshfuji
1112 */
1113 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1114 IF_RA_OTHERCONF)) |
1115 (ra_msg->icmph.icmp6_addrconf_managed ?
1116 IF_RA_MANAGED : 0) |
1117 (ra_msg->icmph.icmp6_addrconf_other ?
1118 IF_RA_OTHERCONF : 0);
1119
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001120 if (!in6_dev->cnf.accept_ra_defrtr)
1121 goto skip_defrtr;
1122
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1124
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001125#ifdef CONFIG_IPV6_ROUTER_PREF
1126 pref = ra_msg->icmph.icmp6_router_pref;
1127 /* 10b is handled as if it were 00b (medium) */
YOSHIFUJI Hideaki930d6ff2006-03-20 17:05:30 -08001128 if (pref == ICMPV6_ROUTER_PREF_INVALID ||
YOSHIFUJI Hideaki6d5b78c2007-06-22 16:07:04 -07001129 !in6_dev->cnf.accept_ra_rtr_pref)
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001130 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1131#endif
1132
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001133 rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134
1135 if (rt)
1136 neigh = rt->rt6i_nexthop;
1137
1138 if (rt && lifetime == 0) {
1139 neigh_clone(neigh);
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001140 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 rt = NULL;
1142 }
1143
1144 if (rt == NULL && lifetime) {
1145 ND_PRINTK3(KERN_DEBUG
1146 "ICMPv6 RA: adding default router.\n");
1147
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001148 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149 if (rt == NULL) {
1150 ND_PRINTK0(KERN_ERR
1151 "ICMPv6 RA: %s() failed to add default route.\n",
1152 __FUNCTION__);
1153 in6_dev_put(in6_dev);
1154 return;
1155 }
1156
1157 neigh = rt->rt6i_nexthop;
1158 if (neigh == NULL) {
1159 ND_PRINTK0(KERN_ERR
1160 "ICMPv6 RA: %s() got default router without neighbour.\n",
1161 __FUNCTION__);
1162 dst_release(&rt->u.dst);
1163 in6_dev_put(in6_dev);
1164 return;
1165 }
1166 neigh->flags |= NTF_ROUTER;
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001167 } else if (rt) {
1168 rt->rt6i_flags |= (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 }
1170
1171 if (rt)
1172 rt->rt6i_expires = jiffies + (HZ * lifetime);
1173
1174 if (ra_msg->icmph.icmp6_hop_limit) {
1175 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1176 if (rt)
1177 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = ra_msg->icmph.icmp6_hop_limit;
1178 }
1179
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001180skip_defrtr:
1181
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 /*
1183 * Update Reachable Time and Retrans Timer
1184 */
1185
1186 if (in6_dev->nd_parms) {
1187 unsigned long rtime = ntohl(ra_msg->retrans_timer);
1188
1189 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1190 rtime = (rtime*HZ)/1000;
1191 if (rtime < HZ/10)
1192 rtime = HZ/10;
1193 in6_dev->nd_parms->retrans_time = rtime;
1194 in6_dev->tstamp = jiffies;
1195 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1196 }
1197
1198 rtime = ntohl(ra_msg->reachable_time);
1199 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1200 rtime = (rtime*HZ)/1000;
1201
1202 if (rtime < HZ/10)
1203 rtime = HZ/10;
1204
1205 if (rtime != in6_dev->nd_parms->base_reachable_time) {
1206 in6_dev->nd_parms->base_reachable_time = rtime;
1207 in6_dev->nd_parms->gc_staletime = 3 * rtime;
1208 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1209 in6_dev->tstamp = jiffies;
1210 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1211 }
1212 }
1213 }
1214
1215 /*
1216 * Process options.
1217 */
1218
1219 if (!neigh)
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001220 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 skb->dev, 1);
1222 if (neigh) {
1223 u8 *lladdr = NULL;
1224 if (ndopts.nd_opts_src_lladdr) {
1225 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1226 skb->dev);
1227 if (!lladdr) {
1228 ND_PRINTK2(KERN_WARNING
1229 "ICMPv6 RA: invalid link-layer address length\n");
1230 goto out;
1231 }
1232 }
1233 neigh_update(neigh, lladdr, NUD_STALE,
1234 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1235 NEIGH_UPDATE_F_OVERRIDE|
1236 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1237 NEIGH_UPDATE_F_ISROUTER);
1238 }
1239
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001240#ifdef CONFIG_IPV6_ROUTE_INFO
YOSHIFUJI Hideaki09c884d2006-03-20 17:07:03 -08001241 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001242 struct nd_opt_hdr *p;
1243 for (p = ndopts.nd_opts_ri;
1244 p;
1245 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
YOSHIFUJI Hideaki09c884d2006-03-20 17:07:03 -08001246 if (((struct route_info *)p)->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
1247 continue;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001248 rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001249 &ipv6_hdr(skb)->saddr);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001250 }
1251 }
1252#endif
1253
YOSHIFUJI Hideakic4fd30e2006-03-20 16:55:26 -08001254 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 struct nd_opt_hdr *p;
1256 for (p = ndopts.nd_opts_pi;
1257 p;
1258 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1259 addrconf_prefix_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3);
1260 }
1261 }
1262
1263 if (ndopts.nd_opts_mtu) {
Al Viroe69a4ad2006-11-14 20:56:00 -08001264 __be32 n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 u32 mtu;
1266
Al Viroe69a4ad2006-11-14 20:56:00 -08001267 memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1268 mtu = ntohl(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269
1270 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1271 ND_PRINTK2(KERN_WARNING
1272 "ICMPv6 RA: invalid mtu: %d\n",
1273 mtu);
1274 } else if (in6_dev->cnf.mtu6 != mtu) {
1275 in6_dev->cnf.mtu6 = mtu;
1276
1277 if (rt)
1278 rt->u.dst.metrics[RTAX_MTU-1] = mtu;
1279
1280 rt6_mtu_change(skb->dev, mtu);
1281 }
1282 }
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001283
Pierre Ynard31910572007-10-10 21:22:05 -07001284 if (ndopts.nd_useropts) {
YOSHIFUJI Hideaki61cf46a2008-01-22 17:32:53 +09001285 struct nd_opt_hdr *p;
1286 for (p = ndopts.nd_useropts;
1287 p;
1288 p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) {
1289 ndisc_ra_useropt(skb, p);
Pierre Ynard31910572007-10-10 21:22:05 -07001290 }
1291 }
1292
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1294 ND_PRINTK2(KERN_WARNING
1295 "ICMPv6 RA: invalid RA options");
1296 }
1297out:
1298 if (rt)
1299 dst_release(&rt->u.dst);
1300 else if (neigh)
1301 neigh_release(neigh);
1302 in6_dev_put(in6_dev);
1303}
1304
1305static void ndisc_redirect_rcv(struct sk_buff *skb)
1306{
1307 struct inet6_dev *in6_dev;
1308 struct icmp6hdr *icmph;
1309 struct in6_addr *dest;
1310 struct in6_addr *target; /* new first hop to destination */
1311 struct neighbour *neigh;
1312 int on_link = 0;
1313 struct ndisc_options ndopts;
1314 int optlen;
1315 u8 *lladdr = NULL;
1316
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001317 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 ND_PRINTK2(KERN_WARNING
1319 "ICMPv6 Redirect: source address is not link-local.\n");
1320 return;
1321 }
1322
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001323 optlen = skb->tail - skb->transport_header;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1325
1326 if (optlen < 0) {
1327 ND_PRINTK2(KERN_WARNING
1328 "ICMPv6 Redirect: packet too short\n");
1329 return;
1330 }
1331
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -03001332 icmph = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 target = (struct in6_addr *) (icmph + 1);
1334 dest = target + 1;
1335
1336 if (ipv6_addr_is_multicast(dest)) {
1337 ND_PRINTK2(KERN_WARNING
1338 "ICMPv6 Redirect: destination address is multicast.\n");
1339 return;
1340 }
1341
1342 if (ipv6_addr_equal(dest, target)) {
1343 on_link = 1;
Brian Haleybf0b48d2007-10-08 00:12:05 -07001344 } else if (ipv6_addr_type(target) !=
1345 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001346 ND_PRINTK2(KERN_WARNING
Brian Haleybf0b48d2007-10-08 00:12:05 -07001347 "ICMPv6 Redirect: target address is not link-local unicast.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348 return;
1349 }
1350
1351 in6_dev = in6_dev_get(skb->dev);
1352 if (!in6_dev)
1353 return;
1354 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects) {
1355 in6_dev_put(in6_dev);
1356 return;
1357 }
1358
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001359 /* RFC2461 8.1:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 * The IP source address of the Redirect MUST be the same as the current
1361 * first-hop router for the specified ICMP Destination Address.
1362 */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001363
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) {
1365 ND_PRINTK2(KERN_WARNING
1366 "ICMPv6 Redirect: invalid ND options\n");
1367 in6_dev_put(in6_dev);
1368 return;
1369 }
1370 if (ndopts.nd_opts_tgt_lladdr) {
1371 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1372 skb->dev);
1373 if (!lladdr) {
1374 ND_PRINTK2(KERN_WARNING
1375 "ICMPv6 Redirect: invalid link-layer address length\n");
1376 in6_dev_put(in6_dev);
1377 return;
1378 }
1379 }
1380
1381 neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1);
1382 if (neigh) {
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001383 rt6_redirect(dest, &ipv6_hdr(skb)->daddr,
1384 &ipv6_hdr(skb)->saddr, neigh, lladdr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385 on_link);
1386 neigh_release(neigh);
1387 }
1388 in6_dev_put(in6_dev);
1389}
1390
1391void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh,
1392 struct in6_addr *target)
1393{
1394 struct sock *sk = ndisc_socket->sk;
1395 int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1396 struct sk_buff *buff;
1397 struct icmp6hdr *icmph;
1398 struct in6_addr saddr_buf;
1399 struct in6_addr *addrp;
1400 struct net_device *dev;
1401 struct rt6_info *rt;
1402 struct dst_entry *dst;
1403 struct inet6_dev *idev;
1404 struct flowi fl;
1405 u8 *opt;
1406 int rd_len;
1407 int err;
1408 int hlen;
1409 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1410
1411 dev = skb->dev;
1412
Neil Horman95c385b2007-04-25 17:08:10 -07001413 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 ND_PRINTK2(KERN_WARNING
1415 "ICMPv6 Redirect: no link-local address on %s\n",
1416 dev->name);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001417 return;
1418 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001420 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
Brian Haleybf0b48d2007-10-08 00:12:05 -07001421 ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
Li Yewang29556522007-01-30 14:33:20 -08001422 ND_PRINTK2(KERN_WARNING
Brian Haleybf0b48d2007-10-08 00:12:05 -07001423 "ICMPv6 Redirect: target address is not link-local unicast.\n");
Li Yewang29556522007-01-30 14:33:20 -08001424 return;
1425 }
1426
YOSHIFUJI Hideaki95e41e92007-12-06 15:43:30 -08001427 icmpv6_flow_init(ndisc_socket->sk, &fl, NDISC_REDIRECT,
1428 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429
1430 dst = ip6_route_output(NULL, &fl);
1431 if (dst == NULL)
1432 return;
1433
1434 err = xfrm_lookup(&dst, &fl, NULL, 0);
Patrick McHardye1044112005-09-08 15:11:55 -07001435 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437
1438 rt = (struct rt6_info *) dst;
1439
1440 if (rt->rt6i_flags & RTF_GATEWAY) {
1441 ND_PRINTK2(KERN_WARNING
1442 "ICMPv6 Redirect: destination is not a neighbour.\n");
1443 dst_release(dst);
1444 return;
1445 }
1446 if (!xrlim_allow(dst, 1*HZ)) {
1447 dst_release(dst);
1448 return;
1449 }
1450
1451 if (dev->addr_len) {
1452 read_lock_bh(&neigh->lock);
1453 if (neigh->nud_state & NUD_VALID) {
1454 memcpy(ha_buf, neigh->ha, dev->addr_len);
1455 read_unlock_bh(&neigh->lock);
1456 ha = ha_buf;
1457 len += ndisc_opt_addr_space(dev);
1458 } else
1459 read_unlock_bh(&neigh->lock);
1460 }
1461
1462 rd_len = min_t(unsigned int,
1463 IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8);
1464 rd_len &= ~0x7;
1465 len += rd_len;
1466
David S. Millerd54a81d2006-12-02 21:00:06 -08001467 buff = sock_alloc_send_skb(sk,
1468 (MAX_HEADER + sizeof(struct ipv6hdr) +
1469 len + LL_RESERVED_SPACE(dev)),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470 1, &err);
1471 if (buff == NULL) {
1472 ND_PRINTK0(KERN_ERR
1473 "ICMPv6 Redirect: %s() failed to allocate an skb.\n",
1474 __FUNCTION__);
1475 dst_release(dst);
1476 return;
1477 }
1478
1479 hlen = 0;
1480
1481 skb_reserve(buff, LL_RESERVED_SPACE(dev));
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001482 ip6_nd_hdr(sk, buff, dev, &saddr_buf, &ipv6_hdr(skb)->saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483 IPPROTO_ICMPV6, len);
1484
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001485 skb_set_transport_header(buff, skb_tail_pointer(buff) - buff->data);
Arnaldo Carvalho de Melod10ba342007-03-14 21:05:37 -03001486 skb_put(buff, len);
1487 icmph = icmp6_hdr(buff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488
1489 memset(icmph, 0, sizeof(struct icmp6hdr));
1490 icmph->icmp6_type = NDISC_REDIRECT;
1491
1492 /*
1493 * copy target and destination addresses
1494 */
1495
1496 addrp = (struct in6_addr *)(icmph + 1);
1497 ipv6_addr_copy(addrp, target);
1498 addrp++;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001499 ipv6_addr_copy(addrp, &ipv6_hdr(skb)->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500
1501 opt = (u8*) (addrp + 1);
1502
1503 /*
1504 * include target_address option
1505 */
1506
1507 if (ha)
1508 opt = ndisc_fill_addr_option(opt, ND_OPT_TARGET_LL_ADDR, ha,
1509 dev->addr_len, dev->type);
1510
1511 /*
1512 * build redirect option and copy skb over to the new packet.
1513 */
1514
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001515 memset(opt, 0, 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 *(opt++) = ND_OPT_REDIRECT_HDR;
1517 *(opt++) = (rd_len >> 3);
1518 opt += 6;
1519
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001520 memcpy(opt, ipv6_hdr(skb), rd_len - 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001522 icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &ipv6_hdr(skb)->saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523 len, IPPROTO_ICMPV6,
1524 csum_partial((u8 *) icmph, len, 0));
1525
1526 buff->dst = dst;
1527 idev = in6_dev_get(dst->dev);
YOSHIFUJI Hideakia11d2062006-11-04 20:11:37 +09001528 IP6_INC_STATS(idev, IPSTATS_MIB_OUTREQUESTS);
Patrick McHardy6e23ae22007-11-19 18:53:30 -08001529 err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, buff, NULL, dst->dev,
1530 dst_output);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531 if (!err) {
David L Stevens14878f72007-09-16 16:52:35 -07001532 ICMP6MSGOUT_INC_STATS(idev, NDISC_REDIRECT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);
1534 }
1535
1536 if (likely(idev != NULL))
1537 in6_dev_put(idev);
1538}
1539
1540static void pndisc_redo(struct sk_buff *skb)
1541{
YOSHIFUJI Hideaki140e26fc2005-10-05 12:11:41 -07001542 ndisc_recv_ns(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001543 kfree_skb(skb);
1544}
1545
1546int ndisc_rcv(struct sk_buff *skb)
1547{
1548 struct nd_msg *msg;
1549
1550 if (!pskb_may_pull(skb, skb->len))
1551 return 0;
1552
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001553 msg = (struct nd_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001555 __skb_push(skb, skb->data - skb_transport_header(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001557 if (ipv6_hdr(skb)->hop_limit != 255) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558 ND_PRINTK2(KERN_WARNING
1559 "ICMPv6 NDISC: invalid hop-limit: %d\n",
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001560 ipv6_hdr(skb)->hop_limit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 return 0;
1562 }
1563
1564 if (msg->icmph.icmp6_code != 0) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001565 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566 "ICMPv6 NDISC: invalid ICMPv6 code: %d\n",
1567 msg->icmph.icmp6_code);
1568 return 0;
1569 }
1570
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001571 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1572
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573 switch (msg->icmph.icmp6_type) {
1574 case NDISC_NEIGHBOUR_SOLICITATION:
1575 ndisc_recv_ns(skb);
1576 break;
1577
1578 case NDISC_NEIGHBOUR_ADVERTISEMENT:
1579 ndisc_recv_na(skb);
1580 break;
1581
1582 case NDISC_ROUTER_SOLICITATION:
1583 ndisc_recv_rs(skb);
1584 break;
1585
1586 case NDISC_ROUTER_ADVERTISEMENT:
1587 ndisc_router_discovery(skb);
1588 break;
1589
1590 case NDISC_REDIRECT:
1591 ndisc_redirect_rcv(skb);
1592 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07001593 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594
1595 return 0;
1596}
1597
1598static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1599{
1600 struct net_device *dev = ptr;
1601
Eric W. Biedermane9dc8652007-09-12 13:02:17 +02001602 if (dev->nd_net != &init_net)
1603 return NOTIFY_DONE;
1604
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605 switch (event) {
1606 case NETDEV_CHANGEADDR:
1607 neigh_changeaddr(&nd_tbl, dev);
1608 fib6_run_gc(~0UL);
1609 break;
1610 case NETDEV_DOWN:
1611 neigh_ifdown(&nd_tbl, dev);
1612 fib6_run_gc(~0UL);
1613 break;
1614 default:
1615 break;
1616 }
1617
1618 return NOTIFY_DONE;
1619}
1620
1621static struct notifier_block ndisc_netdev_notifier = {
1622 .notifier_call = ndisc_netdev_event,
1623};
1624
1625#ifdef CONFIG_SYSCTL
1626static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1627 const char *func, const char *dev_name)
1628{
1629 static char warncomm[TASK_COMM_LEN];
1630 static int warned;
1631 if (strcmp(warncomm, current->comm) && warned < 5) {
1632 strcpy(warncomm, current->comm);
1633 printk(KERN_WARNING
1634 "process `%s' is using deprecated sysctl (%s) "
1635 "net.ipv6.neigh.%s.%s; "
1636 "Use net.ipv6.neigh.%s.%s_ms "
1637 "instead.\n",
1638 warncomm, func,
1639 dev_name, ctl->procname,
1640 dev_name, ctl->procname);
1641 warned++;
1642 }
1643}
1644
1645int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, struct file * filp, void __user *buffer, size_t *lenp, loff_t *ppos)
1646{
1647 struct net_device *dev = ctl->extra1;
1648 struct inet6_dev *idev;
1649 int ret;
1650
Eric W. Biedermand12af672007-10-18 03:05:25 -07001651 if ((strcmp(ctl->procname, "retrans_time") == 0) ||
1652 (strcmp(ctl->procname, "base_reachable_time") == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1654
Eric W. Biedermand12af672007-10-18 03:05:25 -07001655 if (strcmp(ctl->procname, "retrans_time") == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001657
1658 else if (strcmp(ctl->procname, "base_reachable_time") == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659 ret = proc_dointvec_jiffies(ctl, write,
1660 filp, buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001661
1662 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
YOSHIFUJI Hideakiad02ac12007-10-29 01:32:23 -07001663 (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664 ret = proc_dointvec_ms_jiffies(ctl, write,
1665 filp, buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001666 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 ret = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668
1669 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
Eric W. Biedermand12af672007-10-18 03:05:25 -07001670 if (ctl->data == &idev->nd_parms->base_reachable_time)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1672 idev->tstamp = jiffies;
1673 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1674 in6_dev_put(idev);
1675 }
1676 return ret;
1677}
1678
1679static int ndisc_ifinfo_sysctl_strategy(ctl_table *ctl, int __user *name,
1680 int nlen, void __user *oldval,
1681 size_t __user *oldlenp,
Alexey Dobriyan1f29bcd2006-12-10 02:19:10 -08001682 void __user *newval, size_t newlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683{
1684 struct net_device *dev = ctl->extra1;
1685 struct inet6_dev *idev;
1686 int ret;
1687
1688 if (ctl->ctl_name == NET_NEIGH_RETRANS_TIME ||
1689 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME)
1690 ndisc_warn_deprecated_sysctl(ctl, "procfs", dev ? dev->name : "default");
1691
1692 switch (ctl->ctl_name) {
1693 case NET_NEIGH_REACHABLE_TIME:
1694 ret = sysctl_jiffies(ctl, name, nlen,
Alexey Dobriyan1f29bcd2006-12-10 02:19:10 -08001695 oldval, oldlenp, newval, newlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696 break;
1697 case NET_NEIGH_RETRANS_TIME_MS:
1698 case NET_NEIGH_REACHABLE_TIME_MS:
1699 ret = sysctl_ms_jiffies(ctl, name, nlen,
Alexey Dobriyan1f29bcd2006-12-10 02:19:10 -08001700 oldval, oldlenp, newval, newlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701 break;
1702 default:
1703 ret = 0;
1704 }
1705
1706 if (newval && newlen && ret > 0 &&
1707 dev && (idev = in6_dev_get(dev)) != NULL) {
1708 if (ctl->ctl_name == NET_NEIGH_REACHABLE_TIME ||
1709 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME_MS)
1710 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1711 idev->tstamp = jiffies;
1712 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1713 in6_dev_put(idev);
1714 }
1715
1716 return ret;
1717}
1718
1719#endif
1720
Denis V. Lunev9b0f9762008-02-29 11:13:15 -08001721int __init ndisc_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722{
1723 struct ipv6_pinfo *np;
1724 struct sock *sk;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001725 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726
1727 err = sock_create_kern(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6, &ndisc_socket);
1728 if (err < 0) {
1729 ND_PRINTK0(KERN_ERR
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001730 "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731 err);
1732 ndisc_socket = NULL; /* For safety. */
1733 return err;
1734 }
1735
1736 sk = ndisc_socket->sk;
1737 np = inet6_sk(sk);
1738 sk->sk_allocation = GFP_ATOMIC;
1739 np->hop_limit = 255;
1740 /* Do not loopback ndisc messages */
1741 np->mc_loop = 0;
1742 sk->sk_prot->unhash(sk);
1743
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001744 /*
1745 * Initialize the neighbour table
1746 */
1747
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748 neigh_table_init(&nd_tbl);
1749
1750#ifdef CONFIG_SYSCTL
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001751 neigh_sysctl_register(NULL, &nd_tbl.parms, NET_IPV6, NET_IPV6_NEIGH,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752 "ipv6",
1753 &ndisc_ifinfo_sysctl_change,
1754 &ndisc_ifinfo_sysctl_strategy);
1755#endif
1756
1757 register_netdevice_notifier(&ndisc_netdev_notifier);
1758 return 0;
1759}
1760
1761void ndisc_cleanup(void)
1762{
Dmitry Mishin36f73d02006-11-03 16:08:19 -08001763 unregister_netdevice_notifier(&ndisc_netdev_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764#ifdef CONFIG_SYSCTL
1765 neigh_sysctl_unregister(&nd_tbl.parms);
1766#endif
1767 neigh_table_clear(&nd_tbl);
1768 sock_release(ndisc_socket);
1769 ndisc_socket = NULL; /* For safety. */
1770}