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