projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[SK_BUFF]: More skb_put related skb_reset_transport_header
[deliverable/linux.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
d10ba34b
ACM		 495 skb_set_transport_header(skb, skb->tail - skb->data);
496 skb_put(skb, len);
497 msg = (struct nd_msg *)skb_transport_header(skb);
1da177e4 498
1ab1457c
YH		 499 msg->icmph.icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT;
500 msg->icmph.icmp6_code = 0;
501 msg->icmph.icmp6_cksum = 0;
1da177e4 502
1ab1457c
YH		 503 msg->icmph.icmp6_unused = 0;
504 msg->icmph.icmp6_router = router;
505 msg->icmph.icmp6_solicited = solicited;
506 msg->icmph.icmp6_override = override;
1da177e4 507
1ab1457c 508 /* Set the target address. */
1da177e4
LT		 509 ipv6_addr_copy(&msg->target, solicited_addr);
510
511 if (inc_opt)
512 ndisc_fill_addr_option(msg->opt, ND_OPT_TARGET_LL_ADDR, dev->dev_addr,
513 dev->addr_len, dev->type);
514
515 /* checksum */
1ab1457c 516 msg->icmph.icmp6_cksum = csum_ipv6_magic(src_addr, daddr, len,
1da177e4 517 IPPROTO_ICMPV6,
1ab1457c 518 csum_partial((__u8 *) msg,
1da177e4
LT		 519 len, 0));
520
521 skb->dst = dst;
522 idev = in6_dev_get(dst->dev);
a11d206d 523 IP6_INC_STATS(idev, IPSTATS_MIB_OUTREQUESTS);
1da177e4
LT		 524 err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, skb, NULL, dst->dev, dst_output);
525 if (!err) {
526 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTNEIGHBORADVERTISEMENTS);
527 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);
528 }
529
530 if (likely(idev != NULL))
531 in6_dev_put(idev);
1ab1457c 532}
1da177e4
LT		 533
534void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh,
535 struct in6_addr *solicit,
1ab1457c 536 struct in6_addr *daddr, struct in6_addr *saddr)
1da177e4
LT		 537{
538 struct flowi fl;
539 struct dst_entry* dst;
540 struct inet6_dev *idev;
1ab1457c
YH		 541 struct sock *sk = ndisc_socket->sk;
542 struct sk_buff *skb;
543 struct nd_msg *msg;
1da177e4 544 struct in6_addr addr_buf;
1ab1457c 545 int len;
1da177e4
LT		 546 int err;
547 int send_llinfo;
548
549 if (saddr == NULL) {
95c385b4
NH		 550 if (ipv6_get_lladdr(dev, &addr_buf,
551 (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
1da177e4
LT		 552 return;
553 saddr = &addr_buf;
554 }
555
af184765
YH		 556 ndisc_flow_init(&fl, NDISC_NEIGHBOUR_SOLICITATION, saddr, daddr,
557 dev->ifindex);
1da177e4
LT		 558
559 dst = ndisc_dst_alloc(dev, neigh, daddr, ip6_output);
560 if (!dst)
561 return;
562
563 err = xfrm_lookup(&dst, &fl, NULL, 0);
e104411b 564 if (err < 0)
1da177e4 565 return;
1da177e4
LT		 566
567 len = sizeof(struct icmp6hdr) + sizeof(struct in6_addr);
568 send_llinfo = dev->addr_len && !ipv6_addr_any(saddr);
569 if (send_llinfo)
570 len += ndisc_opt_addr_space(dev);
571
d54a81d3
DM		 572 skb = sock_alloc_send_skb(sk,
573 (MAX_HEADER + sizeof(struct ipv6hdr) +
574 len + LL_RESERVED_SPACE(dev)),
1da177e4
LT		 575 1, &err);
576 if (skb == NULL) {
577 ND_PRINTK0(KERN_ERR
1ab1457c 578 "ICMPv6 NA: %s() failed to allocate an skb.\n",
1da177e4
LT		 579 __FUNCTION__);
580 dst_release(dst);
581 return;
582 }
583
584 skb_reserve(skb, LL_RESERVED_SPACE(dev));
585 ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);
586
d10ba34b
ACM		 587 skb_set_transport_header(skb, skb->tail - skb->data);
588 skb_put(skb, len);
589 msg = (struct nd_msg *)skb_transport_header(skb);
1da177e4
LT		 590 msg->icmph.icmp6_type = NDISC_NEIGHBOUR_SOLICITATION;
591 msg->icmph.icmp6_code = 0;
592 msg->icmph.icmp6_cksum = 0;
593 msg->icmph.icmp6_unused = 0;
594
595 /* Set the target address. */
596 ipv6_addr_copy(&msg->target, solicit);
597
598 if (send_llinfo)
599 ndisc_fill_addr_option(msg->opt, ND_OPT_SOURCE_LL_ADDR, dev->dev_addr,
600 dev->addr_len, dev->type);
601
602 /* checksum */
0660e03f 603 msg->icmph.icmp6_cksum = csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
1ab1457c 604 daddr, len,
1da177e4 605 IPPROTO_ICMPV6,
1ab1457c 606 csum_partial((__u8 *) msg,
1da177e4
LT		 607 len, 0));
608 /* send it! */
609 skb->dst = dst;
610 idev = in6_dev_get(dst->dev);
a11d206d 611 IP6_INC_STATS(idev, IPSTATS_MIB_OUTREQUESTS);
1da177e4
LT		 612 err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, skb, NULL, dst->dev, dst_output);
613 if (!err) {
614 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTNEIGHBORSOLICITS);
615 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);
616 }
617
618 if (likely(idev != NULL))
619 in6_dev_put(idev);
620}
621
622void ndisc_send_rs(struct net_device *dev, struct in6_addr *saddr,
623 struct in6_addr *daddr)
624{
625 struct flowi fl;
626 struct dst_entry* dst;
627 struct inet6_dev *idev;
628 struct sock *sk = ndisc_socket->sk;
1ab1457c
YH		 629 struct sk_buff *skb;
630 struct icmp6hdr *hdr;
1da177e4 631 __u8 * opt;
95c385b4 632 int send_sllao = dev->addr_len;
1ab1457c 633 int len;
1da177e4
LT		 634 int err;
635
95c385b4
NH		 636
637#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
638 /*
639 * According to section 2.2 of RFC 4429, we must not
640 * send router solicitations with a sllao from
641 * optimistic addresses, but we may send the solicitation
642 * if we don't include the sllao. So here we check
643 * if our address is optimistic, and if so, we
644 * supress the inclusion of the sllao.
645 */
646 if (send_sllao) {
ca043569 647 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(saddr, dev, 1);
95c385b4
NH		 648 if (ifp) {
649 if (ifp->flags & IFA_F_OPTIMISTIC) {
ca043569 650 send_sllao = 0;
95c385b4 651 }
ca043569 652 in6_ifa_put(ifp);
95c385b4
NH		 653 } else {
654 send_sllao = 0;
655 }
656 }
657#endif
af184765
YH		 658 ndisc_flow_init(&fl, NDISC_ROUTER_SOLICITATION, saddr, daddr,
659 dev->ifindex);
1da177e4
LT		 660
661 dst = ndisc_dst_alloc(dev, NULL, daddr, ip6_output);
662 if (!dst)
663 return;
664
665 err = xfrm_lookup(&dst, &fl, NULL, 0);
e104411b 666 if (err < 0)
1da177e4 667 return;
1da177e4
LT		 668
669 len = sizeof(struct icmp6hdr);
95c385b4 670 if (send_sllao)
1da177e4
LT		 671 len += ndisc_opt_addr_space(dev);
672
1ab1457c 673 skb = sock_alloc_send_skb(sk,
d54a81d3
DM		 674 (MAX_HEADER + sizeof(struct ipv6hdr) +
675 len + LL_RESERVED_SPACE(dev)),
1da177e4
LT		 676 1, &err);
677 if (skb == NULL) {
678 ND_PRINTK0(KERN_ERR
1ab1457c 679 "ICMPv6 RS: %s() failed to allocate an skb.\n",
1da177e4
LT		 680 __FUNCTION__);
681 dst_release(dst);
682 return;
683 }
684
685 skb_reserve(skb, LL_RESERVED_SPACE(dev));
686 ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);
687
d10ba34b
ACM		 688 skb_set_transport_header(skb, skb->tail - skb->data);
689 skb_put(skb, len);
690 hdr = icmp6_hdr(skb);
1ab1457c
YH		 691 hdr->icmp6_type = NDISC_ROUTER_SOLICITATION;
692 hdr->icmp6_code = 0;
693 hdr->icmp6_cksum = 0;
694 hdr->icmp6_unused = 0;
1da177e4
LT		 695
696 opt = (u8*) (hdr + 1);
697
95c385b4 698 if (send_sllao)
1da177e4
LT		 699 ndisc_fill_addr_option(opt, ND_OPT_SOURCE_LL_ADDR, dev->dev_addr,
700 dev->addr_len, dev->type);
701
702 /* checksum */
0660e03f 703 hdr->icmp6_cksum = csum_ipv6_magic(&ipv6_hdr(skb)->saddr, daddr, len,
1da177e4
LT		 704 IPPROTO_ICMPV6,
705 csum_partial((__u8 *) hdr, len, 0));
706
707 /* send it! */
708 skb->dst = dst;
709 idev = in6_dev_get(dst->dev);
a11d206d 710 IP6_INC_STATS(idev, IPSTATS_MIB_OUTREQUESTS);
1da177e4
LT		 711 err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, skb, NULL, dst->dev, dst_output);
712 if (!err) {
713 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTROUTERSOLICITS);
714 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);
715 }
716
717 if (likely(idev != NULL))
718 in6_dev_put(idev);
719}
1ab1457c 720
1da177e4
LT		 721
722static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
723{
724 /*
725 * "The sender MUST return an ICMP
726 * destination unreachable"
727 */
728 dst_link_failure(skb);
729 kfree_skb(skb);
730}
731
732/* Called with locked neigh: either read or both */
733
734static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
735{
736 struct in6_addr *saddr = NULL;
737 struct in6_addr mcaddr;
738 struct net_device *dev = neigh->dev;
739 struct in6_addr *target = (struct in6_addr *)&neigh->primary_key;
740 int probes = atomic_read(&neigh->probes);
741
0660e03f
ACM		 742 if (skb && ipv6_chk_addr(&ipv6_hdr(skb)->saddr, dev, 1))
743 saddr = &ipv6_hdr(skb)->saddr;
1da177e4
LT		 744
745 if ((probes -= neigh->parms->ucast_probes) < 0) {
746 if (!(neigh->nud_state & NUD_VALID)) {
747 ND_PRINTK1(KERN_DEBUG
748 "%s(): trying to ucast probe in NUD_INVALID: "
46b86a2d 749 NIP6_FMT "\n",
1da177e4
LT		 750 __FUNCTION__,
751 NIP6(*target));
752 }
753 ndisc_send_ns(dev, neigh, target, target, saddr);
754 } else if ((probes -= neigh->parms->app_probes) < 0) {
755#ifdef CONFIG_ARPD
756 neigh_app_ns(neigh);
757#endif
758 } else {
759 addrconf_addr_solict_mult(target, &mcaddr);
760 ndisc_send_ns(dev, NULL, target, &mcaddr, saddr);
761 }
762}
763
764static void ndisc_recv_ns(struct sk_buff *skb)
765{
9c70220b 766 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
0660e03f
ACM		 767 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
768 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
1da177e4
LT		 769 u8 *lladdr = NULL;
770 u32 ndoptlen = skb->tail - msg->opt;
771 struct ndisc_options ndopts;
772 struct net_device *dev = skb->dev;
773 struct inet6_ifaddr *ifp;
774 struct inet6_dev *idev = NULL;
775 struct neighbour *neigh;
62dd9318 776 struct pneigh_entry *pneigh = NULL;
1da177e4
LT		 777 int dad = ipv6_addr_any(saddr);
778 int inc;
62dd9318 779 int is_router;
1da177e4
LT		 780
781 if (ipv6_addr_is_multicast(&msg->target)) {
1ab1457c 782 ND_PRINTK2(KERN_WARNING
1da177e4
LT		 783 "ICMPv6 NS: multicast target address");
784 return;
785 }
786
787 /*
788 * RFC2461 7.1.1:
789 * DAD has to be destined for solicited node multicast address.
790 */
791 if (dad &&
792 !(daddr->s6_addr32[0] == htonl(0xff020000) &&
793 daddr->s6_addr32[1] == htonl(0x00000000) &&
794 daddr->s6_addr32[2] == htonl(0x00000001) &&
795 daddr->s6_addr [12] == 0xff )) {
796 ND_PRINTK2(KERN_WARNING
797 "ICMPv6 NS: bad DAD packet (wrong destination)\n");
798 return;
799 }
800
801 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
1ab1457c 802 ND_PRINTK2(KERN_WARNING
1da177e4
LT		 803 "ICMPv6 NS: invalid ND options\n");
804 return;
805 }
806
807 if (ndopts.nd_opts_src_lladdr) {
808 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
809 if (!lladdr) {
810 ND_PRINTK2(KERN_WARNING
811 "ICMPv6 NS: invalid link-layer address length\n");
812 return;
813 }
814
815 /* RFC2461 7.1.1:
1ab1457c
YH		 816 * If the IP source address is the unspecified address,
817 * there MUST NOT be source link-layer address option
1da177e4
LT		 818 * in the message.
819 */
820 if (dad) {
1ab1457c 821 ND_PRINTK2(KERN_WARNING
1da177e4
LT		 822 "ICMPv6 NS: bad DAD packet (link-layer address option)\n");
823 return;
824 }
825 }
826
827 inc = ipv6_addr_is_multicast(daddr);
828
829 if ((ifp = ipv6_get_ifaddr(&msg->target, dev, 1)) != NULL) {
95c385b4
NH		 830
831 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
832 if (dad) {
833 if (dev->type == ARPHRD_IEEE802_TR) {
98e399f8
ACM		 834 const unsigned char *sadr;
835 sadr = skb_mac_header(skb);
95c385b4
NH		 836 if (((sadr[8] ^ dev->dev_addr[0]) & 0x7f) == 0 &&
837 sadr[9] == dev->dev_addr[1] &&
838 sadr[10] == dev->dev_addr[2] &&
839 sadr[11] == dev->dev_addr[3] &&
840 sadr[12] == dev->dev_addr[4] &&
841 sadr[13] == dev->dev_addr[5]) {
842 /* looped-back to us */
843 goto out;
844 }
845 }
846
847 /*
848 * We are colliding with another node
849 * who is doing DAD
850 * so fail our DAD process
851 */
852 addrconf_dad_failure(ifp);
1da177e4 853 goto out;
95c385b4
NH		 854 } else {
855 /*
856 * This is not a dad solicitation.
857 * If we are an optimistic node,
858 * we should respond.
859 * Otherwise, we should ignore it.
860 */
861 if (!(ifp->flags & IFA_F_OPTIMISTIC))
1da177e4 862 goto out;
1da177e4 863 }
1da177e4
LT		 864 }
865
866 idev = ifp->idev;
867 } else {
868 idev = in6_dev_get(dev);
869 if (!idev) {
870 /* XXX: count this drop? */
871 return;
872 }
873
874 if (ipv6_chk_acast_addr(dev, &msg->target) ||
1ab1457c 875 (idev->cnf.forwarding &&
fbea49e1 876 (ipv6_devconf.proxy_ndp || idev->cnf.proxy_ndp) &&
62dd9318
VN		 877 (pneigh = pneigh_lookup(&nd_tbl,
878 &msg->target, dev, 0)) != NULL)) {
a61bbcf2 879 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
1da177e4
LT		 880 skb->pkt_type != PACKET_HOST &&
881 inc != 0 &&
882 idev->nd_parms->proxy_delay != 0) {
883 /*
884 * for anycast or proxy,
1ab1457c
YH		 885 * sender should delay its response
886 * by a random time between 0 and
1da177e4
LT		 887 * MAX_ANYCAST_DELAY_TIME seconds.
888 * (RFC2461) -- yoshfuji
889 */
890 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
891 if (n)
892 pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
893 goto out;
894 }
895 } else
896 goto out;
897 }
898
fc26d0ab 899 is_router = !!(pneigh ? pneigh->flags & NTF_ROUTER : idev->cnf.forwarding);
62dd9318 900
1da177e4
LT		 901 if (dad) {
902 struct in6_addr maddr;
903
904 ipv6_addr_all_nodes(&maddr);
905 ndisc_send_na(dev, NULL, &maddr, &msg->target,
62dd9318 906 is_router, 0, (ifp != NULL), 1);
1da177e4
LT		 907 goto out;
908 }
909
910 if (inc)
911 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
912 else
913 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
914
1ab1457c 915 /*
1da177e4
LT		 916 * update / create cache entry
917 * for the source address
918 */
919 neigh = __neigh_lookup(&nd_tbl, saddr, dev,
920 !inc || lladdr || !dev->addr_len);
921 if (neigh)
1ab1457c 922 neigh_update(neigh, lladdr, NUD_STALE,
1da177e4
LT		 923 NEIGH_UPDATE_F_WEAK_OVERRIDE|
924 NEIGH_UPDATE_F_OVERRIDE);
925 if (neigh || !dev->hard_header) {
926 ndisc_send_na(dev, neigh, saddr, &msg->target,
62dd9318 927 is_router,
1da177e4
LT		 928 1, (ifp != NULL && inc), inc);
929 if (neigh)
930 neigh_release(neigh);
931 }
932
933out:
934 if (ifp)
935 in6_ifa_put(ifp);
936 else
937 in6_dev_put(idev);
938
939 return;
940}
941
942static void ndisc_recv_na(struct sk_buff *skb)
943{
9c70220b 944 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
0660e03f
ACM		 945 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
946 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
1da177e4
LT		 947 u8 *lladdr = NULL;
948 u32 ndoptlen = skb->tail - msg->opt;
949 struct ndisc_options ndopts;
950 struct net_device *dev = skb->dev;
951 struct inet6_ifaddr *ifp;
952 struct neighbour *neigh;
953
954 if (skb->len < sizeof(struct nd_msg)) {
955 ND_PRINTK2(KERN_WARNING
956 "ICMPv6 NA: packet too short\n");
957 return;
958 }
959
960 if (ipv6_addr_is_multicast(&msg->target)) {
961 ND_PRINTK2(KERN_WARNING
962 "ICMPv6 NA: target address is multicast.\n");
963 return;
964 }
965
966 if (ipv6_addr_is_multicast(daddr) &&
967 msg->icmph.icmp6_solicited) {
968 ND_PRINTK2(KERN_WARNING
969 "ICMPv6 NA: solicited NA is multicasted.\n");
970 return;
971 }
1ab1457c 972
1da177e4
LT		 973 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
974 ND_PRINTK2(KERN_WARNING
975 "ICMPv6 NS: invalid ND option\n");
976 return;
977 }
978 if (ndopts.nd_opts_tgt_lladdr) {
979 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
980 if (!lladdr) {
981 ND_PRINTK2(KERN_WARNING
982 "ICMPv6 NA: invalid link-layer address length\n");
983 return;
984 }
985 }
986 if ((ifp = ipv6_get_ifaddr(&msg->target, dev, 1))) {
987 if (ifp->flags & IFA_F_TENTATIVE) {
988 addrconf_dad_failure(ifp);
989 return;
990 }
991 /* What should we make now? The advertisement
992 is invalid, but ndisc specs say nothing
993 about it. It could be misconfiguration, or
994 an smart proxy agent tries to help us :-)
995 */
996 ND_PRINTK1(KERN_WARNING
997 "ICMPv6 NA: someone advertises our address on %s!\n",
998 ifp->idev->dev->name);
999 in6_ifa_put(ifp);
1000 return;
1001 }
1002 neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
1003
1004 if (neigh) {
1005 u8 old_flags = neigh->flags;
1006
1007 if (neigh->nud_state & NUD_FAILED)
1008 goto out;
1009
5f3e6e9e
VN		 1010 /*
1011 * Don't update the neighbor cache entry on a proxy NA from
1012 * ourselves because either the proxied node is off link or it
1013 * has already sent a NA to us.
1014 */
1015 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
fbea49e1
YH		 1016 ipv6_devconf.forwarding && ipv6_devconf.proxy_ndp &&
1017 pneigh_lookup(&nd_tbl, &msg->target, dev, 0)) {
1018 /* XXX: idev->cnf.prixy_ndp */
5f3e6e9e 1019 goto out;
fbea49e1 1020 }
5f3e6e9e 1021
1da177e4
LT		 1022 neigh_update(neigh, lladdr,
1023 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
1024 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1025 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
1026 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1027 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));
1028
1029 if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
1030 /*
1031 * Change: router to host
1032 */
1033 struct rt6_info *rt;
1034 rt = rt6_get_dflt_router(saddr, dev);
1035 if (rt)
e0a1ad73 1036 ip6_del_rt(rt);
1da177e4
LT		 1037 }
1038
1039out:
1040 neigh_release(neigh);
1041 }
1042}
1043
1044static void ndisc_recv_rs(struct sk_buff *skb)
1045{
9c70220b 1046 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
1da177e4
LT		 1047 unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
1048 struct neighbour *neigh;
1049 struct inet6_dev *idev;
0660e03f 1050 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
1da177e4
LT		 1051 struct ndisc_options ndopts;
1052 u8 *lladdr = NULL;
1053
1054 if (skb->len < sizeof(*rs_msg))
1055 return;
1056
1057 idev = in6_dev_get(skb->dev);
1058 if (!idev) {
1059 if (net_ratelimit())
1060 ND_PRINTK1("ICMP6 RS: can't find in6 device\n");
1061 return;
1062 }
1063
1064 /* Don't accept RS if we're not in router mode */
1065 if (!idev->cnf.forwarding)
1066 goto out;
1067
1068 /*
1069 * Don't update NCE if src = ::;
1070 * this implies that the source node has no ip address assigned yet.
1071 */
1072 if (ipv6_addr_any(saddr))
1073 goto out;
1074
1075 /* Parse ND options */
1076 if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {
1077 if (net_ratelimit())
1078 ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n");
1079 goto out;
1080 }
1081
1082 if (ndopts.nd_opts_src_lladdr) {
1083 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1084 skb->dev);
1085 if (!lladdr)
1086 goto out;
1087 }
1088
1089 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
1090 if (neigh) {
1091 neigh_update(neigh, lladdr, NUD_STALE,
1092 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1093 NEIGH_UPDATE_F_OVERRIDE|
1094 NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
1095 neigh_release(neigh);
1096 }
1097out:
1098 in6_dev_put(idev);
1099}
1100
1101static void ndisc_router_discovery(struct sk_buff *skb)
1102{
9c70220b 1103 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
1da177e4
LT		 1104 struct neighbour *neigh = NULL;
1105 struct inet6_dev *in6_dev;
65f5c7c1 1106 struct rt6_info *rt = NULL;
1da177e4
LT		 1107 int lifetime;
1108 struct ndisc_options ndopts;
1109 int optlen;
ebacaaa0 1110 unsigned int pref = 0;
1da177e4
LT		 1111
1112 __u8 * opt = (__u8 *)(ra_msg + 1);
1113
9c70220b
ACM		 1114 optlen = (skb->tail - skb_transport_header(skb)) -
1115 sizeof(struct ra_msg);
1da177e4 1116
0660e03f 1117 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1da177e4
LT		 1118 ND_PRINTK2(KERN_WARNING
1119 "ICMPv6 RA: source address is not link-local.\n");
1120 return;
1121 }
1122 if (optlen < 0) {
1ab1457c 1123 ND_PRINTK2(KERN_WARNING
1da177e4
LT		 1124 "ICMPv6 RA: packet too short\n");
1125 return;
1126 }
1127
1128 /*
1129 * set the RA_RECV flag in the interface
1130 */
1131
1132 in6_dev = in6_dev_get(skb->dev);
1133 if (in6_dev == NULL) {
1134 ND_PRINTK0(KERN_ERR
1135 "ICMPv6 RA: can't find inet6 device for %s.\n",
1136 skb->dev->name);
1137 return;
1138 }
1139 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_ra) {
1140 in6_dev_put(in6_dev);
1141 return;
1142 }
1143
1144 if (!ndisc_parse_options(opt, optlen, &ndopts)) {
1145 in6_dev_put(in6_dev);
1146 ND_PRINTK2(KERN_WARNING
1147 "ICMP6 RA: invalid ND options\n");
1148 return;
1149 }
1150
1151 if (in6_dev->if_flags & IF_RS_SENT) {
1152 /*
1153 * flag that an RA was received after an RS was sent
1154 * out on this interface.
1155 */
1156 in6_dev->if_flags |= IF_RA_RCVD;
1157 }
1158
1159 /*
1160 * Remember the managed/otherconf flags from most recently
1161 * received RA message (RFC 2462) -- yoshfuji
1162 */
1163 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1164 IF_RA_OTHERCONF)) |
1165 (ra_msg->icmph.icmp6_addrconf_managed ?
1166 IF_RA_MANAGED : 0) |
1167 (ra_msg->icmph.icmp6_addrconf_other ?
1168 IF_RA_OTHERCONF : 0);
1169
65f5c7c1
YH		 1170 if (!in6_dev->cnf.accept_ra_defrtr)
1171 goto skip_defrtr;
1172
1da177e4
LT		 1173 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1174
ebacaaa0
YH		 1175#ifdef CONFIG_IPV6_ROUTER_PREF
1176 pref = ra_msg->icmph.icmp6_router_pref;
1177 /* 10b is handled as if it were 00b (medium) */
930d6ff2
YH		 1178 if (pref == ICMPV6_ROUTER_PREF_INVALID ||
1179 in6_dev->cnf.accept_ra_rtr_pref)
ebacaaa0
YH		 1180 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1181#endif
1182
0660e03f 1183 rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
1da177e4
LT		 1184
1185 if (rt)
1186 neigh = rt->rt6i_nexthop;
1187
1188 if (rt && lifetime == 0) {
1189 neigh_clone(neigh);
e0a1ad73 1190 ip6_del_rt(rt);
1da177e4
LT		 1191 rt = NULL;
1192 }
1193
1194 if (rt == NULL && lifetime) {
1195 ND_PRINTK3(KERN_DEBUG
1196 "ICMPv6 RA: adding default router.\n");
1197
0660e03f 1198 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
1da177e4
LT		 1199 if (rt == NULL) {
1200 ND_PRINTK0(KERN_ERR
1201 "ICMPv6 RA: %s() failed to add default route.\n",
1202 __FUNCTION__);
1203 in6_dev_put(in6_dev);
1204 return;
1205 }
1206
1207 neigh = rt->rt6i_nexthop;
1208 if (neigh == NULL) {
1209 ND_PRINTK0(KERN_ERR
1210 "ICMPv6 RA: %s() got default router without neighbour.\n",
1211 __FUNCTION__);
1212 dst_release(&rt->u.dst);
1213 in6_dev_put(in6_dev);
1214 return;
1215 }
1216 neigh->flags |= NTF_ROUTER;
ebacaaa0
YH		 1217 } else if (rt) {
1218 rt->rt6i_flags |= (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
1da177e4
LT		 1219 }
1220
1221 if (rt)
1222 rt->rt6i_expires = jiffies + (HZ * lifetime);
1223
1224 if (ra_msg->icmph.icmp6_hop_limit) {
1225 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1226 if (rt)
1227 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = ra_msg->icmph.icmp6_hop_limit;
1228 }
1229
65f5c7c1
YH		 1230skip_defrtr:
1231
1da177e4
LT		 1232 /*
1233 * Update Reachable Time and Retrans Timer
1234 */
1235
1236 if (in6_dev->nd_parms) {
1237 unsigned long rtime = ntohl(ra_msg->retrans_timer);
1238
1239 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1240 rtime = (rtime*HZ)/1000;
1241 if (rtime < HZ/10)
1242 rtime = HZ/10;
1243 in6_dev->nd_parms->retrans_time = rtime;
1244 in6_dev->tstamp = jiffies;
1245 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1246 }
1247
1248 rtime = ntohl(ra_msg->reachable_time);
1249 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1250 rtime = (rtime*HZ)/1000;
1251
1252 if (rtime < HZ/10)
1253 rtime = HZ/10;
1254
1255 if (rtime != in6_dev->nd_parms->base_reachable_time) {
1256 in6_dev->nd_parms->base_reachable_time = rtime;
1257 in6_dev->nd_parms->gc_staletime = 3 * rtime;
1258 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1259 in6_dev->tstamp = jiffies;
1260 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1261 }
1262 }
1263 }
1264
1265 /*
1266 * Process options.
1267 */
1268
1269 if (!neigh)
0660e03f 1270 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
1da177e4
LT		 1271 skb->dev, 1);
1272 if (neigh) {
1273 u8 *lladdr = NULL;
1274 if (ndopts.nd_opts_src_lladdr) {
1275 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1276 skb->dev);
1277 if (!lladdr) {
1278 ND_PRINTK2(KERN_WARNING
1279 "ICMPv6 RA: invalid link-layer address length\n");
1280 goto out;
1281 }
1282 }
1283 neigh_update(neigh, lladdr, NUD_STALE,
1284 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1285 NEIGH_UPDATE_F_OVERRIDE|
1286 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1287 NEIGH_UPDATE_F_ISROUTER);
1288 }
1289
70ceb4f5 1290#ifdef CONFIG_IPV6_ROUTE_INFO
09c884d4 1291 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
70ceb4f5
YH		 1292 struct nd_opt_hdr *p;
1293 for (p = ndopts.nd_opts_ri;
1294 p;
1295 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
09c884d4
YH		 1296 if (((struct route_info *)p)->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
1297 continue;
70ceb4f5 1298 rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3,
0660e03f 1299 &ipv6_hdr(skb)->saddr);
70ceb4f5
YH		 1300 }
1301 }
1302#endif
1303
c4fd30eb 1304 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
1da177e4
LT		 1305 struct nd_opt_hdr *p;
1306 for (p = ndopts.nd_opts_pi;
1307 p;
1308 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1309 addrconf_prefix_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3);
1310 }
1311 }
1312
1313 if (ndopts.nd_opts_mtu) {
e69a4adc 1314 __be32 n;
1da177e4
LT		 1315 u32 mtu;
1316
e69a4adc
AV		 1317 memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1318 mtu = ntohl(n);
1da177e4
LT		 1319
1320 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1321 ND_PRINTK2(KERN_WARNING
1322 "ICMPv6 RA: invalid mtu: %d\n",
1323 mtu);
1324 } else if (in6_dev->cnf.mtu6 != mtu) {
1325 in6_dev->cnf.mtu6 = mtu;
1326
1327 if (rt)
1328 rt->u.dst.metrics[RTAX_MTU-1] = mtu;
1329
1330 rt6_mtu_change(skb->dev, mtu);
1331 }
1332 }
1ab1457c 1333
1da177e4
LT		 1334 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1335 ND_PRINTK2(KERN_WARNING
1336 "ICMPv6 RA: invalid RA options");
1337 }
1338out:
1339 if (rt)
1340 dst_release(&rt->u.dst);
1341 else if (neigh)
1342 neigh_release(neigh);
1343 in6_dev_put(in6_dev);
1344}
1345
1346static void ndisc_redirect_rcv(struct sk_buff *skb)
1347{
1348 struct inet6_dev *in6_dev;
1349 struct icmp6hdr *icmph;
1350 struct in6_addr *dest;
1351 struct in6_addr *target; /* new first hop to destination */
1352 struct neighbour *neigh;
1353 int on_link = 0;
1354 struct ndisc_options ndopts;
1355 int optlen;
1356 u8 *lladdr = NULL;
1357
0660e03f 1358 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1da177e4
LT		 1359 ND_PRINTK2(KERN_WARNING
1360 "ICMPv6 Redirect: source address is not link-local.\n");
1361 return;
1362 }
1363
9c70220b 1364 optlen = skb->tail - skb_transport_header(skb);
1da177e4
LT		 1365 optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1366
1367 if (optlen < 0) {
1368 ND_PRINTK2(KERN_WARNING
1369 "ICMPv6 Redirect: packet too short\n");
1370 return;
1371 }
1372
cc70ab26 1373 icmph = icmp6_hdr(skb);
1da177e4
LT		 1374 target = (struct in6_addr *) (icmph + 1);
1375 dest = target + 1;
1376
1377 if (ipv6_addr_is_multicast(dest)) {
1378 ND_PRINTK2(KERN_WARNING
1379 "ICMPv6 Redirect: destination address is multicast.\n");
1380 return;
1381 }
1382
1383 if (ipv6_addr_equal(dest, target)) {
1384 on_link = 1;
1385 } else if (!(ipv6_addr_type(target) & IPV6_ADDR_LINKLOCAL)) {
1ab1457c 1386 ND_PRINTK2(KERN_WARNING
1da177e4
LT		 1387 "ICMPv6 Redirect: target address is not link-local.\n");
1388 return;
1389 }
1390
1391 in6_dev = in6_dev_get(skb->dev);
1392 if (!in6_dev)
1393 return;
1394 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects) {
1395 in6_dev_put(in6_dev);
1396 return;
1397 }
1398
1ab1457c 1399 /* RFC2461 8.1:
1da177e4
LT		 1400 * The IP source address of the Redirect MUST be the same as the current
1401 * first-hop router for the specified ICMP Destination Address.
1402 */
1ab1457c 1403
1da177e4
LT		 1404 if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) {
1405 ND_PRINTK2(KERN_WARNING
1406 "ICMPv6 Redirect: invalid ND options\n");
1407 in6_dev_put(in6_dev);
1408 return;
1409 }
1410 if (ndopts.nd_opts_tgt_lladdr) {
1411 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1412 skb->dev);
1413 if (!lladdr) {
1414 ND_PRINTK2(KERN_WARNING
1415 "ICMPv6 Redirect: invalid link-layer address length\n");
1416 in6_dev_put(in6_dev);
1417 return;
1418 }
1419 }
1420
1421 neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1);
1422 if (neigh) {
0660e03f
ACM		 1423 rt6_redirect(dest, &ipv6_hdr(skb)->daddr,
1424 &ipv6_hdr(skb)->saddr, neigh, lladdr,
1da177e4
LT		 1425 on_link);
1426 neigh_release(neigh);
1427 }
1428 in6_dev_put(in6_dev);
1429}
1430
1431void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh,
1432 struct in6_addr *target)
1433{
1434 struct sock *sk = ndisc_socket->sk;
1435 int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1436 struct sk_buff *buff;
1437 struct icmp6hdr *icmph;
1438 struct in6_addr saddr_buf;
1439 struct in6_addr *addrp;
1440 struct net_device *dev;
1441 struct rt6_info *rt;
1442 struct dst_entry *dst;
1443 struct inet6_dev *idev;
1444 struct flowi fl;
1445 u8 *opt;
1446 int rd_len;
1447 int err;
1448 int hlen;
1449 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1450
1451 dev = skb->dev;
1452
95c385b4 1453 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
1da177e4
LT		 1454 ND_PRINTK2(KERN_WARNING
1455 "ICMPv6 Redirect: no link-local address on %s\n",
1456 dev->name);
1ab1457c
YH		 1457 return;
1458 }
1da177e4 1459
0660e03f 1460 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
29556526
LY		 1461 !(ipv6_addr_type(target) & IPV6_ADDR_LINKLOCAL)) {
1462 ND_PRINTK2(KERN_WARNING
1463 "ICMPv6 Redirect: target address is not link-local.\n");
1464 return;
1465 }
1466
0660e03f 1467 ndisc_flow_init(&fl, NDISC_REDIRECT, &saddr_buf, &ipv6_hdr(skb)->saddr,
af184765 1468 dev->ifindex);
1da177e4
LT		 1469
1470 dst = ip6_route_output(NULL, &fl);
1471 if (dst == NULL)
1472 return;
1473
1474 err = xfrm_lookup(&dst, &fl, NULL, 0);
e104411b 1475 if (err)
1da177e4 1476 return;
1da177e4
LT		 1477
1478 rt = (struct rt6_info *) dst;
1479
1480 if (rt->rt6i_flags & RTF_GATEWAY) {
1481 ND_PRINTK2(KERN_WARNING
1482 "ICMPv6 Redirect: destination is not a neighbour.\n");
1483 dst_release(dst);
1484 return;
1485 }
1486 if (!xrlim_allow(dst, 1*HZ)) {
1487 dst_release(dst);
1488 return;
1489 }
1490
1491 if (dev->addr_len) {
1492 read_lock_bh(&neigh->lock);
1493 if (neigh->nud_state & NUD_VALID) {
1494 memcpy(ha_buf, neigh->ha, dev->addr_len);
1495 read_unlock_bh(&neigh->lock);
1496 ha = ha_buf;
1497 len += ndisc_opt_addr_space(dev);
1498 } else
1499 read_unlock_bh(&neigh->lock);
1500 }
1501
1502 rd_len = min_t(unsigned int,
1503 IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8);
1504 rd_len &= ~0x7;
1505 len += rd_len;
1506
d54a81d3
DM		 1507 buff = sock_alloc_send_skb(sk,
1508 (MAX_HEADER + sizeof(struct ipv6hdr) +
1509 len + LL_RESERVED_SPACE(dev)),
1da177e4
LT		 1510 1, &err);
1511 if (buff == NULL) {
1512 ND_PRINTK0(KERN_ERR
1513 "ICMPv6 Redirect: %s() failed to allocate an skb.\n",
1514 __FUNCTION__);
1515 dst_release(dst);
1516 return;
1517 }
1518
1519 hlen = 0;
1520
1521 skb_reserve(buff, LL_RESERVED_SPACE(dev));
0660e03f 1522 ip6_nd_hdr(sk, buff, dev, &saddr_buf, &ipv6_hdr(skb)->saddr,
1da177e4
LT		 1523 IPPROTO_ICMPV6, len);
1524
d10ba34b
ACM		 1525 skb_set_transport_header(buff, buff->tail - buff->data);
1526 skb_put(buff, len);
1527 icmph = icmp6_hdr(buff);
1da177e4
LT		 1528
1529 memset(icmph, 0, sizeof(struct icmp6hdr));
1530 icmph->icmp6_type = NDISC_REDIRECT;
1531
1532 /*
1533 * copy target and destination addresses
1534 */
1535
1536 addrp = (struct in6_addr *)(icmph + 1);
1537 ipv6_addr_copy(addrp, target);
1538 addrp++;
0660e03f 1539 ipv6_addr_copy(addrp, &ipv6_hdr(skb)->daddr);
1da177e4
LT		 1540
1541 opt = (u8*) (addrp + 1);
1542
1543 /*
1544 * include target_address option
1545 */
1546
1547 if (ha)
1548 opt = ndisc_fill_addr_option(opt, ND_OPT_TARGET_LL_ADDR, ha,
1549 dev->addr_len, dev->type);
1550
1551 /*
1552 * build redirect option and copy skb over to the new packet.
1553 */
1554
1ab1457c 1555 memset(opt, 0, 8);
1da177e4
LT		 1556 *(opt++) = ND_OPT_REDIRECT_HDR;
1557 *(opt++) = (rd_len >> 3);
1558 opt += 6;
1559
0660e03f 1560 memcpy(opt, ipv6_hdr(skb), rd_len - 8);
1da177e4 1561
0660e03f 1562 icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &ipv6_hdr(skb)->saddr,
1da177e4
LT		 1563 len, IPPROTO_ICMPV6,
1564 csum_partial((u8 *) icmph, len, 0));
1565
1566 buff->dst = dst;
1567 idev = in6_dev_get(dst->dev);
a11d206d 1568 IP6_INC_STATS(idev, IPSTATS_MIB_OUTREQUESTS);
1da177e4
LT		 1569 err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, buff, NULL, dst->dev, dst_output);
1570 if (!err) {
1571 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTREDIRECTS);
1572 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);
1573 }
1574
1575 if (likely(idev != NULL))
1576 in6_dev_put(idev);
1577}
1578
1579static void pndisc_redo(struct sk_buff *skb)
1580{
140e26fc 1581 ndisc_recv_ns(skb);
1da177e4
LT		 1582 kfree_skb(skb);
1583}
1584
1585int ndisc_rcv(struct sk_buff *skb)
1586{
1587 struct nd_msg *msg;
1588
1589 if (!pskb_may_pull(skb, skb->len))
1590 return 0;
1591
9c70220b 1592 msg = (struct nd_msg *)skb_transport_header(skb);
1da177e4 1593
9c70220b 1594 __skb_push(skb, skb->data - skb_transport_header(skb));
1da177e4 1595
0660e03f 1596 if (ipv6_hdr(skb)->hop_limit != 255) {
1da177e4
LT		 1597 ND_PRINTK2(KERN_WARNING
1598 "ICMPv6 NDISC: invalid hop-limit: %d\n",
0660e03f 1599 ipv6_hdr(skb)->hop_limit);
1da177e4
LT		 1600 return 0;
1601 }
1602
1603 if (msg->icmph.icmp6_code != 0) {
1ab1457c 1604 ND_PRINTK2(KERN_WARNING
1da177e4
LT		 1605 "ICMPv6 NDISC: invalid ICMPv6 code: %d\n",
1606 msg->icmph.icmp6_code);
1607 return 0;
1608 }
1609
a61bbcf2
PM		 1610 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1611
1da177e4
LT		 1612 switch (msg->icmph.icmp6_type) {
1613 case NDISC_NEIGHBOUR_SOLICITATION:
1614 ndisc_recv_ns(skb);
1615 break;
1616
1617 case NDISC_NEIGHBOUR_ADVERTISEMENT:
1618 ndisc_recv_na(skb);
1619 break;
1620
1621 case NDISC_ROUTER_SOLICITATION:
1622 ndisc_recv_rs(skb);
1623 break;
1624
1625 case NDISC_ROUTER_ADVERTISEMENT:
1626 ndisc_router_discovery(skb);
1627 break;
1628
1629 case NDISC_REDIRECT:
1630 ndisc_redirect_rcv(skb);
1631 break;
1632 };
1633
1634 return 0;
1635}
1636
1637static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1638{
1639 struct net_device *dev = ptr;
1640
1641 switch (event) {
1642 case NETDEV_CHANGEADDR:
1643 neigh_changeaddr(&nd_tbl, dev);
1644 fib6_run_gc(~0UL);
1645 break;
1646 case NETDEV_DOWN:
1647 neigh_ifdown(&nd_tbl, dev);
1648 fib6_run_gc(~0UL);
1649 break;
1650 default:
1651 break;
1652 }
1653
1654 return NOTIFY_DONE;
1655}
1656
1657static struct notifier_block ndisc_netdev_notifier = {
1658 .notifier_call = ndisc_netdev_event,
1659};
1660
1661#ifdef CONFIG_SYSCTL
1662static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1663 const char *func, const char *dev_name)
1664{
1665 static char warncomm[TASK_COMM_LEN];
1666 static int warned;
1667 if (strcmp(warncomm, current->comm) && warned < 5) {
1668 strcpy(warncomm, current->comm);
1669 printk(KERN_WARNING
1670 "process `%s' is using deprecated sysctl (%s) "
1671 "net.ipv6.neigh.%s.%s; "
1672 "Use net.ipv6.neigh.%s.%s_ms "
1673 "instead.\n",
1674 warncomm, func,
1675 dev_name, ctl->procname,
1676 dev_name, ctl->procname);
1677 warned++;
1678 }
1679}
1680
1681int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, struct file * filp, void __user *buffer, size_t *lenp, loff_t *ppos)
1682{
1683 struct net_device *dev = ctl->extra1;
1684 struct inet6_dev *idev;
1685 int ret;
1686
1687 if (ctl->ctl_name == NET_NEIGH_RETRANS_TIME ||
1688 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME)
1689 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1690
1691 switch (ctl->ctl_name) {
1692 case NET_NEIGH_RETRANS_TIME:
1693 ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1694 break;
1695 case NET_NEIGH_REACHABLE_TIME:
1696 ret = proc_dointvec_jiffies(ctl, write,
1697 filp, buffer, lenp, ppos);
1698 break;
1699 case NET_NEIGH_RETRANS_TIME_MS:
1700 case NET_NEIGH_REACHABLE_TIME_MS:
1701 ret = proc_dointvec_ms_jiffies(ctl, write,
1702 filp, buffer, lenp, ppos);
1703 break;
1704 default:
1705 ret = -1;
1706 }
1707
1708 if (write && ret == 0 && 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 return ret;
1717}
1718
1719static int ndisc_ifinfo_sysctl_strategy(ctl_table *ctl, int __user *name,
1720 int nlen, void __user *oldval,
1721 size_t __user *oldlenp,
1f29bcd7 1722 void __user *newval, size_t newlen)
1da177e4
LT		 1723{
1724 struct net_device *dev = ctl->extra1;
1725 struct inet6_dev *idev;
1726 int ret;
1727
1728 if (ctl->ctl_name == NET_NEIGH_RETRANS_TIME ||
1729 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME)
1730 ndisc_warn_deprecated_sysctl(ctl, "procfs", dev ? dev->name : "default");
1731
1732 switch (ctl->ctl_name) {
1733 case NET_NEIGH_REACHABLE_TIME:
1734 ret = sysctl_jiffies(ctl, name, nlen,
1f29bcd7 1735 oldval, oldlenp, newval, newlen);
1da177e4
LT		 1736 break;
1737 case NET_NEIGH_RETRANS_TIME_MS:
1738 case NET_NEIGH_REACHABLE_TIME_MS:
1739 ret = sysctl_ms_jiffies(ctl, name, nlen,
1f29bcd7 1740 oldval, oldlenp, newval, newlen);
1da177e4
LT		 1741 break;
1742 default:
1743 ret = 0;
1744 }
1745
1746 if (newval && newlen && ret > 0 &&
1747 dev && (idev = in6_dev_get(dev)) != NULL) {
1748 if (ctl->ctl_name == NET_NEIGH_REACHABLE_TIME ||
1749 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME_MS)
1750 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1751 idev->tstamp = jiffies;
1752 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1753 in6_dev_put(idev);
1754 }
1755
1756 return ret;
1757}
1758
1759#endif
1760
1761int __init ndisc_init(struct net_proto_family *ops)
1762{
1763 struct ipv6_pinfo *np;
1764 struct sock *sk;
1ab1457c 1765 int err;
1da177e4
LT		 1766
1767 err = sock_create_kern(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6, &ndisc_socket);
1768 if (err < 0) {
1769 ND_PRINTK0(KERN_ERR
1ab1457c 1770 "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",
1da177e4
LT		 1771 err);
1772 ndisc_socket = NULL; /* For safety. */
1773 return err;
1774 }
1775
1776 sk = ndisc_socket->sk;
1777 np = inet6_sk(sk);
1778 sk->sk_allocation = GFP_ATOMIC;
1779 np->hop_limit = 255;
1780 /* Do not loopback ndisc messages */
1781 np->mc_loop = 0;
1782 sk->sk_prot->unhash(sk);
1783
1ab1457c
YH		 1784 /*
1785 * Initialize the neighbour table
1786 */
1787
1da177e4
LT		 1788 neigh_table_init(&nd_tbl);
1789
1790#ifdef CONFIG_SYSCTL
1ab1457c 1791 neigh_sysctl_register(NULL, &nd_tbl.parms, NET_IPV6, NET_IPV6_NEIGH,
1da177e4
LT		 1792 "ipv6",
1793 &ndisc_ifinfo_sysctl_change,
1794 &ndisc_ifinfo_sysctl_strategy);
1795#endif
1796
1797 register_netdevice_notifier(&ndisc_netdev_notifier);
1798 return 0;
1799}
1800
1801void ndisc_cleanup(void)
1802{
36f73d0c 1803 unregister_netdevice_notifier(&ndisc_netdev_notifier);
1da177e4
LT		 1804#ifdef CONFIG_SYSCTL
1805 neigh_sysctl_unregister(&nd_tbl.parms);
1806#endif
1807 neigh_table_clear(&nd_tbl);
1808 sock_release(ndisc_socket);
1809 ndisc_socket = NULL; /* For safety. */
1810}
Linux kernel - Deliverables
This page took 0.310067 seconds and 5 git commands to generate.