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