blob: 9f061d1adbc2b3770d987ff0fe239a2ef29417bc [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>
Denis V. Lunev1ed85162008-04-03 14:31:03 -070087#include <net/inet_common.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070088#include <linux/proc_fs.h>
89
90#include <linux/netfilter.h>
91#include <linux/netfilter_ipv6.h>
92
Linus Torvalds1da177e2005-04-16 15:20:36 -070093static u32 ndisc_hash(const void *pkey, const struct net_device *dev);
94static int ndisc_constructor(struct neighbour *neigh);
95static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb);
96static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb);
97static int pndisc_constructor(struct pneigh_entry *n);
98static void pndisc_destructor(struct pneigh_entry *n);
99static void pndisc_redo(struct sk_buff *skb);
100
101static struct neigh_ops ndisc_generic_ops = {
102 .family = AF_INET6,
103 .solicit = ndisc_solicit,
104 .error_report = ndisc_error_report,
105 .output = neigh_resolve_output,
106 .connected_output = neigh_connected_output,
107 .hh_output = dev_queue_xmit,
108 .queue_xmit = dev_queue_xmit,
109};
110
111static struct neigh_ops ndisc_hh_ops = {
112 .family = AF_INET6,
113 .solicit = ndisc_solicit,
114 .error_report = ndisc_error_report,
115 .output = neigh_resolve_output,
116 .connected_output = neigh_resolve_output,
117 .hh_output = dev_queue_xmit,
118 .queue_xmit = dev_queue_xmit,
119};
120
121
122static struct neigh_ops ndisc_direct_ops = {
123 .family = AF_INET6,
124 .output = dev_queue_xmit,
125 .connected_output = dev_queue_xmit,
126 .hh_output = dev_queue_xmit,
127 .queue_xmit = dev_queue_xmit,
128};
129
130struct neigh_table nd_tbl = {
131 .family = AF_INET6,
132 .entry_size = sizeof(struct neighbour) + sizeof(struct in6_addr),
133 .key_len = sizeof(struct in6_addr),
134 .hash = ndisc_hash,
135 .constructor = ndisc_constructor,
136 .pconstructor = pndisc_constructor,
137 .pdestructor = pndisc_destructor,
138 .proxy_redo = pndisc_redo,
139 .id = "ndisc_cache",
140 .parms = {
141 .tbl = &nd_tbl,
142 .base_reachable_time = 30 * HZ,
143 .retrans_time = 1 * HZ,
144 .gc_staletime = 60 * HZ,
145 .reachable_time = 30 * HZ,
146 .delay_probe_time = 5 * HZ,
147 .queue_len = 3,
148 .ucast_probes = 3,
149 .mcast_probes = 3,
150 .anycast_delay = 1 * HZ,
151 .proxy_delay = (8 * HZ) / 10,
152 .proxy_qlen = 64,
153 },
154 .gc_interval = 30 * HZ,
155 .gc_thresh1 = 128,
156 .gc_thresh2 = 512,
157 .gc_thresh3 = 1024,
158};
159
160/* ND options */
161struct ndisc_options {
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800162 struct nd_opt_hdr *nd_opt_array[__ND_OPT_ARRAY_MAX];
163#ifdef CONFIG_IPV6_ROUTE_INFO
164 struct nd_opt_hdr *nd_opts_ri;
165 struct nd_opt_hdr *nd_opts_ri_end;
166#endif
Pierre Ynard31910572007-10-10 21:22:05 -0700167 struct nd_opt_hdr *nd_useropts;
168 struct nd_opt_hdr *nd_useropts_end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169};
170
171#define nd_opts_src_lladdr nd_opt_array[ND_OPT_SOURCE_LL_ADDR]
172#define nd_opts_tgt_lladdr nd_opt_array[ND_OPT_TARGET_LL_ADDR]
173#define nd_opts_pi nd_opt_array[ND_OPT_PREFIX_INFO]
174#define nd_opts_pi_end nd_opt_array[__ND_OPT_PREFIX_INFO_END]
175#define nd_opts_rh nd_opt_array[ND_OPT_REDIRECT_HDR]
176#define nd_opts_mtu nd_opt_array[ND_OPT_MTU]
177
178#define NDISC_OPT_SPACE(len) (((len)+2+7)&~7)
179
180/*
181 * Return the padding between the option length and the start of the
182 * link addr. Currently only IP-over-InfiniBand needs this, although
183 * if RFC 3831 IPv6-over-Fibre Channel is ever implemented it may
184 * also need a pad of 2.
185 */
186static int ndisc_addr_option_pad(unsigned short type)
187{
188 switch (type) {
189 case ARPHRD_INFINIBAND: return 2;
190 default: return 0;
191 }
192}
193
194static inline int ndisc_opt_addr_space(struct net_device *dev)
195{
196 return NDISC_OPT_SPACE(dev->addr_len + ndisc_addr_option_pad(dev->type));
197}
198
199static u8 *ndisc_fill_addr_option(u8 *opt, int type, void *data, int data_len,
200 unsigned short addr_type)
201{
202 int space = NDISC_OPT_SPACE(data_len);
203 int pad = ndisc_addr_option_pad(addr_type);
204
205 opt[0] = type;
206 opt[1] = space>>3;
207
208 memset(opt + 2, 0, pad);
209 opt += pad;
210 space -= pad;
211
212 memcpy(opt+2, data, data_len);
213 data_len += 2;
214 opt += data_len;
215 if ((space -= data_len) > 0)
216 memset(opt, 0, space);
217 return opt + space;
218}
219
220static struct nd_opt_hdr *ndisc_next_option(struct nd_opt_hdr *cur,
221 struct nd_opt_hdr *end)
222{
223 int type;
224 if (!cur || !end || cur >= end)
225 return NULL;
226 type = cur->nd_opt_type;
227 do {
228 cur = ((void *)cur) + (cur->nd_opt_len << 3);
229 } while(cur < end && cur->nd_opt_type != type);
230 return (cur <= end && cur->nd_opt_type == type ? cur : NULL);
231}
232
Pierre Ynard31910572007-10-10 21:22:05 -0700233static inline int ndisc_is_useropt(struct nd_opt_hdr *opt)
234{
235 return (opt->nd_opt_type == ND_OPT_RDNSS);
236}
237
238static struct nd_opt_hdr *ndisc_next_useropt(struct nd_opt_hdr *cur,
239 struct nd_opt_hdr *end)
240{
241 if (!cur || !end || cur >= end)
242 return NULL;
243 do {
244 cur = ((void *)cur) + (cur->nd_opt_len << 3);
245 } while(cur < end && !ndisc_is_useropt(cur));
246 return (cur <= end && ndisc_is_useropt(cur) ? cur : NULL);
247}
248
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249static struct ndisc_options *ndisc_parse_options(u8 *opt, int opt_len,
250 struct ndisc_options *ndopts)
251{
252 struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)opt;
253
254 if (!nd_opt || opt_len < 0 || !ndopts)
255 return NULL;
256 memset(ndopts, 0, sizeof(*ndopts));
257 while (opt_len) {
258 int l;
259 if (opt_len < sizeof(struct nd_opt_hdr))
260 return NULL;
261 l = nd_opt->nd_opt_len << 3;
262 if (opt_len < l || l == 0)
263 return NULL;
264 switch (nd_opt->nd_opt_type) {
265 case ND_OPT_SOURCE_LL_ADDR:
266 case ND_OPT_TARGET_LL_ADDR:
267 case ND_OPT_MTU:
268 case ND_OPT_REDIRECT_HDR:
269 if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) {
270 ND_PRINTK2(KERN_WARNING
271 "%s(): duplicated ND6 option found: type=%d\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800272 __func__,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 nd_opt->nd_opt_type);
274 } else {
275 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
276 }
277 break;
278 case ND_OPT_PREFIX_INFO:
279 ndopts->nd_opts_pi_end = nd_opt;
Stephen Hemmingercfcabdc2007-10-09 01:59:42 -0700280 if (!ndopts->nd_opt_array[nd_opt->nd_opt_type])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
282 break;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800283#ifdef CONFIG_IPV6_ROUTE_INFO
284 case ND_OPT_ROUTE_INFO:
285 ndopts->nd_opts_ri_end = nd_opt;
286 if (!ndopts->nd_opts_ri)
287 ndopts->nd_opts_ri = nd_opt;
288 break;
289#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 default:
Pierre Ynard31910572007-10-10 21:22:05 -0700291 if (ndisc_is_useropt(nd_opt)) {
292 ndopts->nd_useropts_end = nd_opt;
293 if (!ndopts->nd_useropts)
294 ndopts->nd_useropts = nd_opt;
295 } else {
296 /*
297 * Unknown options must be silently ignored,
298 * to accommodate future extension to the
299 * protocol.
300 */
301 ND_PRINTK2(KERN_NOTICE
302 "%s(): ignored unsupported option; type=%d, len=%d\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800303 __func__,
Pierre Ynard31910572007-10-10 21:22:05 -0700304 nd_opt->nd_opt_type, nd_opt->nd_opt_len);
305 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 }
307 opt_len -= l;
308 nd_opt = ((void *)nd_opt) + l;
309 }
310 return ndopts;
311}
312
313static inline u8 *ndisc_opt_addr_data(struct nd_opt_hdr *p,
314 struct net_device *dev)
315{
316 u8 *lladdr = (u8 *)(p + 1);
317 int lladdrlen = p->nd_opt_len << 3;
318 int prepad = ndisc_addr_option_pad(dev->type);
319 if (lladdrlen != NDISC_OPT_SPACE(dev->addr_len + prepad))
320 return NULL;
321 return (lladdr + prepad);
322}
323
324int ndisc_mc_map(struct in6_addr *addr, char *buf, struct net_device *dev, int dir)
325{
326 switch (dev->type) {
327 case ARPHRD_ETHER:
328 case ARPHRD_IEEE802: /* Not sure. Check it later. --ANK */
329 case ARPHRD_FDDI:
330 ipv6_eth_mc_map(addr, buf);
331 return 0;
332 case ARPHRD_IEEE802_TR:
333 ipv6_tr_mc_map(addr,buf);
334 return 0;
335 case ARPHRD_ARCNET:
336 ipv6_arcnet_mc_map(addr, buf);
337 return 0;
338 case ARPHRD_INFINIBAND:
Rolf Manderscheida9e527e2007-12-10 13:38:41 -0700339 ipv6_ib_mc_map(addr, dev->broadcast, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 return 0;
341 default:
342 if (dir) {
343 memcpy(buf, dev->broadcast, dev->addr_len);
344 return 0;
345 }
346 }
347 return -EINVAL;
348}
349
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900350EXPORT_SYMBOL(ndisc_mc_map);
351
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352static u32 ndisc_hash(const void *pkey, const struct net_device *dev)
353{
354 const u32 *p32 = pkey;
355 u32 addr_hash, i;
356
357 addr_hash = 0;
358 for (i = 0; i < (sizeof(struct in6_addr) / sizeof(u32)); i++)
359 addr_hash ^= *p32++;
360
361 return jhash_2words(addr_hash, dev->ifindex, nd_tbl.hash_rnd);
362}
363
364static int ndisc_constructor(struct neighbour *neigh)
365{
366 struct in6_addr *addr = (struct in6_addr*)&neigh->primary_key;
367 struct net_device *dev = neigh->dev;
368 struct inet6_dev *in6_dev;
369 struct neigh_parms *parms;
370 int is_multicast = ipv6_addr_is_multicast(addr);
371
372 rcu_read_lock();
373 in6_dev = in6_dev_get(dev);
374 if (in6_dev == NULL) {
375 rcu_read_unlock();
376 return -EINVAL;
377 }
378
379 parms = in6_dev->nd_parms;
380 __neigh_parms_put(neigh->parms);
381 neigh->parms = neigh_parms_clone(parms);
382 rcu_read_unlock();
383
384 neigh->type = is_multicast ? RTN_MULTICAST : RTN_UNICAST;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700385 if (!dev->header_ops) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 neigh->nud_state = NUD_NOARP;
387 neigh->ops = &ndisc_direct_ops;
388 neigh->output = neigh->ops->queue_xmit;
389 } else {
390 if (is_multicast) {
391 neigh->nud_state = NUD_NOARP;
392 ndisc_mc_map(addr, neigh->ha, dev, 1);
393 } else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {
394 neigh->nud_state = NUD_NOARP;
395 memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
396 if (dev->flags&IFF_LOOPBACK)
397 neigh->type = RTN_LOCAL;
398 } else if (dev->flags&IFF_POINTOPOINT) {
399 neigh->nud_state = NUD_NOARP;
400 memcpy(neigh->ha, dev->broadcast, dev->addr_len);
401 }
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700402 if (dev->header_ops->cache)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 neigh->ops = &ndisc_hh_ops;
404 else
405 neigh->ops = &ndisc_generic_ops;
406 if (neigh->nud_state&NUD_VALID)
407 neigh->output = neigh->ops->connected_output;
408 else
409 neigh->output = neigh->ops->output;
410 }
411 in6_dev_put(in6_dev);
412 return 0;
413}
414
415static int pndisc_constructor(struct pneigh_entry *n)
416{
417 struct in6_addr *addr = (struct in6_addr*)&n->key;
418 struct in6_addr maddr;
419 struct net_device *dev = n->dev;
420
421 if (dev == NULL || __in6_dev_get(dev) == NULL)
422 return -EINVAL;
423 addrconf_addr_solict_mult(addr, &maddr);
424 ipv6_dev_mc_inc(dev, &maddr);
425 return 0;
426}
427
428static void pndisc_destructor(struct pneigh_entry *n)
429{
430 struct in6_addr *addr = (struct in6_addr*)&n->key;
431 struct in6_addr maddr;
432 struct net_device *dev = n->dev;
433
434 if (dev == NULL || __in6_dev_get(dev) == NULL)
435 return;
436 addrconf_addr_solict_mult(addr, &maddr);
437 ipv6_dev_mc_dec(dev, &maddr);
438}
439
Brian Haley305d5522008-11-04 17:51:14 -0800440struct sk_buff *ndisc_build_skb(struct net_device *dev,
441 const struct in6_addr *daddr,
442 const struct in6_addr *saddr,
443 struct icmp6hdr *icmp6h,
444 const struct in6_addr *target,
445 int llinfo)
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900446{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900447 struct net *net = dev_net(dev);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -0800448 struct sock *sk = net->ipv6.ndisc_sk;
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900449 struct sk_buff *skb;
450 struct icmp6hdr *hdr;
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900451 int len;
452 int err;
Brian Haley305d5522008-11-04 17:51:14 -0800453 u8 *opt;
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900454
455 if (!dev->addr_len)
456 llinfo = 0;
457
458 len = sizeof(struct icmp6hdr) + (target ? sizeof(*target) : 0);
459 if (llinfo)
460 len += ndisc_opt_addr_space(dev);
461
462 skb = sock_alloc_send_skb(sk,
463 (MAX_HEADER + sizeof(struct ipv6hdr) +
Johannes Bergf5184d22008-05-12 20:48:31 -0700464 len + LL_ALLOCATED_SPACE(dev)),
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900465 1, &err);
466 if (!skb) {
467 ND_PRINTK0(KERN_ERR
468 "ICMPv6 ND: %s() failed to allocate an skb.\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800469 __func__);
Brian Haley305d5522008-11-04 17:51:14 -0800470 return NULL;
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900471 }
472
473 skb_reserve(skb, LL_RESERVED_SPACE(dev));
474 ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);
475
476 skb->transport_header = skb->tail;
477 skb_put(skb, len);
478
479 hdr = (struct icmp6hdr *)skb_transport_header(skb);
480 memcpy(hdr, icmp6h, sizeof(*hdr));
481
482 opt = skb_transport_header(skb) + sizeof(struct icmp6hdr);
483 if (target) {
484 ipv6_addr_copy((struct in6_addr *)opt, target);
485 opt += sizeof(*target);
486 }
487
488 if (llinfo)
489 ndisc_fill_addr_option(opt, llinfo, dev->dev_addr,
490 dev->addr_len, dev->type);
491
492 hdr->icmp6_cksum = csum_ipv6_magic(saddr, daddr, len,
493 IPPROTO_ICMPV6,
Joe Perches07f07572008-11-19 15:44:53 -0800494 csum_partial(hdr,
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900495 len, 0));
496
Brian Haley305d5522008-11-04 17:51:14 -0800497 return skb;
498}
499
500EXPORT_SYMBOL(ndisc_build_skb);
501
502void ndisc_send_skb(struct sk_buff *skb,
503 struct net_device *dev,
504 struct neighbour *neigh,
505 const struct in6_addr *daddr,
506 const struct in6_addr *saddr,
507 struct icmp6hdr *icmp6h)
508{
509 struct flowi fl;
510 struct dst_entry *dst;
511 struct net *net = dev_net(dev);
512 struct sock *sk = net->ipv6.ndisc_sk;
513 struct inet6_dev *idev;
514 int err;
515 u8 type;
516
517 type = icmp6h->icmp6_type;
518
519 icmpv6_flow_init(sk, &fl, type, saddr, daddr, dev->ifindex);
520
521 dst = icmp6_dst_alloc(dev, neigh, daddr);
522 if (!dst) {
523 kfree_skb(skb);
524 return;
525 }
526
Alexey Dobriyan52479b62008-11-25 17:35:18 -0800527 err = xfrm_lookup(net, &dst, &fl, NULL, 0);
Brian Haley305d5522008-11-04 17:51:14 -0800528 if (err < 0) {
529 kfree_skb(skb);
530 return;
531 }
532
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900533 skb->dst = dst;
534
535 idev = in6_dev_get(dst->dev);
Denis V. Lunev3bd653c2008-10-08 10:54:51 -0700536 IP6_INC_STATS(net, idev, IPSTATS_MIB_OUTREQUESTS);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900537
Patrick McHardy6e23ae22007-11-19 18:53:30 -0800538 err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev,
539 dst_output);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900540 if (!err) {
Denis V. Lunev5c5d2442008-10-08 10:33:50 -0700541 ICMP6MSGOUT_INC_STATS(net, idev, type);
Denis V. Luneva862f6a2008-10-08 10:33:06 -0700542 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900543 }
544
545 if (likely(idev != NULL))
546 in6_dev_put(idev);
547}
548
Brian Haley305d5522008-11-04 17:51:14 -0800549EXPORT_SYMBOL(ndisc_send_skb);
550
551/*
552 * Send a Neighbour Discover packet
553 */
554static void __ndisc_send(struct net_device *dev,
555 struct neighbour *neigh,
556 const struct in6_addr *daddr,
557 const struct in6_addr *saddr,
558 struct icmp6hdr *icmp6h, const struct in6_addr *target,
559 int llinfo)
560{
561 struct sk_buff *skb;
562
563 skb = ndisc_build_skb(dev, daddr, saddr, icmp6h, target, llinfo);
564 if (!skb)
565 return;
566
567 ndisc_send_skb(skb, dev, neigh, daddr, saddr, icmp6h);
568}
569
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570static void ndisc_send_na(struct net_device *dev, struct neighbour *neigh,
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +0900571 const struct in6_addr *daddr,
572 const struct in6_addr *solicited_addr,
573 int router, int solicited, int override, int inc_opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574{
575 struct in6_addr tmpaddr;
576 struct inet6_ifaddr *ifp;
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +0900577 const struct in6_addr *src_addr;
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900578 struct icmp6hdr icmp6h = {
579 .icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT,
580 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581
582 /* for anycast or proxy, solicited_addr != src_addr */
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900583 ifp = ipv6_get_ifaddr(dev_net(dev), solicited_addr, dev, 1);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900584 if (ifp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 src_addr = solicited_addr;
Neil Horman95c385b2007-04-25 17:08:10 -0700586 if (ifp->flags & IFA_F_OPTIMISTIC)
587 override = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 in6_ifa_put(ifp);
589 } else {
Brian Haley191cd582008-08-14 15:33:21 -0700590 if (ipv6_dev_get_saddr(dev_net(dev), dev, daddr,
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900591 inet6_sk(dev_net(dev)->ipv6.ndisc_sk)->srcprefs,
YOSHIFUJI Hideaki7cbca672008-03-25 09:37:42 +0900592 &tmpaddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 return;
594 src_addr = &tmpaddr;
595 }
596
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900597 icmp6h.icmp6_router = router;
598 icmp6h.icmp6_solicited = solicited;
599 icmp6h.icmp6_override = override;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900601 __ndisc_send(dev, neigh, daddr, src_addr,
602 &icmp6h, solicited_addr,
David L Stevens14878f72007-09-16 16:52:35 -0700603 inc_opt ? ND_OPT_TARGET_LL_ADDR : 0);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900604}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605
606void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh,
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +0900607 const struct in6_addr *solicit,
608 const struct in6_addr *daddr, const struct in6_addr *saddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 struct in6_addr addr_buf;
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900611 struct icmp6hdr icmp6h = {
612 .icmp6_type = NDISC_NEIGHBOUR_SOLICITATION,
613 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614
615 if (saddr == NULL) {
Neil Horman95c385b2007-04-25 17:08:10 -0700616 if (ipv6_get_lladdr(dev, &addr_buf,
617 (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 return;
619 saddr = &addr_buf;
620 }
621
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900622 __ndisc_send(dev, neigh, daddr, saddr,
623 &icmp6h, solicit,
David L Stevens14878f72007-09-16 16:52:35 -0700624 !ipv6_addr_any(saddr) ? ND_OPT_SOURCE_LL_ADDR : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625}
626
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +0900627void ndisc_send_rs(struct net_device *dev, const struct in6_addr *saddr,
628 const struct in6_addr *daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629{
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900630 struct icmp6hdr icmp6h = {
631 .icmp6_type = NDISC_ROUTER_SOLICITATION,
632 };
Neil Horman95c385b2007-04-25 17:08:10 -0700633 int send_sllao = dev->addr_len;
Neil Horman95c385b2007-04-25 17:08:10 -0700634
635#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
636 /*
637 * According to section 2.2 of RFC 4429, we must not
638 * send router solicitations with a sllao from
639 * optimistic addresses, but we may send the solicitation
640 * if we don't include the sllao. So here we check
641 * if our address is optimistic, and if so, we
Joe Perchesbea85192007-12-20 14:01:35 -0800642 * suppress the inclusion of the sllao.
Neil Horman95c385b2007-04-25 17:08:10 -0700643 */
644 if (send_sllao) {
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900645 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev_net(dev), saddr,
Daniel Lezcano1cab3da2008-01-10 22:44:09 -0800646 dev, 1);
Neil Horman95c385b2007-04-25 17:08:10 -0700647 if (ifp) {
648 if (ifp->flags & IFA_F_OPTIMISTIC) {
YOSHIFUJI Hideakica043562007-02-28 23:13:20 +0900649 send_sllao = 0;
Neil Horman95c385b2007-04-25 17:08:10 -0700650 }
YOSHIFUJI Hideakica043562007-02-28 23:13:20 +0900651 in6_ifa_put(ifp);
Neil Horman95c385b2007-04-25 17:08:10 -0700652 } else {
653 send_sllao = 0;
654 }
655 }
656#endif
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900657 __ndisc_send(dev, NULL, daddr, saddr,
658 &icmp6h, NULL,
David L Stevens14878f72007-09-16 16:52:35 -0700659 send_sllao ? ND_OPT_SOURCE_LL_ADDR : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660}
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900661
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662
663static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
664{
665 /*
666 * "The sender MUST return an ICMP
667 * destination unreachable"
668 */
669 dst_link_failure(skb);
670 kfree_skb(skb);
671}
672
673/* Called with locked neigh: either read or both */
674
675static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
676{
677 struct in6_addr *saddr = NULL;
678 struct in6_addr mcaddr;
679 struct net_device *dev = neigh->dev;
680 struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
681 int probes = atomic_read(&neigh->probes);
682
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900683 if (skb && ipv6_chk_addr(dev_net(dev), &ipv6_hdr(skb)->saddr, dev, 1))
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700684 saddr = &ipv6_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685
686 if ((probes -= neigh->parms->ucast_probes) < 0) {
687 if (!(neigh->nud_state & NUD_VALID)) {
Harvey Harrison5b095d9892008-10-29 12:52:50 -0700688 ND_PRINTK1(KERN_DEBUG "%s(): trying to ucast probe in NUD_INVALID: %pI6\n",
Harvey Harrison0c6ce782008-10-28 16:09:23 -0700689 __func__, target);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 }
691 ndisc_send_ns(dev, neigh, target, target, saddr);
692 } else if ((probes -= neigh->parms->app_probes) < 0) {
693#ifdef CONFIG_ARPD
694 neigh_app_ns(neigh);
695#endif
696 } else {
697 addrconf_addr_solict_mult(target, &mcaddr);
698 ndisc_send_ns(dev, NULL, target, &mcaddr, saddr);
699 }
700}
701
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900702static int pndisc_is_router(const void *pkey,
703 struct net_device *dev)
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700704{
705 struct pneigh_entry *n;
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900706 int ret = -1;
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700707
708 read_lock_bh(&nd_tbl.lock);
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900709 n = __pneigh_lookup(&nd_tbl, dev_net(dev), pkey, dev);
710 if (n)
711 ret = !!(n->flags & NTF_ROUTER);
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700712 read_unlock_bh(&nd_tbl.lock);
713
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900714 return ret;
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700715}
716
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717static void ndisc_recv_ns(struct sk_buff *skb)
718{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700719 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700720 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
721 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 u8 *lladdr = NULL;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700723 u32 ndoptlen = skb->tail - (skb->transport_header +
724 offsetof(struct nd_msg, opt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 struct ndisc_options ndopts;
726 struct net_device *dev = skb->dev;
727 struct inet6_ifaddr *ifp;
728 struct inet6_dev *idev = NULL;
729 struct neighbour *neigh;
730 int dad = ipv6_addr_any(saddr);
731 int inc;
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900732 int is_router = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733
734 if (ipv6_addr_is_multicast(&msg->target)) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900735 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 "ICMPv6 NS: multicast target address");
737 return;
738 }
739
740 /*
741 * RFC2461 7.1.1:
742 * DAD has to be destined for solicited node multicast address.
743 */
744 if (dad &&
745 !(daddr->s6_addr32[0] == htonl(0xff020000) &&
746 daddr->s6_addr32[1] == htonl(0x00000000) &&
747 daddr->s6_addr32[2] == htonl(0x00000001) &&
748 daddr->s6_addr [12] == 0xff )) {
749 ND_PRINTK2(KERN_WARNING
750 "ICMPv6 NS: bad DAD packet (wrong destination)\n");
751 return;
752 }
753
754 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900755 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 "ICMPv6 NS: invalid ND options\n");
757 return;
758 }
759
760 if (ndopts.nd_opts_src_lladdr) {
761 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
762 if (!lladdr) {
763 ND_PRINTK2(KERN_WARNING
764 "ICMPv6 NS: invalid link-layer address length\n");
765 return;
766 }
767
768 /* RFC2461 7.1.1:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900769 * If the IP source address is the unspecified address,
770 * there MUST NOT be source link-layer address option
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 * in the message.
772 */
773 if (dad) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900774 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 "ICMPv6 NS: bad DAD packet (link-layer address option)\n");
776 return;
777 }
778 }
779
780 inc = ipv6_addr_is_multicast(daddr);
781
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900782 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
Daniel Lezcanoa18bc692008-03-07 11:14:49 -0800783 if (ifp) {
Neil Horman95c385b2007-04-25 17:08:10 -0700784
785 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
786 if (dad) {
787 if (dev->type == ARPHRD_IEEE802_TR) {
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -0700788 const unsigned char *sadr;
789 sadr = skb_mac_header(skb);
Neil Horman95c385b2007-04-25 17:08:10 -0700790 if (((sadr[8] ^ dev->dev_addr[0]) & 0x7f) == 0 &&
791 sadr[9] == dev->dev_addr[1] &&
792 sadr[10] == dev->dev_addr[2] &&
793 sadr[11] == dev->dev_addr[3] &&
794 sadr[12] == dev->dev_addr[4] &&
795 sadr[13] == dev->dev_addr[5]) {
796 /* looped-back to us */
797 goto out;
798 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 }
Neil Horman95c385b2007-04-25 17:08:10 -0700800
801 /*
802 * We are colliding with another node
803 * who is doing DAD
804 * so fail our DAD process
805 */
806 addrconf_dad_failure(ifp);
Denis V. Lunev9e3be4b2007-09-11 11:04:49 +0200807 return;
Neil Horman95c385b2007-04-25 17:08:10 -0700808 } else {
809 /*
810 * This is not a dad solicitation.
811 * If we are an optimistic node,
812 * we should respond.
813 * Otherwise, we should ignore it.
814 */
815 if (!(ifp->flags & IFA_F_OPTIMISTIC))
816 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 }
819
820 idev = ifp->idev;
821 } else {
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700822 struct net *net = dev_net(dev);
823
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 idev = in6_dev_get(dev);
825 if (!idev) {
826 /* XXX: count this drop? */
827 return;
828 }
829
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700830 if (ipv6_chk_acast_addr(net, dev, &msg->target) ||
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900831 (idev->cnf.forwarding &&
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700832 (net->ipv6.devconf_all->proxy_ndp || idev->cnf.proxy_ndp) &&
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900833 (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) {
Patrick McHardya61bbcf2005-08-14 17:24:31 -0700834 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 skb->pkt_type != PACKET_HOST &&
836 inc != 0 &&
837 idev->nd_parms->proxy_delay != 0) {
838 /*
839 * for anycast or proxy,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900840 * sender should delay its response
841 * by a random time between 0 and
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 * MAX_ANYCAST_DELAY_TIME seconds.
843 * (RFC2461) -- yoshfuji
844 */
845 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
846 if (n)
847 pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
848 goto out;
849 }
850 } else
851 goto out;
852 }
853
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900854 if (is_router < 0)
855 is_router = !!idev->cnf.forwarding;
Ville Nuorvala62dd9312006-09-22 14:43:19 -0700856
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 if (dad) {
YOSHIFUJI Hideakif3ee4012008-04-10 15:42:11 +0900858 ndisc_send_na(dev, NULL, &in6addr_linklocal_allnodes, &msg->target,
Ville Nuorvala62dd9312006-09-22 14:43:19 -0700859 is_router, 0, (ifp != NULL), 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 goto out;
861 }
862
863 if (inc)
864 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
865 else
866 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
867
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900868 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 * update / create cache entry
870 * for the source address
871 */
872 neigh = __neigh_lookup(&nd_tbl, saddr, dev,
873 !inc || lladdr || !dev->addr_len);
874 if (neigh)
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900875 neigh_update(neigh, lladdr, NUD_STALE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 NEIGH_UPDATE_F_WEAK_OVERRIDE|
877 NEIGH_UPDATE_F_OVERRIDE);
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700878 if (neigh || !dev->header_ops) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 ndisc_send_na(dev, neigh, saddr, &msg->target,
Ville Nuorvala62dd9312006-09-22 14:43:19 -0700880 is_router,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 1, (ifp != NULL && inc), inc);
882 if (neigh)
883 neigh_release(neigh);
884 }
885
886out:
887 if (ifp)
888 in6_ifa_put(ifp);
889 else
890 in6_dev_put(idev);
891
892 return;
893}
894
895static void ndisc_recv_na(struct sk_buff *skb)
896{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700897 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700898 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
899 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 u8 *lladdr = NULL;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700901 u32 ndoptlen = skb->tail - (skb->transport_header +
902 offsetof(struct nd_msg, opt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 struct ndisc_options ndopts;
904 struct net_device *dev = skb->dev;
905 struct inet6_ifaddr *ifp;
906 struct neighbour *neigh;
907
908 if (skb->len < sizeof(struct nd_msg)) {
909 ND_PRINTK2(KERN_WARNING
910 "ICMPv6 NA: packet too short\n");
911 return;
912 }
913
914 if (ipv6_addr_is_multicast(&msg->target)) {
915 ND_PRINTK2(KERN_WARNING
916 "ICMPv6 NA: target address is multicast.\n");
917 return;
918 }
919
920 if (ipv6_addr_is_multicast(daddr) &&
921 msg->icmph.icmp6_solicited) {
922 ND_PRINTK2(KERN_WARNING
923 "ICMPv6 NA: solicited NA is multicasted.\n");
924 return;
925 }
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900926
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
928 ND_PRINTK2(KERN_WARNING
929 "ICMPv6 NS: invalid ND option\n");
930 return;
931 }
932 if (ndopts.nd_opts_tgt_lladdr) {
933 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
934 if (!lladdr) {
935 ND_PRINTK2(KERN_WARNING
936 "ICMPv6 NA: invalid link-layer address length\n");
937 return;
938 }
939 }
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900940 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
Daniel Lezcanoa18bc692008-03-07 11:14:49 -0800941 if (ifp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 if (ifp->flags & IFA_F_TENTATIVE) {
943 addrconf_dad_failure(ifp);
944 return;
945 }
946 /* What should we make now? The advertisement
947 is invalid, but ndisc specs say nothing
948 about it. It could be misconfiguration, or
949 an smart proxy agent tries to help us :-)
Jan Sembera24fc7b82008-12-09 15:48:32 -0800950
951 We should not print the error if NA has been
952 received from loopback - it is just our own
953 unsolicited advertisement.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 */
Jan Sembera24fc7b82008-12-09 15:48:32 -0800955 if (skb->pkt_type != PACKET_LOOPBACK)
956 ND_PRINTK1(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957 "ICMPv6 NA: someone advertises our address on %s!\n",
958 ifp->idev->dev->name);
959 in6_ifa_put(ifp);
960 return;
961 }
962 neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
963
964 if (neigh) {
965 u8 old_flags = neigh->flags;
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700966 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967
968 if (neigh->nud_state & NUD_FAILED)
969 goto out;
970
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -0700971 /*
972 * Don't update the neighbor cache entry on a proxy NA from
973 * ourselves because either the proxied node is off link or it
974 * has already sent a NA to us.
975 */
976 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700977 net->ipv6.devconf_all->forwarding && net->ipv6.devconf_all->proxy_ndp &&
978 pneigh_lookup(&nd_tbl, net, &msg->target, dev, 0)) {
YOSHIFUJI Hideakifbea49e2006-09-22 14:43:49 -0700979 /* XXX: idev->cnf.prixy_ndp */
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -0700980 goto out;
YOSHIFUJI Hideakifbea49e2006-09-22 14:43:49 -0700981 }
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -0700982
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 neigh_update(neigh, lladdr,
984 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
985 NEIGH_UPDATE_F_WEAK_OVERRIDE|
986 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
987 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
988 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));
989
990 if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
991 /*
992 * Change: router to host
993 */
994 struct rt6_info *rt;
995 rt = rt6_get_dflt_router(saddr, dev);
996 if (rt)
Thomas Grafe0a1ad732006-08-22 00:00:21 -0700997 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 }
999
1000out:
1001 neigh_release(neigh);
1002 }
1003}
1004
1005static void ndisc_recv_rs(struct sk_buff *skb)
1006{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001007 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
1009 struct neighbour *neigh;
1010 struct inet6_dev *idev;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001011 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 struct ndisc_options ndopts;
1013 u8 *lladdr = NULL;
1014
1015 if (skb->len < sizeof(*rs_msg))
1016 return;
1017
1018 idev = in6_dev_get(skb->dev);
1019 if (!idev) {
1020 if (net_ratelimit())
1021 ND_PRINTK1("ICMP6 RS: can't find in6 device\n");
1022 return;
1023 }
1024
1025 /* Don't accept RS if we're not in router mode */
1026 if (!idev->cnf.forwarding)
1027 goto out;
1028
1029 /*
1030 * Don't update NCE if src = ::;
1031 * this implies that the source node has no ip address assigned yet.
1032 */
1033 if (ipv6_addr_any(saddr))
1034 goto out;
1035
1036 /* Parse ND options */
1037 if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {
1038 if (net_ratelimit())
1039 ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n");
1040 goto out;
1041 }
1042
1043 if (ndopts.nd_opts_src_lladdr) {
1044 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1045 skb->dev);
1046 if (!lladdr)
1047 goto out;
1048 }
1049
1050 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
1051 if (neigh) {
1052 neigh_update(neigh, lladdr, NUD_STALE,
1053 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1054 NEIGH_UPDATE_F_OVERRIDE|
1055 NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
1056 neigh_release(neigh);
1057 }
1058out:
1059 in6_dev_put(idev);
1060}
1061
Pierre Ynard31910572007-10-10 21:22:05 -07001062static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt)
1063{
1064 struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra);
1065 struct sk_buff *skb;
1066 struct nlmsghdr *nlh;
1067 struct nduseroptmsg *ndmsg;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001068 struct net *net = dev_net(ra->dev);
Pierre Ynard31910572007-10-10 21:22:05 -07001069 int err;
1070 int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg)
1071 + (opt->nd_opt_len << 3));
1072 size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr));
1073
1074 skb = nlmsg_new(msg_size, GFP_ATOMIC);
1075 if (skb == NULL) {
1076 err = -ENOBUFS;
1077 goto errout;
1078 }
1079
1080 nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0);
1081 if (nlh == NULL) {
1082 goto nla_put_failure;
1083 }
1084
1085 ndmsg = nlmsg_data(nlh);
1086 ndmsg->nduseropt_family = AF_INET6;
Pierre Ynarddbb2ed22007-11-12 17:58:35 -08001087 ndmsg->nduseropt_ifindex = ra->dev->ifindex;
Pierre Ynard31910572007-10-10 21:22:05 -07001088 ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type;
1089 ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code;
1090 ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3;
1091
1092 memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3);
1093
1094 NLA_PUT(skb, NDUSEROPT_SRCADDR, sizeof(struct in6_addr),
1095 &ipv6_hdr(ra)->saddr);
1096 nlmsg_end(skb, nlh);
1097
Pablo Neira Ayuso1ce85fe2009-02-24 23:18:28 -08001098 rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL, GFP_ATOMIC);
Pierre Ynard31910572007-10-10 21:22:05 -07001099 return;
1100
1101nla_put_failure:
1102 nlmsg_free(skb);
1103 err = -EMSGSIZE;
1104errout:
Daniel Lezcanoa18bc692008-03-07 11:14:49 -08001105 rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err);
Pierre Ynard31910572007-10-10 21:22:05 -07001106}
1107
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108static void ndisc_router_discovery(struct sk_buff *skb)
1109{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001110 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 struct neighbour *neigh = NULL;
1112 struct inet6_dev *in6_dev;
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001113 struct rt6_info *rt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114 int lifetime;
1115 struct ndisc_options ndopts;
1116 int optlen;
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001117 unsigned int pref = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118
1119 __u8 * opt = (__u8 *)(ra_msg + 1);
1120
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001121 optlen = (skb->tail - skb->transport_header) - sizeof(struct ra_msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001123 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124 ND_PRINTK2(KERN_WARNING
1125 "ICMPv6 RA: source address is not link-local.\n");
1126 return;
1127 }
1128 if (optlen < 0) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001129 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 "ICMPv6 RA: packet too short\n");
1131 return;
1132 }
1133
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001134#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001135 if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) {
1136 ND_PRINTK2(KERN_WARNING
1137 "ICMPv6 RA: from host or unauthorized router\n");
1138 return;
1139 }
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001140#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001141
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142 /*
1143 * set the RA_RECV flag in the interface
1144 */
1145
1146 in6_dev = in6_dev_get(skb->dev);
1147 if (in6_dev == NULL) {
1148 ND_PRINTK0(KERN_ERR
1149 "ICMPv6 RA: can't find inet6 device for %s.\n",
1150 skb->dev->name);
1151 return;
1152 }
1153 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_ra) {
1154 in6_dev_put(in6_dev);
1155 return;
1156 }
1157
1158 if (!ndisc_parse_options(opt, optlen, &ndopts)) {
1159 in6_dev_put(in6_dev);
1160 ND_PRINTK2(KERN_WARNING
1161 "ICMP6 RA: invalid ND options\n");
1162 return;
1163 }
1164
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001165#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001166 /* skip link-specific parameters from interior routers */
1167 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1168 goto skip_linkparms;
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001169#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001170
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 if (in6_dev->if_flags & IF_RS_SENT) {
1172 /*
1173 * flag that an RA was received after an RS was sent
1174 * out on this interface.
1175 */
1176 in6_dev->if_flags |= IF_RA_RCVD;
1177 }
1178
1179 /*
1180 * Remember the managed/otherconf flags from most recently
1181 * received RA message (RFC 2462) -- yoshfuji
1182 */
1183 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1184 IF_RA_OTHERCONF)) |
1185 (ra_msg->icmph.icmp6_addrconf_managed ?
1186 IF_RA_MANAGED : 0) |
1187 (ra_msg->icmph.icmp6_addrconf_other ?
1188 IF_RA_OTHERCONF : 0);
1189
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001190 if (!in6_dev->cnf.accept_ra_defrtr)
1191 goto skip_defrtr;
1192
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1194
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001195#ifdef CONFIG_IPV6_ROUTER_PREF
1196 pref = ra_msg->icmph.icmp6_router_pref;
1197 /* 10b is handled as if it were 00b (medium) */
YOSHIFUJI Hideaki930d6ff2006-03-20 17:05:30 -08001198 if (pref == ICMPV6_ROUTER_PREF_INVALID ||
YOSHIFUJI Hideaki6d5b78c2007-06-22 16:07:04 -07001199 !in6_dev->cnf.accept_ra_rtr_pref)
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001200 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1201#endif
1202
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001203 rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204
1205 if (rt)
1206 neigh = rt->rt6i_nexthop;
1207
1208 if (rt && lifetime == 0) {
1209 neigh_clone(neigh);
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001210 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211 rt = NULL;
1212 }
1213
1214 if (rt == NULL && lifetime) {
1215 ND_PRINTK3(KERN_DEBUG
1216 "ICMPv6 RA: adding default router.\n");
1217
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001218 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 if (rt == NULL) {
1220 ND_PRINTK0(KERN_ERR
1221 "ICMPv6 RA: %s() failed to add default route.\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001222 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223 in6_dev_put(in6_dev);
1224 return;
1225 }
1226
1227 neigh = rt->rt6i_nexthop;
1228 if (neigh == NULL) {
1229 ND_PRINTK0(KERN_ERR
1230 "ICMPv6 RA: %s() got default router without neighbour.\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001231 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 dst_release(&rt->u.dst);
1233 in6_dev_put(in6_dev);
1234 return;
1235 }
1236 neigh->flags |= NTF_ROUTER;
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001237 } else if (rt) {
Pedro Ribeiro22441cf2008-10-15 15:47:49 -07001238 rt->rt6i_flags = (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 }
1240
1241 if (rt)
1242 rt->rt6i_expires = jiffies + (HZ * lifetime);
1243
1244 if (ra_msg->icmph.icmp6_hop_limit) {
1245 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1246 if (rt)
1247 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = ra_msg->icmph.icmp6_hop_limit;
1248 }
1249
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001250skip_defrtr:
1251
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 /*
1253 * Update Reachable Time and Retrans Timer
1254 */
1255
1256 if (in6_dev->nd_parms) {
1257 unsigned long rtime = ntohl(ra_msg->retrans_timer);
1258
1259 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1260 rtime = (rtime*HZ)/1000;
1261 if (rtime < HZ/10)
1262 rtime = HZ/10;
1263 in6_dev->nd_parms->retrans_time = rtime;
1264 in6_dev->tstamp = jiffies;
1265 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1266 }
1267
1268 rtime = ntohl(ra_msg->reachable_time);
1269 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1270 rtime = (rtime*HZ)/1000;
1271
1272 if (rtime < HZ/10)
1273 rtime = HZ/10;
1274
1275 if (rtime != in6_dev->nd_parms->base_reachable_time) {
1276 in6_dev->nd_parms->base_reachable_time = rtime;
1277 in6_dev->nd_parms->gc_staletime = 3 * rtime;
1278 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1279 in6_dev->tstamp = jiffies;
1280 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1281 }
1282 }
1283 }
1284
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001285#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001286skip_linkparms:
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001287#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001288
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 /*
1290 * Process options.
1291 */
1292
1293 if (!neigh)
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001294 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 skb->dev, 1);
1296 if (neigh) {
1297 u8 *lladdr = NULL;
1298 if (ndopts.nd_opts_src_lladdr) {
1299 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1300 skb->dev);
1301 if (!lladdr) {
1302 ND_PRINTK2(KERN_WARNING
1303 "ICMPv6 RA: invalid link-layer address length\n");
1304 goto out;
1305 }
1306 }
1307 neigh_update(neigh, lladdr, NUD_STALE,
1308 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1309 NEIGH_UPDATE_F_OVERRIDE|
1310 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1311 NEIGH_UPDATE_F_ISROUTER);
1312 }
1313
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001314#ifdef CONFIG_IPV6_ROUTE_INFO
YOSHIFUJI Hideaki09c884d2006-03-20 17:07:03 -08001315 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001316 struct nd_opt_hdr *p;
1317 for (p = ndopts.nd_opts_ri;
1318 p;
1319 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
YOSHIFUJI Hideaki6294e002008-03-15 23:56:52 -04001320 struct route_info *ri = (struct route_info *)p;
1321#ifdef CONFIG_IPV6_NDISC_NODETYPE
1322 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT &&
1323 ri->prefix_len == 0)
1324 continue;
1325#endif
1326 if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
YOSHIFUJI Hideaki09c884d2006-03-20 17:07:03 -08001327 continue;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001328 rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001329 &ipv6_hdr(skb)->saddr);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001330 }
1331 }
1332#endif
1333
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001334#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001335 /* skip link-specific ndopts from interior routers */
1336 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1337 goto out;
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001338#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001339
YOSHIFUJI Hideakic4fd30e2006-03-20 16:55:26 -08001340 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 struct nd_opt_hdr *p;
1342 for (p = ndopts.nd_opts_pi;
1343 p;
1344 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1345 addrconf_prefix_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3);
1346 }
1347 }
1348
1349 if (ndopts.nd_opts_mtu) {
Al Viroe69a4ad2006-11-14 20:56:00 -08001350 __be32 n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 u32 mtu;
1352
Al Viroe69a4ad2006-11-14 20:56:00 -08001353 memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1354 mtu = ntohl(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355
1356 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1357 ND_PRINTK2(KERN_WARNING
1358 "ICMPv6 RA: invalid mtu: %d\n",
1359 mtu);
1360 } else if (in6_dev->cnf.mtu6 != mtu) {
1361 in6_dev->cnf.mtu6 = mtu;
1362
1363 if (rt)
1364 rt->u.dst.metrics[RTAX_MTU-1] = mtu;
1365
1366 rt6_mtu_change(skb->dev, mtu);
1367 }
1368 }
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001369
Pierre Ynard31910572007-10-10 21:22:05 -07001370 if (ndopts.nd_useropts) {
YOSHIFUJI Hideaki61cf46a2008-01-22 17:32:53 +09001371 struct nd_opt_hdr *p;
1372 for (p = ndopts.nd_useropts;
1373 p;
1374 p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) {
1375 ndisc_ra_useropt(skb, p);
Pierre Ynard31910572007-10-10 21:22:05 -07001376 }
1377 }
1378
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1380 ND_PRINTK2(KERN_WARNING
1381 "ICMPv6 RA: invalid RA options");
1382 }
1383out:
1384 if (rt)
1385 dst_release(&rt->u.dst);
1386 else if (neigh)
1387 neigh_release(neigh);
1388 in6_dev_put(in6_dev);
1389}
1390
1391static void ndisc_redirect_rcv(struct sk_buff *skb)
1392{
1393 struct inet6_dev *in6_dev;
1394 struct icmp6hdr *icmph;
1395 struct in6_addr *dest;
1396 struct in6_addr *target; /* new first hop to destination */
1397 struct neighbour *neigh;
1398 int on_link = 0;
1399 struct ndisc_options ndopts;
1400 int optlen;
1401 u8 *lladdr = NULL;
1402
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001403#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001404 switch (skb->ndisc_nodetype) {
1405 case NDISC_NODETYPE_HOST:
1406 case NDISC_NODETYPE_NODEFAULT:
1407 ND_PRINTK2(KERN_WARNING
1408 "ICMPv6 Redirect: from host or unauthorized router\n");
1409 return;
1410 }
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001411#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001412
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001413 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 ND_PRINTK2(KERN_WARNING
1415 "ICMPv6 Redirect: source address is not link-local.\n");
1416 return;
1417 }
1418
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001419 optlen = skb->tail - skb->transport_header;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1421
1422 if (optlen < 0) {
1423 ND_PRINTK2(KERN_WARNING
1424 "ICMPv6 Redirect: packet too short\n");
1425 return;
1426 }
1427
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -03001428 icmph = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429 target = (struct in6_addr *) (icmph + 1);
1430 dest = target + 1;
1431
1432 if (ipv6_addr_is_multicast(dest)) {
1433 ND_PRINTK2(KERN_WARNING
1434 "ICMPv6 Redirect: destination address is multicast.\n");
1435 return;
1436 }
1437
1438 if (ipv6_addr_equal(dest, target)) {
1439 on_link = 1;
Brian Haleybf0b48d2007-10-08 00:12:05 -07001440 } else if (ipv6_addr_type(target) !=
1441 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001442 ND_PRINTK2(KERN_WARNING
Brian Haleybf0b48d2007-10-08 00:12:05 -07001443 "ICMPv6 Redirect: target address is not link-local unicast.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 return;
1445 }
1446
1447 in6_dev = in6_dev_get(skb->dev);
1448 if (!in6_dev)
1449 return;
1450 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects) {
1451 in6_dev_put(in6_dev);
1452 return;
1453 }
1454
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001455 /* RFC2461 8.1:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456 * The IP source address of the Redirect MUST be the same as the current
1457 * first-hop router for the specified ICMP Destination Address.
1458 */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001459
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) {
1461 ND_PRINTK2(KERN_WARNING
1462 "ICMPv6 Redirect: invalid ND options\n");
1463 in6_dev_put(in6_dev);
1464 return;
1465 }
1466 if (ndopts.nd_opts_tgt_lladdr) {
1467 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1468 skb->dev);
1469 if (!lladdr) {
1470 ND_PRINTK2(KERN_WARNING
1471 "ICMPv6 Redirect: invalid link-layer address length\n");
1472 in6_dev_put(in6_dev);
1473 return;
1474 }
1475 }
1476
1477 neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1);
1478 if (neigh) {
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001479 rt6_redirect(dest, &ipv6_hdr(skb)->daddr,
1480 &ipv6_hdr(skb)->saddr, neigh, lladdr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481 on_link);
1482 neigh_release(neigh);
1483 }
1484 in6_dev_put(in6_dev);
1485}
1486
1487void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh,
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +09001488 const struct in6_addr *target)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489{
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001490 struct net_device *dev = skb->dev;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001491 struct net *net = dev_net(dev);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001492 struct sock *sk = net->ipv6.ndisc_sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1494 struct sk_buff *buff;
1495 struct icmp6hdr *icmph;
1496 struct in6_addr saddr_buf;
1497 struct in6_addr *addrp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498 struct rt6_info *rt;
1499 struct dst_entry *dst;
1500 struct inet6_dev *idev;
1501 struct flowi fl;
1502 u8 *opt;
1503 int rd_len;
1504 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1506
Neil Horman95c385b2007-04-25 17:08:10 -07001507 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 ND_PRINTK2(KERN_WARNING
1509 "ICMPv6 Redirect: no link-local address on %s\n",
1510 dev->name);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001511 return;
1512 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001514 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
Brian Haleybf0b48d2007-10-08 00:12:05 -07001515 ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
Li Yewang29556522007-01-30 14:33:20 -08001516 ND_PRINTK2(KERN_WARNING
Brian Haleybf0b48d2007-10-08 00:12:05 -07001517 "ICMPv6 Redirect: target address is not link-local unicast.\n");
Li Yewang29556522007-01-30 14:33:20 -08001518 return;
1519 }
1520
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001521 icmpv6_flow_init(sk, &fl, NDISC_REDIRECT,
YOSHIFUJI Hideaki95e41e92007-12-06 15:43:30 -08001522 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001524 dst = ip6_route_output(net, NULL, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525 if (dst == NULL)
1526 return;
1527
Alexey Dobriyan52479b62008-11-25 17:35:18 -08001528 err = xfrm_lookup(net, &dst, &fl, NULL, 0);
Patrick McHardye1044112005-09-08 15:11:55 -07001529 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531
1532 rt = (struct rt6_info *) dst;
1533
1534 if (rt->rt6i_flags & RTF_GATEWAY) {
1535 ND_PRINTK2(KERN_WARNING
1536 "ICMPv6 Redirect: destination is not a neighbour.\n");
Ilpo Järvinend73f0802009-02-06 23:47:37 -08001537 goto release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 }
Ilpo Järvinend73f0802009-02-06 23:47:37 -08001539 if (!xrlim_allow(dst, 1*HZ))
1540 goto release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541
1542 if (dev->addr_len) {
1543 read_lock_bh(&neigh->lock);
1544 if (neigh->nud_state & NUD_VALID) {
1545 memcpy(ha_buf, neigh->ha, dev->addr_len);
1546 read_unlock_bh(&neigh->lock);
1547 ha = ha_buf;
1548 len += ndisc_opt_addr_space(dev);
1549 } else
1550 read_unlock_bh(&neigh->lock);
1551 }
1552
1553 rd_len = min_t(unsigned int,
1554 IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8);
1555 rd_len &= ~0x7;
1556 len += rd_len;
1557
David S. Millerd54a81d2006-12-02 21:00:06 -08001558 buff = sock_alloc_send_skb(sk,
1559 (MAX_HEADER + sizeof(struct ipv6hdr) +
Johannes Bergf5184d22008-05-12 20:48:31 -07001560 len + LL_ALLOCATED_SPACE(dev)),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 1, &err);
1562 if (buff == NULL) {
1563 ND_PRINTK0(KERN_ERR
1564 "ICMPv6 Redirect: %s() failed to allocate an skb.\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001565 __func__);
Ilpo Järvinend73f0802009-02-06 23:47:37 -08001566 goto release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567 }
1568
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569 skb_reserve(buff, LL_RESERVED_SPACE(dev));
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001570 ip6_nd_hdr(sk, buff, dev, &saddr_buf, &ipv6_hdr(skb)->saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571 IPPROTO_ICMPV6, len);
1572
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001573 skb_set_transport_header(buff, skb_tail_pointer(buff) - buff->data);
Arnaldo Carvalho de Melod10ba342007-03-14 21:05:37 -03001574 skb_put(buff, len);
1575 icmph = icmp6_hdr(buff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576
1577 memset(icmph, 0, sizeof(struct icmp6hdr));
1578 icmph->icmp6_type = NDISC_REDIRECT;
1579
1580 /*
1581 * copy target and destination addresses
1582 */
1583
1584 addrp = (struct in6_addr *)(icmph + 1);
1585 ipv6_addr_copy(addrp, target);
1586 addrp++;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001587 ipv6_addr_copy(addrp, &ipv6_hdr(skb)->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588
1589 opt = (u8*) (addrp + 1);
1590
1591 /*
1592 * include target_address option
1593 */
1594
1595 if (ha)
1596 opt = ndisc_fill_addr_option(opt, ND_OPT_TARGET_LL_ADDR, ha,
1597 dev->addr_len, dev->type);
1598
1599 /*
1600 * build redirect option and copy skb over to the new packet.
1601 */
1602
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001603 memset(opt, 0, 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604 *(opt++) = ND_OPT_REDIRECT_HDR;
1605 *(opt++) = (rd_len >> 3);
1606 opt += 6;
1607
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001608 memcpy(opt, ipv6_hdr(skb), rd_len - 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001610 icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &ipv6_hdr(skb)->saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611 len, IPPROTO_ICMPV6,
Joe Perches07f07572008-11-19 15:44:53 -08001612 csum_partial(icmph, len, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613
1614 buff->dst = dst;
1615 idev = in6_dev_get(dst->dev);
Denis V. Lunev3bd653c2008-10-08 10:54:51 -07001616 IP6_INC_STATS(net, idev, IPSTATS_MIB_OUTREQUESTS);
Patrick McHardy6e23ae22007-11-19 18:53:30 -08001617 err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, buff, NULL, dst->dev,
1618 dst_output);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619 if (!err) {
Denis V. Lunev5c5d2442008-10-08 10:33:50 -07001620 ICMP6MSGOUT_INC_STATS(net, idev, NDISC_REDIRECT);
Denis V. Luneva862f6a2008-10-08 10:33:06 -07001621 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622 }
1623
1624 if (likely(idev != NULL))
1625 in6_dev_put(idev);
Ilpo Järvinend73f0802009-02-06 23:47:37 -08001626 return;
1627
1628release:
1629 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630}
1631
1632static void pndisc_redo(struct sk_buff *skb)
1633{
YOSHIFUJI Hideaki140e26fc2005-10-05 12:11:41 -07001634 ndisc_recv_ns(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635 kfree_skb(skb);
1636}
1637
1638int ndisc_rcv(struct sk_buff *skb)
1639{
1640 struct nd_msg *msg;
1641
1642 if (!pskb_may_pull(skb, skb->len))
1643 return 0;
1644
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001645 msg = (struct nd_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001647 __skb_push(skb, skb->data - skb_transport_header(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001649 if (ipv6_hdr(skb)->hop_limit != 255) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650 ND_PRINTK2(KERN_WARNING
1651 "ICMPv6 NDISC: invalid hop-limit: %d\n",
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001652 ipv6_hdr(skb)->hop_limit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653 return 0;
1654 }
1655
1656 if (msg->icmph.icmp6_code != 0) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001657 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 "ICMPv6 NDISC: invalid ICMPv6 code: %d\n",
1659 msg->icmph.icmp6_code);
1660 return 0;
1661 }
1662
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001663 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1664
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665 switch (msg->icmph.icmp6_type) {
1666 case NDISC_NEIGHBOUR_SOLICITATION:
1667 ndisc_recv_ns(skb);
1668 break;
1669
1670 case NDISC_NEIGHBOUR_ADVERTISEMENT:
1671 ndisc_recv_na(skb);
1672 break;
1673
1674 case NDISC_ROUTER_SOLICITATION:
1675 ndisc_recv_rs(skb);
1676 break;
1677
1678 case NDISC_ROUTER_ADVERTISEMENT:
1679 ndisc_router_discovery(skb);
1680 break;
1681
1682 case NDISC_REDIRECT:
1683 ndisc_redirect_rcv(skb);
1684 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07001685 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686
1687 return 0;
1688}
1689
1690static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1691{
1692 struct net_device *dev = ptr;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001693 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694
1695 switch (event) {
1696 case NETDEV_CHANGEADDR:
1697 neigh_changeaddr(&nd_tbl, dev);
Daniel Lezcano5b7c9312008-03-03 23:28:58 -08001698 fib6_run_gc(~0UL, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699 break;
1700 case NETDEV_DOWN:
1701 neigh_ifdown(&nd_tbl, dev);
Daniel Lezcano5b7c9312008-03-03 23:28:58 -08001702 fib6_run_gc(~0UL, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 break;
1704 default:
1705 break;
1706 }
1707
1708 return NOTIFY_DONE;
1709}
1710
1711static struct notifier_block ndisc_netdev_notifier = {
1712 .notifier_call = ndisc_netdev_event,
1713};
1714
1715#ifdef CONFIG_SYSCTL
1716static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1717 const char *func, const char *dev_name)
1718{
1719 static char warncomm[TASK_COMM_LEN];
1720 static int warned;
1721 if (strcmp(warncomm, current->comm) && warned < 5) {
1722 strcpy(warncomm, current->comm);
1723 printk(KERN_WARNING
1724 "process `%s' is using deprecated sysctl (%s) "
1725 "net.ipv6.neigh.%s.%s; "
1726 "Use net.ipv6.neigh.%s.%s_ms "
1727 "instead.\n",
1728 warncomm, func,
1729 dev_name, ctl->procname,
1730 dev_name, ctl->procname);
1731 warned++;
1732 }
1733}
1734
1735int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, struct file * filp, void __user *buffer, size_t *lenp, loff_t *ppos)
1736{
1737 struct net_device *dev = ctl->extra1;
1738 struct inet6_dev *idev;
1739 int ret;
1740
Eric W. Biedermand12af672007-10-18 03:05:25 -07001741 if ((strcmp(ctl->procname, "retrans_time") == 0) ||
1742 (strcmp(ctl->procname, "base_reachable_time") == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1744
Eric W. Biedermand12af672007-10-18 03:05:25 -07001745 if (strcmp(ctl->procname, "retrans_time") == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746 ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001747
1748 else if (strcmp(ctl->procname, "base_reachable_time") == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749 ret = proc_dointvec_jiffies(ctl, write,
1750 filp, buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001751
1752 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
YOSHIFUJI Hideakiad02ac12007-10-29 01:32:23 -07001753 (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754 ret = proc_dointvec_ms_jiffies(ctl, write,
1755 filp, buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001756 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 ret = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758
1759 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
Eric W. Biedermand12af672007-10-18 03:05:25 -07001760 if (ctl->data == &idev->nd_parms->base_reachable_time)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1762 idev->tstamp = jiffies;
1763 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1764 in6_dev_put(idev);
1765 }
1766 return ret;
1767}
1768
Alexey Dobriyanf221e722008-10-15 22:04:23 -07001769int ndisc_ifinfo_sysctl_strategy(ctl_table *ctl,
1770 void __user *oldval, size_t __user *oldlenp,
YOSHIFUJI Hideaki0686caa2008-05-19 16:25:42 -07001771 void __user *newval, size_t newlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772{
1773 struct net_device *dev = ctl->extra1;
1774 struct inet6_dev *idev;
1775 int ret;
1776
1777 if (ctl->ctl_name == NET_NEIGH_RETRANS_TIME ||
1778 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME)
1779 ndisc_warn_deprecated_sysctl(ctl, "procfs", dev ? dev->name : "default");
1780
1781 switch (ctl->ctl_name) {
1782 case NET_NEIGH_REACHABLE_TIME:
Alexey Dobriyanf221e722008-10-15 22:04:23 -07001783 ret = sysctl_jiffies(ctl, oldval, oldlenp, newval, newlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784 break;
1785 case NET_NEIGH_RETRANS_TIME_MS:
1786 case NET_NEIGH_REACHABLE_TIME_MS:
Alexey Dobriyanf221e722008-10-15 22:04:23 -07001787 ret = sysctl_ms_jiffies(ctl, oldval, oldlenp, newval, newlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 break;
1789 default:
1790 ret = 0;
1791 }
1792
1793 if (newval && newlen && ret > 0 &&
1794 dev && (idev = in6_dev_get(dev)) != NULL) {
1795 if (ctl->ctl_name == NET_NEIGH_REACHABLE_TIME ||
1796 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME_MS)
1797 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1798 idev->tstamp = jiffies;
1799 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1800 in6_dev_put(idev);
1801 }
1802
1803 return ret;
1804}
1805
1806#endif
1807
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001808static int ndisc_net_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001809{
1810 struct ipv6_pinfo *np;
1811 struct sock *sk;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001812 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813
Denis V. Lunev1ed85162008-04-03 14:31:03 -07001814 err = inet_ctl_sock_create(&sk, PF_INET6,
1815 SOCK_RAW, IPPROTO_ICMPV6, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816 if (err < 0) {
1817 ND_PRINTK0(KERN_ERR
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001818 "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819 err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820 return err;
1821 }
1822
Denis V. Lunev1ed85162008-04-03 14:31:03 -07001823 net->ipv6.ndisc_sk = sk;
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001824
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825 np = inet6_sk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 np->hop_limit = 255;
1827 /* Do not loopback ndisc messages */
1828 np->mc_loop = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001830 return 0;
1831}
1832
1833static void ndisc_net_exit(struct net *net)
1834{
Denis V. Lunev1ed85162008-04-03 14:31:03 -07001835 inet_ctl_sock_destroy(net->ipv6.ndisc_sk);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001836}
1837
1838static struct pernet_operations ndisc_net_ops = {
1839 .init = ndisc_net_init,
1840 .exit = ndisc_net_exit,
1841};
1842
1843int __init ndisc_init(void)
1844{
1845 int err;
1846
1847 err = register_pernet_subsys(&ndisc_net_ops);
1848 if (err)
1849 return err;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001850 /*
1851 * Initialize the neighbour table
1852 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853 neigh_table_init(&nd_tbl);
1854
1855#ifdef CONFIG_SYSCTL
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001856 err = neigh_sysctl_register(NULL, &nd_tbl.parms, NET_IPV6,
1857 NET_IPV6_NEIGH, "ipv6",
1858 &ndisc_ifinfo_sysctl_change,
1859 &ndisc_ifinfo_sysctl_strategy);
1860 if (err)
1861 goto out_unregister_pernet;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862#endif
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001863 err = register_netdevice_notifier(&ndisc_netdev_notifier);
1864 if (err)
1865 goto out_unregister_sysctl;
1866out:
1867 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001869out_unregister_sysctl:
1870#ifdef CONFIG_SYSCTL
1871 neigh_sysctl_unregister(&nd_tbl.parms);
1872out_unregister_pernet:
1873#endif
1874 unregister_pernet_subsys(&ndisc_net_ops);
1875 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876}
1877
1878void ndisc_cleanup(void)
1879{
Dmitry Mishin36f73d02006-11-03 16:08:19 -08001880 unregister_netdevice_notifier(&ndisc_netdev_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881#ifdef CONFIG_SYSCTL
1882 neigh_sysctl_unregister(&nd_tbl.parms);
1883#endif
1884 neigh_table_clear(&nd_tbl);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001885 unregister_pernet_subsys(&ndisc_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001886}