]> 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: return operator cleanup
[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>
5a0e3ad6 62#include <linux/slab.h>
1da177e4
LT		 63#ifdef CONFIG_SYSCTL
64#include <linux/sysctl.h>
65#endif
66
1823730f 67#include <linux/if_addr.h>
1da177e4
LT		 68#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
31910575
PY		 83#include <net/netlink.h>
84#include <linux/rtnetlink.h>
85
1da177e4
LT		 86#include <net/flow.h>
87#include <net/ip6_checksum.h>
1ed8516f 88#include <net/inet_common.h>
1da177e4
LT		 89#include <linux/proc_fs.h>
90
91#include <linux/netfilter.h>
92#include <linux/netfilter_ipv6.h>
93
1da177e4
LT		 94static u32 ndisc_hash(const void *pkey, const struct net_device *dev);
95static int ndisc_constructor(struct neighbour *neigh);
96static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb);
97static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb);
98static int pndisc_constructor(struct pneigh_entry *n);
99static void pndisc_destructor(struct pneigh_entry *n);
100static void pndisc_redo(struct sk_buff *skb);
101
89d69d2b 102static const struct neigh_ops ndisc_generic_ops = {
1da177e4
LT		 103 .family = AF_INET6,
104 .solicit = ndisc_solicit,
105 .error_report = ndisc_error_report,
106 .output = neigh_resolve_output,
107 .connected_output = neigh_connected_output,
108 .hh_output = dev_queue_xmit,
109 .queue_xmit = dev_queue_xmit,
110};
111
89d69d2b 112static const struct neigh_ops ndisc_hh_ops = {
1da177e4
LT		 113 .family = AF_INET6,
114 .solicit = ndisc_solicit,
115 .error_report = ndisc_error_report,
116 .output = neigh_resolve_output,
117 .connected_output = neigh_resolve_output,
118 .hh_output = dev_queue_xmit,
119 .queue_xmit = dev_queue_xmit,
120};
121
122
89d69d2b 123static const struct neigh_ops ndisc_direct_ops = {
1da177e4
LT		 124 .family = AF_INET6,
125 .output = dev_queue_xmit,
126 .connected_output = dev_queue_xmit,
127 .hh_output = dev_queue_xmit,
128 .queue_xmit = dev_queue_xmit,
129};
130
131struct neigh_table nd_tbl = {
132 .family = AF_INET6,
133 .entry_size = sizeof(struct neighbour) + sizeof(struct in6_addr),
134 .key_len = sizeof(struct in6_addr),
135 .hash = ndisc_hash,
136 .constructor = ndisc_constructor,
137 .pconstructor = pndisc_constructor,
138 .pdestructor = pndisc_destructor,
139 .proxy_redo = pndisc_redo,
140 .id = "ndisc_cache",
141 .parms = {
142 .tbl = &nd_tbl,
143 .base_reachable_time = 30 * HZ,
144 .retrans_time = 1 * HZ,
145 .gc_staletime = 60 * HZ,
146 .reachable_time = 30 * HZ,
147 .delay_probe_time = 5 * HZ,
148 .queue_len = 3,
149 .ucast_probes = 3,
150 .mcast_probes = 3,
151 .anycast_delay = 1 * HZ,
152 .proxy_delay = (8 * HZ) / 10,
153 .proxy_qlen = 64,
154 },
155 .gc_interval = 30 * HZ,
156 .gc_thresh1 = 128,
157 .gc_thresh2 = 512,
158 .gc_thresh3 = 1024,
159};
160
161/* ND options */
162struct ndisc_options {
70ceb4f5
YH		 163 struct nd_opt_hdr *nd_opt_array[__ND_OPT_ARRAY_MAX];
164#ifdef CONFIG_IPV6_ROUTE_INFO
165 struct nd_opt_hdr *nd_opts_ri;
166 struct nd_opt_hdr *nd_opts_ri_end;
167#endif
31910575
PY		 168 struct nd_opt_hdr *nd_useropts;
169 struct nd_opt_hdr *nd_useropts_end;
1da177e4
LT		 170};
171
172#define nd_opts_src_lladdr nd_opt_array[ND_OPT_SOURCE_LL_ADDR]
173#define nd_opts_tgt_lladdr nd_opt_array[ND_OPT_TARGET_LL_ADDR]
174#define nd_opts_pi nd_opt_array[ND_OPT_PREFIX_INFO]
175#define nd_opts_pi_end nd_opt_array[__ND_OPT_PREFIX_INFO_END]
176#define nd_opts_rh nd_opt_array[ND_OPT_REDIRECT_HDR]
177#define nd_opts_mtu nd_opt_array[ND_OPT_MTU]
178
179#define NDISC_OPT_SPACE(len) (((len)+2+7)&~7)
180
181/*
182 * Return the padding between the option length and the start of the
183 * link addr. Currently only IP-over-InfiniBand needs this, although
184 * if RFC 3831 IPv6-over-Fibre Channel is ever implemented it may
185 * also need a pad of 2.
186 */
187static int ndisc_addr_option_pad(unsigned short type)
188{
189 switch (type) {
190 case ARPHRD_INFINIBAND: return 2;
191 default: return 0;
192 }
193}
194
195static inline int ndisc_opt_addr_space(struct net_device *dev)
196{
197 return NDISC_OPT_SPACE(dev->addr_len + ndisc_addr_option_pad(dev->type));
198}
199
200static u8 *ndisc_fill_addr_option(u8 *opt, int type, void *data, int data_len,
201 unsigned short addr_type)
202{
203 int space = NDISC_OPT_SPACE(data_len);
204 int pad = ndisc_addr_option_pad(addr_type);
205
206 opt[0] = type;
207 opt[1] = space>>3;
208
209 memset(opt + 2, 0, pad);
210 opt += pad;
211 space -= pad;
212
213 memcpy(opt+2, data, data_len);
214 data_len += 2;
215 opt += data_len;
216 if ((space -= data_len) > 0)
217 memset(opt, 0, space);
218 return opt + space;
219}
220
221static struct nd_opt_hdr *ndisc_next_option(struct nd_opt_hdr *cur,
222 struct nd_opt_hdr *end)
223{
224 int type;
225 if (!cur || !end || cur >= end)
226 return NULL;
227 type = cur->nd_opt_type;
228 do {
229 cur = ((void *)cur) + (cur->nd_opt_len << 3);
230 } while(cur < end && cur->nd_opt_type != type);
a02cec21 231 return cur <= end && cur->nd_opt_type == type ? cur : NULL;
1da177e4
LT		 232}
233
31910575
PY		 234static inline int ndisc_is_useropt(struct nd_opt_hdr *opt)
235{
a02cec21 236 return opt->nd_opt_type == ND_OPT_RDNSS;
31910575
PY		 237}
238
239static struct nd_opt_hdr *ndisc_next_useropt(struct nd_opt_hdr *cur,
240 struct nd_opt_hdr *end)
241{
242 if (!cur || !end || cur >= end)
243 return NULL;
244 do {
245 cur = ((void *)cur) + (cur->nd_opt_len << 3);
246 } while(cur < end && !ndisc_is_useropt(cur));
a02cec21 247 return cur <= end && ndisc_is_useropt(cur) ? cur : NULL;
31910575
PY		 248}
249
1da177e4
LT		 250static struct ndisc_options *ndisc_parse_options(u8 *opt, int opt_len,
251 struct ndisc_options *ndopts)
252{
253 struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)opt;
254
255 if (!nd_opt || opt_len < 0 || !ndopts)
256 return NULL;
257 memset(ndopts, 0, sizeof(*ndopts));
258 while (opt_len) {
259 int l;
260 if (opt_len < sizeof(struct nd_opt_hdr))
261 return NULL;
262 l = nd_opt->nd_opt_len << 3;
263 if (opt_len < l || l == 0)
264 return NULL;
265 switch (nd_opt->nd_opt_type) {
266 case ND_OPT_SOURCE_LL_ADDR:
267 case ND_OPT_TARGET_LL_ADDR:
268 case ND_OPT_MTU:
269 case ND_OPT_REDIRECT_HDR:
270 if (ndopts->nd_opt_array[nd_opt->nd_opt_type]) {
271 ND_PRINTK2(KERN_WARNING
272 "%s(): duplicated ND6 option found: type=%d\n",
0dc47877 273 __func__,
1da177e4
LT		 274 nd_opt->nd_opt_type);
275 } else {
276 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
277 }
278 break;
279 case ND_OPT_PREFIX_INFO:
280 ndopts->nd_opts_pi_end = nd_opt;
cfcabdcc 281 if (!ndopts->nd_opt_array[nd_opt->nd_opt_type])
1da177e4
LT		 282 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
283 break;
70ceb4f5
YH		 284#ifdef CONFIG_IPV6_ROUTE_INFO
285 case ND_OPT_ROUTE_INFO:
286 ndopts->nd_opts_ri_end = nd_opt;
287 if (!ndopts->nd_opts_ri)
288 ndopts->nd_opts_ri = nd_opt;
289 break;
290#endif
1da177e4 291 default:
31910575
PY		 292 if (ndisc_is_useropt(nd_opt)) {
293 ndopts->nd_useropts_end = nd_opt;
294 if (!ndopts->nd_useropts)
295 ndopts->nd_useropts = nd_opt;
296 } else {
297 /*
298 * Unknown options must be silently ignored,
299 * to accommodate future extension to the
300 * protocol.
301 */
302 ND_PRINTK2(KERN_NOTICE
303 "%s(): ignored unsupported option; type=%d, len=%d\n",
0dc47877 304 __func__,
31910575
PY		 305 nd_opt->nd_opt_type, nd_opt->nd_opt_len);
306 }
1da177e4
LT		 307 }
308 opt_len -= l;
309 nd_opt = ((void *)nd_opt) + l;
310 }
311 return ndopts;
312}
313
314static inline u8 *ndisc_opt_addr_data(struct nd_opt_hdr *p,
315 struct net_device *dev)
316{
317 u8 *lladdr = (u8 *)(p + 1);
318 int lladdrlen = p->nd_opt_len << 3;
319 int prepad = ndisc_addr_option_pad(dev->type);
320 if (lladdrlen != NDISC_OPT_SPACE(dev->addr_len + prepad))
321 return NULL;
a02cec21 322 return lladdr + prepad;
1da177e4
LT		 323}
324
325int ndisc_mc_map(struct in6_addr *addr, char *buf, struct net_device *dev, int dir)
326{
327 switch (dev->type) {
328 case ARPHRD_ETHER:
329 case ARPHRD_IEEE802: /* Not sure. Check it later. --ANK */
330 case ARPHRD_FDDI:
331 ipv6_eth_mc_map(addr, buf);
332 return 0;
333 case ARPHRD_IEEE802_TR:
334 ipv6_tr_mc_map(addr,buf);
335 return 0;
336 case ARPHRD_ARCNET:
337 ipv6_arcnet_mc_map(addr, buf);
338 return 0;
339 case ARPHRD_INFINIBAND:
a9e527e3 340 ipv6_ib_mc_map(addr, dev->broadcast, buf);
1da177e4
LT		 341 return 0;
342 default:
343 if (dir) {
344 memcpy(buf, dev->broadcast, dev->addr_len);
345 return 0;
346 }
347 }
348 return -EINVAL;
349}
350
7159039a
YH		 351EXPORT_SYMBOL(ndisc_mc_map);
352
1da177e4
LT		 353static u32 ndisc_hash(const void *pkey, const struct net_device *dev)
354{
355 const u32 *p32 = pkey;
356 u32 addr_hash, i;
357
358 addr_hash = 0;
359 for (i = 0; i < (sizeof(struct in6_addr) / sizeof(u32)); i++)
360 addr_hash ^= *p32++;
361
362 return jhash_2words(addr_hash, dev->ifindex, nd_tbl.hash_rnd);
363}
364
365static int ndisc_constructor(struct neighbour *neigh)
366{
367 struct in6_addr *addr = (struct in6_addr*)&neigh->primary_key;
368 struct net_device *dev = neigh->dev;
369 struct inet6_dev *in6_dev;
370 struct neigh_parms *parms;
371 int is_multicast = ipv6_addr_is_multicast(addr);
372
373 rcu_read_lock();
374 in6_dev = in6_dev_get(dev);
375 if (in6_dev == NULL) {
376 rcu_read_unlock();
377 return -EINVAL;
378 }
379
380 parms = in6_dev->nd_parms;
381 __neigh_parms_put(neigh->parms);
382 neigh->parms = neigh_parms_clone(parms);
383 rcu_read_unlock();
384
385 neigh->type = is_multicast ? RTN_MULTICAST : RTN_UNICAST;
3b04ddde 386 if (!dev->header_ops) {
1da177e4
LT		 387 neigh->nud_state = NUD_NOARP;
388 neigh->ops = &ndisc_direct_ops;
389 neigh->output = neigh->ops->queue_xmit;
390 } else {
391 if (is_multicast) {
392 neigh->nud_state = NUD_NOARP;
393 ndisc_mc_map(addr, neigh->ha, dev, 1);
394 } else if (dev->flags&(IFF_NOARP|IFF_LOOPBACK)) {
395 neigh->nud_state = NUD_NOARP;
396 memcpy(neigh->ha, dev->dev_addr, dev->addr_len);
397 if (dev->flags&IFF_LOOPBACK)
398 neigh->type = RTN_LOCAL;
399 } else if (dev->flags&IFF_POINTOPOINT) {
400 neigh->nud_state = NUD_NOARP;
401 memcpy(neigh->ha, dev->broadcast, dev->addr_len);
402 }
3b04ddde 403 if (dev->header_ops->cache)
1da177e4
LT		 404 neigh->ops = &ndisc_hh_ops;
405 else
406 neigh->ops = &ndisc_generic_ops;
407 if (neigh->nud_state&NUD_VALID)
408 neigh->output = neigh->ops->connected_output;
409 else
410 neigh->output = neigh->ops->output;
411 }
412 in6_dev_put(in6_dev);
413 return 0;
414}
415
416static int pndisc_constructor(struct pneigh_entry *n)
417{
418 struct in6_addr *addr = (struct in6_addr*)&n->key;
419 struct in6_addr maddr;
420 struct net_device *dev = n->dev;
421
422 if (dev == NULL || __in6_dev_get(dev) == NULL)
423 return -EINVAL;
424 addrconf_addr_solict_mult(addr, &maddr);
425 ipv6_dev_mc_inc(dev, &maddr);
426 return 0;
427}
428
429static void pndisc_destructor(struct pneigh_entry *n)
430{
431 struct in6_addr *addr = (struct in6_addr*)&n->key;
432 struct in6_addr maddr;
433 struct net_device *dev = n->dev;
434
435 if (dev == NULL || __in6_dev_get(dev) == NULL)
436 return;
437 addrconf_addr_solict_mult(addr, &maddr);
438 ipv6_dev_mc_dec(dev, &maddr);
439}
440
305d552a
BH		 441struct sk_buff *ndisc_build_skb(struct net_device *dev,
442 const struct in6_addr *daddr,
443 const struct in6_addr *saddr,
444 struct icmp6hdr *icmp6h,
445 const struct in6_addr *target,
446 int llinfo)
1da177e4 447{
c346dca1 448 struct net *net = dev_net(dev);
1762f7e8 449 struct sock *sk = net->ipv6.ndisc_sk;
1ab1457c 450 struct sk_buff *skb;
e1ec7842 451 struct icmp6hdr *hdr;
e1ec7842 452 int len;
1da177e4 453 int err;
305d552a 454 u8 *opt;
1da177e4 455
e1ec7842
YH		 456 if (!dev->addr_len)
457 llinfo = 0;
458
459 len = sizeof(struct icmp6hdr) + (target ? sizeof(*target) : 0);
460 if (llinfo)
461 len += ndisc_opt_addr_space(dev);
1da177e4 462
d54a81d3
DM		 463 skb = sock_alloc_send_skb(sk,
464 (MAX_HEADER + sizeof(struct ipv6hdr) +
f5184d26 465 len + LL_ALLOCATED_SPACE(dev)),
1da177e4 466 1, &err);
e1ec7842 467 if (!skb) {
1da177e4 468 ND_PRINTK0(KERN_ERR
dae9de8e
BH		 469 "ICMPv6 ND: %s() failed to allocate an skb, err=%d.\n",
470 __func__, err);
305d552a 471 return NULL;
1da177e4
LT		 472 }
473
474 skb_reserve(skb, LL_RESERVED_SPACE(dev));
e1ec7842 475 ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);
1da177e4 476
27a884dc 477 skb->transport_header = skb->tail;
d10ba34b 478 skb_put(skb, len);
1da177e4 479
e1ec7842
YH		 480 hdr = (struct icmp6hdr *)skb_transport_header(skb);
481 memcpy(hdr, icmp6h, sizeof(*hdr));
1da177e4 482
e1ec7842
YH		 483 opt = skb_transport_header(skb) + sizeof(struct icmp6hdr);
484 if (target) {
485 ipv6_addr_copy((struct in6_addr *)opt, target);
486 opt += sizeof(*target);
487 }
1da177e4 488
e1ec7842
YH		 489 if (llinfo)
490 ndisc_fill_addr_option(opt, llinfo, dev->dev_addr,
1da177e4
LT		 491 dev->addr_len, dev->type);
492
e1ec7842
YH		 493 hdr->icmp6_cksum = csum_ipv6_magic(saddr, daddr, len,
494 IPPROTO_ICMPV6,
07f0757a 495 csum_partial(hdr,
e1ec7842 496 len, 0));
1da177e4 497
305d552a
BH		 498 return skb;
499}
500
501EXPORT_SYMBOL(ndisc_build_skb);
502
503void ndisc_send_skb(struct sk_buff *skb,
504 struct net_device *dev,
505 struct neighbour *neigh,
506 const struct in6_addr *daddr,
507 const struct in6_addr *saddr,
508 struct icmp6hdr *icmp6h)
509{
510 struct flowi fl;
511 struct dst_entry *dst;
512 struct net *net = dev_net(dev);
513 struct sock *sk = net->ipv6.ndisc_sk;
514 struct inet6_dev *idev;
515 int err;
516 u8 type;
517
518 type = icmp6h->icmp6_type;
519
520 icmpv6_flow_init(sk, &fl, type, saddr, daddr, dev->ifindex);
521
522 dst = icmp6_dst_alloc(dev, neigh, daddr);
523 if (!dst) {
524 kfree_skb(skb);
525 return;
526 }
527
52479b62 528 err = xfrm_lookup(net, &dst, &fl, NULL, 0);
305d552a
BH		 529 if (err < 0) {
530 kfree_skb(skb);
531 return;
532 }
533
adf30907 534 skb_dst_set(skb, dst);
e1ec7842 535
1da177e4 536 idev = in6_dev_get(dst->dev);
edf391ff 537 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
e1ec7842 538
b2e0b385 539 err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, skb, NULL, dst->dev,
6e23ae2a 540 dst_output);
1da177e4 541 if (!err) {
5c5d244b 542 ICMP6MSGOUT_INC_STATS(net, idev, type);
a862f6a6 543 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
1da177e4
LT		 544 }
545
546 if (likely(idev != NULL))
547 in6_dev_put(idev);
1ab1457c 548}
1da177e4 549
305d552a
BH		 550EXPORT_SYMBOL(ndisc_send_skb);
551
552/*
553 * Send a Neighbour Discover packet
554 */
555static void __ndisc_send(struct net_device *dev,
556 struct neighbour *neigh,
557 const struct in6_addr *daddr,
558 const struct in6_addr *saddr,
559 struct icmp6hdr *icmp6h, const struct in6_addr *target,
560 int llinfo)
561{
562 struct sk_buff *skb;
563
564 skb = ndisc_build_skb(dev, daddr, saddr, icmp6h, target, llinfo);
565 if (!skb)
566 return;
567
568 ndisc_send_skb(skb, dev, neigh, daddr, saddr, icmp6h);
569}
570
e1ec7842 571static void ndisc_send_na(struct net_device *dev, struct neighbour *neigh,
9acd9f3a
YH		 572 const struct in6_addr *daddr,
573 const struct in6_addr *solicited_addr,
574 int router, int solicited, int override, int inc_opt)
e1ec7842
YH		 575{
576 struct in6_addr tmpaddr;
577 struct inet6_ifaddr *ifp;
9acd9f3a 578 const struct in6_addr *src_addr;
e1ec7842
YH		 579 struct icmp6hdr icmp6h = {
580 .icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT,
581 };
582
583 /* for anycast or proxy, solicited_addr != src_addr */
c346dca1 584 ifp = ipv6_get_ifaddr(dev_net(dev), solicited_addr, dev, 1);
e1ec7842
YH		 585 if (ifp) {
586 src_addr = solicited_addr;
587 if (ifp->flags & IFA_F_OPTIMISTIC)
588 override = 0;
9f888160 589 inc_opt |= ifp->idev->cnf.force_tllao;
e1ec7842
YH		 590 in6_ifa_put(ifp);
591 } else {
191cd582 592 if (ipv6_dev_get_saddr(dev_net(dev), dev, daddr,
c346dca1 593 inet6_sk(dev_net(dev)->ipv6.ndisc_sk)->srcprefs,
7cbca67c 594 &tmpaddr))
e1ec7842
YH		 595 return;
596 src_addr = &tmpaddr;
597 }
598
599 icmp6h.icmp6_router = router;
600 icmp6h.icmp6_solicited = solicited;
601 icmp6h.icmp6_override = override;
602
603 __ndisc_send(dev, neigh, daddr, src_addr,
604 &icmp6h, solicited_addr,
14878f75 605 inc_opt ? ND_OPT_TARGET_LL_ADDR : 0);
e1ec7842
YH		 606}
607
1da177e4 608void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh,
9acd9f3a
YH		 609 const struct in6_addr *solicit,
610 const struct in6_addr *daddr, const struct in6_addr *saddr)
1da177e4 611{
1da177e4 612 struct in6_addr addr_buf;
e1ec7842
YH		 613 struct icmp6hdr icmp6h = {
614 .icmp6_type = NDISC_NEIGHBOUR_SOLICITATION,
615 };
1da177e4
LT		 616
617 if (saddr == NULL) {
95c385b4
NH		 618 if (ipv6_get_lladdr(dev, &addr_buf,
619 (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
1da177e4
LT		 620 return;
621 saddr = &addr_buf;
622 }
623
e1ec7842
YH		 624 __ndisc_send(dev, neigh, daddr, saddr,
625 &icmp6h, solicit,
14878f75 626 !ipv6_addr_any(saddr) ? ND_OPT_SOURCE_LL_ADDR : 0);
1da177e4
LT		 627}
628
9acd9f3a
YH		 629void ndisc_send_rs(struct net_device *dev, const struct in6_addr *saddr,
630 const struct in6_addr *daddr)
1da177e4 631{
e1ec7842
YH		 632 struct icmp6hdr icmp6h = {
633 .icmp6_type = NDISC_ROUTER_SOLICITATION,
634 };
95c385b4 635 int send_sllao = dev->addr_len;
95c385b4
NH		 636
637#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
638 /*
639 * According to section 2.2 of RFC 4429, we must not
640 * send router solicitations with a sllao from
641 * optimistic addresses, but we may send the solicitation
642 * if we don't include the sllao. So here we check
643 * if our address is optimistic, and if so, we
bea85195 644 * suppress the inclusion of the sllao.
95c385b4
NH		 645 */
646 if (send_sllao) {
c346dca1 647 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(dev_net(dev), saddr,
1cab3da6 648 dev, 1);
95c385b4
NH		 649 if (ifp) {
650 if (ifp->flags & IFA_F_OPTIMISTIC) {
ca043569 651 send_sllao = 0;
95c385b4 652 }
ca043569 653 in6_ifa_put(ifp);
95c385b4
NH		 654 } else {
655 send_sllao = 0;
656 }
657 }
658#endif
e1ec7842
YH		 659 __ndisc_send(dev, NULL, daddr, saddr,
660 &icmp6h, NULL,
14878f75 661 send_sllao ? ND_OPT_SOURCE_LL_ADDR : 0);
1da177e4 662}
1ab1457c 663
1da177e4
LT		 664
665static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
666{
667 /*
668 * "The sender MUST return an ICMP
669 * destination unreachable"
670 */
671 dst_link_failure(skb);
672 kfree_skb(skb);
673}
674
675/* Called with locked neigh: either read or both */
676
677static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
678{
679 struct in6_addr *saddr = NULL;
680 struct in6_addr mcaddr;
681 struct net_device *dev = neigh->dev;
682 struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
683 int probes = atomic_read(&neigh->probes);
684
c346dca1 685 if (skb && ipv6_chk_addr(dev_net(dev), &ipv6_hdr(skb)->saddr, dev, 1))
0660e03f 686 saddr = &ipv6_hdr(skb)->saddr;
1da177e4
LT		 687
688 if ((probes -= neigh->parms->ucast_probes) < 0) {
689 if (!(neigh->nud_state & NUD_VALID)) {
5b095d98 690 ND_PRINTK1(KERN_DEBUG "%s(): trying to ucast probe in NUD_INVALID: %pI6\n",
0c6ce78a 691 __func__, target);
1da177e4
LT		 692 }
693 ndisc_send_ns(dev, neigh, target, target, saddr);
694 } else if ((probes -= neigh->parms->app_probes) < 0) {
695#ifdef CONFIG_ARPD
696 neigh_app_ns(neigh);
697#endif
698 } else {
699 addrconf_addr_solict_mult(target, &mcaddr);
700 ndisc_send_ns(dev, NULL, target, &mcaddr, saddr);
701 }
702}
703
0736ffc0
YH		 704static int pndisc_is_router(const void *pkey,
705 struct net_device *dev)
fa86d322
PE		 706{
707 struct pneigh_entry *n;
0736ffc0 708 int ret = -1;
fa86d322
PE		 709
710 read_lock_bh(&nd_tbl.lock);
0736ffc0
YH		 711 n = __pneigh_lookup(&nd_tbl, dev_net(dev), pkey, dev);
712 if (n)
713 ret = !!(n->flags & NTF_ROUTER);
fa86d322
PE		 714 read_unlock_bh(&nd_tbl.lock);
715
0736ffc0 716 return ret;
fa86d322
PE		 717}
718
1da177e4
LT		 719static void ndisc_recv_ns(struct sk_buff *skb)
720{
9c70220b 721 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
0660e03f
ACM		 722 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
723 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
1da177e4 724 u8 *lladdr = NULL;
27a884dc
ACM		 725 u32 ndoptlen = skb->tail - (skb->transport_header +
726 offsetof(struct nd_msg, opt));
1da177e4
LT		 727 struct ndisc_options ndopts;
728 struct net_device *dev = skb->dev;
729 struct inet6_ifaddr *ifp;
730 struct inet6_dev *idev = NULL;
731 struct neighbour *neigh;
732 int dad = ipv6_addr_any(saddr);
733 int inc;
0736ffc0 734 int is_router = -1;
1da177e4
LT		 735
736 if (ipv6_addr_is_multicast(&msg->target)) {
1ab1457c 737 ND_PRINTK2(KERN_WARNING
1da177e4
LT		 738 "ICMPv6 NS: multicast target address");
739 return;
740 }
741
742 /*
743 * RFC2461 7.1.1:
744 * DAD has to be destined for solicited node multicast address.
745 */
746 if (dad &&
747 !(daddr->s6_addr32[0] == htonl(0xff020000) &&
748 daddr->s6_addr32[1] == htonl(0x00000000) &&
749 daddr->s6_addr32[2] == htonl(0x00000001) &&
750 daddr->s6_addr [12] == 0xff )) {
751 ND_PRINTK2(KERN_WARNING
752 "ICMPv6 NS: bad DAD packet (wrong destination)\n");
753 return;
754 }
755
756 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
1ab1457c 757 ND_PRINTK2(KERN_WARNING
1da177e4
LT		 758 "ICMPv6 NS: invalid ND options\n");
759 return;
760 }
761
762 if (ndopts.nd_opts_src_lladdr) {
763 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
764 if (!lladdr) {
765 ND_PRINTK2(KERN_WARNING
766 "ICMPv6 NS: invalid link-layer address length\n");
767 return;
768 }
769
770 /* RFC2461 7.1.1:
1ab1457c
YH		 771 * If the IP source address is the unspecified address,
772 * there MUST NOT be source link-layer address option
1da177e4
LT		 773 * in the message.
774 */
775 if (dad) {
1ab1457c 776 ND_PRINTK2(KERN_WARNING
1da177e4
LT		 777 "ICMPv6 NS: bad DAD packet (link-layer address option)\n");
778 return;
779 }
780 }
781
782 inc = ipv6_addr_is_multicast(daddr);
783
c346dca1 784 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
a18bc695 785 if (ifp) {
95c385b4
NH		 786
787 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
788 if (dad) {
789 if (dev->type == ARPHRD_IEEE802_TR) {
98e399f8
ACM		 790 const unsigned char *sadr;
791 sadr = skb_mac_header(skb);
95c385b4
NH		 792 if (((sadr[8] ^ dev->dev_addr[0]) & 0x7f) == 0 &&
793 sadr[9] == dev->dev_addr[1] &&
794 sadr[10] == dev->dev_addr[2] &&
795 sadr[11] == dev->dev_addr[3] &&
796 sadr[12] == dev->dev_addr[4] &&
797 sadr[13] == dev->dev_addr[5]) {
798 /* looped-back to us */
799 goto out;
800 }
801 }
802
803 /*
804 * We are colliding with another node
805 * who is doing DAD
806 * so fail our DAD process
807 */
808 addrconf_dad_failure(ifp);
9e3be4b3 809 return;
95c385b4
NH		 810 } else {
811 /*
812 * This is not a dad solicitation.
813 * If we are an optimistic node,
814 * we should respond.
815 * Otherwise, we should ignore it.
816 */
817 if (!(ifp->flags & IFA_F_OPTIMISTIC))
1da177e4 818 goto out;
1da177e4 819 }
1da177e4
LT		 820 }
821
822 idev = ifp->idev;
823 } else {
53b7997f
YH		 824 struct net *net = dev_net(dev);
825
1da177e4
LT		 826 idev = in6_dev_get(dev);
827 if (!idev) {
828 /* XXX: count this drop? */
829 return;
830 }
831
53b7997f 832 if (ipv6_chk_acast_addr(net, dev, &msg->target) ||
1ab1457c 833 (idev->cnf.forwarding &&
53b7997f 834 (net->ipv6.devconf_all->proxy_ndp || idev->cnf.proxy_ndp) &&
0736ffc0 835 (is_router = pndisc_is_router(&msg->target, dev)) >= 0)) {
a61bbcf2 836 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
1da177e4
LT		 837 skb->pkt_type != PACKET_HOST &&
838 inc != 0 &&
839 idev->nd_parms->proxy_delay != 0) {
840 /*
841 * for anycast or proxy,
1ab1457c
YH		 842 * sender should delay its response
843 * by a random time between 0 and
1da177e4
LT		 844 * MAX_ANYCAST_DELAY_TIME seconds.
845 * (RFC2461) -- yoshfuji
846 */
847 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
848 if (n)
849 pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
850 goto out;
851 }
852 } else
853 goto out;
854 }
855
0736ffc0
YH		 856 if (is_router < 0)
857 is_router = !!idev->cnf.forwarding;
62dd9318 858
1da177e4 859 if (dad) {
f3ee4010 860 ndisc_send_na(dev, NULL, &in6addr_linklocal_allnodes, &msg->target,
62dd9318 861 is_router, 0, (ifp != NULL), 1);
1da177e4
LT		 862 goto out;
863 }
864
865 if (inc)
866 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
867 else
868 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
869
1ab1457c 870 /*
1da177e4
LT		 871 * update / create cache entry
872 * for the source address
873 */
874 neigh = __neigh_lookup(&nd_tbl, saddr, dev,
875 !inc || lladdr || !dev->addr_len);
876 if (neigh)
1ab1457c 877 neigh_update(neigh, lladdr, NUD_STALE,
1da177e4
LT		 878 NEIGH_UPDATE_F_WEAK_OVERRIDE|
879 NEIGH_UPDATE_F_OVERRIDE);
3b04ddde 880 if (neigh || !dev->header_ops) {
1da177e4 881 ndisc_send_na(dev, neigh, saddr, &msg->target,
62dd9318 882 is_router,
1da177e4
LT		 883 1, (ifp != NULL && inc), inc);
884 if (neigh)
885 neigh_release(neigh);
886 }
887
888out:
889 if (ifp)
890 in6_ifa_put(ifp);
891 else
892 in6_dev_put(idev);
1da177e4
LT		 893}
894
895static void ndisc_recv_na(struct sk_buff *skb)
896{
9c70220b 897 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
0660e03f
ACM		 898 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
899 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
1da177e4 900 u8 *lladdr = NULL;
27a884dc
ACM		 901 u32 ndoptlen = skb->tail - (skb->transport_header +
902 offsetof(struct nd_msg, opt));
1da177e4
LT		 903 struct ndisc_options ndopts;
904 struct net_device *dev = skb->dev;
905 struct inet6_ifaddr *ifp;
906 struct neighbour *neigh;
907
908 if (skb->len < sizeof(struct nd_msg)) {
909 ND_PRINTK2(KERN_WARNING
910 "ICMPv6 NA: packet too short\n");
911 return;
912 }
913
914 if (ipv6_addr_is_multicast(&msg->target)) {
915 ND_PRINTK2(KERN_WARNING
916 "ICMPv6 NA: target address is multicast.\n");
917 return;
918 }
919
920 if (ipv6_addr_is_multicast(daddr) &&
921 msg->icmph.icmp6_solicited) {
922 ND_PRINTK2(KERN_WARNING
923 "ICMPv6 NA: solicited NA is multicasted.\n");
924 return;
925 }
1ab1457c 926
1da177e4
LT		 927 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
928 ND_PRINTK2(KERN_WARNING
929 "ICMPv6 NS: invalid ND option\n");
930 return;
931 }
932 if (ndopts.nd_opts_tgt_lladdr) {
933 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
934 if (!lladdr) {
935 ND_PRINTK2(KERN_WARNING
936 "ICMPv6 NA: invalid link-layer address length\n");
937 return;
938 }
939 }
c346dca1 940 ifp = ipv6_get_ifaddr(dev_net(dev), &msg->target, dev, 1);
a18bc695 941 if (ifp) {
1da177e4
LT		 942 if (ifp->flags & IFA_F_TENTATIVE) {
943 addrconf_dad_failure(ifp);
944 return;
945 }
946 /* What should we make now? The advertisement
947 is invalid, but ndisc specs say nothing
948 about it. It could be misconfiguration, or
949 an smart proxy agent tries to help us :-)
24fc7b86
JS		 950
951 We should not print the error if NA has been
952 received from loopback - it is just our own
953 unsolicited advertisement.
1da177e4 954 */
24fc7b86
JS		 955 if (skb->pkt_type != PACKET_LOOPBACK)
956 ND_PRINTK1(KERN_WARNING
a6fa3286
JR		 957 "ICMPv6 NA: someone advertises our address %pI6 on %s!\n",
958 &ifp->addr, ifp->idev->dev->name);
1da177e4
LT		 959 in6_ifa_put(ifp);
960 return;
961 }
962 neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
963
964 if (neigh) {
965 u8 old_flags = neigh->flags;
53b7997f 966 struct net *net = dev_net(dev);
1da177e4
LT		 967
968 if (neigh->nud_state & NUD_FAILED)
969 goto out;
970
5f3e6e9e
VN		 971 /*
972 * Don't update the neighbor cache entry on a proxy NA from
973 * ourselves because either the proxied node is off link or it
974 * has already sent a NA to us.
975 */
976 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
53b7997f
YH		 977 net->ipv6.devconf_all->forwarding && net->ipv6.devconf_all->proxy_ndp &&
978 pneigh_lookup(&nd_tbl, net, &msg->target, dev, 0)) {
fbea49e1 979 /* XXX: idev->cnf.prixy_ndp */
5f3e6e9e 980 goto out;
fbea49e1 981 }
5f3e6e9e 982
1da177e4
LT		 983 neigh_update(neigh, lladdr,
984 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
985 NEIGH_UPDATE_F_WEAK_OVERRIDE|
986 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
987 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
988 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));
989
990 if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
991 /*
992 * Change: router to host
993 */
994 struct rt6_info *rt;
995 rt = rt6_get_dflt_router(saddr, dev);
996 if (rt)
e0a1ad73 997 ip6_del_rt(rt);
1da177e4
LT		 998 }
999
1000out:
1001 neigh_release(neigh);
1002 }
1003}
1004
1005static void ndisc_recv_rs(struct sk_buff *skb)
1006{
9c70220b 1007 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
1da177e4
LT		 1008 unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
1009 struct neighbour *neigh;
1010 struct inet6_dev *idev;
0660e03f 1011 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
1da177e4
LT		 1012 struct ndisc_options ndopts;
1013 u8 *lladdr = NULL;
1014
1015 if (skb->len < sizeof(*rs_msg))
1016 return;
1017
1018 idev = in6_dev_get(skb->dev);
1019 if (!idev) {
1020 if (net_ratelimit())
1021 ND_PRINTK1("ICMP6 RS: can't find in6 device\n");
1022 return;
1023 }
1024
1025 /* Don't accept RS if we're not in router mode */
1026 if (!idev->cnf.forwarding)
1027 goto out;
1028
1029 /*
1030 * Don't update NCE if src = ::;
1031 * this implies that the source node has no ip address assigned yet.
1032 */
1033 if (ipv6_addr_any(saddr))
1034 goto out;
1035
1036 /* Parse ND options */
1037 if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {
1038 if (net_ratelimit())
1039 ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n");
1040 goto out;
1041 }
1042
1043 if (ndopts.nd_opts_src_lladdr) {
1044 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1045 skb->dev);
1046 if (!lladdr)
1047 goto out;
1048 }
1049
1050 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
1051 if (neigh) {
1052 neigh_update(neigh, lladdr, NUD_STALE,
1053 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1054 NEIGH_UPDATE_F_OVERRIDE|
1055 NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
1056 neigh_release(neigh);
1057 }
1058out:
1059 in6_dev_put(idev);
1060}
1061
31910575
PY		 1062static void ndisc_ra_useropt(struct sk_buff *ra, struct nd_opt_hdr *opt)
1063{
1064 struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb_transport_header(ra);
1065 struct sk_buff *skb;
1066 struct nlmsghdr *nlh;
1067 struct nduseroptmsg *ndmsg;
c346dca1 1068 struct net *net = dev_net(ra->dev);
31910575
PY		 1069 int err;
1070 int base_size = NLMSG_ALIGN(sizeof(struct nduseroptmsg)
1071 + (opt->nd_opt_len << 3));
1072 size_t msg_size = base_size + nla_total_size(sizeof(struct in6_addr));
1073
1074 skb = nlmsg_new(msg_size, GFP_ATOMIC);
1075 if (skb == NULL) {
1076 err = -ENOBUFS;
1077 goto errout;
1078 }
1079
1080 nlh = nlmsg_put(skb, 0, 0, RTM_NEWNDUSEROPT, base_size, 0);
1081 if (nlh == NULL) {
1082 goto nla_put_failure;
1083 }
1084
1085 ndmsg = nlmsg_data(nlh);
1086 ndmsg->nduseropt_family = AF_INET6;
dbb2ed24 1087 ndmsg->nduseropt_ifindex = ra->dev->ifindex;
31910575
PY		 1088 ndmsg->nduseropt_icmp_type = icmp6h->icmp6_type;
1089 ndmsg->nduseropt_icmp_code = icmp6h->icmp6_code;
1090 ndmsg->nduseropt_opts_len = opt->nd_opt_len << 3;
1091
1092 memcpy(ndmsg + 1, opt, opt->nd_opt_len << 3);
1093
1094 NLA_PUT(skb, NDUSEROPT_SRCADDR, sizeof(struct in6_addr),
1095 &ipv6_hdr(ra)->saddr);
1096 nlmsg_end(skb, nlh);
1097
1ce85fe4 1098 rtnl_notify(skb, net, 0, RTNLGRP_ND_USEROPT, NULL, GFP_ATOMIC);
31910575
PY		 1099 return;
1100
1101nla_put_failure:
1102 nlmsg_free(skb);
1103 err = -EMSGSIZE;
1104errout:
a18bc695 1105 rtnl_set_sk_err(net, RTNLGRP_ND_USEROPT, err);
31910575
PY		 1106}
1107
65e9b62d
TG		 1108static inline int accept_ra(struct inet6_dev *in6_dev)
1109{
1110 /*
1111 * If forwarding is enabled, RA are not accepted unless the special
1112 * hybrid mode (accept_ra=2) is enabled.
1113 */
1114 if (in6_dev->cnf.forwarding && in6_dev->cnf.accept_ra < 2)
1115 return 0;
1116
1117 return in6_dev->cnf.accept_ra;
1118}
1119
1da177e4
LT		 1120static void ndisc_router_discovery(struct sk_buff *skb)
1121{
9c70220b 1122 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
1da177e4
LT		 1123 struct neighbour *neigh = NULL;
1124 struct inet6_dev *in6_dev;
65f5c7c1 1125 struct rt6_info *rt = NULL;
1da177e4
LT		 1126 int lifetime;
1127 struct ndisc_options ndopts;
1128 int optlen;
ebacaaa0 1129 unsigned int pref = 0;
1da177e4
LT		 1130
1131 __u8 * opt = (__u8 *)(ra_msg + 1);
1132
27a884dc 1133 optlen = (skb->tail - skb->transport_header) - sizeof(struct ra_msg);
1da177e4 1134
0660e03f 1135 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1da177e4
LT		 1136 ND_PRINTK2(KERN_WARNING
1137 "ICMPv6 RA: source address is not link-local.\n");
1138 return;
1139 }
1140 if (optlen < 0) {
1ab1457c 1141 ND_PRINTK2(KERN_WARNING
1da177e4
LT		 1142 "ICMPv6 RA: packet too short\n");
1143 return;
1144 }
1145
de357cc0 1146#ifdef CONFIG_IPV6_NDISC_NODETYPE
fadf6bf0
TF		 1147 if (skb->ndisc_nodetype == NDISC_NODETYPE_HOST) {
1148 ND_PRINTK2(KERN_WARNING
1149 "ICMPv6 RA: from host or unauthorized router\n");
1150 return;
1151 }
de357cc0 1152#endif
fadf6bf0 1153
1da177e4
LT		 1154 /*
1155 * set the RA_RECV flag in the interface
1156 */
1157
1158 in6_dev = in6_dev_get(skb->dev);
1159 if (in6_dev == NULL) {
1160 ND_PRINTK0(KERN_ERR
1161 "ICMPv6 RA: can't find inet6 device for %s.\n",
1162 skb->dev->name);
1163 return;
1164 }
1da177e4
LT		 1165
1166 if (!ndisc_parse_options(opt, optlen, &ndopts)) {
1167 in6_dev_put(in6_dev);
1168 ND_PRINTK2(KERN_WARNING
1169 "ICMP6 RA: invalid ND options\n");
1170 return;
1171 }
1172
65e9b62d 1173 if (!accept_ra(in6_dev))
31ce8c71
DW		 1174 goto skip_linkparms;
1175
de357cc0 1176#ifdef CONFIG_IPV6_NDISC_NODETYPE
fadf6bf0
TF		 1177 /* skip link-specific parameters from interior routers */
1178 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1179 goto skip_linkparms;
de357cc0 1180#endif
fadf6bf0 1181
1da177e4
LT		 1182 if (in6_dev->if_flags & IF_RS_SENT) {
1183 /*
1184 * flag that an RA was received after an RS was sent
1185 * out on this interface.
1186 */
1187 in6_dev->if_flags |= IF_RA_RCVD;
1188 }
1189
1190 /*
1191 * Remember the managed/otherconf flags from most recently
1192 * received RA message (RFC 2462) -- yoshfuji
1193 */
1194 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1195 IF_RA_OTHERCONF)) |
1196 (ra_msg->icmph.icmp6_addrconf_managed ?
1197 IF_RA_MANAGED : 0) |
1198 (ra_msg->icmph.icmp6_addrconf_other ?
1199 IF_RA_OTHERCONF : 0);
1200
65f5c7c1
YH		 1201 if (!in6_dev->cnf.accept_ra_defrtr)
1202 goto skip_defrtr;
1203
1da177e4
LT		 1204 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1205
ebacaaa0
YH		 1206#ifdef CONFIG_IPV6_ROUTER_PREF
1207 pref = ra_msg->icmph.icmp6_router_pref;
1208 /* 10b is handled as if it were 00b (medium) */
930d6ff2 1209 if (pref == ICMPV6_ROUTER_PREF_INVALID ||
6d5b78cd 1210 !in6_dev->cnf.accept_ra_rtr_pref)
ebacaaa0
YH		 1211 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1212#endif
1213
0660e03f 1214 rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
1da177e4
LT		 1215
1216 if (rt)
1217 neigh = rt->rt6i_nexthop;
1218
1219 if (rt && lifetime == 0) {
1220 neigh_clone(neigh);
e0a1ad73 1221 ip6_del_rt(rt);
1da177e4
LT		 1222 rt = NULL;
1223 }
1224
1225 if (rt == NULL && lifetime) {
1226 ND_PRINTK3(KERN_DEBUG
1227 "ICMPv6 RA: adding default router.\n");
1228
0660e03f 1229 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
1da177e4
LT		 1230 if (rt == NULL) {
1231 ND_PRINTK0(KERN_ERR
1232 "ICMPv6 RA: %s() failed to add default route.\n",
0dc47877 1233 __func__);
1da177e4
LT		 1234 in6_dev_put(in6_dev);
1235 return;
1236 }
1237
1238 neigh = rt->rt6i_nexthop;
1239 if (neigh == NULL) {
1240 ND_PRINTK0(KERN_ERR
1241 "ICMPv6 RA: %s() got default router without neighbour.\n",
0dc47877 1242 __func__);
d8d1f30b 1243 dst_release(&rt->dst);
1da177e4
LT		 1244 in6_dev_put(in6_dev);
1245 return;
1246 }
1247 neigh->flags |= NTF_ROUTER;
ebacaaa0 1248 } else if (rt) {
22441cfa 1249 rt->rt6i_flags = (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
1da177e4
LT		 1250 }
1251
1252 if (rt)
1253 rt->rt6i_expires = jiffies + (HZ * lifetime);
1254
1255 if (ra_msg->icmph.icmp6_hop_limit) {
1256 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1257 if (rt)
d8d1f30b 1258 rt->dst.metrics[RTAX_HOPLIMIT-1] = ra_msg->icmph.icmp6_hop_limit;
1da177e4
LT		 1259 }
1260
65f5c7c1
YH		 1261skip_defrtr:
1262
1da177e4
LT		 1263 /*
1264 * Update Reachable Time and Retrans Timer
1265 */
1266
1267 if (in6_dev->nd_parms) {
1268 unsigned long rtime = ntohl(ra_msg->retrans_timer);
1269
1270 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1271 rtime = (rtime*HZ)/1000;
1272 if (rtime < HZ/10)
1273 rtime = HZ/10;
1274 in6_dev->nd_parms->retrans_time = rtime;
1275 in6_dev->tstamp = jiffies;
1276 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1277 }
1278
1279 rtime = ntohl(ra_msg->reachable_time);
1280 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1281 rtime = (rtime*HZ)/1000;
1282
1283 if (rtime < HZ/10)
1284 rtime = HZ/10;
1285
1286 if (rtime != in6_dev->nd_parms->base_reachable_time) {
1287 in6_dev->nd_parms->base_reachable_time = rtime;
1288 in6_dev->nd_parms->gc_staletime = 3 * rtime;
1289 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1290 in6_dev->tstamp = jiffies;
1291 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1292 }
1293 }
1294 }
1295
fadf6bf0
TF		 1296skip_linkparms:
1297
1da177e4
LT		 1298 /*
1299 * Process options.
1300 */
1301
1302 if (!neigh)
0660e03f 1303 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
1da177e4
LT		 1304 skb->dev, 1);
1305 if (neigh) {
1306 u8 *lladdr = NULL;
1307 if (ndopts.nd_opts_src_lladdr) {
1308 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1309 skb->dev);
1310 if (!lladdr) {
1311 ND_PRINTK2(KERN_WARNING
1312 "ICMPv6 RA: invalid link-layer address length\n");
1313 goto out;
1314 }
1315 }
1316 neigh_update(neigh, lladdr, NUD_STALE,
1317 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1318 NEIGH_UPDATE_F_OVERRIDE|
1319 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1320 NEIGH_UPDATE_F_ISROUTER);
1321 }
1322
65e9b62d 1323 if (!accept_ra(in6_dev))
31ce8c71
DW		 1324 goto out;
1325
70ceb4f5 1326#ifdef CONFIG_IPV6_ROUTE_INFO
09c884d4 1327 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
70ceb4f5
YH		 1328 struct nd_opt_hdr *p;
1329 for (p = ndopts.nd_opts_ri;
1330 p;
1331 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
6294e000
YH		 1332 struct route_info *ri = (struct route_info *)p;
1333#ifdef CONFIG_IPV6_NDISC_NODETYPE
1334 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT &&
1335 ri->prefix_len == 0)
1336 continue;
1337#endif
1338 if (ri->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
09c884d4 1339 continue;
70ceb4f5 1340 rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3,
0660e03f 1341 &ipv6_hdr(skb)->saddr);
70ceb4f5
YH		 1342 }
1343 }
1344#endif
1345
de357cc0 1346#ifdef CONFIG_IPV6_NDISC_NODETYPE
fadf6bf0
TF		 1347 /* skip link-specific ndopts from interior routers */
1348 if (skb->ndisc_nodetype == NDISC_NODETYPE_NODEFAULT)
1349 goto out;
de357cc0 1350#endif
fadf6bf0 1351
c4fd30eb 1352 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
1da177e4
LT		 1353 struct nd_opt_hdr *p;
1354 for (p = ndopts.nd_opts_pi;
1355 p;
1356 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1357 addrconf_prefix_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3);
1358 }
1359 }
1360
1361 if (ndopts.nd_opts_mtu) {
e69a4adc 1362 __be32 n;
1da177e4
LT		 1363 u32 mtu;
1364
e69a4adc
AV		 1365 memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1366 mtu = ntohl(n);
1da177e4
LT		 1367
1368 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1369 ND_PRINTK2(KERN_WARNING
1370 "ICMPv6 RA: invalid mtu: %d\n",
1371 mtu);
1372 } else if (in6_dev->cnf.mtu6 != mtu) {
1373 in6_dev->cnf.mtu6 = mtu;
1374
1375 if (rt)
d8d1f30b 1376 rt->dst.metrics[RTAX_MTU-1] = mtu;
1da177e4
LT		 1377
1378 rt6_mtu_change(skb->dev, mtu);
1379 }
1380 }
1ab1457c 1381
31910575 1382 if (ndopts.nd_useropts) {
61cf46ad
YH		 1383 struct nd_opt_hdr *p;
1384 for (p = ndopts.nd_useropts;
1385 p;
1386 p = ndisc_next_useropt(p, ndopts.nd_useropts_end)) {
1387 ndisc_ra_useropt(skb, p);
31910575
PY		 1388 }
1389 }
1390
1da177e4
LT		 1391 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1392 ND_PRINTK2(KERN_WARNING
1393 "ICMPv6 RA: invalid RA options");
1394 }
1395out:
1396 if (rt)
d8d1f30b 1397 dst_release(&rt->dst);
1da177e4
LT		 1398 else if (neigh)
1399 neigh_release(neigh);
1400 in6_dev_put(in6_dev);
1401}
1402
1403static void ndisc_redirect_rcv(struct sk_buff *skb)
1404{
1405 struct inet6_dev *in6_dev;
1406 struct icmp6hdr *icmph;
1407 struct in6_addr *dest;
1408 struct in6_addr *target; /* new first hop to destination */
1409 struct neighbour *neigh;
1410 int on_link = 0;
1411 struct ndisc_options ndopts;
1412 int optlen;
1413 u8 *lladdr = NULL;
1414
de357cc0 1415#ifdef CONFIG_IPV6_NDISC_NODETYPE
fadf6bf0
TF		 1416 switch (skb->ndisc_nodetype) {
1417 case NDISC_NODETYPE_HOST:
1418 case NDISC_NODETYPE_NODEFAULT:
1419 ND_PRINTK2(KERN_WARNING
1420 "ICMPv6 Redirect: from host or unauthorized router\n");
1421 return;
1422 }
de357cc0 1423#endif
fadf6bf0 1424
0660e03f 1425 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1da177e4
LT		 1426 ND_PRINTK2(KERN_WARNING
1427 "ICMPv6 Redirect: source address is not link-local.\n");
1428 return;
1429 }
1430
27a884dc 1431 optlen = skb->tail - skb->transport_header;
1da177e4
LT		 1432 optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1433
1434 if (optlen < 0) {
1435 ND_PRINTK2(KERN_WARNING
1436 "ICMPv6 Redirect: packet too short\n");
1437 return;
1438 }
1439
cc70ab26 1440 icmph = icmp6_hdr(skb);
1da177e4
LT		 1441 target = (struct in6_addr *) (icmph + 1);
1442 dest = target + 1;
1443
1444 if (ipv6_addr_is_multicast(dest)) {
1445 ND_PRINTK2(KERN_WARNING
1446 "ICMPv6 Redirect: destination address is multicast.\n");
1447 return;
1448 }
1449
1450 if (ipv6_addr_equal(dest, target)) {
1451 on_link = 1;
bf0b48df
BH		 1452 } else if (ipv6_addr_type(target) !=
1453 (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
1ab1457c 1454 ND_PRINTK2(KERN_WARNING
bf0b48df 1455 "ICMPv6 Redirect: target address is not link-local unicast.\n");
1da177e4
LT		 1456 return;
1457 }
1458
1459 in6_dev = in6_dev_get(skb->dev);
1460 if (!in6_dev)
1461 return;
1462 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects) {
1463 in6_dev_put(in6_dev);
1464 return;
1465 }
1466
1ab1457c 1467 /* RFC2461 8.1:
1da177e4
LT		 1468 * The IP source address of the Redirect MUST be the same as the current
1469 * first-hop router for the specified ICMP Destination Address.
1470 */
1ab1457c 1471
1da177e4
LT		 1472 if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) {
1473 ND_PRINTK2(KERN_WARNING
1474 "ICMPv6 Redirect: invalid ND options\n");
1475 in6_dev_put(in6_dev);
1476 return;
1477 }
1478 if (ndopts.nd_opts_tgt_lladdr) {
1479 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1480 skb->dev);
1481 if (!lladdr) {
1482 ND_PRINTK2(KERN_WARNING
1483 "ICMPv6 Redirect: invalid link-layer address length\n");
1484 in6_dev_put(in6_dev);
1485 return;
1486 }
1487 }
1488
1489 neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1);
1490 if (neigh) {
0660e03f
ACM		 1491 rt6_redirect(dest, &ipv6_hdr(skb)->daddr,
1492 &ipv6_hdr(skb)->saddr, neigh, lladdr,
1da177e4
LT		 1493 on_link);
1494 neigh_release(neigh);
1495 }
1496 in6_dev_put(in6_dev);
1497}
1498
1499void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh,
9acd9f3a 1500 const struct in6_addr *target)
1da177e4 1501{
1762f7e8 1502 struct net_device *dev = skb->dev;
c346dca1 1503 struct net *net = dev_net(dev);
1762f7e8 1504 struct sock *sk = net->ipv6.ndisc_sk;
1da177e4
LT		 1505 int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1506 struct sk_buff *buff;
1507 struct icmp6hdr *icmph;
1508 struct in6_addr saddr_buf;
1509 struct in6_addr *addrp;
1da177e4
LT		 1510 struct rt6_info *rt;
1511 struct dst_entry *dst;
1512 struct inet6_dev *idev;
1513 struct flowi fl;
1514 u8 *opt;
1515 int rd_len;
1516 int err;
1da177e4
LT		 1517 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1518
95c385b4 1519 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
1da177e4
LT		 1520 ND_PRINTK2(KERN_WARNING
1521 "ICMPv6 Redirect: no link-local address on %s\n",
1522 dev->name);
1ab1457c
YH		 1523 return;
1524 }
1da177e4 1525
0660e03f 1526 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
bf0b48df 1527 ipv6_addr_type(target) != (IPV6_ADDR_UNICAST|IPV6_ADDR_LINKLOCAL)) {
29556526 1528 ND_PRINTK2(KERN_WARNING
bf0b48df 1529 "ICMPv6 Redirect: target address is not link-local unicast.\n");
29556526
LY		 1530 return;
1531 }
1532
1762f7e8 1533 icmpv6_flow_init(sk, &fl, NDISC_REDIRECT,
95e41e93 1534 &saddr_buf, &ipv6_hdr(skb)->saddr, dev->ifindex);
1da177e4 1535
1762f7e8 1536 dst = ip6_route_output(net, NULL, &fl);
1da177e4
LT		 1537 if (dst == NULL)
1538 return;
1539
52479b62 1540 err = xfrm_lookup(net, &dst, &fl, NULL, 0);
e104411b 1541 if (err)
1da177e4 1542 return;
1da177e4
LT		 1543
1544 rt = (struct rt6_info *) dst;
1545
1546 if (rt->rt6i_flags & RTF_GATEWAY) {
1547 ND_PRINTK2(KERN_WARNING
1548 "ICMPv6 Redirect: destination is not a neighbour.\n");
d73f0801 1549 goto release;
1da177e4 1550 }
d73f0801
IJ		 1551 if (!xrlim_allow(dst, 1*HZ))
1552 goto release;
1da177e4
LT		 1553
1554 if (dev->addr_len) {
1555 read_lock_bh(&neigh->lock);
1556 if (neigh->nud_state & NUD_VALID) {
1557 memcpy(ha_buf, neigh->ha, dev->addr_len);
1558 read_unlock_bh(&neigh->lock);
1559 ha = ha_buf;
1560 len += ndisc_opt_addr_space(dev);
1561 } else
1562 read_unlock_bh(&neigh->lock);
1563 }
1564
1565 rd_len = min_t(unsigned int,
1566 IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8);
1567 rd_len &= ~0x7;
1568 len += rd_len;
1569
d54a81d3
DM		 1570 buff = sock_alloc_send_skb(sk,
1571 (MAX_HEADER + sizeof(struct ipv6hdr) +
f5184d26 1572 len + LL_ALLOCATED_SPACE(dev)),
1da177e4
LT		 1573 1, &err);
1574 if (buff == NULL) {
1575 ND_PRINTK0(KERN_ERR
dae9de8e
BH		 1576 "ICMPv6 Redirect: %s() failed to allocate an skb, err=%d.\n",
1577 __func__, err);
d73f0801 1578 goto release;
1da177e4
LT		 1579 }
1580
1da177e4 1581 skb_reserve(buff, LL_RESERVED_SPACE(dev));
0660e03f 1582 ip6_nd_hdr(sk, buff, dev, &saddr_buf, &ipv6_hdr(skb)->saddr,
1da177e4
LT		 1583 IPPROTO_ICMPV6, len);
1584
27a884dc 1585 skb_set_transport_header(buff, skb_tail_pointer(buff) - buff->data);
d10ba34b
ACM		 1586 skb_put(buff, len);
1587 icmph = icmp6_hdr(buff);
1da177e4
LT		 1588
1589 memset(icmph, 0, sizeof(struct icmp6hdr));
1590 icmph->icmp6_type = NDISC_REDIRECT;
1591
1592 /*
1593 * copy target and destination addresses
1594 */
1595
1596 addrp = (struct in6_addr *)(icmph + 1);
1597 ipv6_addr_copy(addrp, target);
1598 addrp++;
0660e03f 1599 ipv6_addr_copy(addrp, &ipv6_hdr(skb)->daddr);
1da177e4
LT		 1600
1601 opt = (u8*) (addrp + 1);
1602
1603 /*
1604 * include target_address option
1605 */
1606
1607 if (ha)
1608 opt = ndisc_fill_addr_option(opt, ND_OPT_TARGET_LL_ADDR, ha,
1609 dev->addr_len, dev->type);
1610
1611 /*
1612 * build redirect option and copy skb over to the new packet.
1613 */
1614
1ab1457c 1615 memset(opt, 0, 8);
1da177e4
LT		 1616 *(opt++) = ND_OPT_REDIRECT_HDR;
1617 *(opt++) = (rd_len >> 3);
1618 opt += 6;
1619
0660e03f 1620 memcpy(opt, ipv6_hdr(skb), rd_len - 8);
1da177e4 1621
0660e03f 1622 icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &ipv6_hdr(skb)->saddr,
1da177e4 1623 len, IPPROTO_ICMPV6,
07f0757a 1624 csum_partial(icmph, len, 0));
1da177e4 1625
adf30907 1626 skb_dst_set(buff, dst);
1da177e4 1627 idev = in6_dev_get(dst->dev);
edf391ff 1628 IP6_UPD_PO_STATS(net, idev, IPSTATS_MIB_OUT, skb->len);
b2e0b385 1629 err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, buff, NULL, dst->dev,
6e23ae2a 1630 dst_output);
1da177e4 1631 if (!err) {
5c5d244b 1632 ICMP6MSGOUT_INC_STATS(net, idev, NDISC_REDIRECT);
a862f6a6 1633 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTMSGS);
1da177e4
LT		 1634 }
1635
1636 if (likely(idev != NULL))
1637 in6_dev_put(idev);
d73f0801
IJ		 1638 return;
1639
1640release:
1641 dst_release(dst);
1da177e4
LT		 1642}
1643
1644static void pndisc_redo(struct sk_buff *skb)
1645{
140e26fc 1646 ndisc_recv_ns(skb);
1da177e4
LT		 1647 kfree_skb(skb);
1648}
1649
1650int ndisc_rcv(struct sk_buff *skb)
1651{
1652 struct nd_msg *msg;
1653
1654 if (!pskb_may_pull(skb, skb->len))
1655 return 0;
1656
9c70220b 1657 msg = (struct nd_msg *)skb_transport_header(skb);
1da177e4 1658
9c70220b 1659 __skb_push(skb, skb->data - skb_transport_header(skb));
1da177e4 1660
0660e03f 1661 if (ipv6_hdr(skb)->hop_limit != 255) {
1da177e4
LT		 1662 ND_PRINTK2(KERN_WARNING
1663 "ICMPv6 NDISC: invalid hop-limit: %d\n",
0660e03f 1664 ipv6_hdr(skb)->hop_limit);
1da177e4
LT		 1665 return 0;
1666 }
1667
1668 if (msg->icmph.icmp6_code != 0) {
1ab1457c 1669 ND_PRINTK2(KERN_WARNING
1da177e4
LT		 1670 "ICMPv6 NDISC: invalid ICMPv6 code: %d\n",
1671 msg->icmph.icmp6_code);
1672 return 0;
1673 }
1674
a61bbcf2
PM		 1675 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1676
1da177e4
LT		 1677 switch (msg->icmph.icmp6_type) {
1678 case NDISC_NEIGHBOUR_SOLICITATION:
1679 ndisc_recv_ns(skb);
1680 break;
1681
1682 case NDISC_NEIGHBOUR_ADVERTISEMENT:
1683 ndisc_recv_na(skb);
1684 break;
1685
1686 case NDISC_ROUTER_SOLICITATION:
1687 ndisc_recv_rs(skb);
1688 break;
1689
1690 case NDISC_ROUTER_ADVERTISEMENT:
1691 ndisc_router_discovery(skb);
1692 break;
1693
1694 case NDISC_REDIRECT:
1695 ndisc_redirect_rcv(skb);
1696 break;
3ff50b79 1697 }
1da177e4
LT		 1698
1699 return 0;
1700}
1701
1702static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1703{
1704 struct net_device *dev = ptr;
c346dca1 1705 struct net *net = dev_net(dev);
1da177e4
LT		 1706
1707 switch (event) {
1708 case NETDEV_CHANGEADDR:
1709 neigh_changeaddr(&nd_tbl, dev);
5b7c931d 1710 fib6_run_gc(~0UL, net);
1da177e4
LT		 1711 break;
1712 case NETDEV_DOWN:
1713 neigh_ifdown(&nd_tbl, dev);
5b7c931d 1714 fib6_run_gc(~0UL, net);
1da177e4
LT		 1715 break;
1716 default:
1717 break;
1718 }
1719
1720 return NOTIFY_DONE;
1721}
1722
1723static struct notifier_block ndisc_netdev_notifier = {
1724 .notifier_call = ndisc_netdev_event,
1725};
1726
1727#ifdef CONFIG_SYSCTL
1728static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1729 const char *func, const char *dev_name)
1730{
1731 static char warncomm[TASK_COMM_LEN];
1732 static int warned;
1733 if (strcmp(warncomm, current->comm) && warned < 5) {
1734 strcpy(warncomm, current->comm);
1735 printk(KERN_WARNING
1736 "process `%s' is using deprecated sysctl (%s) "
1737 "net.ipv6.neigh.%s.%s; "
1738 "Use net.ipv6.neigh.%s.%s_ms "
1739 "instead.\n",
1740 warncomm, func,
1741 dev_name, ctl->procname,
1742 dev_name, ctl->procname);
1743 warned++;
1744 }
1745}
1746
8d65af78 1747int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, void __user *buffer, size_t *lenp, loff_t *ppos)
1da177e4
LT		 1748{
1749 struct net_device *dev = ctl->extra1;
1750 struct inet6_dev *idev;
1751 int ret;
1752
d12af679
EB		 1753 if ((strcmp(ctl->procname, "retrans_time") == 0) ||
1754 (strcmp(ctl->procname, "base_reachable_time") == 0))
1da177e4
LT		 1755 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1756
d12af679 1757 if (strcmp(ctl->procname, "retrans_time") == 0)
8d65af78 1758 ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
d12af679
EB		 1759
1760 else if (strcmp(ctl->procname, "base_reachable_time") == 0)
1da177e4 1761 ret = proc_dointvec_jiffies(ctl, write,
8d65af78 1762 buffer, lenp, ppos);
d12af679
EB		 1763
1764 else if ((strcmp(ctl->procname, "retrans_time_ms") == 0) ||
ad02ac14 1765 (strcmp(ctl->procname, "base_reachable_time_ms") == 0))
1da177e4 1766 ret = proc_dointvec_ms_jiffies(ctl, write,
8d65af78 1767 buffer, lenp, ppos);
d12af679 1768 else
1da177e4 1769 ret = -1;
1da177e4
LT		 1770
1771 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
d12af679 1772 if (ctl->data == &idev->nd_parms->base_reachable_time)
1da177e4
LT		 1773 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1774 idev->tstamp = jiffies;
1775 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1776 in6_dev_put(idev);
1777 }
1778 return ret;
1779}
1780
1da177e4
LT		 1781
1782#endif
1783
2c8c1e72 1784static int __net_init ndisc_net_init(struct net *net)
1da177e4
LT		 1785{
1786 struct ipv6_pinfo *np;
1787 struct sock *sk;
1ab1457c 1788 int err;
1da177e4 1789
1ed8516f
DL		 1790 err = inet_ctl_sock_create(&sk, PF_INET6,
1791 SOCK_RAW, IPPROTO_ICMPV6, net);
1da177e4
LT		 1792 if (err < 0) {
1793 ND_PRINTK0(KERN_ERR
1ab1457c 1794 "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",
1da177e4 1795 err);
1da177e4
LT		 1796 return err;
1797 }
1798
1ed8516f 1799 net->ipv6.ndisc_sk = sk;
1762f7e8 1800
1da177e4 1801 np = inet6_sk(sk);
1da177e4
LT		 1802 np->hop_limit = 255;
1803 /* Do not loopback ndisc messages */
1804 np->mc_loop = 0;
1da177e4 1805
1762f7e8
DL		 1806 return 0;
1807}
1808
2c8c1e72 1809static void __net_exit ndisc_net_exit(struct net *net)
1762f7e8 1810{
1ed8516f 1811 inet_ctl_sock_destroy(net->ipv6.ndisc_sk);
1762f7e8
DL		 1812}
1813
1814static struct pernet_operations ndisc_net_ops = {
1815 .init = ndisc_net_init,
1816 .exit = ndisc_net_exit,
1817};
1818
1819int __init ndisc_init(void)
1820{
1821 int err;
1822
1823 err = register_pernet_subsys(&ndisc_net_ops);
1824 if (err)
1825 return err;
1ab1457c
YH		 1826 /*
1827 * Initialize the neighbour table
1828 */
1da177e4
LT		 1829 neigh_table_init(&nd_tbl);
1830
1831#ifdef CONFIG_SYSCTL
54716e3b 1832 err = neigh_sysctl_register(NULL, &nd_tbl.parms, "ipv6",
f8572d8f 1833 &ndisc_ifinfo_sysctl_change);
1762f7e8
DL		 1834 if (err)
1835 goto out_unregister_pernet;
1da177e4 1836#endif
1762f7e8
DL		 1837 err = register_netdevice_notifier(&ndisc_netdev_notifier);
1838 if (err)
1839 goto out_unregister_sysctl;
1840out:
1841 return err;
1da177e4 1842
1762f7e8
DL		 1843out_unregister_sysctl:
1844#ifdef CONFIG_SYSCTL
1845 neigh_sysctl_unregister(&nd_tbl.parms);
1846out_unregister_pernet:
1847#endif
1848 unregister_pernet_subsys(&ndisc_net_ops);
1849 goto out;
1da177e4
LT		 1850}
1851
1852void ndisc_cleanup(void)
1853{
36f73d0c 1854 unregister_netdevice_notifier(&ndisc_netdev_notifier);
1da177e4
LT		 1855#ifdef CONFIG_SYSCTL
1856 neigh_sysctl_unregister(&nd_tbl.parms);
1857#endif
1858 neigh_table_clear(&nd_tbl);
1762f7e8 1859 unregister_pernet_subsys(&ndisc_net_ops);
1da177e4 1860}
Clone of davem's net-next-2.6 tree