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