blob: 282fdb31f8ed92455a2aba625d45301433d92364 [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);
519 IP6_INC_STATS(idev, IPSTATS_MIB_OUTREQUESTS);
520
Patrick McHardy6e23ae22007-11-19 18:53:30 -0800521 err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev,
522 dst_output);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900523 if (!err) {
David L Stevens14878f72007-09-16 16:52:35 -0700524 ICMP6MSGOUT_INC_STATS(idev, type);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900525 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);
526 }
527
528 if (likely(idev != NULL))
529 in6_dev_put(idev);
530}
531
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532static void ndisc_send_na(struct net_device *dev, struct neighbour *neigh,
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 {
YOSHIFUJI Hideaki7cbca672008-03-25 09:37:42 +0900552 if (ipv6_dev_get_saddr(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 {
787 idev = in6_dev_get(dev);
788 if (!idev) {
789 /* XXX: count this drop? */
790 return;
791 }
792
Daniel Lezcano6ab57e72008-03-26 16:52:32 -0700793 if (ipv6_chk_acast_addr(dev_net(dev), dev, &msg->target) ||
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900794 (idev->cnf.forwarding &&
YOSHIFUJI Hideakifbea49e2006-09-22 14:43:49 -0700795 (ipv6_devconf.proxy_ndp || idev->cnf.proxy_ndp) &&
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900796 (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) {
Patrick McHardya61bbcf2005-08-14 17:24:31 -0700797 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 skb->pkt_type != PACKET_HOST &&
799 inc != 0 &&
800 idev->nd_parms->proxy_delay != 0) {
801 /*
802 * for anycast or proxy,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900803 * sender should delay its response
804 * by a random time between 0 and
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 * MAX_ANYCAST_DELAY_TIME seconds.
806 * (RFC2461) -- yoshfuji
807 */
808 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
809 if (n)
810 pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
811 goto out;
812 }
813 } else
814 goto out;
815 }
816
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900817 if (is_router < 0)
818 is_router = !!idev->cnf.forwarding;
Ville Nuorvala62dd9312006-09-22 14:43:19 -0700819
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 if (dad) {
YOSHIFUJI Hideakif3ee4012008-04-10 15:42:11 +0900821 ndisc_send_na(dev, NULL, &in6addr_linklocal_allnodes, &msg->target,
Ville Nuorvala62dd9312006-09-22 14:43:19 -0700822 is_router, 0, (ifp != NULL), 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 goto out;
824 }
825
826 if (inc)
827 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
828 else
829 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
830
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900831 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 * update / create cache entry
833 * for the source address
834 */
835 neigh = __neigh_lookup(&nd_tbl, saddr, dev,
836 !inc || lladdr || !dev->addr_len);
837 if (neigh)
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900838 neigh_update(neigh, lladdr, NUD_STALE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 NEIGH_UPDATE_F_WEAK_OVERRIDE|
840 NEIGH_UPDATE_F_OVERRIDE);
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700841 if (neigh || !dev->header_ops) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 ndisc_send_na(dev, neigh, saddr, &msg->target,
Ville Nuorvala62dd9312006-09-22 14:43:19 -0700843 is_router,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 1, (ifp != NULL && inc), inc);
845 if (neigh)
846 neigh_release(neigh);
847 }
848
849out:
850 if (ifp)
851 in6_ifa_put(ifp);
852 else
853 in6_dev_put(idev);
854
855 return;
856}
857
858static void ndisc_recv_na(struct sk_buff *skb)
859{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700860 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700861 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
862 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 u8 *lladdr = NULL;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700864 u32 ndoptlen = skb->tail - (skb->transport_header +
865 offsetof(struct nd_msg, opt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 struct ndisc_options ndopts;
867 struct net_device *dev = skb->dev;
868 struct inet6_ifaddr *ifp;
869 struct neighbour *neigh;
870
871 if (skb->len < sizeof(struct nd_msg)) {
872 ND_PRINTK2(KERN_WARNING
873 "ICMPv6 NA: packet too short\n");
874 return;
875 }
876
877 if (ipv6_addr_is_multicast(&msg->target)) {
878 ND_PRINTK2(KERN_WARNING
879 "ICMPv6 NA: target address is multicast.\n");
880 return;
881 }
882
883 if (ipv6_addr_is_multicast(daddr) &&
884 msg->icmph.icmp6_solicited) {
885 ND_PRINTK2(KERN_WARNING
886 "ICMPv6 NA: solicited NA is multicasted.\n");
887 return;
888 }
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900889
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
891 ND_PRINTK2(KERN_WARNING
892 "ICMPv6 NS: invalid ND option\n");
893 return;
894 }
895 if (ndopts.nd_opts_tgt_lladdr) {
896 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
897 if (!lladdr) {
898 ND_PRINTK2(KERN_WARNING
899 "ICMPv6 NA: invalid link-layer address length\n");
900 return;
901 }
902 }
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900903 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
Daniel Lezcanoa18bc692008-03-07 11:14:49 -0800904 if (ifp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 if (ifp->flags & IFA_F_TENTATIVE) {
906 addrconf_dad_failure(ifp);
907 return;
908 }
909 /* What should we make now? The advertisement
910 is invalid, but ndisc specs say nothing
911 about it. It could be misconfiguration, or
912 an smart proxy agent tries to help us :-)
913 */
914 ND_PRINTK1(KERN_WARNING
915 "ICMPv6 NA: someone advertises our address on %s!\n",
916 ifp->idev->dev->name);
917 in6_ifa_put(ifp);
918 return;
919 }
920 neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
921
922 if (neigh) {
923 u8 old_flags = neigh->flags;
924
925 if (neigh->nud_state & NUD_FAILED)
926 goto out;
927
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -0700928 /*
929 * Don't update the neighbor cache entry on a proxy NA from
930 * ourselves because either the proxied node is off link or it
931 * has already sent a NA to us.
932 */
933 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
YOSHIFUJI Hideakifbea49e2006-09-22 14:43:49 -0700934 ipv6_devconf.forwarding && ipv6_devconf.proxy_ndp &&
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900935 pneigh_lookup(&nd_tbl, dev_net(dev), &msg->target, dev, 0)) {
YOSHIFUJI Hideakifbea49e2006-09-22 14:43:49 -0700936 /* XXX: idev->cnf.prixy_ndp */
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -0700937 goto out;
YOSHIFUJI Hideakifbea49e2006-09-22 14:43:49 -0700938 }
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -0700939
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940 neigh_update(neigh, lladdr,
941 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
942 NEIGH_UPDATE_F_WEAK_OVERRIDE|
943 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
944 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
945 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));
946
947 if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
948 /*
949 * Change: router to host
950 */
951 struct rt6_info *rt;
952 rt = rt6_get_dflt_router(saddr, dev);
953 if (rt)
Thomas Grafe0a1ad732006-08-22 00:00:21 -0700954 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 }
956
957out:
958 neigh_release(neigh);
959 }
960}
961
962static void ndisc_recv_rs(struct sk_buff *skb)
963{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700964 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
966 struct neighbour *neigh;
967 struct inet6_dev *idev;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700968 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969 struct ndisc_options ndopts;
970 u8 *lladdr = NULL;
971
972 if (skb->len < sizeof(*rs_msg))
973 return;
974
975 idev = in6_dev_get(skb->dev);
976 if (!idev) {
977 if (net_ratelimit())
978 ND_PRINTK1("ICMP6 RS: can't find in6 device\n");
979 return;
980 }
981
982 /* Don't accept RS if we're not in router mode */
983 if (!idev->cnf.forwarding)
984 goto out;
985
986 /*
987 * Don't update NCE if src = ::;
988 * this implies that the source node has no ip address assigned yet.
989 */
990 if (ipv6_addr_any(saddr))
991 goto out;
992
993 /* Parse ND options */
994 if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {
995 if (net_ratelimit())
996 ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n");
997 goto out;
998 }
999
1000 if (ndopts.nd_opts_src_lladdr) {
1001 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1002 skb->dev);
1003 if (!lladdr)
1004 goto out;
1005 }
1006
1007 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
1008 if (neigh) {
1009 neigh_update(neigh, lladdr, NUD_STALE,
1010 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1011 NEIGH_UPDATE_F_OVERRIDE|
1012 NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
1013 neigh_release(neigh);
1014 }
1015out:
1016 in6_dev_put(idev);
1017}
1018
Pierre Ynard31910572007-10-10 21:22:05 -07001019static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt)
1020{
1021 struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra);
1022 struct sk_buff *skb;
1023 struct nlmsghdr *nlh;
1024 struct nduseroptmsg *ndmsg;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001025 struct net *net = dev_net(ra->dev);
Pierre Ynard31910572007-10-10 21:22:05 -07001026 int err;
1027 int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg)
1028 + (opt->nd_opt_len << 3));
1029 size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr));
1030
1031 skb = nlmsg_new(msg_size, GFP_ATOMIC);
1032 if (skb == NULL) {
1033 err = -ENOBUFS;
1034 goto errout;
1035 }
1036
1037 nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0);
1038 if (nlh == NULL) {
1039 goto nla_put_failure;
1040 }
1041
1042 ndmsg = nlmsg_data(nlh);
1043 ndmsg->nduseropt_family = AF_INET6;
Pierre Ynarddbb2ed22007-11-12 17:58:35 -08001044 ndmsg->nduseropt_ifindex = ra->dev->ifindex;
Pierre Ynard31910572007-10-10 21:22:05 -07001045 ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type;
1046 ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code;
1047 ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3;
1048
1049 memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3);
1050
1051 NLA_PUT(skb, NDUSEROPT_SRCADDR, sizeof(struct in6_addr),
1052 &ipv6_hdr(ra)->saddr);
1053 nlmsg_end(skb, nlh);
1054
Daniel Lezcanoa18bc692008-03-07 11:14:49 -08001055 err = rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL,
Denis V. Lunev97c53ca2007-11-19 22:26:51 -08001056 GFP_ATOMIC);
Pierre Ynard31910572007-10-10 21:22:05 -07001057 if (err < 0)
1058 goto errout;
1059
1060 return;
1061
1062nla_put_failure:
1063 nlmsg_free(skb);
1064 err = -EMSGSIZE;
1065errout:
Daniel Lezcanoa18bc692008-03-07 11:14:49 -08001066 rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err);
Pierre Ynard31910572007-10-10 21:22:05 -07001067}
1068
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069static void ndisc_router_discovery(struct sk_buff *skb)
1070{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001071 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 struct neighbour *neigh = NULL;
1073 struct inet6_dev *in6_dev;
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001074 struct rt6_info *rt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 int lifetime;
1076 struct ndisc_options ndopts;
1077 int optlen;
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001078 unsigned int pref = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079
1080 __u8 * opt = (__u8 *)(ra_msg + 1);
1081
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001082 optlen = (skb->tail - skb->transport_header) - sizeof(struct ra_msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001084 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 ND_PRINTK2(KERN_WARNING
1086 "ICMPv6 RA: source address is not link-local.\n");
1087 return;
1088 }
1089 if (optlen < 0) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001090 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 "ICMPv6 RA: packet too short\n");
1092 return;
1093 }
1094
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001095#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001096 if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) {
1097 ND_PRINTK2(KERN_WARNING
1098 "ICMPv6 RA: from host or unauthorized router\n");
1099 return;
1100 }
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001101#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001102
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 /*
1104 * set the RA_RECV flag in the interface
1105 */
1106
1107 in6_dev = in6_dev_get(skb->dev);
1108 if (in6_dev == NULL) {
1109 ND_PRINTK0(KERN_ERR
1110 "ICMPv6 RA: can't find inet6 device for %s.\n",
1111 skb->dev->name);
1112 return;
1113 }
1114 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_ra) {
1115 in6_dev_put(in6_dev);
1116 return;
1117 }
1118
1119 if (!ndisc_parse_options(opt, optlen, &ndopts)) {
1120 in6_dev_put(in6_dev);
1121 ND_PRINTK2(KERN_WARNING
1122 "ICMP6 RA: invalid ND options\n");
1123 return;
1124 }
1125
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001126#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001127 /* skip link-specific parameters from interior routers */
1128 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1129 goto skip_linkparms;
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001130#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001131
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 if (in6_dev->if_flags & IF_RS_SENT) {
1133 /*
1134 * flag that an RA was received after an RS was sent
1135 * out on this interface.
1136 */
1137 in6_dev->if_flags |= IF_RA_RCVD;
1138 }
1139
1140 /*
1141 * Remember the managed/otherconf flags from most recently
1142 * received RA message (RFC 2462) -- yoshfuji
1143 */
1144 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1145 IF_RA_OTHERCONF)) |
1146 (ra_msg->icmph.icmp6_addrconf_managed ?
1147 IF_RA_MANAGED : 0) |
1148 (ra_msg->icmph.icmp6_addrconf_other ?
1149 IF_RA_OTHERCONF : 0);
1150
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001151 if (!in6_dev->cnf.accept_ra_defrtr)
1152 goto skip_defrtr;
1153
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1155
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001156#ifdef CONFIG_IPV6_ROUTER_PREF
1157 pref = ra_msg->icmph.icmp6_router_pref;
1158 /* 10b is handled as if it were 00b (medium) */
YOSHIFUJI Hideaki930d6ff2006-03-20 17:05:30 -08001159 if (pref == ICMPV6_ROUTER_PREF_INVALID ||
YOSHIFUJI Hideaki6d5b78c2007-06-22 16:07:04 -07001160 !in6_dev->cnf.accept_ra_rtr_pref)
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001161 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1162#endif
1163
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001164 rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165
1166 if (rt)
1167 neigh = rt->rt6i_nexthop;
1168
1169 if (rt && lifetime == 0) {
1170 neigh_clone(neigh);
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001171 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172 rt = NULL;
1173 }
1174
1175 if (rt == NULL && lifetime) {
1176 ND_PRINTK3(KERN_DEBUG
1177 "ICMPv6 RA: adding default router.\n");
1178
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001179 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180 if (rt == NULL) {
1181 ND_PRINTK0(KERN_ERR
1182 "ICMPv6 RA: %s() failed to add default route.\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001183 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184 in6_dev_put(in6_dev);
1185 return;
1186 }
1187
1188 neigh = rt->rt6i_nexthop;
1189 if (neigh == NULL) {
1190 ND_PRINTK0(KERN_ERR
1191 "ICMPv6 RA: %s() got default router without neighbour.\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001192 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 dst_release(&rt->u.dst);
1194 in6_dev_put(in6_dev);
1195 return;
1196 }
1197 neigh->flags |= NTF_ROUTER;
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001198 } else if (rt) {
1199 rt->rt6i_flags |= (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 }
1201
1202 if (rt)
1203 rt->rt6i_expires = jiffies + (HZ * lifetime);
1204
1205 if (ra_msg->icmph.icmp6_hop_limit) {
1206 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1207 if (rt)
1208 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = ra_msg->icmph.icmp6_hop_limit;
1209 }
1210
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001211skip_defrtr:
1212
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213 /*
1214 * Update Reachable Time and Retrans Timer
1215 */
1216
1217 if (in6_dev->nd_parms) {
1218 unsigned long rtime = ntohl(ra_msg->retrans_timer);
1219
1220 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1221 rtime = (rtime*HZ)/1000;
1222 if (rtime < HZ/10)
1223 rtime = HZ/10;
1224 in6_dev->nd_parms->retrans_time = rtime;
1225 in6_dev->tstamp = jiffies;
1226 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1227 }
1228
1229 rtime = ntohl(ra_msg->reachable_time);
1230 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1231 rtime = (rtime*HZ)/1000;
1232
1233 if (rtime < HZ/10)
1234 rtime = HZ/10;
1235
1236 if (rtime != in6_dev->nd_parms->base_reachable_time) {
1237 in6_dev->nd_parms->base_reachable_time = rtime;
1238 in6_dev->nd_parms->gc_staletime = 3 * rtime;
1239 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1240 in6_dev->tstamp = jiffies;
1241 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1242 }
1243 }
1244 }
1245
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001246#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001247skip_linkparms:
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001248#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001249
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 /*
1251 * Process options.
1252 */
1253
1254 if (!neigh)
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001255 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256 skb->dev, 1);
1257 if (neigh) {
1258 u8 *lladdr = NULL;
1259 if (ndopts.nd_opts_src_lladdr) {
1260 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1261 skb->dev);
1262 if (!lladdr) {
1263 ND_PRINTK2(KERN_WARNING
1264 "ICMPv6 RA: invalid link-layer address length\n");
1265 goto out;
1266 }
1267 }
1268 neigh_update(neigh, lladdr, NUD_STALE,
1269 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1270 NEIGH_UPDATE_F_OVERRIDE|
1271 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1272 NEIGH_UPDATE_F_ISROUTER);
1273 }
1274
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001275#ifdef CONFIG_IPV6_ROUTE_INFO
YOSHIFUJI Hideaki09c884d2006-03-20 17:07:03 -08001276 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001277 struct nd_opt_hdr *p;
1278 for (p = ndopts.nd_opts_ri;
1279 p;
1280 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
YOSHIFUJI Hideaki6294e002008-03-15 23:56:52 -04001281 struct route_info *ri = (struct route_info *)p;
1282#ifdef CONFIG_IPV6_NDISC_NODETYPE
1283 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT &&
1284 ri->prefix_len == 0)
1285 continue;
1286#endif
1287 if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
YOSHIFUJI Hideaki09c884d2006-03-20 17:07:03 -08001288 continue;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001289 rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001290 &ipv6_hdr(skb)->saddr);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001291 }
1292 }
1293#endif
1294
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001295#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001296 /* skip link-specific ndopts from interior routers */
1297 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1298 goto out;
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001299#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001300
YOSHIFUJI Hideakic4fd30e2006-03-20 16:55:26 -08001301 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 struct nd_opt_hdr *p;
1303 for (p = ndopts.nd_opts_pi;
1304 p;
1305 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1306 addrconf_prefix_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3);
1307 }
1308 }
1309
1310 if (ndopts.nd_opts_mtu) {
Al Viroe69a4ad2006-11-14 20:56:00 -08001311 __be32 n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 u32 mtu;
1313
Al Viroe69a4ad2006-11-14 20:56:00 -08001314 memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1315 mtu = ntohl(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316
1317 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1318 ND_PRINTK2(KERN_WARNING
1319 "ICMPv6 RA: invalid mtu: %d\n",
1320 mtu);
1321 } else if (in6_dev->cnf.mtu6 != mtu) {
1322 in6_dev->cnf.mtu6 = mtu;
1323
1324 if (rt)
1325 rt->u.dst.metrics[RTAX_MTU-1] = mtu;
1326
1327 rt6_mtu_change(skb->dev, mtu);
1328 }
1329 }
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001330
Pierre Ynard31910572007-10-10 21:22:05 -07001331 if (ndopts.nd_useropts) {
YOSHIFUJI Hideaki61cf46a2008-01-22 17:32:53 +09001332 struct nd_opt_hdr *p;
1333 for (p = ndopts.nd_useropts;
1334 p;
1335 p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) {
1336 ndisc_ra_useropt(skb, p);
Pierre Ynard31910572007-10-10 21:22:05 -07001337 }
1338 }
1339
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1341 ND_PRINTK2(KERN_WARNING
1342 "ICMPv6 RA: invalid RA options");
1343 }
1344out:
1345 if (rt)
1346 dst_release(&rt->u.dst);
1347 else if (neigh)
1348 neigh_release(neigh);
1349 in6_dev_put(in6_dev);
1350}
1351
1352static void ndisc_redirect_rcv(struct sk_buff *skb)
1353{
1354 struct inet6_dev *in6_dev;
1355 struct icmp6hdr *icmph;
1356 struct in6_addr *dest;
1357 struct in6_addr *target; /* new first hop to destination */
1358 struct neighbour *neigh;
1359 int on_link = 0;
1360 struct ndisc_options ndopts;
1361 int optlen;
1362 u8 *lladdr = NULL;
1363
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001364#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001365 switch (skb->ndisc_nodetype) {
1366 case NDISC_NODETYPE_HOST:
1367 case NDISC_NODETYPE_NODEFAULT:
1368 ND_PRINTK2(KERN_WARNING
1369 "ICMPv6 Redirect: from host or unauthorized router\n");
1370 return;
1371 }
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001372#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001373
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001374 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375 ND_PRINTK2(KERN_WARNING
1376 "ICMPv6 Redirect: source address is not link-local.\n");
1377 return;
1378 }
1379
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001380 optlen = skb->tail - skb->transport_header;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1382
1383 if (optlen < 0) {
1384 ND_PRINTK2(KERN_WARNING
1385 "ICMPv6 Redirect: packet too short\n");
1386 return;
1387 }
1388
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -03001389 icmph = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 target = (struct in6_addr *) (icmph + 1);
1391 dest = target + 1;
1392
1393 if (ipv6_addr_is_multicast(dest)) {
1394 ND_PRINTK2(KERN_WARNING
1395 "ICMPv6 Redirect: destination address is multicast.\n");
1396 return;
1397 }
1398
1399 if (ipv6_addr_equal(dest, target)) {
1400 on_link = 1;
Brian Haleybf0b48d2007-10-08 00:12:05 -07001401 } else if (ipv6_addr_type(target) !=
1402 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001403 ND_PRINTK2(KERN_WARNING
Brian Haleybf0b48d2007-10-08 00:12:05 -07001404 "ICMPv6 Redirect: target address is not link-local unicast.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 return;
1406 }
1407
1408 in6_dev = in6_dev_get(skb->dev);
1409 if (!in6_dev)
1410 return;
1411 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects) {
1412 in6_dev_put(in6_dev);
1413 return;
1414 }
1415
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001416 /* RFC2461 8.1:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417 * The IP source address of the Redirect MUST be the same as the current
1418 * first-hop router for the specified ICMP Destination Address.
1419 */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001420
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421 if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) {
1422 ND_PRINTK2(KERN_WARNING
1423 "ICMPv6 Redirect: invalid ND options\n");
1424 in6_dev_put(in6_dev);
1425 return;
1426 }
1427 if (ndopts.nd_opts_tgt_lladdr) {
1428 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1429 skb->dev);
1430 if (!lladdr) {
1431 ND_PRINTK2(KERN_WARNING
1432 "ICMPv6 Redirect: invalid link-layer address length\n");
1433 in6_dev_put(in6_dev);
1434 return;
1435 }
1436 }
1437
1438 neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1);
1439 if (neigh) {
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001440 rt6_redirect(dest, &ipv6_hdr(skb)->daddr,
1441 &ipv6_hdr(skb)->saddr, neigh, lladdr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 on_link);
1443 neigh_release(neigh);
1444 }
1445 in6_dev_put(in6_dev);
1446}
1447
1448void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh,
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +09001449 const struct in6_addr *target)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450{
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001451 struct net_device *dev = skb->dev;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001452 struct net *net = dev_net(dev);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001453 struct sock *sk = net->ipv6.ndisc_sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454 int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1455 struct sk_buff *buff;
1456 struct icmp6hdr *icmph;
1457 struct in6_addr saddr_buf;
1458 struct in6_addr *addrp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 struct rt6_info *rt;
1460 struct dst_entry *dst;
1461 struct inet6_dev *idev;
1462 struct flowi fl;
1463 u8 *opt;
1464 int rd_len;
1465 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1467
Neil Horman95c385b2007-04-25 17:08:10 -07001468 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 ND_PRINTK2(KERN_WARNING
1470 "ICMPv6 Redirect: no link-local address on %s\n",
1471 dev->name);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001472 return;
1473 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001475 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
Brian Haleybf0b48d2007-10-08 00:12:05 -07001476 ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
Li Yewang29556522007-01-30 14:33:20 -08001477 ND_PRINTK2(KERN_WARNING
Brian Haleybf0b48d2007-10-08 00:12:05 -07001478 "ICMPv6 Redirect: target address is not link-local unicast.\n");
Li Yewang29556522007-01-30 14:33:20 -08001479 return;
1480 }
1481
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001482 icmpv6_flow_init(sk, &fl, NDISC_REDIRECT,
YOSHIFUJI Hideaki95e41e92007-12-06 15:43:30 -08001483 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001485 dst = ip6_route_output(net, NULL, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 if (dst == NULL)
1487 return;
1488
1489 err = xfrm_lookup(&dst, &fl, NULL, 0);
Patrick McHardye1044112005-09-08 15:11:55 -07001490 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492
1493 rt = (struct rt6_info *) dst;
1494
1495 if (rt->rt6i_flags & RTF_GATEWAY) {
1496 ND_PRINTK2(KERN_WARNING
1497 "ICMPv6 Redirect: destination is not a neighbour.\n");
1498 dst_release(dst);
1499 return;
1500 }
1501 if (!xrlim_allow(dst, 1*HZ)) {
1502 dst_release(dst);
1503 return;
1504 }
1505
1506 if (dev->addr_len) {
1507 read_lock_bh(&neigh->lock);
1508 if (neigh->nud_state & NUD_VALID) {
1509 memcpy(ha_buf, neigh->ha, dev->addr_len);
1510 read_unlock_bh(&neigh->lock);
1511 ha = ha_buf;
1512 len += ndisc_opt_addr_space(dev);
1513 } else
1514 read_unlock_bh(&neigh->lock);
1515 }
1516
1517 rd_len = min_t(unsigned int,
1518 IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8);
1519 rd_len &= ~0x7;
1520 len += rd_len;
1521
David S. Millerd54a81d2006-12-02 21:00:06 -08001522 buff = sock_alloc_send_skb(sk,
1523 (MAX_HEADER + sizeof(struct ipv6hdr) +
Johannes Bergf5184d22008-05-12 20:48:31 -07001524 len + LL_ALLOCATED_SPACE(dev)),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525 1, &err);
1526 if (buff == NULL) {
1527 ND_PRINTK0(KERN_ERR
1528 "ICMPv6 Redirect: %s() failed to allocate an skb.\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001529 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530 dst_release(dst);
1531 return;
1532 }
1533
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534 skb_reserve(buff, LL_RESERVED_SPACE(dev));
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001535 ip6_nd_hdr(sk, buff, dev, &saddr_buf, &ipv6_hdr(skb)->saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536 IPPROTO_ICMPV6, len);
1537
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001538 skb_set_transport_header(buff, skb_tail_pointer(buff) - buff->data);
Arnaldo Carvalho de Melod10ba342007-03-14 21:05:37 -03001539 skb_put(buff, len);
1540 icmph = icmp6_hdr(buff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541
1542 memset(icmph, 0, sizeof(struct icmp6hdr));
1543 icmph->icmp6_type = NDISC_REDIRECT;
1544
1545 /*
1546 * copy target and destination addresses
1547 */
1548
1549 addrp = (struct in6_addr *)(icmph + 1);
1550 ipv6_addr_copy(addrp, target);
1551 addrp++;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001552 ipv6_addr_copy(addrp, &ipv6_hdr(skb)->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553
1554 opt = (u8*) (addrp + 1);
1555
1556 /*
1557 * include target_address option
1558 */
1559
1560 if (ha)
1561 opt = ndisc_fill_addr_option(opt, ND_OPT_TARGET_LL_ADDR, ha,
1562 dev->addr_len, dev->type);
1563
1564 /*
1565 * build redirect option and copy skb over to the new packet.
1566 */
1567
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001568 memset(opt, 0, 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569 *(opt++) = ND_OPT_REDIRECT_HDR;
1570 *(opt++) = (rd_len >> 3);
1571 opt += 6;
1572
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001573 memcpy(opt, ipv6_hdr(skb), rd_len - 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001575 icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &ipv6_hdr(skb)->saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576 len, IPPROTO_ICMPV6,
1577 csum_partial((u8 *) icmph, len, 0));
1578
1579 buff->dst = dst;
1580 idev = in6_dev_get(dst->dev);
YOSHIFUJI Hideakia11d2062006-11-04 20:11:37 +09001581 IP6_INC_STATS(idev, IPSTATS_MIB_OUTREQUESTS);
Patrick McHardy6e23ae22007-11-19 18:53:30 -08001582 err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, buff, NULL, dst->dev,
1583 dst_output);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 if (!err) {
David L Stevens14878f72007-09-16 16:52:35 -07001585 ICMP6MSGOUT_INC_STATS(idev, NDISC_REDIRECT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);
1587 }
1588
1589 if (likely(idev != NULL))
1590 in6_dev_put(idev);
1591}
1592
1593static void pndisc_redo(struct sk_buff *skb)
1594{
YOSHIFUJI Hideaki140e26fc2005-10-05 12:11:41 -07001595 ndisc_recv_ns(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596 kfree_skb(skb);
1597}
1598
1599int ndisc_rcv(struct sk_buff *skb)
1600{
1601 struct nd_msg *msg;
1602
1603 if (!pskb_may_pull(skb, skb->len))
1604 return 0;
1605
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001606 msg = (struct nd_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001608 __skb_push(skb, skb->data - skb_transport_header(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001610 if (ipv6_hdr(skb)->hop_limit != 255) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611 ND_PRINTK2(KERN_WARNING
1612 "ICMPv6 NDISC: invalid hop-limit: %d\n",
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001613 ipv6_hdr(skb)->hop_limit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614 return 0;
1615 }
1616
1617 if (msg->icmph.icmp6_code != 0) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001618 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619 "ICMPv6 NDISC: invalid ICMPv6 code: %d\n",
1620 msg->icmph.icmp6_code);
1621 return 0;
1622 }
1623
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001624 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1625
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626 switch (msg->icmph.icmp6_type) {
1627 case NDISC_NEIGHBOUR_SOLICITATION:
1628 ndisc_recv_ns(skb);
1629 break;
1630
1631 case NDISC_NEIGHBOUR_ADVERTISEMENT:
1632 ndisc_recv_na(skb);
1633 break;
1634
1635 case NDISC_ROUTER_SOLICITATION:
1636 ndisc_recv_rs(skb);
1637 break;
1638
1639 case NDISC_ROUTER_ADVERTISEMENT:
1640 ndisc_router_discovery(skb);
1641 break;
1642
1643 case NDISC_REDIRECT:
1644 ndisc_redirect_rcv(skb);
1645 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07001646 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647
1648 return 0;
1649}
1650
1651static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1652{
1653 struct net_device *dev = ptr;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001654 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655
1656 switch (event) {
1657 case NETDEV_CHANGEADDR:
1658 neigh_changeaddr(&nd_tbl, dev);
Daniel Lezcano5b7c9312008-03-03 23:28:58 -08001659 fib6_run_gc(~0UL, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660 break;
1661 case NETDEV_DOWN:
1662 neigh_ifdown(&nd_tbl, dev);
Daniel Lezcano5b7c9312008-03-03 23:28:58 -08001663 fib6_run_gc(~0UL, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664 break;
1665 default:
1666 break;
1667 }
1668
1669 return NOTIFY_DONE;
1670}
1671
1672static struct notifier_block ndisc_netdev_notifier = {
1673 .notifier_call = ndisc_netdev_event,
1674};
1675
1676#ifdef CONFIG_SYSCTL
1677static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1678 const char *func, const char *dev_name)
1679{
1680 static char warncomm[TASK_COMM_LEN];
1681 static int warned;
1682 if (strcmp(warncomm, current->comm) && warned < 5) {
1683 strcpy(warncomm, current->comm);
1684 printk(KERN_WARNING
1685 "process `%s' is using deprecated sysctl (%s) "
1686 "net.ipv6.neigh.%s.%s; "
1687 "Use net.ipv6.neigh.%s.%s_ms "
1688 "instead.\n",
1689 warncomm, func,
1690 dev_name, ctl->procname,
1691 dev_name, ctl->procname);
1692 warned++;
1693 }
1694}
1695
1696int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, struct file * filp, void __user *buffer, size_t *lenp, loff_t *ppos)
1697{
1698 struct net_device *dev = ctl->extra1;
1699 struct inet6_dev *idev;
1700 int ret;
1701
Eric W. Biedermand12af672007-10-18 03:05:25 -07001702 if ((strcmp(ctl->procname, "retrans_time") == 0) ||
1703 (strcmp(ctl->procname, "base_reachable_time") == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1705
Eric W. Biedermand12af672007-10-18 03:05:25 -07001706 if (strcmp(ctl->procname, "retrans_time") == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001708
1709 else if (strcmp(ctl->procname, "base_reachable_time") == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001710 ret = proc_dointvec_jiffies(ctl, write,
1711 filp, buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001712
1713 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
YOSHIFUJI Hideakiad02ac12007-10-29 01:32:23 -07001714 (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715 ret = proc_dointvec_ms_jiffies(ctl, write,
1716 filp, buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001717 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 ret = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719
1720 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
Eric W. Biedermand12af672007-10-18 03:05:25 -07001721 if (ctl->data == &idev->nd_parms->base_reachable_time)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1723 idev->tstamp = jiffies;
1724 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1725 in6_dev_put(idev);
1726 }
1727 return ret;
1728}
1729
YOSHIFUJI Hideaki0686caa2008-05-19 16:25:42 -07001730int ndisc_ifinfo_sysctl_strategy(ctl_table *ctl, int __user *name,
1731 int nlen, void __user *oldval,
1732 size_t __user *oldlenp,
1733 void __user *newval, size_t newlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734{
1735 struct net_device *dev = ctl->extra1;
1736 struct inet6_dev *idev;
1737 int ret;
1738
1739 if (ctl->ctl_name == NET_NEIGH_RETRANS_TIME ||
1740 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME)
1741 ndisc_warn_deprecated_sysctl(ctl, "procfs", dev ? dev->name : "default");
1742
1743 switch (ctl->ctl_name) {
1744 case NET_NEIGH_REACHABLE_TIME:
1745 ret = sysctl_jiffies(ctl, name, nlen,
Alexey Dobriyan1f29bcd2006-12-10 02:19:10 -08001746 oldval, oldlenp, newval, newlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747 break;
1748 case NET_NEIGH_RETRANS_TIME_MS:
1749 case NET_NEIGH_REACHABLE_TIME_MS:
1750 ret = sysctl_ms_jiffies(ctl, name, nlen,
Alexey Dobriyan1f29bcd2006-12-10 02:19:10 -08001751 oldval, oldlenp, newval, newlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752 break;
1753 default:
1754 ret = 0;
1755 }
1756
1757 if (newval && newlen && ret > 0 &&
1758 dev && (idev = in6_dev_get(dev)) != NULL) {
1759 if (ctl->ctl_name == NET_NEIGH_REACHABLE_TIME ||
1760 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME_MS)
1761 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1762 idev->tstamp = jiffies;
1763 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1764 in6_dev_put(idev);
1765 }
1766
1767 return ret;
1768}
1769
1770#endif
1771
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001772static int ndisc_net_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773{
1774 struct ipv6_pinfo *np;
1775 struct sock *sk;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001776 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777
Denis V. Lunev1ed85162008-04-03 14:31:03 -07001778 err = inet_ctl_sock_create(&sk, PF_INET6,
1779 SOCK_RAW, IPPROTO_ICMPV6, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780 if (err < 0) {
1781 ND_PRINTK0(KERN_ERR
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001782 "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783 err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784 return err;
1785 }
1786
Denis V. Lunev1ed85162008-04-03 14:31:03 -07001787 net->ipv6.ndisc_sk = sk;
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001788
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789 np = inet6_sk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 np->hop_limit = 255;
1791 /* Do not loopback ndisc messages */
1792 np->mc_loop = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001794 return 0;
1795}
1796
1797static void ndisc_net_exit(struct net *net)
1798{
Denis V. Lunev1ed85162008-04-03 14:31:03 -07001799 inet_ctl_sock_destroy(net->ipv6.ndisc_sk);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001800}
1801
1802static struct pernet_operations ndisc_net_ops = {
1803 .init = ndisc_net_init,
1804 .exit = ndisc_net_exit,
1805};
1806
1807int __init ndisc_init(void)
1808{
1809 int err;
1810
1811 err = register_pernet_subsys(&ndisc_net_ops);
1812 if (err)
1813 return err;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001814 /*
1815 * Initialize the neighbour table
1816 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 neigh_table_init(&nd_tbl);
1818
1819#ifdef CONFIG_SYSCTL
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001820 err = neigh_sysctl_register(NULL, &nd_tbl.parms, NET_IPV6,
1821 NET_IPV6_NEIGH, "ipv6",
1822 &ndisc_ifinfo_sysctl_change,
1823 &ndisc_ifinfo_sysctl_strategy);
1824 if (err)
1825 goto out_unregister_pernet;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826#endif
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001827 err = register_netdevice_notifier(&ndisc_netdev_notifier);
1828 if (err)
1829 goto out_unregister_sysctl;
1830out:
1831 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001833out_unregister_sysctl:
1834#ifdef CONFIG_SYSCTL
1835 neigh_sysctl_unregister(&nd_tbl.parms);
1836out_unregister_pernet:
1837#endif
1838 unregister_pernet_subsys(&ndisc_net_ops);
1839 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001840}
1841
1842void ndisc_cleanup(void)
1843{
Dmitry Mishin36f73d02006-11-03 16:08:19 -08001844 unregister_netdevice_notifier(&ndisc_netdev_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845#ifdef CONFIG_SYSCTL
1846 neigh_sysctl_unregister(&nd_tbl.parms);
1847#endif
1848 neigh_table_clear(&nd_tbl);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001849 unregister_pernet_subsys(&ndisc_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850}