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
);
441 * Send a Neighbour Advertisement
443 static void __ndisc_send(struct net_device
*dev
,
444 struct neighbour
*neigh
,
445 const struct in6_addr
*daddr
,
446 const struct in6_addr
*saddr
,
447 struct icmp6hdr
*icmp6h
, const struct in6_addr
*target
,
451 struct dst_entry
*dst
;
452 struct net
*net
= dev_net(dev
);
453 struct sock
*sk
= net
->ipv6
.ndisc_sk
;
455 struct icmp6hdr
*hdr
;
456 struct inet6_dev
*idev
;
461 type
= icmp6h
->icmp6_type
;
463 icmpv6_flow_init(sk
, &fl
, type
, 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_ALLOCATED_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 const struct in6_addr
*daddr
,
534 const struct in6_addr
*solicited_addr
,
535 int router
, int solicited
, int override
, int inc_opt
)
537 struct in6_addr tmpaddr
;
538 struct inet6_ifaddr
*ifp
;
539 const struct in6_addr
*src_addr
;
540 struct icmp6hdr icmp6h
= {
541 .icmp6_type
= NDISC_NEIGHBOUR_ADVERTISEMENT
,
544 /* for anycast or proxy, solicited_addr != src_addr */
545 ifp
= ipv6_get_ifaddr(dev_net(dev
), solicited_addr
, dev
, 1);
547 src_addr
= solicited_addr
;
548 if (ifp
->flags
& IFA_F_OPTIMISTIC
)
552 if (ipv6_dev_get_saddr(dev_net(dev
), dev
, daddr
,
553 inet6_sk(dev_net(dev
)->ipv6
.ndisc_sk
)->srcprefs
,
559 icmp6h
.icmp6_router
= router
;
560 icmp6h
.icmp6_solicited
= solicited
;
561 icmp6h
.icmp6_override
= override
;
563 __ndisc_send(dev
, neigh
, daddr
, src_addr
,
564 &icmp6h
, solicited_addr
,
565 inc_opt
? ND_OPT_TARGET_LL_ADDR
: 0);
568 void ndisc_send_ns(struct net_device
*dev
, struct neighbour
*neigh
,
569 const struct in6_addr
*solicit
,
570 const struct in6_addr
*daddr
, const struct in6_addr
*saddr
)
572 struct in6_addr addr_buf
;
573 struct icmp6hdr icmp6h
= {
574 .icmp6_type
= NDISC_NEIGHBOUR_SOLICITATION
,
578 if (ipv6_get_lladdr(dev
, &addr_buf
,
579 (IFA_F_TENTATIVE
|IFA_F_OPTIMISTIC
)))
584 __ndisc_send(dev
, neigh
, daddr
, saddr
,
586 !ipv6_addr_any(saddr
) ? ND_OPT_SOURCE_LL_ADDR
: 0);
589 void ndisc_send_rs(struct net_device
*dev
, const struct in6_addr
*saddr
,
590 const struct in6_addr
*daddr
)
592 struct icmp6hdr icmp6h
= {
593 .icmp6_type
= NDISC_ROUTER_SOLICITATION
,
595 int send_sllao
= dev
->addr_len
;
597 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
599 * According to section 2.2 of RFC 4429, we must not
600 * send router solicitations with a sllao from
601 * optimistic addresses, but we may send the solicitation
602 * if we don't include the sllao. So here we check
603 * if our address is optimistic, and if so, we
604 * suppress the inclusion of the sllao.
607 struct inet6_ifaddr
*ifp
= ipv6_get_ifaddr(dev_net(dev
), saddr
,
610 if (ifp
->flags
& IFA_F_OPTIMISTIC
) {
619 __ndisc_send(dev
, NULL
, daddr
, saddr
,
621 send_sllao
? ND_OPT_SOURCE_LL_ADDR
: 0);
625 static void ndisc_error_report(struct neighbour
*neigh
, struct sk_buff
*skb
)
628 * "The sender MUST return an ICMP
629 * destination unreachable"
631 dst_link_failure(skb
);
635 /* Called with locked neigh: either read or both */
637 static void ndisc_solicit(struct neighbour
*neigh
, struct sk_buff
*skb
)
639 struct in6_addr
*saddr
= NULL
;
640 struct in6_addr mcaddr
;
641 struct net_device
*dev
= neigh
->dev
;
642 struct in6_addr
*target
= (struct in6_addr
*)&neigh
->primary_key
;
643 int probes
= atomic_read(&neigh
->probes
);
645 if (skb
&& ipv6_chk_addr(dev_net(dev
), &ipv6_hdr(skb
)->saddr
, dev
, 1))
646 saddr
= &ipv6_hdr(skb
)->saddr
;
648 if ((probes
-= neigh
->parms
->ucast_probes
) < 0) {
649 if (!(neigh
->nud_state
& NUD_VALID
)) {
650 ND_PRINTK1(KERN_DEBUG
651 "%s(): trying to ucast probe in NUD_INVALID: "
656 ndisc_send_ns(dev
, neigh
, target
, target
, saddr
);
657 } else if ((probes
-= neigh
->parms
->app_probes
) < 0) {
662 addrconf_addr_solict_mult(target
, &mcaddr
);
663 ndisc_send_ns(dev
, NULL
, target
, &mcaddr
, saddr
);
667 static int pndisc_is_router(const void *pkey
,
668 struct net_device
*dev
)
670 struct pneigh_entry
*n
;
673 read_lock_bh(&nd_tbl
.lock
);
674 n
= __pneigh_lookup(&nd_tbl
, dev_net(dev
), pkey
, dev
);
676 ret
= !!(n
->flags
& NTF_ROUTER
);
677 read_unlock_bh(&nd_tbl
.lock
);
682 static void ndisc_recv_ns(struct sk_buff
*skb
)
684 struct nd_msg
*msg
= (struct nd_msg
*)skb_transport_header(skb
);
685 struct in6_addr
*saddr
= &ipv6_hdr(skb
)->saddr
;
686 struct in6_addr
*daddr
= &ipv6_hdr(skb
)->daddr
;
688 u32 ndoptlen
= skb
->tail
- (skb
->transport_header
+
689 offsetof(struct nd_msg
, opt
));
690 struct ndisc_options ndopts
;
691 struct net_device
*dev
= skb
->dev
;
692 struct inet6_ifaddr
*ifp
;
693 struct inet6_dev
*idev
= NULL
;
694 struct neighbour
*neigh
;
695 int dad
= ipv6_addr_any(saddr
);
699 if (ipv6_addr_is_multicast(&msg
->target
)) {
700 ND_PRINTK2(KERN_WARNING
701 "ICMPv6 NS: multicast target address");
707 * DAD has to be destined for solicited node multicast address.
710 !(daddr
->s6_addr32
[0] == htonl(0xff020000) &&
711 daddr
->s6_addr32
[1] == htonl(0x00000000) &&
712 daddr
->s6_addr32
[2] == htonl(0x00000001) &&
713 daddr
->s6_addr
[12] == 0xff )) {
714 ND_PRINTK2(KERN_WARNING
715 "ICMPv6 NS: bad DAD packet (wrong destination)\n");
719 if (!ndisc_parse_options(msg
->opt
, ndoptlen
, &ndopts
)) {
720 ND_PRINTK2(KERN_WARNING
721 "ICMPv6 NS: invalid ND options\n");
725 if (ndopts
.nd_opts_src_lladdr
) {
726 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_src_lladdr
, dev
);
728 ND_PRINTK2(KERN_WARNING
729 "ICMPv6 NS: invalid link-layer address length\n");
734 * If the IP source address is the unspecified address,
735 * there MUST NOT be source link-layer address option
739 ND_PRINTK2(KERN_WARNING
740 "ICMPv6 NS: bad DAD packet (link-layer address option)\n");
745 inc
= ipv6_addr_is_multicast(daddr
);
747 ifp
= ipv6_get_ifaddr(dev_net(dev
), &msg
->target
, dev
, 1);
750 if (ifp
->flags
& (IFA_F_TENTATIVE
|IFA_F_OPTIMISTIC
)) {
752 if (dev
->type
== ARPHRD_IEEE802_TR
) {
753 const unsigned char *sadr
;
754 sadr
= skb_mac_header(skb
);
755 if (((sadr
[8] ^ dev
->dev_addr
[0]) & 0x7f) == 0 &&
756 sadr
[9] == dev
->dev_addr
[1] &&
757 sadr
[10] == dev
->dev_addr
[2] &&
758 sadr
[11] == dev
->dev_addr
[3] &&
759 sadr
[12] == dev
->dev_addr
[4] &&
760 sadr
[13] == dev
->dev_addr
[5]) {
761 /* looped-back to us */
767 * We are colliding with another node
769 * so fail our DAD process
771 addrconf_dad_failure(ifp
);
775 * This is not a dad solicitation.
776 * If we are an optimistic node,
778 * Otherwise, we should ignore it.
780 if (!(ifp
->flags
& IFA_F_OPTIMISTIC
))
787 struct net
*net
= dev_net(dev
);
789 idev
= in6_dev_get(dev
);
791 /* XXX: count this drop? */
795 if (ipv6_chk_acast_addr(net
, dev
, &msg
->target
) ||
796 (idev
->cnf
.forwarding
&&
797 (net
->ipv6
.devconf_all
->proxy_ndp
|| idev
->cnf
.proxy_ndp
) &&
798 (is_router
= pndisc_is_router(&msg
->target
, dev
)) >= 0)) {
799 if (!(NEIGH_CB(skb
)->flags
& LOCALLY_ENQUEUED
) &&
800 skb
->pkt_type
!= PACKET_HOST
&&
802 idev
->nd_parms
->proxy_delay
!= 0) {
804 * for anycast or proxy,
805 * sender should delay its response
806 * by a random time between 0 and
807 * MAX_ANYCAST_DELAY_TIME seconds.
808 * (RFC2461) -- yoshfuji
810 struct sk_buff
*n
= skb_clone(skb
, GFP_ATOMIC
);
812 pneigh_enqueue(&nd_tbl
, idev
->nd_parms
, n
);
820 is_router
= !!idev
->cnf
.forwarding
;
823 ndisc_send_na(dev
, NULL
, &in6addr_linklocal_allnodes
, &msg
->target
,
824 is_router
, 0, (ifp
!= NULL
), 1);
829 NEIGH_CACHE_STAT_INC(&nd_tbl
, rcv_probes_mcast
);
831 NEIGH_CACHE_STAT_INC(&nd_tbl
, rcv_probes_ucast
);
834 * update / create cache entry
835 * for the source address
837 neigh
= __neigh_lookup(&nd_tbl
, saddr
, dev
,
838 !inc
|| lladdr
|| !dev
->addr_len
);
840 neigh_update(neigh
, lladdr
, NUD_STALE
,
841 NEIGH_UPDATE_F_WEAK_OVERRIDE
|
842 NEIGH_UPDATE_F_OVERRIDE
);
843 if (neigh
|| !dev
->header_ops
) {
844 ndisc_send_na(dev
, neigh
, saddr
, &msg
->target
,
846 1, (ifp
!= NULL
&& inc
), inc
);
848 neigh_release(neigh
);
860 static void ndisc_recv_na(struct sk_buff
*skb
)
862 struct nd_msg
*msg
= (struct nd_msg
*)skb_transport_header(skb
);
863 struct in6_addr
*saddr
= &ipv6_hdr(skb
)->saddr
;
864 struct in6_addr
*daddr
= &ipv6_hdr(skb
)->daddr
;
866 u32 ndoptlen
= skb
->tail
- (skb
->transport_header
+
867 offsetof(struct nd_msg
, opt
));
868 struct ndisc_options ndopts
;
869 struct net_device
*dev
= skb
->dev
;
870 struct inet6_ifaddr
*ifp
;
871 struct neighbour
*neigh
;
873 if (skb
->len
< sizeof(struct nd_msg
)) {
874 ND_PRINTK2(KERN_WARNING
875 "ICMPv6 NA: packet too short\n");
879 if (ipv6_addr_is_multicast(&msg
->target
)) {
880 ND_PRINTK2(KERN_WARNING
881 "ICMPv6 NA: target address is multicast.\n");
885 if (ipv6_addr_is_multicast(daddr
) &&
886 msg
->icmph
.icmp6_solicited
) {
887 ND_PRINTK2(KERN_WARNING
888 "ICMPv6 NA: solicited NA is multicasted.\n");
892 if (!ndisc_parse_options(msg
->opt
, ndoptlen
, &ndopts
)) {
893 ND_PRINTK2(KERN_WARNING
894 "ICMPv6 NS: invalid ND option\n");
897 if (ndopts
.nd_opts_tgt_lladdr
) {
898 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_tgt_lladdr
, dev
);
900 ND_PRINTK2(KERN_WARNING
901 "ICMPv6 NA: invalid link-layer address length\n");
905 ifp
= ipv6_get_ifaddr(dev_net(dev
), &msg
->target
, dev
, 1);
907 if (ifp
->flags
& IFA_F_TENTATIVE
) {
908 addrconf_dad_failure(ifp
);
911 /* What should we make now? The advertisement
912 is invalid, but ndisc specs say nothing
913 about it. It could be misconfiguration, or
914 an smart proxy agent tries to help us :-)
916 ND_PRINTK1(KERN_WARNING
917 "ICMPv6 NA: someone advertises our address on %s!\n",
918 ifp
->idev
->dev
->name
);
922 neigh
= neigh_lookup(&nd_tbl
, &msg
->target
, dev
);
925 u8 old_flags
= neigh
->flags
;
926 struct net
*net
= dev_net(dev
);
928 if (neigh
->nud_state
& NUD_FAILED
)
932 * Don't update the neighbor cache entry on a proxy NA from
933 * ourselves because either the proxied node is off link or it
934 * has already sent a NA to us.
936 if (lladdr
&& !memcmp(lladdr
, dev
->dev_addr
, dev
->addr_len
) &&
937 net
->ipv6
.devconf_all
->forwarding
&& net
->ipv6
.devconf_all
->proxy_ndp
&&
938 pneigh_lookup(&nd_tbl
, net
, &msg
->target
, dev
, 0)) {
939 /* XXX: idev->cnf.prixy_ndp */
943 neigh_update(neigh
, lladdr
,
944 msg
->icmph
.icmp6_solicited
? NUD_REACHABLE
: NUD_STALE
,
945 NEIGH_UPDATE_F_WEAK_OVERRIDE
|
946 (msg
->icmph
.icmp6_override
? NEIGH_UPDATE_F_OVERRIDE
: 0)|
947 NEIGH_UPDATE_F_OVERRIDE_ISROUTER
|
948 (msg
->icmph
.icmp6_router
? NEIGH_UPDATE_F_ISROUTER
: 0));
950 if ((old_flags
& ~neigh
->flags
) & NTF_ROUTER
) {
952 * Change: router to host
955 rt
= rt6_get_dflt_router(saddr
, dev
);
961 neigh_release(neigh
);
965 static void ndisc_recv_rs(struct sk_buff
*skb
)
967 struct rs_msg
*rs_msg
= (struct rs_msg
*)skb_transport_header(skb
);
968 unsigned long ndoptlen
= skb
->len
- sizeof(*rs_msg
);
969 struct neighbour
*neigh
;
970 struct inet6_dev
*idev
;
971 struct in6_addr
*saddr
= &ipv6_hdr(skb
)->saddr
;
972 struct ndisc_options ndopts
;
975 if (skb
->len
< sizeof(*rs_msg
))
978 idev
= in6_dev_get(skb
->dev
);
981 ND_PRINTK1("ICMP6 RS: can't find in6 device\n");
985 /* Don't accept RS if we're not in router mode */
986 if (!idev
->cnf
.forwarding
)
990 * Don't update NCE if src = ::;
991 * this implies that the source node has no ip address assigned yet.
993 if (ipv6_addr_any(saddr
))
996 /* Parse ND options */
997 if (!ndisc_parse_options(rs_msg
->opt
, ndoptlen
, &ndopts
)) {
999 ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n");
1003 if (ndopts
.nd_opts_src_lladdr
) {
1004 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_src_lladdr
,
1010 neigh
= __neigh_lookup(&nd_tbl
, saddr
, skb
->dev
, 1);
1012 neigh_update(neigh
, lladdr
, NUD_STALE
,
1013 NEIGH_UPDATE_F_WEAK_OVERRIDE
|
1014 NEIGH_UPDATE_F_OVERRIDE
|
1015 NEIGH_UPDATE_F_OVERRIDE_ISROUTER
);
1016 neigh_release(neigh
);
1022 static void ndisc_ra_useropt(struct sk_buff
*ra
, struct nd_opt_hdr
*opt
)
1024 struct icmp6hdr
*icmp6h
= (struct icmp6hdr
*)skb_transport_header(ra
);
1025 struct sk_buff
*skb
;
1026 struct nlmsghdr
*nlh
;
1027 struct nduseroptmsg
*ndmsg
;
1028 struct net
*net
= dev_net(ra
->dev
);
1030 int base_size
= NLMSG_ALIGN(sizeof(struct nduseroptmsg
)
1031 + (opt
->nd_opt_len
<< 3));
1032 size_t msg_size
= base_size
+ nla_total_size(sizeof(struct in6_addr
));
1034 skb
= nlmsg_new(msg_size
, GFP_ATOMIC
);
1040 nlh
= nlmsg_put(skb
, 0, 0, RTM_NEWNDUSEROPT
, base_size
, 0);
1042 goto nla_put_failure
;
1045 ndmsg
= nlmsg_data(nlh
);
1046 ndmsg
->nduseropt_family
= AF_INET6
;
1047 ndmsg
->nduseropt_ifindex
= ra
->dev
->ifindex
;
1048 ndmsg
->nduseropt_icmp_type
= icmp6h
->icmp6_type
;
1049 ndmsg
->nduseropt_icmp_code
= icmp6h
->icmp6_code
;
1050 ndmsg
->nduseropt_opts_len
= opt
->nd_opt_len
<< 3;
1052 memcpy(ndmsg
+ 1, opt
, opt
->nd_opt_len
<< 3);
1054 NLA_PUT(skb
, NDUSEROPT_SRCADDR
, sizeof(struct in6_addr
),
1055 &ipv6_hdr(ra
)->saddr
);
1056 nlmsg_end(skb
, nlh
);
1058 err
= rtnl_notify(skb
, net
, 0, RTNLGRP_ND_USEROPT
, NULL
,
1069 rtnl_set_sk_err(net
, RTNLGRP_ND_USEROPT
, err
);
1072 static void ndisc_router_discovery(struct sk_buff
*skb
)
1074 struct ra_msg
*ra_msg
= (struct ra_msg
*)skb_transport_header(skb
);
1075 struct neighbour
*neigh
= NULL
;
1076 struct inet6_dev
*in6_dev
;
1077 struct rt6_info
*rt
= NULL
;
1079 struct ndisc_options ndopts
;
1081 unsigned int pref
= 0;
1083 __u8
* opt
= (__u8
*)(ra_msg
+ 1);
1085 optlen
= (skb
->tail
- skb
->transport_header
) - sizeof(struct ra_msg
);
1087 if (!(ipv6_addr_type(&ipv6_hdr(skb
)->saddr
) & IPV6_ADDR_LINKLOCAL
)) {
1088 ND_PRINTK2(KERN_WARNING
1089 "ICMPv6 RA: source address is not link-local.\n");
1093 ND_PRINTK2(KERN_WARNING
1094 "ICMPv6 RA: packet too short\n");
1098 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1099 if (skb
->ndisc_nodetype
== NDISC_NODETYPE_HOST
) {
1100 ND_PRINTK2(KERN_WARNING
1101 "ICMPv6 RA: from host or unauthorized router\n");
1107 * set the RA_RECV flag in the interface
1110 in6_dev
= in6_dev_get(skb
->dev
);
1111 if (in6_dev
== NULL
) {
1113 "ICMPv6 RA: can't find inet6 device for %s.\n",
1117 if (in6_dev
->cnf
.forwarding
|| !in6_dev
->cnf
.accept_ra
) {
1118 in6_dev_put(in6_dev
);
1122 if (!ndisc_parse_options(opt
, optlen
, &ndopts
)) {
1123 in6_dev_put(in6_dev
);
1124 ND_PRINTK2(KERN_WARNING
1125 "ICMP6 RA: invalid ND options\n");
1129 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1130 /* skip link-specific parameters from interior routers */
1131 if (skb
->ndisc_nodetype
== NDISC_NODETYPE_NODEFAULT
)
1132 goto skip_linkparms
;
1135 if (in6_dev
->if_flags
& IF_RS_SENT
) {
1137 * flag that an RA was received after an RS was sent
1138 * out on this interface.
1140 in6_dev
->if_flags
|= IF_RA_RCVD
;
1144 * Remember the managed/otherconf flags from most recently
1145 * received RA message (RFC 2462) -- yoshfuji
1147 in6_dev
->if_flags
= (in6_dev
->if_flags
& ~(IF_RA_MANAGED
|
1149 (ra_msg
->icmph
.icmp6_addrconf_managed
?
1150 IF_RA_MANAGED
: 0) |
1151 (ra_msg
->icmph
.icmp6_addrconf_other
?
1152 IF_RA_OTHERCONF
: 0);
1154 if (!in6_dev
->cnf
.accept_ra_defrtr
)
1157 lifetime
= ntohs(ra_msg
->icmph
.icmp6_rt_lifetime
);
1159 #ifdef CONFIG_IPV6_ROUTER_PREF
1160 pref
= ra_msg
->icmph
.icmp6_router_pref
;
1161 /* 10b is handled as if it were 00b (medium) */
1162 if (pref
== ICMPV6_ROUTER_PREF_INVALID
||
1163 !in6_dev
->cnf
.accept_ra_rtr_pref
)
1164 pref
= ICMPV6_ROUTER_PREF_MEDIUM
;
1167 rt
= rt6_get_dflt_router(&ipv6_hdr(skb
)->saddr
, skb
->dev
);
1170 neigh
= rt
->rt6i_nexthop
;
1172 if (rt
&& lifetime
== 0) {
1178 if (rt
== NULL
&& lifetime
) {
1179 ND_PRINTK3(KERN_DEBUG
1180 "ICMPv6 RA: adding default router.\n");
1182 rt
= rt6_add_dflt_router(&ipv6_hdr(skb
)->saddr
, skb
->dev
, pref
);
1185 "ICMPv6 RA: %s() failed to add default route.\n",
1187 in6_dev_put(in6_dev
);
1191 neigh
= rt
->rt6i_nexthop
;
1192 if (neigh
== NULL
) {
1194 "ICMPv6 RA: %s() got default router without neighbour.\n",
1196 dst_release(&rt
->u
.dst
);
1197 in6_dev_put(in6_dev
);
1200 neigh
->flags
|= NTF_ROUTER
;
1202 rt
->rt6i_flags
|= (rt
->rt6i_flags
& ~RTF_PREF_MASK
) | RTF_PREF(pref
);
1206 rt
->rt6i_expires
= jiffies
+ (HZ
* lifetime
);
1208 if (ra_msg
->icmph
.icmp6_hop_limit
) {
1209 in6_dev
->cnf
.hop_limit
= ra_msg
->icmph
.icmp6_hop_limit
;
1211 rt
->u
.dst
.metrics
[RTAX_HOPLIMIT
-1] = ra_msg
->icmph
.icmp6_hop_limit
;
1217 * Update Reachable Time and Retrans Timer
1220 if (in6_dev
->nd_parms
) {
1221 unsigned long rtime
= ntohl(ra_msg
->retrans_timer
);
1223 if (rtime
&& rtime
/1000 < MAX_SCHEDULE_TIMEOUT
/HZ
) {
1224 rtime
= (rtime
*HZ
)/1000;
1227 in6_dev
->nd_parms
->retrans_time
= rtime
;
1228 in6_dev
->tstamp
= jiffies
;
1229 inet6_ifinfo_notify(RTM_NEWLINK
, in6_dev
);
1232 rtime
= ntohl(ra_msg
->reachable_time
);
1233 if (rtime
&& rtime
/1000 < MAX_SCHEDULE_TIMEOUT
/(3*HZ
)) {
1234 rtime
= (rtime
*HZ
)/1000;
1239 if (rtime
!= in6_dev
->nd_parms
->base_reachable_time
) {
1240 in6_dev
->nd_parms
->base_reachable_time
= rtime
;
1241 in6_dev
->nd_parms
->gc_staletime
= 3 * rtime
;
1242 in6_dev
->nd_parms
->reachable_time
= neigh_rand_reach_time(rtime
);
1243 in6_dev
->tstamp
= jiffies
;
1244 inet6_ifinfo_notify(RTM_NEWLINK
, in6_dev
);
1249 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1258 neigh
= __neigh_lookup(&nd_tbl
, &ipv6_hdr(skb
)->saddr
,
1262 if (ndopts
.nd_opts_src_lladdr
) {
1263 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_src_lladdr
,
1266 ND_PRINTK2(KERN_WARNING
1267 "ICMPv6 RA: invalid link-layer address length\n");
1271 neigh_update(neigh
, lladdr
, NUD_STALE
,
1272 NEIGH_UPDATE_F_WEAK_OVERRIDE
|
1273 NEIGH_UPDATE_F_OVERRIDE
|
1274 NEIGH_UPDATE_F_OVERRIDE_ISROUTER
|
1275 NEIGH_UPDATE_F_ISROUTER
);
1278 #ifdef CONFIG_IPV6_ROUTE_INFO
1279 if (in6_dev
->cnf
.accept_ra_rtr_pref
&& ndopts
.nd_opts_ri
) {
1280 struct nd_opt_hdr
*p
;
1281 for (p
= ndopts
.nd_opts_ri
;
1283 p
= ndisc_next_option(p
, ndopts
.nd_opts_ri_end
)) {
1284 struct route_info
*ri
= (struct route_info
*)p
;
1285 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1286 if (skb
->ndisc_nodetype
== NDISC_NODETYPE_NODEFAULT
&&
1287 ri
->prefix_len
== 0)
1290 if (ri
->prefix_len
> in6_dev
->cnf
.accept_ra_rt_info_max_plen
)
1292 rt6_route_rcv(skb
->dev
, (u8
*)p
, (p
->nd_opt_len
) << 3,
1293 &ipv6_hdr(skb
)->saddr
);
1298 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1299 /* skip link-specific ndopts from interior routers */
1300 if (skb
->ndisc_nodetype
== NDISC_NODETYPE_NODEFAULT
)
1304 if (in6_dev
->cnf
.accept_ra_pinfo
&& ndopts
.nd_opts_pi
) {
1305 struct nd_opt_hdr
*p
;
1306 for (p
= ndopts
.nd_opts_pi
;
1308 p
= ndisc_next_option(p
, ndopts
.nd_opts_pi_end
)) {
1309 addrconf_prefix_rcv(skb
->dev
, (u8
*)p
, (p
->nd_opt_len
) << 3);
1313 if (ndopts
.nd_opts_mtu
) {
1317 memcpy(&n
, ((u8
*)(ndopts
.nd_opts_mtu
+1))+2, sizeof(mtu
));
1320 if (mtu
< IPV6_MIN_MTU
|| mtu
> skb
->dev
->mtu
) {
1321 ND_PRINTK2(KERN_WARNING
1322 "ICMPv6 RA: invalid mtu: %d\n",
1324 } else if (in6_dev
->cnf
.mtu6
!= mtu
) {
1325 in6_dev
->cnf
.mtu6
= mtu
;
1328 rt
->u
.dst
.metrics
[RTAX_MTU
-1] = mtu
;
1330 rt6_mtu_change(skb
->dev
, mtu
);
1334 if (ndopts
.nd_useropts
) {
1335 struct nd_opt_hdr
*p
;
1336 for (p
= ndopts
.nd_useropts
;
1338 p
= ndisc_next_useropt(p
, ndopts
.nd_useropts_end
)) {
1339 ndisc_ra_useropt(skb
, p
);
1343 if (ndopts
.nd_opts_tgt_lladdr
|| ndopts
.nd_opts_rh
) {
1344 ND_PRINTK2(KERN_WARNING
1345 "ICMPv6 RA: invalid RA options");
1349 dst_release(&rt
->u
.dst
);
1351 neigh_release(neigh
);
1352 in6_dev_put(in6_dev
);
1355 static void ndisc_redirect_rcv(struct sk_buff
*skb
)
1357 struct inet6_dev
*in6_dev
;
1358 struct icmp6hdr
*icmph
;
1359 struct in6_addr
*dest
;
1360 struct in6_addr
*target
; /* new first hop to destination */
1361 struct neighbour
*neigh
;
1363 struct ndisc_options ndopts
;
1367 #ifdef CONFIG_IPV6_NDISC_NODETYPE
1368 switch (skb
->ndisc_nodetype
) {
1369 case NDISC_NODETYPE_HOST
:
1370 case NDISC_NODETYPE_NODEFAULT
:
1371 ND_PRINTK2(KERN_WARNING
1372 "ICMPv6 Redirect: from host or unauthorized router\n");
1377 if (!(ipv6_addr_type(&ipv6_hdr(skb
)->saddr
) & IPV6_ADDR_LINKLOCAL
)) {
1378 ND_PRINTK2(KERN_WARNING
1379 "ICMPv6 Redirect: source address is not link-local.\n");
1383 optlen
= skb
->tail
- skb
->transport_header
;
1384 optlen
-= sizeof(struct icmp6hdr
) + 2 * sizeof(struct in6_addr
);
1387 ND_PRINTK2(KERN_WARNING
1388 "ICMPv6 Redirect: packet too short\n");
1392 icmph
= icmp6_hdr(skb
);
1393 target
= (struct in6_addr
*) (icmph
+ 1);
1396 if (ipv6_addr_is_multicast(dest
)) {
1397 ND_PRINTK2(KERN_WARNING
1398 "ICMPv6 Redirect: destination address is multicast.\n");
1402 if (ipv6_addr_equal(dest
, target
)) {
1404 } else if (ipv6_addr_type(target
) !=
1405 (IPV6_ADDR_UNICAST
|IPV6_ADDR_LINKLOCAL
)) {
1406 ND_PRINTK2(KERN_WARNING
1407 "ICMPv6 Redirect: target address is not link-local unicast.\n");
1411 in6_dev
= in6_dev_get(skb
->dev
);
1414 if (in6_dev
->cnf
.forwarding
|| !in6_dev
->cnf
.accept_redirects
) {
1415 in6_dev_put(in6_dev
);
1420 * The IP source address of the Redirect MUST be the same as the current
1421 * first-hop router for the specified ICMP Destination Address.
1424 if (!ndisc_parse_options((u8
*)(dest
+ 1), optlen
, &ndopts
)) {
1425 ND_PRINTK2(KERN_WARNING
1426 "ICMPv6 Redirect: invalid ND options\n");
1427 in6_dev_put(in6_dev
);
1430 if (ndopts
.nd_opts_tgt_lladdr
) {
1431 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_tgt_lladdr
,
1434 ND_PRINTK2(KERN_WARNING
1435 "ICMPv6 Redirect: invalid link-layer address length\n");
1436 in6_dev_put(in6_dev
);
1441 neigh
= __neigh_lookup(&nd_tbl
, target
, skb
->dev
, 1);
1443 rt6_redirect(dest
, &ipv6_hdr(skb
)->daddr
,
1444 &ipv6_hdr(skb
)->saddr
, neigh
, lladdr
,
1446 neigh_release(neigh
);
1448 in6_dev_put(in6_dev
);
1451 void ndisc_send_redirect(struct sk_buff
*skb
, struct neighbour
*neigh
,
1452 const struct in6_addr
*target
)
1454 struct net_device
*dev
= skb
->dev
;
1455 struct net
*net
= dev_net(dev
);
1456 struct sock
*sk
= net
->ipv6
.ndisc_sk
;
1457 int len
= sizeof(struct icmp6hdr
) + 2 * sizeof(struct in6_addr
);
1458 struct sk_buff
*buff
;
1459 struct icmp6hdr
*icmph
;
1460 struct in6_addr saddr_buf
;
1461 struct in6_addr
*addrp
;
1462 struct rt6_info
*rt
;
1463 struct dst_entry
*dst
;
1464 struct inet6_dev
*idev
;
1469 u8 ha_buf
[MAX_ADDR_LEN
], *ha
= NULL
;
1471 if (ipv6_get_lladdr(dev
, &saddr_buf
, IFA_F_TENTATIVE
)) {
1472 ND_PRINTK2(KERN_WARNING
1473 "ICMPv6 Redirect: no link-local address on %s\n",
1478 if (!ipv6_addr_equal(&ipv6_hdr(skb
)->daddr
, target
) &&
1479 ipv6_addr_type(target
) != (IPV6_ADDR_UNICAST
|IPV6_ADDR_LINKLOCAL
)) {
1480 ND_PRINTK2(KERN_WARNING
1481 "ICMPv6 Redirect: target address is not link-local unicast.\n");
1485 icmpv6_flow_init(sk
, &fl
, NDISC_REDIRECT
,
1486 &saddr_buf
, &ipv6_hdr(skb
)->saddr
, dev
->ifindex
);
1488 dst
= ip6_route_output(net
, NULL
, &fl
);
1492 err
= xfrm_lookup(&dst
, &fl
, NULL
, 0);
1496 rt
= (struct rt6_info
*) dst
;
1498 if (rt
->rt6i_flags
& RTF_GATEWAY
) {
1499 ND_PRINTK2(KERN_WARNING
1500 "ICMPv6 Redirect: destination is not a neighbour.\n");
1504 if (!xrlim_allow(dst
, 1*HZ
)) {
1509 if (dev
->addr_len
) {
1510 read_lock_bh(&neigh
->lock
);
1511 if (neigh
->nud_state
& NUD_VALID
) {
1512 memcpy(ha_buf
, neigh
->ha
, dev
->addr_len
);
1513 read_unlock_bh(&neigh
->lock
);
1515 len
+= ndisc_opt_addr_space(dev
);
1517 read_unlock_bh(&neigh
->lock
);
1520 rd_len
= min_t(unsigned int,
1521 IPV6_MIN_MTU
-sizeof(struct ipv6hdr
)-len
, skb
->len
+ 8);
1525 buff
= sock_alloc_send_skb(sk
,
1526 (MAX_HEADER
+ sizeof(struct ipv6hdr
) +
1527 len
+ LL_ALLOCATED_SPACE(dev
)),
1531 "ICMPv6 Redirect: %s() failed to allocate an skb.\n",
1537 skb_reserve(buff
, LL_RESERVED_SPACE(dev
));
1538 ip6_nd_hdr(sk
, buff
, dev
, &saddr_buf
, &ipv6_hdr(skb
)->saddr
,
1539 IPPROTO_ICMPV6
, len
);
1541 skb_set_transport_header(buff
, skb_tail_pointer(buff
) - buff
->data
);
1543 icmph
= icmp6_hdr(buff
);
1545 memset(icmph
, 0, sizeof(struct icmp6hdr
));
1546 icmph
->icmp6_type
= NDISC_REDIRECT
;
1549 * copy target and destination addresses
1552 addrp
= (struct in6_addr
*)(icmph
+ 1);
1553 ipv6_addr_copy(addrp
, target
);
1555 ipv6_addr_copy(addrp
, &ipv6_hdr(skb
)->daddr
);
1557 opt
= (u8
*) (addrp
+ 1);
1560 * include target_address option
1564 opt
= ndisc_fill_addr_option(opt
, ND_OPT_TARGET_LL_ADDR
, ha
,
1565 dev
->addr_len
, dev
->type
);
1568 * build redirect option and copy skb over to the new packet.
1572 *(opt
++) = ND_OPT_REDIRECT_HDR
;
1573 *(opt
++) = (rd_len
>> 3);
1576 memcpy(opt
, ipv6_hdr(skb
), rd_len
- 8);
1578 icmph
->icmp6_cksum
= csum_ipv6_magic(&saddr_buf
, &ipv6_hdr(skb
)->saddr
,
1579 len
, IPPROTO_ICMPV6
,
1580 csum_partial((u8
*) icmph
, len
, 0));
1583 idev
= in6_dev_get(dst
->dev
);
1584 IP6_INC_STATS(idev
, IPSTATS_MIB_OUTREQUESTS
);
1585 err
= NF_HOOK(PF_INET6
, NF_INET_LOCAL_OUT
, buff
, NULL
, dst
->dev
,
1588 ICMP6MSGOUT_INC_STATS(idev
, NDISC_REDIRECT
);
1589 ICMP6_INC_STATS(idev
, ICMP6_MIB_OUTMSGS
);
1592 if (likely(idev
!= NULL
))
1596 static void pndisc_redo(struct sk_buff
*skb
)
1602 int ndisc_rcv(struct sk_buff
*skb
)
1606 if (!pskb_may_pull(skb
, skb
->len
))
1609 msg
= (struct nd_msg
*)skb_transport_header(skb
);
1611 __skb_push(skb
, skb
->data
- skb_transport_header(skb
));
1613 if (ipv6_hdr(skb
)->hop_limit
!= 255) {
1614 ND_PRINTK2(KERN_WARNING
1615 "ICMPv6 NDISC: invalid hop-limit: %d\n",
1616 ipv6_hdr(skb
)->hop_limit
);
1620 if (msg
->icmph
.icmp6_code
!= 0) {
1621 ND_PRINTK2(KERN_WARNING
1622 "ICMPv6 NDISC: invalid ICMPv6 code: %d\n",
1623 msg
->icmph
.icmp6_code
);
1627 memset(NEIGH_CB(skb
), 0, sizeof(struct neighbour_cb
));
1629 switch (msg
->icmph
.icmp6_type
) {
1630 case NDISC_NEIGHBOUR_SOLICITATION
:
1634 case NDISC_NEIGHBOUR_ADVERTISEMENT
:
1638 case NDISC_ROUTER_SOLICITATION
:
1642 case NDISC_ROUTER_ADVERTISEMENT
:
1643 ndisc_router_discovery(skb
);
1646 case NDISC_REDIRECT
:
1647 ndisc_redirect_rcv(skb
);
1654 static int ndisc_netdev_event(struct notifier_block
*this, unsigned long event
, void *ptr
)
1656 struct net_device
*dev
= ptr
;
1657 struct net
*net
= dev_net(dev
);
1660 case NETDEV_CHANGEADDR
:
1661 neigh_changeaddr(&nd_tbl
, dev
);
1662 fib6_run_gc(~0UL, net
);
1665 neigh_ifdown(&nd_tbl
, dev
);
1666 fib6_run_gc(~0UL, net
);
1675 static struct notifier_block ndisc_netdev_notifier
= {
1676 .notifier_call
= ndisc_netdev_event
,
1679 #ifdef CONFIG_SYSCTL
1680 static void ndisc_warn_deprecated_sysctl(struct ctl_table
*ctl
,
1681 const char *func
, const char *dev_name
)
1683 static char warncomm
[TASK_COMM_LEN
];
1685 if (strcmp(warncomm
, current
->comm
) && warned
< 5) {
1686 strcpy(warncomm
, current
->comm
);
1688 "process `%s' is using deprecated sysctl (%s) "
1689 "net.ipv6.neigh.%s.%s; "
1690 "Use net.ipv6.neigh.%s.%s_ms "
1693 dev_name
, ctl
->procname
,
1694 dev_name
, ctl
->procname
);
1699 int ndisc_ifinfo_sysctl_change(struct ctl_table
*ctl
, int write
, struct file
* filp
, void __user
*buffer
, size_t *lenp
, loff_t
*ppos
)
1701 struct net_device
*dev
= ctl
->extra1
;
1702 struct inet6_dev
*idev
;
1705 if ((strcmp(ctl
->procname
, "retrans_time") == 0) ||
1706 (strcmp(ctl
->procname
, "base_reachable_time") == 0))
1707 ndisc_warn_deprecated_sysctl(ctl
, "syscall", dev
? dev
->name
: "default");
1709 if (strcmp(ctl
->procname
, "retrans_time") == 0)
1710 ret
= proc_dointvec(ctl
, write
, filp
, buffer
, lenp
, ppos
);
1712 else if (strcmp(ctl
->procname
, "base_reachable_time") == 0)
1713 ret
= proc_dointvec_jiffies(ctl
, write
,
1714 filp
, buffer
, lenp
, ppos
);
1716 else if ((strcmp(ctl
->procname
, "retrans_time_ms") == 0) ||
1717 (strcmp(ctl
->procname
, "base_reachable_time_ms") == 0))
1718 ret
= proc_dointvec_ms_jiffies(ctl
, write
,
1719 filp
, buffer
, lenp
, ppos
);
1723 if (write
&& ret
== 0 && dev
&& (idev
= in6_dev_get(dev
)) != NULL
) {
1724 if (ctl
->data
== &idev
->nd_parms
->base_reachable_time
)
1725 idev
->nd_parms
->reachable_time
= neigh_rand_reach_time(idev
->nd_parms
->base_reachable_time
);
1726 idev
->tstamp
= jiffies
;
1727 inet6_ifinfo_notify(RTM_NEWLINK
, idev
);
1733 int ndisc_ifinfo_sysctl_strategy(ctl_table
*ctl
, int __user
*name
,
1734 int nlen
, void __user
*oldval
,
1735 size_t __user
*oldlenp
,
1736 void __user
*newval
, size_t newlen
)
1738 struct net_device
*dev
= ctl
->extra1
;
1739 struct inet6_dev
*idev
;
1742 if (ctl
->ctl_name
== NET_NEIGH_RETRANS_TIME
||
1743 ctl
->ctl_name
== NET_NEIGH_REACHABLE_TIME
)
1744 ndisc_warn_deprecated_sysctl(ctl
, "procfs", dev
? dev
->name
: "default");
1746 switch (ctl
->ctl_name
) {
1747 case NET_NEIGH_REACHABLE_TIME
:
1748 ret
= sysctl_jiffies(ctl
, name
, nlen
,
1749 oldval
, oldlenp
, newval
, newlen
);
1751 case NET_NEIGH_RETRANS_TIME_MS
:
1752 case NET_NEIGH_REACHABLE_TIME_MS
:
1753 ret
= sysctl_ms_jiffies(ctl
, name
, nlen
,
1754 oldval
, oldlenp
, newval
, newlen
);
1760 if (newval
&& newlen
&& ret
> 0 &&
1761 dev
&& (idev
= in6_dev_get(dev
)) != NULL
) {
1762 if (ctl
->ctl_name
== NET_NEIGH_REACHABLE_TIME
||
1763 ctl
->ctl_name
== NET_NEIGH_REACHABLE_TIME_MS
)
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
);
1775 static int ndisc_net_init(struct net
*net
)
1777 struct ipv6_pinfo
*np
;
1781 err
= inet_ctl_sock_create(&sk
, PF_INET6
,
1782 SOCK_RAW
, IPPROTO_ICMPV6
, net
);
1785 "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",
1790 net
->ipv6
.ndisc_sk
= sk
;
1793 np
->hop_limit
= 255;
1794 /* Do not loopback ndisc messages */
1800 static void ndisc_net_exit(struct net
*net
)
1802 inet_ctl_sock_destroy(net
->ipv6
.ndisc_sk
);
1805 static struct pernet_operations ndisc_net_ops
= {
1806 .init
= ndisc_net_init
,
1807 .exit
= ndisc_net_exit
,
1810 int __init
ndisc_init(void)
1814 err
= register_pernet_subsys(&ndisc_net_ops
);
1818 * Initialize the neighbour table
1820 neigh_table_init(&nd_tbl
);
1822 #ifdef CONFIG_SYSCTL
1823 err
= neigh_sysctl_register(NULL
, &nd_tbl
.parms
, NET_IPV6
,
1824 NET_IPV6_NEIGH
, "ipv6",
1825 &ndisc_ifinfo_sysctl_change
,
1826 &ndisc_ifinfo_sysctl_strategy
);
1828 goto out_unregister_pernet
;
1830 err
= register_netdevice_notifier(&ndisc_netdev_notifier
);
1832 goto out_unregister_sysctl
;
1836 out_unregister_sysctl
:
1837 #ifdef CONFIG_SYSCTL
1838 neigh_sysctl_unregister(&nd_tbl
.parms
);
1839 out_unregister_pernet
:
1841 unregister_pernet_subsys(&ndisc_net_ops
);
1845 void ndisc_cleanup(void)
1847 unregister_netdevice_notifier(&ndisc_netdev_notifier
);
1848 #ifdef CONFIG_SYSCTL
1849 neigh_sysctl_unregister(&nd_tbl
.parms
);
1851 neigh_table_clear(&nd_tbl
);
1852 unregister_pernet_subsys(&ndisc_net_ops
);