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