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