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>
62 #include <linux/slab.h>
64 #include <linux/sysctl.h>
67 #include <linux/if_addr.h>
68 #include <linux/if_arp.h>
69 #include <linux/ipv6.h>
70 #include <linux/icmpv6.h>
71 #include <linux/jhash.h>
77 #include <net/protocol.h>
78 #include <net/ndisc.h>
79 #include <net/ip6_route.h>
80 #include <net/addrconf.h>
83 #include <net/netlink.h>
84 #include <linux/rtnetlink.h>
87 #include <net/ip6_checksum.h>
88 #include <net/inet_common.h>
89 #include <linux/proc_fs.h>
91 #include <linux/netfilter.h>
92 #include <linux/netfilter_ipv6.h>
94 static u32
ndisc_hash(const void *pkey
,
95 const struct net_device
*dev
,
97 static int ndisc_constructor(struct neighbour
*neigh
);
98 static void ndisc_solicit(struct neighbour
*neigh
, struct sk_buff
*skb
);
99 static void ndisc_error_report(struct neighbour
*neigh
, struct sk_buff
*skb
);
100 static int pndisc_constructor(struct pneigh_entry
*n
);
101 static void pndisc_destructor(struct pneigh_entry
*n
);
102 static void pndisc_redo(struct sk_buff
*skb
);
104 static const struct neigh_ops ndisc_generic_ops
= {
106 .solicit
= ndisc_solicit
,
107 .error_report
= ndisc_error_report
,
108 .output
= neigh_resolve_output
,
109 .connected_output
= neigh_connected_output
,
112 static const 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
,
121 static const struct neigh_ops ndisc_direct_ops
= {
123 .output
= neigh_direct_output
,
124 .connected_output
= neigh_direct_output
,
127 struct neigh_table nd_tbl
= {
129 .key_len
= sizeof(struct in6_addr
),
131 .constructor
= ndisc_constructor
,
132 .pconstructor
= pndisc_constructor
,
133 .pdestructor
= pndisc_destructor
,
134 .proxy_redo
= pndisc_redo
,
138 .base_reachable_time
= ND_REACHABLE_TIME
,
139 .retrans_time
= ND_RETRANS_TIMER
,
140 .gc_staletime
= 60 * HZ
,
141 .reachable_time
= ND_REACHABLE_TIME
,
142 .delay_probe_time
= 5 * HZ
,
143 .queue_len_bytes
= 64*1024,
146 .anycast_delay
= 1 * HZ
,
147 .proxy_delay
= (8 * HZ
) / 10,
150 .gc_interval
= 30 * HZ
,
157 struct ndisc_options
{
158 struct nd_opt_hdr
*nd_opt_array
[__ND_OPT_ARRAY_MAX
];
159 #ifdef CONFIG_IPV6_ROUTE_INFO
160 struct nd_opt_hdr
*nd_opts_ri
;
161 struct nd_opt_hdr
*nd_opts_ri_end
;
163 struct nd_opt_hdr
*nd_useropts
;
164 struct nd_opt_hdr
*nd_useropts_end
;
167 #define nd_opts_src_lladdr nd_opt_array[ND_OPT_SOURCE_LL_ADDR]
168 #define nd_opts_tgt_lladdr nd_opt_array[ND_OPT_TARGET_LL_ADDR]
169 #define nd_opts_pi nd_opt_array[ND_OPT_PREFIX_INFO]
170 #define nd_opts_pi_end nd_opt_array[__ND_OPT_PREFIX_INFO_END]
171 #define nd_opts_rh nd_opt_array[ND_OPT_REDIRECT_HDR]
172 #define nd_opts_mtu nd_opt_array[ND_OPT_MTU]
174 #define NDISC_OPT_SPACE(len) (((len)+2+7)&~7)
177 * Return the padding between the option length and the start of the
178 * link addr. Currently only IP-over-InfiniBand needs this, although
179 * if RFC 3831 IPv6-over-Fibre Channel is ever implemented it may
180 * also need a pad of 2.
182 static int ndisc_addr_option_pad(unsigned short type
)
185 case ARPHRD_INFINIBAND
: return 2;
190 static inline int ndisc_opt_addr_space(struct net_device
*dev
)
192 return NDISC_OPT_SPACE(dev
->addr_len
+ ndisc_addr_option_pad(dev
->type
));
195 static u8
*ndisc_fill_addr_option(u8
*opt
, int type
, void *data
, int data_len
,
196 unsigned short addr_type
)
198 int space
= NDISC_OPT_SPACE(data_len
);
199 int pad
= ndisc_addr_option_pad(addr_type
);
204 memset(opt
+ 2, 0, pad
);
208 memcpy(opt
+2, data
, data_len
);
211 if ((space
-= data_len
) > 0)
212 memset(opt
, 0, space
);
216 static struct nd_opt_hdr
*ndisc_next_option(struct nd_opt_hdr
*cur
,
217 struct nd_opt_hdr
*end
)
220 if (!cur
|| !end
|| cur
>= end
)
222 type
= cur
->nd_opt_type
;
224 cur
= ((void *)cur
) + (cur
->nd_opt_len
<< 3);
225 } while(cur
< end
&& cur
->nd_opt_type
!= type
);
226 return cur
<= end
&& cur
->nd_opt_type
== type
? cur
: NULL
;
229 static inline int ndisc_is_useropt(struct nd_opt_hdr
*opt
)
231 return opt
->nd_opt_type
== ND_OPT_RDNSS
;
234 static struct nd_opt_hdr
*ndisc_next_useropt(struct nd_opt_hdr
*cur
,
235 struct nd_opt_hdr
*end
)
237 if (!cur
|| !end
|| cur
>= end
)
240 cur
= ((void *)cur
) + (cur
->nd_opt_len
<< 3);
241 } while(cur
< end
&& !ndisc_is_useropt(cur
));
242 return cur
<= end
&& ndisc_is_useropt(cur
) ? cur
: NULL
;
245 static struct ndisc_options
*ndisc_parse_options(u8
*opt
, int opt_len
,
246 struct ndisc_options
*ndopts
)
248 struct nd_opt_hdr
*nd_opt
= (struct nd_opt_hdr
*)opt
;
250 if (!nd_opt
|| opt_len
< 0 || !ndopts
)
252 memset(ndopts
, 0, sizeof(*ndopts
));
255 if (opt_len
< sizeof(struct nd_opt_hdr
))
257 l
= nd_opt
->nd_opt_len
<< 3;
258 if (opt_len
< l
|| l
== 0)
260 switch (nd_opt
->nd_opt_type
) {
261 case ND_OPT_SOURCE_LL_ADDR
:
262 case ND_OPT_TARGET_LL_ADDR
:
264 case ND_OPT_REDIRECT_HDR
:
265 if (ndopts
->nd_opt_array
[nd_opt
->nd_opt_type
]) {
266 ND_PRINTK2(KERN_WARNING
267 "%s(): duplicated ND6 option found: type=%d\n",
269 nd_opt
->nd_opt_type
);
271 ndopts
->nd_opt_array
[nd_opt
->nd_opt_type
] = nd_opt
;
274 case ND_OPT_PREFIX_INFO
:
275 ndopts
->nd_opts_pi_end
= nd_opt
;
276 if (!ndopts
->nd_opt_array
[nd_opt
->nd_opt_type
])
277 ndopts
->nd_opt_array
[nd_opt
->nd_opt_type
] = nd_opt
;
279 #ifdef CONFIG_IPV6_ROUTE_INFO
280 case ND_OPT_ROUTE_INFO
:
281 ndopts
->nd_opts_ri_end
= nd_opt
;
282 if (!ndopts
->nd_opts_ri
)
283 ndopts
->nd_opts_ri
= nd_opt
;
287 if (ndisc_is_useropt(nd_opt
)) {
288 ndopts
->nd_useropts_end
= nd_opt
;
289 if (!ndopts
->nd_useropts
)
290 ndopts
->nd_useropts
= nd_opt
;
293 * Unknown options must be silently ignored,
294 * to accommodate future extension to the
297 ND_PRINTK2(KERN_NOTICE
298 "%s(): ignored unsupported option; type=%d, len=%d\n",
300 nd_opt
->nd_opt_type
, nd_opt
->nd_opt_len
);
304 nd_opt
= ((void *)nd_opt
) + l
;
309 static inline u8
*ndisc_opt_addr_data(struct nd_opt_hdr
*p
,
310 struct net_device
*dev
)
312 u8
*lladdr
= (u8
*)(p
+ 1);
313 int lladdrlen
= p
->nd_opt_len
<< 3;
314 int prepad
= ndisc_addr_option_pad(dev
->type
);
315 if (lladdrlen
!= NDISC_OPT_SPACE(dev
->addr_len
+ prepad
))
317 return lladdr
+ prepad
;
320 int ndisc_mc_map(const struct in6_addr
*addr
, char *buf
, struct net_device
*dev
, int dir
)
324 case ARPHRD_IEEE802
: /* Not sure. Check it later. --ANK */
326 ipv6_eth_mc_map(addr
, buf
);
328 case ARPHRD_IEEE802_TR
:
329 ipv6_tr_mc_map(addr
,buf
);
332 ipv6_arcnet_mc_map(addr
, buf
);
334 case ARPHRD_INFINIBAND
:
335 ipv6_ib_mc_map(addr
, dev
->broadcast
, buf
);
338 return ipv6_ipgre_mc_map(addr
, dev
->broadcast
, buf
);
341 memcpy(buf
, dev
->broadcast
, dev
->addr_len
);
348 EXPORT_SYMBOL(ndisc_mc_map
);
350 static u32
ndisc_hash(const void *pkey
,
351 const struct net_device
*dev
,
354 return ndisc_hashfn(pkey
, dev
, hash_rnd
);
357 static int ndisc_constructor(struct neighbour
*neigh
)
359 struct in6_addr
*addr
= (struct in6_addr
*)&neigh
->primary_key
;
360 struct net_device
*dev
= neigh
->dev
;
361 struct inet6_dev
*in6_dev
;
362 struct neigh_parms
*parms
;
363 int is_multicast
= ipv6_addr_is_multicast(addr
);
365 in6_dev
= in6_dev_get(dev
);
366 if (in6_dev
== NULL
) {
370 parms
= in6_dev
->nd_parms
;
371 __neigh_parms_put(neigh
->parms
);
372 neigh
->parms
= neigh_parms_clone(parms
);
374 neigh
->type
= is_multicast
? RTN_MULTICAST
: RTN_UNICAST
;
375 if (!dev
->header_ops
) {
376 neigh
->nud_state
= NUD_NOARP
;
377 neigh
->ops
= &ndisc_direct_ops
;
378 neigh
->output
= neigh_direct_output
;
381 neigh
->nud_state
= NUD_NOARP
;
382 ndisc_mc_map(addr
, neigh
->ha
, dev
, 1);
383 } else if (dev
->flags
&(IFF_NOARP
|IFF_LOOPBACK
)) {
384 neigh
->nud_state
= NUD_NOARP
;
385 memcpy(neigh
->ha
, dev
->dev_addr
, dev
->addr_len
);
386 if (dev
->flags
&IFF_LOOPBACK
)
387 neigh
->type
= RTN_LOCAL
;
388 } else if (dev
->flags
&IFF_POINTOPOINT
) {
389 neigh
->nud_state
= NUD_NOARP
;
390 memcpy(neigh
->ha
, dev
->broadcast
, dev
->addr_len
);
392 if (dev
->header_ops
->cache
)
393 neigh
->ops
= &ndisc_hh_ops
;
395 neigh
->ops
= &ndisc_generic_ops
;
396 if (neigh
->nud_state
&NUD_VALID
)
397 neigh
->output
= neigh
->ops
->connected_output
;
399 neigh
->output
= neigh
->ops
->output
;
401 in6_dev_put(in6_dev
);
405 static int pndisc_constructor(struct pneigh_entry
*n
)
407 struct in6_addr
*addr
= (struct in6_addr
*)&n
->key
;
408 struct in6_addr maddr
;
409 struct net_device
*dev
= n
->dev
;
411 if (dev
== NULL
|| __in6_dev_get(dev
) == NULL
)
413 addrconf_addr_solict_mult(addr
, &maddr
);
414 ipv6_dev_mc_inc(dev
, &maddr
);
418 static void pndisc_destructor(struct pneigh_entry
*n
)
420 struct in6_addr
*addr
= (struct in6_addr
*)&n
->key
;
421 struct in6_addr maddr
;
422 struct net_device
*dev
= n
->dev
;
424 if (dev
== NULL
|| __in6_dev_get(dev
) == NULL
)
426 addrconf_addr_solict_mult(addr
, &maddr
);
427 ipv6_dev_mc_dec(dev
, &maddr
);
430 struct sk_buff
*ndisc_build_skb(struct net_device
*dev
,
431 const struct in6_addr
*daddr
,
432 const struct in6_addr
*saddr
,
433 struct icmp6hdr
*icmp6h
,
434 const struct in6_addr
*target
,
437 struct net
*net
= dev_net(dev
);
438 struct sock
*sk
= net
->ipv6
.ndisc_sk
;
440 struct icmp6hdr
*hdr
;
441 int hlen
= LL_RESERVED_SPACE(dev
);
442 int tlen
= dev
->needed_tailroom
;
450 len
= sizeof(struct icmp6hdr
) + (target
? sizeof(*target
) : 0);
452 len
+= ndisc_opt_addr_space(dev
);
454 skb
= sock_alloc_send_skb(sk
,
455 (MAX_HEADER
+ sizeof(struct ipv6hdr
) +
460 "ICMPv6 ND: %s() failed to allocate an skb, err=%d.\n",
465 skb_reserve(skb
, hlen
);
466 ip6_nd_hdr(sk
, skb
, dev
, saddr
, daddr
, IPPROTO_ICMPV6
, len
);
468 skb
->transport_header
= skb
->tail
;
471 hdr
= (struct icmp6hdr
*)skb_transport_header(skb
);
472 memcpy(hdr
, icmp6h
, sizeof(*hdr
));
474 opt
= skb_transport_header(skb
) + sizeof(struct icmp6hdr
);
476 *(struct in6_addr
*)opt
= *target
;
477 opt
+= sizeof(*target
);
481 ndisc_fill_addr_option(opt
, llinfo
, dev
->dev_addr
,
482 dev
->addr_len
, dev
->type
);
484 hdr
->icmp6_cksum
= csum_ipv6_magic(saddr
, daddr
, len
,
492 EXPORT_SYMBOL(ndisc_build_skb
);
494 void ndisc_send_skb(struct sk_buff
*skb
,
495 struct net_device
*dev
,
496 struct neighbour
*neigh
,
497 const struct in6_addr
*daddr
,
498 const struct in6_addr
*saddr
,
499 struct icmp6hdr
*icmp6h
)
502 struct dst_entry
*dst
;
503 struct net
*net
= dev_net(dev
);
504 struct sock
*sk
= net
->ipv6
.ndisc_sk
;
505 struct inet6_dev
*idev
;
509 type
= icmp6h
->icmp6_type
;
511 icmpv6_flow_init(sk
, &fl6
, type
, saddr
, daddr
, dev
->ifindex
);
512 dst
= icmp6_dst_alloc(dev
, neigh
, &fl6
);
518 skb_dst_set(skb
, dst
);
521 idev
= __in6_dev_get(dst
->dev
);
522 IP6_UPD_PO_STATS(net
, idev
, IPSTATS_MIB_OUT
, skb
->len
);
524 err
= NF_HOOK(NFPROTO_IPV6
, NF_INET_LOCAL_OUT
, skb
, NULL
, dst
->dev
,
527 ICMP6MSGOUT_INC_STATS(net
, idev
, type
);
528 ICMP6_INC_STATS(net
, idev
, ICMP6_MIB_OUTMSGS
);
534 EXPORT_SYMBOL(ndisc_send_skb
);
537 * Send a Neighbour Discover packet
539 static void __ndisc_send(struct net_device
*dev
,
540 struct neighbour
*neigh
,
541 const struct in6_addr
*daddr
,
542 const struct in6_addr
*saddr
,
543 struct icmp6hdr
*icmp6h
, const struct in6_addr
*target
,
548 skb
= ndisc_build_skb(dev
, daddr
, saddr
, icmp6h
, target
, llinfo
);
552 ndisc_send_skb(skb
, dev
, neigh
, daddr
, saddr
, icmp6h
);
555 static void ndisc_send_na(struct net_device
*dev
, struct neighbour
*neigh
,
556 const struct in6_addr
*daddr
,
557 const struct in6_addr
*solicited_addr
,
558 int router
, int solicited
, int override
, int inc_opt
)
560 struct in6_addr tmpaddr
;
561 struct inet6_ifaddr
*ifp
;
562 const struct in6_addr
*src_addr
;
563 struct icmp6hdr icmp6h
= {
564 .icmp6_type
= NDISC_NEIGHBOUR_ADVERTISEMENT
,
567 /* for anycast or proxy, solicited_addr != src_addr */
568 ifp
= ipv6_get_ifaddr(dev_net(dev
), solicited_addr
, dev
, 1);
570 src_addr
= solicited_addr
;
571 if (ifp
->flags
& IFA_F_OPTIMISTIC
)
573 inc_opt
|= ifp
->idev
->cnf
.force_tllao
;
576 if (ipv6_dev_get_saddr(dev_net(dev
), dev
, daddr
,
577 inet6_sk(dev_net(dev
)->ipv6
.ndisc_sk
)->srcprefs
,
583 icmp6h
.icmp6_router
= router
;
584 icmp6h
.icmp6_solicited
= solicited
;
585 icmp6h
.icmp6_override
= override
;
587 __ndisc_send(dev
, neigh
, daddr
, src_addr
,
588 &icmp6h
, solicited_addr
,
589 inc_opt
? ND_OPT_TARGET_LL_ADDR
: 0);
592 static void ndisc_send_unsol_na(struct net_device
*dev
)
594 struct inet6_dev
*idev
;
595 struct inet6_ifaddr
*ifa
;
596 struct in6_addr mcaddr
;
598 idev
= in6_dev_get(dev
);
602 read_lock_bh(&idev
->lock
);
603 list_for_each_entry(ifa
, &idev
->addr_list
, if_list
) {
604 addrconf_addr_solict_mult(&ifa
->addr
, &mcaddr
);
605 ndisc_send_na(dev
, NULL
, &mcaddr
, &ifa
->addr
,
606 /*router=*/ !!idev
->cnf
.forwarding
,
607 /*solicited=*/ false, /*override=*/ true,
610 read_unlock_bh(&idev
->lock
);
615 void ndisc_send_ns(struct net_device
*dev
, struct neighbour
*neigh
,
616 const struct in6_addr
*solicit
,
617 const struct in6_addr
*daddr
, const struct in6_addr
*saddr
)
619 struct in6_addr addr_buf
;
620 struct icmp6hdr icmp6h
= {
621 .icmp6_type
= NDISC_NEIGHBOUR_SOLICITATION
,
625 if (ipv6_get_lladdr(dev
, &addr_buf
,
626 (IFA_F_TENTATIVE
|IFA_F_OPTIMISTIC
)))
631 __ndisc_send(dev
, neigh
, daddr
, saddr
,
633 !ipv6_addr_any(saddr
) ? ND_OPT_SOURCE_LL_ADDR
: 0);
636 void ndisc_send_rs(struct net_device
*dev
, const struct in6_addr
*saddr
,
637 const struct in6_addr
*daddr
)
639 struct icmp6hdr icmp6h
= {
640 .icmp6_type
= NDISC_ROUTER_SOLICITATION
,
642 int send_sllao
= dev
->addr_len
;
644 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
646 * According to section 2.2 of RFC 4429, we must not
647 * send router solicitations with a sllao from
648 * optimistic addresses, but we may send the solicitation
649 * if we don't include the sllao. So here we check
650 * if our address is optimistic, and if so, we
651 * suppress the inclusion of the sllao.
654 struct inet6_ifaddr
*ifp
= ipv6_get_ifaddr(dev_net(dev
), saddr
,
657 if (ifp
->flags
& IFA_F_OPTIMISTIC
) {
666 __ndisc_send(dev
, NULL
, daddr
, saddr
,
668 send_sllao
? ND_OPT_SOURCE_LL_ADDR
: 0);
672 static void ndisc_error_report(struct neighbour
*neigh
, struct sk_buff
*skb
)
675 * "The sender MUST return an ICMP
676 * destination unreachable"
678 dst_link_failure(skb
);
682 /* Called with locked neigh: either read or both */
684 static void ndisc_solicit(struct neighbour
*neigh
, struct sk_buff
*skb
)
686 struct in6_addr
*saddr
= NULL
;
687 struct in6_addr mcaddr
;
688 struct net_device
*dev
= neigh
->dev
;
689 struct in6_addr
*target
= (struct in6_addr
*)&neigh
->primary_key
;
690 int probes
= atomic_read(&neigh
->probes
);
692 if (skb
&& ipv6_chk_addr(dev_net(dev
), &ipv6_hdr(skb
)->saddr
, dev
, 1))
693 saddr
= &ipv6_hdr(skb
)->saddr
;
695 if ((probes
-= neigh
->parms
->ucast_probes
) < 0) {
696 if (!(neigh
->nud_state
& NUD_VALID
)) {
697 ND_PRINTK1(KERN_DEBUG
"%s(): trying to ucast probe in NUD_INVALID: %pI6\n",
700 ndisc_send_ns(dev
, neigh
, target
, target
, saddr
);
701 } else if ((probes
-= neigh
->parms
->app_probes
) < 0) {
706 addrconf_addr_solict_mult(target
, &mcaddr
);
707 ndisc_send_ns(dev
, NULL
, target
, &mcaddr
, saddr
);
711 static int pndisc_is_router(const void *pkey
,
712 struct net_device
*dev
)
714 struct pneigh_entry
*n
;
717 read_lock_bh(&nd_tbl
.lock
);
718 n
= __pneigh_lookup(&nd_tbl
, dev_net(dev
), pkey
, dev
);
720 ret
= !!(n
->flags
& NTF_ROUTER
);
721 read_unlock_bh(&nd_tbl
.lock
);
726 static void ndisc_recv_ns(struct sk_buff
*skb
)
728 struct nd_msg
*msg
= (struct nd_msg
*)skb_transport_header(skb
);
729 const struct in6_addr
*saddr
= &ipv6_hdr(skb
)->saddr
;
730 const struct in6_addr
*daddr
= &ipv6_hdr(skb
)->daddr
;
732 u32 ndoptlen
= skb
->tail
- (skb
->transport_header
+
733 offsetof(struct nd_msg
, opt
));
734 struct ndisc_options ndopts
;
735 struct net_device
*dev
= skb
->dev
;
736 struct inet6_ifaddr
*ifp
;
737 struct inet6_dev
*idev
= NULL
;
738 struct neighbour
*neigh
;
739 int dad
= ipv6_addr_any(saddr
);
743 if (ipv6_addr_is_multicast(&msg
->target
)) {
744 ND_PRINTK2(KERN_WARNING
745 "ICMPv6 NS: multicast target address");
751 * DAD has to be destined for solicited node multicast address.
754 !(daddr
->s6_addr32
[0] == htonl(0xff020000) &&
755 daddr
->s6_addr32
[1] == htonl(0x00000000) &&
756 daddr
->s6_addr32
[2] == htonl(0x00000001) &&
757 daddr
->s6_addr
[12] == 0xff )) {
758 ND_PRINTK2(KERN_WARNING
759 "ICMPv6 NS: bad DAD packet (wrong destination)\n");
763 if (!ndisc_parse_options(msg
->opt
, ndoptlen
, &ndopts
)) {
764 ND_PRINTK2(KERN_WARNING
765 "ICMPv6 NS: invalid ND options\n");
769 if (ndopts
.nd_opts_src_lladdr
) {
770 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_src_lladdr
, dev
);
772 ND_PRINTK2(KERN_WARNING
773 "ICMPv6 NS: invalid link-layer address length\n");
778 * If the IP source address is the unspecified address,
779 * there MUST NOT be source link-layer address option
783 ND_PRINTK2(KERN_WARNING
784 "ICMPv6 NS: bad DAD packet (link-layer address option)\n");
789 inc
= ipv6_addr_is_multicast(daddr
);
791 ifp
= ipv6_get_ifaddr(dev_net(dev
), &msg
->target
, dev
, 1);
794 if (ifp
->flags
& (IFA_F_TENTATIVE
|IFA_F_OPTIMISTIC
)) {
796 if (dev
->type
== ARPHRD_IEEE802_TR
) {
797 const unsigned char *sadr
;
798 sadr
= skb_mac_header(skb
);
799 if (((sadr
[8] ^ dev
->dev_addr
[0]) & 0x7f) == 0 &&
800 sadr
[9] == dev
->dev_addr
[1] &&
801 sadr
[10] == dev
->dev_addr
[2] &&
802 sadr
[11] == dev
->dev_addr
[3] &&
803 sadr
[12] == dev
->dev_addr
[4] &&
804 sadr
[13] == dev
->dev_addr
[5]) {
805 /* looped-back to us */
811 * We are colliding with another node
813 * so fail our DAD process
815 addrconf_dad_failure(ifp
);
819 * This is not a dad solicitation.
820 * If we are an optimistic node,
822 * Otherwise, we should ignore it.
824 if (!(ifp
->flags
& IFA_F_OPTIMISTIC
))
831 struct net
*net
= dev_net(dev
);
833 idev
= in6_dev_get(dev
);
835 /* XXX: count this drop? */
839 if (ipv6_chk_acast_addr(net
, dev
, &msg
->target
) ||
840 (idev
->cnf
.forwarding
&&
841 (net
->ipv6
.devconf_all
->proxy_ndp
|| idev
->cnf
.proxy_ndp
) &&
842 (is_router
= pndisc_is_router(&msg
->target
, dev
)) >= 0)) {
843 if (!(NEIGH_CB(skb
)->flags
& LOCALLY_ENQUEUED
) &&
844 skb
->pkt_type
!= PACKET_HOST
&&
846 idev
->nd_parms
->proxy_delay
!= 0) {
848 * for anycast or proxy,
849 * sender should delay its response
850 * by a random time between 0 and
851 * MAX_ANYCAST_DELAY_TIME seconds.
852 * (RFC2461) -- yoshfuji
854 struct sk_buff
*n
= skb_clone(skb
, GFP_ATOMIC
);
856 pneigh_enqueue(&nd_tbl
, idev
->nd_parms
, n
);
864 is_router
= !!idev
->cnf
.forwarding
;
867 ndisc_send_na(dev
, NULL
, &in6addr_linklocal_allnodes
, &msg
->target
,
868 is_router
, 0, (ifp
!= NULL
), 1);
873 NEIGH_CACHE_STAT_INC(&nd_tbl
, rcv_probes_mcast
);
875 NEIGH_CACHE_STAT_INC(&nd_tbl
, rcv_probes_ucast
);
878 * update / create cache entry
879 * for the source address
881 neigh
= __neigh_lookup(&nd_tbl
, saddr
, dev
,
882 !inc
|| lladdr
|| !dev
->addr_len
);
884 neigh_update(neigh
, lladdr
, NUD_STALE
,
885 NEIGH_UPDATE_F_WEAK_OVERRIDE
|
886 NEIGH_UPDATE_F_OVERRIDE
);
887 if (neigh
|| !dev
->header_ops
) {
888 ndisc_send_na(dev
, neigh
, saddr
, &msg
->target
,
890 1, (ifp
!= NULL
&& inc
), inc
);
892 neigh_release(neigh
);
902 static void ndisc_recv_na(struct sk_buff
*skb
)
904 struct nd_msg
*msg
= (struct nd_msg
*)skb_transport_header(skb
);
905 const struct in6_addr
*saddr
= &ipv6_hdr(skb
)->saddr
;
906 const struct in6_addr
*daddr
= &ipv6_hdr(skb
)->daddr
;
908 u32 ndoptlen
= skb
->tail
- (skb
->transport_header
+
909 offsetof(struct nd_msg
, opt
));
910 struct ndisc_options ndopts
;
911 struct net_device
*dev
= skb
->dev
;
912 struct inet6_ifaddr
*ifp
;
913 struct neighbour
*neigh
;
915 if (skb
->len
< sizeof(struct nd_msg
)) {
916 ND_PRINTK2(KERN_WARNING
917 "ICMPv6 NA: packet too short\n");
921 if (ipv6_addr_is_multicast(&msg
->target
)) {
922 ND_PRINTK2(KERN_WARNING
923 "ICMPv6 NA: target address is multicast.\n");
927 if (ipv6_addr_is_multicast(daddr
) &&
928 msg
->icmph
.icmp6_solicited
) {
929 ND_PRINTK2(KERN_WARNING
930 "ICMPv6 NA: solicited NA is multicasted.\n");
934 if (!ndisc_parse_options(msg
->opt
, ndoptlen
, &ndopts
)) {
935 ND_PRINTK2(KERN_WARNING
936 "ICMPv6 NS: invalid ND option\n");
939 if (ndopts
.nd_opts_tgt_lladdr
) {
940 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_tgt_lladdr
, dev
);
942 ND_PRINTK2(KERN_WARNING
943 "ICMPv6 NA: invalid link-layer address length\n");
947 ifp
= ipv6_get_ifaddr(dev_net(dev
), &msg
->target
, dev
, 1);
949 if (skb
->pkt_type
!= PACKET_LOOPBACK
950 && (ifp
->flags
& IFA_F_TENTATIVE
)) {
951 addrconf_dad_failure(ifp
);
954 /* What should we make now? The advertisement
955 is invalid, but ndisc specs say nothing
956 about it. It could be misconfiguration, or
957 an smart proxy agent tries to help us :-)
959 We should not print the error if NA has been
960 received from loopback - it is just our own
961 unsolicited advertisement.
963 if (skb
->pkt_type
!= PACKET_LOOPBACK
)
964 ND_PRINTK1(KERN_WARNING
965 "ICMPv6 NA: someone advertises our address %pI6 on %s!\n",
966 &ifp
->addr
, ifp
->idev
->dev
->name
);
970 neigh
= neigh_lookup(&nd_tbl
, &msg
->target
, dev
);
973 u8 old_flags
= neigh
->flags
;
974 struct net
*net
= dev_net(dev
);
976 if (neigh
->nud_state
& NUD_FAILED
)
980 * Don't update the neighbor cache entry on a proxy NA from
981 * ourselves because either the proxied node is off link or it
982 * has already sent a NA to us.
984 if (lladdr
&& !memcmp(lladdr
, dev
->dev_addr
, dev
->addr_len
) &&
985 net
->ipv6
.devconf_all
->forwarding
&& net
->ipv6
.devconf_all
->proxy_ndp
&&
986 pneigh_lookup(&nd_tbl
, net
, &msg
->target
, dev
, 0)) {
987 /* XXX: idev->cnf.prixy_ndp */
991 neigh_update(neigh
, lladdr
,
992 msg
->icmph
.icmp6_solicited
? NUD_REACHABLE
: NUD_STALE
,
993 NEIGH_UPDATE_F_WEAK_OVERRIDE
|
994 (msg
->icmph
.icmp6_override
? NEIGH_UPDATE_F_OVERRIDE
: 0)|
995 NEIGH_UPDATE_F_OVERRIDE_ISROUTER
|
996 (msg
->icmph
.icmp6_router
? NEIGH_UPDATE_F_ISROUTER
: 0));
998 if ((old_flags
& ~neigh
->flags
) & NTF_ROUTER
) {
1000 * Change: router to host
1002 struct rt6_info
*rt
;
1003 rt
= rt6_get_dflt_router(saddr
, dev
);
1009 neigh_release(neigh
);
1013 static void ndisc_recv_rs(struct sk_buff
*skb
)
1015 struct rs_msg
*rs_msg
= (struct rs_msg
*)skb_transport_header(skb
);
1016 unsigned long ndoptlen
= skb
->len
- sizeof(*rs_msg
);
1017 struct neighbour
*neigh
;
1018 struct inet6_dev
*idev
;
1019 const struct in6_addr
*saddr
= &ipv6_hdr(skb
)->saddr
;
1020 struct ndisc_options ndopts
;
1023 if (skb
->len
< sizeof(*rs_msg
))
1026 idev
= __in6_dev_get(skb
->dev
);
1028 if (net_ratelimit())
1029 ND_PRINTK1("ICMP6 RS: can't find in6 device\n");
1033 /* Don't accept RS if we're not in router mode */
1034 if (!idev
->cnf
.forwarding
)
1038 * Don't update NCE if src = ::;
1039 * this implies that the source node has no ip address assigned yet.
1041 if (ipv6_addr_any(saddr
))
1044 /* Parse ND options */
1045 if (!ndisc_parse_options(rs_msg
->opt
, ndoptlen
, &ndopts
)) {
1046 if (net_ratelimit())
1047 ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n");
1051 if (ndopts
.nd_opts_src_lladdr
) {
1052 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_src_lladdr
,
1058 neigh
= __neigh_lookup(&nd_tbl
, saddr
, skb
->dev
, 1);
1060 neigh_update(neigh
, lladdr
, NUD_STALE
,
1061 NEIGH_UPDATE_F_WEAK_OVERRIDE
|
1062 NEIGH_UPDATE_F_OVERRIDE
|
1063 NEIGH_UPDATE_F_OVERRIDE_ISROUTER
);
1064 neigh_release(neigh
);
1070 static void ndisc_ra_useropt(struct sk_buff
*ra
, struct nd_opt_hdr
*opt
)
1072 struct icmp6hdr
*icmp6h
= (struct icmp6hdr
*)skb_transport_header(ra
);
1073 struct sk_buff
*skb
;
1074 struct nlmsghdr
*nlh
;
1075 struct nduseroptmsg
*ndmsg
;
1076 struct net
*net
= dev_net(ra
->dev
);
1078 int base_size
= NLMSG_ALIGN(sizeof(struct nduseroptmsg
)
1079 + (opt
->nd_opt_len
<< 3));
1080 size_t msg_size
= base_size
+ nla_total_size(sizeof(struct in6_addr
));
1082 skb
= nlmsg_new(msg_size
, GFP_ATOMIC
);
1088 nlh
= nlmsg_put(skb
, 0, 0, RTM_NEWNDUSEROPT
, base_size
, 0);
1090 goto nla_put_failure
;
1093 ndmsg
= nlmsg_data(nlh
);
1094 ndmsg
->nduseropt_family
= AF_INET6
;
1095 ndmsg
->nduseropt_ifindex
= ra
->dev
->ifindex
;
1096 ndmsg
->nduseropt_icmp_type
= icmp6h
->icmp6_type
;
1097 ndmsg
->nduseropt_icmp_code
= icmp6h
->icmp6_code
;
1098 ndmsg
->nduseropt_opts_len
= opt
->nd_opt_len
<< 3;
1100 memcpy(ndmsg
+ 1, opt
, opt
->nd_opt_len
<< 3);
1102 if (nla_put(skb
, NDUSEROPT_SRCADDR
, sizeof(struct in6_addr
),
1103 &ipv6_hdr(ra
)->saddr
))
1104 goto nla_put_failure
;
1105 nlmsg_end(skb
, nlh
);
1107 rtnl_notify(skb
, net
, 0, RTNLGRP_ND_USEROPT
, NULL
, GFP_ATOMIC
);
1114 rtnl_set_sk_err(net
, RTNLGRP_ND_USEROPT
, err
);
1117 static inline int accept_ra(struct inet6_dev
*in6_dev
)
1120 * If forwarding is enabled, RA are not accepted unless the special
1121 * hybrid mode (accept_ra=2) is enabled.
1123 if (in6_dev
->cnf
.forwarding
&& in6_dev
->cnf
.accept_ra
< 2)
1126 return in6_dev
->cnf
.accept_ra
;
1129 static void ndisc_router_discovery(struct sk_buff
*skb
)
1131 struct ra_msg
*ra_msg
= (struct ra_msg
*)skb_transport_header(skb
);
1132 struct neighbour
*neigh
= NULL
;
1133 struct inet6_dev
*in6_dev
;
1134 struct rt6_info
*rt
= NULL
;
1136 struct ndisc_options ndopts
;
1138 unsigned int pref
= 0;
1140 __u8
* opt
= (__u8
*)(ra_msg
+ 1);
1142 optlen
= (skb
->tail
- skb
->transport_header
) - sizeof(struct ra_msg
);
1144 if (!(ipv6_addr_type(&ipv6_hdr(skb
)->saddr
) & IPV6_ADDR_LINKLOCAL
)) {
1145 ND_PRINTK2(KERN_WARNING
1146 "ICMPv6 RA: source address is not link-local.\n");
1150 ND_PRINTK2(KERN_WARNING
1151 "ICMPv6 RA: packet too short\n");
1155 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1156 if (skb
->ndisc_nodetype
== NDISC_NODETYPE_HOST
) {
1157 ND_PRINTK2(KERN_WARNING
1158 "ICMPv6 RA: from host or unauthorized router\n");
1164 * set the RA_RECV flag in the interface
1167 in6_dev
= __in6_dev_get(skb
->dev
);
1168 if (in6_dev
== NULL
) {
1170 "ICMPv6 RA: can't find inet6 device for %s.\n",
1175 if (!ndisc_parse_options(opt
, optlen
, &ndopts
)) {
1176 ND_PRINTK2(KERN_WARNING
1177 "ICMP6 RA: invalid ND options\n");
1181 if (!accept_ra(in6_dev
))
1182 goto skip_linkparms
;
1184 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1185 /* skip link-specific parameters from interior routers */
1186 if (skb
->ndisc_nodetype
== NDISC_NODETYPE_NODEFAULT
)
1187 goto skip_linkparms
;
1190 if (in6_dev
->if_flags
& IF_RS_SENT
) {
1192 * flag that an RA was received after an RS was sent
1193 * out on this interface.
1195 in6_dev
->if_flags
|= IF_RA_RCVD
;
1199 * Remember the managed/otherconf flags from most recently
1200 * received RA message (RFC 2462) -- yoshfuji
1202 in6_dev
->if_flags
= (in6_dev
->if_flags
& ~(IF_RA_MANAGED
|
1204 (ra_msg
->icmph
.icmp6_addrconf_managed
?
1205 IF_RA_MANAGED
: 0) |
1206 (ra_msg
->icmph
.icmp6_addrconf_other
?
1207 IF_RA_OTHERCONF
: 0);
1209 if (!in6_dev
->cnf
.accept_ra_defrtr
)
1212 if (ipv6_chk_addr(dev_net(in6_dev
->dev
), &ipv6_hdr(skb
)->saddr
, NULL
, 0))
1215 lifetime
= ntohs(ra_msg
->icmph
.icmp6_rt_lifetime
);
1217 #ifdef CONFIG_IPV6_ROUTER_PREF
1218 pref
= ra_msg
->icmph
.icmp6_router_pref
;
1219 /* 10b is handled as if it were 00b (medium) */
1220 if (pref
== ICMPV6_ROUTER_PREF_INVALID
||
1221 !in6_dev
->cnf
.accept_ra_rtr_pref
)
1222 pref
= ICMPV6_ROUTER_PREF_MEDIUM
;
1225 rt
= rt6_get_dflt_router(&ipv6_hdr(skb
)->saddr
, skb
->dev
);
1228 neigh
= dst_neigh_lookup(&rt
->dst
, &ipv6_hdr(skb
)->saddr
);
1231 "ICMPv6 RA: %s() got default router without neighbour.\n",
1233 dst_release(&rt
->dst
);
1237 if (rt
&& lifetime
== 0) {
1242 if (rt
== NULL
&& lifetime
) {
1243 ND_PRINTK3(KERN_DEBUG
1244 "ICMPv6 RA: adding default router.\n");
1246 rt
= rt6_add_dflt_router(&ipv6_hdr(skb
)->saddr
, skb
->dev
, pref
);
1249 "ICMPv6 RA: %s() failed to add default route.\n",
1254 neigh
= dst_neigh_lookup(&rt
->dst
, &ipv6_hdr(skb
)->saddr
);
1255 if (neigh
== NULL
) {
1257 "ICMPv6 RA: %s() got default router without neighbour.\n",
1259 dst_release(&rt
->dst
);
1262 neigh
->flags
|= NTF_ROUTER
;
1264 rt
->rt6i_flags
= (rt
->rt6i_flags
& ~RTF_PREF_MASK
) | RTF_PREF(pref
);
1268 rt
->dst
.expires
= jiffies
+ (HZ
* lifetime
);
1270 if (ra_msg
->icmph
.icmp6_hop_limit
) {
1271 in6_dev
->cnf
.hop_limit
= ra_msg
->icmph
.icmp6_hop_limit
;
1273 dst_metric_set(&rt
->dst
, RTAX_HOPLIMIT
,
1274 ra_msg
->icmph
.icmp6_hop_limit
);
1280 * Update Reachable Time and Retrans Timer
1283 if (in6_dev
->nd_parms
) {
1284 unsigned long rtime
= ntohl(ra_msg
->retrans_timer
);
1286 if (rtime
&& rtime
/1000 < MAX_SCHEDULE_TIMEOUT
/HZ
) {
1287 rtime
= (rtime
*HZ
)/1000;
1290 in6_dev
->nd_parms
->retrans_time
= rtime
;
1291 in6_dev
->tstamp
= jiffies
;
1292 inet6_ifinfo_notify(RTM_NEWLINK
, in6_dev
);
1295 rtime
= ntohl(ra_msg
->reachable_time
);
1296 if (rtime
&& rtime
/1000 < MAX_SCHEDULE_TIMEOUT
/(3*HZ
)) {
1297 rtime
= (rtime
*HZ
)/1000;
1302 if (rtime
!= in6_dev
->nd_parms
->base_reachable_time
) {
1303 in6_dev
->nd_parms
->base_reachable_time
= rtime
;
1304 in6_dev
->nd_parms
->gc_staletime
= 3 * rtime
;
1305 in6_dev
->nd_parms
->reachable_time
= neigh_rand_reach_time(rtime
);
1306 in6_dev
->tstamp
= jiffies
;
1307 inet6_ifinfo_notify(RTM_NEWLINK
, in6_dev
);
1319 neigh
= __neigh_lookup(&nd_tbl
, &ipv6_hdr(skb
)->saddr
,
1323 if (ndopts
.nd_opts_src_lladdr
) {
1324 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_src_lladdr
,
1327 ND_PRINTK2(KERN_WARNING
1328 "ICMPv6 RA: invalid link-layer address length\n");
1332 neigh_update(neigh
, lladdr
, NUD_STALE
,
1333 NEIGH_UPDATE_F_WEAK_OVERRIDE
|
1334 NEIGH_UPDATE_F_OVERRIDE
|
1335 NEIGH_UPDATE_F_OVERRIDE_ISROUTER
|
1336 NEIGH_UPDATE_F_ISROUTER
);
1339 if (!accept_ra(in6_dev
))
1342 #ifdef CONFIG_IPV6_ROUTE_INFO
1343 if (ipv6_chk_addr(dev_net(in6_dev
->dev
), &ipv6_hdr(skb
)->saddr
, NULL
, 0))
1344 goto skip_routeinfo
;
1346 if (in6_dev
->cnf
.accept_ra_rtr_pref
&& ndopts
.nd_opts_ri
) {
1347 struct nd_opt_hdr
*p
;
1348 for (p
= ndopts
.nd_opts_ri
;
1350 p
= ndisc_next_option(p
, ndopts
.nd_opts_ri_end
)) {
1351 struct route_info
*ri
= (struct route_info
*)p
;
1352 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1353 if (skb
->ndisc_nodetype
== NDISC_NODETYPE_NODEFAULT
&&
1354 ri
->prefix_len
== 0)
1357 if (ri
->prefix_len
> in6_dev
->cnf
.accept_ra_rt_info_max_plen
)
1359 rt6_route_rcv(skb
->dev
, (u8
*)p
, (p
->nd_opt_len
) << 3,
1360 &ipv6_hdr(skb
)->saddr
);
1367 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1368 /* skip link-specific ndopts from interior routers */
1369 if (skb
->ndisc_nodetype
== NDISC_NODETYPE_NODEFAULT
)
1373 if (in6_dev
->cnf
.accept_ra_pinfo
&& ndopts
.nd_opts_pi
) {
1374 struct nd_opt_hdr
*p
;
1375 for (p
= ndopts
.nd_opts_pi
;
1377 p
= ndisc_next_option(p
, ndopts
.nd_opts_pi_end
)) {
1378 addrconf_prefix_rcv(skb
->dev
, (u8
*)p
,
1379 (p
->nd_opt_len
) << 3,
1380 ndopts
.nd_opts_src_lladdr
!= NULL
);
1384 if (ndopts
.nd_opts_mtu
) {
1388 memcpy(&n
, ((u8
*)(ndopts
.nd_opts_mtu
+1))+2, sizeof(mtu
));
1391 if (mtu
< IPV6_MIN_MTU
|| mtu
> skb
->dev
->mtu
) {
1392 ND_PRINTK2(KERN_WARNING
1393 "ICMPv6 RA: invalid mtu: %d\n",
1395 } else if (in6_dev
->cnf
.mtu6
!= mtu
) {
1396 in6_dev
->cnf
.mtu6
= mtu
;
1399 dst_metric_set(&rt
->dst
, RTAX_MTU
, mtu
);
1401 rt6_mtu_change(skb
->dev
, mtu
);
1405 if (ndopts
.nd_useropts
) {
1406 struct nd_opt_hdr
*p
;
1407 for (p
= ndopts
.nd_useropts
;
1409 p
= ndisc_next_useropt(p
, ndopts
.nd_useropts_end
)) {
1410 ndisc_ra_useropt(skb
, p
);
1414 if (ndopts
.nd_opts_tgt_lladdr
|| ndopts
.nd_opts_rh
) {
1415 ND_PRINTK2(KERN_WARNING
1416 "ICMPv6 RA: invalid RA options");
1420 dst_release(&rt
->dst
);
1422 neigh_release(neigh
);
1425 static void ndisc_redirect_rcv(struct sk_buff
*skb
)
1427 struct inet6_dev
*in6_dev
;
1428 struct icmp6hdr
*icmph
;
1429 const struct in6_addr
*dest
;
1430 const struct in6_addr
*target
; /* new first hop to destination */
1431 struct neighbour
*neigh
;
1433 struct ndisc_options ndopts
;
1437 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1438 switch (skb
->ndisc_nodetype
) {
1439 case NDISC_NODETYPE_HOST
:
1440 case NDISC_NODETYPE_NODEFAULT
:
1441 ND_PRINTK2(KERN_WARNING
1442 "ICMPv6 Redirect: from host or unauthorized router\n");
1447 if (!(ipv6_addr_type(&ipv6_hdr(skb
)->saddr
) & IPV6_ADDR_LINKLOCAL
)) {
1448 ND_PRINTK2(KERN_WARNING
1449 "ICMPv6 Redirect: source address is not link-local.\n");
1453 optlen
= skb
->tail
- skb
->transport_header
;
1454 optlen
-= sizeof(struct icmp6hdr
) + 2 * sizeof(struct in6_addr
);
1457 ND_PRINTK2(KERN_WARNING
1458 "ICMPv6 Redirect: packet too short\n");
1462 icmph
= icmp6_hdr(skb
);
1463 target
= (const struct in6_addr
*) (icmph
+ 1);
1466 if (ipv6_addr_is_multicast(dest
)) {
1467 ND_PRINTK2(KERN_WARNING
1468 "ICMPv6 Redirect: destination address is multicast.\n");
1472 if (ipv6_addr_equal(dest
, target
)) {
1474 } else if (ipv6_addr_type(target
) !=
1475 (IPV6_ADDR_UNICAST
|IPV6_ADDR_LINKLOCAL
)) {
1476 ND_PRINTK2(KERN_WARNING
1477 "ICMPv6 Redirect: target address is not link-local unicast.\n");
1481 in6_dev
= __in6_dev_get(skb
->dev
);
1484 if (in6_dev
->cnf
.forwarding
|| !in6_dev
->cnf
.accept_redirects
)
1488 * The IP source address of the Redirect MUST be the same as the current
1489 * first-hop router for the specified ICMP Destination Address.
1492 if (!ndisc_parse_options((u8
*)(dest
+ 1), optlen
, &ndopts
)) {
1493 ND_PRINTK2(KERN_WARNING
1494 "ICMPv6 Redirect: invalid ND options\n");
1497 if (ndopts
.nd_opts_tgt_lladdr
) {
1498 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_tgt_lladdr
,
1501 ND_PRINTK2(KERN_WARNING
1502 "ICMPv6 Redirect: invalid link-layer address length\n");
1507 neigh
= __neigh_lookup(&nd_tbl
, target
, skb
->dev
, 1);
1509 rt6_redirect(dest
, &ipv6_hdr(skb
)->daddr
,
1510 &ipv6_hdr(skb
)->saddr
, neigh
, lladdr
,
1512 neigh_release(neigh
);
1516 void ndisc_send_redirect(struct sk_buff
*skb
, const struct in6_addr
*target
)
1518 struct net_device
*dev
= skb
->dev
;
1519 struct net
*net
= dev_net(dev
);
1520 struct sock
*sk
= net
->ipv6
.ndisc_sk
;
1521 int len
= sizeof(struct icmp6hdr
) + 2 * sizeof(struct in6_addr
);
1522 struct sk_buff
*buff
;
1523 struct icmp6hdr
*icmph
;
1524 struct in6_addr saddr_buf
;
1525 struct in6_addr
*addrp
;
1526 struct rt6_info
*rt
;
1527 struct dst_entry
*dst
;
1528 struct inet6_dev
*idev
;
1534 u8 ha_buf
[MAX_ADDR_LEN
], *ha
= NULL
;
1536 if (ipv6_get_lladdr(dev
, &saddr_buf
, IFA_F_TENTATIVE
)) {
1537 ND_PRINTK2(KERN_WARNING
1538 "ICMPv6 Redirect: no link-local address on %s\n",
1543 if (!ipv6_addr_equal(&ipv6_hdr(skb
)->daddr
, target
) &&
1544 ipv6_addr_type(target
) != (IPV6_ADDR_UNICAST
|IPV6_ADDR_LINKLOCAL
)) {
1545 ND_PRINTK2(KERN_WARNING
1546 "ICMPv6 Redirect: target address is not link-local unicast.\n");
1550 icmpv6_flow_init(sk
, &fl6
, NDISC_REDIRECT
,
1551 &saddr_buf
, &ipv6_hdr(skb
)->saddr
, dev
->ifindex
);
1553 dst
= ip6_route_output(net
, NULL
, &fl6
);
1558 dst
= xfrm_lookup(net
, dst
, flowi6_to_flowi(&fl6
), NULL
, 0);
1562 rt
= (struct rt6_info
*) dst
;
1564 if (rt
->rt6i_flags
& RTF_GATEWAY
) {
1565 ND_PRINTK2(KERN_WARNING
1566 "ICMPv6 Redirect: destination is not a neighbour.\n");
1570 rt6_bind_peer(rt
, 1);
1571 if (!inet_peer_xrlim_allow(rt
->rt6i_peer
, 1*HZ
))
1574 if (dev
->addr_len
) {
1575 struct neighbour
*neigh
= dst_neigh_lookup(skb_dst(skb
), target
);
1577 ND_PRINTK2(KERN_WARNING
1578 "ICMPv6 Redirect: no neigh for target address\n");
1582 read_lock_bh(&neigh
->lock
);
1583 if (neigh
->nud_state
& NUD_VALID
) {
1584 memcpy(ha_buf
, neigh
->ha
, dev
->addr_len
);
1585 read_unlock_bh(&neigh
->lock
);
1587 len
+= ndisc_opt_addr_space(dev
);
1589 read_unlock_bh(&neigh
->lock
);
1591 neigh_release(neigh
);
1594 rd_len
= min_t(unsigned int,
1595 IPV6_MIN_MTU
-sizeof(struct ipv6hdr
)-len
, skb
->len
+ 8);
1599 hlen
= LL_RESERVED_SPACE(dev
);
1600 tlen
= dev
->needed_tailroom
;
1601 buff
= sock_alloc_send_skb(sk
,
1602 (MAX_HEADER
+ sizeof(struct ipv6hdr
) +
1607 "ICMPv6 Redirect: %s() failed to allocate an skb, err=%d.\n",
1612 skb_reserve(buff
, hlen
);
1613 ip6_nd_hdr(sk
, buff
, dev
, &saddr_buf
, &ipv6_hdr(skb
)->saddr
,
1614 IPPROTO_ICMPV6
, len
);
1616 skb_set_transport_header(buff
, skb_tail_pointer(buff
) - buff
->data
);
1618 icmph
= icmp6_hdr(buff
);
1620 memset(icmph
, 0, sizeof(struct icmp6hdr
));
1621 icmph
->icmp6_type
= NDISC_REDIRECT
;
1624 * copy target and destination addresses
1627 addrp
= (struct in6_addr
*)(icmph
+ 1);
1630 *addrp
= ipv6_hdr(skb
)->daddr
;
1632 opt
= (u8
*) (addrp
+ 1);
1635 * include target_address option
1639 opt
= ndisc_fill_addr_option(opt
, ND_OPT_TARGET_LL_ADDR
, ha
,
1640 dev
->addr_len
, dev
->type
);
1643 * build redirect option and copy skb over to the new packet.
1647 *(opt
++) = ND_OPT_REDIRECT_HDR
;
1648 *(opt
++) = (rd_len
>> 3);
1651 memcpy(opt
, ipv6_hdr(skb
), rd_len
- 8);
1653 icmph
->icmp6_cksum
= csum_ipv6_magic(&saddr_buf
, &ipv6_hdr(skb
)->saddr
,
1654 len
, IPPROTO_ICMPV6
,
1655 csum_partial(icmph
, len
, 0));
1657 skb_dst_set(buff
, dst
);
1659 idev
= __in6_dev_get(dst
->dev
);
1660 IP6_UPD_PO_STATS(net
, idev
, IPSTATS_MIB_OUT
, skb
->len
);
1661 err
= NF_HOOK(NFPROTO_IPV6
, NF_INET_LOCAL_OUT
, buff
, NULL
, dst
->dev
,
1664 ICMP6MSGOUT_INC_STATS(net
, idev
, NDISC_REDIRECT
);
1665 ICMP6_INC_STATS(net
, idev
, ICMP6_MIB_OUTMSGS
);
1675 static void pndisc_redo(struct sk_buff
*skb
)
1681 int ndisc_rcv(struct sk_buff
*skb
)
1685 if (!pskb_may_pull(skb
, skb
->len
))
1688 msg
= (struct nd_msg
*)skb_transport_header(skb
);
1690 __skb_push(skb
, skb
->data
- skb_transport_header(skb
));
1692 if (ipv6_hdr(skb
)->hop_limit
!= 255) {
1693 ND_PRINTK2(KERN_WARNING
1694 "ICMPv6 NDISC: invalid hop-limit: %d\n",
1695 ipv6_hdr(skb
)->hop_limit
);
1699 if (msg
->icmph
.icmp6_code
!= 0) {
1700 ND_PRINTK2(KERN_WARNING
1701 "ICMPv6 NDISC: invalid ICMPv6 code: %d\n",
1702 msg
->icmph
.icmp6_code
);
1706 memset(NEIGH_CB(skb
), 0, sizeof(struct neighbour_cb
));
1708 switch (msg
->icmph
.icmp6_type
) {
1709 case NDISC_NEIGHBOUR_SOLICITATION
:
1713 case NDISC_NEIGHBOUR_ADVERTISEMENT
:
1717 case NDISC_ROUTER_SOLICITATION
:
1721 case NDISC_ROUTER_ADVERTISEMENT
:
1722 ndisc_router_discovery(skb
);
1725 case NDISC_REDIRECT
:
1726 ndisc_redirect_rcv(skb
);
1733 static int ndisc_netdev_event(struct notifier_block
*this, unsigned long event
, void *ptr
)
1735 struct net_device
*dev
= ptr
;
1736 struct net
*net
= dev_net(dev
);
1739 case NETDEV_CHANGEADDR
:
1740 neigh_changeaddr(&nd_tbl
, dev
);
1741 fib6_run_gc(~0UL, net
);
1744 neigh_ifdown(&nd_tbl
, dev
);
1745 fib6_run_gc(~0UL, net
);
1747 case NETDEV_NOTIFY_PEERS
:
1748 ndisc_send_unsol_na(dev
);
1757 static struct notifier_block ndisc_netdev_notifier
= {
1758 .notifier_call
= ndisc_netdev_event
,
1761 #ifdef CONFIG_SYSCTL
1762 static void ndisc_warn_deprecated_sysctl(struct ctl_table
*ctl
,
1763 const char *func
, const char *dev_name
)
1765 static char warncomm
[TASK_COMM_LEN
];
1767 if (strcmp(warncomm
, current
->comm
) && warned
< 5) {
1768 strcpy(warncomm
, current
->comm
);
1770 "process `%s' is using deprecated sysctl (%s) "
1771 "net.ipv6.neigh.%s.%s; "
1772 "Use net.ipv6.neigh.%s.%s_ms "
1775 dev_name
, ctl
->procname
,
1776 dev_name
, ctl
->procname
);
1781 int ndisc_ifinfo_sysctl_change(struct ctl_table
*ctl
, int write
, void __user
*buffer
, size_t *lenp
, loff_t
*ppos
)
1783 struct net_device
*dev
= ctl
->extra1
;
1784 struct inet6_dev
*idev
;
1787 if ((strcmp(ctl
->procname
, "retrans_time") == 0) ||
1788 (strcmp(ctl
->procname
, "base_reachable_time") == 0))
1789 ndisc_warn_deprecated_sysctl(ctl
, "syscall", dev
? dev
->name
: "default");
1791 if (strcmp(ctl
->procname
, "retrans_time") == 0)
1792 ret
= proc_dointvec(ctl
, write
, buffer
, lenp
, ppos
);
1794 else if (strcmp(ctl
->procname
, "base_reachable_time") == 0)
1795 ret
= proc_dointvec_jiffies(ctl
, write
,
1796 buffer
, lenp
, ppos
);
1798 else if ((strcmp(ctl
->procname
, "retrans_time_ms") == 0) ||
1799 (strcmp(ctl
->procname
, "base_reachable_time_ms") == 0))
1800 ret
= proc_dointvec_ms_jiffies(ctl
, write
,
1801 buffer
, lenp
, ppos
);
1805 if (write
&& ret
== 0 && dev
&& (idev
= in6_dev_get(dev
)) != NULL
) {
1806 if (ctl
->data
== &idev
->nd_parms
->base_reachable_time
)
1807 idev
->nd_parms
->reachable_time
= neigh_rand_reach_time(idev
->nd_parms
->base_reachable_time
);
1808 idev
->tstamp
= jiffies
;
1809 inet6_ifinfo_notify(RTM_NEWLINK
, idev
);
1818 static int __net_init
ndisc_net_init(struct net
*net
)
1820 struct ipv6_pinfo
*np
;
1824 err
= inet_ctl_sock_create(&sk
, PF_INET6
,
1825 SOCK_RAW
, IPPROTO_ICMPV6
, net
);
1828 "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",
1833 net
->ipv6
.ndisc_sk
= sk
;
1836 np
->hop_limit
= 255;
1837 /* Do not loopback ndisc messages */
1843 static void __net_exit
ndisc_net_exit(struct net
*net
)
1845 inet_ctl_sock_destroy(net
->ipv6
.ndisc_sk
);
1848 static struct pernet_operations ndisc_net_ops
= {
1849 .init
= ndisc_net_init
,
1850 .exit
= ndisc_net_exit
,
1853 int __init
ndisc_init(void)
1857 err
= register_pernet_subsys(&ndisc_net_ops
);
1861 * Initialize the neighbour table
1863 neigh_table_init(&nd_tbl
);
1865 #ifdef CONFIG_SYSCTL
1866 err
= neigh_sysctl_register(NULL
, &nd_tbl
.parms
, "ipv6",
1867 &ndisc_ifinfo_sysctl_change
);
1869 goto out_unregister_pernet
;
1871 err
= register_netdevice_notifier(&ndisc_netdev_notifier
);
1873 goto out_unregister_sysctl
;
1877 out_unregister_sysctl
:
1878 #ifdef CONFIG_SYSCTL
1879 neigh_sysctl_unregister(&nd_tbl
.parms
);
1880 out_unregister_pernet
:
1882 unregister_pernet_subsys(&ndisc_net_ops
);
1886 void ndisc_cleanup(void)
1888 unregister_netdevice_notifier(&ndisc_netdev_notifier
);
1889 #ifdef CONFIG_SYSCTL
1890 neigh_sysctl_unregister(&nd_tbl
.parms
);
1892 neigh_table_clear(&nd_tbl
);
1893 unregister_pernet_subsys(&ndisc_net_ops
);