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 <net/inet_common.h>
88 #include <linux/proc_fs.h>
90 #include <linux/netfilter.h>
91 #include <linux/netfilter_ipv6.h>
93 static u32
ndisc_hash(const void *pkey
, const struct net_device
*dev
);
94 static int ndisc_constructor(struct neighbour
*neigh
);
95 static void ndisc_solicit(struct neighbour
*neigh
, struct sk_buff
*skb
);
96 static void ndisc_error_report(struct neighbour
*neigh
, struct sk_buff
*skb
);
97 static int pndisc_constructor(struct pneigh_entry
*n
);
98 static void pndisc_destructor(struct pneigh_entry
*n
);
99 static void pndisc_redo(struct sk_buff
*skb
);
101 static struct neigh_ops ndisc_generic_ops
= {
103 .solicit
= ndisc_solicit
,
104 .error_report
= ndisc_error_report
,
105 .output
= neigh_resolve_output
,
106 .connected_output
= neigh_connected_output
,
107 .hh_output
= dev_queue_xmit
,
108 .queue_xmit
= dev_queue_xmit
,
111 static struct neigh_ops ndisc_hh_ops
= {
113 .solicit
= ndisc_solicit
,
114 .error_report
= ndisc_error_report
,
115 .output
= neigh_resolve_output
,
116 .connected_output
= neigh_resolve_output
,
117 .hh_output
= dev_queue_xmit
,
118 .queue_xmit
= dev_queue_xmit
,
122 static struct neigh_ops ndisc_direct_ops
= {
124 .output
= dev_queue_xmit
,
125 .connected_output
= dev_queue_xmit
,
126 .hh_output
= dev_queue_xmit
,
127 .queue_xmit
= dev_queue_xmit
,
130 struct neigh_table nd_tbl
= {
132 .entry_size
= sizeof(struct neighbour
) + sizeof(struct in6_addr
),
133 .key_len
= sizeof(struct in6_addr
),
135 .constructor
= ndisc_constructor
,
136 .pconstructor
= pndisc_constructor
,
137 .pdestructor
= pndisc_destructor
,
138 .proxy_redo
= pndisc_redo
,
142 .base_reachable_time
= 30 * HZ
,
143 .retrans_time
= 1 * HZ
,
144 .gc_staletime
= 60 * HZ
,
145 .reachable_time
= 30 * HZ
,
146 .delay_probe_time
= 5 * HZ
,
150 .anycast_delay
= 1 * HZ
,
151 .proxy_delay
= (8 * HZ
) / 10,
154 .gc_interval
= 30 * HZ
,
161 struct ndisc_options
{
162 struct nd_opt_hdr
*nd_opt_array
[__ND_OPT_ARRAY_MAX
];
163 #ifdef CONFIG_IPV6_ROUTE_INFO
164 struct nd_opt_hdr
*nd_opts_ri
;
165 struct nd_opt_hdr
*nd_opts_ri_end
;
167 struct nd_opt_hdr
*nd_useropts
;
168 struct nd_opt_hdr
*nd_useropts_end
;
171 #define nd_opts_src_lladdr nd_opt_array[ND_OPT_SOURCE_LL_ADDR]
172 #define nd_opts_tgt_lladdr nd_opt_array[ND_OPT_TARGET_LL_ADDR]
173 #define nd_opts_pi nd_opt_array[ND_OPT_PREFIX_INFO]
174 #define nd_opts_pi_end nd_opt_array[__ND_OPT_PREFIX_INFO_END]
175 #define nd_opts_rh nd_opt_array[ND_OPT_REDIRECT_HDR]
176 #define nd_opts_mtu nd_opt_array[ND_OPT_MTU]
178 #define NDISC_OPT_SPACE(len) (((len)+2+7)&~7)
181 * Return the padding between the option length and the start of the
182 * link addr. Currently only IP-over-InfiniBand needs this, although
183 * if RFC 3831 IPv6-over-Fibre Channel is ever implemented it may
184 * also need a pad of 2.
186 static int ndisc_addr_option_pad(unsigned short type
)
189 case ARPHRD_INFINIBAND
: return 2;
194 static inline int ndisc_opt_addr_space(struct net_device
*dev
)
196 return NDISC_OPT_SPACE(dev
->addr_len
+ ndisc_addr_option_pad(dev
->type
));
199 static u8
*ndisc_fill_addr_option(u8
*opt
, int type
, void *data
, int data_len
,
200 unsigned short addr_type
)
202 int space
= NDISC_OPT_SPACE(data_len
);
203 int pad
= ndisc_addr_option_pad(addr_type
);
208 memset(opt
+ 2, 0, pad
);
212 memcpy(opt
+2, data
, data_len
);
215 if ((space
-= data_len
) > 0)
216 memset(opt
, 0, space
);
220 static struct nd_opt_hdr
*ndisc_next_option(struct nd_opt_hdr
*cur
,
221 struct nd_opt_hdr
*end
)
224 if (!cur
|| !end
|| cur
>= end
)
226 type
= cur
->nd_opt_type
;
228 cur
= ((void *)cur
) + (cur
->nd_opt_len
<< 3);
229 } while(cur
< end
&& cur
->nd_opt_type
!= type
);
230 return (cur
<= end
&& cur
->nd_opt_type
== type
? cur
: NULL
);
233 static inline int ndisc_is_useropt(struct nd_opt_hdr
*opt
)
235 return (opt
->nd_opt_type
== ND_OPT_RDNSS
);
238 static struct nd_opt_hdr
*ndisc_next_useropt(struct nd_opt_hdr
*cur
,
239 struct nd_opt_hdr
*end
)
241 if (!cur
|| !end
|| cur
>= end
)
244 cur
= ((void *)cur
) + (cur
->nd_opt_len
<< 3);
245 } while(cur
< end
&& !ndisc_is_useropt(cur
));
246 return (cur
<= end
&& ndisc_is_useropt(cur
) ? cur
: NULL
);
249 static struct ndisc_options
*ndisc_parse_options(u8
*opt
, int opt_len
,
250 struct ndisc_options
*ndopts
)
252 struct nd_opt_hdr
*nd_opt
= (struct nd_opt_hdr
*)opt
;
254 if (!nd_opt
|| opt_len
< 0 || !ndopts
)
256 memset(ndopts
, 0, sizeof(*ndopts
));
259 if (opt_len
< sizeof(struct nd_opt_hdr
))
261 l
= nd_opt
->nd_opt_len
<< 3;
262 if (opt_len
< l
|| l
== 0)
264 switch (nd_opt
->nd_opt_type
) {
265 case ND_OPT_SOURCE_LL_ADDR
:
266 case ND_OPT_TARGET_LL_ADDR
:
268 case ND_OPT_REDIRECT_HDR
:
269 if (ndopts
->nd_opt_array
[nd_opt
->nd_opt_type
]) {
270 ND_PRINTK2(KERN_WARNING
271 "%s(): duplicated ND6 option found: type=%d\n",
273 nd_opt
->nd_opt_type
);
275 ndopts
->nd_opt_array
[nd_opt
->nd_opt_type
] = nd_opt
;
278 case ND_OPT_PREFIX_INFO
:
279 ndopts
->nd_opts_pi_end
= nd_opt
;
280 if (!ndopts
->nd_opt_array
[nd_opt
->nd_opt_type
])
281 ndopts
->nd_opt_array
[nd_opt
->nd_opt_type
] = nd_opt
;
283 #ifdef CONFIG_IPV6_ROUTE_INFO
284 case ND_OPT_ROUTE_INFO
:
285 ndopts
->nd_opts_ri_end
= nd_opt
;
286 if (!ndopts
->nd_opts_ri
)
287 ndopts
->nd_opts_ri
= nd_opt
;
291 if (ndisc_is_useropt(nd_opt
)) {
292 ndopts
->nd_useropts_end
= nd_opt
;
293 if (!ndopts
->nd_useropts
)
294 ndopts
->nd_useropts
= nd_opt
;
297 * Unknown options must be silently ignored,
298 * to accommodate future extension to the
301 ND_PRINTK2(KERN_NOTICE
302 "%s(): ignored unsupported option; type=%d, len=%d\n",
304 nd_opt
->nd_opt_type
, nd_opt
->nd_opt_len
);
308 nd_opt
= ((void *)nd_opt
) + l
;
313 static inline u8
*ndisc_opt_addr_data(struct nd_opt_hdr
*p
,
314 struct net_device
*dev
)
316 u8
*lladdr
= (u8
*)(p
+ 1);
317 int lladdrlen
= p
->nd_opt_len
<< 3;
318 int prepad
= ndisc_addr_option_pad(dev
->type
);
319 if (lladdrlen
!= NDISC_OPT_SPACE(dev
->addr_len
+ prepad
))
321 return (lladdr
+ prepad
);
324 int ndisc_mc_map(struct in6_addr
*addr
, char *buf
, struct net_device
*dev
, int dir
)
328 case ARPHRD_IEEE802
: /* Not sure. Check it later. --ANK */
330 ipv6_eth_mc_map(addr
, buf
);
332 case ARPHRD_IEEE802_TR
:
333 ipv6_tr_mc_map(addr
,buf
);
336 ipv6_arcnet_mc_map(addr
, buf
);
338 case ARPHRD_INFINIBAND
:
339 ipv6_ib_mc_map(addr
, dev
->broadcast
, buf
);
343 memcpy(buf
, dev
->broadcast
, dev
->addr_len
);
350 EXPORT_SYMBOL(ndisc_mc_map
);
352 static u32
ndisc_hash(const void *pkey
, const struct net_device
*dev
)
354 const u32
*p32
= pkey
;
358 for (i
= 0; i
< (sizeof(struct in6_addr
) / sizeof(u32
)); i
++)
361 return jhash_2words(addr_hash
, dev
->ifindex
, nd_tbl
.hash_rnd
);
364 static int ndisc_constructor(struct neighbour
*neigh
)
366 struct in6_addr
*addr
= (struct in6_addr
*)&neigh
->primary_key
;
367 struct net_device
*dev
= neigh
->dev
;
368 struct inet6_dev
*in6_dev
;
369 struct neigh_parms
*parms
;
370 int is_multicast
= ipv6_addr_is_multicast(addr
);
373 in6_dev
= in6_dev_get(dev
);
374 if (in6_dev
== NULL
) {
379 parms
= in6_dev
->nd_parms
;
380 __neigh_parms_put(neigh
->parms
);
381 neigh
->parms
= neigh_parms_clone(parms
);
384 neigh
->type
= is_multicast
? RTN_MULTICAST
: RTN_UNICAST
;
385 if (!dev
->header_ops
) {
386 neigh
->nud_state
= NUD_NOARP
;
387 neigh
->ops
= &ndisc_direct_ops
;
388 neigh
->output
= neigh
->ops
->queue_xmit
;
391 neigh
->nud_state
= NUD_NOARP
;
392 ndisc_mc_map(addr
, neigh
->ha
, dev
, 1);
393 } else if (dev
->flags
&(IFF_NOARP
|IFF_LOOPBACK
)) {
394 neigh
->nud_state
= NUD_NOARP
;
395 memcpy(neigh
->ha
, dev
->dev_addr
, dev
->addr_len
);
396 if (dev
->flags
&IFF_LOOPBACK
)
397 neigh
->type
= RTN_LOCAL
;
398 } else if (dev
->flags
&IFF_POINTOPOINT
) {
399 neigh
->nud_state
= NUD_NOARP
;
400 memcpy(neigh
->ha
, dev
->broadcast
, dev
->addr_len
);
402 if (dev
->header_ops
->cache
)
403 neigh
->ops
= &ndisc_hh_ops
;
405 neigh
->ops
= &ndisc_generic_ops
;
406 if (neigh
->nud_state
&NUD_VALID
)
407 neigh
->output
= neigh
->ops
->connected_output
;
409 neigh
->output
= neigh
->ops
->output
;
411 in6_dev_put(in6_dev
);
415 static int pndisc_constructor(struct pneigh_entry
*n
)
417 struct in6_addr
*addr
= (struct in6_addr
*)&n
->key
;
418 struct in6_addr maddr
;
419 struct net_device
*dev
= n
->dev
;
421 if (dev
== NULL
|| __in6_dev_get(dev
) == NULL
)
423 addrconf_addr_solict_mult(addr
, &maddr
);
424 ipv6_dev_mc_inc(dev
, &maddr
);
428 static void pndisc_destructor(struct pneigh_entry
*n
)
430 struct in6_addr
*addr
= (struct in6_addr
*)&n
->key
;
431 struct in6_addr maddr
;
432 struct net_device
*dev
= n
->dev
;
434 if (dev
== NULL
|| __in6_dev_get(dev
) == NULL
)
436 addrconf_addr_solict_mult(addr
, &maddr
);
437 ipv6_dev_mc_dec(dev
, &maddr
);
440 struct sk_buff
*ndisc_build_skb(struct net_device
*dev
,
441 const struct in6_addr
*daddr
,
442 const struct in6_addr
*saddr
,
443 struct icmp6hdr
*icmp6h
,
444 const struct in6_addr
*target
,
447 struct net
*net
= dev_net(dev
);
448 struct sock
*sk
= net
->ipv6
.ndisc_sk
;
450 struct icmp6hdr
*hdr
;
458 len
= sizeof(struct icmp6hdr
) + (target
? sizeof(*target
) : 0);
460 len
+= ndisc_opt_addr_space(dev
);
462 skb
= sock_alloc_send_skb(sk
,
463 (MAX_HEADER
+ sizeof(struct ipv6hdr
) +
464 len
+ LL_ALLOCATED_SPACE(dev
)),
468 "ICMPv6 ND: %s() failed to allocate an skb, err=%d.\n",
473 skb_reserve(skb
, LL_RESERVED_SPACE(dev
));
474 ip6_nd_hdr(sk
, skb
, dev
, saddr
, daddr
, IPPROTO_ICMPV6
, len
);
476 skb
->transport_header
= skb
->tail
;
479 hdr
= (struct icmp6hdr
*)skb_transport_header(skb
);
480 memcpy(hdr
, icmp6h
, sizeof(*hdr
));
482 opt
= skb_transport_header(skb
) + sizeof(struct icmp6hdr
);
484 ipv6_addr_copy((struct in6_addr
*)opt
, target
);
485 opt
+= sizeof(*target
);
489 ndisc_fill_addr_option(opt
, llinfo
, dev
->dev_addr
,
490 dev
->addr_len
, dev
->type
);
492 hdr
->icmp6_cksum
= csum_ipv6_magic(saddr
, daddr
, len
,
500 EXPORT_SYMBOL(ndisc_build_skb
);
502 void ndisc_send_skb(struct sk_buff
*skb
,
503 struct net_device
*dev
,
504 struct neighbour
*neigh
,
505 const struct in6_addr
*daddr
,
506 const struct in6_addr
*saddr
,
507 struct icmp6hdr
*icmp6h
)
510 struct dst_entry
*dst
;
511 struct net
*net
= dev_net(dev
);
512 struct sock
*sk
= net
->ipv6
.ndisc_sk
;
513 struct inet6_dev
*idev
;
517 type
= icmp6h
->icmp6_type
;
519 icmpv6_flow_init(sk
, &fl
, type
, saddr
, daddr
, dev
->ifindex
);
521 dst
= icmp6_dst_alloc(dev
, neigh
, daddr
);
527 err
= xfrm_lookup(net
, &dst
, &fl
, NULL
, 0);
533 skb_dst_set(skb
, dst
);
535 idev
= in6_dev_get(dst
->dev
);
536 IP6_UPD_PO_STATS(net
, idev
, IPSTATS_MIB_OUT
, skb
->len
);
538 err
= NF_HOOK(PF_INET6
, NF_INET_LOCAL_OUT
, skb
, NULL
, dst
->dev
,
541 ICMP6MSGOUT_INC_STATS(net
, idev
, type
);
542 ICMP6_INC_STATS(net
, idev
, ICMP6_MIB_OUTMSGS
);
545 if (likely(idev
!= NULL
))
549 EXPORT_SYMBOL(ndisc_send_skb
);
552 * Send a Neighbour Discover packet
554 static void __ndisc_send(struct net_device
*dev
,
555 struct neighbour
*neigh
,
556 const struct in6_addr
*daddr
,
557 const struct in6_addr
*saddr
,
558 struct icmp6hdr
*icmp6h
, const struct in6_addr
*target
,
563 skb
= ndisc_build_skb(dev
, daddr
, saddr
, icmp6h
, target
, llinfo
);
567 ndisc_send_skb(skb
, dev
, neigh
, daddr
, saddr
, icmp6h
);
570 static void ndisc_send_na(struct net_device
*dev
, struct neighbour
*neigh
,
571 const struct in6_addr
*daddr
,
572 const struct in6_addr
*solicited_addr
,
573 int router
, int solicited
, int override
, int inc_opt
)
575 struct in6_addr tmpaddr
;
576 struct inet6_ifaddr
*ifp
;
577 const struct in6_addr
*src_addr
;
578 struct icmp6hdr icmp6h
= {
579 .icmp6_type
= NDISC_NEIGHBOUR_ADVERTISEMENT
,
582 /* for anycast or proxy, solicited_addr != src_addr */
583 ifp
= ipv6_get_ifaddr(dev_net(dev
), solicited_addr
, dev
, 1);
585 src_addr
= solicited_addr
;
586 if (ifp
->flags
& IFA_F_OPTIMISTIC
)
590 if (ipv6_dev_get_saddr(dev_net(dev
), dev
, daddr
,
591 inet6_sk(dev_net(dev
)->ipv6
.ndisc_sk
)->srcprefs
,
597 icmp6h
.icmp6_router
= router
;
598 icmp6h
.icmp6_solicited
= solicited
;
599 icmp6h
.icmp6_override
= override
;
601 __ndisc_send(dev
, neigh
, daddr
, src_addr
,
602 &icmp6h
, solicited_addr
,
603 inc_opt
? ND_OPT_TARGET_LL_ADDR
: 0);
606 void ndisc_send_ns(struct net_device
*dev
, struct neighbour
*neigh
,
607 const struct in6_addr
*solicit
,
608 const struct in6_addr
*daddr
, const struct in6_addr
*saddr
)
610 struct in6_addr addr_buf
;
611 struct icmp6hdr icmp6h
= {
612 .icmp6_type
= NDISC_NEIGHBOUR_SOLICITATION
,
616 if (ipv6_get_lladdr(dev
, &addr_buf
,
617 (IFA_F_TENTATIVE
|IFA_F_OPTIMISTIC
)))
622 __ndisc_send(dev
, neigh
, daddr
, saddr
,
624 !ipv6_addr_any(saddr
) ? ND_OPT_SOURCE_LL_ADDR
: 0);
627 void ndisc_send_rs(struct net_device
*dev
, const struct in6_addr
*saddr
,
628 const struct in6_addr
*daddr
)
630 struct icmp6hdr icmp6h
= {
631 .icmp6_type
= NDISC_ROUTER_SOLICITATION
,
633 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 * suppress the inclusion of the sllao.
645 struct inet6_ifaddr
*ifp
= ipv6_get_ifaddr(dev_net(dev
), saddr
,
648 if (ifp
->flags
& IFA_F_OPTIMISTIC
) {
657 __ndisc_send(dev
, NULL
, daddr
, saddr
,
659 send_sllao
? ND_OPT_SOURCE_LL_ADDR
: 0);
661 EXPORT_SYMBOL(ndisc_send_rs
);
664 static void ndisc_error_report(struct neighbour
*neigh
, struct sk_buff
*skb
)
667 * "The sender MUST return an ICMP
668 * destination unreachable"
670 dst_link_failure(skb
);
674 /* Called with locked neigh: either read or both */
676 static void ndisc_solicit(struct neighbour
*neigh
, struct sk_buff
*skb
)
678 struct in6_addr
*saddr
= NULL
;
679 struct in6_addr mcaddr
;
680 struct net_device
*dev
= neigh
->dev
;
681 struct in6_addr
*target
= (struct in6_addr
*)&neigh
->primary_key
;
682 int probes
= atomic_read(&neigh
->probes
);
684 if (skb
&& ipv6_chk_addr(dev_net(dev
), &ipv6_hdr(skb
)->saddr
, dev
, 1))
685 saddr
= &ipv6_hdr(skb
)->saddr
;
687 if ((probes
-= neigh
->parms
->ucast_probes
) < 0) {
688 if (!(neigh
->nud_state
& NUD_VALID
)) {
689 ND_PRINTK1(KERN_DEBUG
"%s(): trying to ucast probe in NUD_INVALID: %pI6\n",
692 ndisc_send_ns(dev
, neigh
, target
, target
, saddr
);
693 } else if ((probes
-= neigh
->parms
->app_probes
) < 0) {
698 addrconf_addr_solict_mult(target
, &mcaddr
);
699 ndisc_send_ns(dev
, NULL
, target
, &mcaddr
, saddr
);
703 static int pndisc_is_router(const void *pkey
,
704 struct net_device
*dev
)
706 struct pneigh_entry
*n
;
709 read_lock_bh(&nd_tbl
.lock
);
710 n
= __pneigh_lookup(&nd_tbl
, dev_net(dev
), pkey
, dev
);
712 ret
= !!(n
->flags
& NTF_ROUTER
);
713 read_unlock_bh(&nd_tbl
.lock
);
718 static void ndisc_recv_ns(struct sk_buff
*skb
)
720 struct nd_msg
*msg
= (struct nd_msg
*)skb_transport_header(skb
);
721 struct in6_addr
*saddr
= &ipv6_hdr(skb
)->saddr
;
722 struct in6_addr
*daddr
= &ipv6_hdr(skb
)->daddr
;
724 u32 ndoptlen
= skb
->tail
- (skb
->transport_header
+
725 offsetof(struct nd_msg
, opt
));
726 struct ndisc_options ndopts
;
727 struct net_device
*dev
= skb
->dev
;
728 struct inet6_ifaddr
*ifp
;
729 struct inet6_dev
*idev
= NULL
;
730 struct neighbour
*neigh
;
731 int dad
= ipv6_addr_any(saddr
);
735 if (ipv6_addr_is_multicast(&msg
->target
)) {
736 ND_PRINTK2(KERN_WARNING
737 "ICMPv6 NS: multicast target address");
743 * DAD has to be destined for solicited node multicast address.
746 !(daddr
->s6_addr32
[0] == htonl(0xff020000) &&
747 daddr
->s6_addr32
[1] == htonl(0x00000000) &&
748 daddr
->s6_addr32
[2] == htonl(0x00000001) &&
749 daddr
->s6_addr
[12] == 0xff )) {
750 ND_PRINTK2(KERN_WARNING
751 "ICMPv6 NS: bad DAD packet (wrong destination)\n");
755 if (!ndisc_parse_options(msg
->opt
, ndoptlen
, &ndopts
)) {
756 ND_PRINTK2(KERN_WARNING
757 "ICMPv6 NS: invalid ND options\n");
761 if (ndopts
.nd_opts_src_lladdr
) {
762 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_src_lladdr
, dev
);
764 ND_PRINTK2(KERN_WARNING
765 "ICMPv6 NS: invalid link-layer address length\n");
770 * If the IP source address is the unspecified address,
771 * there MUST NOT be source link-layer address option
775 ND_PRINTK2(KERN_WARNING
776 "ICMPv6 NS: bad DAD packet (link-layer address option)\n");
781 inc
= ipv6_addr_is_multicast(daddr
);
783 ifp
= ipv6_get_ifaddr(dev_net(dev
), &msg
->target
, dev
, 1);
786 if (ifp
->flags
& (IFA_F_TENTATIVE
|IFA_F_OPTIMISTIC
)) {
788 if (dev
->type
== ARPHRD_IEEE802_TR
) {
789 const unsigned char *sadr
;
790 sadr
= skb_mac_header(skb
);
791 if (((sadr
[8] ^ dev
->dev_addr
[0]) & 0x7f) == 0 &&
792 sadr
[9] == dev
->dev_addr
[1] &&
793 sadr
[10] == dev
->dev_addr
[2] &&
794 sadr
[11] == dev
->dev_addr
[3] &&
795 sadr
[12] == dev
->dev_addr
[4] &&
796 sadr
[13] == dev
->dev_addr
[5]) {
797 /* looped-back to us */
803 * We are colliding with another node
805 * so fail our DAD process
807 addrconf_dad_failure(ifp
);
811 * This is not a dad solicitation.
812 * If we are an optimistic node,
814 * Otherwise, we should ignore it.
816 if (!(ifp
->flags
& IFA_F_OPTIMISTIC
))
823 struct net
*net
= dev_net(dev
);
825 idev
= in6_dev_get(dev
);
827 /* XXX: count this drop? */
831 if (ipv6_chk_acast_addr(net
, dev
, &msg
->target
) ||
832 (idev
->cnf
.forwarding
&&
833 (net
->ipv6
.devconf_all
->proxy_ndp
|| idev
->cnf
.proxy_ndp
) &&
834 (is_router
= pndisc_is_router(&msg
->target
, dev
)) >= 0)) {
835 if (!(NEIGH_CB(skb
)->flags
& LOCALLY_ENQUEUED
) &&
836 skb
->pkt_type
!= PACKET_HOST
&&
838 idev
->nd_parms
->proxy_delay
!= 0) {
840 * for anycast or proxy,
841 * sender should delay its response
842 * by a random time between 0 and
843 * MAX_ANYCAST_DELAY_TIME seconds.
844 * (RFC2461) -- yoshfuji
846 struct sk_buff
*n
= skb_clone(skb
, GFP_ATOMIC
);
848 pneigh_enqueue(&nd_tbl
, idev
->nd_parms
, n
);
856 is_router
= !!idev
->cnf
.forwarding
;
859 ndisc_send_na(dev
, NULL
, &in6addr_linklocal_allnodes
, &msg
->target
,
860 is_router
, 0, (ifp
!= NULL
), 1);
865 NEIGH_CACHE_STAT_INC(&nd_tbl
, rcv_probes_mcast
);
867 NEIGH_CACHE_STAT_INC(&nd_tbl
, rcv_probes_ucast
);
870 * update / create cache entry
871 * for the source address
873 neigh
= __neigh_lookup(&nd_tbl
, saddr
, dev
,
874 !inc
|| lladdr
|| !dev
->addr_len
);
876 neigh_update(neigh
, lladdr
, NUD_STALE
,
877 NEIGH_UPDATE_F_WEAK_OVERRIDE
|
878 NEIGH_UPDATE_F_OVERRIDE
);
879 if (neigh
|| !dev
->header_ops
) {
880 ndisc_send_na(dev
, neigh
, saddr
, &msg
->target
,
882 1, (ifp
!= NULL
&& inc
), inc
);
884 neigh_release(neigh
);
896 static void ndisc_recv_na(struct sk_buff
*skb
)
898 struct nd_msg
*msg
= (struct nd_msg
*)skb_transport_header(skb
);
899 struct in6_addr
*saddr
= &ipv6_hdr(skb
)->saddr
;
900 struct in6_addr
*daddr
= &ipv6_hdr(skb
)->daddr
;
902 u32 ndoptlen
= skb
->tail
- (skb
->transport_header
+
903 offsetof(struct nd_msg
, opt
));
904 struct ndisc_options ndopts
;
905 struct net_device
*dev
= skb
->dev
;
906 struct inet6_ifaddr
*ifp
;
907 struct neighbour
*neigh
;
909 if (skb
->len
< sizeof(struct nd_msg
)) {
910 ND_PRINTK2(KERN_WARNING
911 "ICMPv6 NA: packet too short\n");
915 if (ipv6_addr_is_multicast(&msg
->target
)) {
916 ND_PRINTK2(KERN_WARNING
917 "ICMPv6 NA: target address is multicast.\n");
921 if (ipv6_addr_is_multicast(daddr
) &&
922 msg
->icmph
.icmp6_solicited
) {
923 ND_PRINTK2(KERN_WARNING
924 "ICMPv6 NA: solicited NA is multicasted.\n");
928 if (!ndisc_parse_options(msg
->opt
, ndoptlen
, &ndopts
)) {
929 ND_PRINTK2(KERN_WARNING
930 "ICMPv6 NS: invalid ND option\n");
933 if (ndopts
.nd_opts_tgt_lladdr
) {
934 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_tgt_lladdr
, dev
);
936 ND_PRINTK2(KERN_WARNING
937 "ICMPv6 NA: invalid link-layer address length\n");
941 ifp
= ipv6_get_ifaddr(dev_net(dev
), &msg
->target
, dev
, 1);
943 if (ifp
->flags
& IFA_F_TENTATIVE
) {
944 addrconf_dad_failure(ifp
);
947 /* What should we make now? The advertisement
948 is invalid, but ndisc specs say nothing
949 about it. It could be misconfiguration, or
950 an smart proxy agent tries to help us :-)
952 We should not print the error if NA has been
953 received from loopback - it is just our own
954 unsolicited advertisement.
956 if (skb
->pkt_type
!= PACKET_LOOPBACK
)
957 ND_PRINTK1(KERN_WARNING
958 "ICMPv6 NA: someone advertises our address %pI6 on %s!\n",
959 &ifp
->addr
, ifp
->idev
->dev
->name
);
963 neigh
= neigh_lookup(&nd_tbl
, &msg
->target
, dev
);
966 u8 old_flags
= neigh
->flags
;
967 struct net
*net
= dev_net(dev
);
969 if (neigh
->nud_state
& NUD_FAILED
)
973 * Don't update the neighbor cache entry on a proxy NA from
974 * ourselves because either the proxied node is off link or it
975 * has already sent a NA to us.
977 if (lladdr
&& !memcmp(lladdr
, dev
->dev_addr
, dev
->addr_len
) &&
978 net
->ipv6
.devconf_all
->forwarding
&& net
->ipv6
.devconf_all
->proxy_ndp
&&
979 pneigh_lookup(&nd_tbl
, net
, &msg
->target
, dev
, 0)) {
980 /* XXX: idev->cnf.prixy_ndp */
984 neigh_update(neigh
, lladdr
,
985 msg
->icmph
.icmp6_solicited
? NUD_REACHABLE
: NUD_STALE
,
986 NEIGH_UPDATE_F_WEAK_OVERRIDE
|
987 (msg
->icmph
.icmp6_override
? NEIGH_UPDATE_F_OVERRIDE
: 0)|
988 NEIGH_UPDATE_F_OVERRIDE_ISROUTER
|
989 (msg
->icmph
.icmp6_router
? NEIGH_UPDATE_F_ISROUTER
: 0));
991 if ((old_flags
& ~neigh
->flags
) & NTF_ROUTER
) {
993 * Change: router to host
996 rt
= rt6_get_dflt_router(saddr
, dev
);
1002 neigh_release(neigh
);
1006 static void ndisc_recv_rs(struct sk_buff
*skb
)
1008 struct rs_msg
*rs_msg
= (struct rs_msg
*)skb_transport_header(skb
);
1009 unsigned long ndoptlen
= skb
->len
- sizeof(*rs_msg
);
1010 struct neighbour
*neigh
;
1011 struct inet6_dev
*idev
;
1012 struct in6_addr
*saddr
= &ipv6_hdr(skb
)->saddr
;
1013 struct ndisc_options ndopts
;
1016 if (skb
->len
< sizeof(*rs_msg
))
1019 idev
= in6_dev_get(skb
->dev
);
1021 if (net_ratelimit())
1022 ND_PRINTK1("ICMP6 RS: can't find in6 device\n");
1026 /* Don't accept RS if we're not in router mode */
1027 if (!idev
->cnf
.forwarding
)
1031 * Don't update NCE if src = ::;
1032 * this implies that the source node has no ip address assigned yet.
1034 if (ipv6_addr_any(saddr
))
1037 /* Parse ND options */
1038 if (!ndisc_parse_options(rs_msg
->opt
, ndoptlen
, &ndopts
)) {
1039 if (net_ratelimit())
1040 ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n");
1044 if (ndopts
.nd_opts_src_lladdr
) {
1045 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_src_lladdr
,
1051 neigh
= __neigh_lookup(&nd_tbl
, saddr
, skb
->dev
, 1);
1053 neigh_update(neigh
, lladdr
, NUD_STALE
,
1054 NEIGH_UPDATE_F_WEAK_OVERRIDE
|
1055 NEIGH_UPDATE_F_OVERRIDE
|
1056 NEIGH_UPDATE_F_OVERRIDE_ISROUTER
);
1057 neigh_release(neigh
);
1063 static void ndisc_ra_useropt(struct sk_buff
*ra
, struct nd_opt_hdr
*opt
)
1065 struct icmp6hdr
*icmp6h
= (struct icmp6hdr
*)skb_transport_header(ra
);
1066 struct sk_buff
*skb
;
1067 struct nlmsghdr
*nlh
;
1068 struct nduseroptmsg
*ndmsg
;
1069 struct net
*net
= dev_net(ra
->dev
);
1071 int base_size
= NLMSG_ALIGN(sizeof(struct nduseroptmsg
)
1072 + (opt
->nd_opt_len
<< 3));
1073 size_t msg_size
= base_size
+ nla_total_size(sizeof(struct in6_addr
));
1075 skb
= nlmsg_new(msg_size
, GFP_ATOMIC
);
1081 nlh
= nlmsg_put(skb
, 0, 0, RTM_NEWNDUSEROPT
, base_size
, 0);
1083 goto nla_put_failure
;
1086 ndmsg
= nlmsg_data(nlh
);
1087 ndmsg
->nduseropt_family
= AF_INET6
;
1088 ndmsg
->nduseropt_ifindex
= ra
->dev
->ifindex
;
1089 ndmsg
->nduseropt_icmp_type
= icmp6h
->icmp6_type
;
1090 ndmsg
->nduseropt_icmp_code
= icmp6h
->icmp6_code
;
1091 ndmsg
->nduseropt_opts_len
= opt
->nd_opt_len
<< 3;
1093 memcpy(ndmsg
+ 1, opt
, opt
->nd_opt_len
<< 3);
1095 NLA_PUT(skb
, NDUSEROPT_SRCADDR
, sizeof(struct in6_addr
),
1096 &ipv6_hdr(ra
)->saddr
);
1097 nlmsg_end(skb
, nlh
);
1099 rtnl_notify(skb
, net
, 0, RTNLGRP_ND_USEROPT
, NULL
, GFP_ATOMIC
);
1106 rtnl_set_sk_err(net
, RTNLGRP_ND_USEROPT
, err
);
1109 static void ndisc_router_discovery(struct sk_buff
*skb
)
1111 struct ra_msg
*ra_msg
= (struct ra_msg
*)skb_transport_header(skb
);
1112 struct neighbour
*neigh
= NULL
;
1113 struct inet6_dev
*in6_dev
;
1114 struct rt6_info
*rt
= NULL
;
1116 struct ndisc_options ndopts
;
1118 unsigned int pref
= 0;
1120 __u8
* opt
= (__u8
*)(ra_msg
+ 1);
1122 optlen
= (skb
->tail
- skb
->transport_header
) - sizeof(struct ra_msg
);
1124 if (!(ipv6_addr_type(&ipv6_hdr(skb
)->saddr
) & IPV6_ADDR_LINKLOCAL
)) {
1125 ND_PRINTK2(KERN_WARNING
1126 "ICMPv6 RA: source address is not link-local.\n");
1130 ND_PRINTK2(KERN_WARNING
1131 "ICMPv6 RA: packet too short\n");
1135 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1136 if (skb
->ndisc_nodetype
== NDISC_NODETYPE_HOST
) {
1137 ND_PRINTK2(KERN_WARNING
1138 "ICMPv6 RA: from host or unauthorized router\n");
1144 * set the RA_RECV flag in the interface
1147 in6_dev
= in6_dev_get(skb
->dev
);
1148 if (in6_dev
== NULL
) {
1150 "ICMPv6 RA: can't find inet6 device for %s.\n",
1155 if (!ndisc_parse_options(opt
, optlen
, &ndopts
)) {
1156 in6_dev_put(in6_dev
);
1157 ND_PRINTK2(KERN_WARNING
1158 "ICMP6 RA: invalid ND options\n");
1162 /* skip route and link configuration on routers */
1163 if (in6_dev
->cnf
.forwarding
|| !in6_dev
->cnf
.accept_ra
)
1164 goto skip_linkparms
;
1166 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1167 /* skip link-specific parameters from interior routers */
1168 if (skb
->ndisc_nodetype
== NDISC_NODETYPE_NODEFAULT
)
1169 goto skip_linkparms
;
1172 if (in6_dev
->if_flags
& IF_RS_SENT
) {
1174 * flag that an RA was received after an RS was sent
1175 * out on this interface.
1177 in6_dev
->if_flags
|= IF_RA_RCVD
;
1181 * Remember the managed/otherconf flags from most recently
1182 * received RA message (RFC 2462) -- yoshfuji
1184 in6_dev
->if_flags
= (in6_dev
->if_flags
& ~(IF_RA_MANAGED
|
1186 (ra_msg
->icmph
.icmp6_addrconf_managed
?
1187 IF_RA_MANAGED
: 0) |
1188 (ra_msg
->icmph
.icmp6_addrconf_other
?
1189 IF_RA_OTHERCONF
: 0);
1191 if (!in6_dev
->cnf
.accept_ra_defrtr
)
1194 lifetime
= ntohs(ra_msg
->icmph
.icmp6_rt_lifetime
);
1196 #ifdef CONFIG_IPV6_ROUTER_PREF
1197 pref
= ra_msg
->icmph
.icmp6_router_pref
;
1198 /* 10b is handled as if it were 00b (medium) */
1199 if (pref
== ICMPV6_ROUTER_PREF_INVALID
||
1200 !in6_dev
->cnf
.accept_ra_rtr_pref
)
1201 pref
= ICMPV6_ROUTER_PREF_MEDIUM
;
1204 rt
= rt6_get_dflt_router(&ipv6_hdr(skb
)->saddr
, skb
->dev
);
1207 neigh
= rt
->rt6i_nexthop
;
1209 if (rt
&& lifetime
== 0) {
1215 if (rt
== NULL
&& lifetime
) {
1216 ND_PRINTK3(KERN_DEBUG
1217 "ICMPv6 RA: adding default router.\n");
1219 rt
= rt6_add_dflt_router(&ipv6_hdr(skb
)->saddr
, skb
->dev
, pref
);
1222 "ICMPv6 RA: %s() failed to add default route.\n",
1224 in6_dev_put(in6_dev
);
1228 neigh
= rt
->rt6i_nexthop
;
1229 if (neigh
== NULL
) {
1231 "ICMPv6 RA: %s() got default router without neighbour.\n",
1233 dst_release(&rt
->u
.dst
);
1234 in6_dev_put(in6_dev
);
1237 neigh
->flags
|= NTF_ROUTER
;
1239 rt
->rt6i_flags
= (rt
->rt6i_flags
& ~RTF_PREF_MASK
) | RTF_PREF(pref
);
1243 rt
->rt6i_expires
= jiffies
+ (HZ
* lifetime
);
1245 if (ra_msg
->icmph
.icmp6_hop_limit
) {
1246 in6_dev
->cnf
.hop_limit
= ra_msg
->icmph
.icmp6_hop_limit
;
1248 rt
->u
.dst
.metrics
[RTAX_HOPLIMIT
-1] = ra_msg
->icmph
.icmp6_hop_limit
;
1254 * Update Reachable Time and Retrans Timer
1257 if (in6_dev
->nd_parms
) {
1258 unsigned long rtime
= ntohl(ra_msg
->retrans_timer
);
1260 if (rtime
&& rtime
/1000 < MAX_SCHEDULE_TIMEOUT
/HZ
) {
1261 rtime
= (rtime
*HZ
)/1000;
1264 in6_dev
->nd_parms
->retrans_time
= rtime
;
1265 in6_dev
->tstamp
= jiffies
;
1266 inet6_ifinfo_notify(RTM_NEWLINK
, in6_dev
);
1269 rtime
= ntohl(ra_msg
->reachable_time
);
1270 if (rtime
&& rtime
/1000 < MAX_SCHEDULE_TIMEOUT
/(3*HZ
)) {
1271 rtime
= (rtime
*HZ
)/1000;
1276 if (rtime
!= in6_dev
->nd_parms
->base_reachable_time
) {
1277 in6_dev
->nd_parms
->base_reachable_time
= rtime
;
1278 in6_dev
->nd_parms
->gc_staletime
= 3 * rtime
;
1279 in6_dev
->nd_parms
->reachable_time
= neigh_rand_reach_time(rtime
);
1280 in6_dev
->tstamp
= jiffies
;
1281 inet6_ifinfo_notify(RTM_NEWLINK
, in6_dev
);
1293 neigh
= __neigh_lookup(&nd_tbl
, &ipv6_hdr(skb
)->saddr
,
1297 if (ndopts
.nd_opts_src_lladdr
) {
1298 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_src_lladdr
,
1301 ND_PRINTK2(KERN_WARNING
1302 "ICMPv6 RA: invalid link-layer address length\n");
1306 neigh_update(neigh
, lladdr
, NUD_STALE
,
1307 NEIGH_UPDATE_F_WEAK_OVERRIDE
|
1308 NEIGH_UPDATE_F_OVERRIDE
|
1309 NEIGH_UPDATE_F_OVERRIDE_ISROUTER
|
1310 NEIGH_UPDATE_F_ISROUTER
);
1313 /* skip route and link configuration on routers */
1314 if (in6_dev
->cnf
.forwarding
|| !in6_dev
->cnf
.accept_ra
)
1317 #ifdef CONFIG_IPV6_ROUTE_INFO
1318 if (in6_dev
->cnf
.accept_ra_rtr_pref
&& ndopts
.nd_opts_ri
) {
1319 struct nd_opt_hdr
*p
;
1320 for (p
= ndopts
.nd_opts_ri
;
1322 p
= ndisc_next_option(p
, ndopts
.nd_opts_ri_end
)) {
1323 struct route_info
*ri
= (struct route_info
*)p
;
1324 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1325 if (skb
->ndisc_nodetype
== NDISC_NODETYPE_NODEFAULT
&&
1326 ri
->prefix_len
== 0)
1329 if (ri
->prefix_len
> in6_dev
->cnf
.accept_ra_rt_info_max_plen
)
1331 rt6_route_rcv(skb
->dev
, (u8
*)p
, (p
->nd_opt_len
) << 3,
1332 &ipv6_hdr(skb
)->saddr
);
1337 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1338 /* skip link-specific ndopts from interior routers */
1339 if (skb
->ndisc_nodetype
== NDISC_NODETYPE_NODEFAULT
)
1343 if (in6_dev
->cnf
.accept_ra_pinfo
&& ndopts
.nd_opts_pi
) {
1344 struct nd_opt_hdr
*p
;
1345 for (p
= ndopts
.nd_opts_pi
;
1347 p
= ndisc_next_option(p
, ndopts
.nd_opts_pi_end
)) {
1348 addrconf_prefix_rcv(skb
->dev
, (u8
*)p
, (p
->nd_opt_len
) << 3);
1352 if (ndopts
.nd_opts_mtu
) {
1356 memcpy(&n
, ((u8
*)(ndopts
.nd_opts_mtu
+1))+2, sizeof(mtu
));
1359 if (mtu
< IPV6_MIN_MTU
|| mtu
> skb
->dev
->mtu
) {
1360 ND_PRINTK2(KERN_WARNING
1361 "ICMPv6 RA: invalid mtu: %d\n",
1363 } else if (in6_dev
->cnf
.mtu6
!= mtu
) {
1364 in6_dev
->cnf
.mtu6
= mtu
;
1367 rt
->u
.dst
.metrics
[RTAX_MTU
-1] = mtu
;
1369 rt6_mtu_change(skb
->dev
, mtu
);
1373 if (ndopts
.nd_useropts
) {
1374 struct nd_opt_hdr
*p
;
1375 for (p
= ndopts
.nd_useropts
;
1377 p
= ndisc_next_useropt(p
, ndopts
.nd_useropts_end
)) {
1378 ndisc_ra_useropt(skb
, p
);
1382 if (ndopts
.nd_opts_tgt_lladdr
|| ndopts
.nd_opts_rh
) {
1383 ND_PRINTK2(KERN_WARNING
1384 "ICMPv6 RA: invalid RA options");
1388 dst_release(&rt
->u
.dst
);
1390 neigh_release(neigh
);
1391 in6_dev_put(in6_dev
);
1394 static void ndisc_redirect_rcv(struct sk_buff
*skb
)
1396 struct inet6_dev
*in6_dev
;
1397 struct icmp6hdr
*icmph
;
1398 struct in6_addr
*dest
;
1399 struct in6_addr
*target
; /* new first hop to destination */
1400 struct neighbour
*neigh
;
1402 struct ndisc_options ndopts
;
1406 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1407 switch (skb
->ndisc_nodetype
) {
1408 case NDISC_NODETYPE_HOST
:
1409 case NDISC_NODETYPE_NODEFAULT
:
1410 ND_PRINTK2(KERN_WARNING
1411 "ICMPv6 Redirect: from host or unauthorized router\n");
1416 if (!(ipv6_addr_type(&ipv6_hdr(skb
)->saddr
) & IPV6_ADDR_LINKLOCAL
)) {
1417 ND_PRINTK2(KERN_WARNING
1418 "ICMPv6 Redirect: source address is not link-local.\n");
1422 optlen
= skb
->tail
- skb
->transport_header
;
1423 optlen
-= sizeof(struct icmp6hdr
) + 2 * sizeof(struct in6_addr
);
1426 ND_PRINTK2(KERN_WARNING
1427 "ICMPv6 Redirect: packet too short\n");
1431 icmph
= icmp6_hdr(skb
);
1432 target
= (struct in6_addr
*) (icmph
+ 1);
1435 if (ipv6_addr_is_multicast(dest
)) {
1436 ND_PRINTK2(KERN_WARNING
1437 "ICMPv6 Redirect: destination address is multicast.\n");
1441 if (ipv6_addr_equal(dest
, target
)) {
1443 } else if (ipv6_addr_type(target
) !=
1444 (IPV6_ADDR_UNICAST
|IPV6_ADDR_LINKLOCAL
)) {
1445 ND_PRINTK2(KERN_WARNING
1446 "ICMPv6 Redirect: target address is not link-local unicast.\n");
1450 in6_dev
= in6_dev_get(skb
->dev
);
1453 if (in6_dev
->cnf
.forwarding
|| !in6_dev
->cnf
.accept_redirects
) {
1454 in6_dev_put(in6_dev
);
1459 * The IP source address of the Redirect MUST be the same as the current
1460 * first-hop router for the specified ICMP Destination Address.
1463 if (!ndisc_parse_options((u8
*)(dest
+ 1), optlen
, &ndopts
)) {
1464 ND_PRINTK2(KERN_WARNING
1465 "ICMPv6 Redirect: invalid ND options\n");
1466 in6_dev_put(in6_dev
);
1469 if (ndopts
.nd_opts_tgt_lladdr
) {
1470 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_tgt_lladdr
,
1473 ND_PRINTK2(KERN_WARNING
1474 "ICMPv6 Redirect: invalid link-layer address length\n");
1475 in6_dev_put(in6_dev
);
1480 neigh
= __neigh_lookup(&nd_tbl
, target
, skb
->dev
, 1);
1482 rt6_redirect(dest
, &ipv6_hdr(skb
)->daddr
,
1483 &ipv6_hdr(skb
)->saddr
, neigh
, lladdr
,
1485 neigh_release(neigh
);
1487 in6_dev_put(in6_dev
);
1490 void ndisc_send_redirect(struct sk_buff
*skb
, struct neighbour
*neigh
,
1491 const struct in6_addr
*target
)
1493 struct net_device
*dev
= skb
->dev
;
1494 struct net
*net
= dev_net(dev
);
1495 struct sock
*sk
= net
->ipv6
.ndisc_sk
;
1496 int len
= sizeof(struct icmp6hdr
) + 2 * sizeof(struct in6_addr
);
1497 struct sk_buff
*buff
;
1498 struct icmp6hdr
*icmph
;
1499 struct in6_addr saddr_buf
;
1500 struct in6_addr
*addrp
;
1501 struct rt6_info
*rt
;
1502 struct dst_entry
*dst
;
1503 struct inet6_dev
*idev
;
1508 u8 ha_buf
[MAX_ADDR_LEN
], *ha
= NULL
;
1510 if (ipv6_get_lladdr(dev
, &saddr_buf
, IFA_F_TENTATIVE
)) {
1511 ND_PRINTK2(KERN_WARNING
1512 "ICMPv6 Redirect: no link-local address on %s\n",
1517 if (!ipv6_addr_equal(&ipv6_hdr(skb
)->daddr
, target
) &&
1518 ipv6_addr_type(target
) != (IPV6_ADDR_UNICAST
|IPV6_ADDR_LINKLOCAL
)) {
1519 ND_PRINTK2(KERN_WARNING
1520 "ICMPv6 Redirect: target address is not link-local unicast.\n");
1524 icmpv6_flow_init(sk
, &fl
, NDISC_REDIRECT
,
1525 &saddr_buf
, &ipv6_hdr(skb
)->saddr
, dev
->ifindex
);
1527 dst
= ip6_route_output(net
, NULL
, &fl
);
1531 err
= xfrm_lookup(net
, &dst
, &fl
, NULL
, 0);
1535 rt
= (struct rt6_info
*) dst
;
1537 if (rt
->rt6i_flags
& RTF_GATEWAY
) {
1538 ND_PRINTK2(KERN_WARNING
1539 "ICMPv6 Redirect: destination is not a neighbour.\n");
1542 if (!xrlim_allow(dst
, 1*HZ
))
1545 if (dev
->addr_len
) {
1546 read_lock_bh(&neigh
->lock
);
1547 if (neigh
->nud_state
& NUD_VALID
) {
1548 memcpy(ha_buf
, neigh
->ha
, dev
->addr_len
);
1549 read_unlock_bh(&neigh
->lock
);
1551 len
+= ndisc_opt_addr_space(dev
);
1553 read_unlock_bh(&neigh
->lock
);
1556 rd_len
= min_t(unsigned int,
1557 IPV6_MIN_MTU
-sizeof(struct ipv6hdr
)-len
, skb
->len
+ 8);
1561 buff
= sock_alloc_send_skb(sk
,
1562 (MAX_HEADER
+ sizeof(struct ipv6hdr
) +
1563 len
+ LL_ALLOCATED_SPACE(dev
)),
1567 "ICMPv6 Redirect: %s() failed to allocate an skb, err=%d.\n",
1572 skb_reserve(buff
, LL_RESERVED_SPACE(dev
));
1573 ip6_nd_hdr(sk
, buff
, dev
, &saddr_buf
, &ipv6_hdr(skb
)->saddr
,
1574 IPPROTO_ICMPV6
, len
);
1576 skb_set_transport_header(buff
, skb_tail_pointer(buff
) - buff
->data
);
1578 icmph
= icmp6_hdr(buff
);
1580 memset(icmph
, 0, sizeof(struct icmp6hdr
));
1581 icmph
->icmp6_type
= NDISC_REDIRECT
;
1584 * copy target and destination addresses
1587 addrp
= (struct in6_addr
*)(icmph
+ 1);
1588 ipv6_addr_copy(addrp
, target
);
1590 ipv6_addr_copy(addrp
, &ipv6_hdr(skb
)->daddr
);
1592 opt
= (u8
*) (addrp
+ 1);
1595 * include target_address option
1599 opt
= ndisc_fill_addr_option(opt
, ND_OPT_TARGET_LL_ADDR
, ha
,
1600 dev
->addr_len
, dev
->type
);
1603 * build redirect option and copy skb over to the new packet.
1607 *(opt
++) = ND_OPT_REDIRECT_HDR
;
1608 *(opt
++) = (rd_len
>> 3);
1611 memcpy(opt
, ipv6_hdr(skb
), rd_len
- 8);
1613 icmph
->icmp6_cksum
= csum_ipv6_magic(&saddr_buf
, &ipv6_hdr(skb
)->saddr
,
1614 len
, IPPROTO_ICMPV6
,
1615 csum_partial(icmph
, len
, 0));
1617 skb_dst_set(buff
, dst
);
1618 idev
= in6_dev_get(dst
->dev
);
1619 IP6_UPD_PO_STATS(net
, idev
, IPSTATS_MIB_OUT
, skb
->len
);
1620 err
= NF_HOOK(PF_INET6
, NF_INET_LOCAL_OUT
, buff
, NULL
, dst
->dev
,
1623 ICMP6MSGOUT_INC_STATS(net
, idev
, NDISC_REDIRECT
);
1624 ICMP6_INC_STATS(net
, idev
, ICMP6_MIB_OUTMSGS
);
1627 if (likely(idev
!= NULL
))
1635 static void pndisc_redo(struct sk_buff
*skb
)
1641 int ndisc_rcv(struct sk_buff
*skb
)
1645 if (!pskb_may_pull(skb
, skb
->len
))
1648 msg
= (struct nd_msg
*)skb_transport_header(skb
);
1650 __skb_push(skb
, skb
->data
- skb_transport_header(skb
));
1652 if (ipv6_hdr(skb
)->hop_limit
!= 255) {
1653 ND_PRINTK2(KERN_WARNING
1654 "ICMPv6 NDISC: invalid hop-limit: %d\n",
1655 ipv6_hdr(skb
)->hop_limit
);
1659 if (msg
->icmph
.icmp6_code
!= 0) {
1660 ND_PRINTK2(KERN_WARNING
1661 "ICMPv6 NDISC: invalid ICMPv6 code: %d\n",
1662 msg
->icmph
.icmp6_code
);
1666 memset(NEIGH_CB(skb
), 0, sizeof(struct neighbour_cb
));
1668 switch (msg
->icmph
.icmp6_type
) {
1669 case NDISC_NEIGHBOUR_SOLICITATION
:
1673 case NDISC_NEIGHBOUR_ADVERTISEMENT
:
1677 case NDISC_ROUTER_SOLICITATION
:
1681 case NDISC_ROUTER_ADVERTISEMENT
:
1682 ndisc_router_discovery(skb
);
1685 case NDISC_REDIRECT
:
1686 ndisc_redirect_rcv(skb
);
1693 static int ndisc_netdev_event(struct notifier_block
*this, unsigned long event
, void *ptr
)
1695 struct net_device
*dev
= ptr
;
1696 struct net
*net
= dev_net(dev
);
1699 case NETDEV_CHANGEADDR
:
1700 neigh_changeaddr(&nd_tbl
, dev
);
1701 fib6_run_gc(~0UL, net
);
1704 neigh_ifdown(&nd_tbl
, dev
);
1705 fib6_run_gc(~0UL, net
);
1714 static struct notifier_block ndisc_netdev_notifier
= {
1715 .notifier_call
= ndisc_netdev_event
,
1718 #ifdef CONFIG_SYSCTL
1719 static void ndisc_warn_deprecated_sysctl(struct ctl_table
*ctl
,
1720 const char *func
, const char *dev_name
)
1722 static char warncomm
[TASK_COMM_LEN
];
1724 if (strcmp(warncomm
, current
->comm
) && warned
< 5) {
1725 strcpy(warncomm
, current
->comm
);
1727 "process `%s' is using deprecated sysctl (%s) "
1728 "net.ipv6.neigh.%s.%s; "
1729 "Use net.ipv6.neigh.%s.%s_ms "
1732 dev_name
, ctl
->procname
,
1733 dev_name
, ctl
->procname
);
1738 int ndisc_ifinfo_sysctl_change(struct ctl_table
*ctl
, int write
, struct file
* filp
, void __user
*buffer
, size_t *lenp
, loff_t
*ppos
)
1740 struct net_device
*dev
= ctl
->extra1
;
1741 struct inet6_dev
*idev
;
1744 if ((strcmp(ctl
->procname
, "retrans_time") == 0) ||
1745 (strcmp(ctl
->procname
, "base_reachable_time") == 0))
1746 ndisc_warn_deprecated_sysctl(ctl
, "syscall", dev
? dev
->name
: "default");
1748 if (strcmp(ctl
->procname
, "retrans_time") == 0)
1749 ret
= proc_dointvec(ctl
, write
, filp
, buffer
, lenp
, ppos
);
1751 else if (strcmp(ctl
->procname
, "base_reachable_time") == 0)
1752 ret
= proc_dointvec_jiffies(ctl
, write
,
1753 filp
, buffer
, lenp
, ppos
);
1755 else if ((strcmp(ctl
->procname
, "retrans_time_ms") == 0) ||
1756 (strcmp(ctl
->procname
, "base_reachable_time_ms") == 0))
1757 ret
= proc_dointvec_ms_jiffies(ctl
, write
,
1758 filp
, buffer
, lenp
, ppos
);
1762 if (write
&& ret
== 0 && dev
&& (idev
= in6_dev_get(dev
)) != NULL
) {
1763 if (ctl
->data
== &idev
->nd_parms
->base_reachable_time
)
1764 idev
->nd_parms
->reachable_time
= neigh_rand_reach_time(idev
->nd_parms
->base_reachable_time
);
1765 idev
->tstamp
= jiffies
;
1766 inet6_ifinfo_notify(RTM_NEWLINK
, idev
);
1772 int ndisc_ifinfo_sysctl_strategy(ctl_table
*ctl
,
1773 void __user
*oldval
, size_t __user
*oldlenp
,
1774 void __user
*newval
, size_t newlen
)
1776 struct net_device
*dev
= ctl
->extra1
;
1777 struct inet6_dev
*idev
;
1780 if (ctl
->ctl_name
== NET_NEIGH_RETRANS_TIME
||
1781 ctl
->ctl_name
== NET_NEIGH_REACHABLE_TIME
)
1782 ndisc_warn_deprecated_sysctl(ctl
, "procfs", dev
? dev
->name
: "default");
1784 switch (ctl
->ctl_name
) {
1785 case NET_NEIGH_REACHABLE_TIME
:
1786 ret
= sysctl_jiffies(ctl
, oldval
, oldlenp
, newval
, newlen
);
1788 case NET_NEIGH_RETRANS_TIME_MS
:
1789 case NET_NEIGH_REACHABLE_TIME_MS
:
1790 ret
= sysctl_ms_jiffies(ctl
, oldval
, oldlenp
, newval
, newlen
);
1796 if (newval
&& newlen
&& ret
> 0 &&
1797 dev
&& (idev
= in6_dev_get(dev
)) != NULL
) {
1798 if (ctl
->ctl_name
== NET_NEIGH_REACHABLE_TIME
||
1799 ctl
->ctl_name
== NET_NEIGH_REACHABLE_TIME_MS
)
1800 idev
->nd_parms
->reachable_time
= neigh_rand_reach_time(idev
->nd_parms
->base_reachable_time
);
1801 idev
->tstamp
= jiffies
;
1802 inet6_ifinfo_notify(RTM_NEWLINK
, idev
);
1811 static int ndisc_net_init(struct net
*net
)
1813 struct ipv6_pinfo
*np
;
1817 err
= inet_ctl_sock_create(&sk
, PF_INET6
,
1818 SOCK_RAW
, IPPROTO_ICMPV6
, net
);
1821 "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",
1826 net
->ipv6
.ndisc_sk
= sk
;
1829 np
->hop_limit
= 255;
1830 /* Do not loopback ndisc messages */
1836 static void ndisc_net_exit(struct net
*net
)
1838 inet_ctl_sock_destroy(net
->ipv6
.ndisc_sk
);
1841 static struct pernet_operations ndisc_net_ops
= {
1842 .init
= ndisc_net_init
,
1843 .exit
= ndisc_net_exit
,
1846 int __init
ndisc_init(void)
1850 err
= register_pernet_subsys(&ndisc_net_ops
);
1854 * Initialize the neighbour table
1856 neigh_table_init(&nd_tbl
);
1858 #ifdef CONFIG_SYSCTL
1859 err
= neigh_sysctl_register(NULL
, &nd_tbl
.parms
, NET_IPV6
,
1860 NET_IPV6_NEIGH
, "ipv6",
1861 &ndisc_ifinfo_sysctl_change
,
1862 &ndisc_ifinfo_sysctl_strategy
);
1864 goto out_unregister_pernet
;
1866 err
= register_netdevice_notifier(&ndisc_netdev_notifier
);
1868 goto out_unregister_sysctl
;
1872 out_unregister_sysctl
:
1873 #ifdef CONFIG_SYSCTL
1874 neigh_sysctl_unregister(&nd_tbl
.parms
);
1875 out_unregister_pernet
:
1877 unregister_pernet_subsys(&ndisc_net_ops
);
1881 void ndisc_cleanup(void)
1883 unregister_netdevice_notifier(&ndisc_netdev_notifier
);
1884 #ifdef CONFIG_SYSCTL
1885 neigh_sysctl_unregister(&nd_tbl
.parms
);
1887 neigh_table_clear(&nd_tbl
);
1888 unregister_pernet_subsys(&ndisc_net_ops
);