2 * Neighbour Discovery for IPv6
3 * Linux INET6 implementation
6 * Pedro Roque <roque@di.fc.ul.pt>
7 * Mike Shaver <shaver@ingenia.com>
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.
18 * Lars Fenneberg : fixed MTU setting on receipt
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
28 /* Set to 3 to get tracing... */
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
39 #define ND_PRINTK1 ND_PRINTK
43 #define ND_PRINTK2 ND_PRINTK
47 #define ND_PRINTK3 ND_PRINTK
50 #include <linux/module.h>
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>
62 #include <linux/sysctl.h>
65 #include <linux/if_addr.h>
66 #include <linux/if_arp.h>
67 #include <linux/ipv6.h>
68 #include <linux/icmpv6.h>
69 #include <linux/jhash.h>
75 #include <net/protocol.h>
76 #include <net/ndisc.h>
77 #include <net/ip6_route.h>
78 #include <net/addrconf.h>
82 #include <net/ip6_checksum.h>
83 #include <linux/proc_fs.h>
85 #include <linux/netfilter.h>
86 #include <linux/netfilter_ipv6.h>
88 static struct socket *ndisc_socket;
90 static u32 ndisc_hash(const void *pkey, const struct net_device *dev);
91 static int ndisc_constructor(struct neighbour *neigh);
92 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb);
93 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb);
94 static int pndisc_constructor(struct pneigh_entry *n);
95 static void pndisc_destructor(struct pneigh_entry *n);
96 static void pndisc_redo(struct sk_buff *skb);
98 static struct neigh_ops ndisc_generic_ops = {
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,
108 static struct neigh_ops ndisc_hh_ops = {
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,
119 static struct neigh_ops ndisc_direct_ops = {
121 .output = dev_queue_xmit,
122 .connected_output = dev_queue_xmit,
123 .hh_output = dev_queue_xmit,
124 .queue_xmit = dev_queue_xmit,
127 struct neigh_table nd_tbl = {
129 .entry_size = sizeof(struct neighbour) + sizeof(struct in6_addr),
130 .key_len = sizeof(struct in6_addr),
132 .constructor = ndisc_constructor,
133 .pconstructor = pndisc_constructor,
134 .pdestructor = pndisc_destructor,
135 .proxy_redo = pndisc_redo,
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,
147 .anycast_delay = 1 * HZ,
148 .proxy_delay = (8 * HZ) / 10,
151 .gc_interval = 30 * HZ,
158 struct ndisc_options {
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;
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]
173 #define NDISC_OPT_SPACE(len) (((len)+2+7)&~7)
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.
181 static int ndisc_addr_option_pad(unsigned short type)
184 case ARPHRD_INFINIBAND: return 2;
189 static inline int ndisc_opt_addr_space(struct net_device *dev)
191 return NDISC_OPT_SPACE(dev->addr_len + ndisc_addr_option_pad(dev->type));
194 static u8 *ndisc_fill_addr_option(u8 *opt, int type, void *data, int data_len,
195 unsigned short addr_type)
197 int space = NDISC_OPT_SPACE(data_len);
198 int pad = ndisc_addr_option_pad(addr_type);
203 memset(opt + 2, 0, pad);
207 memcpy(opt+2, data, data_len);
210 if ((space -= data_len) > 0)
211 memset(opt, 0, space);
215 static struct nd_opt_hdr *ndisc_next_option(struct nd_opt_hdr *cur,
216 struct nd_opt_hdr *end)
219 if (!cur || !end || cur >= end)
221 type = cur->nd_opt_type;
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);
228 static struct ndisc_options *ndisc_parse_options(u8 *opt, int opt_len,
229 struct ndisc_options *ndopts)
231 struct nd_opt_hdr *nd_opt = (struct nd_opt_hdr *)opt;
233 if (!nd_opt || opt_len < 0 || !ndopts)
235 memset(ndopts, 0, sizeof(*ndopts));
238 if (opt_len < sizeof(struct nd_opt_hdr))
240 l = nd_opt->nd_opt_len << 3;
241 if (opt_len < l || l == 0)
243 switch (nd_opt->nd_opt_type) {
244 case ND_OPT_SOURCE_LL_ADDR:
245 case ND_OPT_TARGET_LL_ADDR:
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",
252 nd_opt->nd_opt_type);
254 ndopts->nd_opt_array[nd_opt->nd_opt_type] = nd_opt;
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;
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;
271 * Unknown options must be silently ignored,
272 * to accommodate future extension to the protocol.
274 ND_PRINTK2(KERN_NOTICE
275 "%s(): ignored unsupported option; type=%d, len=%d\n",
277 nd_opt->nd_opt_type, nd_opt->nd_opt_len);
280 nd_opt = ((void *)nd_opt) + l;
285 static inline u8 *ndisc_opt_addr_data(struct nd_opt_hdr *p,
286 struct net_device *dev)
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))
293 return (lladdr + prepad);
296 int ndisc_mc_map(struct in6_addr *addr, char *buf, struct net_device *dev, int dir)
300 case ARPHRD_IEEE802: /* Not sure. Check it later. --ANK */
302 ipv6_eth_mc_map(addr, buf);
304 case ARPHRD_IEEE802_TR:
305 ipv6_tr_mc_map(addr,buf);
308 ipv6_arcnet_mc_map(addr, buf);
310 case ARPHRD_INFINIBAND:
311 ipv6_ib_mc_map(addr, buf);
315 memcpy(buf, dev->broadcast, dev->addr_len);
322 EXPORT_SYMBOL(ndisc_mc_map);
324 static u32 ndisc_hash(const void *pkey, const struct net_device *dev)
326 const u32 *p32 = pkey;
330 for (i = 0; i < (sizeof(struct in6_addr) / sizeof(u32)); i++)
333 return jhash_2words(addr_hash, dev->ifindex, nd_tbl.hash_rnd);
336 static int ndisc_constructor(struct neighbour *neigh)
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);
345 in6_dev = in6_dev_get(dev);
346 if (in6_dev == NULL) {
351 parms = in6_dev->nd_parms;
352 __neigh_parms_put(neigh->parms);
353 neigh->parms = neigh_parms_clone(parms);
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;
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);
374 if (dev->hard_header_cache)
375 neigh->ops = &ndisc_hh_ops;
377 neigh->ops = &ndisc_generic_ops;
378 if (neigh->nud_state&NUD_VALID)
379 neigh->output = neigh->ops->connected_output;
381 neigh->output = neigh->ops->output;
383 in6_dev_put(in6_dev);
387 static int pndisc_constructor(struct pneigh_entry *n)
389 struct in6_addr *addr = (struct in6_addr*)&n->key;
390 struct in6_addr maddr;
391 struct net_device *dev = n->dev;
393 if (dev == NULL || __in6_dev_get(dev) == NULL)
395 addrconf_addr_solict_mult(addr, &maddr);
396 ipv6_dev_mc_inc(dev, &maddr);
400 static void pndisc_destructor(struct pneigh_entry *n)
402 struct in6_addr *addr = (struct in6_addr*)&n->key;
403 struct in6_addr maddr;
404 struct net_device *dev = n->dev;
406 if (dev == NULL || __in6_dev_get(dev) == NULL)
408 addrconf_addr_solict_mult(addr, &maddr);
409 ipv6_dev_mc_dec(dev, &maddr);
413 * Send a Neighbour Advertisement
416 static inline void ndisc_flow_init(struct flowi *fl, u8 type,
417 struct in6_addr *saddr, struct in6_addr *daddr,
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;
427 security_sk_classify_flow(ndisc_socket->sk, fl);
430 static void ndisc_send_na(struct net_device *dev, struct neighbour *neigh,
431 struct in6_addr *daddr, struct in6_addr *solicited_addr,
432 int router, int solicited, int override, int inc_opt)
434 struct in6_addr tmpaddr;
435 struct inet6_ifaddr *ifp;
436 struct inet6_dev *idev;
438 struct dst_entry* dst;
439 struct sock *sk = ndisc_socket->sk;
440 struct in6_addr *src_addr;
446 len = sizeof(struct icmp6hdr) + sizeof(struct in6_addr);
448 /* for anycast or proxy, solicited_addr != src_addr */
449 ifp = ipv6_get_ifaddr(solicited_addr, dev, 1);
451 src_addr = solicited_addr;
452 if (ifp->flags & IFA_F_OPTIMISTIC)
456 if (ipv6_dev_get_saddr(dev, daddr, &tmpaddr))
461 ndisc_flow_init(&fl, NDISC_NEIGHBOUR_ADVERTISEMENT, src_addr, daddr,
464 dst = ndisc_dst_alloc(dev, neigh, daddr, ip6_output);
468 err = xfrm_lookup(&dst, &fl, NULL, 0);
474 len += ndisc_opt_addr_space(dev);
479 skb = sock_alloc_send_skb(sk,
480 (MAX_HEADER + sizeof(struct ipv6hdr) +
481 len + LL_RESERVED_SPACE(dev)),
486 "ICMPv6 NA: %s() failed to allocate an skb.\n",
492 skb_reserve(skb, LL_RESERVED_SPACE(dev));
493 ip6_nd_hdr(sk, skb, dev, src_addr, daddr, IPPROTO_ICMPV6, len);
495 msg = (struct nd_msg *)skb_put(skb, len);
496 skb->h.raw = (unsigned char*)msg;
498 msg->icmph.icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT;
499 msg->icmph.icmp6_code = 0;
500 msg->icmph.icmp6_cksum = 0;
502 msg->icmph.icmp6_unused = 0;
503 msg->icmph.icmp6_router = router;
504 msg->icmph.icmp6_solicited = solicited;
505 msg->icmph.icmp6_override = override;
507 /* Set the target address. */
508 ipv6_addr_copy(&msg->target, solicited_addr);
511 ndisc_fill_addr_option(msg->opt, ND_OPT_TARGET_LL_ADDR, dev->dev_addr,
512 dev->addr_len, dev->type);
515 msg->icmph.icmp6_cksum = csum_ipv6_magic(src_addr, daddr, len,
517 csum_partial((__u8 *) msg,
521 idev = in6_dev_get(dst->dev);
522 IP6_INC_STATS(idev, IPSTATS_MIB_OUTREQUESTS);
523 err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, skb, NULL, dst->dev, dst_output);
525 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTNEIGHBORADVERTISEMENTS);
526 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);
529 if (likely(idev != NULL))
533 void ndisc_send_ns(struct net_device *dev, struct neighbour *neigh,
534 struct in6_addr *solicit,
535 struct in6_addr *daddr, struct in6_addr *saddr)
538 struct dst_entry* dst;
539 struct inet6_dev *idev;
540 struct sock *sk = ndisc_socket->sk;
543 struct in6_addr addr_buf;
549 if (ipv6_get_lladdr(dev, &addr_buf,
550 (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)))
555 ndisc_flow_init(&fl, NDISC_NEIGHBOUR_SOLICITATION, saddr, daddr,
558 dst = ndisc_dst_alloc(dev, neigh, daddr, ip6_output);
562 err = xfrm_lookup(&dst, &fl, NULL, 0);
566 len = sizeof(struct icmp6hdr) + sizeof(struct in6_addr);
567 send_llinfo = dev->addr_len && !ipv6_addr_any(saddr);
569 len += ndisc_opt_addr_space(dev);
571 skb = sock_alloc_send_skb(sk,
572 (MAX_HEADER + sizeof(struct ipv6hdr) +
573 len + LL_RESERVED_SPACE(dev)),
577 "ICMPv6 NA: %s() failed to allocate an skb.\n",
583 skb_reserve(skb, LL_RESERVED_SPACE(dev));
584 ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);
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;
593 /* Set the target address. */
594 ipv6_addr_copy(&msg->target, solicit);
597 ndisc_fill_addr_option(msg->opt, ND_OPT_SOURCE_LL_ADDR, dev->dev_addr,
598 dev->addr_len, dev->type);
601 msg->icmph.icmp6_cksum = csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
604 csum_partial((__u8 *) msg,
608 idev = in6_dev_get(dst->dev);
609 IP6_INC_STATS(idev, IPSTATS_MIB_OUTREQUESTS);
610 err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, skb, NULL, dst->dev, dst_output);
612 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTNEIGHBORSOLICITS);
613 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);
616 if (likely(idev != NULL))
620 void ndisc_send_rs(struct net_device *dev, struct in6_addr *saddr,
621 struct in6_addr *daddr)
624 struct dst_entry* dst;
625 struct inet6_dev *idev;
626 struct sock *sk = ndisc_socket->sk;
628 struct icmp6hdr *hdr;
630 int send_sllao = dev->addr_len;
635 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
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.
645 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(saddr, dev, 1);
647 if (ifp->flags & IFA_F_OPTIMISTIC) {
656 ndisc_flow_init(&fl, NDISC_ROUTER_SOLICITATION, saddr, daddr,
659 dst = ndisc_dst_alloc(dev, NULL, daddr, ip6_output);
663 err = xfrm_lookup(&dst, &fl, NULL, 0);
667 len = sizeof(struct icmp6hdr);
669 len += ndisc_opt_addr_space(dev);
671 skb = sock_alloc_send_skb(sk,
672 (MAX_HEADER + sizeof(struct ipv6hdr) +
673 len + LL_RESERVED_SPACE(dev)),
677 "ICMPv6 RS: %s() failed to allocate an skb.\n",
683 skb_reserve(skb, LL_RESERVED_SPACE(dev));
684 ip6_nd_hdr(sk, skb, dev, saddr, daddr, IPPROTO_ICMPV6, len);
686 hdr = (struct icmp6hdr *)skb_put(skb, len);
687 skb->h.raw = (unsigned char*)hdr;
688 hdr->icmp6_type = NDISC_ROUTER_SOLICITATION;
690 hdr->icmp6_cksum = 0;
691 hdr->icmp6_unused = 0;
693 opt = (u8*) (hdr + 1);
696 ndisc_fill_addr_option(opt, ND_OPT_SOURCE_LL_ADDR, dev->dev_addr,
697 dev->addr_len, dev->type);
700 hdr->icmp6_cksum = csum_ipv6_magic(&ipv6_hdr(skb)->saddr, daddr, len,
702 csum_partial((__u8 *) hdr, len, 0));
706 idev = in6_dev_get(dst->dev);
707 IP6_INC_STATS(idev, IPSTATS_MIB_OUTREQUESTS);
708 err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, skb, NULL, dst->dev, dst_output);
710 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTROUTERSOLICITS);
711 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);
714 if (likely(idev != NULL))
719 static void ndisc_error_report(struct neighbour *neigh, struct sk_buff *skb)
722 * "The sender MUST return an ICMP
723 * destination unreachable"
725 dst_link_failure(skb);
729 /* Called with locked neigh: either read or both */
731 static void ndisc_solicit(struct neighbour *neigh, struct sk_buff *skb)
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);
739 if (skb && ipv6_chk_addr(&ipv6_hdr(skb)->saddr, dev, 1))
740 saddr = &ipv6_hdr(skb)->saddr;
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: "
750 ndisc_send_ns(dev, neigh, target, target, saddr);
751 } else if ((probes -= neigh->parms->app_probes) < 0) {
756 addrconf_addr_solict_mult(target, &mcaddr);
757 ndisc_send_ns(dev, NULL, target, &mcaddr, saddr);
761 static void ndisc_recv_ns(struct sk_buff *skb)
763 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
764 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
765 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
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;
773 struct pneigh_entry *pneigh = NULL;
774 int dad = ipv6_addr_any(saddr);
778 if (ipv6_addr_is_multicast(&msg->target)) {
779 ND_PRINTK2(KERN_WARNING
780 "ICMPv6 NS: multicast target address");
786 * DAD has to be destined for solicited node multicast address.
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");
798 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
799 ND_PRINTK2(KERN_WARNING
800 "ICMPv6 NS: invalid ND options\n");
804 if (ndopts.nd_opts_src_lladdr) {
805 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr, dev);
807 ND_PRINTK2(KERN_WARNING
808 "ICMPv6 NS: invalid link-layer address length\n");
813 * If the IP source address is the unspecified address,
814 * there MUST NOT be source link-layer address option
818 ND_PRINTK2(KERN_WARNING
819 "ICMPv6 NS: bad DAD packet (link-layer address option)\n");
824 inc = ipv6_addr_is_multicast(daddr);
826 if ((ifp = ipv6_get_ifaddr(&msg->target, dev, 1)) != NULL) {
828 if (ifp->flags & (IFA_F_TENTATIVE|IFA_F_OPTIMISTIC)) {
830 if (dev->type == ARPHRD_IEEE802_TR) {
831 const unsigned char *sadr;
832 sadr = skb_mac_header(skb);
833 if (((sadr[8] ^ dev->dev_addr[0]) & 0x7f) == 0 &&
834 sadr[9] == dev->dev_addr[1] &&
835 sadr[10] == dev->dev_addr[2] &&
836 sadr[11] == dev->dev_addr[3] &&
837 sadr[12] == dev->dev_addr[4] &&
838 sadr[13] == dev->dev_addr[5]) {
839 /* looped-back to us */
845 * We are colliding with another node
847 * so fail our DAD process
849 addrconf_dad_failure(ifp);
853 * This is not a dad solicitation.
854 * If we are an optimistic node,
856 * Otherwise, we should ignore it.
858 if (!(ifp->flags & IFA_F_OPTIMISTIC))
865 idev = in6_dev_get(dev);
867 /* XXX: count this drop? */
871 if (ipv6_chk_acast_addr(dev, &msg->target) ||
872 (idev->cnf.forwarding &&
873 (ipv6_devconf.proxy_ndp || idev->cnf.proxy_ndp) &&
874 (pneigh = pneigh_lookup(&nd_tbl,
875 &msg->target, dev, 0)) != NULL)) {
876 if (!(NEIGH_CB(skb)->flags & LOCALLY_ENQUEUED) &&
877 skb->pkt_type != PACKET_HOST &&
879 idev->nd_parms->proxy_delay != 0) {
881 * for anycast or proxy,
882 * sender should delay its response
883 * by a random time between 0 and
884 * MAX_ANYCAST_DELAY_TIME seconds.
885 * (RFC2461) -- yoshfuji
887 struct sk_buff *n = skb_clone(skb, GFP_ATOMIC);
889 pneigh_enqueue(&nd_tbl, idev->nd_parms, n);
896 is_router = !!(pneigh ? pneigh->flags & NTF_ROUTER : idev->cnf.forwarding);
899 struct in6_addr maddr;
901 ipv6_addr_all_nodes(&maddr);
902 ndisc_send_na(dev, NULL, &maddr, &msg->target,
903 is_router, 0, (ifp != NULL), 1);
908 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_mcast);
910 NEIGH_CACHE_STAT_INC(&nd_tbl, rcv_probes_ucast);
913 * update / create cache entry
914 * for the source address
916 neigh = __neigh_lookup(&nd_tbl, saddr, dev,
917 !inc || lladdr || !dev->addr_len);
919 neigh_update(neigh, lladdr, NUD_STALE,
920 NEIGH_UPDATE_F_WEAK_OVERRIDE|
921 NEIGH_UPDATE_F_OVERRIDE);
922 if (neigh || !dev->hard_header) {
923 ndisc_send_na(dev, neigh, saddr, &msg->target,
925 1, (ifp != NULL && inc), inc);
927 neigh_release(neigh);
939 static void ndisc_recv_na(struct sk_buff *skb)
941 struct nd_msg *msg = (struct nd_msg *)skb_transport_header(skb);
942 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
943 struct in6_addr *daddr = &ipv6_hdr(skb)->daddr;
945 u32 ndoptlen = skb->tail - msg->opt;
946 struct ndisc_options ndopts;
947 struct net_device *dev = skb->dev;
948 struct inet6_ifaddr *ifp;
949 struct neighbour *neigh;
951 if (skb->len < sizeof(struct nd_msg)) {
952 ND_PRINTK2(KERN_WARNING
953 "ICMPv6 NA: packet too short\n");
957 if (ipv6_addr_is_multicast(&msg->target)) {
958 ND_PRINTK2(KERN_WARNING
959 "ICMPv6 NA: target address is multicast.\n");
963 if (ipv6_addr_is_multicast(daddr) &&
964 msg->icmph.icmp6_solicited) {
965 ND_PRINTK2(KERN_WARNING
966 "ICMPv6 NA: solicited NA is multicasted.\n");
970 if (!ndisc_parse_options(msg->opt, ndoptlen, &ndopts)) {
971 ND_PRINTK2(KERN_WARNING
972 "ICMPv6 NS: invalid ND option\n");
975 if (ndopts.nd_opts_tgt_lladdr) {
976 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr, dev);
978 ND_PRINTK2(KERN_WARNING
979 "ICMPv6 NA: invalid link-layer address length\n");
983 if ((ifp = ipv6_get_ifaddr(&msg->target, dev, 1))) {
984 if (ifp->flags & IFA_F_TENTATIVE) {
985 addrconf_dad_failure(ifp);
988 /* What should we make now? The advertisement
989 is invalid, but ndisc specs say nothing
990 about it. It could be misconfiguration, or
991 an smart proxy agent tries to help us :-)
993 ND_PRINTK1(KERN_WARNING
994 "ICMPv6 NA: someone advertises our address on %s!\n",
995 ifp->idev->dev->name);
999 neigh = neigh_lookup(&nd_tbl, &msg->target, dev);
1002 u8 old_flags = neigh->flags;
1004 if (neigh->nud_state & NUD_FAILED)
1008 * Don't update the neighbor cache entry on a proxy NA from
1009 * ourselves because either the proxied node is off link or it
1010 * has already sent a NA to us.
1012 if (lladdr && !memcmp(lladdr, dev->dev_addr, dev->addr_len) &&
1013 ipv6_devconf.forwarding && ipv6_devconf.proxy_ndp &&
1014 pneigh_lookup(&nd_tbl, &msg->target, dev, 0)) {
1015 /* XXX: idev->cnf.prixy_ndp */
1019 neigh_update(neigh, lladdr,
1020 msg->icmph.icmp6_solicited ? NUD_REACHABLE : NUD_STALE,
1021 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1022 (msg->icmph.icmp6_override ? NEIGH_UPDATE_F_OVERRIDE : 0)|
1023 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1024 (msg->icmph.icmp6_router ? NEIGH_UPDATE_F_ISROUTER : 0));
1026 if ((old_flags & ~neigh->flags) & NTF_ROUTER) {
1028 * Change: router to host
1030 struct rt6_info *rt;
1031 rt = rt6_get_dflt_router(saddr, dev);
1037 neigh_release(neigh);
1041 static void ndisc_recv_rs(struct sk_buff *skb)
1043 struct rs_msg *rs_msg = (struct rs_msg *)skb_transport_header(skb);
1044 unsigned long ndoptlen = skb->len - sizeof(*rs_msg);
1045 struct neighbour *neigh;
1046 struct inet6_dev *idev;
1047 struct in6_addr *saddr = &ipv6_hdr(skb)->saddr;
1048 struct ndisc_options ndopts;
1051 if (skb->len < sizeof(*rs_msg))
1054 idev = in6_dev_get(skb->dev);
1056 if (net_ratelimit())
1057 ND_PRINTK1("ICMP6 RS: can't find in6 device\n");
1061 /* Don't accept RS if we're not in router mode */
1062 if (!idev->cnf.forwarding)
1066 * Don't update NCE if src = ::;
1067 * this implies that the source node has no ip address assigned yet.
1069 if (ipv6_addr_any(saddr))
1072 /* Parse ND options */
1073 if (!ndisc_parse_options(rs_msg->opt, ndoptlen, &ndopts)) {
1074 if (net_ratelimit())
1075 ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n");
1079 if (ndopts.nd_opts_src_lladdr) {
1080 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1086 neigh = __neigh_lookup(&nd_tbl, saddr, skb->dev, 1);
1088 neigh_update(neigh, lladdr, NUD_STALE,
1089 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1090 NEIGH_UPDATE_F_OVERRIDE|
1091 NEIGH_UPDATE_F_OVERRIDE_ISROUTER);
1092 neigh_release(neigh);
1098 static void ndisc_router_discovery(struct sk_buff *skb)
1100 struct ra_msg *ra_msg = (struct ra_msg *)skb_transport_header(skb);
1101 struct neighbour *neigh = NULL;
1102 struct inet6_dev *in6_dev;
1103 struct rt6_info *rt = NULL;
1105 struct ndisc_options ndopts;
1107 unsigned int pref = 0;
1109 __u8 * opt = (__u8 *)(ra_msg + 1);
1111 optlen = (skb->tail - skb_transport_header(skb)) -
1112 sizeof(struct ra_msg);
1114 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1115 ND_PRINTK2(KERN_WARNING
1116 "ICMPv6 RA: source address is not link-local.\n");
1120 ND_PRINTK2(KERN_WARNING
1121 "ICMPv6 RA: packet too short\n");
1126 * set the RA_RECV flag in the interface
1129 in6_dev = in6_dev_get(skb->dev);
1130 if (in6_dev == NULL) {
1132 "ICMPv6 RA: can't find inet6 device for %s.\n",
1136 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_ra) {
1137 in6_dev_put(in6_dev);
1141 if (!ndisc_parse_options(opt, optlen, &ndopts)) {
1142 in6_dev_put(in6_dev);
1143 ND_PRINTK2(KERN_WARNING
1144 "ICMP6 RA: invalid ND options\n");
1148 if (in6_dev->if_flags & IF_RS_SENT) {
1150 * flag that an RA was received after an RS was sent
1151 * out on this interface.
1153 in6_dev->if_flags |= IF_RA_RCVD;
1157 * Remember the managed/otherconf flags from most recently
1158 * received RA message (RFC 2462) -- yoshfuji
1160 in6_dev->if_flags = (in6_dev->if_flags & ~(IF_RA_MANAGED |
1162 (ra_msg->icmph.icmp6_addrconf_managed ?
1163 IF_RA_MANAGED : 0) |
1164 (ra_msg->icmph.icmp6_addrconf_other ?
1165 IF_RA_OTHERCONF : 0);
1167 if (!in6_dev->cnf.accept_ra_defrtr)
1170 lifetime = ntohs(ra_msg->icmph.icmp6_rt_lifetime);
1172 #ifdef CONFIG_IPV6_ROUTER_PREF
1173 pref = ra_msg->icmph.icmp6_router_pref;
1174 /* 10b is handled as if it were 00b (medium) */
1175 if (pref == ICMPV6_ROUTER_PREF_INVALID ||
1176 in6_dev->cnf.accept_ra_rtr_pref)
1177 pref = ICMPV6_ROUTER_PREF_MEDIUM;
1180 rt = rt6_get_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev);
1183 neigh = rt->rt6i_nexthop;
1185 if (rt && lifetime == 0) {
1191 if (rt == NULL && lifetime) {
1192 ND_PRINTK3(KERN_DEBUG
1193 "ICMPv6 RA: adding default router.\n");
1195 rt = rt6_add_dflt_router(&ipv6_hdr(skb)->saddr, skb->dev, pref);
1198 "ICMPv6 RA: %s() failed to add default route.\n",
1200 in6_dev_put(in6_dev);
1204 neigh = rt->rt6i_nexthop;
1205 if (neigh == NULL) {
1207 "ICMPv6 RA: %s() got default router without neighbour.\n",
1209 dst_release(&rt->u.dst);
1210 in6_dev_put(in6_dev);
1213 neigh->flags |= NTF_ROUTER;
1215 rt->rt6i_flags |= (rt->rt6i_flags & ~RTF_PREF_MASK) | RTF_PREF(pref);
1219 rt->rt6i_expires = jiffies + (HZ * lifetime);
1221 if (ra_msg->icmph.icmp6_hop_limit) {
1222 in6_dev->cnf.hop_limit = ra_msg->icmph.icmp6_hop_limit;
1224 rt->u.dst.metrics[RTAX_HOPLIMIT-1] = ra_msg->icmph.icmp6_hop_limit;
1230 * Update Reachable Time and Retrans Timer
1233 if (in6_dev->nd_parms) {
1234 unsigned long rtime = ntohl(ra_msg->retrans_timer);
1236 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/HZ) {
1237 rtime = (rtime*HZ)/1000;
1240 in6_dev->nd_parms->retrans_time = rtime;
1241 in6_dev->tstamp = jiffies;
1242 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1245 rtime = ntohl(ra_msg->reachable_time);
1246 if (rtime && rtime/1000 < MAX_SCHEDULE_TIMEOUT/(3*HZ)) {
1247 rtime = (rtime*HZ)/1000;
1252 if (rtime != in6_dev->nd_parms->base_reachable_time) {
1253 in6_dev->nd_parms->base_reachable_time = rtime;
1254 in6_dev->nd_parms->gc_staletime = 3 * rtime;
1255 in6_dev->nd_parms->reachable_time = neigh_rand_reach_time(rtime);
1256 in6_dev->tstamp = jiffies;
1257 inet6_ifinfo_notify(RTM_NEWLINK, in6_dev);
1267 neigh = __neigh_lookup(&nd_tbl, &ipv6_hdr(skb)->saddr,
1271 if (ndopts.nd_opts_src_lladdr) {
1272 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_src_lladdr,
1275 ND_PRINTK2(KERN_WARNING
1276 "ICMPv6 RA: invalid link-layer address length\n");
1280 neigh_update(neigh, lladdr, NUD_STALE,
1281 NEIGH_UPDATE_F_WEAK_OVERRIDE|
1282 NEIGH_UPDATE_F_OVERRIDE|
1283 NEIGH_UPDATE_F_OVERRIDE_ISROUTER|
1284 NEIGH_UPDATE_F_ISROUTER);
1287 #ifdef CONFIG_IPV6_ROUTE_INFO
1288 if (in6_dev->cnf.accept_ra_rtr_pref && ndopts.nd_opts_ri) {
1289 struct nd_opt_hdr *p;
1290 for (p = ndopts.nd_opts_ri;
1292 p = ndisc_next_option(p, ndopts.nd_opts_ri_end)) {
1293 if (((struct route_info *)p)->prefix_len > in6_dev->cnf.accept_ra_rt_info_max_plen)
1295 rt6_route_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3,
1296 &ipv6_hdr(skb)->saddr);
1301 if (in6_dev->cnf.accept_ra_pinfo && ndopts.nd_opts_pi) {
1302 struct nd_opt_hdr *p;
1303 for (p = ndopts.nd_opts_pi;
1305 p = ndisc_next_option(p, ndopts.nd_opts_pi_end)) {
1306 addrconf_prefix_rcv(skb->dev, (u8*)p, (p->nd_opt_len) << 3);
1310 if (ndopts.nd_opts_mtu) {
1314 memcpy(&n, ((u8*)(ndopts.nd_opts_mtu+1))+2, sizeof(mtu));
1317 if (mtu < IPV6_MIN_MTU || mtu > skb->dev->mtu) {
1318 ND_PRINTK2(KERN_WARNING
1319 "ICMPv6 RA: invalid mtu: %d\n",
1321 } else if (in6_dev->cnf.mtu6 != mtu) {
1322 in6_dev->cnf.mtu6 = mtu;
1325 rt->u.dst.metrics[RTAX_MTU-1] = mtu;
1327 rt6_mtu_change(skb->dev, mtu);
1331 if (ndopts.nd_opts_tgt_lladdr || ndopts.nd_opts_rh) {
1332 ND_PRINTK2(KERN_WARNING
1333 "ICMPv6 RA: invalid RA options");
1337 dst_release(&rt->u.dst);
1339 neigh_release(neigh);
1340 in6_dev_put(in6_dev);
1343 static void ndisc_redirect_rcv(struct sk_buff *skb)
1345 struct inet6_dev *in6_dev;
1346 struct icmp6hdr *icmph;
1347 struct in6_addr *dest;
1348 struct in6_addr *target; /* new first hop to destination */
1349 struct neighbour *neigh;
1351 struct ndisc_options ndopts;
1355 if (!(ipv6_addr_type(&ipv6_hdr(skb)->saddr) & IPV6_ADDR_LINKLOCAL)) {
1356 ND_PRINTK2(KERN_WARNING
1357 "ICMPv6 Redirect: source address is not link-local.\n");
1361 optlen = skb->tail - skb_transport_header(skb);
1362 optlen -= sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1365 ND_PRINTK2(KERN_WARNING
1366 "ICMPv6 Redirect: packet too short\n");
1370 icmph = icmp6_hdr(skb);
1371 target = (struct in6_addr *) (icmph + 1);
1374 if (ipv6_addr_is_multicast(dest)) {
1375 ND_PRINTK2(KERN_WARNING
1376 "ICMPv6 Redirect: destination address is multicast.\n");
1380 if (ipv6_addr_equal(dest, target)) {
1382 } else if (!(ipv6_addr_type(target) & IPV6_ADDR_LINKLOCAL)) {
1383 ND_PRINTK2(KERN_WARNING
1384 "ICMPv6 Redirect: target address is not link-local.\n");
1388 in6_dev = in6_dev_get(skb->dev);
1391 if (in6_dev->cnf.forwarding || !in6_dev->cnf.accept_redirects) {
1392 in6_dev_put(in6_dev);
1397 * The IP source address of the Redirect MUST be the same as the current
1398 * first-hop router for the specified ICMP Destination Address.
1401 if (!ndisc_parse_options((u8*)(dest + 1), optlen, &ndopts)) {
1402 ND_PRINTK2(KERN_WARNING
1403 "ICMPv6 Redirect: invalid ND options\n");
1404 in6_dev_put(in6_dev);
1407 if (ndopts.nd_opts_tgt_lladdr) {
1408 lladdr = ndisc_opt_addr_data(ndopts.nd_opts_tgt_lladdr,
1411 ND_PRINTK2(KERN_WARNING
1412 "ICMPv6 Redirect: invalid link-layer address length\n");
1413 in6_dev_put(in6_dev);
1418 neigh = __neigh_lookup(&nd_tbl, target, skb->dev, 1);
1420 rt6_redirect(dest, &ipv6_hdr(skb)->daddr,
1421 &ipv6_hdr(skb)->saddr, neigh, lladdr,
1423 neigh_release(neigh);
1425 in6_dev_put(in6_dev);
1428 void ndisc_send_redirect(struct sk_buff *skb, struct neighbour *neigh,
1429 struct in6_addr *target)
1431 struct sock *sk = ndisc_socket->sk;
1432 int len = sizeof(struct icmp6hdr) + 2 * sizeof(struct in6_addr);
1433 struct sk_buff *buff;
1434 struct icmp6hdr *icmph;
1435 struct in6_addr saddr_buf;
1436 struct in6_addr *addrp;
1437 struct net_device *dev;
1438 struct rt6_info *rt;
1439 struct dst_entry *dst;
1440 struct inet6_dev *idev;
1446 u8 ha_buf[MAX_ADDR_LEN], *ha = NULL;
1450 if (ipv6_get_lladdr(dev, &saddr_buf, IFA_F_TENTATIVE)) {
1451 ND_PRINTK2(KERN_WARNING
1452 "ICMPv6 Redirect: no link-local address on %s\n",
1457 if (!ipv6_addr_equal(&ipv6_hdr(skb)->daddr, target) &&
1458 !(ipv6_addr_type(target) & IPV6_ADDR_LINKLOCAL)) {
1459 ND_PRINTK2(KERN_WARNING
1460 "ICMPv6 Redirect: target address is not link-local.\n");
1464 ndisc_flow_init(&fl, NDISC_REDIRECT, &saddr_buf, &ipv6_hdr(skb)->saddr,
1467 dst = ip6_route_output(NULL, &fl);
1471 err = xfrm_lookup(&dst, &fl, NULL, 0);
1475 rt = (struct rt6_info *) dst;
1477 if (rt->rt6i_flags & RTF_GATEWAY) {
1478 ND_PRINTK2(KERN_WARNING
1479 "ICMPv6 Redirect: destination is not a neighbour.\n");
1483 if (!xrlim_allow(dst, 1*HZ)) {
1488 if (dev->addr_len) {
1489 read_lock_bh(&neigh->lock);
1490 if (neigh->nud_state & NUD_VALID) {
1491 memcpy(ha_buf, neigh->ha, dev->addr_len);
1492 read_unlock_bh(&neigh->lock);
1494 len += ndisc_opt_addr_space(dev);
1496 read_unlock_bh(&neigh->lock);
1499 rd_len = min_t(unsigned int,
1500 IPV6_MIN_MTU-sizeof(struct ipv6hdr)-len, skb->len + 8);
1504 buff = sock_alloc_send_skb(sk,
1505 (MAX_HEADER + sizeof(struct ipv6hdr) +
1506 len + LL_RESERVED_SPACE(dev)),
1510 "ICMPv6 Redirect: %s() failed to allocate an skb.\n",
1518 skb_reserve(buff, LL_RESERVED_SPACE(dev));
1519 ip6_nd_hdr(sk, buff, dev, &saddr_buf, &ipv6_hdr(skb)->saddr,
1520 IPPROTO_ICMPV6, len);
1522 icmph = (struct icmp6hdr *)skb_put(buff, len);
1523 buff->h.raw = (unsigned char*)icmph;
1525 memset(icmph, 0, sizeof(struct icmp6hdr));
1526 icmph->icmp6_type = NDISC_REDIRECT;
1529 * copy target and destination addresses
1532 addrp = (struct in6_addr *)(icmph + 1);
1533 ipv6_addr_copy(addrp, target);
1535 ipv6_addr_copy(addrp, &ipv6_hdr(skb)->daddr);
1537 opt = (u8*) (addrp + 1);
1540 * include target_address option
1544 opt = ndisc_fill_addr_option(opt, ND_OPT_TARGET_LL_ADDR, ha,
1545 dev->addr_len, dev->type);
1548 * build redirect option and copy skb over to the new packet.
1552 *(opt++) = ND_OPT_REDIRECT_HDR;
1553 *(opt++) = (rd_len >> 3);
1556 memcpy(opt, ipv6_hdr(skb), rd_len - 8);
1558 icmph->icmp6_cksum = csum_ipv6_magic(&saddr_buf, &ipv6_hdr(skb)->saddr,
1559 len, IPPROTO_ICMPV6,
1560 csum_partial((u8 *) icmph, len, 0));
1563 idev = in6_dev_get(dst->dev);
1564 IP6_INC_STATS(idev, IPSTATS_MIB_OUTREQUESTS);
1565 err = NF_HOOK(PF_INET6, NF_IP6_LOCAL_OUT, buff, NULL, dst->dev, dst_output);
1567 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTREDIRECTS);
1568 ICMP6_INC_STATS(idev, ICMP6_MIB_OUTMSGS);
1571 if (likely(idev != NULL))
1575 static void pndisc_redo(struct sk_buff *skb)
1581 int ndisc_rcv(struct sk_buff *skb)
1585 if (!pskb_may_pull(skb, skb->len))
1588 msg = (struct nd_msg *)skb_transport_header(skb);
1590 __skb_push(skb, skb->data - skb_transport_header(skb));
1592 if (ipv6_hdr(skb)->hop_limit != 255) {
1593 ND_PRINTK2(KERN_WARNING
1594 "ICMPv6 NDISC: invalid hop-limit: %d\n",
1595 ipv6_hdr(skb)->hop_limit);
1599 if (msg->icmph.icmp6_code != 0) {
1600 ND_PRINTK2(KERN_WARNING
1601 "ICMPv6 NDISC: invalid ICMPv6 code: %d\n",
1602 msg->icmph.icmp6_code);
1606 memset(NEIGH_CB(skb), 0, sizeof(struct neighbour_cb));
1608 switch (msg->icmph.icmp6_type) {
1609 case NDISC_NEIGHBOUR_SOLICITATION:
1613 case NDISC_NEIGHBOUR_ADVERTISEMENT:
1617 case NDISC_ROUTER_SOLICITATION:
1621 case NDISC_ROUTER_ADVERTISEMENT:
1622 ndisc_router_discovery(skb);
1625 case NDISC_REDIRECT:
1626 ndisc_redirect_rcv(skb);
1633 static int ndisc_netdev_event(struct notifier_block *this, unsigned long event, void *ptr)
1635 struct net_device *dev = ptr;
1638 case NETDEV_CHANGEADDR:
1639 neigh_changeaddr(&nd_tbl, dev);
1643 neigh_ifdown(&nd_tbl, dev);
1653 static struct notifier_block ndisc_netdev_notifier = {
1654 .notifier_call = ndisc_netdev_event,
1657 #ifdef CONFIG_SYSCTL
1658 static void ndisc_warn_deprecated_sysctl(struct ctl_table *ctl,
1659 const char *func, const char *dev_name)
1661 static char warncomm[TASK_COMM_LEN];
1663 if (strcmp(warncomm, current->comm) && warned < 5) {
1664 strcpy(warncomm, current->comm);
1666 "process `%s' is using deprecated sysctl (%s) "
1667 "net.ipv6.neigh.%s.%s; "
1668 "Use net.ipv6.neigh.%s.%s_ms "
1671 dev_name, ctl->procname,
1672 dev_name, ctl->procname);
1677 int ndisc_ifinfo_sysctl_change(struct ctl_table *ctl, int write, struct file * filp, void __user *buffer, size_t *lenp, loff_t *ppos)
1679 struct net_device *dev = ctl->extra1;
1680 struct inet6_dev *idev;
1683 if (ctl->ctl_name == NET_NEIGH_RETRANS_TIME ||
1684 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME)
1685 ndisc_warn_deprecated_sysctl(ctl, "syscall", dev ? dev->name : "default");
1687 switch (ctl->ctl_name) {
1688 case NET_NEIGH_RETRANS_TIME:
1689 ret = proc_dointvec(ctl, write, filp, buffer, lenp, ppos);
1691 case NET_NEIGH_REACHABLE_TIME:
1692 ret = proc_dointvec_jiffies(ctl, write,
1693 filp, buffer, lenp, ppos);
1695 case NET_NEIGH_RETRANS_TIME_MS:
1696 case NET_NEIGH_REACHABLE_TIME_MS:
1697 ret = proc_dointvec_ms_jiffies(ctl, write,
1698 filp, buffer, lenp, ppos);
1704 if (write && ret == 0 && dev && (idev = in6_dev_get(dev)) != NULL) {
1705 if (ctl->ctl_name == NET_NEIGH_REACHABLE_TIME ||
1706 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME_MS)
1707 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1708 idev->tstamp = jiffies;
1709 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1715 static int ndisc_ifinfo_sysctl_strategy(ctl_table *ctl, int __user *name,
1716 int nlen, void __user *oldval,
1717 size_t __user *oldlenp,
1718 void __user *newval, size_t newlen)
1720 struct net_device *dev = ctl->extra1;
1721 struct inet6_dev *idev;
1724 if (ctl->ctl_name == NET_NEIGH_RETRANS_TIME ||
1725 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME)
1726 ndisc_warn_deprecated_sysctl(ctl, "procfs", dev ? dev->name : "default");
1728 switch (ctl->ctl_name) {
1729 case NET_NEIGH_REACHABLE_TIME:
1730 ret = sysctl_jiffies(ctl, name, nlen,
1731 oldval, oldlenp, newval, newlen);
1733 case NET_NEIGH_RETRANS_TIME_MS:
1734 case NET_NEIGH_REACHABLE_TIME_MS:
1735 ret = sysctl_ms_jiffies(ctl, name, nlen,
1736 oldval, oldlenp, newval, newlen);
1742 if (newval && newlen && ret > 0 &&
1743 dev && (idev = in6_dev_get(dev)) != NULL) {
1744 if (ctl->ctl_name == NET_NEIGH_REACHABLE_TIME ||
1745 ctl->ctl_name == NET_NEIGH_REACHABLE_TIME_MS)
1746 idev->nd_parms->reachable_time = neigh_rand_reach_time(idev->nd_parms->base_reachable_time);
1747 idev->tstamp = jiffies;
1748 inet6_ifinfo_notify(RTM_NEWLINK, idev);
1757 int __init ndisc_init(struct net_proto_family *ops)
1759 struct ipv6_pinfo *np;
1763 err = sock_create_kern(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6, &ndisc_socket);
1766 "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",
1768 ndisc_socket = NULL; /* For safety. */
1772 sk = ndisc_socket->sk;
1774 sk->sk_allocation = GFP_ATOMIC;
1775 np->hop_limit = 255;
1776 /* Do not loopback ndisc messages */
1778 sk->sk_prot->unhash(sk);
1781 * Initialize the neighbour table
1784 neigh_table_init(&nd_tbl);
1786 #ifdef CONFIG_SYSCTL
1787 neigh_sysctl_register(NULL, &nd_tbl.parms, NET_IPV6, NET_IPV6_NEIGH,
1789 &ndisc_ifinfo_sysctl_change,
1790 &ndisc_ifinfo_sysctl_strategy);
1793 register_netdevice_notifier(&ndisc_netdev_notifier);
1797 void ndisc_cleanup(void)
1799 unregister_netdevice_notifier(&ndisc_netdev_notifier);
1800 #ifdef CONFIG_SYSCTL
1801 neigh_sysctl_unregister(&nd_tbl.parms);
1803 neigh_table_clear(&nd_tbl);
1804 sock_release(ndisc_socket);
1805 ndisc_socket = NULL; /* For safety. */