]> bbs.cooldavid.org Git - net-next-2.6.git/blame - net/ipv6/ndisc.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
net: replace %p6 with %pI6
[net-next-2.6.git] / net / ipv6 / ndisc.c
CommitLineData
1da177e4
LT		 1/*
2 * Neighbour Discovery for IPv6
1ab1457c 3 * Linux INET6 implementation
1da177e4
LT		 4 *
5 * Authors:
1ab1457c 6 * Pedro Roque <roque@di.fc.ul.pt>
1da177e4
LT		 7 * 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 *
31910575
PY		 18 * Pierre Ynard : export userland ND options
19 * through netlink (RDNSS support)
1da177e4
LT		 20 * Lars Fenneberg : fixed MTU setting on receipt
21 * of an RA.
1da177e4
LT		 22 * 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>
1da177e4
LT		 52#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
1823730f 66#include <linux/if_addr.h>
1da177e4
LT		 67#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
31910575
PY		 82#include <net/netlink.h>
83#include <linux/rtnetlink.h>
84
1da177e4
LT		 85#include <net/flow.h>
86#include <net/ip6_checksum.h>
1ed8516f 87#include <net/inet_common.h>
1da177e4
LT		 88#include <linux/proc_fs.h>
89
90#include <linux/netfilter.h>
91#include <linux/netfilter_ipv6.h>
92
1da177e4
LT		 93static 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 {
70ceb4f5
YH		 162 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
31910575
PY		 167 struct nd_opt_hdr *nd_useropts;
168 struct nd_opt_hdr *nd_useropts_end;
1da177e4
LT		 169};
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
31910575
PY		 233static 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
1da177e4
LT		 249static 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",
0dc47877 272 __func__,
1da177e4
LT		 273 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;
cfcabdcc 280 if (!ndopts->nd_opt_array[nd_opt->nd_opt_type])
1da177e4
LT		 281 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
282 break;
70ceb4f5
YH		 283#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
1da177e4 290 default:
31910575
PY		 291 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",
0dc47877 303 __func__,
31910575
PY		 304 nd_opt->nd_opt_type, nd_opt->nd_opt_len);
305 }
1da177e4
LT		 306 }
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:
a9e527e3 339 ipv6_ib_mc_map(addr, dev->broadcast, buf);
1da177e4
LT		 340 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
7159039a
YH		 350EXPORT_SYMBOL(ndisc_mc_map);
351
1da177e4
LT		 352static 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;
3b04ddde 385 if (!dev->header_ops) {
1da177e4
LT		 386 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 }
3b04ddde 402 if (dev->header_ops->cache)
1da177e4
LT		 403 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 */
e1ec7842
YH		 443static void __ndisc_send(struct net_device *dev,
444 struct neighbour *neigh,
9acd9f3a
YH		 445 const struct in6_addr *daddr,
446 const struct in6_addr *saddr,
447 struct icmp6hdr *icmp6h, const struct in6_addr *target,
14878f75 448 int llinfo)
1da177e4 449{
1da177e4 450 struct flowi fl;
e1ec7842 451 struct dst_entry *dst;
c346dca1 452 struct net *net = dev_net(dev);
1762f7e8 453 struct sock *sk = net->ipv6.ndisc_sk;
1ab1457c 454 struct sk_buff *skb;
e1ec7842
YH		 455 struct icmp6hdr *hdr;
456 struct inet6_dev *idev;
457 int len;
1da177e4 458 int err;
14878f75
DS		 459 u8 *opt, type;
460
461 type = icmp6h->icmp6_type;
1da177e4 462
1762f7e8 463 icmpv6_flow_init(sk, &fl, type, saddr, daddr, dev->ifindex);
1da177e4 464
3b00944c 465 dst = icmp6_dst_alloc(dev, neigh, daddr);
1da177e4
LT		 466 if (!dst)
467 return;
468
469 err = xfrm_lookup(&dst, &fl, NULL, 0);
e104411b 470 if (err < 0)
1da177e4 471 return;
1da177e4 472
e1ec7842
YH		 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);
1da177e4 479
d54a81d3
DM		 480 skb = sock_alloc_send_skb(sk,
481 (MAX_HEADER + sizeof(struct ipv6hdr) +
f5184d26 482 len + LL_ALLOCATED_SPACE(dev)),
1da177e4 483 1, &err);
e1ec7842 484 if (!skb) {
1da177e4 485 ND_PRINTK0(KERN_ERR
e1ec7842 486 "ICMPv6 ND: %s() failed to allocate an skb.\n",
0dc47877 487 __func__);
1da177e4
LT		 488 dst_release(dst);
489 return;
490 }
491
492 skb_reserve(skb, LL_RESERVED_SPACE(dev));
e1ec7842 493 ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);
1da177e4 494
27a884dc 495 skb->transport_header = skb->tail;
d10ba34b 496 skb_put(skb, len);
1da177e4 497
e1ec7842
YH		 498 hdr = (struct icmp6hdr *)skb_transport_header(skb);
499 memcpy(hdr, icmp6h, sizeof(*hdr));
1da177e4 500
e1ec7842
YH		 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 }
1da177e4 506
e1ec7842
YH		 507 if (llinfo)
508 ndisc_fill_addr_option(opt, llinfo, dev->dev_addr,
1da177e4
LT		 509 dev->addr_len, dev->type);
510
e1ec7842
YH		 511 hdr->icmp6_cksum = csum_ipv6_magic(saddr, daddr, len,
512 IPPROTO_ICMPV6,
513 csum_partial((__u8 *) hdr,
514 len, 0));
1da177e4
LT		 515
516 skb->dst = dst;
e1ec7842 517
1da177e4 518 idev = in6_dev_get(dst->dev);
3bd653c8 519 IP6_INC_STATS(net, idev, IPSTATS_MIB_OUTREQUESTS);
e1ec7842 520
6e23ae2a
PM		 521 err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev,
522 dst_output);
1da177e4 523 if (!err) {
5c5d244b 524 ICMP6MSGOUT_INC_STATS(net, idev, type);
a862f6a6 525 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
1da177e4
LT		 526 }
527
528 if (likely(idev != NULL))
529 in6_dev_put(idev);
1ab1457c 530}
1da177e4 531
e1ec7842 532static void ndisc_send_na(struct net_device *dev, struct neighbour *neigh,
9acd9f3a
YH		 533 const struct in6_addr *daddr,
534 const struct in6_addr *solicited_addr,
535 int router, int solicited, int override, int inc_opt)
e1ec7842
YH		 536{
537 struct in6_addr tmpaddr;
538 struct inet6_ifaddr *ifp;
9acd9f3a 539 const struct in6_addr *src_addr;
e1ec7842
YH		 540 struct icmp6hdr icmp6h = {
541 .icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT,
542 };
543
544 /* for anycast or proxy, solicited_addr != src_addr */
c346dca1 545 ifp = ipv6_get_ifaddr(dev_net(dev), solicited_addr, dev, 1);
e1ec7842
YH		 546 if (ifp) {
547 src_addr = solicited_addr;
548 if (ifp->flags & IFA_F_OPTIMISTIC)
549 override = 0;
550 in6_ifa_put(ifp);
551 } else {
191cd582 552 if (ipv6_dev_get_saddr(dev_net(dev), dev, daddr,
c346dca1 553 inet6_sk(dev_net(dev)->ipv6.ndisc_sk)->srcprefs,
7cbca67c 554 &tmpaddr))
e1ec7842
YH		 555 return;
556 src_addr = &tmpaddr;
557 }
558
559 icmp6h.icmp6_router = router;
560 icmp6h.icmp6_solicited = solicited;
561 icmp6h.icmp6_override = override;
562
563 __ndisc_send(dev, neigh, daddr, src_addr,
564 &icmp6h, solicited_addr,
14878f75 565 inc_opt ? ND_OPT_TARGET_LL_ADDR : 0);
e1ec7842
YH		 566}
567
1da177e4 568void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh,
9acd9f3a
YH		 569 const struct in6_addr *solicit,
570 const struct in6_addr *daddr, const struct in6_addr *saddr)
1da177e4 571{
1da177e4 572 struct in6_addr addr_buf;
e1ec7842
YH		 573 struct icmp6hdr icmp6h = {
574 .icmp6_type = NDISC_NEIGHBOUR_SOLICITATION,
575 };
1da177e4
LT		 576
577 if (saddr == NULL) {
95c385b4
NH		 578 if (ipv6_get_lladdr(dev, &addr_buf,
579 (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
1da177e4
LT		 580 return;
581 saddr = &addr_buf;
582 }
583
e1ec7842
YH		 584 __ndisc_send(dev, neigh, daddr, saddr,
585 &icmp6h, solicit,
14878f75 586 !ipv6_addr_any(saddr) ? ND_OPT_SOURCE_LL_ADDR : 0);
1da177e4
LT		 587}
588
9acd9f3a
YH		 589void ndisc_send_rs(struct net_device *dev, const struct in6_addr *saddr,
590 const struct in6_addr *daddr)
1da177e4 591{
e1ec7842
YH		 592 struct icmp6hdr icmp6h = {
593 .icmp6_type = NDISC_ROUTER_SOLICITATION,
594 };
95c385b4 595 int send_sllao = dev->addr_len;
95c385b4
NH		 596
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
bea85195 604 * suppress the inclusion of the sllao.
95c385b4
NH		 605 */
606 if (send_sllao) {
c346dca1 607 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev_net(dev), saddr,
1cab3da6 608 dev, 1);
95c385b4
NH		 609 if (ifp) {
610 if (ifp->flags & IFA_F_OPTIMISTIC) {
ca043569 611 send_sllao = 0;
95c385b4 612 }
ca043569 613 in6_ifa_put(ifp);
95c385b4
NH		 614 } else {
615 send_sllao = 0;
616 }
617 }
618#endif
e1ec7842
YH		 619 __ndisc_send(dev, NULL, daddr, saddr,
620 &icmp6h, NULL,
14878f75 621 send_sllao ? ND_OPT_SOURCE_LL_ADDR : 0);
1da177e4 622}
1ab1457c 623
1da177e4
LT		 624
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
c346dca1 645 if (skb && ipv6_chk_addr(dev_net(dev), &ipv6_hdr(skb)->saddr, dev, 1))
0660e03f 646 saddr = &ipv6_hdr(skb)->saddr;
1da177e4
LT		 647
648 if ((probes -= neigh->parms->ucast_probes) < 0) {
649 if (!(neigh->nud_state & NUD_VALID)) {
5b095d98 650 ND_PRINTK1(KERN_DEBUG "%s(): trying to ucast probe in NUD_INVALID: %pI6\n",
0c6ce78a 651 __func__, target);
1da177e4
LT		 652 }
653 ndisc_send_ns(dev, neigh, target, target, saddr);
654 } else if ((probes -= neigh->parms->app_probes) < 0) {
655#ifdef CONFIG_ARPD
656 neigh_app_ns(neigh);
657#endif
658 } else {
659 addrconf_addr_solict_mult(target, &mcaddr);
660 ndisc_send_ns(dev, NULL, target, &mcaddr, saddr);
661 }
662}
663
0736ffc0
YH		 664static int pndisc_is_router(const void *pkey,
665 struct net_device *dev)
fa86d322
PE		 666{
667 struct pneigh_entry *n;
0736ffc0 668 int ret = -1;
fa86d322
PE		 669
670 read_lock_bh(&nd_tbl.lock);
0736ffc0
YH		 671 n = __pneigh_lookup(&nd_tbl, dev_net(dev), pkey, dev);
672 if (n)
673 ret = !!(n->flags & NTF_ROUTER);
fa86d322
PE		 674 read_unlock_bh(&nd_tbl.lock);
675
0736ffc0 676 return ret;
fa86d322
PE		 677}
678
1da177e4
LT		 679static void ndisc_recv_ns(struct sk_buff *skb)
680{
9c70220b 681 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
0660e03f
ACM		 682 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
683 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
1da177e4 684 u8 *lladdr = NULL;
27a884dc
ACM		 685 u32 ndoptlen = skb->tail - (skb->transport_header +
686 offsetof(struct nd_msg, opt));
1da177e4
LT		 687 struct ndisc_options ndopts;
688 struct net_device *dev = skb->dev;
689 struct inet6_ifaddr *ifp;
690 struct inet6_dev *idev = NULL;
691 struct neighbour *neigh;
692 int dad = ipv6_addr_any(saddr);
693 int inc;
0736ffc0 694 int is_router = -1;
1da177e4
LT		 695
696 if (ipv6_addr_is_multicast(&msg->target)) {
1ab1457c 697 ND_PRINTK2(KERN_WARNING
1da177e4
LT		 698 "ICMPv6 NS: multicast target address");
699 return;
700 }
701
702 /*
703 * RFC2461 7.1.1:
704 * DAD has to be destined for solicited node multicast address.
705 */
706 if (dad &&
707 !(daddr->s6_addr32[0] == htonl(0xff020000) &&
708 daddr->s6_addr32[1] == htonl(0x00000000) &&
709 daddr->s6_addr32[2] == htonl(0x00000001) &&
710 daddr->s6_addr [12] == 0xff )) {
711 ND_PRINTK2(KERN_WARNING
712 "ICMPv6 NS: bad DAD packet (wrong destination)\n");
713 return;
714 }
715
716 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
1ab1457c 717 ND_PRINTK2(KERN_WARNING
1da177e4
LT		 718 "ICMPv6 NS: invalid ND options\n");
719 return;
720 }
721
722 if (ndopts.nd_opts_src_lladdr) {
723 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
724 if (!lladdr) {
725 ND_PRINTK2(KERN_WARNING
726 "ICMPv6 NS: invalid link-layer address length\n");
727 return;
728 }
729
730 /* RFC2461 7.1.1:
1ab1457c
YH		 731 * If the IP source address is the unspecified address,
732 * there MUST NOT be source link-layer address option
1da177e4
LT		 733 * in the message.
734 */
735 if (dad) {
1ab1457c 736 ND_PRINTK2(KERN_WARNING
1da177e4
LT		 737 "ICMPv6 NS: bad DAD packet (link-layer address option)\n");
738 return;
739 }
740 }
741
742 inc = ipv6_addr_is_multicast(daddr);
743
c346dca1 744 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
a18bc695 745 if (ifp) {
95c385b4
NH		 746
747 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
748 if (dad) {
749 if (dev->type == ARPHRD_IEEE802_TR) {
98e399f8
ACM		 750 const unsigned char *sadr;
751 sadr = skb_mac_header(skb);
95c385b4
NH		 752 if (((sadr[8] ^ dev->dev_addr[0]) & 0x7f) == 0 &&
753 sadr[9] == dev->dev_addr[1] &&
754 sadr[10] == dev->dev_addr[2] &&
755 sadr[11] == dev->dev_addr[3] &&
756 sadr[12] == dev->dev_addr[4] &&
757 sadr[13] == dev->dev_addr[5]) {
758 /* looped-back to us */
759 goto out;
760 }
761 }
762
763 /*
764 * We are colliding with another node
765 * who is doing DAD
766 * so fail our DAD process
767 */
768 addrconf_dad_failure(ifp);
9e3be4b3 769 return;
95c385b4
NH		 770 } else {
771 /*
772 * This is not a dad solicitation.
773 * If we are an optimistic node,
774 * we should respond.
775 * Otherwise, we should ignore it.
776 */
777 if (!(ifp->flags & IFA_F_OPTIMISTIC))
1da177e4 778 goto out;
1da177e4 779 }
1da177e4
LT		 780 }
781
782 idev = ifp->idev;
783 } else {
53b7997f
YH		 784 struct net *net = dev_net(dev);
785
1da177e4
LT		 786 idev = in6_dev_get(dev);
787 if (!idev) {
788 /* XXX: count this drop? */
789 return;
790 }
791
53b7997f 792 if (ipv6_chk_acast_addr(net, dev, &msg->target) ||
1ab1457c 793 (idev->cnf.forwarding &&
53b7997f 794 (net->ipv6.devconf_all->proxy_ndp || idev->cnf.proxy_ndp) &&
0736ffc0 795 (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) {
a61bbcf2 796 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
1da177e4
LT		 797 skb->pkt_type != PACKET_HOST &&
798 inc != 0 &&
799 idev->nd_parms->proxy_delay != 0) {
800 /*
801 * for anycast or proxy,
1ab1457c
YH		 802 * sender should delay its response
803 * by a random time between 0 and
1da177e4
LT		 804 * MAX_ANYCAST_DELAY_TIME seconds.
805 * (RFC2461) -- yoshfuji
806 */
807 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
808 if (n)
809 pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
810 goto out;
811 }
812 } else
813 goto out;
814 }
815
0736ffc0
YH		 816 if (is_router < 0)
817 is_router = !!idev->cnf.forwarding;
62dd9318 818
1da177e4 819 if (dad) {
f3ee4010 820 ndisc_send_na(dev, NULL, &in6addr_linklocal_allnodes, &msg->target,
62dd9318 821 is_router, 0, (ifp != NULL), 1);
1da177e4
LT		 822 goto out;
823 }
824
825 if (inc)
826 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
827 else
828 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
829
1ab1457c 830 /*
1da177e4
LT		 831 * update / create cache entry
832 * for the source address
833 */
834 neigh = __neigh_lookup(&nd_tbl, saddr, dev,
835 !inc || lladdr || !dev->addr_len);
836 if (neigh)
1ab1457c 837 neigh_update(neigh, lladdr, NUD_STALE,
1da177e4
LT		 838 NEIGH_UPDATE_F_WEAK_OVERRIDE|
839 NEIGH_UPDATE_F_OVERRIDE);
3b04ddde 840 if (neigh || !dev->header_ops) {
1da177e4 841 ndisc_send_na(dev, neigh, saddr, &msg->target,
62dd9318 842 is_router,
1da177e4
LT		 843 1, (ifp != NULL && inc), inc);
844 if (neigh)
845 neigh_release(neigh);
846 }
847
848out:
849 if (ifp)
850 in6_ifa_put(ifp);
851 else
852 in6_dev_put(idev);
853
854 return;
855}
856
857static void ndisc_recv_na(struct sk_buff *skb)
858{
9c70220b 859 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
0660e03f
ACM		 860 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
861 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
1da177e4 862 u8 *lladdr = NULL;
27a884dc
ACM		 863 u32 ndoptlen = skb->tail - (skb->transport_header +
864 offsetof(struct nd_msg, opt));
1da177e4
LT		 865 struct ndisc_options ndopts;
866 struct net_device *dev = skb->dev;
867 struct inet6_ifaddr *ifp;
868 struct neighbour *neigh;
869
870 if (skb->len < sizeof(struct nd_msg)) {
871 ND_PRINTK2(KERN_WARNING
872 "ICMPv6 NA: packet too short\n");
873 return;
874 }
875
876 if (ipv6_addr_is_multicast(&msg->target)) {
877 ND_PRINTK2(KERN_WARNING
878 "ICMPv6 NA: target address is multicast.\n");
879 return;
880 }
881
882 if (ipv6_addr_is_multicast(daddr) &&
883 msg->icmph.icmp6_solicited) {
884 ND_PRINTK2(KERN_WARNING
885 "ICMPv6 NA: solicited NA is multicasted.\n");
886 return;
887 }
1ab1457c 888
1da177e4
LT		 889 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
890 ND_PRINTK2(KERN_WARNING
891 "ICMPv6 NS: invalid ND option\n");
892 return;
893 }
894 if (ndopts.nd_opts_tgt_lladdr) {
895 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
896 if (!lladdr) {
897 ND_PRINTK2(KERN_WARNING
898 "ICMPv6 NA: invalid link-layer address length\n");
899 return;
900 }
901 }
c346dca1 902 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
a18bc695 903 if (ifp) {
1da177e4
LT		 904 if (ifp->flags & IFA_F_TENTATIVE) {
905 addrconf_dad_failure(ifp);
906 return;
907 }
908 /* What should we make now? The advertisement
909 is invalid, but ndisc specs say nothing
910 about it. It could be misconfiguration, or
911 an smart proxy agent tries to help us :-)
912 */
913 ND_PRINTK1(KERN_WARNING
914 "ICMPv6 NA: someone advertises our address on %s!\n",
915 ifp->idev->dev->name);
916 in6_ifa_put(ifp);
917 return;
918 }
919 neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
920
921 if (neigh) {
922 u8 old_flags = neigh->flags;
53b7997f 923 struct net *net = dev_net(dev);
1da177e4
LT		 924
925 if (neigh->nud_state & NUD_FAILED)
926 goto out;
927
5f3e6e9e
VN		 928 /*
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) &&
53b7997f
YH		 934 net->ipv6.devconf_all->forwarding && net->ipv6.devconf_all->proxy_ndp &&
935 pneigh_lookup(&nd_tbl, net, &msg->target, dev, 0)) {
fbea49e1 936 /* XXX: idev->cnf.prixy_ndp */
5f3e6e9e 937 goto out;
fbea49e1 938 }
5f3e6e9e 939
1da177e4
LT		 940 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)
e0a1ad73 954 ip6_del_rt(rt);
1da177e4
LT		 955 }
956
957out:
958 neigh_release(neigh);
959 }
960}
961
962static void ndisc_recv_rs(struct sk_buff *skb)
963{
9c70220b 964 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
1da177e4
LT		 965 unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
966 struct neighbour *neigh;
967 struct inet6_dev *idev;
0660e03f 968 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
1da177e4
LT		 969 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
31910575
PY		 1019static 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;
c346dca1 1025 struct net *net = dev_net(ra->dev);
31910575
PY		 1026 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;
dbb2ed24 1044 ndmsg->nduseropt_ifindex = ra->dev->ifindex;
31910575
PY		 1045 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
a18bc695 1055 err = rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL,
97c53cac 1056 GFP_ATOMIC);
31910575
PY		 1057 if (err < 0)
1058 goto errout;
1059
1060 return;
1061
1062nla_put_failure:
1063 nlmsg_free(skb);
1064 err = -EMSGSIZE;
1065errout:
a18bc695 1066 rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err);
31910575
PY		 1067}
1068
1da177e4
LT		 1069static void ndisc_router_discovery(struct sk_buff *skb)
1070{
9c70220b 1071 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
1da177e4
LT		 1072 struct neighbour *neigh = NULL;
1073 struct inet6_dev *in6_dev;
65f5c7c1 1074 struct rt6_info *rt = NULL;
1da177e4
LT		 1075 int lifetime;
1076 struct ndisc_options ndopts;
1077 int optlen;
ebacaaa0 1078 unsigned int pref = 0;
1da177e4
LT		 1079
1080 __u8 * opt = (__u8 *)(ra_msg + 1);
1081
27a884dc 1082 optlen = (skb->tail - skb->transport_header) - sizeof(struct ra_msg);
1da177e4 1083
0660e03f 1084 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1da177e4
LT		 1085 ND_PRINTK2(KERN_WARNING
1086 "ICMPv6 RA: source address is not link-local.\n");
1087 return;
1088 }
1089 if (optlen < 0) {
1ab1457c 1090 ND_PRINTK2(KERN_WARNING
1da177e4
LT		 1091 "ICMPv6 RA: packet too short\n");
1092 return;
1093 }
1094
de357cc0 1095#ifdef CONFIG_IPV6_NDISC_NODETYPE
fadf6bf0
TF		 1096 if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) {
1097 ND_PRINTK2(KERN_WARNING
1098 "ICMPv6 RA: from host or unauthorized router\n");
1099 return;
1100 }
de357cc0 1101#endif
fadf6bf0 1102
1da177e4
LT		 1103 /*
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
de357cc0 1126#ifdef CONFIG_IPV6_NDISC_NODETYPE
fadf6bf0
TF		 1127 /* skip link-specific parameters from interior routers */
1128 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1129 goto skip_linkparms;
de357cc0 1130#endif
fadf6bf0 1131
1da177e4
LT		 1132 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
65f5c7c1
YH		 1151 if (!in6_dev->cnf.accept_ra_defrtr)
1152 goto skip_defrtr;
1153
1da177e4
LT		 1154 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1155
ebacaaa0
YH		 1156#ifdef CONFIG_IPV6_ROUTER_PREF
1157 pref = ra_msg->icmph.icmp6_router_pref;
1158 /* 10b is handled as if it were 00b (medium) */
930d6ff2 1159 if (pref == ICMPV6_ROUTER_PREF_INVALID ||
6d5b78cd 1160 !in6_dev->cnf.accept_ra_rtr_pref)
ebacaaa0
YH		 1161 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1162#endif
1163
0660e03f 1164 rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
1da177e4
LT		 1165
1166 if (rt)
1167 neigh = rt->rt6i_nexthop;
1168
1169 if (rt && lifetime == 0) {
1170 neigh_clone(neigh);
e0a1ad73 1171 ip6_del_rt(rt);
1da177e4
LT		 1172 rt = NULL;
1173 }
1174
1175 if (rt == NULL && lifetime) {
1176 ND_PRINTK3(KERN_DEBUG
1177 "ICMPv6 RA: adding default router.\n");
1178
0660e03f 1179 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
1da177e4
LT		 1180 if (rt == NULL) {
1181 ND_PRINTK0(KERN_ERR
1182 "ICMPv6 RA: %s() failed to add default route.\n",
0dc47877 1183 __func__);
1da177e4
LT		 1184 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",
0dc47877 1192 __func__);
1da177e4
LT		 1193 dst_release(&rt->u.dst);
1194 in6_dev_put(in6_dev);
1195 return;
1196 }
1197 neigh->flags |= NTF_ROUTER;
ebacaaa0 1198 } else if (rt) {
22441cfa 1199 rt->rt6i_flags = (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
1da177e4
LT		 1200 }
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
65f5c7c1
YH		 1211skip_defrtr:
1212
1da177e4
LT		 1213 /*
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
de357cc0 1246#ifdef CONFIG_IPV6_NDISC_NODETYPE
fadf6bf0 1247skip_linkparms:
de357cc0 1248#endif
fadf6bf0 1249
1da177e4
LT		 1250 /*
1251 * Process options.
1252 */
1253
1254 if (!neigh)
0660e03f 1255 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
1da177e4
LT		 1256 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
70ceb4f5 1275#ifdef CONFIG_IPV6_ROUTE_INFO
09c884d4 1276 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
70ceb4f5
YH		 1277 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)) {
6294e000
YH		 1281 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)
09c884d4 1288 continue;
70ceb4f5 1289 rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3,
0660e03f 1290 &ipv6_hdr(skb)->saddr);
70ceb4f5
YH		 1291 }
1292 }
1293#endif
1294
de357cc0 1295#ifdef CONFIG_IPV6_NDISC_NODETYPE
fadf6bf0
TF		 1296 /* skip link-specific ndopts from interior routers */
1297 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1298 goto out;
de357cc0 1299#endif
fadf6bf0 1300
c4fd30eb 1301 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
1da177e4
LT		 1302 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) {
e69a4adc 1311 __be32 n;
1da177e4
LT		 1312 u32 mtu;
1313
e69a4adc
AV		 1314 memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1315 mtu = ntohl(n);
1da177e4
LT		 1316
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 }
1ab1457c 1330
31910575 1331 if (ndopts.nd_useropts) {
61cf46ad
YH		 1332 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);
31910575
PY		 1337 }
1338 }
1339
1da177e4
LT		 1340 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
de357cc0 1364#ifdef CONFIG_IPV6_NDISC_NODETYPE
fadf6bf0
TF		 1365 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 }
de357cc0 1372#endif
fadf6bf0 1373
0660e03f 1374 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1da177e4
LT		 1375 ND_PRINTK2(KERN_WARNING
1376 "ICMPv6 Redirect: source address is not link-local.\n");
1377 return;
1378 }
1379
27a884dc 1380 optlen = skb->tail - skb->transport_header;
1da177e4
LT		 1381 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
cc70ab26 1389 icmph = icmp6_hdr(skb);
1da177e4
LT		 1390 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;
bf0b48df
BH		 1401 } else if (ipv6_addr_type(target) !=
1402 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1ab1457c 1403 ND_PRINTK2(KERN_WARNING
bf0b48df 1404 "ICMPv6 Redirect: target address is not link-local unicast.\n");
1da177e4
LT		 1405 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
1ab1457c 1416 /* RFC2461 8.1:
1da177e4
LT		 1417 * 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 */
1ab1457c 1420
1da177e4
LT		 1421 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) {
0660e03f
ACM		 1440 rt6_redirect(dest, &ipv6_hdr(skb)->daddr,
1441 &ipv6_hdr(skb)->saddr, neigh, lladdr,
1da177e4
LT		 1442 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,
9acd9f3a 1449 const struct in6_addr *target)
1da177e4 1450{
1762f7e8 1451 struct net_device *dev = skb->dev;
c346dca1 1452 struct net *net = dev_net(dev);
1762f7e8 1453 struct sock *sk = net->ipv6.ndisc_sk;
1da177e4
LT		 1454 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;
1da177e4
LT		 1459 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;
1da177e4
LT		 1466 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1467
95c385b4 1468 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
1da177e4
LT		 1469 ND_PRINTK2(KERN_WARNING
1470 "ICMPv6 Redirect: no link-local address on %s\n",
1471 dev->name);
1ab1457c
YH		 1472 return;
1473 }
1da177e4 1474
0660e03f 1475 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
bf0b48df 1476 ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
29556526 1477 ND_PRINTK2(KERN_WARNING
bf0b48df 1478 "ICMPv6 Redirect: target address is not link-local unicast.\n");
29556526
LY		 1479 return;
1480 }
1481
1762f7e8 1482 icmpv6_flow_init(sk, &fl, NDISC_REDIRECT,
95e41e93 1483 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex);
1da177e4 1484
1762f7e8 1485 dst = ip6_route_output(net, NULL, &fl);
1da177e4
LT		 1486 if (dst == NULL)
1487 return;
1488
1489 err = xfrm_lookup(&dst, &fl, NULL, 0);
e104411b 1490 if (err)
1da177e4 1491 return;
1da177e4
LT		 1492
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
d54a81d3
DM		 1522 buff = sock_alloc_send_skb(sk,
1523 (MAX_HEADER + sizeof(struct ipv6hdr) +
f5184d26 1524 len + LL_ALLOCATED_SPACE(dev)),
1da177e4
LT		 1525 1, &err);
1526 if (buff == NULL) {
1527 ND_PRINTK0(KERN_ERR
1528 "ICMPv6 Redirect: %s() failed to allocate an skb.\n",
0dc47877 1529 __func__);
1da177e4
LT		 1530 dst_release(dst);
1531 return;
1532 }
1533
1da177e4 1534 skb_reserve(buff, LL_RESERVED_SPACE(dev));
0660e03f 1535 ip6_nd_hdr(sk, buff, dev, &saddr_buf, &ipv6_hdr(skb)->saddr,
1da177e4
LT		 1536 IPPROTO_ICMPV6, len);
1537
27a884dc 1538 skb_set_transport_header(buff, skb_tail_pointer(buff) - buff->data);
d10ba34b
ACM		 1539 skb_put(buff, len);
1540 icmph = icmp6_hdr(buff);
1da177e4
LT		 1541
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++;
0660e03f 1552 ipv6_addr_copy(addrp, &ipv6_hdr(skb)->daddr);
1da177e4
LT		 1553
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
1ab1457c 1568 memset(opt, 0, 8);
1da177e4
LT		 1569 *(opt++) = ND_OPT_REDIRECT_HDR;
1570 *(opt++) = (rd_len >> 3);
1571 opt += 6;
1572
0660e03f 1573 memcpy(opt, ipv6_hdr(skb), rd_len - 8);
1da177e4 1574
0660e03f 1575 icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &ipv6_hdr(skb)->saddr,
1da177e4
LT		 1576 len, IPPROTO_ICMPV6,
1577 csum_partial((u8 *) icmph, len, 0));
1578
1579 buff->dst = dst;
1580 idev = in6_dev_get(dst->dev);
3bd653c8 1581 IP6_INC_STATS(net, idev, IPSTATS_MIB_OUTREQUESTS);
6e23ae2a
PM		 1582 err = NF_HOOK(PF_INET6, NF_INET_LOCAL_OUT, buff, NULL, dst->dev,
1583 dst_output);
1da177e4 1584 if (!err) {
5c5d244b 1585 ICMP6MSGOUT_INC_STATS(net, idev, NDISC_REDIRECT);
a862f6a6 1586 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
1da177e4
LT		 1587 }
1588
1589 if (likely(idev != NULL))
1590 in6_dev_put(idev);
1591}
1592
1593static void pndisc_redo(struct sk_buff *skb)
1594{
140e26fc 1595 ndisc_recv_ns(skb);
1da177e4
LT		 1596 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
9c70220b 1606 msg = (struct nd_msg *)skb_transport_header(skb);
1da177e4 1607
9c70220b 1608 __skb_push(skb, skb->data - skb_transport_header(skb));
1da177e4 1609
0660e03f 1610 if (ipv6_hdr(skb)->hop_limit != 255) {
1da177e4
LT		 1611 ND_PRINTK2(KERN_WARNING
1612 "ICMPv6 NDISC: invalid hop-limit: %d\n",
0660e03f 1613 ipv6_hdr(skb)->hop_limit);
1da177e4
LT		 1614 return 0;
1615 }
1616
1617 if (msg->icmph.icmp6_code != 0) {
1ab1457c 1618 ND_PRINTK2(KERN_WARNING
1da177e4
LT		 1619 "ICMPv6 NDISC: invalid ICMPv6 code: %d\n",
1620 msg->icmph.icmp6_code);
1621 return 0;
1622 }
1623
a61bbcf2
PM		 1624 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1625
1da177e4
LT		 1626 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;
3ff50b79 1646 }
1da177e4
LT		 1647
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;
c346dca1 1654 struct net *net = dev_net(dev);
1da177e4
LT		 1655
1656 switch (event) {
1657 case NETDEV_CHANGEADDR:
1658 neigh_changeaddr(&nd_tbl, dev);
5b7c931d 1659 fib6_run_gc(~0UL, net);
1da177e4
LT		 1660 break;
1661 case NETDEV_DOWN:
1662 neigh_ifdown(&nd_tbl, dev);
5b7c931d 1663 fib6_run_gc(~0UL, net);
1da177e4
LT		 1664 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
d12af679
EB		 1702 if ((strcmp(ctl->procname, "retrans_time") == 0) ||
1703 (strcmp(ctl->procname, "base_reachable_time") == 0))
1da177e4
LT		 1704 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1705
d12af679 1706 if (strcmp(ctl->procname, "retrans_time") == 0)
1da177e4 1707 ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
d12af679
EB		 1708
1709 else if (strcmp(ctl->procname, "base_reachable_time") == 0)
1da177e4
LT		 1710 ret = proc_dointvec_jiffies(ctl, write,
1711 filp, buffer, lenp, ppos);
d12af679
EB		 1712
1713 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
ad02ac14 1714 (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
1da177e4
LT		 1715 ret = proc_dointvec_ms_jiffies(ctl, write,
1716 filp, buffer, lenp, ppos);
d12af679 1717 else
1da177e4 1718 ret = -1;
1da177e4
LT		 1719
1720 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
d12af679 1721 if (ctl->data == &idev->nd_parms->base_reachable_time)
1da177e4
LT		 1722 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
f221e726
AD		 1730int ndisc_ifinfo_sysctl_strategy(ctl_table *ctl,
1731 void __user *oldval, size_t __user *oldlenp,
0686caa3 1732 void __user *newval, size_t newlen)
1da177e4
LT		 1733{
1734 struct net_device *dev = ctl->extra1;
1735 struct inet6_dev *idev;
1736 int ret;
1737
1738 if (ctl->ctl_name == NET_NEIGH_RETRANS_TIME ||
1739 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME)
1740 ndisc_warn_deprecated_sysctl(ctl, "procfs", dev ? dev->name : "default");
1741
1742 switch (ctl->ctl_name) {
1743 case NET_NEIGH_REACHABLE_TIME:
f221e726 1744 ret = sysctl_jiffies(ctl, oldval, oldlenp, newval, newlen);
1da177e4
LT		 1745 break;
1746 case NET_NEIGH_RETRANS_TIME_MS:
1747 case NET_NEIGH_REACHABLE_TIME_MS:
f221e726 1748 ret = sysctl_ms_jiffies(ctl, oldval, oldlenp, newval, newlen);
1da177e4
LT		 1749 break;
1750 default:
1751 ret = 0;
1752 }
1753
1754 if (newval && newlen && ret > 0 &&
1755 dev && (idev = in6_dev_get(dev)) != NULL) {
1756 if (ctl->ctl_name == NET_NEIGH_REACHABLE_TIME ||
1757 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME_MS)
1758 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1759 idev->tstamp = jiffies;
1760 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1761 in6_dev_put(idev);
1762 }
1763
1764 return ret;
1765}
1766
1767#endif
1768
1762f7e8 1769static int ndisc_net_init(struct net *net)
1da177e4
LT		 1770{
1771 struct ipv6_pinfo *np;
1772 struct sock *sk;
1ab1457c 1773 int err;
1da177e4 1774
1ed8516f
DL		 1775 err = inet_ctl_sock_create(&sk, PF_INET6,
1776 SOCK_RAW, IPPROTO_ICMPV6, net);
1da177e4
LT		 1777 if (err < 0) {
1778 ND_PRINTK0(KERN_ERR
1ab1457c 1779 "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",
1da177e4 1780 err);
1da177e4
LT		 1781 return err;
1782 }
1783
1ed8516f 1784 net->ipv6.ndisc_sk = sk;
1762f7e8 1785
1da177e4 1786 np = inet6_sk(sk);
1da177e4
LT		 1787 np->hop_limit = 255;
1788 /* Do not loopback ndisc messages */
1789 np->mc_loop = 0;
1da177e4 1790
1762f7e8
DL		 1791 return 0;
1792}
1793
1794static void ndisc_net_exit(struct net *net)
1795{
1ed8516f 1796 inet_ctl_sock_destroy(net->ipv6.ndisc_sk);
1762f7e8
DL		 1797}
1798
1799static struct pernet_operations ndisc_net_ops = {
1800 .init = ndisc_net_init,
1801 .exit = ndisc_net_exit,
1802};
1803
1804int __init ndisc_init(void)
1805{
1806 int err;
1807
1808 err = register_pernet_subsys(&ndisc_net_ops);
1809 if (err)
1810 return err;
1ab1457c
YH		 1811 /*
1812 * Initialize the neighbour table
1813 */
1da177e4
LT		 1814 neigh_table_init(&nd_tbl);
1815
1816#ifdef CONFIG_SYSCTL
1762f7e8
DL		 1817 err = neigh_sysctl_register(NULL, &nd_tbl.parms, NET_IPV6,
1818 NET_IPV6_NEIGH, "ipv6",
1819 &ndisc_ifinfo_sysctl_change,
1820 &ndisc_ifinfo_sysctl_strategy);
1821 if (err)
1822 goto out_unregister_pernet;
1da177e4 1823#endif
1762f7e8
DL		 1824 err = register_netdevice_notifier(&ndisc_netdev_notifier);
1825 if (err)
1826 goto out_unregister_sysctl;
1827out:
1828 return err;
1da177e4 1829
1762f7e8
DL		 1830out_unregister_sysctl:
1831#ifdef CONFIG_SYSCTL
1832 neigh_sysctl_unregister(&nd_tbl.parms);
1833out_unregister_pernet:
1834#endif
1835 unregister_pernet_subsys(&ndisc_net_ops);
1836 goto out;
1da177e4
LT		 1837}
1838
1839void ndisc_cleanup(void)
1840{
36f73d0c 1841 unregister_netdevice_notifier(&ndisc_netdev_notifier);
1da177e4
LT		 1842#ifdef CONFIG_SYSCTL
1843 neigh_sysctl_unregister(&nd_tbl.parms);
1844#endif
1845 neigh_table_clear(&nd_tbl);
1762f7e8 1846 unregister_pernet_subsys(&ndisc_net_ops);
1da177e4 1847}
Clone of davem's net-next-2.6 tree