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 * Pierre Ynard : export userland ND options
19 * through netlink (RDNSS support)
20 * Lars Fenneberg : fixed MTU setting on receipt
22 * Janos Farkas : kmalloc failure checks
23 * Alexey Kuznetsov : state machine reworked
24 * and moved to net/core.
25 * Pekka Savola : RFC2461 validation
26 * YOSHIFUJI Hideaki @USAGI : Verify ND options properly
29 /* Set to 3 to get tracing... */
32 #define ND_PRINTK(fmt, args...) do { if (net_ratelimit()) { printk(fmt, ## args); } } while(0)
33 #define ND_NOPRINTK(x...) do { ; } while(0)
34 #define ND_PRINTK0 ND_PRINTK
35 #define ND_PRINTK1 ND_NOPRINTK
36 #define ND_PRINTK2 ND_NOPRINTK
37 #define ND_PRINTK3 ND_NOPRINTK
40 #define ND_PRINTK1 ND_PRINTK
44 #define ND_PRINTK2 ND_PRINTK
48 #define ND_PRINTK3 ND_PRINTK
51 #include <linux/module.h>
52 #include <linux/errno.h>
53 #include <linux/types.h>
54 #include <linux/socket.h>
55 #include <linux/sockios.h>
56 #include <linux/sched.h>
57 #include <linux/net.h>
58 #include <linux/in6.h>
59 #include <linux/route.h>
60 #include <linux/init.h>
61 #include <linux/rcupdate.h>
63 #include <linux/sysctl.h>
66 #include <linux/if_addr.h>
67 #include <linux/if_arp.h>
68 #include <linux/ipv6.h>
69 #include <linux/icmpv6.h>
70 #include <linux/jhash.h>
76 #include <net/protocol.h>
77 #include <net/ndisc.h>
78 #include <net/ip6_route.h>
79 #include <net/addrconf.h>
82 #include <net/netlink.h>
83 #include <linux/rtnetlink.h>
86 #include <net/ip6_checksum.h>
87 #include <linux/proc_fs.h>
89 #include <linux/netfilter.h>
90 #include <linux/netfilter_ipv6.h>
92 static struct socket
*ndisc_socket
;
94 static u32
ndisc_hash(const void *pkey
, const struct net_device
*dev
);
95 static int ndisc_constructor(struct neighbour
*neigh
);
96 static void ndisc_solicit(struct neighbour
*neigh
, struct sk_buff
*skb
);
97 static void ndisc_error_report(struct neighbour
*neigh
, struct sk_buff
*skb
);
98 static int pndisc_constructor(struct pneigh_entry
*n
);
99 static void pndisc_destructor(struct pneigh_entry
*n
);
100 static void pndisc_redo(struct sk_buff
*skb
);
102 static struct neigh_ops ndisc_generic_ops
= {
104 .solicit
= ndisc_solicit
,
105 .error_report
= ndisc_error_report
,
106 .output
= neigh_resolve_output
,
107 .connected_output
= neigh_connected_output
,
108 .hh_output
= dev_queue_xmit
,
109 .queue_xmit
= dev_queue_xmit
,
112 static struct neigh_ops ndisc_hh_ops
= {
114 .solicit
= ndisc_solicit
,
115 .error_report
= ndisc_error_report
,
116 .output
= neigh_resolve_output
,
117 .connected_output
= neigh_resolve_output
,
118 .hh_output
= dev_queue_xmit
,
119 .queue_xmit
= dev_queue_xmit
,
123 static struct neigh_ops ndisc_direct_ops
= {
125 .output
= dev_queue_xmit
,
126 .connected_output
= dev_queue_xmit
,
127 .hh_output
= dev_queue_xmit
,
128 .queue_xmit
= dev_queue_xmit
,
131 struct neigh_table nd_tbl
= {
133 .entry_size
= sizeof(struct neighbour
) + sizeof(struct in6_addr
),
134 .key_len
= sizeof(struct in6_addr
),
136 .constructor
= ndisc_constructor
,
137 .pconstructor
= pndisc_constructor
,
138 .pdestructor
= pndisc_destructor
,
139 .proxy_redo
= pndisc_redo
,
143 .base_reachable_time
= 30 * HZ
,
144 .retrans_time
= 1 * HZ
,
145 .gc_staletime
= 60 * HZ
,
146 .reachable_time
= 30 * HZ
,
147 .delay_probe_time
= 5 * HZ
,
151 .anycast_delay
= 1 * HZ
,
152 .proxy_delay
= (8 * HZ
) / 10,
155 .gc_interval
= 30 * HZ
,
162 struct ndisc_options
{
163 struct nd_opt_hdr
*nd_opt_array
[__ND_OPT_ARRAY_MAX
];
164 #ifdef CONFIG_IPV6_ROUTE_INFO
165 struct nd_opt_hdr
*nd_opts_ri
;
166 struct nd_opt_hdr
*nd_opts_ri_end
;
168 struct nd_opt_hdr
*nd_useropts
;
169 struct nd_opt_hdr
*nd_useropts_end
;
172 #define nd_opts_src_lladdr nd_opt_array[ND_OPT_SOURCE_LL_ADDR]
173 #define nd_opts_tgt_lladdr nd_opt_array[ND_OPT_TARGET_LL_ADDR]
174 #define nd_opts_pi nd_opt_array[ND_OPT_PREFIX_INFO]
175 #define nd_opts_pi_end nd_opt_array[__ND_OPT_PREFIX_INFO_END]
176 #define nd_opts_rh nd_opt_array[ND_OPT_REDIRECT_HDR]
177 #define nd_opts_mtu nd_opt_array[ND_OPT_MTU]
179 #define NDISC_OPT_SPACE(len) (((len)+2+7)&~7)
182 * Return the padding between the option length and the start of the
183 * link addr. Currently only IP-over-InfiniBand needs this, although
184 * if RFC 3831 IPv6-over-Fibre Channel is ever implemented it may
185 * also need a pad of 2.
187 static int ndisc_addr_option_pad(unsigned short type
)
190 case ARPHRD_INFINIBAND
: return 2;
195 static inline int ndisc_opt_addr_space(struct net_device
*dev
)
197 return NDISC_OPT_SPACE(dev
->addr_len
+ ndisc_addr_option_pad(dev
->type
));
200 static u8
*ndisc_fill_addr_option(u8
*opt
, int type
, void *data
, int data_len
,
201 unsigned short addr_type
)
203 int space
= NDISC_OPT_SPACE(data_len
);
204 int pad
= ndisc_addr_option_pad(addr_type
);
209 memset(opt
+ 2, 0, pad
);
213 memcpy(opt
+2, data
, data_len
);
216 if ((space
-= data_len
) > 0)
217 memset(opt
, 0, space
);
221 static struct nd_opt_hdr
*ndisc_next_option(struct nd_opt_hdr
*cur
,
222 struct nd_opt_hdr
*end
)
225 if (!cur
|| !end
|| cur
>= end
)
227 type
= cur
->nd_opt_type
;
229 cur
= ((void *)cur
) + (cur
->nd_opt_len
<< 3);
230 } while(cur
< end
&& cur
->nd_opt_type
!= type
);
231 return (cur
<= end
&& cur
->nd_opt_type
== type
? cur
: NULL
);
234 static inline int ndisc_is_useropt(struct nd_opt_hdr
*opt
)
236 return (opt
->nd_opt_type
== ND_OPT_RDNSS
);
239 static struct nd_opt_hdr
*ndisc_next_useropt(struct nd_opt_hdr
*cur
,
240 struct nd_opt_hdr
*end
)
242 if (!cur
|| !end
|| cur
>= end
)
245 cur
= ((void *)cur
) + (cur
->nd_opt_len
<< 3);
246 } while(cur
< end
&& !ndisc_is_useropt(cur
));
247 return (cur
<= end
&& ndisc_is_useropt(cur
) ? cur
: NULL
);
250 static struct ndisc_options
*ndisc_parse_options(u8
*opt
, int opt_len
,
251 struct ndisc_options
*ndopts
)
253 struct nd_opt_hdr
*nd_opt
= (struct nd_opt_hdr
*)opt
;
255 if (!nd_opt
|| opt_len
< 0 || !ndopts
)
257 memset(ndopts
, 0, sizeof(*ndopts
));
260 if (opt_len
< sizeof(struct nd_opt_hdr
))
262 l
= nd_opt
->nd_opt_len
<< 3;
263 if (opt_len
< l
|| l
== 0)
265 switch (nd_opt
->nd_opt_type
) {
266 case ND_OPT_SOURCE_LL_ADDR
:
267 case ND_OPT_TARGET_LL_ADDR
:
269 case ND_OPT_REDIRECT_HDR
:
270 if (ndopts
->nd_opt_array
[nd_opt
->nd_opt_type
]) {
271 ND_PRINTK2(KERN_WARNING
272 "%s(): duplicated ND6 option found: type=%d\n",
274 nd_opt
->nd_opt_type
);
276 ndopts
->nd_opt_array
[nd_opt
->nd_opt_type
] = nd_opt
;
279 case ND_OPT_PREFIX_INFO
:
280 ndopts
->nd_opts_pi_end
= nd_opt
;
281 if (!ndopts
->nd_opt_array
[nd_opt
->nd_opt_type
])
282 ndopts
->nd_opt_array
[nd_opt
->nd_opt_type
] = nd_opt
;
284 #ifdef CONFIG_IPV6_ROUTE_INFO
285 case ND_OPT_ROUTE_INFO
:
286 ndopts
->nd_opts_ri_end
= nd_opt
;
287 if (!ndopts
->nd_opts_ri
)
288 ndopts
->nd_opts_ri
= nd_opt
;
292 if (ndisc_is_useropt(nd_opt
)) {
293 ndopts
->nd_useropts_end
= nd_opt
;
294 if (!ndopts
->nd_useropts
)
295 ndopts
->nd_useropts
= nd_opt
;
298 * Unknown options must be silently ignored,
299 * to accommodate future extension to the
302 ND_PRINTK2(KERN_NOTICE
303 "%s(): ignored unsupported option; type=%d, len=%d\n",
305 nd_opt
->nd_opt_type
, nd_opt
->nd_opt_len
);
309 nd_opt
= ((void *)nd_opt
) + l
;
314 static inline u8
*ndisc_opt_addr_data(struct nd_opt_hdr
*p
,
315 struct net_device
*dev
)
317 u8
*lladdr
= (u8
*)(p
+ 1);
318 int lladdrlen
= p
->nd_opt_len
<< 3;
319 int prepad
= ndisc_addr_option_pad(dev
->type
);
320 if (lladdrlen
!= NDISC_OPT_SPACE(dev
->addr_len
+ prepad
))
322 return (lladdr
+ prepad
);
325 int ndisc_mc_map(struct in6_addr
*addr
, char *buf
, struct net_device
*dev
, int dir
)
329 case ARPHRD_IEEE802
: /* Not sure. Check it later. --ANK */
331 ipv6_eth_mc_map(addr
, buf
);
333 case ARPHRD_IEEE802_TR
:
334 ipv6_tr_mc_map(addr
,buf
);
337 ipv6_arcnet_mc_map(addr
, buf
);
339 case ARPHRD_INFINIBAND
:
340 ipv6_ib_mc_map(addr
, dev
->broadcast
, buf
);
344 memcpy(buf
, dev
->broadcast
, dev
->addr_len
);
351 EXPORT_SYMBOL(ndisc_mc_map
);
353 static u32
ndisc_hash(const void *pkey
, const struct net_device
*dev
)
355 const u32
*p32
= pkey
;
359 for (i
= 0; i
< (sizeof(struct in6_addr
) / sizeof(u32
)); i
++)
362 return jhash_2words(addr_hash
, dev
->ifindex
, nd_tbl
.hash_rnd
);
365 static int ndisc_constructor(struct neighbour
*neigh
)
367 struct in6_addr
*addr
= (struct in6_addr
*)&neigh
->primary_key
;
368 struct net_device
*dev
= neigh
->dev
;
369 struct inet6_dev
*in6_dev
;
370 struct neigh_parms
*parms
;
371 int is_multicast
= ipv6_addr_is_multicast(addr
);
374 in6_dev
= in6_dev_get(dev
);
375 if (in6_dev
== NULL
) {
380 parms
= in6_dev
->nd_parms
;
381 __neigh_parms_put(neigh
->parms
);
382 neigh
->parms
= neigh_parms_clone(parms
);
385 neigh
->type
= is_multicast
? RTN_MULTICAST
: RTN_UNICAST
;
386 if (!dev
->header_ops
) {
387 neigh
->nud_state
= NUD_NOARP
;
388 neigh
->ops
= &ndisc_direct_ops
;
389 neigh
->output
= neigh
->ops
->queue_xmit
;
392 neigh
->nud_state
= NUD_NOARP
;
393 ndisc_mc_map(addr
, neigh
->ha
, dev
, 1);
394 } else if (dev
->flags
&(IFF_NOARP
|IFF_LOOPBACK
)) {
395 neigh
->nud_state
= NUD_NOARP
;
396 memcpy(neigh
->ha
, dev
->dev_addr
, dev
->addr_len
);
397 if (dev
->flags
&IFF_LOOPBACK
)
398 neigh
->type
= RTN_LOCAL
;
399 } else if (dev
->flags
&IFF_POINTOPOINT
) {
400 neigh
->nud_state
= NUD_NOARP
;
401 memcpy(neigh
->ha
, dev
->broadcast
, dev
->addr_len
);
403 if (dev
->header_ops
->cache
)
404 neigh
->ops
= &ndisc_hh_ops
;
406 neigh
->ops
= &ndisc_generic_ops
;
407 if (neigh
->nud_state
&NUD_VALID
)
408 neigh
->output
= neigh
->ops
->connected_output
;
410 neigh
->output
= neigh
->ops
->output
;
412 in6_dev_put(in6_dev
);
416 static int pndisc_constructor(struct pneigh_entry
*n
)
418 struct in6_addr
*addr
= (struct in6_addr
*)&n
->key
;
419 struct in6_addr maddr
;
420 struct net_device
*dev
= n
->dev
;
422 if (dev
== NULL
|| __in6_dev_get(dev
) == NULL
)
424 addrconf_addr_solict_mult(addr
, &maddr
);
425 ipv6_dev_mc_inc(dev
, &maddr
);
429 static void pndisc_destructor(struct pneigh_entry
*n
)
431 struct in6_addr
*addr
= (struct in6_addr
*)&n
->key
;
432 struct in6_addr maddr
;
433 struct net_device
*dev
= n
->dev
;
435 if (dev
== NULL
|| __in6_dev_get(dev
) == NULL
)
437 addrconf_addr_solict_mult(addr
, &maddr
);
438 ipv6_dev_mc_dec(dev
, &maddr
);
442 * Send a Neighbour Advertisement
444 static void __ndisc_send(struct net_device
*dev
,
445 struct neighbour
*neigh
,
446 struct in6_addr
*daddr
, struct in6_addr
*saddr
,
447 struct icmp6hdr
*icmp6h
, struct in6_addr
*target
,
451 struct dst_entry
*dst
;
452 struct sock
*sk
= ndisc_socket
->sk
;
454 struct icmp6hdr
*hdr
;
455 struct inet6_dev
*idev
;
460 type
= icmp6h
->icmp6_type
;
462 icmpv6_flow_init(ndisc_socket
->sk
, &fl
, type
,
463 saddr
, daddr
, dev
->ifindex
);
465 dst
= icmp6_dst_alloc(dev
, neigh
, daddr
);
469 err
= xfrm_lookup(&dst
, &fl
, NULL
, 0);
476 len
= sizeof(struct icmp6hdr
) + (target
? sizeof(*target
) : 0);
478 len
+= ndisc_opt_addr_space(dev
);
480 skb
= sock_alloc_send_skb(sk
,
481 (MAX_HEADER
+ sizeof(struct ipv6hdr
) +
482 len
+ LL_RESERVED_SPACE(dev
)),
486 "ICMPv6 ND: %s() failed to allocate an skb.\n",
492 skb_reserve(skb
, LL_RESERVED_SPACE(dev
));
493 ip6_nd_hdr(sk
, skb
, dev
, saddr
, daddr
, IPPROTO_ICMPV6
, len
);
495 skb
->transport_header
= skb
->tail
;
498 hdr
= (struct icmp6hdr
*)skb_transport_header(skb
);
499 memcpy(hdr
, icmp6h
, sizeof(*hdr
));
501 opt
= skb_transport_header(skb
) + sizeof(struct icmp6hdr
);
503 ipv6_addr_copy((struct in6_addr
*)opt
, target
);
504 opt
+= sizeof(*target
);
508 ndisc_fill_addr_option(opt
, llinfo
, dev
->dev_addr
,
509 dev
->addr_len
, dev
->type
);
511 hdr
->icmp6_cksum
= csum_ipv6_magic(saddr
, daddr
, len
,
513 csum_partial((__u8
*) hdr
,
518 idev
= in6_dev_get(dst
->dev
);
519 IP6_INC_STATS(idev
, IPSTATS_MIB_OUTREQUESTS
);
521 err
= NF_HOOK(PF_INET6
, NF_INET_LOCAL_OUT
, skb
, NULL
, dst
->dev
,
524 ICMP6MSGOUT_INC_STATS(idev
, type
);
525 ICMP6_INC_STATS(idev
, ICMP6_MIB_OUTMSGS
);
528 if (likely(idev
!= NULL
))
532 static void ndisc_send_na(struct net_device
*dev
, struct neighbour
*neigh
,
533 struct in6_addr
*daddr
, struct in6_addr
*solicited_addr
,
534 int router
, int solicited
, int override
, int inc_opt
)
536 struct in6_addr tmpaddr
;
537 struct inet6_ifaddr
*ifp
;
538 struct in6_addr
*src_addr
;
539 struct icmp6hdr icmp6h
= {
540 .icmp6_type
= NDISC_NEIGHBOUR_ADVERTISEMENT
,
543 /* for anycast or proxy, solicited_addr != src_addr */
544 ifp
= ipv6_get_ifaddr(&init_net
, solicited_addr
, dev
, 1);
546 src_addr
= solicited_addr
;
547 if (ifp
->flags
& IFA_F_OPTIMISTIC
)
551 if (ipv6_dev_get_saddr(dev
, daddr
, &tmpaddr
))
556 icmp6h
.icmp6_router
= router
;
557 icmp6h
.icmp6_solicited
= solicited
;
558 icmp6h
.icmp6_override
= override
;
560 __ndisc_send(dev
, neigh
, daddr
, src_addr
,
561 &icmp6h
, solicited_addr
,
562 inc_opt
? ND_OPT_TARGET_LL_ADDR
: 0);
565 void ndisc_send_ns(struct net_device
*dev
, struct neighbour
*neigh
,
566 struct in6_addr
*solicit
,
567 struct in6_addr
*daddr
, struct in6_addr
*saddr
)
569 struct in6_addr addr_buf
;
570 struct icmp6hdr icmp6h
= {
571 .icmp6_type
= NDISC_NEIGHBOUR_SOLICITATION
,
575 if (ipv6_get_lladdr(dev
, &addr_buf
,
576 (IFA_F_TENTATIVE
|IFA_F_OPTIMISTIC
)))
581 __ndisc_send(dev
, neigh
, daddr
, saddr
,
583 !ipv6_addr_any(saddr
) ? ND_OPT_SOURCE_LL_ADDR
: 0);
586 void ndisc_send_rs(struct net_device
*dev
, struct in6_addr
*saddr
,
587 struct in6_addr
*daddr
)
589 struct icmp6hdr icmp6h
= {
590 .icmp6_type
= NDISC_ROUTER_SOLICITATION
,
592 int send_sllao
= dev
->addr_len
;
594 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
596 * According to section 2.2 of RFC 4429, we must not
597 * send router solicitations with a sllao from
598 * optimistic addresses, but we may send the solicitation
599 * if we don't include the sllao. So here we check
600 * if our address is optimistic, and if so, we
601 * suppress the inclusion of the sllao.
604 struct inet6_ifaddr
*ifp
= ipv6_get_ifaddr(&init_net
, saddr
,
607 if (ifp
->flags
& IFA_F_OPTIMISTIC
) {
616 __ndisc_send(dev
, NULL
, daddr
, saddr
,
618 send_sllao
? ND_OPT_SOURCE_LL_ADDR
: 0);
622 static void ndisc_error_report(struct neighbour
*neigh
, struct sk_buff
*skb
)
625 * "The sender MUST return an ICMP
626 * destination unreachable"
628 dst_link_failure(skb
);
632 /* Called with locked neigh: either read or both */
634 static void ndisc_solicit(struct neighbour
*neigh
, struct sk_buff
*skb
)
636 struct in6_addr
*saddr
= NULL
;
637 struct in6_addr mcaddr
;
638 struct net_device
*dev
= neigh
->dev
;
639 struct in6_addr
*target
= (struct in6_addr
*)&neigh
->primary_key
;
640 int probes
= atomic_read(&neigh
->probes
);
642 if (skb
&& ipv6_chk_addr(&init_net
, &ipv6_hdr(skb
)->saddr
, dev
, 1))
643 saddr
= &ipv6_hdr(skb
)->saddr
;
645 if ((probes
-= neigh
->parms
->ucast_probes
) < 0) {
646 if (!(neigh
->nud_state
& NUD_VALID
)) {
647 ND_PRINTK1(KERN_DEBUG
648 "%s(): trying to ucast probe in NUD_INVALID: "
653 ndisc_send_ns(dev
, neigh
, target
, target
, saddr
);
654 } else if ((probes
-= neigh
->parms
->app_probes
) < 0) {
659 addrconf_addr_solict_mult(target
, &mcaddr
);
660 ndisc_send_ns(dev
, NULL
, target
, &mcaddr
, saddr
);
664 static void ndisc_recv_ns(struct sk_buff
*skb
)
666 struct nd_msg
*msg
= (struct nd_msg
*)skb_transport_header(skb
);
667 struct in6_addr
*saddr
= &ipv6_hdr(skb
)->saddr
;
668 struct in6_addr
*daddr
= &ipv6_hdr(skb
)->daddr
;
670 u32 ndoptlen
= skb
->tail
- (skb
->transport_header
+
671 offsetof(struct nd_msg
, opt
));
672 struct ndisc_options ndopts
;
673 struct net_device
*dev
= skb
->dev
;
674 struct inet6_ifaddr
*ifp
;
675 struct inet6_dev
*idev
= NULL
;
676 struct neighbour
*neigh
;
677 struct pneigh_entry
*pneigh
= NULL
;
678 int dad
= ipv6_addr_any(saddr
);
682 if (ipv6_addr_is_multicast(&msg
->target
)) {
683 ND_PRINTK2(KERN_WARNING
684 "ICMPv6 NS: multicast target address");
690 * DAD has to be destined for solicited node multicast address.
693 !(daddr
->s6_addr32
[0] == htonl(0xff020000) &&
694 daddr
->s6_addr32
[1] == htonl(0x00000000) &&
695 daddr
->s6_addr32
[2] == htonl(0x00000001) &&
696 daddr
->s6_addr
[12] == 0xff )) {
697 ND_PRINTK2(KERN_WARNING
698 "ICMPv6 NS: bad DAD packet (wrong destination)\n");
702 if (!ndisc_parse_options(msg
->opt
, ndoptlen
, &ndopts
)) {
703 ND_PRINTK2(KERN_WARNING
704 "ICMPv6 NS: invalid ND options\n");
708 if (ndopts
.nd_opts_src_lladdr
) {
709 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_src_lladdr
, dev
);
711 ND_PRINTK2(KERN_WARNING
712 "ICMPv6 NS: invalid link-layer address length\n");
717 * If the IP source address is the unspecified address,
718 * there MUST NOT be source link-layer address option
722 ND_PRINTK2(KERN_WARNING
723 "ICMPv6 NS: bad DAD packet (link-layer address option)\n");
728 inc
= ipv6_addr_is_multicast(daddr
);
730 if ((ifp
= ipv6_get_ifaddr(&init_net
, &msg
->target
, dev
, 1)) != NULL
) {
732 if (ifp
->flags
& (IFA_F_TENTATIVE
|IFA_F_OPTIMISTIC
)) {
734 if (dev
->type
== ARPHRD_IEEE802_TR
) {
735 const unsigned char *sadr
;
736 sadr
= skb_mac_header(skb
);
737 if (((sadr
[8] ^ dev
->dev_addr
[0]) & 0x7f) == 0 &&
738 sadr
[9] == dev
->dev_addr
[1] &&
739 sadr
[10] == dev
->dev_addr
[2] &&
740 sadr
[11] == dev
->dev_addr
[3] &&
741 sadr
[12] == dev
->dev_addr
[4] &&
742 sadr
[13] == dev
->dev_addr
[5]) {
743 /* looped-back to us */
749 * We are colliding with another node
751 * so fail our DAD process
753 addrconf_dad_failure(ifp
);
757 * This is not a dad solicitation.
758 * If we are an optimistic node,
760 * Otherwise, we should ignore it.
762 if (!(ifp
->flags
& IFA_F_OPTIMISTIC
))
769 idev
= in6_dev_get(dev
);
771 /* XXX: count this drop? */
775 if (ipv6_chk_acast_addr(dev
, &msg
->target
) ||
776 (idev
->cnf
.forwarding
&&
777 (ipv6_devconf
.proxy_ndp
|| idev
->cnf
.proxy_ndp
) &&
778 (pneigh
= pneigh_lookup(&nd_tbl
, &init_net
,
779 &msg
->target
, dev
, 0)) != NULL
)) {
780 if (!(NEIGH_CB(skb
)->flags
& LOCALLY_ENQUEUED
) &&
781 skb
->pkt_type
!= PACKET_HOST
&&
783 idev
->nd_parms
->proxy_delay
!= 0) {
785 * for anycast or proxy,
786 * sender should delay its response
787 * by a random time between 0 and
788 * MAX_ANYCAST_DELAY_TIME seconds.
789 * (RFC2461) -- yoshfuji
791 struct sk_buff
*n
= skb_clone(skb
, GFP_ATOMIC
);
793 pneigh_enqueue(&nd_tbl
, idev
->nd_parms
, n
);
800 is_router
= !!(pneigh
? pneigh
->flags
& NTF_ROUTER
: idev
->cnf
.forwarding
);
803 struct in6_addr maddr
;
805 ipv6_addr_all_nodes(&maddr
);
806 ndisc_send_na(dev
, NULL
, &maddr
, &msg
->target
,
807 is_router
, 0, (ifp
!= NULL
), 1);
812 NEIGH_CACHE_STAT_INC(&nd_tbl
, rcv_probes_mcast
);
814 NEIGH_CACHE_STAT_INC(&nd_tbl
, rcv_probes_ucast
);
817 * update / create cache entry
818 * for the source address
820 neigh
= __neigh_lookup(&nd_tbl
, saddr
, dev
,
821 !inc
|| lladdr
|| !dev
->addr_len
);
823 neigh_update(neigh
, lladdr
, NUD_STALE
,
824 NEIGH_UPDATE_F_WEAK_OVERRIDE
|
825 NEIGH_UPDATE_F_OVERRIDE
);
826 if (neigh
|| !dev
->header_ops
) {
827 ndisc_send_na(dev
, neigh
, saddr
, &msg
->target
,
829 1, (ifp
!= NULL
&& inc
), inc
);
831 neigh_release(neigh
);
843 static void ndisc_recv_na(struct sk_buff
*skb
)
845 struct nd_msg
*msg
= (struct nd_msg
*)skb_transport_header(skb
);
846 struct in6_addr
*saddr
= &ipv6_hdr(skb
)->saddr
;
847 struct in6_addr
*daddr
= &ipv6_hdr(skb
)->daddr
;
849 u32 ndoptlen
= skb
->tail
- (skb
->transport_header
+
850 offsetof(struct nd_msg
, opt
));
851 struct ndisc_options ndopts
;
852 struct net_device
*dev
= skb
->dev
;
853 struct inet6_ifaddr
*ifp
;
854 struct neighbour
*neigh
;
856 if (skb
->len
< sizeof(struct nd_msg
)) {
857 ND_PRINTK2(KERN_WARNING
858 "ICMPv6 NA: packet too short\n");
862 if (ipv6_addr_is_multicast(&msg
->target
)) {
863 ND_PRINTK2(KERN_WARNING
864 "ICMPv6 NA: target address is multicast.\n");
868 if (ipv6_addr_is_multicast(daddr
) &&
869 msg
->icmph
.icmp6_solicited
) {
870 ND_PRINTK2(KERN_WARNING
871 "ICMPv6 NA: solicited NA is multicasted.\n");
875 if (!ndisc_parse_options(msg
->opt
, ndoptlen
, &ndopts
)) {
876 ND_PRINTK2(KERN_WARNING
877 "ICMPv6 NS: invalid ND option\n");
880 if (ndopts
.nd_opts_tgt_lladdr
) {
881 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_tgt_lladdr
, dev
);
883 ND_PRINTK2(KERN_WARNING
884 "ICMPv6 NA: invalid link-layer address length\n");
888 if ((ifp
= ipv6_get_ifaddr(&init_net
, &msg
->target
, dev
, 1))) {
889 if (ifp
->flags
& IFA_F_TENTATIVE
) {
890 addrconf_dad_failure(ifp
);
893 /* What should we make now? The advertisement
894 is invalid, but ndisc specs say nothing
895 about it. It could be misconfiguration, or
896 an smart proxy agent tries to help us :-)
898 ND_PRINTK1(KERN_WARNING
899 "ICMPv6 NA: someone advertises our address on %s!\n",
900 ifp
->idev
->dev
->name
);
904 neigh
= neigh_lookup(&nd_tbl
, &msg
->target
, dev
);
907 u8 old_flags
= neigh
->flags
;
909 if (neigh
->nud_state
& NUD_FAILED
)
913 * Don't update the neighbor cache entry on a proxy NA from
914 * ourselves because either the proxied node is off link or it
915 * has already sent a NA to us.
917 if (lladdr
&& !memcmp(lladdr
, dev
->dev_addr
, dev
->addr_len
) &&
918 ipv6_devconf
.forwarding
&& ipv6_devconf
.proxy_ndp
&&
919 pneigh_lookup(&nd_tbl
, &init_net
, &msg
->target
, dev
, 0)) {
920 /* XXX: idev->cnf.prixy_ndp */
924 neigh_update(neigh
, lladdr
,
925 msg
->icmph
.icmp6_solicited
? NUD_REACHABLE
: NUD_STALE
,
926 NEIGH_UPDATE_F_WEAK_OVERRIDE
|
927 (msg
->icmph
.icmp6_override
? NEIGH_UPDATE_F_OVERRIDE
: 0)|
928 NEIGH_UPDATE_F_OVERRIDE_ISROUTER
|
929 (msg
->icmph
.icmp6_router
? NEIGH_UPDATE_F_ISROUTER
: 0));
931 if ((old_flags
& ~neigh
->flags
) & NTF_ROUTER
) {
933 * Change: router to host
936 rt
= rt6_get_dflt_router(saddr
, dev
);
942 neigh_release(neigh
);
946 static void ndisc_recv_rs(struct sk_buff
*skb
)
948 struct rs_msg
*rs_msg
= (struct rs_msg
*)skb_transport_header(skb
);
949 unsigned long ndoptlen
= skb
->len
- sizeof(*rs_msg
);
950 struct neighbour
*neigh
;
951 struct inet6_dev
*idev
;
952 struct in6_addr
*saddr
= &ipv6_hdr(skb
)->saddr
;
953 struct ndisc_options ndopts
;
956 if (skb
->len
< sizeof(*rs_msg
))
959 idev
= in6_dev_get(skb
->dev
);
962 ND_PRINTK1("ICMP6 RS: can't find in6 device\n");
966 /* Don't accept RS if we're not in router mode */
967 if (!idev
->cnf
.forwarding
)
971 * Don't update NCE if src = ::;
972 * this implies that the source node has no ip address assigned yet.
974 if (ipv6_addr_any(saddr
))
977 /* Parse ND options */
978 if (!ndisc_parse_options(rs_msg
->opt
, ndoptlen
, &ndopts
)) {
980 ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n");
984 if (ndopts
.nd_opts_src_lladdr
) {
985 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_src_lladdr
,
991 neigh
= __neigh_lookup(&nd_tbl
, saddr
, skb
->dev
, 1);
993 neigh_update(neigh
, lladdr
, NUD_STALE
,
994 NEIGH_UPDATE_F_WEAK_OVERRIDE
|
995 NEIGH_UPDATE_F_OVERRIDE
|
996 NEIGH_UPDATE_F_OVERRIDE_ISROUTER
);
997 neigh_release(neigh
);
1003 static void ndisc_ra_useropt(struct sk_buff
*ra
, struct nd_opt_hdr
*opt
)
1005 struct icmp6hdr
*icmp6h
= (struct icmp6hdr
*)skb_transport_header(ra
);
1006 struct sk_buff
*skb
;
1007 struct nlmsghdr
*nlh
;
1008 struct nduseroptmsg
*ndmsg
;
1010 int base_size
= NLMSG_ALIGN(sizeof(struct nduseroptmsg
)
1011 + (opt
->nd_opt_len
<< 3));
1012 size_t msg_size
= base_size
+ nla_total_size(sizeof(struct in6_addr
));
1014 skb
= nlmsg_new(msg_size
, GFP_ATOMIC
);
1020 nlh
= nlmsg_put(skb
, 0, 0, RTM_NEWNDUSEROPT
, base_size
, 0);
1022 goto nla_put_failure
;
1025 ndmsg
= nlmsg_data(nlh
);
1026 ndmsg
->nduseropt_family
= AF_INET6
;
1027 ndmsg
->nduseropt_ifindex
= ra
->dev
->ifindex
;
1028 ndmsg
->nduseropt_icmp_type
= icmp6h
->icmp6_type
;
1029 ndmsg
->nduseropt_icmp_code
= icmp6h
->icmp6_code
;
1030 ndmsg
->nduseropt_opts_len
= opt
->nd_opt_len
<< 3;
1032 memcpy(ndmsg
+ 1, opt
, opt
->nd_opt_len
<< 3);
1034 NLA_PUT(skb
, NDUSEROPT_SRCADDR
, sizeof(struct in6_addr
),
1035 &ipv6_hdr(ra
)->saddr
);
1036 nlmsg_end(skb
, nlh
);
1038 err
= rtnl_notify(skb
, &init_net
, 0, RTNLGRP_ND_USEROPT
, NULL
,
1049 rtnl_set_sk_err(&init_net
, RTNLGRP_ND_USEROPT
, err
);
1052 static void ndisc_router_discovery(struct sk_buff
*skb
)
1054 struct ra_msg
*ra_msg
= (struct ra_msg
*)skb_transport_header(skb
);
1055 struct neighbour
*neigh
= NULL
;
1056 struct inet6_dev
*in6_dev
;
1057 struct rt6_info
*rt
= NULL
;
1059 struct ndisc_options ndopts
;
1061 unsigned int pref
= 0;
1063 __u8
* opt
= (__u8
*)(ra_msg
+ 1);
1065 optlen
= (skb
->tail
- skb
->transport_header
) - sizeof(struct ra_msg
);
1067 if (!(ipv6_addr_type(&ipv6_hdr(skb
)->saddr
) & IPV6_ADDR_LINKLOCAL
)) {
1068 ND_PRINTK2(KERN_WARNING
1069 "ICMPv6 RA: source address is not link-local.\n");
1073 ND_PRINTK2(KERN_WARNING
1074 "ICMPv6 RA: packet too short\n");
1079 * set the RA_RECV flag in the interface
1082 in6_dev
= in6_dev_get(skb
->dev
);
1083 if (in6_dev
== NULL
) {
1085 "ICMPv6 RA: can't find inet6 device for %s.\n",
1089 if (in6_dev
->cnf
.forwarding
|| !in6_dev
->cnf
.accept_ra
) {
1090 in6_dev_put(in6_dev
);
1094 if (!ndisc_parse_options(opt
, optlen
, &ndopts
)) {
1095 in6_dev_put(in6_dev
);
1096 ND_PRINTK2(KERN_WARNING
1097 "ICMP6 RA: invalid ND options\n");
1101 if (in6_dev
->if_flags
& IF_RS_SENT
) {
1103 * flag that an RA was received after an RS was sent
1104 * out on this interface.
1106 in6_dev
->if_flags
|= IF_RA_RCVD
;
1110 * Remember the managed/otherconf flags from most recently
1111 * received RA message (RFC 2462) -- yoshfuji
1113 in6_dev
->if_flags
= (in6_dev
->if_flags
& ~(IF_RA_MANAGED
|
1115 (ra_msg
->icmph
.icmp6_addrconf_managed
?
1116 IF_RA_MANAGED
: 0) |
1117 (ra_msg
->icmph
.icmp6_addrconf_other
?
1118 IF_RA_OTHERCONF
: 0);
1120 if (!in6_dev
->cnf
.accept_ra_defrtr
)
1123 lifetime
= ntohs(ra_msg
->icmph
.icmp6_rt_lifetime
);
1125 #ifdef CONFIG_IPV6_ROUTER_PREF
1126 pref
= ra_msg
->icmph
.icmp6_router_pref
;
1127 /* 10b is handled as if it were 00b (medium) */
1128 if (pref
== ICMPV6_ROUTER_PREF_INVALID
||
1129 !in6_dev
->cnf
.accept_ra_rtr_pref
)
1130 pref
= ICMPV6_ROUTER_PREF_MEDIUM
;
1133 rt
= rt6_get_dflt_router(&ipv6_hdr(skb
)->saddr
, skb
->dev
);
1136 neigh
= rt
->rt6i_nexthop
;
1138 if (rt
&& lifetime
== 0) {
1144 if (rt
== NULL
&& lifetime
) {
1145 ND_PRINTK3(KERN_DEBUG
1146 "ICMPv6 RA: adding default router.\n");
1148 rt
= rt6_add_dflt_router(&ipv6_hdr(skb
)->saddr
, skb
->dev
, pref
);
1151 "ICMPv6 RA: %s() failed to add default route.\n",
1153 in6_dev_put(in6_dev
);
1157 neigh
= rt
->rt6i_nexthop
;
1158 if (neigh
== NULL
) {
1160 "ICMPv6 RA: %s() got default router without neighbour.\n",
1162 dst_release(&rt
->u
.dst
);
1163 in6_dev_put(in6_dev
);
1166 neigh
->flags
|= NTF_ROUTER
;
1168 rt
->rt6i_flags
|= (rt
->rt6i_flags
& ~RTF_PREF_MASK
) | RTF_PREF(pref
);
1172 rt
->rt6i_expires
= jiffies
+ (HZ
* lifetime
);
1174 if (ra_msg
->icmph
.icmp6_hop_limit
) {
1175 in6_dev
->cnf
.hop_limit
= ra_msg
->icmph
.icmp6_hop_limit
;
1177 rt
->u
.dst
.metrics
[RTAX_HOPLIMIT
-1] = ra_msg
->icmph
.icmp6_hop_limit
;
1183 * Update Reachable Time and Retrans Timer
1186 if (in6_dev
->nd_parms
) {
1187 unsigned long rtime
= ntohl(ra_msg
->retrans_timer
);
1189 if (rtime
&& rtime
/1000 < MAX_SCHEDULE_TIMEOUT
/HZ
) {
1190 rtime
= (rtime
*HZ
)/1000;
1193 in6_dev
->nd_parms
->retrans_time
= rtime
;
1194 in6_dev
->tstamp
= jiffies
;
1195 inet6_ifinfo_notify(RTM_NEWLINK
, in6_dev
);
1198 rtime
= ntohl(ra_msg
->reachable_time
);
1199 if (rtime
&& rtime
/1000 < MAX_SCHEDULE_TIMEOUT
/(3*HZ
)) {
1200 rtime
= (rtime
*HZ
)/1000;
1205 if (rtime
!= in6_dev
->nd_parms
->base_reachable_time
) {
1206 in6_dev
->nd_parms
->base_reachable_time
= rtime
;
1207 in6_dev
->nd_parms
->gc_staletime
= 3 * rtime
;
1208 in6_dev
->nd_parms
->reachable_time
= neigh_rand_reach_time(rtime
);
1209 in6_dev
->tstamp
= jiffies
;
1210 inet6_ifinfo_notify(RTM_NEWLINK
, in6_dev
);
1220 neigh
= __neigh_lookup(&nd_tbl
, &ipv6_hdr(skb
)->saddr
,
1224 if (ndopts
.nd_opts_src_lladdr
) {
1225 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_src_lladdr
,
1228 ND_PRINTK2(KERN_WARNING
1229 "ICMPv6 RA: invalid link-layer address length\n");
1233 neigh_update(neigh
, lladdr
, NUD_STALE
,
1234 NEIGH_UPDATE_F_WEAK_OVERRIDE
|
1235 NEIGH_UPDATE_F_OVERRIDE
|
1236 NEIGH_UPDATE_F_OVERRIDE_ISROUTER
|
1237 NEIGH_UPDATE_F_ISROUTER
);
1240 #ifdef CONFIG_IPV6_ROUTE_INFO
1241 if (in6_dev
->cnf
.accept_ra_rtr_pref
&& ndopts
.nd_opts_ri
) {
1242 struct nd_opt_hdr
*p
;
1243 for (p
= ndopts
.nd_opts_ri
;
1245 p
= ndisc_next_option(p
, ndopts
.nd_opts_ri_end
)) {
1246 if (((struct route_info
*)p
)->prefix_len
> in6_dev
->cnf
.accept_ra_rt_info_max_plen
)
1248 rt6_route_rcv(skb
->dev
, (u8
*)p
, (p
->nd_opt_len
) << 3,
1249 &ipv6_hdr(skb
)->saddr
);
1254 if (in6_dev
->cnf
.accept_ra_pinfo
&& ndopts
.nd_opts_pi
) {
1255 struct nd_opt_hdr
*p
;
1256 for (p
= ndopts
.nd_opts_pi
;
1258 p
= ndisc_next_option(p
, ndopts
.nd_opts_pi_end
)) {
1259 addrconf_prefix_rcv(skb
->dev
, (u8
*)p
, (p
->nd_opt_len
) << 3);
1263 if (ndopts
.nd_opts_mtu
) {
1267 memcpy(&n
, ((u8
*)(ndopts
.nd_opts_mtu
+1))+2, sizeof(mtu
));
1270 if (mtu
< IPV6_MIN_MTU
|| mtu
> skb
->dev
->mtu
) {
1271 ND_PRINTK2(KERN_WARNING
1272 "ICMPv6 RA: invalid mtu: %d\n",
1274 } else if (in6_dev
->cnf
.mtu6
!= mtu
) {
1275 in6_dev
->cnf
.mtu6
= mtu
;
1278 rt
->u
.dst
.metrics
[RTAX_MTU
-1] = mtu
;
1280 rt6_mtu_change(skb
->dev
, mtu
);
1284 if (ndopts
.nd_useropts
) {
1285 struct nd_opt_hdr
*p
;
1286 for (p
= ndopts
.nd_useropts
;
1288 p
= ndisc_next_useropt(p
, ndopts
.nd_useropts_end
)) {
1289 ndisc_ra_useropt(skb
, p
);
1293 if (ndopts
.nd_opts_tgt_lladdr
|| ndopts
.nd_opts_rh
) {
1294 ND_PRINTK2(KERN_WARNING
1295 "ICMPv6 RA: invalid RA options");
1299 dst_release(&rt
->u
.dst
);
1301 neigh_release(neigh
);
1302 in6_dev_put(in6_dev
);
1305 static void ndisc_redirect_rcv(struct sk_buff
*skb
)
1307 struct inet6_dev
*in6_dev
;
1308 struct icmp6hdr
*icmph
;
1309 struct in6_addr
*dest
;
1310 struct in6_addr
*target
; /* new first hop to destination */
1311 struct neighbour
*neigh
;
1313 struct ndisc_options ndopts
;
1317 if (!(ipv6_addr_type(&ipv6_hdr(skb
)->saddr
) & IPV6_ADDR_LINKLOCAL
)) {
1318 ND_PRINTK2(KERN_WARNING
1319 "ICMPv6 Redirect: source address is not link-local.\n");
1323 optlen
= skb
->tail
- skb
->transport_header
;
1324 optlen
-= sizeof(struct icmp6hdr
) + 2 * sizeof(struct in6_addr
);
1327 ND_PRINTK2(KERN_WARNING
1328 "ICMPv6 Redirect: packet too short\n");
1332 icmph
= icmp6_hdr(skb
);
1333 target
= (struct in6_addr
*) (icmph
+ 1);
1336 if (ipv6_addr_is_multicast(dest
)) {
1337 ND_PRINTK2(KERN_WARNING
1338 "ICMPv6 Redirect: destination address is multicast.\n");
1342 if (ipv6_addr_equal(dest
, target
)) {
1344 } else if (ipv6_addr_type(target
) !=
1345 (IPV6_ADDR_UNICAST
|IPV6_ADDR_LINKLOCAL
)) {
1346 ND_PRINTK2(KERN_WARNING
1347 "ICMPv6 Redirect: target address is not link-local unicast.\n");
1351 in6_dev
= in6_dev_get(skb
->dev
);
1354 if (in6_dev
->cnf
.forwarding
|| !in6_dev
->cnf
.accept_redirects
) {
1355 in6_dev_put(in6_dev
);
1360 * The IP source address of the Redirect MUST be the same as the current
1361 * first-hop router for the specified ICMP Destination Address.
1364 if (!ndisc_parse_options((u8
*)(dest
+ 1), optlen
, &ndopts
)) {
1365 ND_PRINTK2(KERN_WARNING
1366 "ICMPv6 Redirect: invalid ND options\n");
1367 in6_dev_put(in6_dev
);
1370 if (ndopts
.nd_opts_tgt_lladdr
) {
1371 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_tgt_lladdr
,
1374 ND_PRINTK2(KERN_WARNING
1375 "ICMPv6 Redirect: invalid link-layer address length\n");
1376 in6_dev_put(in6_dev
);
1381 neigh
= __neigh_lookup(&nd_tbl
, target
, skb
->dev
, 1);
1383 rt6_redirect(dest
, &ipv6_hdr(skb
)->daddr
,
1384 &ipv6_hdr(skb
)->saddr
, neigh
, lladdr
,
1386 neigh_release(neigh
);
1388 in6_dev_put(in6_dev
);
1391 void ndisc_send_redirect(struct sk_buff
*skb
, struct neighbour
*neigh
,
1392 struct in6_addr
*target
)
1394 struct sock
*sk
= ndisc_socket
->sk
;
1395 int len
= sizeof(struct icmp6hdr
) + 2 * sizeof(struct in6_addr
);
1396 struct sk_buff
*buff
;
1397 struct icmp6hdr
*icmph
;
1398 struct in6_addr saddr_buf
;
1399 struct in6_addr
*addrp
;
1400 struct net_device
*dev
;
1401 struct rt6_info
*rt
;
1402 struct dst_entry
*dst
;
1403 struct inet6_dev
*idev
;
1409 u8 ha_buf
[MAX_ADDR_LEN
], *ha
= NULL
;
1413 if (ipv6_get_lladdr(dev
, &saddr_buf
, IFA_F_TENTATIVE
)) {
1414 ND_PRINTK2(KERN_WARNING
1415 "ICMPv6 Redirect: no link-local address on %s\n",
1420 if (!ipv6_addr_equal(&ipv6_hdr(skb
)->daddr
, target
) &&
1421 ipv6_addr_type(target
) != (IPV6_ADDR_UNICAST
|IPV6_ADDR_LINKLOCAL
)) {
1422 ND_PRINTK2(KERN_WARNING
1423 "ICMPv6 Redirect: target address is not link-local unicast.\n");
1427 icmpv6_flow_init(ndisc_socket
->sk
, &fl
, NDISC_REDIRECT
,
1428 &saddr_buf
, &ipv6_hdr(skb
)->saddr
, dev
->ifindex
);
1430 dst
= ip6_route_output(NULL
, &fl
);
1434 err
= xfrm_lookup(&dst
, &fl
, NULL
, 0);
1438 rt
= (struct rt6_info
*) dst
;
1440 if (rt
->rt6i_flags
& RTF_GATEWAY
) {
1441 ND_PRINTK2(KERN_WARNING
1442 "ICMPv6 Redirect: destination is not a neighbour.\n");
1446 if (!xrlim_allow(dst
, 1*HZ
)) {
1451 if (dev
->addr_len
) {
1452 read_lock_bh(&neigh
->lock
);
1453 if (neigh
->nud_state
& NUD_VALID
) {
1454 memcpy(ha_buf
, neigh
->ha
, dev
->addr_len
);
1455 read_unlock_bh(&neigh
->lock
);
1457 len
+= ndisc_opt_addr_space(dev
);
1459 read_unlock_bh(&neigh
->lock
);
1462 rd_len
= min_t(unsigned int,
1463 IPV6_MIN_MTU
-sizeof(struct ipv6hdr
)-len
, skb
->len
+ 8);
1467 buff
= sock_alloc_send_skb(sk
,
1468 (MAX_HEADER
+ sizeof(struct ipv6hdr
) +
1469 len
+ LL_RESERVED_SPACE(dev
)),
1473 "ICMPv6 Redirect: %s() failed to allocate an skb.\n",
1481 skb_reserve(buff
, LL_RESERVED_SPACE(dev
));
1482 ip6_nd_hdr(sk
, buff
, dev
, &saddr_buf
, &ipv6_hdr(skb
)->saddr
,
1483 IPPROTO_ICMPV6
, len
);
1485 skb_set_transport_header(buff
, skb_tail_pointer(buff
) - buff
->data
);
1487 icmph
= icmp6_hdr(buff
);
1489 memset(icmph
, 0, sizeof(struct icmp6hdr
));
1490 icmph
->icmp6_type
= NDISC_REDIRECT
;
1493 * copy target and destination addresses
1496 addrp
= (struct in6_addr
*)(icmph
+ 1);
1497 ipv6_addr_copy(addrp
, target
);
1499 ipv6_addr_copy(addrp
, &ipv6_hdr(skb
)->daddr
);
1501 opt
= (u8
*) (addrp
+ 1);
1504 * include target_address option
1508 opt
= ndisc_fill_addr_option(opt
, ND_OPT_TARGET_LL_ADDR
, ha
,
1509 dev
->addr_len
, dev
->type
);
1512 * build redirect option and copy skb over to the new packet.
1516 *(opt
++) = ND_OPT_REDIRECT_HDR
;
1517 *(opt
++) = (rd_len
>> 3);
1520 memcpy(opt
, ipv6_hdr(skb
), rd_len
- 8);
1522 icmph
->icmp6_cksum
= csum_ipv6_magic(&saddr_buf
, &ipv6_hdr(skb
)->saddr
,
1523 len
, IPPROTO_ICMPV6
,
1524 csum_partial((u8
*) icmph
, len
, 0));
1527 idev
= in6_dev_get(dst
->dev
);
1528 IP6_INC_STATS(idev
, IPSTATS_MIB_OUTREQUESTS
);
1529 err
= NF_HOOK(PF_INET6
, NF_INET_LOCAL_OUT
, buff
, NULL
, dst
->dev
,
1532 ICMP6MSGOUT_INC_STATS(idev
, NDISC_REDIRECT
);
1533 ICMP6_INC_STATS(idev
, ICMP6_MIB_OUTMSGS
);
1536 if (likely(idev
!= NULL
))
1540 static void pndisc_redo(struct sk_buff
*skb
)
1546 int ndisc_rcv(struct sk_buff
*skb
)
1550 if (!pskb_may_pull(skb
, skb
->len
))
1553 msg
= (struct nd_msg
*)skb_transport_header(skb
);
1555 __skb_push(skb
, skb
->data
- skb_transport_header(skb
));
1557 if (ipv6_hdr(skb
)->hop_limit
!= 255) {
1558 ND_PRINTK2(KERN_WARNING
1559 "ICMPv6 NDISC: invalid hop-limit: %d\n",
1560 ipv6_hdr(skb
)->hop_limit
);
1564 if (msg
->icmph
.icmp6_code
!= 0) {
1565 ND_PRINTK2(KERN_WARNING
1566 "ICMPv6 NDISC: invalid ICMPv6 code: %d\n",
1567 msg
->icmph
.icmp6_code
);
1571 memset(NEIGH_CB(skb
), 0, sizeof(struct neighbour_cb
));
1573 switch (msg
->icmph
.icmp6_type
) {
1574 case NDISC_NEIGHBOUR_SOLICITATION
:
1578 case NDISC_NEIGHBOUR_ADVERTISEMENT
:
1582 case NDISC_ROUTER_SOLICITATION
:
1586 case NDISC_ROUTER_ADVERTISEMENT
:
1587 ndisc_router_discovery(skb
);
1590 case NDISC_REDIRECT
:
1591 ndisc_redirect_rcv(skb
);
1598 static int ndisc_netdev_event(struct notifier_block
*this, unsigned long event
, void *ptr
)
1600 struct net_device
*dev
= ptr
;
1602 if (dev
->nd_net
!= &init_net
)
1606 case NETDEV_CHANGEADDR
:
1607 neigh_changeaddr(&nd_tbl
, dev
);
1611 neigh_ifdown(&nd_tbl
, dev
);
1621 static struct notifier_block ndisc_netdev_notifier
= {
1622 .notifier_call
= ndisc_netdev_event
,
1625 #ifdef CONFIG_SYSCTL
1626 static void ndisc_warn_deprecated_sysctl(struct ctl_table
*ctl
,
1627 const char *func
, const char *dev_name
)
1629 static char warncomm
[TASK_COMM_LEN
];
1631 if (strcmp(warncomm
, current
->comm
) && warned
< 5) {
1632 strcpy(warncomm
, current
->comm
);
1634 "process `%s' is using deprecated sysctl (%s) "
1635 "net.ipv6.neigh.%s.%s; "
1636 "Use net.ipv6.neigh.%s.%s_ms "
1639 dev_name
, ctl
->procname
,
1640 dev_name
, ctl
->procname
);
1645 int ndisc_ifinfo_sysctl_change(struct ctl_table
*ctl
, int write
, struct file
* filp
, void __user
*buffer
, size_t *lenp
, loff_t
*ppos
)
1647 struct net_device
*dev
= ctl
->extra1
;
1648 struct inet6_dev
*idev
;
1651 if ((strcmp(ctl
->procname
, "retrans_time") == 0) ||
1652 (strcmp(ctl
->procname
, "base_reachable_time") == 0))
1653 ndisc_warn_deprecated_sysctl(ctl
, "syscall", dev
? dev
->name
: "default");
1655 if (strcmp(ctl
->procname
, "retrans_time") == 0)
1656 ret
= proc_dointvec(ctl
, write
, filp
, buffer
, lenp
, ppos
);
1658 else if (strcmp(ctl
->procname
, "base_reachable_time") == 0)
1659 ret
= proc_dointvec_jiffies(ctl
, write
,
1660 filp
, buffer
, lenp
, ppos
);
1662 else if ((strcmp(ctl
->procname
, "retrans_time_ms") == 0) ||
1663 (strcmp(ctl
->procname
, "base_reachable_time_ms") == 0))
1664 ret
= proc_dointvec_ms_jiffies(ctl
, write
,
1665 filp
, buffer
, lenp
, ppos
);
1669 if (write
&& ret
== 0 && dev
&& (idev
= in6_dev_get(dev
)) != NULL
) {
1670 if (ctl
->data
== &idev
->nd_parms
->base_reachable_time
)
1671 idev
->nd_parms
->reachable_time
= neigh_rand_reach_time(idev
->nd_parms
->base_reachable_time
);
1672 idev
->tstamp
= jiffies
;
1673 inet6_ifinfo_notify(RTM_NEWLINK
, idev
);
1679 static int ndisc_ifinfo_sysctl_strategy(ctl_table
*ctl
, int __user
*name
,
1680 int nlen
, void __user
*oldval
,
1681 size_t __user
*oldlenp
,
1682 void __user
*newval
, size_t newlen
)
1684 struct net_device
*dev
= ctl
->extra1
;
1685 struct inet6_dev
*idev
;
1688 if (ctl
->ctl_name
== NET_NEIGH_RETRANS_TIME
||
1689 ctl
->ctl_name
== NET_NEIGH_REACHABLE_TIME
)
1690 ndisc_warn_deprecated_sysctl(ctl
, "procfs", dev
? dev
->name
: "default");
1692 switch (ctl
->ctl_name
) {
1693 case NET_NEIGH_REACHABLE_TIME
:
1694 ret
= sysctl_jiffies(ctl
, name
, nlen
,
1695 oldval
, oldlenp
, newval
, newlen
);
1697 case NET_NEIGH_RETRANS_TIME_MS
:
1698 case NET_NEIGH_REACHABLE_TIME_MS
:
1699 ret
= sysctl_ms_jiffies(ctl
, name
, nlen
,
1700 oldval
, oldlenp
, newval
, newlen
);
1706 if (newval
&& newlen
&& ret
> 0 &&
1707 dev
&& (idev
= in6_dev_get(dev
)) != NULL
) {
1708 if (ctl
->ctl_name
== NET_NEIGH_REACHABLE_TIME
||
1709 ctl
->ctl_name
== NET_NEIGH_REACHABLE_TIME_MS
)
1710 idev
->nd_parms
->reachable_time
= neigh_rand_reach_time(idev
->nd_parms
->base_reachable_time
);
1711 idev
->tstamp
= jiffies
;
1712 inet6_ifinfo_notify(RTM_NEWLINK
, idev
);
1721 int __init
ndisc_init(void)
1723 struct ipv6_pinfo
*np
;
1727 err
= sock_create_kern(PF_INET6
, SOCK_RAW
, IPPROTO_ICMPV6
, &ndisc_socket
);
1730 "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",
1732 ndisc_socket
= NULL
; /* For safety. */
1736 sk
= ndisc_socket
->sk
;
1738 sk
->sk_allocation
= GFP_ATOMIC
;
1739 np
->hop_limit
= 255;
1740 /* Do not loopback ndisc messages */
1742 sk
->sk_prot
->unhash(sk
);
1745 * Initialize the neighbour table
1748 neigh_table_init(&nd_tbl
);
1750 #ifdef CONFIG_SYSCTL
1751 neigh_sysctl_register(NULL
, &nd_tbl
.parms
, NET_IPV6
, NET_IPV6_NEIGH
,
1753 &ndisc_ifinfo_sysctl_change
,
1754 &ndisc_ifinfo_sysctl_strategy
);
1757 register_netdevice_notifier(&ndisc_netdev_notifier
);
1761 void ndisc_cleanup(void)
1763 unregister_netdevice_notifier(&ndisc_netdev_notifier
);
1764 #ifdef CONFIG_SYSCTL
1765 neigh_sysctl_unregister(&nd_tbl
.parms
);
1767 neigh_table_clear(&nd_tbl
);
1768 sock_release(ndisc_socket
);
1769 ndisc_socket
= NULL
; /* For safety. */