blob: d0f54d18e19b92de1407eb9a36fed5344363d01d [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
440/*
441 * Send a Neighbour Advertisement
442 */
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900443static void __ndisc_send(struct net_device *dev,
444 struct neighbour *neigh,
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +0900445 const struct in6_addr *daddr,
446 const struct in6_addr *saddr,
447 struct icmp6hdr *icmp6h, const struct in6_addr *target,
David L Stevens14878f72007-09-16 16:52:35 -0700448 int llinfo)
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900449{
450 struct flowi fl;
451 struct dst_entry *dst;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900452 struct net *net = dev_net(dev);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -0800453 struct sock *sk = net->ipv6.ndisc_sk;
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900454 struct sk_buff *skb;
455 struct icmp6hdr *hdr;
456 struct inet6_dev *idev;
457 int len;
458 int err;
David L Stevens14878f72007-09-16 16:52:35 -0700459 u8 *opt, type;
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900460
David L Stevens14878f72007-09-16 16:52:35 -0700461 type = icmp6h->icmp6_type;
462
Daniel Lezcano1762f7e2008-03-07 11:15:34 -0800463 icmpv6_flow_init(sk, &fl, type, saddr, daddr, dev->ifindex);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900464
YOSHIFUJI Hideaki3b009442007-12-06 16:11:48 -0800465 dst = icmp6_dst_alloc(dev, neigh, daddr);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900466 if (!dst)
467 return;
468
469 err = xfrm_lookup(&dst, &fl, NULL, 0);
470 if (err < 0)
471 return;
472
473 if (!dev->addr_len)
474 llinfo = 0;
475
476 len = sizeof(struct icmp6hdr) + (target ? sizeof(*target) : 0);
477 if (llinfo)
478 len += ndisc_opt_addr_space(dev);
479
480 skb = sock_alloc_send_skb(sk,
481 (MAX_HEADER + sizeof(struct ipv6hdr) +
Johannes Bergf5184d22008-05-12 20:48:31 -0700482 len + LL_ALLOCATED_SPACE(dev)),
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900483 1, &err);
484 if (!skb) {
485 ND_PRINTK0(KERN_ERR
486 "ICMPv6 ND: %s() failed to allocate an skb.\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800487 __func__);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900488 dst_release(dst);
489 return;
490 }
491
492 skb_reserve(skb, LL_RESERVED_SPACE(dev));
493 ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);
494
495 skb->transport_header = skb->tail;
496 skb_put(skb, len);
497
498 hdr = (struct icmp6hdr *)skb_transport_header(skb);
499 memcpy(hdr, icmp6h, sizeof(*hdr));
500
501 opt = skb_transport_header(skb) + sizeof(struct icmp6hdr);
502 if (target) {
503 ipv6_addr_copy((struct in6_addr *)opt, target);
504 opt += sizeof(*target);
505 }
506
507 if (llinfo)
508 ndisc_fill_addr_option(opt, llinfo, dev->dev_addr,
509 dev->addr_len, dev->type);
510
511 hdr->icmp6_cksum = csum_ipv6_magic(saddr, daddr, len,
512 IPPROTO_ICMPV6,
513 csum_partial((__u8 *) hdr,
514 len, 0));
515
516 skb->dst = dst;
517
518 idev = in6_dev_get(dst->dev);
Denis V. Lunev3bd653c2008-10-08 10:54:51 -0700519 IP6_INC_STATS(net, idev, IPSTATS_MIB_OUTREQUESTS);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900520
Patrick McHardy6e23ae22007-11-19 18:53:30 -0800521 err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev,
522 dst_output);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900523 if (!err) {
Denis V. Lunev5c5d2442008-10-08 10:33:50 -0700524 ICMP6MSGOUT_INC_STATS(net, idev, type);
Denis V. Luneva862f6a2008-10-08 10:33:06 -0700525 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900526 }
527
528 if (likely(idev != NULL))
529 in6_dev_put(idev);
530}
531
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532static void ndisc_send_na(struct net_device *dev, struct neighbour *neigh,
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +0900533 const struct in6_addr *daddr,
534 const struct in6_addr *solicited_addr,
535 int router, int solicited, int override, int inc_opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536{
537 struct in6_addr tmpaddr;
538 struct inet6_ifaddr *ifp;
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +0900539 const struct in6_addr *src_addr;
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900540 struct icmp6hdr icmp6h = {
541 .icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT,
542 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543
544 /* for anycast or proxy, solicited_addr != src_addr */
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900545 ifp = ipv6_get_ifaddr(dev_net(dev), solicited_addr, dev, 1);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900546 if (ifp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 src_addr = solicited_addr;
Neil Horman95c385b2007-04-25 17:08:10 -0700548 if (ifp->flags & IFA_F_OPTIMISTIC)
549 override = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 in6_ifa_put(ifp);
551 } else {
Brian Haley191cd582008-08-14 15:33:21 -0700552 if (ipv6_dev_get_saddr(dev_net(dev), dev, daddr,
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900553 inet6_sk(dev_net(dev)->ipv6.ndisc_sk)->srcprefs,
YOSHIFUJI Hideaki7cbca672008-03-25 09:37:42 +0900554 &tmpaddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 return;
556 src_addr = &tmpaddr;
557 }
558
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900559 icmp6h.icmp6_router = router;
560 icmp6h.icmp6_solicited = solicited;
561 icmp6h.icmp6_override = override;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900563 __ndisc_send(dev, neigh, daddr, src_addr,
564 &icmp6h, solicited_addr,
David L Stevens14878f72007-09-16 16:52:35 -0700565 inc_opt ? ND_OPT_TARGET_LL_ADDR : 0);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900566}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567
568void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh,
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +0900569 const struct in6_addr *solicit,
570 const struct in6_addr *daddr, const struct in6_addr *saddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 struct in6_addr addr_buf;
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900573 struct icmp6hdr icmp6h = {
574 .icmp6_type = NDISC_NEIGHBOUR_SOLICITATION,
575 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576
577 if (saddr == NULL) {
Neil Horman95c385b2007-04-25 17:08:10 -0700578 if (ipv6_get_lladdr(dev, &addr_buf,
579 (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 return;
581 saddr = &addr_buf;
582 }
583
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900584 __ndisc_send(dev, neigh, daddr, saddr,
585 &icmp6h, solicit,
David L Stevens14878f72007-09-16 16:52:35 -0700586 !ipv6_addr_any(saddr) ? ND_OPT_SOURCE_LL_ADDR : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587}
588
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +0900589void ndisc_send_rs(struct net_device *dev, const struct in6_addr *saddr,
590 const struct in6_addr *daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591{
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900592 struct icmp6hdr icmp6h = {
593 .icmp6_type = NDISC_ROUTER_SOLICITATION,
594 };
Neil Horman95c385b2007-04-25 17:08:10 -0700595 int send_sllao = dev->addr_len;
Neil Horman95c385b2007-04-25 17:08:10 -0700596
597#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
598 /*
599 * According to section 2.2 of RFC 4429, we must not
600 * send router solicitations with a sllao from
601 * optimistic addresses, but we may send the solicitation
602 * if we don't include the sllao. So here we check
603 * if our address is optimistic, and if so, we
Joe Perchesbea85192007-12-20 14:01:35 -0800604 * suppress the inclusion of the sllao.
Neil Horman95c385b2007-04-25 17:08:10 -0700605 */
606 if (send_sllao) {
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900607 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev_net(dev), saddr,
Daniel Lezcano1cab3da2008-01-10 22:44:09 -0800608 dev, 1);
Neil Horman95c385b2007-04-25 17:08:10 -0700609 if (ifp) {
610 if (ifp->flags & IFA_F_OPTIMISTIC) {
YOSHIFUJI Hideakica043562007-02-28 23:13:20 +0900611 send_sllao = 0;
Neil Horman95c385b2007-04-25 17:08:10 -0700612 }
YOSHIFUJI Hideakica043562007-02-28 23:13:20 +0900613 in6_ifa_put(ifp);
Neil Horman95c385b2007-04-25 17:08:10 -0700614 } else {
615 send_sllao = 0;
616 }
617 }
618#endif
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900619 __ndisc_send(dev, NULL, daddr, saddr,
620 &icmp6h, NULL,
David L Stevens14878f72007-09-16 16:52:35 -0700621 send_sllao ? ND_OPT_SOURCE_LL_ADDR : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622}
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900623
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624
625static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
626{
627 /*
628 * "The sender MUST return an ICMP
629 * destination unreachable"
630 */
631 dst_link_failure(skb);
632 kfree_skb(skb);
633}
634
635/* Called with locked neigh: either read or both */
636
637static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
638{
639 struct in6_addr *saddr = NULL;
640 struct in6_addr mcaddr;
641 struct net_device *dev = neigh->dev;
642 struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
643 int probes = atomic_read(&neigh->probes);
644
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900645 if (skb && ipv6_chk_addr(dev_net(dev), &ipv6_hdr(skb)->saddr, dev, 1))
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700646 saddr = &ipv6_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647
648 if ((probes -= neigh->parms->ucast_probes) < 0) {
649 if (!(neigh->nud_state & NUD_VALID)) {
650 ND_PRINTK1(KERN_DEBUG
651 "%s(): trying to ucast probe in NUD_INVALID: "
Joe Perches46b86a22006-01-13 14:29:07 -0800652 NIP6_FMT "\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800653 __func__,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 NIP6(*target));
655 }
656 ndisc_send_ns(dev, neigh, target, target, saddr);
657 } else if ((probes -= neigh->parms->app_probes) < 0) {
658#ifdef CONFIG_ARPD
659 neigh_app_ns(neigh);
660#endif
661 } else {
662 addrconf_addr_solict_mult(target, &mcaddr);
663 ndisc_send_ns(dev, NULL, target, &mcaddr, saddr);
664 }
665}
666
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900667static int pndisc_is_router(const void *pkey,
668 struct net_device *dev)
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700669{
670 struct pneigh_entry *n;
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900671 int ret = -1;
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700672
673 read_lock_bh(&nd_tbl.lock);
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900674 n = __pneigh_lookup(&nd_tbl, dev_net(dev), pkey, dev);
675 if (n)
676 ret = !!(n->flags & NTF_ROUTER);
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700677 read_unlock_bh(&nd_tbl.lock);
678
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900679 return ret;
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700680}
681
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682static void ndisc_recv_ns(struct sk_buff *skb)
683{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700684 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700685 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
686 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 u8 *lladdr = NULL;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700688 u32 ndoptlen = skb->tail - (skb->transport_header +
689 offsetof(struct nd_msg, opt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 struct ndisc_options ndopts;
691 struct net_device *dev = skb->dev;
692 struct inet6_ifaddr *ifp;
693 struct inet6_dev *idev = NULL;
694 struct neighbour *neigh;
695 int dad = ipv6_addr_any(saddr);
696 int inc;
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900697 int is_router = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698
699 if (ipv6_addr_is_multicast(&msg->target)) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900700 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 "ICMPv6 NS: multicast target address");
702 return;
703 }
704
705 /*
706 * RFC2461 7.1.1:
707 * DAD has to be destined for solicited node multicast address.
708 */
709 if (dad &&
710 !(daddr->s6_addr32[0] == htonl(0xff020000) &&
711 daddr->s6_addr32[1] == htonl(0x00000000) &&
712 daddr->s6_addr32[2] == htonl(0x00000001) &&
713 daddr->s6_addr [12] == 0xff )) {
714 ND_PRINTK2(KERN_WARNING
715 "ICMPv6 NS: bad DAD packet (wrong destination)\n");
716 return;
717 }
718
719 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900720 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 "ICMPv6 NS: invalid ND options\n");
722 return;
723 }
724
725 if (ndopts.nd_opts_src_lladdr) {
726 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
727 if (!lladdr) {
728 ND_PRINTK2(KERN_WARNING
729 "ICMPv6 NS: invalid link-layer address length\n");
730 return;
731 }
732
733 /* RFC2461 7.1.1:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900734 * If the IP source address is the unspecified address,
735 * there MUST NOT be source link-layer address option
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 * in the message.
737 */
738 if (dad) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900739 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 "ICMPv6 NS: bad DAD packet (link-layer address option)\n");
741 return;
742 }
743 }
744
745 inc = ipv6_addr_is_multicast(daddr);
746
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900747 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
Daniel Lezcanoa18bc692008-03-07 11:14:49 -0800748 if (ifp) {
Neil Horman95c385b2007-04-25 17:08:10 -0700749
750 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
751 if (dad) {
752 if (dev->type == ARPHRD_IEEE802_TR) {
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -0700753 const unsigned char *sadr;
754 sadr = skb_mac_header(skb);
Neil Horman95c385b2007-04-25 17:08:10 -0700755 if (((sadr[8] ^ dev->dev_addr[0]) & 0x7f) == 0 &&
756 sadr[9] == dev->dev_addr[1] &&
757 sadr[10] == dev->dev_addr[2] &&
758 sadr[11] == dev->dev_addr[3] &&
759 sadr[12] == dev->dev_addr[4] &&
760 sadr[13] == dev->dev_addr[5]) {
761 /* looped-back to us */
762 goto out;
763 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 }
Neil Horman95c385b2007-04-25 17:08:10 -0700765
766 /*
767 * We are colliding with another node
768 * who is doing DAD
769 * so fail our DAD process
770 */
771 addrconf_dad_failure(ifp);
Denis V. Lunev9e3be4b2007-09-11 11:04:49 +0200772 return;
Neil Horman95c385b2007-04-25 17:08:10 -0700773 } else {
774 /*
775 * This is not a dad solicitation.
776 * If we are an optimistic node,
777 * we should respond.
778 * Otherwise, we should ignore it.
779 */
780 if (!(ifp->flags & IFA_F_OPTIMISTIC))
781 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 }
784
785 idev = ifp->idev;
786 } else {
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700787 struct net *net = dev_net(dev);
788
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 idev = in6_dev_get(dev);
790 if (!idev) {
791 /* XXX: count this drop? */
792 return;
793 }
794
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700795 if (ipv6_chk_acast_addr(net, dev, &msg->target) ||
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900796 (idev->cnf.forwarding &&
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700797 (net->ipv6.devconf_all->proxy_ndp || idev->cnf.proxy_ndp) &&
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900798 (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) {
Patrick McHardya61bbcf2005-08-14 17:24:31 -0700799 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 skb->pkt_type != PACKET_HOST &&
801 inc != 0 &&
802 idev->nd_parms->proxy_delay != 0) {
803 /*
804 * for anycast or proxy,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900805 * sender should delay its response
806 * by a random time between 0 and
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 * MAX_ANYCAST_DELAY_TIME seconds.
808 * (RFC2461) -- yoshfuji
809 */
810 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
811 if (n)
812 pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
813 goto out;
814 }
815 } else
816 goto out;
817 }
818
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900819 if (is_router < 0)
820 is_router = !!idev->cnf.forwarding;
Ville Nuorvala62dd9312006-09-22 14:43:19 -0700821
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 if (dad) {
YOSHIFUJI Hideakif3ee4012008-04-10 15:42:11 +0900823 ndisc_send_na(dev, NULL, &in6addr_linklocal_allnodes, &msg->target,
Ville Nuorvala62dd9312006-09-22 14:43:19 -0700824 is_router, 0, (ifp != NULL), 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 goto out;
826 }
827
828 if (inc)
829 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
830 else
831 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
832
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900833 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 * update / create cache entry
835 * for the source address
836 */
837 neigh = __neigh_lookup(&nd_tbl, saddr, dev,
838 !inc || lladdr || !dev->addr_len);
839 if (neigh)
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900840 neigh_update(neigh, lladdr, NUD_STALE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 NEIGH_UPDATE_F_WEAK_OVERRIDE|
842 NEIGH_UPDATE_F_OVERRIDE);
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700843 if (neigh || !dev->header_ops) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 ndisc_send_na(dev, neigh, saddr, &msg->target,
Ville Nuorvala62dd9312006-09-22 14:43:19 -0700845 is_router,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 1, (ifp != NULL && inc), inc);
847 if (neigh)
848 neigh_release(neigh);
849 }
850
851out:
852 if (ifp)
853 in6_ifa_put(ifp);
854 else
855 in6_dev_put(idev);
856
857 return;
858}
859
860static void ndisc_recv_na(struct sk_buff *skb)
861{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700862 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700863 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
864 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 u8 *lladdr = NULL;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700866 u32 ndoptlen = skb->tail - (skb->transport_header +
867 offsetof(struct nd_msg, opt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 struct ndisc_options ndopts;
869 struct net_device *dev = skb->dev;
870 struct inet6_ifaddr *ifp;
871 struct neighbour *neigh;
872
873 if (skb->len < sizeof(struct nd_msg)) {
874 ND_PRINTK2(KERN_WARNING
875 "ICMPv6 NA: packet too short\n");
876 return;
877 }
878
879 if (ipv6_addr_is_multicast(&msg->target)) {
880 ND_PRINTK2(KERN_WARNING
881 "ICMPv6 NA: target address is multicast.\n");
882 return;
883 }
884
885 if (ipv6_addr_is_multicast(daddr) &&
886 msg->icmph.icmp6_solicited) {
887 ND_PRINTK2(KERN_WARNING
888 "ICMPv6 NA: solicited NA is multicasted.\n");
889 return;
890 }
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900891
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
893 ND_PRINTK2(KERN_WARNING
894 "ICMPv6 NS: invalid ND option\n");
895 return;
896 }
897 if (ndopts.nd_opts_tgt_lladdr) {
898 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
899 if (!lladdr) {
900 ND_PRINTK2(KERN_WARNING
901 "ICMPv6 NA: invalid link-layer address length\n");
902 return;
903 }
904 }
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900905 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
Daniel Lezcanoa18bc692008-03-07 11:14:49 -0800906 if (ifp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 if (ifp->flags & IFA_F_TENTATIVE) {
908 addrconf_dad_failure(ifp);
909 return;
910 }
911 /* What should we make now? The advertisement
912 is invalid, but ndisc specs say nothing
913 about it. It could be misconfiguration, or
914 an smart proxy agent tries to help us :-)
Jan Sembera24fc7b82008-12-09 15:48:32 -0800915
916 We should not print the error if NA has been
917 received from loopback - it is just our own
918 unsolicited advertisement.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 */
Jan Sembera24fc7b82008-12-09 15:48:32 -0800920 if (skb->pkt_type != PACKET_LOOPBACK)
921 ND_PRINTK1(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 "ICMPv6 NA: someone advertises our address on %s!\n",
923 ifp->idev->dev->name);
924 in6_ifa_put(ifp);
925 return;
926 }
927 neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
928
929 if (neigh) {
930 u8 old_flags = neigh->flags;
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700931 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932
933 if (neigh->nud_state & NUD_FAILED)
934 goto out;
935
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -0700936 /*
937 * Don't update the neighbor cache entry on a proxy NA from
938 * ourselves because either the proxied node is off link or it
939 * has already sent a NA to us.
940 */
941 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700942 net->ipv6.devconf_all->forwarding && net->ipv6.devconf_all->proxy_ndp &&
943 pneigh_lookup(&nd_tbl, net, &msg->target, dev, 0)) {
YOSHIFUJI Hideakifbea49e2006-09-22 14:43:49 -0700944 /* XXX: idev->cnf.prixy_ndp */
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -0700945 goto out;
YOSHIFUJI Hideakifbea49e2006-09-22 14:43:49 -0700946 }
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -0700947
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 neigh_update(neigh, lladdr,
949 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
950 NEIGH_UPDATE_F_WEAK_OVERRIDE|
951 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
952 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
953 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));
954
955 if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
956 /*
957 * Change: router to host
958 */
959 struct rt6_info *rt;
960 rt = rt6_get_dflt_router(saddr, dev);
961 if (rt)
Thomas Grafe0a1ad732006-08-22 00:00:21 -0700962 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 }
964
965out:
966 neigh_release(neigh);
967 }
968}
969
970static void ndisc_recv_rs(struct sk_buff *skb)
971{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700972 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
974 struct neighbour *neigh;
975 struct inet6_dev *idev;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700976 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 struct ndisc_options ndopts;
978 u8 *lladdr = NULL;
979
980 if (skb->len < sizeof(*rs_msg))
981 return;
982
983 idev = in6_dev_get(skb->dev);
984 if (!idev) {
985 if (net_ratelimit())
986 ND_PRINTK1("ICMP6 RS: can't find in6 device\n");
987 return;
988 }
989
990 /* Don't accept RS if we're not in router mode */
991 if (!idev->cnf.forwarding)
992 goto out;
993
994 /*
995 * Don't update NCE if src = ::;
996 * this implies that the source node has no ip address assigned yet.
997 */
998 if (ipv6_addr_any(saddr))
999 goto out;
1000
1001 /* Parse ND options */
1002 if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {
1003 if (net_ratelimit())
1004 ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n");
1005 goto out;
1006 }
1007
1008 if (ndopts.nd_opts_src_lladdr) {
1009 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1010 skb->dev);
1011 if (!lladdr)
1012 goto out;
1013 }
1014
1015 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
1016 if (neigh) {
1017 neigh_update(neigh, lladdr, NUD_STALE,
1018 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1019 NEIGH_UPDATE_F_OVERRIDE|
1020 NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
1021 neigh_release(neigh);
1022 }
1023out:
1024 in6_dev_put(idev);
1025}
1026
Pierre Ynard31910572007-10-10 21:22:05 -07001027static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt)
1028{
1029 struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra);
1030 struct sk_buff *skb;
1031 struct nlmsghdr *nlh;
1032 struct nduseroptmsg *ndmsg;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001033 struct net *net = dev_net(ra->dev);
Pierre Ynard31910572007-10-10 21:22:05 -07001034 int err;
1035 int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg)
1036 + (opt->nd_opt_len << 3));
1037 size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr));
1038
1039 skb = nlmsg_new(msg_size, GFP_ATOMIC);
1040 if (skb == NULL) {
1041 err = -ENOBUFS;
1042 goto errout;
1043 }
1044
1045 nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0);
1046 if (nlh == NULL) {
1047 goto nla_put_failure;
1048 }
1049
1050 ndmsg = nlmsg_data(nlh);
1051 ndmsg->nduseropt_family = AF_INET6;
Pierre Ynarddbb2ed22007-11-12 17:58:35 -08001052 ndmsg->nduseropt_ifindex = ra->dev->ifindex;
Pierre Ynard31910572007-10-10 21:22:05 -07001053 ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type;
1054 ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code;
1055 ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3;
1056
1057 memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3);
1058
1059 NLA_PUT(skb, NDUSEROPT_SRCADDR, sizeof(struct in6_addr),
1060 &ipv6_hdr(ra)->saddr);
1061 nlmsg_end(skb, nlh);
1062
Daniel Lezcanoa18bc692008-03-07 11:14:49 -08001063 err = rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL,
Denis V. Lunev97c53ca2007-11-19 22:26:51 -08001064 GFP_ATOMIC);
Pierre Ynard31910572007-10-10 21:22:05 -07001065 if (err < 0)
1066 goto errout;
1067
1068 return;
1069
1070nla_put_failure:
1071 nlmsg_free(skb);
1072 err = -EMSGSIZE;
1073errout:
Daniel Lezcanoa18bc692008-03-07 11:14:49 -08001074 rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err);
Pierre Ynard31910572007-10-10 21:22:05 -07001075}
1076
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077static void ndisc_router_discovery(struct sk_buff *skb)
1078{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001079 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080 struct neighbour *neigh = NULL;
1081 struct inet6_dev *in6_dev;
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001082 struct rt6_info *rt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 int lifetime;
1084 struct ndisc_options ndopts;
1085 int optlen;
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001086 unsigned int pref = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087
1088 __u8 * opt = (__u8 *)(ra_msg + 1);
1089
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001090 optlen = (skb->tail - skb->transport_header) - sizeof(struct ra_msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001092 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093 ND_PRINTK2(KERN_WARNING
1094 "ICMPv6 RA: source address is not link-local.\n");
1095 return;
1096 }
1097 if (optlen < 0) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001098 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 "ICMPv6 RA: packet too short\n");
1100 return;
1101 }
1102
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001103#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001104 if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) {
1105 ND_PRINTK2(KERN_WARNING
1106 "ICMPv6 RA: from host or unauthorized router\n");
1107 return;
1108 }
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001109#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001110
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 /*
1112 * set the RA_RECV flag in the interface
1113 */
1114
1115 in6_dev = in6_dev_get(skb->dev);
1116 if (in6_dev == NULL) {
1117 ND_PRINTK0(KERN_ERR
1118 "ICMPv6 RA: can't find inet6 device for %s.\n",
1119 skb->dev->name);
1120 return;
1121 }
1122 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_ra) {
1123 in6_dev_put(in6_dev);
1124 return;
1125 }
1126
1127 if (!ndisc_parse_options(opt, optlen, &ndopts)) {
1128 in6_dev_put(in6_dev);
1129 ND_PRINTK2(KERN_WARNING
1130 "ICMP6 RA: invalid ND options\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 /* skip link-specific parameters from interior routers */
1136 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1137 goto skip_linkparms;
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001138#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001139
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 if (in6_dev->if_flags & IF_RS_SENT) {
1141 /*
1142 * flag that an RA was received after an RS was sent
1143 * out on this interface.
1144 */
1145 in6_dev->if_flags |= IF_RA_RCVD;
1146 }
1147
1148 /*
1149 * Remember the managed/otherconf flags from most recently
1150 * received RA message (RFC 2462) -- yoshfuji
1151 */
1152 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1153 IF_RA_OTHERCONF)) |
1154 (ra_msg->icmph.icmp6_addrconf_managed ?
1155 IF_RA_MANAGED : 0) |
1156 (ra_msg->icmph.icmp6_addrconf_other ?
1157 IF_RA_OTHERCONF : 0);
1158
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001159 if (!in6_dev->cnf.accept_ra_defrtr)
1160 goto skip_defrtr;
1161
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1163
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001164#ifdef CONFIG_IPV6_ROUTER_PREF
1165 pref = ra_msg->icmph.icmp6_router_pref;
1166 /* 10b is handled as if it were 00b (medium) */
YOSHIFUJI Hideaki930d6ff2006-03-20 17:05:30 -08001167 if (pref == ICMPV6_ROUTER_PREF_INVALID ||
YOSHIFUJI Hideaki6d5b78c2007-06-22 16:07:04 -07001168 !in6_dev->cnf.accept_ra_rtr_pref)
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001169 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1170#endif
1171
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001172 rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173
1174 if (rt)
1175 neigh = rt->rt6i_nexthop;
1176
1177 if (rt && lifetime == 0) {
1178 neigh_clone(neigh);
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001179 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180 rt = NULL;
1181 }
1182
1183 if (rt == NULL && lifetime) {
1184 ND_PRINTK3(KERN_DEBUG
1185 "ICMPv6 RA: adding default router.\n");
1186
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001187 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 if (rt == NULL) {
1189 ND_PRINTK0(KERN_ERR
1190 "ICMPv6 RA: %s() failed to add default route.\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001191 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192 in6_dev_put(in6_dev);
1193 return;
1194 }
1195
1196 neigh = rt->rt6i_nexthop;
1197 if (neigh == NULL) {
1198 ND_PRINTK0(KERN_ERR
1199 "ICMPv6 RA: %s() got default router without neighbour.\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001200 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201 dst_release(&rt->u.dst);
1202 in6_dev_put(in6_dev);
1203 return;
1204 }
1205 neigh->flags |= NTF_ROUTER;
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001206 } else if (rt) {
Pedro Ribeiro22441cf2008-10-15 15:47:49 -07001207 rt->rt6i_flags = (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208 }
1209
1210 if (rt)
1211 rt->rt6i_expires = jiffies + (HZ * lifetime);
1212
1213 if (ra_msg->icmph.icmp6_hop_limit) {
1214 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1215 if (rt)
1216 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = ra_msg->icmph.icmp6_hop_limit;
1217 }
1218
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001219skip_defrtr:
1220
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 /*
1222 * Update Reachable Time and Retrans Timer
1223 */
1224
1225 if (in6_dev->nd_parms) {
1226 unsigned long rtime = ntohl(ra_msg->retrans_timer);
1227
1228 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1229 rtime = (rtime*HZ)/1000;
1230 if (rtime < HZ/10)
1231 rtime = HZ/10;
1232 in6_dev->nd_parms->retrans_time = rtime;
1233 in6_dev->tstamp = jiffies;
1234 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1235 }
1236
1237 rtime = ntohl(ra_msg->reachable_time);
1238 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1239 rtime = (rtime*HZ)/1000;
1240
1241 if (rtime < HZ/10)
1242 rtime = HZ/10;
1243
1244 if (rtime != in6_dev->nd_parms->base_reachable_time) {
1245 in6_dev->nd_parms->base_reachable_time = rtime;
1246 in6_dev->nd_parms->gc_staletime = 3 * rtime;
1247 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1248 in6_dev->tstamp = jiffies;
1249 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1250 }
1251 }
1252 }
1253
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001254#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001255skip_linkparms:
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001256#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001257
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 /*
1259 * Process options.
1260 */
1261
1262 if (!neigh)
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001263 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 skb->dev, 1);
1265 if (neigh) {
1266 u8 *lladdr = NULL;
1267 if (ndopts.nd_opts_src_lladdr) {
1268 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1269 skb->dev);
1270 if (!lladdr) {
1271 ND_PRINTK2(KERN_WARNING
1272 "ICMPv6 RA: invalid link-layer address length\n");
1273 goto out;
1274 }
1275 }
1276 neigh_update(neigh, lladdr, NUD_STALE,
1277 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1278 NEIGH_UPDATE_F_OVERRIDE|
1279 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1280 NEIGH_UPDATE_F_ISROUTER);
1281 }
1282
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001283#ifdef CONFIG_IPV6_ROUTE_INFO
YOSHIFUJI Hideaki09c884d2006-03-20 17:07:03 -08001284 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001285 struct nd_opt_hdr *p;
1286 for (p = ndopts.nd_opts_ri;
1287 p;
1288 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
YOSHIFUJI Hideaki6294e002008-03-15 23:56:52 -04001289 struct route_info *ri = (struct route_info *)p;
1290#ifdef CONFIG_IPV6_NDISC_NODETYPE
1291 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT &&
1292 ri->prefix_len == 0)
1293 continue;
1294#endif
1295 if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
YOSHIFUJI Hideaki09c884d2006-03-20 17:07:03 -08001296 continue;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001297 rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001298 &ipv6_hdr(skb)->saddr);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001299 }
1300 }
1301#endif
1302
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001303#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001304 /* skip link-specific ndopts from interior routers */
1305 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1306 goto out;
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001307#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001308
YOSHIFUJI Hideakic4fd30e2006-03-20 16:55:26 -08001309 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 struct nd_opt_hdr *p;
1311 for (p = ndopts.nd_opts_pi;
1312 p;
1313 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1314 addrconf_prefix_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3);
1315 }
1316 }
1317
1318 if (ndopts.nd_opts_mtu) {
Al Viroe69a4ad2006-11-14 20:56:00 -08001319 __be32 n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 u32 mtu;
1321
Al Viroe69a4ad2006-11-14 20:56:00 -08001322 memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1323 mtu = ntohl(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324
1325 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1326 ND_PRINTK2(KERN_WARNING
1327 "ICMPv6 RA: invalid mtu: %d\n",
1328 mtu);
1329 } else if (in6_dev->cnf.mtu6 != mtu) {
1330 in6_dev->cnf.mtu6 = mtu;
1331
1332 if (rt)
1333 rt->u.dst.metrics[RTAX_MTU-1] = mtu;
1334
1335 rt6_mtu_change(skb->dev, mtu);
1336 }
1337 }
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001338
Pierre Ynard31910572007-10-10 21:22:05 -07001339 if (ndopts.nd_useropts) {
YOSHIFUJI Hideaki61cf46a2008-01-22 17:32:53 +09001340 struct nd_opt_hdr *p;
1341 for (p = ndopts.nd_useropts;
1342 p;
1343 p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) {
1344 ndisc_ra_useropt(skb, p);
Pierre Ynard31910572007-10-10 21:22:05 -07001345 }
1346 }
1347
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1349 ND_PRINTK2(KERN_WARNING
1350 "ICMPv6 RA: invalid RA options");
1351 }
1352out:
1353 if (rt)
1354 dst_release(&rt->u.dst);
1355 else if (neigh)
1356 neigh_release(neigh);
1357 in6_dev_put(in6_dev);
1358}
1359
1360static void ndisc_redirect_rcv(struct sk_buff *skb)
1361{
1362 struct inet6_dev *in6_dev;
1363 struct icmp6hdr *icmph;
1364 struct in6_addr *dest;
1365 struct in6_addr *target; /* new first hop to destination */
1366 struct neighbour *neigh;
1367 int on_link = 0;
1368 struct ndisc_options ndopts;
1369 int optlen;
1370 u8 *lladdr = NULL;
1371
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001372#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001373 switch (skb->ndisc_nodetype) {
1374 case NDISC_NODETYPE_HOST:
1375 case NDISC_NODETYPE_NODEFAULT:
1376 ND_PRINTK2(KERN_WARNING
1377 "ICMPv6 Redirect: from host or unauthorized router\n");
1378 return;
1379 }
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001380#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001381
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001382 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 ND_PRINTK2(KERN_WARNING
1384 "ICMPv6 Redirect: source address is not link-local.\n");
1385 return;
1386 }
1387
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001388 optlen = skb->tail - skb->transport_header;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389 optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1390
1391 if (optlen < 0) {
1392 ND_PRINTK2(KERN_WARNING
1393 "ICMPv6 Redirect: packet too short\n");
1394 return;
1395 }
1396
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -03001397 icmph = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398 target = (struct in6_addr *) (icmph + 1);
1399 dest = target + 1;
1400
1401 if (ipv6_addr_is_multicast(dest)) {
1402 ND_PRINTK2(KERN_WARNING
1403 "ICMPv6 Redirect: destination address is multicast.\n");
1404 return;
1405 }
1406
1407 if (ipv6_addr_equal(dest, target)) {
1408 on_link = 1;
Brian Haleybf0b48d2007-10-08 00:12:05 -07001409 } else if (ipv6_addr_type(target) !=
1410 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001411 ND_PRINTK2(KERN_WARNING
Brian Haleybf0b48d2007-10-08 00:12:05 -07001412 "ICMPv6 Redirect: target address is not link-local unicast.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 return;
1414 }
1415
1416 in6_dev = in6_dev_get(skb->dev);
1417 if (!in6_dev)
1418 return;
1419 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects) {
1420 in6_dev_put(in6_dev);
1421 return;
1422 }
1423
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001424 /* RFC2461 8.1:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425 * The IP source address of the Redirect MUST be the same as the current
1426 * first-hop router for the specified ICMP Destination Address.
1427 */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001428
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429 if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) {
1430 ND_PRINTK2(KERN_WARNING
1431 "ICMPv6 Redirect: invalid ND options\n");
1432 in6_dev_put(in6_dev);
1433 return;
1434 }
1435 if (ndopts.nd_opts_tgt_lladdr) {
1436 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1437 skb->dev);
1438 if (!lladdr) {
1439 ND_PRINTK2(KERN_WARNING
1440 "ICMPv6 Redirect: invalid link-layer address length\n");
1441 in6_dev_put(in6_dev);
1442 return;
1443 }
1444 }
1445
1446 neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1);
1447 if (neigh) {
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001448 rt6_redirect(dest, &ipv6_hdr(skb)->daddr,
1449 &ipv6_hdr(skb)->saddr, neigh, lladdr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 on_link);
1451 neigh_release(neigh);
1452 }
1453 in6_dev_put(in6_dev);
1454}
1455
1456void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh,
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +09001457 const struct in6_addr *target)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458{
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001459 struct net_device *dev = skb->dev;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001460 struct net *net = dev_net(dev);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001461 struct sock *sk = net->ipv6.ndisc_sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462 int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1463 struct sk_buff *buff;
1464 struct icmp6hdr *icmph;
1465 struct in6_addr saddr_buf;
1466 struct in6_addr *addrp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467 struct rt6_info *rt;
1468 struct dst_entry *dst;
1469 struct inet6_dev *idev;
1470 struct flowi fl;
1471 u8 *opt;
1472 int rd_len;
1473 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1475
Neil Horman95c385b2007-04-25 17:08:10 -07001476 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477 ND_PRINTK2(KERN_WARNING
1478 "ICMPv6 Redirect: no link-local address on %s\n",
1479 dev->name);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001480 return;
1481 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001483 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
Brian Haleybf0b48d2007-10-08 00:12:05 -07001484 ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
Li Yewang29556522007-01-30 14:33:20 -08001485 ND_PRINTK2(KERN_WARNING
Brian Haleybf0b48d2007-10-08 00:12:05 -07001486 "ICMPv6 Redirect: target address is not link-local unicast.\n");
Li Yewang29556522007-01-30 14:33:20 -08001487 return;
1488 }
1489
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001490 icmpv6_flow_init(sk, &fl, NDISC_REDIRECT,
YOSHIFUJI Hideaki95e41e92007-12-06 15:43:30 -08001491 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001493 dst = ip6_route_output(net, NULL, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494 if (dst == NULL)
1495 return;
1496
1497 err = xfrm_lookup(&dst, &fl, NULL, 0);
Patrick McHardye1044112005-09-08 15:11:55 -07001498 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500
1501 rt = (struct rt6_info *) dst;
1502
1503 if (rt->rt6i_flags & RTF_GATEWAY) {
1504 ND_PRINTK2(KERN_WARNING
1505 "ICMPv6 Redirect: destination is not a neighbour.\n");
1506 dst_release(dst);
1507 return;
1508 }
1509 if (!xrlim_allow(dst, 1*HZ)) {
1510 dst_release(dst);
1511 return;
1512 }
1513
1514 if (dev->addr_len) {
1515 read_lock_bh(&neigh->lock);
1516 if (neigh->nud_state & NUD_VALID) {
1517 memcpy(ha_buf, neigh->ha, dev->addr_len);
1518 read_unlock_bh(&neigh->lock);
1519 ha = ha_buf;
1520 len += ndisc_opt_addr_space(dev);
1521 } else
1522 read_unlock_bh(&neigh->lock);
1523 }
1524
1525 rd_len = min_t(unsigned int,
1526 IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8);
1527 rd_len &= ~0x7;
1528 len += rd_len;
1529
David S. Millerd54a81d2006-12-02 21:00:06 -08001530 buff = sock_alloc_send_skb(sk,
1531 (MAX_HEADER + sizeof(struct ipv6hdr) +
Johannes Bergf5184d22008-05-12 20:48:31 -07001532 len + LL_ALLOCATED_SPACE(dev)),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533 1, &err);
1534 if (buff == NULL) {
1535 ND_PRINTK0(KERN_ERR
1536 "ICMPv6 Redirect: %s() failed to allocate an skb.\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001537 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 dst_release(dst);
1539 return;
1540 }
1541
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542 skb_reserve(buff, LL_RESERVED_SPACE(dev));
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001543 ip6_nd_hdr(sk, buff, dev, &saddr_buf, &ipv6_hdr(skb)->saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 IPPROTO_ICMPV6, len);
1545
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001546 skb_set_transport_header(buff, skb_tail_pointer(buff) - buff->data);
Arnaldo Carvalho de Melod10ba342007-03-14 21:05:37 -03001547 skb_put(buff, len);
1548 icmph = icmp6_hdr(buff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549
1550 memset(icmph, 0, sizeof(struct icmp6hdr));
1551 icmph->icmp6_type = NDISC_REDIRECT;
1552
1553 /*
1554 * copy target and destination addresses
1555 */
1556
1557 addrp = (struct in6_addr *)(icmph + 1);
1558 ipv6_addr_copy(addrp, target);
1559 addrp++;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001560 ipv6_addr_copy(addrp, &ipv6_hdr(skb)->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561
1562 opt = (u8*) (addrp + 1);
1563
1564 /*
1565 * include target_address option
1566 */
1567
1568 if (ha)
1569 opt = ndisc_fill_addr_option(opt, ND_OPT_TARGET_LL_ADDR, ha,
1570 dev->addr_len, dev->type);
1571
1572 /*
1573 * build redirect option and copy skb over to the new packet.
1574 */
1575
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001576 memset(opt, 0, 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577 *(opt++) = ND_OPT_REDIRECT_HDR;
1578 *(opt++) = (rd_len >> 3);
1579 opt += 6;
1580
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001581 memcpy(opt, ipv6_hdr(skb), rd_len - 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001583 icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &ipv6_hdr(skb)->saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 len, IPPROTO_ICMPV6,
1585 csum_partial((u8 *) icmph, len, 0));
1586
1587 buff->dst = dst;
1588 idev = in6_dev_get(dst->dev);
Denis V. Lunev3bd653c2008-10-08 10:54:51 -07001589 IP6_INC_STATS(net, idev, IPSTATS_MIB_OUTREQUESTS);
Patrick McHardy6e23ae22007-11-19 18:53:30 -08001590 err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, buff, NULL, dst->dev,
1591 dst_output);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592 if (!err) {
Denis V. Lunev5c5d2442008-10-08 10:33:50 -07001593 ICMP6MSGOUT_INC_STATS(net, idev, NDISC_REDIRECT);
Denis V. Luneva862f6a2008-10-08 10:33:06 -07001594 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595 }
1596
1597 if (likely(idev != NULL))
1598 in6_dev_put(idev);
1599}
1600
1601static void pndisc_redo(struct sk_buff *skb)
1602{
YOSHIFUJI Hideaki140e26fc2005-10-05 12:11:41 -07001603 ndisc_recv_ns(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604 kfree_skb(skb);
1605}
1606
1607int ndisc_rcv(struct sk_buff *skb)
1608{
1609 struct nd_msg *msg;
1610
1611 if (!pskb_may_pull(skb, skb->len))
1612 return 0;
1613
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001614 msg = (struct nd_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001616 __skb_push(skb, skb->data - skb_transport_header(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001618 if (ipv6_hdr(skb)->hop_limit != 255) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619 ND_PRINTK2(KERN_WARNING
1620 "ICMPv6 NDISC: invalid hop-limit: %d\n",
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001621 ipv6_hdr(skb)->hop_limit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622 return 0;
1623 }
1624
1625 if (msg->icmph.icmp6_code != 0) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001626 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 "ICMPv6 NDISC: invalid ICMPv6 code: %d\n",
1628 msg->icmph.icmp6_code);
1629 return 0;
1630 }
1631
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001632 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1633
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634 switch (msg->icmph.icmp6_type) {
1635 case NDISC_NEIGHBOUR_SOLICITATION:
1636 ndisc_recv_ns(skb);
1637 break;
1638
1639 case NDISC_NEIGHBOUR_ADVERTISEMENT:
1640 ndisc_recv_na(skb);
1641 break;
1642
1643 case NDISC_ROUTER_SOLICITATION:
1644 ndisc_recv_rs(skb);
1645 break;
1646
1647 case NDISC_ROUTER_ADVERTISEMENT:
1648 ndisc_router_discovery(skb);
1649 break;
1650
1651 case NDISC_REDIRECT:
1652 ndisc_redirect_rcv(skb);
1653 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07001654 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655
1656 return 0;
1657}
1658
1659static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1660{
1661 struct net_device *dev = ptr;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001662 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663
1664 switch (event) {
1665 case NETDEV_CHANGEADDR:
1666 neigh_changeaddr(&nd_tbl, dev);
Daniel Lezcano5b7c9312008-03-03 23:28:58 -08001667 fib6_run_gc(~0UL, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 break;
1669 case NETDEV_DOWN:
1670 neigh_ifdown(&nd_tbl, dev);
Daniel Lezcano5b7c9312008-03-03 23:28:58 -08001671 fib6_run_gc(~0UL, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 break;
1673 default:
1674 break;
1675 }
1676
1677 return NOTIFY_DONE;
1678}
1679
1680static struct notifier_block ndisc_netdev_notifier = {
1681 .notifier_call = ndisc_netdev_event,
1682};
1683
1684#ifdef CONFIG_SYSCTL
1685static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1686 const char *func, const char *dev_name)
1687{
1688 static char warncomm[TASK_COMM_LEN];
1689 static int warned;
1690 if (strcmp(warncomm, current->comm) && warned < 5) {
1691 strcpy(warncomm, current->comm);
1692 printk(KERN_WARNING
1693 "process `%s' is using deprecated sysctl (%s) "
1694 "net.ipv6.neigh.%s.%s; "
1695 "Use net.ipv6.neigh.%s.%s_ms "
1696 "instead.\n",
1697 warncomm, func,
1698 dev_name, ctl->procname,
1699 dev_name, ctl->procname);
1700 warned++;
1701 }
1702}
1703
1704int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, struct file * filp, void __user *buffer, size_t *lenp, loff_t *ppos)
1705{
1706 struct net_device *dev = ctl->extra1;
1707 struct inet6_dev *idev;
1708 int ret;
1709
Eric W. Biedermand12af672007-10-18 03:05:25 -07001710 if ((strcmp(ctl->procname, "retrans_time") == 0) ||
1711 (strcmp(ctl->procname, "base_reachable_time") == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1713
Eric W. Biedermand12af672007-10-18 03:05:25 -07001714 if (strcmp(ctl->procname, "retrans_time") == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715 ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001716
1717 else if (strcmp(ctl->procname, "base_reachable_time") == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 ret = proc_dointvec_jiffies(ctl, write,
1719 filp, buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001720
1721 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
YOSHIFUJI Hideakiad02ac12007-10-29 01:32:23 -07001722 (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723 ret = proc_dointvec_ms_jiffies(ctl, write,
1724 filp, buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001725 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726 ret = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727
1728 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
Eric W. Biedermand12af672007-10-18 03:05:25 -07001729 if (ctl->data == &idev->nd_parms->base_reachable_time)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1731 idev->tstamp = jiffies;
1732 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1733 in6_dev_put(idev);
1734 }
1735 return ret;
1736}
1737
Alexey Dobriyanf221e722008-10-15 22:04:23 -07001738int ndisc_ifinfo_sysctl_strategy(ctl_table *ctl,
1739 void __user *oldval, size_t __user *oldlenp,
YOSHIFUJI Hideaki0686caa2008-05-19 16:25:42 -07001740 void __user *newval, size_t newlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741{
1742 struct net_device *dev = ctl->extra1;
1743 struct inet6_dev *idev;
1744 int ret;
1745
1746 if (ctl->ctl_name == NET_NEIGH_RETRANS_TIME ||
1747 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME)
1748 ndisc_warn_deprecated_sysctl(ctl, "procfs", dev ? dev->name : "default");
1749
1750 switch (ctl->ctl_name) {
1751 case NET_NEIGH_REACHABLE_TIME:
Alexey Dobriyanf221e722008-10-15 22:04:23 -07001752 ret = sysctl_jiffies(ctl, oldval, oldlenp, newval, newlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753 break;
1754 case NET_NEIGH_RETRANS_TIME_MS:
1755 case NET_NEIGH_REACHABLE_TIME_MS:
Alexey Dobriyanf221e722008-10-15 22:04:23 -07001756 ret = sysctl_ms_jiffies(ctl, oldval, oldlenp, newval, newlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 break;
1758 default:
1759 ret = 0;
1760 }
1761
1762 if (newval && newlen && ret > 0 &&
1763 dev && (idev = in6_dev_get(dev)) != NULL) {
1764 if (ctl->ctl_name == NET_NEIGH_REACHABLE_TIME ||
1765 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME_MS)
1766 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1767 idev->tstamp = jiffies;
1768 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1769 in6_dev_put(idev);
1770 }
1771
1772 return ret;
1773}
1774
1775#endif
1776
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001777static int ndisc_net_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778{
1779 struct ipv6_pinfo *np;
1780 struct sock *sk;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001781 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782
Denis V. Lunev1ed85162008-04-03 14:31:03 -07001783 err = inet_ctl_sock_create(&sk, PF_INET6,
1784 SOCK_RAW, IPPROTO_ICMPV6, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785 if (err < 0) {
1786 ND_PRINTK0(KERN_ERR
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001787 "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789 return err;
1790 }
1791
Denis V. Lunev1ed85162008-04-03 14:31:03 -07001792 net->ipv6.ndisc_sk = sk;
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001793
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 np = inet6_sk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001795 np->hop_limit = 255;
1796 /* Do not loopback ndisc messages */
1797 np->mc_loop = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001799 return 0;
1800}
1801
1802static void ndisc_net_exit(struct net *net)
1803{
Denis V. Lunev1ed85162008-04-03 14:31:03 -07001804 inet_ctl_sock_destroy(net->ipv6.ndisc_sk);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001805}
1806
1807static struct pernet_operations ndisc_net_ops = {
1808 .init = ndisc_net_init,
1809 .exit = ndisc_net_exit,
1810};
1811
1812int __init ndisc_init(void)
1813{
1814 int err;
1815
1816 err = register_pernet_subsys(&ndisc_net_ops);
1817 if (err)
1818 return err;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001819 /*
1820 * Initialize the neighbour table
1821 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822 neigh_table_init(&nd_tbl);
1823
1824#ifdef CONFIG_SYSCTL
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001825 err = neigh_sysctl_register(NULL, &nd_tbl.parms, NET_IPV6,
1826 NET_IPV6_NEIGH, "ipv6",
1827 &ndisc_ifinfo_sysctl_change,
1828 &ndisc_ifinfo_sysctl_strategy);
1829 if (err)
1830 goto out_unregister_pernet;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001831#endif
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001832 err = register_netdevice_notifier(&ndisc_netdev_notifier);
1833 if (err)
1834 goto out_unregister_sysctl;
1835out:
1836 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001838out_unregister_sysctl:
1839#ifdef CONFIG_SYSCTL
1840 neigh_sysctl_unregister(&nd_tbl.parms);
1841out_unregister_pernet:
1842#endif
1843 unregister_pernet_subsys(&ndisc_net_ops);
1844 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845}
1846
1847void ndisc_cleanup(void)
1848{
Dmitry Mishin36f73d02006-11-03 16:08:19 -08001849 unregister_netdevice_notifier(&ndisc_netdev_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850#ifdef CONFIG_SYSCTL
1851 neigh_sysctl_unregister(&nd_tbl.parms);
1852#endif
1853 neigh_table_clear(&nd_tbl);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001854 unregister_pernet_subsys(&ndisc_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855}