blob: 2342545a5ee9bfe125ff3030bac07cafcb24a00b [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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090062#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070063#ifdef CONFIG_SYSCTL
64#include <linux/sysctl.h>
65#endif
66
Thomas Graf18237302006-08-04 23:04:54 -070067#include <linux/if_addr.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070068#include <linux/if_arp.h>
69#include <linux/ipv6.h>
70#include <linux/icmpv6.h>
71#include <linux/jhash.h>
72
73#include <net/sock.h>
74#include <net/snmp.h>
75
76#include <net/ipv6.h>
77#include <net/protocol.h>
78#include <net/ndisc.h>
79#include <net/ip6_route.h>
80#include <net/addrconf.h>
81#include <net/icmp.h>
82
Pierre Ynard31910572007-10-10 21:22:05 -070083#include <net/netlink.h>
84#include <linux/rtnetlink.h>
85
Linus Torvalds1da177e2005-04-16 15:20:36 -070086#include <net/flow.h>
87#include <net/ip6_checksum.h>
Denis V. Lunev1ed85162008-04-03 14:31:03 -070088#include <net/inet_common.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070089#include <linux/proc_fs.h>
90
91#include <linux/netfilter.h>
92#include <linux/netfilter_ipv6.h>
93
Eric Dumazetd6bf7812010-10-04 06:15:44 +000094static u32 ndisc_hash(const void *pkey,
95 const struct net_device *dev,
96 __u32 rnd);
Linus Torvalds1da177e2005-04-16 15:20:36 -070097static int ndisc_constructor(struct neighbour *neigh);
98static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb);
99static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb);
100static int pndisc_constructor(struct pneigh_entry *n);
101static void pndisc_destructor(struct pneigh_entry *n);
102static void pndisc_redo(struct sk_buff *skb);
103
Stephen Hemminger89d69d22009-09-01 11:13:19 +0000104static const struct neigh_ops ndisc_generic_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 .family = AF_INET6,
106 .solicit = ndisc_solicit,
107 .error_report = ndisc_error_report,
108 .output = neigh_resolve_output,
109 .connected_output = neigh_connected_output,
110 .hh_output = dev_queue_xmit,
111 .queue_xmit = dev_queue_xmit,
112};
113
Stephen Hemminger89d69d22009-09-01 11:13:19 +0000114static const struct neigh_ops ndisc_hh_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 .family = AF_INET6,
116 .solicit = ndisc_solicit,
117 .error_report = ndisc_error_report,
118 .output = neigh_resolve_output,
119 .connected_output = neigh_resolve_output,
120 .hh_output = dev_queue_xmit,
121 .queue_xmit = dev_queue_xmit,
122};
123
124
Stephen Hemminger89d69d22009-09-01 11:13:19 +0000125static const struct neigh_ops ndisc_direct_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 .family = AF_INET6,
127 .output = dev_queue_xmit,
128 .connected_output = dev_queue_xmit,
129 .hh_output = dev_queue_xmit,
130 .queue_xmit = dev_queue_xmit,
131};
132
133struct neigh_table nd_tbl = {
134 .family = AF_INET6,
135 .entry_size = sizeof(struct neighbour) + sizeof(struct in6_addr),
136 .key_len = sizeof(struct in6_addr),
137 .hash = ndisc_hash,
138 .constructor = ndisc_constructor,
139 .pconstructor = pndisc_constructor,
140 .pdestructor = pndisc_destructor,
141 .proxy_redo = pndisc_redo,
142 .id = "ndisc_cache",
143 .parms = {
Shan Weib6720832010-12-01 18:05:12 +0000144 .tbl = &nd_tbl,
145 .base_reachable_time = ND_REACHABLE_TIME,
146 .retrans_time = ND_RETRANS_TIMER,
147 .gc_staletime = 60 * HZ,
148 .reachable_time = ND_REACHABLE_TIME,
149 .delay_probe_time = 5 * HZ,
150 .queue_len = 3,
151 .ucast_probes = 3,
152 .mcast_probes = 3,
153 .anycast_delay = 1 * HZ,
154 .proxy_delay = (8 * HZ) / 10,
155 .proxy_qlen = 64,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 },
157 .gc_interval = 30 * HZ,
158 .gc_thresh1 = 128,
159 .gc_thresh2 = 512,
160 .gc_thresh3 = 1024,
161};
162
163/* ND options */
164struct ndisc_options {
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800165 struct nd_opt_hdr *nd_opt_array[__ND_OPT_ARRAY_MAX];
166#ifdef CONFIG_IPV6_ROUTE_INFO
167 struct nd_opt_hdr *nd_opts_ri;
168 struct nd_opt_hdr *nd_opts_ri_end;
169#endif
Pierre Ynard31910572007-10-10 21:22:05 -0700170 struct nd_opt_hdr *nd_useropts;
171 struct nd_opt_hdr *nd_useropts_end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172};
173
174#define nd_opts_src_lladdr nd_opt_array[ND_OPT_SOURCE_LL_ADDR]
175#define nd_opts_tgt_lladdr nd_opt_array[ND_OPT_TARGET_LL_ADDR]
176#define nd_opts_pi nd_opt_array[ND_OPT_PREFIX_INFO]
177#define nd_opts_pi_end nd_opt_array[__ND_OPT_PREFIX_INFO_END]
178#define nd_opts_rh nd_opt_array[ND_OPT_REDIRECT_HDR]
179#define nd_opts_mtu nd_opt_array[ND_OPT_MTU]
180
181#define NDISC_OPT_SPACE(len) (((len)+2+7)&~7)
182
183/*
184 * Return the padding between the option length and the start of the
185 * link addr. Currently only IP-over-InfiniBand needs this, although
186 * if RFC 3831 IPv6-over-Fibre Channel is ever implemented it may
187 * also need a pad of 2.
188 */
189static int ndisc_addr_option_pad(unsigned short type)
190{
191 switch (type) {
192 case ARPHRD_INFINIBAND: return 2;
193 default: return 0;
194 }
195}
196
197static inline int ndisc_opt_addr_space(struct net_device *dev)
198{
199 return NDISC_OPT_SPACE(dev->addr_len + ndisc_addr_option_pad(dev->type));
200}
201
202static u8 *ndisc_fill_addr_option(u8 *opt, int type, void *data, int data_len,
203 unsigned short addr_type)
204{
205 int space = NDISC_OPT_SPACE(data_len);
206 int pad = ndisc_addr_option_pad(addr_type);
207
208 opt[0] = type;
209 opt[1] = space>>3;
210
211 memset(opt + 2, 0, pad);
212 opt += pad;
213 space -= pad;
214
215 memcpy(opt+2, data, data_len);
216 data_len += 2;
217 opt += data_len;
218 if ((space -= data_len) > 0)
219 memset(opt, 0, space);
220 return opt + space;
221}
222
223static struct nd_opt_hdr *ndisc_next_option(struct nd_opt_hdr *cur,
224 struct nd_opt_hdr *end)
225{
226 int type;
227 if (!cur || !end || cur >= end)
228 return NULL;
229 type = cur->nd_opt_type;
230 do {
231 cur = ((void *)cur) + (cur->nd_opt_len << 3);
232 } while(cur < end && cur->nd_opt_type != type);
Eric Dumazeta02cec22010-09-22 20:43:57 +0000233 return cur <= end && cur->nd_opt_type == type ? cur : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234}
235
Pierre Ynard31910572007-10-10 21:22:05 -0700236static inline int ndisc_is_useropt(struct nd_opt_hdr *opt)
237{
Eric Dumazeta02cec22010-09-22 20:43:57 +0000238 return opt->nd_opt_type == ND_OPT_RDNSS;
Pierre Ynard31910572007-10-10 21:22:05 -0700239}
240
241static struct nd_opt_hdr *ndisc_next_useropt(struct nd_opt_hdr *cur,
242 struct nd_opt_hdr *end)
243{
244 if (!cur || !end || cur >= end)
245 return NULL;
246 do {
247 cur = ((void *)cur) + (cur->nd_opt_len << 3);
248 } while(cur < end && !ndisc_is_useropt(cur));
Eric Dumazeta02cec22010-09-22 20:43:57 +0000249 return cur <= end && ndisc_is_useropt(cur) ? cur : NULL;
Pierre Ynard31910572007-10-10 21:22:05 -0700250}
251
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252static struct ndisc_options *ndisc_parse_options(u8 *opt, int opt_len,
253 struct ndisc_options *ndopts)
254{
255 struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)opt;
256
257 if (!nd_opt || opt_len < 0 || !ndopts)
258 return NULL;
259 memset(ndopts, 0, sizeof(*ndopts));
260 while (opt_len) {
261 int l;
262 if (opt_len < sizeof(struct nd_opt_hdr))
263 return NULL;
264 l = nd_opt->nd_opt_len << 3;
265 if (opt_len < l || l == 0)
266 return NULL;
267 switch (nd_opt->nd_opt_type) {
268 case ND_OPT_SOURCE_LL_ADDR:
269 case ND_OPT_TARGET_LL_ADDR:
270 case ND_OPT_MTU:
271 case ND_OPT_REDIRECT_HDR:
272 if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) {
273 ND_PRINTK2(KERN_WARNING
274 "%s(): duplicated ND6 option found: type=%d\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800275 __func__,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 nd_opt->nd_opt_type);
277 } else {
278 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
279 }
280 break;
281 case ND_OPT_PREFIX_INFO:
282 ndopts->nd_opts_pi_end = nd_opt;
Stephen Hemmingercfcabdc2007-10-09 01:59:42 -0700283 if (!ndopts->nd_opt_array[nd_opt->nd_opt_type])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
285 break;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -0800286#ifdef CONFIG_IPV6_ROUTE_INFO
287 case ND_OPT_ROUTE_INFO:
288 ndopts->nd_opts_ri_end = nd_opt;
289 if (!ndopts->nd_opts_ri)
290 ndopts->nd_opts_ri = nd_opt;
291 break;
292#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 default:
Pierre Ynard31910572007-10-10 21:22:05 -0700294 if (ndisc_is_useropt(nd_opt)) {
295 ndopts->nd_useropts_end = nd_opt;
296 if (!ndopts->nd_useropts)
297 ndopts->nd_useropts = nd_opt;
298 } else {
299 /*
300 * Unknown options must be silently ignored,
301 * to accommodate future extension to the
302 * protocol.
303 */
304 ND_PRINTK2(KERN_NOTICE
305 "%s(): ignored unsupported option; type=%d, len=%d\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -0800306 __func__,
Pierre Ynard31910572007-10-10 21:22:05 -0700307 nd_opt->nd_opt_type, nd_opt->nd_opt_len);
308 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 }
310 opt_len -= l;
311 nd_opt = ((void *)nd_opt) + l;
312 }
313 return ndopts;
314}
315
316static inline u8 *ndisc_opt_addr_data(struct nd_opt_hdr *p,
317 struct net_device *dev)
318{
319 u8 *lladdr = (u8 *)(p + 1);
320 int lladdrlen = p->nd_opt_len << 3;
321 int prepad = ndisc_addr_option_pad(dev->type);
322 if (lladdrlen != NDISC_OPT_SPACE(dev->addr_len + prepad))
323 return NULL;
Eric Dumazeta02cec22010-09-22 20:43:57 +0000324 return lladdr + prepad;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325}
326
327int ndisc_mc_map(struct in6_addr *addr, char *buf, struct net_device *dev, int dir)
328{
329 switch (dev->type) {
330 case ARPHRD_ETHER:
331 case ARPHRD_IEEE802: /* Not sure. Check it later. --ANK */
332 case ARPHRD_FDDI:
333 ipv6_eth_mc_map(addr, buf);
334 return 0;
335 case ARPHRD_IEEE802_TR:
336 ipv6_tr_mc_map(addr,buf);
337 return 0;
338 case ARPHRD_ARCNET:
339 ipv6_arcnet_mc_map(addr, buf);
340 return 0;
341 case ARPHRD_INFINIBAND:
Rolf Manderscheida9e527e32007-12-10 13:38:41 -0700342 ipv6_ib_mc_map(addr, dev->broadcast, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 return 0;
344 default:
345 if (dir) {
346 memcpy(buf, dev->broadcast, dev->addr_len);
347 return 0;
348 }
349 }
350 return -EINVAL;
351}
352
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900353EXPORT_SYMBOL(ndisc_mc_map);
354
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000355static u32 ndisc_hash(const void *pkey,
356 const struct net_device *dev,
357 __u32 hash_rnd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358{
359 const u32 *p32 = pkey;
360 u32 addr_hash, i;
361
362 addr_hash = 0;
363 for (i = 0; i < (sizeof(struct in6_addr) / sizeof(u32)); i++)
364 addr_hash ^= *p32++;
365
Eric Dumazetd6bf7812010-10-04 06:15:44 +0000366 return jhash_2words(addr_hash, dev->ifindex, hash_rnd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367}
368
369static int ndisc_constructor(struct neighbour *neigh)
370{
371 struct in6_addr *addr = (struct in6_addr*)&neigh->primary_key;
372 struct net_device *dev = neigh->dev;
373 struct inet6_dev *in6_dev;
374 struct neigh_parms *parms;
375 int is_multicast = ipv6_addr_is_multicast(addr);
376
377 rcu_read_lock();
378 in6_dev = in6_dev_get(dev);
379 if (in6_dev == NULL) {
380 rcu_read_unlock();
381 return -EINVAL;
382 }
383
384 parms = in6_dev->nd_parms;
385 __neigh_parms_put(neigh->parms);
386 neigh->parms = neigh_parms_clone(parms);
387 rcu_read_unlock();
388
389 neigh->type = is_multicast ? RTN_MULTICAST : RTN_UNICAST;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700390 if (!dev->header_ops) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 neigh->nud_state = NUD_NOARP;
392 neigh->ops = &ndisc_direct_ops;
393 neigh->output = neigh->ops->queue_xmit;
394 } else {
395 if (is_multicast) {
396 neigh->nud_state = NUD_NOARP;
397 ndisc_mc_map(addr, neigh->ha, dev, 1);
398 } else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {
399 neigh->nud_state = NUD_NOARP;
400 memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
401 if (dev->flags&IFF_LOOPBACK)
402 neigh->type = RTN_LOCAL;
403 } else if (dev->flags&IFF_POINTOPOINT) {
404 neigh->nud_state = NUD_NOARP;
405 memcpy(neigh->ha, dev->broadcast, dev->addr_len);
406 }
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700407 if (dev->header_ops->cache)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 neigh->ops = &ndisc_hh_ops;
409 else
410 neigh->ops = &ndisc_generic_ops;
411 if (neigh->nud_state&NUD_VALID)
412 neigh->output = neigh->ops->connected_output;
413 else
414 neigh->output = neigh->ops->output;
415 }
416 in6_dev_put(in6_dev);
417 return 0;
418}
419
420static int pndisc_constructor(struct pneigh_entry *n)
421{
422 struct in6_addr *addr = (struct in6_addr*)&n->key;
423 struct in6_addr maddr;
424 struct net_device *dev = n->dev;
425
426 if (dev == NULL || __in6_dev_get(dev) == NULL)
427 return -EINVAL;
428 addrconf_addr_solict_mult(addr, &maddr);
429 ipv6_dev_mc_inc(dev, &maddr);
430 return 0;
431}
432
433static void pndisc_destructor(struct pneigh_entry *n)
434{
435 struct in6_addr *addr = (struct in6_addr*)&n->key;
436 struct in6_addr maddr;
437 struct net_device *dev = n->dev;
438
439 if (dev == NULL || __in6_dev_get(dev) == NULL)
440 return;
441 addrconf_addr_solict_mult(addr, &maddr);
442 ipv6_dev_mc_dec(dev, &maddr);
443}
444
Brian Haley305d5522008-11-04 17:51:14 -0800445struct sk_buff *ndisc_build_skb(struct net_device *dev,
446 const struct in6_addr *daddr,
447 const struct in6_addr *saddr,
448 struct icmp6hdr *icmp6h,
449 const struct in6_addr *target,
450 int llinfo)
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900451{
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;
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900456 int len;
457 int err;
Brian Haley305d5522008-11-04 17:51:14 -0800458 u8 *opt;
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900459
460 if (!dev->addr_len)
461 llinfo = 0;
462
463 len = sizeof(struct icmp6hdr) + (target ? sizeof(*target) : 0);
464 if (llinfo)
465 len += ndisc_opt_addr_space(dev);
466
467 skb = sock_alloc_send_skb(sk,
468 (MAX_HEADER + sizeof(struct ipv6hdr) +
Johannes Bergf5184d22008-05-12 20:48:31 -0700469 len + LL_ALLOCATED_SPACE(dev)),
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900470 1, &err);
471 if (!skb) {
472 ND_PRINTK0(KERN_ERR
Brian Haleydae9de82009-06-02 00:20:26 -0700473 "ICMPv6 ND: %s() failed to allocate an skb, err=%d.\n",
474 __func__, err);
Brian Haley305d5522008-11-04 17:51:14 -0800475 return NULL;
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900476 }
477
478 skb_reserve(skb, LL_RESERVED_SPACE(dev));
479 ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);
480
481 skb->transport_header = skb->tail;
482 skb_put(skb, len);
483
484 hdr = (struct icmp6hdr *)skb_transport_header(skb);
485 memcpy(hdr, icmp6h, sizeof(*hdr));
486
487 opt = skb_transport_header(skb) + sizeof(struct icmp6hdr);
488 if (target) {
489 ipv6_addr_copy((struct in6_addr *)opt, target);
490 opt += sizeof(*target);
491 }
492
493 if (llinfo)
494 ndisc_fill_addr_option(opt, llinfo, dev->dev_addr,
495 dev->addr_len, dev->type);
496
497 hdr->icmp6_cksum = csum_ipv6_magic(saddr, daddr, len,
498 IPPROTO_ICMPV6,
Joe Perches07f07572008-11-19 15:44:53 -0800499 csum_partial(hdr,
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900500 len, 0));
501
Brian Haley305d5522008-11-04 17:51:14 -0800502 return skb;
503}
504
505EXPORT_SYMBOL(ndisc_build_skb);
506
507void ndisc_send_skb(struct sk_buff *skb,
508 struct net_device *dev,
509 struct neighbour *neigh,
510 const struct in6_addr *daddr,
511 const struct in6_addr *saddr,
512 struct icmp6hdr *icmp6h)
513{
514 struct flowi fl;
515 struct dst_entry *dst;
516 struct net *net = dev_net(dev);
517 struct sock *sk = net->ipv6.ndisc_sk;
518 struct inet6_dev *idev;
519 int err;
520 u8 type;
521
522 type = icmp6h->icmp6_type;
523
524 icmpv6_flow_init(sk, &fl, type, saddr, daddr, dev->ifindex);
525
526 dst = icmp6_dst_alloc(dev, neigh, daddr);
527 if (!dst) {
528 kfree_skb(skb);
529 return;
530 }
531
Alexey Dobriyan52479b62008-11-25 17:35:18 -0800532 err = xfrm_lookup(net, &dst, &fl, NULL, 0);
Brian Haley305d5522008-11-04 17:51:14 -0800533 if (err < 0) {
534 kfree_skb(skb);
535 return;
536 }
537
Eric Dumazetadf30902009-06-02 05:19:30 +0000538 skb_dst_set(skb, dst);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900539
540 idev = in6_dev_get(dst->dev);
Neil Hormanedf391f2009-04-27 02:45:02 -0700541 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900542
Jan Engelhardtb2e0b382010-03-23 04:09:07 +0100543 err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev,
Patrick McHardy6e23ae22007-11-19 18:53:30 -0800544 dst_output);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900545 if (!err) {
Denis V. Lunev5c5d2442008-10-08 10:33:50 -0700546 ICMP6MSGOUT_INC_STATS(net, idev, type);
Denis V. Luneva862f6a2008-10-08 10:33:06 -0700547 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900548 }
549
550 if (likely(idev != NULL))
551 in6_dev_put(idev);
552}
553
Brian Haley305d5522008-11-04 17:51:14 -0800554EXPORT_SYMBOL(ndisc_send_skb);
555
556/*
557 * Send a Neighbour Discover packet
558 */
559static void __ndisc_send(struct net_device *dev,
560 struct neighbour *neigh,
561 const struct in6_addr *daddr,
562 const struct in6_addr *saddr,
563 struct icmp6hdr *icmp6h, const struct in6_addr *target,
564 int llinfo)
565{
566 struct sk_buff *skb;
567
568 skb = ndisc_build_skb(dev, daddr, saddr, icmp6h, target, llinfo);
569 if (!skb)
570 return;
571
572 ndisc_send_skb(skb, dev, neigh, daddr, saddr, icmp6h);
573}
574
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575static void ndisc_send_na(struct net_device *dev, struct neighbour *neigh,
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +0900576 const struct in6_addr *daddr,
577 const struct in6_addr *solicited_addr,
578 int router, int solicited, int override, int inc_opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579{
580 struct in6_addr tmpaddr;
581 struct inet6_ifaddr *ifp;
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +0900582 const struct in6_addr *src_addr;
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900583 struct icmp6hdr icmp6h = {
584 .icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT,
585 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586
587 /* for anycast or proxy, solicited_addr != src_addr */
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900588 ifp = ipv6_get_ifaddr(dev_net(dev), solicited_addr, dev, 1);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900589 if (ifp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 src_addr = solicited_addr;
Neil Horman95c385b2007-04-25 17:08:10 -0700591 if (ifp->flags & IFA_F_OPTIMISTIC)
592 override = 0;
stephen hemminger9f888162010-06-21 11:00:13 +0000593 inc_opt |= ifp->idev->cnf.force_tllao;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 in6_ifa_put(ifp);
595 } else {
Brian Haley191cd582008-08-14 15:33:21 -0700596 if (ipv6_dev_get_saddr(dev_net(dev), dev, daddr,
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900597 inet6_sk(dev_net(dev)->ipv6.ndisc_sk)->srcprefs,
YOSHIFUJI Hideaki7cbca672008-03-25 09:37:42 +0900598 &tmpaddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 return;
600 src_addr = &tmpaddr;
601 }
602
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900603 icmp6h.icmp6_router = router;
604 icmp6h.icmp6_solicited = solicited;
605 icmp6h.icmp6_override = override;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900607 __ndisc_send(dev, neigh, daddr, src_addr,
608 &icmp6h, solicited_addr,
David L Stevens14878f72007-09-16 16:52:35 -0700609 inc_opt ? ND_OPT_TARGET_LL_ADDR : 0);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900610}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611
612void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh,
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +0900613 const struct in6_addr *solicit,
614 const struct in6_addr *daddr, const struct in6_addr *saddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 struct in6_addr addr_buf;
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900617 struct icmp6hdr icmp6h = {
618 .icmp6_type = NDISC_NEIGHBOUR_SOLICITATION,
619 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620
621 if (saddr == NULL) {
Neil Horman95c385b2007-04-25 17:08:10 -0700622 if (ipv6_get_lladdr(dev, &addr_buf,
623 (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 return;
625 saddr = &addr_buf;
626 }
627
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900628 __ndisc_send(dev, neigh, daddr, saddr,
629 &icmp6h, solicit,
David L Stevens14878f72007-09-16 16:52:35 -0700630 !ipv6_addr_any(saddr) ? ND_OPT_SOURCE_LL_ADDR : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631}
632
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +0900633void ndisc_send_rs(struct net_device *dev, const struct in6_addr *saddr,
634 const struct in6_addr *daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635{
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900636 struct icmp6hdr icmp6h = {
637 .icmp6_type = NDISC_ROUTER_SOLICITATION,
638 };
Neil Horman95c385b2007-04-25 17:08:10 -0700639 int send_sllao = dev->addr_len;
Neil Horman95c385b2007-04-25 17:08:10 -0700640
641#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
642 /*
643 * According to section 2.2 of RFC 4429, we must not
644 * send router solicitations with a sllao from
645 * optimistic addresses, but we may send the solicitation
646 * if we don't include the sllao. So here we check
647 * if our address is optimistic, and if so, we
Joe Perchesbea85192007-12-20 14:01:35 -0800648 * suppress the inclusion of the sllao.
Neil Horman95c385b2007-04-25 17:08:10 -0700649 */
650 if (send_sllao) {
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900651 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev_net(dev), saddr,
Daniel Lezcano1cab3da2008-01-10 22:44:09 -0800652 dev, 1);
Neil Horman95c385b2007-04-25 17:08:10 -0700653 if (ifp) {
654 if (ifp->flags & IFA_F_OPTIMISTIC) {
YOSHIFUJI Hideakica043562007-02-28 23:13:20 +0900655 send_sllao = 0;
Neil Horman95c385b2007-04-25 17:08:10 -0700656 }
YOSHIFUJI Hideakica043562007-02-28 23:13:20 +0900657 in6_ifa_put(ifp);
Neil Horman95c385b2007-04-25 17:08:10 -0700658 } else {
659 send_sllao = 0;
660 }
661 }
662#endif
YOSHIFUJI Hideakie1ec7842007-04-24 20:44:52 +0900663 __ndisc_send(dev, NULL, daddr, saddr,
664 &icmp6h, NULL,
David L Stevens14878f72007-09-16 16:52:35 -0700665 send_sllao ? ND_OPT_SOURCE_LL_ADDR : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666}
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900667
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668
669static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
670{
671 /*
672 * "The sender MUST return an ICMP
673 * destination unreachable"
674 */
675 dst_link_failure(skb);
676 kfree_skb(skb);
677}
678
679/* Called with locked neigh: either read or both */
680
681static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
682{
683 struct in6_addr *saddr = NULL;
684 struct in6_addr mcaddr;
685 struct net_device *dev = neigh->dev;
686 struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
687 int probes = atomic_read(&neigh->probes);
688
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900689 if (skb && ipv6_chk_addr(dev_net(dev), &ipv6_hdr(skb)->saddr, dev, 1))
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700690 saddr = &ipv6_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691
692 if ((probes -= neigh->parms->ucast_probes) < 0) {
693 if (!(neigh->nud_state & NUD_VALID)) {
Harvey Harrison5b095d9892008-10-29 12:52:50 -0700694 ND_PRINTK1(KERN_DEBUG "%s(): trying to ucast probe in NUD_INVALID: %pI6\n",
Harvey Harrison0c6ce782008-10-28 16:09:23 -0700695 __func__, target);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 }
697 ndisc_send_ns(dev, neigh, target, target, saddr);
698 } else if ((probes -= neigh->parms->app_probes) < 0) {
699#ifdef CONFIG_ARPD
700 neigh_app_ns(neigh);
701#endif
702 } else {
703 addrconf_addr_solict_mult(target, &mcaddr);
704 ndisc_send_ns(dev, NULL, target, &mcaddr, saddr);
705 }
706}
707
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900708static int pndisc_is_router(const void *pkey,
709 struct net_device *dev)
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700710{
711 struct pneigh_entry *n;
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900712 int ret = -1;
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700713
714 read_lock_bh(&nd_tbl.lock);
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900715 n = __pneigh_lookup(&nd_tbl, dev_net(dev), pkey, dev);
716 if (n)
717 ret = !!(n->flags & NTF_ROUTER);
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700718 read_unlock_bh(&nd_tbl.lock);
719
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900720 return ret;
Pavel Emelyanovfa86d322008-03-24 14:48:59 -0700721}
722
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723static void ndisc_recv_ns(struct sk_buff *skb)
724{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700725 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700726 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
727 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 u8 *lladdr = NULL;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700729 u32 ndoptlen = skb->tail - (skb->transport_header +
730 offsetof(struct nd_msg, opt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 struct ndisc_options ndopts;
732 struct net_device *dev = skb->dev;
733 struct inet6_ifaddr *ifp;
734 struct inet6_dev *idev = NULL;
735 struct neighbour *neigh;
736 int dad = ipv6_addr_any(saddr);
737 int inc;
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900738 int is_router = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739
740 if (ipv6_addr_is_multicast(&msg->target)) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900741 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 "ICMPv6 NS: multicast target address");
743 return;
744 }
745
746 /*
747 * RFC2461 7.1.1:
748 * DAD has to be destined for solicited node multicast address.
749 */
750 if (dad &&
751 !(daddr->s6_addr32[0] == htonl(0xff020000) &&
752 daddr->s6_addr32[1] == htonl(0x00000000) &&
753 daddr->s6_addr32[2] == htonl(0x00000001) &&
754 daddr->s6_addr [12] == 0xff )) {
755 ND_PRINTK2(KERN_WARNING
756 "ICMPv6 NS: bad DAD packet (wrong destination)\n");
757 return;
758 }
759
760 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900761 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 "ICMPv6 NS: invalid ND options\n");
763 return;
764 }
765
766 if (ndopts.nd_opts_src_lladdr) {
767 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
768 if (!lladdr) {
769 ND_PRINTK2(KERN_WARNING
770 "ICMPv6 NS: invalid link-layer address length\n");
771 return;
772 }
773
774 /* RFC2461 7.1.1:
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900775 * If the IP source address is the unspecified address,
776 * there MUST NOT be source link-layer address option
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 * in the message.
778 */
779 if (dad) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900780 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 "ICMPv6 NS: bad DAD packet (link-layer address option)\n");
782 return;
783 }
784 }
785
786 inc = ipv6_addr_is_multicast(daddr);
787
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900788 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
Daniel Lezcanoa18bc692008-03-07 11:14:49 -0800789 if (ifp) {
Neil Horman95c385b2007-04-25 17:08:10 -0700790
791 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
792 if (dad) {
793 if (dev->type == ARPHRD_IEEE802_TR) {
Arnaldo Carvalho de Melo98e399f2007-03-19 15:33:04 -0700794 const unsigned char *sadr;
795 sadr = skb_mac_header(skb);
Neil Horman95c385b2007-04-25 17:08:10 -0700796 if (((sadr[8] ^ dev->dev_addr[0]) & 0x7f) == 0 &&
797 sadr[9] == dev->dev_addr[1] &&
798 sadr[10] == dev->dev_addr[2] &&
799 sadr[11] == dev->dev_addr[3] &&
800 sadr[12] == dev->dev_addr[4] &&
801 sadr[13] == dev->dev_addr[5]) {
802 /* looped-back to us */
803 goto out;
804 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 }
Neil Horman95c385b2007-04-25 17:08:10 -0700806
807 /*
808 * We are colliding with another node
809 * who is doing DAD
810 * so fail our DAD process
811 */
812 addrconf_dad_failure(ifp);
Denis V. Lunev9e3be4b2007-09-11 11:04:49 +0200813 return;
Neil Horman95c385b2007-04-25 17:08:10 -0700814 } else {
815 /*
816 * This is not a dad solicitation.
817 * If we are an optimistic node,
818 * we should respond.
819 * Otherwise, we should ignore it.
820 */
821 if (!(ifp->flags & IFA_F_OPTIMISTIC))
822 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 }
825
826 idev = ifp->idev;
827 } else {
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700828 struct net *net = dev_net(dev);
829
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 idev = in6_dev_get(dev);
831 if (!idev) {
832 /* XXX: count this drop? */
833 return;
834 }
835
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700836 if (ipv6_chk_acast_addr(net, dev, &msg->target) ||
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900837 (idev->cnf.forwarding &&
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700838 (net->ipv6.devconf_all->proxy_ndp || idev->cnf.proxy_ndp) &&
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900839 (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) {
Patrick McHardya61bbcf2005-08-14 17:24:31 -0700840 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 skb->pkt_type != PACKET_HOST &&
842 inc != 0 &&
843 idev->nd_parms->proxy_delay != 0) {
844 /*
845 * for anycast or proxy,
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900846 * sender should delay its response
847 * by a random time between 0 and
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 * MAX_ANYCAST_DELAY_TIME seconds.
849 * (RFC2461) -- yoshfuji
850 */
851 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
852 if (n)
853 pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
854 goto out;
855 }
856 } else
857 goto out;
858 }
859
YOSHIFUJI Hideaki0736ffc2008-03-28 13:37:58 +0900860 if (is_router < 0)
861 is_router = !!idev->cnf.forwarding;
Ville Nuorvala62dd9312006-09-22 14:43:19 -0700862
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 if (dad) {
YOSHIFUJI Hideakif3ee4012008-04-10 15:42:11 +0900864 ndisc_send_na(dev, NULL, &in6addr_linklocal_allnodes, &msg->target,
Ville Nuorvala62dd9312006-09-22 14:43:19 -0700865 is_router, 0, (ifp != NULL), 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 goto out;
867 }
868
869 if (inc)
870 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
871 else
872 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
873
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900874 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 * update / create cache entry
876 * for the source address
877 */
878 neigh = __neigh_lookup(&nd_tbl, saddr, dev,
879 !inc || lladdr || !dev->addr_len);
880 if (neigh)
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900881 neigh_update(neigh, lladdr, NUD_STALE,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 NEIGH_UPDATE_F_WEAK_OVERRIDE|
883 NEIGH_UPDATE_F_OVERRIDE);
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700884 if (neigh || !dev->header_ops) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 ndisc_send_na(dev, neigh, saddr, &msg->target,
Ville Nuorvala62dd9312006-09-22 14:43:19 -0700886 is_router,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 1, (ifp != NULL && inc), inc);
888 if (neigh)
889 neigh_release(neigh);
890 }
891
892out:
893 if (ifp)
894 in6_ifa_put(ifp);
895 else
896 in6_dev_put(idev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897}
898
899static void ndisc_recv_na(struct sk_buff *skb)
900{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700901 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700902 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
903 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 u8 *lladdr = NULL;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700905 u32 ndoptlen = skb->tail - (skb->transport_header +
906 offsetof(struct nd_msg, opt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 struct ndisc_options ndopts;
908 struct net_device *dev = skb->dev;
909 struct inet6_ifaddr *ifp;
910 struct neighbour *neigh;
911
912 if (skb->len < sizeof(struct nd_msg)) {
913 ND_PRINTK2(KERN_WARNING
914 "ICMPv6 NA: packet too short\n");
915 return;
916 }
917
918 if (ipv6_addr_is_multicast(&msg->target)) {
919 ND_PRINTK2(KERN_WARNING
920 "ICMPv6 NA: target address is multicast.\n");
921 return;
922 }
923
924 if (ipv6_addr_is_multicast(daddr) &&
925 msg->icmph.icmp6_solicited) {
926 ND_PRINTK2(KERN_WARNING
927 "ICMPv6 NA: solicited NA is multicasted.\n");
928 return;
929 }
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900930
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
932 ND_PRINTK2(KERN_WARNING
933 "ICMPv6 NS: invalid ND option\n");
934 return;
935 }
936 if (ndopts.nd_opts_tgt_lladdr) {
937 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
938 if (!lladdr) {
939 ND_PRINTK2(KERN_WARNING
940 "ICMPv6 NA: invalid link-layer address length\n");
941 return;
942 }
943 }
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900944 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
Daniel Lezcanoa18bc692008-03-07 11:14:49 -0800945 if (ifp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 if (ifp->flags & IFA_F_TENTATIVE) {
947 addrconf_dad_failure(ifp);
948 return;
949 }
950 /* What should we make now? The advertisement
951 is invalid, but ndisc specs say nothing
952 about it. It could be misconfiguration, or
953 an smart proxy agent tries to help us :-)
Jan Sembera24fc7b82008-12-09 15:48:32 -0800954
955 We should not print the error if NA has been
956 received from loopback - it is just our own
957 unsolicited advertisement.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 */
Jan Sembera24fc7b82008-12-09 15:48:32 -0800959 if (skb->pkt_type != PACKET_LOOPBACK)
960 ND_PRINTK1(KERN_WARNING
Jens Rosenbooma6fa3282009-08-12 22:16:04 +0000961 "ICMPv6 NA: someone advertises our address %pI6 on %s!\n",
962 &ifp->addr, ifp->idev->dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 in6_ifa_put(ifp);
964 return;
965 }
966 neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
967
968 if (neigh) {
969 u8 old_flags = neigh->flags;
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700970 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971
972 if (neigh->nud_state & NUD_FAILED)
973 goto out;
974
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -0700975 /*
976 * Don't update the neighbor cache entry on a proxy NA from
977 * ourselves because either the proxied node is off link or it
978 * has already sent a NA to us.
979 */
980 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
YOSHIFUJI Hideaki53b79972008-07-19 22:35:03 -0700981 net->ipv6.devconf_all->forwarding && net->ipv6.devconf_all->proxy_ndp &&
982 pneigh_lookup(&nd_tbl, net, &msg->target, dev, 0)) {
YOSHIFUJI Hideakifbea49e2006-09-22 14:43:49 -0700983 /* XXX: idev->cnf.prixy_ndp */
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -0700984 goto out;
YOSHIFUJI Hideakifbea49e2006-09-22 14:43:49 -0700985 }
Ville Nuorvala5f3e6e92006-09-22 14:42:46 -0700986
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 neigh_update(neigh, lladdr,
988 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
989 NEIGH_UPDATE_F_WEAK_OVERRIDE|
990 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
991 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
992 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));
993
994 if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
995 /*
996 * Change: router to host
997 */
998 struct rt6_info *rt;
999 rt = rt6_get_dflt_router(saddr, dev);
1000 if (rt)
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001001 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 }
1003
1004out:
1005 neigh_release(neigh);
1006 }
1007}
1008
1009static void ndisc_recv_rs(struct sk_buff *skb)
1010{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001011 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
1013 struct neighbour *neigh;
1014 struct inet6_dev *idev;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001015 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 struct ndisc_options ndopts;
1017 u8 *lladdr = NULL;
1018
1019 if (skb->len < sizeof(*rs_msg))
1020 return;
1021
1022 idev = in6_dev_get(skb->dev);
1023 if (!idev) {
1024 if (net_ratelimit())
1025 ND_PRINTK1("ICMP6 RS: can't find in6 device\n");
1026 return;
1027 }
1028
1029 /* Don't accept RS if we're not in router mode */
1030 if (!idev->cnf.forwarding)
1031 goto out;
1032
1033 /*
1034 * Don't update NCE if src = ::;
1035 * this implies that the source node has no ip address assigned yet.
1036 */
1037 if (ipv6_addr_any(saddr))
1038 goto out;
1039
1040 /* Parse ND options */
1041 if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {
1042 if (net_ratelimit())
1043 ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n");
1044 goto out;
1045 }
1046
1047 if (ndopts.nd_opts_src_lladdr) {
1048 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1049 skb->dev);
1050 if (!lladdr)
1051 goto out;
1052 }
1053
1054 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
1055 if (neigh) {
1056 neigh_update(neigh, lladdr, NUD_STALE,
1057 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1058 NEIGH_UPDATE_F_OVERRIDE|
1059 NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
1060 neigh_release(neigh);
1061 }
1062out:
1063 in6_dev_put(idev);
1064}
1065
Pierre Ynard31910572007-10-10 21:22:05 -07001066static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt)
1067{
1068 struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra);
1069 struct sk_buff *skb;
1070 struct nlmsghdr *nlh;
1071 struct nduseroptmsg *ndmsg;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001072 struct net *net = dev_net(ra->dev);
Pierre Ynard31910572007-10-10 21:22:05 -07001073 int err;
1074 int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg)
1075 + (opt->nd_opt_len << 3));
1076 size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr));
1077
1078 skb = nlmsg_new(msg_size, GFP_ATOMIC);
1079 if (skb == NULL) {
1080 err = -ENOBUFS;
1081 goto errout;
1082 }
1083
1084 nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0);
1085 if (nlh == NULL) {
1086 goto nla_put_failure;
1087 }
1088
1089 ndmsg = nlmsg_data(nlh);
1090 ndmsg->nduseropt_family = AF_INET6;
Pierre Ynarddbb2ed22007-11-12 17:58:35 -08001091 ndmsg->nduseropt_ifindex = ra->dev->ifindex;
Pierre Ynard31910572007-10-10 21:22:05 -07001092 ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type;
1093 ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code;
1094 ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3;
1095
1096 memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3);
1097
1098 NLA_PUT(skb, NDUSEROPT_SRCADDR, sizeof(struct in6_addr),
1099 &ipv6_hdr(ra)->saddr);
1100 nlmsg_end(skb, nlh);
1101
Pablo Neira Ayuso1ce85fe2009-02-24 23:18:28 -08001102 rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL, GFP_ATOMIC);
Pierre Ynard31910572007-10-10 21:22:05 -07001103 return;
1104
1105nla_put_failure:
1106 nlmsg_free(skb);
1107 err = -EMSGSIZE;
1108errout:
Daniel Lezcanoa18bc692008-03-07 11:14:49 -08001109 rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err);
Pierre Ynard31910572007-10-10 21:22:05 -07001110}
1111
Thomas Graf65e9b622010-09-03 02:59:14 +00001112static inline int accept_ra(struct inet6_dev *in6_dev)
1113{
1114 /*
1115 * If forwarding is enabled, RA are not accepted unless the special
1116 * hybrid mode (accept_ra=2) is enabled.
1117 */
1118 if (in6_dev->cnf.forwarding && in6_dev->cnf.accept_ra < 2)
1119 return 0;
1120
1121 return in6_dev->cnf.accept_ra;
1122}
1123
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124static void ndisc_router_discovery(struct sk_buff *skb)
1125{
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001126 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 struct neighbour *neigh = NULL;
1128 struct inet6_dev *in6_dev;
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001129 struct rt6_info *rt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 int lifetime;
1131 struct ndisc_options ndopts;
1132 int optlen;
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001133 unsigned int pref = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134
1135 __u8 * opt = (__u8 *)(ra_msg + 1);
1136
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001137 optlen = (skb->tail - skb->transport_header) - sizeof(struct ra_msg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001139 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 ND_PRINTK2(KERN_WARNING
1141 "ICMPv6 RA: source address is not link-local.\n");
1142 return;
1143 }
1144 if (optlen < 0) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001145 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 "ICMPv6 RA: packet too short\n");
1147 return;
1148 }
1149
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001150#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001151 if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) {
1152 ND_PRINTK2(KERN_WARNING
1153 "ICMPv6 RA: from host or unauthorized router\n");
1154 return;
1155 }
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001156#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001157
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 /*
1159 * set the RA_RECV flag in the interface
1160 */
1161
1162 in6_dev = in6_dev_get(skb->dev);
1163 if (in6_dev == NULL) {
1164 ND_PRINTK0(KERN_ERR
1165 "ICMPv6 RA: can't find inet6 device for %s.\n",
1166 skb->dev->name);
1167 return;
1168 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169
1170 if (!ndisc_parse_options(opt, optlen, &ndopts)) {
1171 in6_dev_put(in6_dev);
1172 ND_PRINTK2(KERN_WARNING
1173 "ICMP6 RA: invalid ND options\n");
1174 return;
1175 }
1176
Thomas Graf65e9b622010-09-03 02:59:14 +00001177 if (!accept_ra(in6_dev))
David Ward31ce8c72009-08-29 00:04:09 -07001178 goto skip_linkparms;
1179
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001180#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001181 /* skip link-specific parameters from interior routers */
1182 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1183 goto skip_linkparms;
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001184#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001185
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 if (in6_dev->if_flags & IF_RS_SENT) {
1187 /*
1188 * flag that an RA was received after an RS was sent
1189 * out on this interface.
1190 */
1191 in6_dev->if_flags |= IF_RA_RCVD;
1192 }
1193
1194 /*
1195 * Remember the managed/otherconf flags from most recently
1196 * received RA message (RFC 2462) -- yoshfuji
1197 */
1198 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1199 IF_RA_OTHERCONF)) |
1200 (ra_msg->icmph.icmp6_addrconf_managed ?
1201 IF_RA_MANAGED : 0) |
1202 (ra_msg->icmph.icmp6_addrconf_other ?
1203 IF_RA_OTHERCONF : 0);
1204
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001205 if (!in6_dev->cnf.accept_ra_defrtr)
1206 goto skip_defrtr;
1207
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1209
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001210#ifdef CONFIG_IPV6_ROUTER_PREF
1211 pref = ra_msg->icmph.icmp6_router_pref;
1212 /* 10b is handled as if it were 00b (medium) */
YOSHIFUJI Hideaki930d6ff2006-03-20 17:05:30 -08001213 if (pref == ICMPV6_ROUTER_PREF_INVALID ||
YOSHIFUJI Hideaki6d5b78c2007-06-22 16:07:04 -07001214 !in6_dev->cnf.accept_ra_rtr_pref)
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001215 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1216#endif
1217
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001218 rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219
1220 if (rt)
1221 neigh = rt->rt6i_nexthop;
1222
1223 if (rt && lifetime == 0) {
1224 neigh_clone(neigh);
Thomas Grafe0a1ad732006-08-22 00:00:21 -07001225 ip6_del_rt(rt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226 rt = NULL;
1227 }
1228
1229 if (rt == NULL && lifetime) {
1230 ND_PRINTK3(KERN_DEBUG
1231 "ICMPv6 RA: adding default router.\n");
1232
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001233 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 if (rt == NULL) {
1235 ND_PRINTK0(KERN_ERR
1236 "ICMPv6 RA: %s() failed to add default route.\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001237 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238 in6_dev_put(in6_dev);
1239 return;
1240 }
1241
1242 neigh = rt->rt6i_nexthop;
1243 if (neigh == NULL) {
1244 ND_PRINTK0(KERN_ERR
1245 "ICMPv6 RA: %s() got default router without neighbour.\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001246 __func__);
Changli Gaod8d1f302010-06-10 23:31:35 -07001247 dst_release(&rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248 in6_dev_put(in6_dev);
1249 return;
1250 }
1251 neigh->flags |= NTF_ROUTER;
YOSHIFUJI Hideakiebacaaa2006-03-20 17:04:53 -08001252 } else if (rt) {
Pedro Ribeiro22441cf2008-10-15 15:47:49 -07001253 rt->rt6i_flags = (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254 }
1255
1256 if (rt)
1257 rt->rt6i_expires = jiffies + (HZ * lifetime);
1258
1259 if (ra_msg->icmph.icmp6_hop_limit) {
1260 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1261 if (rt)
David S. Millerdefb3512010-12-08 21:16:57 -08001262 dst_metric_set(&rt->dst, RTAX_HOPLIMIT,
1263 ra_msg->icmph.icmp6_hop_limit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 }
1265
YOSHIFUJI Hideaki65f5c7c2006-03-20 16:55:08 -08001266skip_defrtr:
1267
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 /*
1269 * Update Reachable Time and Retrans Timer
1270 */
1271
1272 if (in6_dev->nd_parms) {
1273 unsigned long rtime = ntohl(ra_msg->retrans_timer);
1274
1275 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1276 rtime = (rtime*HZ)/1000;
1277 if (rtime < HZ/10)
1278 rtime = HZ/10;
1279 in6_dev->nd_parms->retrans_time = rtime;
1280 in6_dev->tstamp = jiffies;
1281 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1282 }
1283
1284 rtime = ntohl(ra_msg->reachable_time);
1285 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1286 rtime = (rtime*HZ)/1000;
1287
1288 if (rtime < HZ/10)
1289 rtime = HZ/10;
1290
1291 if (rtime != in6_dev->nd_parms->base_reachable_time) {
1292 in6_dev->nd_parms->base_reachable_time = rtime;
1293 in6_dev->nd_parms->gc_staletime = 3 * rtime;
1294 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1295 in6_dev->tstamp = jiffies;
1296 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1297 }
1298 }
1299 }
1300
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001301skip_linkparms:
1302
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 /*
1304 * Process options.
1305 */
1306
1307 if (!neigh)
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001308 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309 skb->dev, 1);
1310 if (neigh) {
1311 u8 *lladdr = NULL;
1312 if (ndopts.nd_opts_src_lladdr) {
1313 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1314 skb->dev);
1315 if (!lladdr) {
1316 ND_PRINTK2(KERN_WARNING
1317 "ICMPv6 RA: invalid link-layer address length\n");
1318 goto out;
1319 }
1320 }
1321 neigh_update(neigh, lladdr, NUD_STALE,
1322 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1323 NEIGH_UPDATE_F_OVERRIDE|
1324 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1325 NEIGH_UPDATE_F_ISROUTER);
1326 }
1327
Thomas Graf65e9b622010-09-03 02:59:14 +00001328 if (!accept_ra(in6_dev))
David Ward31ce8c72009-08-29 00:04:09 -07001329 goto out;
1330
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001331#ifdef CONFIG_IPV6_ROUTE_INFO
YOSHIFUJI Hideaki09c884d2006-03-20 17:07:03 -08001332 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001333 struct nd_opt_hdr *p;
1334 for (p = ndopts.nd_opts_ri;
1335 p;
1336 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
YOSHIFUJI Hideaki6294e002008-03-15 23:56:52 -04001337 struct route_info *ri = (struct route_info *)p;
1338#ifdef CONFIG_IPV6_NDISC_NODETYPE
1339 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT &&
1340 ri->prefix_len == 0)
1341 continue;
1342#endif
1343 if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
YOSHIFUJI Hideaki09c884d2006-03-20 17:07:03 -08001344 continue;
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001345 rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3,
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001346 &ipv6_hdr(skb)->saddr);
YOSHIFUJI Hideaki70ceb4f2006-03-20 17:06:24 -08001347 }
1348 }
1349#endif
1350
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001351#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001352 /* skip link-specific ndopts from interior routers */
1353 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1354 goto out;
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001355#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001356
YOSHIFUJI Hideakic4fd30e2006-03-20 16:55:26 -08001357 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358 struct nd_opt_hdr *p;
1359 for (p = ndopts.nd_opts_pi;
1360 p;
1361 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1362 addrconf_prefix_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3);
1363 }
1364 }
1365
1366 if (ndopts.nd_opts_mtu) {
Al Viroe69a4ad2006-11-14 20:56:00 -08001367 __be32 n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 u32 mtu;
1369
Al Viroe69a4ad2006-11-14 20:56:00 -08001370 memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1371 mtu = ntohl(n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372
1373 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1374 ND_PRINTK2(KERN_WARNING
1375 "ICMPv6 RA: invalid mtu: %d\n",
1376 mtu);
1377 } else if (in6_dev->cnf.mtu6 != mtu) {
1378 in6_dev->cnf.mtu6 = mtu;
1379
1380 if (rt)
David S. Millerdefb3512010-12-08 21:16:57 -08001381 dst_metric_set(&rt->dst, RTAX_MTU, mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382
1383 rt6_mtu_change(skb->dev, mtu);
1384 }
1385 }
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001386
Pierre Ynard31910572007-10-10 21:22:05 -07001387 if (ndopts.nd_useropts) {
YOSHIFUJI Hideaki61cf46ad2008-01-22 17:32:53 +09001388 struct nd_opt_hdr *p;
1389 for (p = ndopts.nd_useropts;
1390 p;
1391 p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) {
1392 ndisc_ra_useropt(skb, p);
Pierre Ynard31910572007-10-10 21:22:05 -07001393 }
1394 }
1395
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1397 ND_PRINTK2(KERN_WARNING
1398 "ICMPv6 RA: invalid RA options");
1399 }
1400out:
1401 if (rt)
Changli Gaod8d1f302010-06-10 23:31:35 -07001402 dst_release(&rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403 else if (neigh)
1404 neigh_release(neigh);
1405 in6_dev_put(in6_dev);
1406}
1407
1408static void ndisc_redirect_rcv(struct sk_buff *skb)
1409{
1410 struct inet6_dev *in6_dev;
1411 struct icmp6hdr *icmph;
1412 struct in6_addr *dest;
1413 struct in6_addr *target; /* new first hop to destination */
1414 struct neighbour *neigh;
1415 int on_link = 0;
1416 struct ndisc_options ndopts;
1417 int optlen;
1418 u8 *lladdr = NULL;
1419
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001420#ifdef CONFIG_IPV6_NDISC_NODETYPE
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001421 switch (skb->ndisc_nodetype) {
1422 case NDISC_NODETYPE_HOST:
1423 case NDISC_NODETYPE_NODEFAULT:
1424 ND_PRINTK2(KERN_WARNING
1425 "ICMPv6 Redirect: from host or unauthorized router\n");
1426 return;
1427 }
YOSHIFUJI Hideakide357cc2008-03-15 23:59:18 -04001428#endif
Templin, Fred Lfadf6bf2008-03-11 18:35:59 -04001429
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001430 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 ND_PRINTK2(KERN_WARNING
1432 "ICMPv6 Redirect: source address is not link-local.\n");
1433 return;
1434 }
1435
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001436 optlen = skb->tail - skb->transport_header;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437 optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1438
1439 if (optlen < 0) {
1440 ND_PRINTK2(KERN_WARNING
1441 "ICMPv6 Redirect: packet too short\n");
1442 return;
1443 }
1444
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -03001445 icmph = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446 target = (struct in6_addr *) (icmph + 1);
1447 dest = target + 1;
1448
1449 if (ipv6_addr_is_multicast(dest)) {
1450 ND_PRINTK2(KERN_WARNING
1451 "ICMPv6 Redirect: destination address is multicast.\n");
1452 return;
1453 }
1454
1455 if (ipv6_addr_equal(dest, target)) {
1456 on_link = 1;
Brian Haleybf0b48d2007-10-08 00:12:05 -07001457 } else if (ipv6_addr_type(target) !=
1458 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001459 ND_PRINTK2(KERN_WARNING
Brian Haleybf0b48d2007-10-08 00:12:05 -07001460 "ICMPv6 Redirect: target address is not link-local unicast.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461 return;
1462 }
1463
1464 in6_dev = in6_dev_get(skb->dev);
1465 if (!in6_dev)
1466 return;
1467 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects) {
1468 in6_dev_put(in6_dev);
1469 return;
1470 }
1471
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001472 /* RFC2461 8.1:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 * The IP source address of the Redirect MUST be the same as the current
1474 * first-hop router for the specified ICMP Destination Address.
1475 */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001476
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477 if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) {
1478 ND_PRINTK2(KERN_WARNING
1479 "ICMPv6 Redirect: invalid ND options\n");
1480 in6_dev_put(in6_dev);
1481 return;
1482 }
1483 if (ndopts.nd_opts_tgt_lladdr) {
1484 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1485 skb->dev);
1486 if (!lladdr) {
1487 ND_PRINTK2(KERN_WARNING
1488 "ICMPv6 Redirect: invalid link-layer address length\n");
1489 in6_dev_put(in6_dev);
1490 return;
1491 }
1492 }
1493
1494 neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1);
1495 if (neigh) {
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001496 rt6_redirect(dest, &ipv6_hdr(skb)->daddr,
1497 &ipv6_hdr(skb)->saddr, neigh, lladdr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498 on_link);
1499 neigh_release(neigh);
1500 }
1501 in6_dev_put(in6_dev);
1502}
1503
1504void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh,
YOSHIFUJI Hideaki9acd9f32008-04-10 15:42:10 +09001505 const struct in6_addr *target)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506{
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001507 struct net_device *dev = skb->dev;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001508 struct net *net = dev_net(dev);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001509 struct sock *sk = net->ipv6.ndisc_sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510 int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1511 struct sk_buff *buff;
1512 struct icmp6hdr *icmph;
1513 struct in6_addr saddr_buf;
1514 struct in6_addr *addrp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515 struct rt6_info *rt;
1516 struct dst_entry *dst;
1517 struct inet6_dev *idev;
1518 struct flowi fl;
1519 u8 *opt;
1520 int rd_len;
1521 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1523
Neil Horman95c385b2007-04-25 17:08:10 -07001524 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525 ND_PRINTK2(KERN_WARNING
1526 "ICMPv6 Redirect: no link-local address on %s\n",
1527 dev->name);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001528 return;
1529 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001531 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
Brian Haleybf0b48d2007-10-08 00:12:05 -07001532 ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
Li Yewang29556522007-01-30 14:33:20 -08001533 ND_PRINTK2(KERN_WARNING
Brian Haleybf0b48d2007-10-08 00:12:05 -07001534 "ICMPv6 Redirect: target address is not link-local unicast.\n");
Li Yewang29556522007-01-30 14:33:20 -08001535 return;
1536 }
1537
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001538 icmpv6_flow_init(sk, &fl, NDISC_REDIRECT,
YOSHIFUJI Hideaki95e41e92007-12-06 15:43:30 -08001539 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001541 dst = ip6_route_output(net, NULL, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542 if (dst == NULL)
1543 return;
1544
Alexey Dobriyan52479b62008-11-25 17:35:18 -08001545 err = xfrm_lookup(net, &dst, &fl, NULL, 0);
Patrick McHardye104411b2005-09-08 15:11:55 -07001546 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548
1549 rt = (struct rt6_info *) dst;
1550
1551 if (rt->rt6i_flags & RTF_GATEWAY) {
1552 ND_PRINTK2(KERN_WARNING
1553 "ICMPv6 Redirect: destination is not a neighbour.\n");
Ilpo Järvinend73f0802009-02-06 23:47:37 -08001554 goto release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555 }
Ilpo Järvinend73f0802009-02-06 23:47:37 -08001556 if (!xrlim_allow(dst, 1*HZ))
1557 goto release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558
1559 if (dev->addr_len) {
1560 read_lock_bh(&neigh->lock);
1561 if (neigh->nud_state & NUD_VALID) {
1562 memcpy(ha_buf, neigh->ha, dev->addr_len);
1563 read_unlock_bh(&neigh->lock);
1564 ha = ha_buf;
1565 len += ndisc_opt_addr_space(dev);
1566 } else
1567 read_unlock_bh(&neigh->lock);
1568 }
1569
1570 rd_len = min_t(unsigned int,
1571 IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8);
1572 rd_len &= ~0x7;
1573 len += rd_len;
1574
David S. Millerd54a81d2006-12-02 21:00:06 -08001575 buff = sock_alloc_send_skb(sk,
1576 (MAX_HEADER + sizeof(struct ipv6hdr) +
Johannes Bergf5184d22008-05-12 20:48:31 -07001577 len + LL_ALLOCATED_SPACE(dev)),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578 1, &err);
1579 if (buff == NULL) {
1580 ND_PRINTK0(KERN_ERR
Brian Haleydae9de82009-06-02 00:20:26 -07001581 "ICMPv6 Redirect: %s() failed to allocate an skb, err=%d.\n",
1582 __func__, err);
Ilpo Järvinend73f0802009-02-06 23:47:37 -08001583 goto release;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 }
1585
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586 skb_reserve(buff, LL_RESERVED_SPACE(dev));
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001587 ip6_nd_hdr(sk, buff, dev, &saddr_buf, &ipv6_hdr(skb)->saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588 IPPROTO_ICMPV6, len);
1589
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -07001590 skb_set_transport_header(buff, skb_tail_pointer(buff) - buff->data);
Arnaldo Carvalho de Melod10ba342007-03-14 21:05:37 -03001591 skb_put(buff, len);
1592 icmph = icmp6_hdr(buff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593
1594 memset(icmph, 0, sizeof(struct icmp6hdr));
1595 icmph->icmp6_type = NDISC_REDIRECT;
1596
1597 /*
1598 * copy target and destination addresses
1599 */
1600
1601 addrp = (struct in6_addr *)(icmph + 1);
1602 ipv6_addr_copy(addrp, target);
1603 addrp++;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001604 ipv6_addr_copy(addrp, &ipv6_hdr(skb)->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605
1606 opt = (u8*) (addrp + 1);
1607
1608 /*
1609 * include target_address option
1610 */
1611
1612 if (ha)
1613 opt = ndisc_fill_addr_option(opt, ND_OPT_TARGET_LL_ADDR, ha,
1614 dev->addr_len, dev->type);
1615
1616 /*
1617 * build redirect option and copy skb over to the new packet.
1618 */
1619
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001620 memset(opt, 0, 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621 *(opt++) = ND_OPT_REDIRECT_HDR;
1622 *(opt++) = (rd_len >> 3);
1623 opt += 6;
1624
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001625 memcpy(opt, ipv6_hdr(skb), rd_len - 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001627 icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &ipv6_hdr(skb)->saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628 len, IPPROTO_ICMPV6,
Joe Perches07f07572008-11-19 15:44:53 -08001629 csum_partial(icmph, len, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630
Eric Dumazetadf30902009-06-02 05:19:30 +00001631 skb_dst_set(buff, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632 idev = in6_dev_get(dst->dev);
Neil Hormanedf391f2009-04-27 02:45:02 -07001633 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
Jan Engelhardtb2e0b382010-03-23 04:09:07 +01001634 err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, buff, NULL, dst->dev,
Patrick McHardy6e23ae22007-11-19 18:53:30 -08001635 dst_output);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 if (!err) {
Denis V. Lunev5c5d2442008-10-08 10:33:50 -07001637 ICMP6MSGOUT_INC_STATS(net, idev, NDISC_REDIRECT);
Denis V. Luneva862f6a2008-10-08 10:33:06 -07001638 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639 }
1640
1641 if (likely(idev != NULL))
1642 in6_dev_put(idev);
Ilpo Järvinend73f0802009-02-06 23:47:37 -08001643 return;
1644
1645release:
1646 dst_release(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647}
1648
1649static void pndisc_redo(struct sk_buff *skb)
1650{
YOSHIFUJI Hideaki140e26fc2005-10-05 12:11:41 -07001651 ndisc_recv_ns(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652 kfree_skb(skb);
1653}
1654
1655int ndisc_rcv(struct sk_buff *skb)
1656{
1657 struct nd_msg *msg;
1658
1659 if (!pskb_may_pull(skb, skb->len))
1660 return 0;
1661
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001662 msg = (struct nd_msg *)skb_transport_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -07001664 __skb_push(skb, skb->data - skb_transport_header(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001666 if (ipv6_hdr(skb)->hop_limit != 255) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 ND_PRINTK2(KERN_WARNING
1668 "ICMPv6 NDISC: invalid hop-limit: %d\n",
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -07001669 ipv6_hdr(skb)->hop_limit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670 return 0;
1671 }
1672
1673 if (msg->icmph.icmp6_code != 0) {
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001674 ND_PRINTK2(KERN_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675 "ICMPv6 NDISC: invalid ICMPv6 code: %d\n",
1676 msg->icmph.icmp6_code);
1677 return 0;
1678 }
1679
Patrick McHardya61bbcf2005-08-14 17:24:31 -07001680 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1681
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 switch (msg->icmph.icmp6_type) {
1683 case NDISC_NEIGHBOUR_SOLICITATION:
1684 ndisc_recv_ns(skb);
1685 break;
1686
1687 case NDISC_NEIGHBOUR_ADVERTISEMENT:
1688 ndisc_recv_na(skb);
1689 break;
1690
1691 case NDISC_ROUTER_SOLICITATION:
1692 ndisc_recv_rs(skb);
1693 break;
1694
1695 case NDISC_ROUTER_ADVERTISEMENT:
1696 ndisc_router_discovery(skb);
1697 break;
1698
1699 case NDISC_REDIRECT:
1700 ndisc_redirect_rcv(skb);
1701 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -07001702 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703
1704 return 0;
1705}
1706
1707static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1708{
1709 struct net_device *dev = ptr;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001710 struct net *net = dev_net(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711
1712 switch (event) {
1713 case NETDEV_CHANGEADDR:
1714 neigh_changeaddr(&nd_tbl, dev);
Daniel Lezcano5b7c9312008-03-03 23:28:58 -08001715 fib6_run_gc(~0UL, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716 break;
1717 case NETDEV_DOWN:
1718 neigh_ifdown(&nd_tbl, dev);
Daniel Lezcano5b7c9312008-03-03 23:28:58 -08001719 fib6_run_gc(~0UL, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720 break;
1721 default:
1722 break;
1723 }
1724
1725 return NOTIFY_DONE;
1726}
1727
1728static struct notifier_block ndisc_netdev_notifier = {
1729 .notifier_call = ndisc_netdev_event,
1730};
1731
1732#ifdef CONFIG_SYSCTL
1733static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1734 const char *func, const char *dev_name)
1735{
1736 static char warncomm[TASK_COMM_LEN];
1737 static int warned;
1738 if (strcmp(warncomm, current->comm) && warned < 5) {
1739 strcpy(warncomm, current->comm);
1740 printk(KERN_WARNING
1741 "process `%s' is using deprecated sysctl (%s) "
1742 "net.ipv6.neigh.%s.%s; "
1743 "Use net.ipv6.neigh.%s.%s_ms "
1744 "instead.\n",
1745 warncomm, func,
1746 dev_name, ctl->procname,
1747 dev_name, ctl->procname);
1748 warned++;
1749 }
1750}
1751
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001752int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, void __user *buffer, size_t *lenp, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753{
1754 struct net_device *dev = ctl->extra1;
1755 struct inet6_dev *idev;
1756 int ret;
1757
Eric W. Biedermand12af672007-10-18 03:05:25 -07001758 if ((strcmp(ctl->procname, "retrans_time") == 0) ||
1759 (strcmp(ctl->procname, "base_reachable_time") == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1761
Eric W. Biedermand12af672007-10-18 03:05:25 -07001762 if (strcmp(ctl->procname, "retrans_time") == 0)
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001763 ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001764
1765 else if (strcmp(ctl->procname, "base_reachable_time") == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766 ret = proc_dointvec_jiffies(ctl, write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001767 buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001768
1769 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
YOSHIFUJI Hideakiad02ac12007-10-29 01:32:23 -07001770 (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771 ret = proc_dointvec_ms_jiffies(ctl, write,
Alexey Dobriyan8d65af72009-09-23 15:57:19 -07001772 buffer, lenp, ppos);
Eric W. Biedermand12af672007-10-18 03:05:25 -07001773 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774 ret = -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775
1776 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
Eric W. Biedermand12af672007-10-18 03:05:25 -07001777 if (ctl->data == &idev->nd_parms->base_reachable_time)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1779 idev->tstamp = jiffies;
1780 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1781 in6_dev_put(idev);
1782 }
1783 return ret;
1784}
1785
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786
1787#endif
1788
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001789static int __net_init ndisc_net_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790{
1791 struct ipv6_pinfo *np;
1792 struct sock *sk;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001793 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794
Denis V. Lunev1ed85162008-04-03 14:31:03 -07001795 err = inet_ctl_sock_create(&sk, PF_INET6,
1796 SOCK_RAW, IPPROTO_ICMPV6, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797 if (err < 0) {
1798 ND_PRINTK0(KERN_ERR
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001799 "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800 err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801 return err;
1802 }
1803
Denis V. Lunev1ed85162008-04-03 14:31:03 -07001804 net->ipv6.ndisc_sk = sk;
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001805
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806 np = inet6_sk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807 np->hop_limit = 255;
1808 /* Do not loopback ndisc messages */
1809 np->mc_loop = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001811 return 0;
1812}
1813
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001814static void __net_exit ndisc_net_exit(struct net *net)
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001815{
Denis V. Lunev1ed85162008-04-03 14:31:03 -07001816 inet_ctl_sock_destroy(net->ipv6.ndisc_sk);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001817}
1818
1819static struct pernet_operations ndisc_net_ops = {
1820 .init = ndisc_net_init,
1821 .exit = ndisc_net_exit,
1822};
1823
1824int __init ndisc_init(void)
1825{
1826 int err;
1827
1828 err = register_pernet_subsys(&ndisc_net_ops);
1829 if (err)
1830 return err;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +09001831 /*
1832 * Initialize the neighbour table
1833 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834 neigh_table_init(&nd_tbl);
1835
1836#ifdef CONFIG_SYSCTL
Eric W. Biederman54716e32010-02-14 03:27:03 +00001837 err = neigh_sysctl_register(NULL, &nd_tbl.parms, "ipv6",
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001838 &ndisc_ifinfo_sysctl_change);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001839 if (err)
1840 goto out_unregister_pernet;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841#endif
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001842 err = register_netdevice_notifier(&ndisc_netdev_notifier);
1843 if (err)
1844 goto out_unregister_sysctl;
1845out:
1846 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001848out_unregister_sysctl:
1849#ifdef CONFIG_SYSCTL
1850 neigh_sysctl_unregister(&nd_tbl.parms);
1851out_unregister_pernet:
1852#endif
1853 unregister_pernet_subsys(&ndisc_net_ops);
1854 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855}
1856
1857void ndisc_cleanup(void)
1858{
Dmitry Mishin36f73d02006-11-03 16:08:19 -08001859 unregister_netdevice_notifier(&ndisc_netdev_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860#ifdef CONFIG_SYSCTL
1861 neigh_sysctl_unregister(&nd_tbl.parms);
1862#endif
1863 neigh_table_clear(&nd_tbl);
Daniel Lezcano1762f7e2008-03-07 11:15:34 -08001864 unregister_pernet_subsys(&ndisc_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865}