blob: 9eb68e92cc18108e762f24cc7f12307018f477cc [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
Brian Haleydae9de82009-06-02 00:20:26 -0700468 "ICMPv6 ND: %s() failed to allocate an skb, err=%d.\n",
469 __func__, err);
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
Eric Dumazetadf30902009-06-02 05:19:30 +0000533 skb_dst_set(skb, dst);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900534
535 idev = in6_dev_get(dst->dev);
Neil Hormanedf391f2009-04-27 02:45:02 -0700536 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
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}
Sascha Hlusiak64506922009-05-19 12:56:52 +0000661EXPORT_SYMBOL(ndisc_send_rs);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900662
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663
664static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
665{
666 /*
667 * "The sender MUST return an ICMP
668 * destination unreachable"
669 */
670 dst_link_failure(skb);
671 kfree_skb(skb);
672}
673
674/* Called with locked neigh: either read or both */
675
676static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
677{
678 struct in6_addr *saddr = NULL;
679 struct in6_addr mcaddr;
680 struct net_device *dev = neigh->dev;
681 struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
682 int probes = atomic_read(&neigh->probes);
683
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900684 if (skb && ipv6_chk_addr(dev_net(dev), &ipv6_hdr(skb)->saddr, dev, 1))
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700685 saddr = &ipv6_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686
687 if ((probes -= neigh->parms->ucast_probes) < 0) {
688 if (!(neigh->nud_state & NUD_VALID)) {
Harvey Harrison5b095d9892008-10-29 12:52:50 -0700689 ND_PRINTK1(KERN_DEBUG "%s(): trying to ucast probe in NUD_INVALID: %pI6\n",
Harvey Harrison0c6ce782008-10-28 16:09:23 -0700690 __func__, target);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 }
692 ndisc_send_ns(dev, neigh, target, target, saddr);
693 } else if ((probes -= neigh->parms->app_probes) < 0) {
694#ifdef CONFIG_ARPD
695 neigh_app_ns(neigh);
696#endif
697 } else {
698 addrconf_addr_solict_mult(target, &mcaddr);
699 ndisc_send_ns(dev, NULL, target, &mcaddr, saddr);
700 }
701}
702
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900703static int pndisc_is_router(const void *pkey,
704 struct net_device *dev)
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700705{
706 struct pneigh_entry *n;
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900707 int ret = -1;
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700708
709 read_lock_bh(&nd_tbl.lock);
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900710 n = __pneigh_lookup(&nd_tbl, dev_net(dev), pkey, dev);
711 if (n)
712 ret = !!(n->flags & NTF_ROUTER);
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700713 read_unlock_bh(&nd_tbl.lock);
714
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900715 return ret;
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700716}
717
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718static void ndisc_recv_ns(struct sk_buff *skb)
719{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700720 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700721 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
722 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 u8 *lladdr = NULL;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700724 u32 ndoptlen = skb->tail - (skb->transport_header +
725 offsetof(struct nd_msg, opt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 struct ndisc_options ndopts;
727 struct net_device *dev = skb->dev;
728 struct inet6_ifaddr *ifp;
729 struct inet6_dev *idev = NULL;
730 struct neighbour *neigh;
731 int dad = ipv6_addr_any(saddr);
732 int inc;
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900733 int is_router = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734
735 if (ipv6_addr_is_multicast(&msg->target)) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900736 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 "ICMPv6 NS: multicast target address");
738 return;
739 }
740
741 /*
742 * RFC2461 7.1.1:
743 * DAD has to be destined for solicited node multicast address.
744 */
745 if (dad &&
746 !(daddr->s6_addr32[0] == htonl(0xff020000) &&
747 daddr->s6_addr32[1] == htonl(0x00000000) &&
748 daddr->s6_addr32[2] == htonl(0x00000001) &&
749 daddr->s6_addr [12] == 0xff )) {
750 ND_PRINTK2(KERN_WARNING
751 "ICMPv6 NS: bad DAD packet (wrong destination)\n");
752 return;
753 }
754
755 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900756 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 "ICMPv6 NS: invalid ND options\n");
758 return;
759 }
760
761 if (ndopts.nd_opts_src_lladdr) {
762 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
763 if (!lladdr) {
764 ND_PRINTK2(KERN_WARNING
765 "ICMPv6 NS: invalid link-layer address length\n");
766 return;
767 }
768
769 /* RFC2461 7.1.1:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900770 * If the IP source address is the unspecified address,
771 * there MUST NOT be source link-layer address option
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 * in the message.
773 */
774 if (dad) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900775 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 "ICMPv6 NS: bad DAD packet (link-layer address option)\n");
777 return;
778 }
779 }
780
781 inc = ipv6_addr_is_multicast(daddr);
782
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900783 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
Daniel Lezcanoa18bc692008-03-07 11:14:49 -0800784 if (ifp) {
Neil Horman95c385b2007-04-25 17:08:10 -0700785
786 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
787 if (dad) {
788 if (dev->type == ARPHRD_IEEE802_TR) {
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -0700789 const unsigned char *sadr;
790 sadr = skb_mac_header(skb);
Neil Horman95c385b2007-04-25 17:08:10 -0700791 if (((sadr[8] ^ dev->dev_addr[0]) & 0x7f) == 0 &&
792 sadr[9] == dev->dev_addr[1] &&
793 sadr[10] == dev->dev_addr[2] &&
794 sadr[11] == dev->dev_addr[3] &&
795 sadr[12] == dev->dev_addr[4] &&
796 sadr[13] == dev->dev_addr[5]) {
797 /* looped-back to us */
798 goto out;
799 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 }
Neil Horman95c385b2007-04-25 17:08:10 -0700801
802 /*
803 * We are colliding with another node
804 * who is doing DAD
805 * so fail our DAD process
806 */
807 addrconf_dad_failure(ifp);
Denis V. Lunev9e3be4b2007-09-11 11:04:49 +0200808 return;
Neil Horman95c385b2007-04-25 17:08:10 -0700809 } else {
810 /*
811 * This is not a dad solicitation.
812 * If we are an optimistic node,
813 * we should respond.
814 * Otherwise, we should ignore it.
815 */
816 if (!(ifp->flags & IFA_F_OPTIMISTIC))
817 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 }
820
821 idev = ifp->idev;
822 } else {
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700823 struct net *net = dev_net(dev);
824
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 idev = in6_dev_get(dev);
826 if (!idev) {
827 /* XXX: count this drop? */
828 return;
829 }
830
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700831 if (ipv6_chk_acast_addr(net, dev, &msg->target) ||
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900832 (idev->cnf.forwarding &&
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700833 (net->ipv6.devconf_all->proxy_ndp || idev->cnf.proxy_ndp) &&
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900834 (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) {
Patrick McHardya61bbcf2005-08-14 17:24:31 -0700835 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836 skb->pkt_type != PACKET_HOST &&
837 inc != 0 &&
838 idev->nd_parms->proxy_delay != 0) {
839 /*
840 * for anycast or proxy,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900841 * sender should delay its response
842 * by a random time between 0 and
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 * MAX_ANYCAST_DELAY_TIME seconds.
844 * (RFC2461) -- yoshfuji
845 */
846 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
847 if (n)
848 pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
849 goto out;
850 }
851 } else
852 goto out;
853 }
854
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900855 if (is_router < 0)
856 is_router = !!idev->cnf.forwarding;
Ville Nuorvala62dd9312006-09-22 14:43:19 -0700857
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 if (dad) {
YOSHIFUJI Hideakif3ee4012008-04-10 15:42:11 +0900859 ndisc_send_na(dev, NULL, &in6addr_linklocal_allnodes, &msg->target,
Ville Nuorvala62dd9312006-09-22 14:43:19 -0700860 is_router, 0, (ifp != NULL), 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 goto out;
862 }
863
864 if (inc)
865 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
866 else
867 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
868
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900869 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 * update / create cache entry
871 * for the source address
872 */
873 neigh = __neigh_lookup(&nd_tbl, saddr, dev,
874 !inc || lladdr || !dev->addr_len);
875 if (neigh)
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900876 neigh_update(neigh, lladdr, NUD_STALE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 NEIGH_UPDATE_F_WEAK_OVERRIDE|
878 NEIGH_UPDATE_F_OVERRIDE);
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700879 if (neigh || !dev->header_ops) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 ndisc_send_na(dev, neigh, saddr, &msg->target,
Ville Nuorvala62dd9312006-09-22 14:43:19 -0700881 is_router,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 1, (ifp != NULL && inc), inc);
883 if (neigh)
884 neigh_release(neigh);
885 }
886
887out:
888 if (ifp)
889 in6_ifa_put(ifp);
890 else
891 in6_dev_put(idev);
892
893 return;
894}
895
896static void ndisc_recv_na(struct sk_buff *skb)
897{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700898 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700899 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
900 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 u8 *lladdr = NULL;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700902 u32 ndoptlen = skb->tail - (skb->transport_header +
903 offsetof(struct nd_msg, opt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 struct ndisc_options ndopts;
905 struct net_device *dev = skb->dev;
906 struct inet6_ifaddr *ifp;
907 struct neighbour *neigh;
908
909 if (skb->len < sizeof(struct nd_msg)) {
910 ND_PRINTK2(KERN_WARNING
911 "ICMPv6 NA: packet too short\n");
912 return;
913 }
914
915 if (ipv6_addr_is_multicast(&msg->target)) {
916 ND_PRINTK2(KERN_WARNING
917 "ICMPv6 NA: target address is multicast.\n");
918 return;
919 }
920
921 if (ipv6_addr_is_multicast(daddr) &&
922 msg->icmph.icmp6_solicited) {
923 ND_PRINTK2(KERN_WARNING
924 "ICMPv6 NA: solicited NA is multicasted.\n");
925 return;
926 }
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900927
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
929 ND_PRINTK2(KERN_WARNING
930 "ICMPv6 NS: invalid ND option\n");
931 return;
932 }
933 if (ndopts.nd_opts_tgt_lladdr) {
934 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
935 if (!lladdr) {
936 ND_PRINTK2(KERN_WARNING
937 "ICMPv6 NA: invalid link-layer address length\n");
938 return;
939 }
940 }
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900941 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
Daniel Lezcanoa18bc692008-03-07 11:14:49 -0800942 if (ifp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 if (ifp->flags & IFA_F_TENTATIVE) {
944 addrconf_dad_failure(ifp);
945 return;
946 }
947 /* What should we make now? The advertisement
948 is invalid, but ndisc specs say nothing
949 about it. It could be misconfiguration, or
950 an smart proxy agent tries to help us :-)
Jan Sembera24fc7b82008-12-09 15:48:32 -0800951
952 We should not print the error if NA has been
953 received from loopback - it is just our own
954 unsolicited advertisement.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 */
Jan Sembera24fc7b82008-12-09 15:48:32 -0800956 if (skb->pkt_type != PACKET_LOOPBACK)
957 ND_PRINTK1(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 "ICMPv6 NA: someone advertises our address on %s!\n",
959 ifp->idev->dev->name);
960 in6_ifa_put(ifp);
961 return;
962 }
963 neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
964
965 if (neigh) {
966 u8 old_flags = neigh->flags;
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700967 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968
969 if (neigh->nud_state & NUD_FAILED)
970 goto out;
971
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -0700972 /*
973 * Don't update the neighbor cache entry on a proxy NA from
974 * ourselves because either the proxied node is off link or it
975 * has already sent a NA to us.
976 */
977 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700978 net->ipv6.devconf_all->forwarding && net->ipv6.devconf_all->proxy_ndp &&
979 pneigh_lookup(&nd_tbl, net, &msg->target, dev, 0)) {
YOSHIFUJI Hideakifbea49e2006-09-22 14:43:49 -0700980 /* XXX: idev->cnf.prixy_ndp */
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -0700981 goto out;
YOSHIFUJI Hideakifbea49e2006-09-22 14:43:49 -0700982 }
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -0700983
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 neigh_update(neigh, lladdr,
985 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
986 NEIGH_UPDATE_F_WEAK_OVERRIDE|
987 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
988 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
989 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));
990
991 if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
992 /*
993 * Change: router to host
994 */
995 struct rt6_info *rt;
996 rt = rt6_get_dflt_router(saddr, dev);
997 if (rt)
Thomas Grafe0a1ad732006-08-22 00:00:21 -0700998 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 }
1000
1001out:
1002 neigh_release(neigh);
1003 }
1004}
1005
1006static void ndisc_recv_rs(struct sk_buff *skb)
1007{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001008 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
1010 struct neighbour *neigh;
1011 struct inet6_dev *idev;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001012 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 struct ndisc_options ndopts;
1014 u8 *lladdr = NULL;
1015
1016 if (skb->len < sizeof(*rs_msg))
1017 return;
1018
1019 idev = in6_dev_get(skb->dev);
1020 if (!idev) {
1021 if (net_ratelimit())
1022 ND_PRINTK1("ICMP6 RS: can't find in6 device\n");
1023 return;
1024 }
1025
1026 /* Don't accept RS if we're not in router mode */
1027 if (!idev->cnf.forwarding)
1028 goto out;
1029
1030 /*
1031 * Don't update NCE if src = ::;
1032 * this implies that the source node has no ip address assigned yet.
1033 */
1034 if (ipv6_addr_any(saddr))
1035 goto out;
1036
1037 /* Parse ND options */
1038 if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {
1039 if (net_ratelimit())
1040 ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n");
1041 goto out;
1042 }
1043
1044 if (ndopts.nd_opts_src_lladdr) {
1045 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1046 skb->dev);
1047 if (!lladdr)
1048 goto out;
1049 }
1050
1051 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
1052 if (neigh) {
1053 neigh_update(neigh, lladdr, NUD_STALE,
1054 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1055 NEIGH_UPDATE_F_OVERRIDE|
1056 NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
1057 neigh_release(neigh);
1058 }
1059out:
1060 in6_dev_put(idev);
1061}
1062
Pierre Ynard31910572007-10-10 21:22:05 -07001063static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt)
1064{
1065 struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra);
1066 struct sk_buff *skb;
1067 struct nlmsghdr *nlh;
1068 struct nduseroptmsg *ndmsg;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001069 struct net *net = dev_net(ra->dev);
Pierre Ynard31910572007-10-10 21:22:05 -07001070 int err;
1071 int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg)
1072 + (opt->nd_opt_len << 3));
1073 size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr));
1074
1075 skb = nlmsg_new(msg_size, GFP_ATOMIC);
1076 if (skb == NULL) {
1077 err = -ENOBUFS;
1078 goto errout;
1079 }
1080
1081 nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0);
1082 if (nlh == NULL) {
1083 goto nla_put_failure;
1084 }
1085
1086 ndmsg = nlmsg_data(nlh);
1087 ndmsg->nduseropt_family = AF_INET6;
Pierre Ynarddbb2ed22007-11-12 17:58:35 -08001088 ndmsg->nduseropt_ifindex = ra->dev->ifindex;
Pierre Ynard31910572007-10-10 21:22:05 -07001089 ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type;
1090 ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code;
1091 ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3;
1092
1093 memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3);
1094
1095 NLA_PUT(skb, NDUSEROPT_SRCADDR, sizeof(struct in6_addr),
1096 &ipv6_hdr(ra)->saddr);
1097 nlmsg_end(skb, nlh);
1098
Pablo Neira Ayuso1ce85fe2009-02-24 23:18:28 -08001099 rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL, GFP_ATOMIC);
Pierre Ynard31910572007-10-10 21:22:05 -07001100 return;
1101
1102nla_put_failure:
1103 nlmsg_free(skb);
1104 err = -EMSGSIZE;
1105errout:
Daniel Lezcanoa18bc692008-03-07 11:14:49 -08001106 rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err);
Pierre Ynard31910572007-10-10 21:22:05 -07001107}
1108
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109static void ndisc_router_discovery(struct sk_buff *skb)
1110{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001111 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 struct neighbour *neigh = NULL;
1113 struct inet6_dev *in6_dev;
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001114 struct rt6_info *rt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115 int lifetime;
1116 struct ndisc_options ndopts;
1117 int optlen;
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001118 unsigned int pref = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119
1120 __u8 * opt = (__u8 *)(ra_msg + 1);
1121
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001122 optlen = (skb->tail - skb->transport_header) - sizeof(struct ra_msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001124 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 ND_PRINTK2(KERN_WARNING
1126 "ICMPv6 RA: source address is not link-local.\n");
1127 return;
1128 }
1129 if (optlen < 0) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001130 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131 "ICMPv6 RA: packet too short\n");
1132 return;
1133 }
1134
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001135#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001136 if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) {
1137 ND_PRINTK2(KERN_WARNING
1138 "ICMPv6 RA: from host or unauthorized router\n");
1139 return;
1140 }
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001141#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001142
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 /*
1144 * set the RA_RECV flag in the interface
1145 */
1146
1147 in6_dev = in6_dev_get(skb->dev);
1148 if (in6_dev == NULL) {
1149 ND_PRINTK0(KERN_ERR
1150 "ICMPv6 RA: can't find inet6 device for %s.\n",
1151 skb->dev->name);
1152 return;
1153 }
1154 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_ra) {
1155 in6_dev_put(in6_dev);
1156 return;
1157 }
1158
1159 if (!ndisc_parse_options(opt, optlen, &ndopts)) {
1160 in6_dev_put(in6_dev);
1161 ND_PRINTK2(KERN_WARNING
1162 "ICMP6 RA: invalid ND options\n");
1163 return;
1164 }
1165
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001166#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001167 /* skip link-specific parameters from interior routers */
1168 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1169 goto skip_linkparms;
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001170#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001171
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172 if (in6_dev->if_flags & IF_RS_SENT) {
1173 /*
1174 * flag that an RA was received after an RS was sent
1175 * out on this interface.
1176 */
1177 in6_dev->if_flags |= IF_RA_RCVD;
1178 }
1179
1180 /*
1181 * Remember the managed/otherconf flags from most recently
1182 * received RA message (RFC 2462) -- yoshfuji
1183 */
1184 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1185 IF_RA_OTHERCONF)) |
1186 (ra_msg->icmph.icmp6_addrconf_managed ?
1187 IF_RA_MANAGED : 0) |
1188 (ra_msg->icmph.icmp6_addrconf_other ?
1189 IF_RA_OTHERCONF : 0);
1190
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001191 if (!in6_dev->cnf.accept_ra_defrtr)
1192 goto skip_defrtr;
1193
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1195
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001196#ifdef CONFIG_IPV6_ROUTER_PREF
1197 pref = ra_msg->icmph.icmp6_router_pref;
1198 /* 10b is handled as if it were 00b (medium) */
YOSHIFUJI Hideaki930d6ff2006-03-20 17:05:30 -08001199 if (pref == ICMPV6_ROUTER_PREF_INVALID ||
YOSHIFUJI Hideaki6d5b78c2007-06-22 16:07:04 -07001200 !in6_dev->cnf.accept_ra_rtr_pref)
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001201 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1202#endif
1203
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001204 rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205
1206 if (rt)
1207 neigh = rt->rt6i_nexthop;
1208
1209 if (rt && lifetime == 0) {
1210 neigh_clone(neigh);
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001211 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212 rt = NULL;
1213 }
1214
1215 if (rt == NULL && lifetime) {
1216 ND_PRINTK3(KERN_DEBUG
1217 "ICMPv6 RA: adding default router.\n");
1218
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001219 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220 if (rt == NULL) {
1221 ND_PRINTK0(KERN_ERR
1222 "ICMPv6 RA: %s() failed to add default route.\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001223 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224 in6_dev_put(in6_dev);
1225 return;
1226 }
1227
1228 neigh = rt->rt6i_nexthop;
1229 if (neigh == NULL) {
1230 ND_PRINTK0(KERN_ERR
1231 "ICMPv6 RA: %s() got default router without neighbour.\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001232 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 dst_release(&rt->u.dst);
1234 in6_dev_put(in6_dev);
1235 return;
1236 }
1237 neigh->flags |= NTF_ROUTER;
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001238 } else if (rt) {
Pedro Ribeiro22441cf2008-10-15 15:47:49 -07001239 rt->rt6i_flags = (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240 }
1241
1242 if (rt)
1243 rt->rt6i_expires = jiffies + (HZ * lifetime);
1244
1245 if (ra_msg->icmph.icmp6_hop_limit) {
1246 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1247 if (rt)
1248 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = ra_msg->icmph.icmp6_hop_limit;
1249 }
1250
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001251skip_defrtr:
1252
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 /*
1254 * Update Reachable Time and Retrans Timer
1255 */
1256
1257 if (in6_dev->nd_parms) {
1258 unsigned long rtime = ntohl(ra_msg->retrans_timer);
1259
1260 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1261 rtime = (rtime*HZ)/1000;
1262 if (rtime < HZ/10)
1263 rtime = HZ/10;
1264 in6_dev->nd_parms->retrans_time = rtime;
1265 in6_dev->tstamp = jiffies;
1266 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1267 }
1268
1269 rtime = ntohl(ra_msg->reachable_time);
1270 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1271 rtime = (rtime*HZ)/1000;
1272
1273 if (rtime < HZ/10)
1274 rtime = HZ/10;
1275
1276 if (rtime != in6_dev->nd_parms->base_reachable_time) {
1277 in6_dev->nd_parms->base_reachable_time = rtime;
1278 in6_dev->nd_parms->gc_staletime = 3 * rtime;
1279 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1280 in6_dev->tstamp = jiffies;
1281 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1282 }
1283 }
1284 }
1285
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001286#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001287skip_linkparms:
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001288#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001289
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290 /*
1291 * Process options.
1292 */
1293
1294 if (!neigh)
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001295 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296 skb->dev, 1);
1297 if (neigh) {
1298 u8 *lladdr = NULL;
1299 if (ndopts.nd_opts_src_lladdr) {
1300 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1301 skb->dev);
1302 if (!lladdr) {
1303 ND_PRINTK2(KERN_WARNING
1304 "ICMPv6 RA: invalid link-layer address length\n");
1305 goto out;
1306 }
1307 }
1308 neigh_update(neigh, lladdr, NUD_STALE,
1309 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1310 NEIGH_UPDATE_F_OVERRIDE|
1311 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1312 NEIGH_UPDATE_F_ISROUTER);
1313 }
1314
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001315#ifdef CONFIG_IPV6_ROUTE_INFO
YOSHIFUJI Hideaki09c884d2006-03-20 17:07:03 -08001316 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001317 struct nd_opt_hdr *p;
1318 for (p = ndopts.nd_opts_ri;
1319 p;
1320 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
YOSHIFUJI Hideaki6294e002008-03-15 23:56:52 -04001321 struct route_info *ri = (struct route_info *)p;
1322#ifdef CONFIG_IPV6_NDISC_NODETYPE
1323 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT &&
1324 ri->prefix_len == 0)
1325 continue;
1326#endif
1327 if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
YOSHIFUJI Hideaki09c884d2006-03-20 17:07:03 -08001328 continue;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001329 rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001330 &ipv6_hdr(skb)->saddr);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001331 }
1332 }
1333#endif
1334
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001335#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001336 /* skip link-specific ndopts from interior routers */
1337 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1338 goto out;
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001339#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001340
YOSHIFUJI Hideakic4fd30e2006-03-20 16:55:26 -08001341 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 struct nd_opt_hdr *p;
1343 for (p = ndopts.nd_opts_pi;
1344 p;
1345 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1346 addrconf_prefix_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3);
1347 }
1348 }
1349
1350 if (ndopts.nd_opts_mtu) {
Al Viroe69a4ad2006-11-14 20:56:00 -08001351 __be32 n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 u32 mtu;
1353
Al Viroe69a4ad2006-11-14 20:56:00 -08001354 memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1355 mtu = ntohl(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356
1357 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1358 ND_PRINTK2(KERN_WARNING
1359 "ICMPv6 RA: invalid mtu: %d\n",
1360 mtu);
1361 } else if (in6_dev->cnf.mtu6 != mtu) {
1362 in6_dev->cnf.mtu6 = mtu;
1363
1364 if (rt)
1365 rt->u.dst.metrics[RTAX_MTU-1] = mtu;
1366
1367 rt6_mtu_change(skb->dev, mtu);
1368 }
1369 }
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001370
Pierre Ynard31910572007-10-10 21:22:05 -07001371 if (ndopts.nd_useropts) {
YOSHIFUJI Hideaki61cf46a2008-01-22 17:32:53 +09001372 struct nd_opt_hdr *p;
1373 for (p = ndopts.nd_useropts;
1374 p;
1375 p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) {
1376 ndisc_ra_useropt(skb, p);
Pierre Ynard31910572007-10-10 21:22:05 -07001377 }
1378 }
1379
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1381 ND_PRINTK2(KERN_WARNING
1382 "ICMPv6 RA: invalid RA options");
1383 }
1384out:
1385 if (rt)
1386 dst_release(&rt->u.dst);
1387 else if (neigh)
1388 neigh_release(neigh);
1389 in6_dev_put(in6_dev);
1390}
1391
1392static void ndisc_redirect_rcv(struct sk_buff *skb)
1393{
1394 struct inet6_dev *in6_dev;
1395 struct icmp6hdr *icmph;
1396 struct in6_addr *dest;
1397 struct in6_addr *target; /* new first hop to destination */
1398 struct neighbour *neigh;
1399 int on_link = 0;
1400 struct ndisc_options ndopts;
1401 int optlen;
1402 u8 *lladdr = NULL;
1403
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001404#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001405 switch (skb->ndisc_nodetype) {
1406 case NDISC_NODETYPE_HOST:
1407 case NDISC_NODETYPE_NODEFAULT:
1408 ND_PRINTK2(KERN_WARNING
1409 "ICMPv6 Redirect: from host or unauthorized router\n");
1410 return;
1411 }
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001412#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001413
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001414 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415 ND_PRINTK2(KERN_WARNING
1416 "ICMPv6 Redirect: source address is not link-local.\n");
1417 return;
1418 }
1419
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001420 optlen = skb->tail - skb->transport_header;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421 optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1422
1423 if (optlen < 0) {
1424 ND_PRINTK2(KERN_WARNING
1425 "ICMPv6 Redirect: packet too short\n");
1426 return;
1427 }
1428
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -03001429 icmph = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 target = (struct in6_addr *) (icmph + 1);
1431 dest = target + 1;
1432
1433 if (ipv6_addr_is_multicast(dest)) {
1434 ND_PRINTK2(KERN_WARNING
1435 "ICMPv6 Redirect: destination address is multicast.\n");
1436 return;
1437 }
1438
1439 if (ipv6_addr_equal(dest, target)) {
1440 on_link = 1;
Brian Haleybf0b48d2007-10-08 00:12:05 -07001441 } else if (ipv6_addr_type(target) !=
1442 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001443 ND_PRINTK2(KERN_WARNING
Brian Haleybf0b48d2007-10-08 00:12:05 -07001444 "ICMPv6 Redirect: target address is not link-local unicast.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445 return;
1446 }
1447
1448 in6_dev = in6_dev_get(skb->dev);
1449 if (!in6_dev)
1450 return;
1451 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects) {
1452 in6_dev_put(in6_dev);
1453 return;
1454 }
1455
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001456 /* RFC2461 8.1:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 * The IP source address of the Redirect MUST be the same as the current
1458 * first-hop router for the specified ICMP Destination Address.
1459 */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001460
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461 if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) {
1462 ND_PRINTK2(KERN_WARNING
1463 "ICMPv6 Redirect: invalid ND options\n");
1464 in6_dev_put(in6_dev);
1465 return;
1466 }
1467 if (ndopts.nd_opts_tgt_lladdr) {
1468 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1469 skb->dev);
1470 if (!lladdr) {
1471 ND_PRINTK2(KERN_WARNING
1472 "ICMPv6 Redirect: invalid link-layer address length\n");
1473 in6_dev_put(in6_dev);
1474 return;
1475 }
1476 }
1477
1478 neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1);
1479 if (neigh) {
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001480 rt6_redirect(dest, &ipv6_hdr(skb)->daddr,
1481 &ipv6_hdr(skb)->saddr, neigh, lladdr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482 on_link);
1483 neigh_release(neigh);
1484 }
1485 in6_dev_put(in6_dev);
1486}
1487
1488void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh,
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +09001489 const struct in6_addr *target)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490{
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001491 struct net_device *dev = skb->dev;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001492 struct net *net = dev_net(dev);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001493 struct sock *sk = net->ipv6.ndisc_sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494 int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1495 struct sk_buff *buff;
1496 struct icmp6hdr *icmph;
1497 struct in6_addr saddr_buf;
1498 struct in6_addr *addrp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499 struct rt6_info *rt;
1500 struct dst_entry *dst;
1501 struct inet6_dev *idev;
1502 struct flowi fl;
1503 u8 *opt;
1504 int rd_len;
1505 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1507
Neil Horman95c385b2007-04-25 17:08:10 -07001508 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509 ND_PRINTK2(KERN_WARNING
1510 "ICMPv6 Redirect: no link-local address on %s\n",
1511 dev->name);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001512 return;
1513 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001515 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
Brian Haleybf0b48d2007-10-08 00:12:05 -07001516 ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
Li Yewang29556522007-01-30 14:33:20 -08001517 ND_PRINTK2(KERN_WARNING
Brian Haleybf0b48d2007-10-08 00:12:05 -07001518 "ICMPv6 Redirect: target address is not link-local unicast.\n");
Li Yewang29556522007-01-30 14:33:20 -08001519 return;
1520 }
1521
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001522 icmpv6_flow_init(sk, &fl, NDISC_REDIRECT,
YOSHIFUJI Hideaki95e41e92007-12-06 15:43:30 -08001523 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001525 dst = ip6_route_output(net, NULL, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526 if (dst == NULL)
1527 return;
1528
Alexey Dobriyan52479b62008-11-25 17:35:18 -08001529 err = xfrm_lookup(net, &dst, &fl, NULL, 0);
Patrick McHardye1044112005-09-08 15:11:55 -07001530 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532
1533 rt = (struct rt6_info *) dst;
1534
1535 if (rt->rt6i_flags & RTF_GATEWAY) {
1536 ND_PRINTK2(KERN_WARNING
1537 "ICMPv6 Redirect: destination is not a neighbour.\n");
Ilpo Järvinend73f0802009-02-06 23:47:37 -08001538 goto release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539 }
Ilpo Järvinend73f0802009-02-06 23:47:37 -08001540 if (!xrlim_allow(dst, 1*HZ))
1541 goto release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542
1543 if (dev->addr_len) {
1544 read_lock_bh(&neigh->lock);
1545 if (neigh->nud_state & NUD_VALID) {
1546 memcpy(ha_buf, neigh->ha, dev->addr_len);
1547 read_unlock_bh(&neigh->lock);
1548 ha = ha_buf;
1549 len += ndisc_opt_addr_space(dev);
1550 } else
1551 read_unlock_bh(&neigh->lock);
1552 }
1553
1554 rd_len = min_t(unsigned int,
1555 IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8);
1556 rd_len &= ~0x7;
1557 len += rd_len;
1558
David S. Millerd54a81d2006-12-02 21:00:06 -08001559 buff = sock_alloc_send_skb(sk,
1560 (MAX_HEADER + sizeof(struct ipv6hdr) +
Johannes Bergf5184d22008-05-12 20:48:31 -07001561 len + LL_ALLOCATED_SPACE(dev)),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562 1, &err);
1563 if (buff == NULL) {
1564 ND_PRINTK0(KERN_ERR
Brian Haleydae9de82009-06-02 00:20:26 -07001565 "ICMPv6 Redirect: %s() failed to allocate an skb, err=%d.\n",
1566 __func__, err);
Ilpo Järvinend73f0802009-02-06 23:47:37 -08001567 goto release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568 }
1569
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 skb_reserve(buff, LL_RESERVED_SPACE(dev));
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001571 ip6_nd_hdr(sk, buff, dev, &saddr_buf, &ipv6_hdr(skb)->saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572 IPPROTO_ICMPV6, len);
1573
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001574 skb_set_transport_header(buff, skb_tail_pointer(buff) - buff->data);
Arnaldo Carvalho de Melod10ba342007-03-14 21:05:37 -03001575 skb_put(buff, len);
1576 icmph = icmp6_hdr(buff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577
1578 memset(icmph, 0, sizeof(struct icmp6hdr));
1579 icmph->icmp6_type = NDISC_REDIRECT;
1580
1581 /*
1582 * copy target and destination addresses
1583 */
1584
1585 addrp = (struct in6_addr *)(icmph + 1);
1586 ipv6_addr_copy(addrp, target);
1587 addrp++;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001588 ipv6_addr_copy(addrp, &ipv6_hdr(skb)->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589
1590 opt = (u8*) (addrp + 1);
1591
1592 /*
1593 * include target_address option
1594 */
1595
1596 if (ha)
1597 opt = ndisc_fill_addr_option(opt, ND_OPT_TARGET_LL_ADDR, ha,
1598 dev->addr_len, dev->type);
1599
1600 /*
1601 * build redirect option and copy skb over to the new packet.
1602 */
1603
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001604 memset(opt, 0, 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605 *(opt++) = ND_OPT_REDIRECT_HDR;
1606 *(opt++) = (rd_len >> 3);
1607 opt += 6;
1608
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001609 memcpy(opt, ipv6_hdr(skb), rd_len - 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001611 icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &ipv6_hdr(skb)->saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612 len, IPPROTO_ICMPV6,
Joe Perches07f07572008-11-19 15:44:53 -08001613 csum_partial(icmph, len, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614
Eric Dumazetadf30902009-06-02 05:19:30 +00001615 skb_dst_set(buff, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616 idev = in6_dev_get(dst->dev);
Neil Hormanedf391f2009-04-27 02:45:02 -07001617 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
Patrick McHardy6e23ae22007-11-19 18:53:30 -08001618 err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, buff, NULL, dst->dev,
1619 dst_output);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620 if (!err) {
Denis V. Lunev5c5d2442008-10-08 10:33:50 -07001621 ICMP6MSGOUT_INC_STATS(net, idev, NDISC_REDIRECT);
Denis V. Luneva862f6a2008-10-08 10:33:06 -07001622 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 }
1624
1625 if (likely(idev != NULL))
1626 in6_dev_put(idev);
Ilpo Järvinend73f0802009-02-06 23:47:37 -08001627 return;
1628
1629release:
1630 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631}
1632
1633static void pndisc_redo(struct sk_buff *skb)
1634{
YOSHIFUJI Hideaki140e26fc2005-10-05 12:11:41 -07001635 ndisc_recv_ns(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 kfree_skb(skb);
1637}
1638
1639int ndisc_rcv(struct sk_buff *skb)
1640{
1641 struct nd_msg *msg;
1642
1643 if (!pskb_may_pull(skb, skb->len))
1644 return 0;
1645
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001646 msg = (struct nd_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001648 __skb_push(skb, skb->data - skb_transport_header(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001650 if (ipv6_hdr(skb)->hop_limit != 255) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 ND_PRINTK2(KERN_WARNING
1652 "ICMPv6 NDISC: invalid hop-limit: %d\n",
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001653 ipv6_hdr(skb)->hop_limit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654 return 0;
1655 }
1656
1657 if (msg->icmph.icmp6_code != 0) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001658 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659 "ICMPv6 NDISC: invalid ICMPv6 code: %d\n",
1660 msg->icmph.icmp6_code);
1661 return 0;
1662 }
1663
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001664 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1665
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 switch (msg->icmph.icmp6_type) {
1667 case NDISC_NEIGHBOUR_SOLICITATION:
1668 ndisc_recv_ns(skb);
1669 break;
1670
1671 case NDISC_NEIGHBOUR_ADVERTISEMENT:
1672 ndisc_recv_na(skb);
1673 break;
1674
1675 case NDISC_ROUTER_SOLICITATION:
1676 ndisc_recv_rs(skb);
1677 break;
1678
1679 case NDISC_ROUTER_ADVERTISEMENT:
1680 ndisc_router_discovery(skb);
1681 break;
1682
1683 case NDISC_REDIRECT:
1684 ndisc_redirect_rcv(skb);
1685 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07001686 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687
1688 return 0;
1689}
1690
1691static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1692{
1693 struct net_device *dev = ptr;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001694 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695
1696 switch (event) {
1697 case NETDEV_CHANGEADDR:
1698 neigh_changeaddr(&nd_tbl, dev);
Daniel Lezcano5b7c9312008-03-03 23:28:58 -08001699 fib6_run_gc(~0UL, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001700 break;
1701 case NETDEV_DOWN:
1702 neigh_ifdown(&nd_tbl, dev);
Daniel Lezcano5b7c9312008-03-03 23:28:58 -08001703 fib6_run_gc(~0UL, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 break;
1705 default:
1706 break;
1707 }
1708
1709 return NOTIFY_DONE;
1710}
1711
1712static struct notifier_block ndisc_netdev_notifier = {
1713 .notifier_call = ndisc_netdev_event,
1714};
1715
1716#ifdef CONFIG_SYSCTL
1717static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1718 const char *func, const char *dev_name)
1719{
1720 static char warncomm[TASK_COMM_LEN];
1721 static int warned;
1722 if (strcmp(warncomm, current->comm) && warned < 5) {
1723 strcpy(warncomm, current->comm);
1724 printk(KERN_WARNING
1725 "process `%s' is using deprecated sysctl (%s) "
1726 "net.ipv6.neigh.%s.%s; "
1727 "Use net.ipv6.neigh.%s.%s_ms "
1728 "instead.\n",
1729 warncomm, func,
1730 dev_name, ctl->procname,
1731 dev_name, ctl->procname);
1732 warned++;
1733 }
1734}
1735
1736int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, struct file * filp, void __user *buffer, size_t *lenp, loff_t *ppos)
1737{
1738 struct net_device *dev = ctl->extra1;
1739 struct inet6_dev *idev;
1740 int ret;
1741
Eric W. Biedermand12af672007-10-18 03:05:25 -07001742 if ((strcmp(ctl->procname, "retrans_time") == 0) ||
1743 (strcmp(ctl->procname, "base_reachable_time") == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1745
Eric W. Biedermand12af672007-10-18 03:05:25 -07001746 if (strcmp(ctl->procname, "retrans_time") == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747 ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001748
1749 else if (strcmp(ctl->procname, "base_reachable_time") == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750 ret = proc_dointvec_jiffies(ctl, write,
1751 filp, buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001752
1753 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
YOSHIFUJI Hideakiad02ac12007-10-29 01:32:23 -07001754 (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001755 ret = proc_dointvec_ms_jiffies(ctl, write,
1756 filp, buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001757 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758 ret = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759
1760 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
Eric W. Biedermand12af672007-10-18 03:05:25 -07001761 if (ctl->data == &idev->nd_parms->base_reachable_time)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1763 idev->tstamp = jiffies;
1764 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1765 in6_dev_put(idev);
1766 }
1767 return ret;
1768}
1769
Alexey Dobriyanf221e722008-10-15 22:04:23 -07001770int ndisc_ifinfo_sysctl_strategy(ctl_table *ctl,
1771 void __user *oldval, size_t __user *oldlenp,
YOSHIFUJI Hideaki0686caa2008-05-19 16:25:42 -07001772 void __user *newval, size_t newlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773{
1774 struct net_device *dev = ctl->extra1;
1775 struct inet6_dev *idev;
1776 int ret;
1777
1778 if (ctl->ctl_name == NET_NEIGH_RETRANS_TIME ||
1779 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME)
1780 ndisc_warn_deprecated_sysctl(ctl, "procfs", dev ? dev->name : "default");
1781
1782 switch (ctl->ctl_name) {
1783 case NET_NEIGH_REACHABLE_TIME:
Alexey Dobriyanf221e722008-10-15 22:04:23 -07001784 ret = sysctl_jiffies(ctl, oldval, oldlenp, newval, newlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785 break;
1786 case NET_NEIGH_RETRANS_TIME_MS:
1787 case NET_NEIGH_REACHABLE_TIME_MS:
Alexey Dobriyanf221e722008-10-15 22:04:23 -07001788 ret = sysctl_ms_jiffies(ctl, oldval, oldlenp, newval, newlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789 break;
1790 default:
1791 ret = 0;
1792 }
1793
1794 if (newval && newlen && ret > 0 &&
1795 dev && (idev = in6_dev_get(dev)) != NULL) {
1796 if (ctl->ctl_name == NET_NEIGH_REACHABLE_TIME ||
1797 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME_MS)
1798 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1799 idev->tstamp = jiffies;
1800 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1801 in6_dev_put(idev);
1802 }
1803
1804 return ret;
1805}
1806
1807#endif
1808
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001809static int ndisc_net_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810{
1811 struct ipv6_pinfo *np;
1812 struct sock *sk;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001813 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814
Denis V. Lunev1ed85162008-04-03 14:31:03 -07001815 err = inet_ctl_sock_create(&sk, PF_INET6,
1816 SOCK_RAW, IPPROTO_ICMPV6, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 if (err < 0) {
1818 ND_PRINTK0(KERN_ERR
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001819 "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820 err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 return err;
1822 }
1823
Denis V. Lunev1ed85162008-04-03 14:31:03 -07001824 net->ipv6.ndisc_sk = sk;
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001825
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 np = inet6_sk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827 np->hop_limit = 255;
1828 /* Do not loopback ndisc messages */
1829 np->mc_loop = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001831 return 0;
1832}
1833
1834static void ndisc_net_exit(struct net *net)
1835{
Denis V. Lunev1ed85162008-04-03 14:31:03 -07001836 inet_ctl_sock_destroy(net->ipv6.ndisc_sk);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001837}
1838
1839static struct pernet_operations ndisc_net_ops = {
1840 .init = ndisc_net_init,
1841 .exit = ndisc_net_exit,
1842};
1843
1844int __init ndisc_init(void)
1845{
1846 int err;
1847
1848 err = register_pernet_subsys(&ndisc_net_ops);
1849 if (err)
1850 return err;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001851 /*
1852 * Initialize the neighbour table
1853 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854 neigh_table_init(&nd_tbl);
1855
1856#ifdef CONFIG_SYSCTL
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001857 err = neigh_sysctl_register(NULL, &nd_tbl.parms, NET_IPV6,
1858 NET_IPV6_NEIGH, "ipv6",
1859 &ndisc_ifinfo_sysctl_change,
1860 &ndisc_ifinfo_sysctl_strategy);
1861 if (err)
1862 goto out_unregister_pernet;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001863#endif
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001864 err = register_netdevice_notifier(&ndisc_netdev_notifier);
1865 if (err)
1866 goto out_unregister_sysctl;
1867out:
1868 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001870out_unregister_sysctl:
1871#ifdef CONFIG_SYSCTL
1872 neigh_sysctl_unregister(&nd_tbl.parms);
1873out_unregister_pernet:
1874#endif
1875 unregister_pernet_subsys(&ndisc_net_ops);
1876 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877}
1878
1879void ndisc_cleanup(void)
1880{
Dmitry Mishin36f73d02006-11-03 16:08:19 -08001881 unregister_netdevice_notifier(&ndisc_netdev_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882#ifdef CONFIG_SYSCTL
1883 neigh_sysctl_unregister(&nd_tbl.parms);
1884#endif
1885 neigh_table_clear(&nd_tbl);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001886 unregister_pernet_subsys(&ndisc_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887}