2 * Neighbour Discovery for IPv6
3 * Linux INET6 implementation
6 * Pedro Roque <roque@di.fc.ul.pt>
7 * Mike Shaver <shaver@ingenia.com>
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version
12 * 2 of the License, or (at your option) any later version.
18 * Lars Fenneberg : fixed MTU setting on receipt
21 * Janos Farkas : kmalloc failure checks
22 * Alexey Kuznetsov : state machine reworked
23 * and moved to net/core.
24 * Pekka Savola : RFC2461 validation
25 * YOSHIFUJI Hideaki @USAGI : Verify ND options properly
28 /* Set to 3 to get tracing... */
31 #define ND_PRINTK(fmt, args...) do { if (net_ratelimit()) { printk(fmt, ## args); } } while(0)
32 #define ND_NOPRINTK(x...) do { ; } while(0)
33 #define ND_PRINTK0 ND_PRINTK
34 #define ND_PRINTK1 ND_NOPRINTK
35 #define ND_PRINTK2 ND_NOPRINTK
36 #define ND_PRINTK3 ND_NOPRINTK
39 #define ND_PRINTK1 ND_PRINTK
43 #define ND_PRINTK2 ND_PRINTK
47 #define ND_PRINTK3 ND_PRINTK
50 #include <linux/module.h>
51 #include <linux/errno.h>
52 #include <linux/types.h>
53 #include <linux/socket.h>
54 #include <linux/sockios.h>
55 #include <linux/sched.h>
56 #include <linux/net.h>
57 #include <linux/in6.h>
58 #include <linux/route.h>
59 #include <linux/init.h>
60 #include <linux/rcupdate.h>
62 #include <linux/sysctl.h>
65 #include <linux/if_addr.h>
66 #include <linux/if_arp.h>
67 #include <linux/ipv6.h>
68 #include <linux/icmpv6.h>
69 #include <linux/jhash.h>
75 #include <net/protocol.h>
76 #include <net/ndisc.h>
77 #include <net/ip6_route.h>
78 #include <net/addrconf.h>
82 #include <net/ip6_checksum.h>
83 #include <linux/proc_fs.h>
85 #include <linux/netfilter.h>
86 #include <linux/netfilter_ipv6.h>
88 static struct socket
*ndisc_socket
;
90 static u32
ndisc_hash(const void *pkey
, const struct net_device
*dev
);
91 static int ndisc_constructor(struct neighbour
*neigh
);
92 static void ndisc_solicit(struct neighbour
*neigh
, struct sk_buff
*skb
);
93 static void ndisc_error_report(struct neighbour
*neigh
, struct sk_buff
*skb
);
94 static int pndisc_constructor(struct pneigh_entry
*n
);
95 static void pndisc_destructor(struct pneigh_entry
*n
);
96 static void pndisc_redo(struct sk_buff
*skb
);
98 static struct neigh_ops ndisc_generic_ops
= {
100 .solicit
= ndisc_solicit
,
101 .error_report
= ndisc_error_report
,
102 .output
= neigh_resolve_output
,
103 .connected_output
= neigh_connected_output
,
104 .hh_output
= dev_queue_xmit
,
105 .queue_xmit
= dev_queue_xmit
,
108 static struct neigh_ops ndisc_hh_ops
= {
110 .solicit
= ndisc_solicit
,
111 .error_report
= ndisc_error_report
,
112 .output
= neigh_resolve_output
,
113 .connected_output
= neigh_resolve_output
,
114 .hh_output
= dev_queue_xmit
,
115 .queue_xmit
= dev_queue_xmit
,
119 static struct neigh_ops ndisc_direct_ops
= {
121 .output
= dev_queue_xmit
,
122 .connected_output
= dev_queue_xmit
,
123 .hh_output
= dev_queue_xmit
,
124 .queue_xmit
= dev_queue_xmit
,
127 struct neigh_table nd_tbl
= {
129 .entry_size
= sizeof(struct neighbour
) + sizeof(struct in6_addr
),
130 .key_len
= sizeof(struct in6_addr
),
132 .constructor
= ndisc_constructor
,
133 .pconstructor
= pndisc_constructor
,
134 .pdestructor
= pndisc_destructor
,
135 .proxy_redo
= pndisc_redo
,
139 .base_reachable_time
= 30 * HZ
,
140 .retrans_time
= 1 * HZ
,
141 .gc_staletime
= 60 * HZ
,
142 .reachable_time
= 30 * HZ
,
143 .delay_probe_time
= 5 * HZ
,
147 .anycast_delay
= 1 * HZ
,
148 .proxy_delay
= (8 * HZ
) / 10,
151 .gc_interval
= 30 * HZ
,
158 struct ndisc_options
{
159 struct nd_opt_hdr
*nd_opt_array
[__ND_OPT_ARRAY_MAX
];
160 #ifdef CONFIG_IPV6_ROUTE_INFO
161 struct nd_opt_hdr
*nd_opts_ri
;
162 struct nd_opt_hdr
*nd_opts_ri_end
;
166 #define nd_opts_src_lladdr nd_opt_array[ND_OPT_SOURCE_LL_ADDR]
167 #define nd_opts_tgt_lladdr nd_opt_array[ND_OPT_TARGET_LL_ADDR]
168 #define nd_opts_pi nd_opt_array[ND_OPT_PREFIX_INFO]
169 #define nd_opts_pi_end nd_opt_array[__ND_OPT_PREFIX_INFO_END]
170 #define nd_opts_rh nd_opt_array[ND_OPT_REDIRECT_HDR]
171 #define nd_opts_mtu nd_opt_array[ND_OPT_MTU]
173 #define NDISC_OPT_SPACE(len) (((len)+2+7)&~7)
176 * Return the padding between the option length and the start of the
177 * link addr. Currently only IP-over-InfiniBand needs this, although
178 * if RFC 3831 IPv6-over-Fibre Channel is ever implemented it may
179 * also need a pad of 2.
181 static int ndisc_addr_option_pad(unsigned short type
)
184 case ARPHRD_INFINIBAND
: return 2;
189 static inline int ndisc_opt_addr_space(struct net_device
*dev
)
191 return NDISC_OPT_SPACE(dev
->addr_len
+ ndisc_addr_option_pad(dev
->type
));
194 static u8
*ndisc_fill_addr_option(u8
*opt
, int type
, void *data
, int data_len
,
195 unsigned short addr_type
)
197 int space
= NDISC_OPT_SPACE(data_len
);
198 int pad
= ndisc_addr_option_pad(addr_type
);
203 memset(opt
+ 2, 0, pad
);
207 memcpy(opt
+2, data
, data_len
);
210 if ((space
-= data_len
) > 0)
211 memset(opt
, 0, space
);
215 static struct nd_opt_hdr
*ndisc_next_option(struct nd_opt_hdr
*cur
,
216 struct nd_opt_hdr
*end
)
219 if (!cur
|| !end
|| cur
>= end
)
221 type
= cur
->nd_opt_type
;
223 cur
= ((void *)cur
) + (cur
->nd_opt_len
<< 3);
224 } while(cur
< end
&& cur
->nd_opt_type
!= type
);
225 return (cur
<= end
&& cur
->nd_opt_type
== type
? cur
: NULL
);
228 static struct ndisc_options
*ndisc_parse_options(u8
*opt
, int opt_len
,
229 struct ndisc_options
*ndopts
)
231 struct nd_opt_hdr
*nd_opt
= (struct nd_opt_hdr
*)opt
;
233 if (!nd_opt
|| opt_len
< 0 || !ndopts
)
235 memset(ndopts
, 0, sizeof(*ndopts
));
238 if (opt_len
< sizeof(struct nd_opt_hdr
))
240 l
= nd_opt
->nd_opt_len
<< 3;
241 if (opt_len
< l
|| l
== 0)
243 switch (nd_opt
->nd_opt_type
) {
244 case ND_OPT_SOURCE_LL_ADDR
:
245 case ND_OPT_TARGET_LL_ADDR
:
247 case ND_OPT_REDIRECT_HDR
:
248 if (ndopts
->nd_opt_array
[nd_opt
->nd_opt_type
]) {
249 ND_PRINTK2(KERN_WARNING
250 "%s(): duplicated ND6 option found: type=%d\n",
252 nd_opt
->nd_opt_type
);
254 ndopts
->nd_opt_array
[nd_opt
->nd_opt_type
] = nd_opt
;
257 case ND_OPT_PREFIX_INFO
:
258 ndopts
->nd_opts_pi_end
= nd_opt
;
259 if (ndopts
->nd_opt_array
[nd_opt
->nd_opt_type
] == 0)
260 ndopts
->nd_opt_array
[nd_opt
->nd_opt_type
] = nd_opt
;
262 #ifdef CONFIG_IPV6_ROUTE_INFO
263 case ND_OPT_ROUTE_INFO
:
264 ndopts
->nd_opts_ri_end
= nd_opt
;
265 if (!ndopts
->nd_opts_ri
)
266 ndopts
->nd_opts_ri
= nd_opt
;
271 * Unknown options must be silently ignored,
272 * to accommodate future extension to the protocol.
274 ND_PRINTK2(KERN_NOTICE
275 "%s(): ignored unsupported option; type=%d, len=%d\n",
277 nd_opt
->nd_opt_type
, nd_opt
->nd_opt_len
);
280 nd_opt
= ((void *)nd_opt
) + l
;
285 static inline u8
*ndisc_opt_addr_data(struct nd_opt_hdr
*p
,
286 struct net_device
*dev
)
288 u8
*lladdr
= (u8
*)(p
+ 1);
289 int lladdrlen
= p
->nd_opt_len
<< 3;
290 int prepad
= ndisc_addr_option_pad(dev
->type
);
291 if (lladdrlen
!= NDISC_OPT_SPACE(dev
->addr_len
+ prepad
))
293 return (lladdr
+ prepad
);
296 int ndisc_mc_map(struct in6_addr
*addr
, char *buf
, struct net_device
*dev
, int dir
)
300 case ARPHRD_IEEE802
: /* Not sure. Check it later. --ANK */
302 ipv6_eth_mc_map(addr
, buf
);
304 case ARPHRD_IEEE802_TR
:
305 ipv6_tr_mc_map(addr
,buf
);
308 ipv6_arcnet_mc_map(addr
, buf
);
310 case ARPHRD_INFINIBAND
:
311 ipv6_ib_mc_map(addr
, buf
);
315 memcpy(buf
, dev
->broadcast
, dev
->addr_len
);
322 EXPORT_SYMBOL(ndisc_mc_map
);
324 static u32
ndisc_hash(const void *pkey
, const struct net_device
*dev
)
326 const u32
*p32
= pkey
;
330 for (i
= 0; i
< (sizeof(struct in6_addr
) / sizeof(u32
)); i
++)
333 return jhash_2words(addr_hash
, dev
->ifindex
, nd_tbl
.hash_rnd
);
336 static int ndisc_constructor(struct neighbour
*neigh
)
338 struct in6_addr
*addr
= (struct in6_addr
*)&neigh
->primary_key
;
339 struct net_device
*dev
= neigh
->dev
;
340 struct inet6_dev
*in6_dev
;
341 struct neigh_parms
*parms
;
342 int is_multicast
= ipv6_addr_is_multicast(addr
);
345 in6_dev
= in6_dev_get(dev
);
346 if (in6_dev
== NULL
) {
351 parms
= in6_dev
->nd_parms
;
352 __neigh_parms_put(neigh
->parms
);
353 neigh
->parms
= neigh_parms_clone(parms
);
356 neigh
->type
= is_multicast
? RTN_MULTICAST
: RTN_UNICAST
;
357 if (dev
->hard_header
== NULL
) {
358 neigh
->nud_state
= NUD_NOARP
;
359 neigh
->ops
= &ndisc_direct_ops
;
360 neigh
->output
= neigh
->ops
->queue_xmit
;
363 neigh
->nud_state
= NUD_NOARP
;
364 ndisc_mc_map(addr
, neigh
->ha
, dev
, 1);
365 } else if (dev
->flags
&(IFF_NOARP
|IFF_LOOPBACK
)) {
366 neigh
->nud_state
= NUD_NOARP
;
367 memcpy(neigh
->ha
, dev
->dev_addr
, dev
->addr_len
);
368 if (dev
->flags
&IFF_LOOPBACK
)
369 neigh
->type
= RTN_LOCAL
;
370 } else if (dev
->flags
&IFF_POINTOPOINT
) {
371 neigh
->nud_state
= NUD_NOARP
;
372 memcpy(neigh
->ha
, dev
->broadcast
, dev
->addr_len
);
374 if (dev
->hard_header_cache
)
375 neigh
->ops
= &ndisc_hh_ops
;
377 neigh
->ops
= &ndisc_generic_ops
;
378 if (neigh
->nud_state
&NUD_VALID
)
379 neigh
->output
= neigh
->ops
->connected_output
;
381 neigh
->output
= neigh
->ops
->output
;
383 in6_dev_put(in6_dev
);
387 static int pndisc_constructor(struct pneigh_entry
*n
)
389 struct in6_addr
*addr
= (struct in6_addr
*)&n
->key
;
390 struct in6_addr maddr
;
391 struct net_device
*dev
= n
->dev
;
393 if (dev
== NULL
|| __in6_dev_get(dev
) == NULL
)
395 addrconf_addr_solict_mult(addr
, &maddr
);
396 ipv6_dev_mc_inc(dev
, &maddr
);
400 static void pndisc_destructor(struct pneigh_entry
*n
)
402 struct in6_addr
*addr
= (struct in6_addr
*)&n
->key
;
403 struct in6_addr maddr
;
404 struct net_device
*dev
= n
->dev
;
406 if (dev
== NULL
|| __in6_dev_get(dev
) == NULL
)
408 addrconf_addr_solict_mult(addr
, &maddr
);
409 ipv6_dev_mc_dec(dev
, &maddr
);
413 * Send a Neighbour Advertisement
416 static inline void ndisc_flow_init(struct flowi
*fl
, u8 type
,
417 struct in6_addr
*saddr
, struct in6_addr
*daddr
,
420 memset(fl
, 0, sizeof(*fl
));
421 ipv6_addr_copy(&fl
->fl6_src
, saddr
);
422 ipv6_addr_copy(&fl
->fl6_dst
, daddr
);
423 fl
->proto
= IPPROTO_ICMPV6
;
424 fl
->fl_icmp_type
= type
;
425 fl
->fl_icmp_code
= 0;
427 security_sk_classify_flow(ndisc_socket
->sk
, fl
);
430 static void ndisc_send_na(struct net_device
*dev
, struct neighbour
*neigh
,
431 struct in6_addr
*daddr
, struct in6_addr
*solicited_addr
,
432 int router
, int solicited
, int override
, int inc_opt
)
434 struct in6_addr tmpaddr
;
435 struct inet6_ifaddr
*ifp
;
436 struct inet6_dev
*idev
;
438 struct dst_entry
* dst
;
439 struct sock
*sk
= ndisc_socket
->sk
;
440 struct in6_addr
*src_addr
;
446 len
= sizeof(struct icmp6hdr
) + sizeof(struct in6_addr
);
448 /* for anycast or proxy, solicited_addr != src_addr */
449 ifp
= ipv6_get_ifaddr(solicited_addr
, dev
, 1);
451 src_addr
= solicited_addr
;
452 if (ifp
->flags
& IFA_F_OPTIMISTIC
)
456 if (ipv6_dev_get_saddr(dev
, daddr
, &tmpaddr
))
461 ndisc_flow_init(&fl
, NDISC_NEIGHBOUR_ADVERTISEMENT
, src_addr
, daddr
,
464 dst
= ndisc_dst_alloc(dev
, neigh
, daddr
, ip6_output
);
468 err
= xfrm_lookup(&dst
, &fl
, NULL
, 0);
474 len
+= ndisc_opt_addr_space(dev
);
479 skb
= sock_alloc_send_skb(sk
,
480 (MAX_HEADER
+ sizeof(struct ipv6hdr
) +
481 len
+ LL_RESERVED_SPACE(dev
)),
486 "ICMPv6 NA: %s() failed to allocate an skb.\n",
492 skb_reserve(skb
, LL_RESERVED_SPACE(dev
));
493 ip6_nd_hdr(sk
, skb
, dev
, src_addr
, daddr
, IPPROTO_ICMPV6
, len
);
495 skb_set_transport_header(skb
, skb
->tail
- skb
->data
);
497 msg
= (struct nd_msg
*)skb_transport_header(skb
);
499 msg
->icmph
.icmp6_type
= NDISC_NEIGHBOUR_ADVERTISEMENT
;
500 msg
->icmph
.icmp6_code
= 0;
501 msg
->icmph
.icmp6_cksum
= 0;
503 msg
->icmph
.icmp6_unused
= 0;
504 msg
->icmph
.icmp6_router
= router
;
505 msg
->icmph
.icmp6_solicited
= solicited
;
506 msg
->icmph
.icmp6_override
= override
;
508 /* Set the target address. */
509 ipv6_addr_copy(&msg
->target
, solicited_addr
);
512 ndisc_fill_addr_option(msg
->opt
, ND_OPT_TARGET_LL_ADDR
, dev
->dev_addr
,
513 dev
->addr_len
, dev
->type
);
516 msg
->icmph
.icmp6_cksum
= csum_ipv6_magic(src_addr
, daddr
, len
,
518 csum_partial((__u8
*) msg
,
522 idev
= in6_dev_get(dst
->dev
);
523 IP6_INC_STATS(idev
, IPSTATS_MIB_OUTREQUESTS
);
524 err
= NF_HOOK(PF_INET6
, NF_IP6_LOCAL_OUT
, skb
, NULL
, dst
->dev
, dst_output
);
526 ICMP6_INC_STATS(idev
, ICMP6_MIB_OUTNEIGHBORADVERTISEMENTS
);
527 ICMP6_INC_STATS(idev
, ICMP6_MIB_OUTMSGS
);
530 if (likely(idev
!= NULL
))
534 void ndisc_send_ns(struct net_device
*dev
, struct neighbour
*neigh
,
535 struct in6_addr
*solicit
,
536 struct in6_addr
*daddr
, struct in6_addr
*saddr
)
539 struct dst_entry
* dst
;
540 struct inet6_dev
*idev
;
541 struct sock
*sk
= ndisc_socket
->sk
;
544 struct in6_addr addr_buf
;
550 if (ipv6_get_lladdr(dev
, &addr_buf
,
551 (IFA_F_TENTATIVE
|IFA_F_OPTIMISTIC
)))
556 ndisc_flow_init(&fl
, NDISC_NEIGHBOUR_SOLICITATION
, saddr
, daddr
,
559 dst
= ndisc_dst_alloc(dev
, neigh
, daddr
, ip6_output
);
563 err
= xfrm_lookup(&dst
, &fl
, NULL
, 0);
567 len
= sizeof(struct icmp6hdr
) + sizeof(struct in6_addr
);
568 send_llinfo
= dev
->addr_len
&& !ipv6_addr_any(saddr
);
570 len
+= ndisc_opt_addr_space(dev
);
572 skb
= sock_alloc_send_skb(sk
,
573 (MAX_HEADER
+ sizeof(struct ipv6hdr
) +
574 len
+ LL_RESERVED_SPACE(dev
)),
578 "ICMPv6 NA: %s() failed to allocate an skb.\n",
584 skb_reserve(skb
, LL_RESERVED_SPACE(dev
));
585 ip6_nd_hdr(sk
, skb
, dev
, saddr
, daddr
, IPPROTO_ICMPV6
, len
);
587 skb_set_transport_header(skb
, skb
->tail
- skb
->data
);
589 msg
= (struct nd_msg
*)skb_transport_header(skb
);
590 msg
->icmph
.icmp6_type
= NDISC_NEIGHBOUR_SOLICITATION
;
591 msg
->icmph
.icmp6_code
= 0;
592 msg
->icmph
.icmp6_cksum
= 0;
593 msg
->icmph
.icmp6_unused
= 0;
595 /* Set the target address. */
596 ipv6_addr_copy(&msg
->target
, solicit
);
599 ndisc_fill_addr_option(msg
->opt
, ND_OPT_SOURCE_LL_ADDR
, dev
->dev_addr
,
600 dev
->addr_len
, dev
->type
);
603 msg
->icmph
.icmp6_cksum
= csum_ipv6_magic(&ipv6_hdr(skb
)->saddr
,
606 csum_partial((__u8
*) msg
,
610 idev
= in6_dev_get(dst
->dev
);
611 IP6_INC_STATS(idev
, IPSTATS_MIB_OUTREQUESTS
);
612 err
= NF_HOOK(PF_INET6
, NF_IP6_LOCAL_OUT
, skb
, NULL
, dst
->dev
, dst_output
);
614 ICMP6_INC_STATS(idev
, ICMP6_MIB_OUTNEIGHBORSOLICITS
);
615 ICMP6_INC_STATS(idev
, ICMP6_MIB_OUTMSGS
);
618 if (likely(idev
!= NULL
))
622 void ndisc_send_rs(struct net_device
*dev
, struct in6_addr
*saddr
,
623 struct in6_addr
*daddr
)
626 struct dst_entry
* dst
;
627 struct inet6_dev
*idev
;
628 struct sock
*sk
= ndisc_socket
->sk
;
630 struct icmp6hdr
*hdr
;
632 int send_sllao
= dev
->addr_len
;
637 #ifdef CONFIG_IPV6_OPTIMISTIC_DAD
639 * According to section 2.2 of RFC 4429, we must not
640 * send router solicitations with a sllao from
641 * optimistic addresses, but we may send the solicitation
642 * if we don't include the sllao. So here we check
643 * if our address is optimistic, and if so, we
644 * supress the inclusion of the sllao.
647 struct inet6_ifaddr
*ifp
= ipv6_get_ifaddr(saddr
, dev
, 1);
649 if (ifp
->flags
& IFA_F_OPTIMISTIC
) {
658 ndisc_flow_init(&fl
, NDISC_ROUTER_SOLICITATION
, saddr
, daddr
,
661 dst
= ndisc_dst_alloc(dev
, NULL
, daddr
, ip6_output
);
665 err
= xfrm_lookup(&dst
, &fl
, NULL
, 0);
669 len
= sizeof(struct icmp6hdr
);
671 len
+= ndisc_opt_addr_space(dev
);
673 skb
= sock_alloc_send_skb(sk
,
674 (MAX_HEADER
+ sizeof(struct ipv6hdr
) +
675 len
+ LL_RESERVED_SPACE(dev
)),
679 "ICMPv6 RS: %s() failed to allocate an skb.\n",
685 skb_reserve(skb
, LL_RESERVED_SPACE(dev
));
686 ip6_nd_hdr(sk
, skb
, dev
, saddr
, daddr
, IPPROTO_ICMPV6
, len
);
688 skb_set_transport_header(skb
, skb
->tail
- skb
->data
);
690 hdr
= icmp6_hdr(skb
);
691 hdr
->icmp6_type
= NDISC_ROUTER_SOLICITATION
;
693 hdr
->icmp6_cksum
= 0;
694 hdr
->icmp6_unused
= 0;
696 opt
= (u8
*) (hdr
+ 1);
699 ndisc_fill_addr_option(opt
, ND_OPT_SOURCE_LL_ADDR
, dev
->dev_addr
,
700 dev
->addr_len
, dev
->type
);
703 hdr
->icmp6_cksum
= csum_ipv6_magic(&ipv6_hdr(skb
)->saddr
, daddr
, len
,
705 csum_partial((__u8
*) hdr
, len
, 0));
709 idev
= in6_dev_get(dst
->dev
);
710 IP6_INC_STATS(idev
, IPSTATS_MIB_OUTREQUESTS
);
711 err
= NF_HOOK(PF_INET6
, NF_IP6_LOCAL_OUT
, skb
, NULL
, dst
->dev
, dst_output
);
713 ICMP6_INC_STATS(idev
, ICMP6_MIB_OUTROUTERSOLICITS
);
714 ICMP6_INC_STATS(idev
, ICMP6_MIB_OUTMSGS
);
717 if (likely(idev
!= NULL
))
722 static void ndisc_error_report(struct neighbour
*neigh
, struct sk_buff
*skb
)
725 * "The sender MUST return an ICMP
726 * destination unreachable"
728 dst_link_failure(skb
);
732 /* Called with locked neigh: either read or both */
734 static void ndisc_solicit(struct neighbour
*neigh
, struct sk_buff
*skb
)
736 struct in6_addr
*saddr
= NULL
;
737 struct in6_addr mcaddr
;
738 struct net_device
*dev
= neigh
->dev
;
739 struct in6_addr
*target
= (struct in6_addr
*)&neigh
->primary_key
;
740 int probes
= atomic_read(&neigh
->probes
);
742 if (skb
&& ipv6_chk_addr(&ipv6_hdr(skb
)->saddr
, dev
, 1))
743 saddr
= &ipv6_hdr(skb
)->saddr
;
745 if ((probes
-= neigh
->parms
->ucast_probes
) < 0) {
746 if (!(neigh
->nud_state
& NUD_VALID
)) {
747 ND_PRINTK1(KERN_DEBUG
748 "%s(): trying to ucast probe in NUD_INVALID: "
753 ndisc_send_ns(dev
, neigh
, target
, target
, saddr
);
754 } else if ((probes
-= neigh
->parms
->app_probes
) < 0) {
759 addrconf_addr_solict_mult(target
, &mcaddr
);
760 ndisc_send_ns(dev
, NULL
, target
, &mcaddr
, saddr
);
764 static void ndisc_recv_ns(struct sk_buff
*skb
)
766 struct nd_msg
*msg
= (struct nd_msg
*)skb_transport_header(skb
);
767 struct in6_addr
*saddr
= &ipv6_hdr(skb
)->saddr
;
768 struct in6_addr
*daddr
= &ipv6_hdr(skb
)->daddr
;
770 u32 ndoptlen
= skb
->tail
- msg
->opt
;
771 struct ndisc_options ndopts
;
772 struct net_device
*dev
= skb
->dev
;
773 struct inet6_ifaddr
*ifp
;
774 struct inet6_dev
*idev
= NULL
;
775 struct neighbour
*neigh
;
776 struct pneigh_entry
*pneigh
= NULL
;
777 int dad
= ipv6_addr_any(saddr
);
781 if (ipv6_addr_is_multicast(&msg
->target
)) {
782 ND_PRINTK2(KERN_WARNING
783 "ICMPv6 NS: multicast target address");
789 * DAD has to be destined for solicited node multicast address.
792 !(daddr
->s6_addr32
[0] == htonl(0xff020000) &&
793 daddr
->s6_addr32
[1] == htonl(0x00000000) &&
794 daddr
->s6_addr32
[2] == htonl(0x00000001) &&
795 daddr
->s6_addr
[12] == 0xff )) {
796 ND_PRINTK2(KERN_WARNING
797 "ICMPv6 NS: bad DAD packet (wrong destination)\n");
801 if (!ndisc_parse_options(msg
->opt
, ndoptlen
, &ndopts
)) {
802 ND_PRINTK2(KERN_WARNING
803 "ICMPv6 NS: invalid ND options\n");
807 if (ndopts
.nd_opts_src_lladdr
) {
808 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_src_lladdr
, dev
);
810 ND_PRINTK2(KERN_WARNING
811 "ICMPv6 NS: invalid link-layer address length\n");
816 * If the IP source address is the unspecified address,
817 * there MUST NOT be source link-layer address option
821 ND_PRINTK2(KERN_WARNING
822 "ICMPv6 NS: bad DAD packet (link-layer address option)\n");
827 inc
= ipv6_addr_is_multicast(daddr
);
829 if ((ifp
= ipv6_get_ifaddr(&msg
->target
, dev
, 1)) != NULL
) {
831 if (ifp
->flags
& (IFA_F_TENTATIVE
|IFA_F_OPTIMISTIC
)) {
833 if (dev
->type
== ARPHRD_IEEE802_TR
) {
834 const unsigned char *sadr
;
835 sadr
= skb_mac_header(skb
);
836 if (((sadr
[8] ^ dev
->dev_addr
[0]) & 0x7f) == 0 &&
837 sadr
[9] == dev
->dev_addr
[1] &&
838 sadr
[10] == dev
->dev_addr
[2] &&
839 sadr
[11] == dev
->dev_addr
[3] &&
840 sadr
[12] == dev
->dev_addr
[4] &&
841 sadr
[13] == dev
->dev_addr
[5]) {
842 /* looped-back to us */
848 * We are colliding with another node
850 * so fail our DAD process
852 addrconf_dad_failure(ifp
);
856 * This is not a dad solicitation.
857 * If we are an optimistic node,
859 * Otherwise, we should ignore it.
861 if (!(ifp
->flags
& IFA_F_OPTIMISTIC
))
868 idev
= in6_dev_get(dev
);
870 /* XXX: count this drop? */
874 if (ipv6_chk_acast_addr(dev
, &msg
->target
) ||
875 (idev
->cnf
.forwarding
&&
876 (ipv6_devconf
.proxy_ndp
|| idev
->cnf
.proxy_ndp
) &&
877 (pneigh
= pneigh_lookup(&nd_tbl
,
878 &msg
->target
, dev
, 0)) != NULL
)) {
879 if (!(NEIGH_CB(skb
)->flags
& LOCALLY_ENQUEUED
) &&
880 skb
->pkt_type
!= PACKET_HOST
&&
882 idev
->nd_parms
->proxy_delay
!= 0) {
884 * for anycast or proxy,
885 * sender should delay its response
886 * by a random time between 0 and
887 * MAX_ANYCAST_DELAY_TIME seconds.
888 * (RFC2461) -- yoshfuji
890 struct sk_buff
*n
= skb_clone(skb
, GFP_ATOMIC
);
892 pneigh_enqueue(&nd_tbl
, idev
->nd_parms
, n
);
899 is_router
= !!(pneigh
? pneigh
->flags
& NTF_ROUTER
: idev
->cnf
.forwarding
);
902 struct in6_addr maddr
;
904 ipv6_addr_all_nodes(&maddr
);
905 ndisc_send_na(dev
, NULL
, &maddr
, &msg
->target
,
906 is_router
, 0, (ifp
!= NULL
), 1);
911 NEIGH_CACHE_STAT_INC(&nd_tbl
, rcv_probes_mcast
);
913 NEIGH_CACHE_STAT_INC(&nd_tbl
, rcv_probes_ucast
);
916 * update / create cache entry
917 * for the source address
919 neigh
= __neigh_lookup(&nd_tbl
, saddr
, dev
,
920 !inc
|| lladdr
|| !dev
->addr_len
);
922 neigh_update(neigh
, lladdr
, NUD_STALE
,
923 NEIGH_UPDATE_F_WEAK_OVERRIDE
|
924 NEIGH_UPDATE_F_OVERRIDE
);
925 if (neigh
|| !dev
->hard_header
) {
926 ndisc_send_na(dev
, neigh
, saddr
, &msg
->target
,
928 1, (ifp
!= NULL
&& inc
), inc
);
930 neigh_release(neigh
);
942 static void ndisc_recv_na(struct sk_buff
*skb
)
944 struct nd_msg
*msg
= (struct nd_msg
*)skb_transport_header(skb
);
945 struct in6_addr
*saddr
= &ipv6_hdr(skb
)->saddr
;
946 struct in6_addr
*daddr
= &ipv6_hdr(skb
)->daddr
;
948 u32 ndoptlen
= skb
->tail
- msg
->opt
;
949 struct ndisc_options ndopts
;
950 struct net_device
*dev
= skb
->dev
;
951 struct inet6_ifaddr
*ifp
;
952 struct neighbour
*neigh
;
954 if (skb
->len
< sizeof(struct nd_msg
)) {
955 ND_PRINTK2(KERN_WARNING
956 "ICMPv6 NA: packet too short\n");
960 if (ipv6_addr_is_multicast(&msg
->target
)) {
961 ND_PRINTK2(KERN_WARNING
962 "ICMPv6 NA: target address is multicast.\n");
966 if (ipv6_addr_is_multicast(daddr
) &&
967 msg
->icmph
.icmp6_solicited
) {
968 ND_PRINTK2(KERN_WARNING
969 "ICMPv6 NA: solicited NA is multicasted.\n");
973 if (!ndisc_parse_options(msg
->opt
, ndoptlen
, &ndopts
)) {
974 ND_PRINTK2(KERN_WARNING
975 "ICMPv6 NS: invalid ND option\n");
978 if (ndopts
.nd_opts_tgt_lladdr
) {
979 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_tgt_lladdr
, dev
);
981 ND_PRINTK2(KERN_WARNING
982 "ICMPv6 NA: invalid link-layer address length\n");
986 if ((ifp
= ipv6_get_ifaddr(&msg
->target
, dev
, 1))) {
987 if (ifp
->flags
& IFA_F_TENTATIVE
) {
988 addrconf_dad_failure(ifp
);
991 /* What should we make now? The advertisement
992 is invalid, but ndisc specs say nothing
993 about it. It could be misconfiguration, or
994 an smart proxy agent tries to help us :-)
996 ND_PRINTK1(KERN_WARNING
997 "ICMPv6 NA: someone advertises our address on %s!\n",
998 ifp
->idev
->dev
->name
);
1002 neigh
= neigh_lookup(&nd_tbl
, &msg
->target
, dev
);
1005 u8 old_flags
= neigh
->flags
;
1007 if (neigh
->nud_state
& NUD_FAILED
)
1011 * Don't update the neighbor cache entry on a proxy NA from
1012 * ourselves because either the proxied node is off link or it
1013 * has already sent a NA to us.
1015 if (lladdr
&& !memcmp(lladdr
, dev
->dev_addr
, dev
->addr_len
) &&
1016 ipv6_devconf
.forwarding
&& ipv6_devconf
.proxy_ndp
&&
1017 pneigh_lookup(&nd_tbl
, &msg
->target
, dev
, 0)) {
1018 /* XXX: idev->cnf.prixy_ndp */
1022 neigh_update(neigh
, lladdr
,
1023 msg
->icmph
.icmp6_solicited
? NUD_REACHABLE
: NUD_STALE
,
1024 NEIGH_UPDATE_F_WEAK_OVERRIDE
|
1025 (msg
->icmph
.icmp6_override
? NEIGH_UPDATE_F_OVERRIDE
: 0)|
1026 NEIGH_UPDATE_F_OVERRIDE_ISROUTER
|
1027 (msg
->icmph
.icmp6_router
? NEIGH_UPDATE_F_ISROUTER
: 0));
1029 if ((old_flags
& ~neigh
->flags
) & NTF_ROUTER
) {
1031 * Change: router to host
1033 struct rt6_info
*rt
;
1034 rt
= rt6_get_dflt_router(saddr
, dev
);
1040 neigh_release(neigh
);
1044 static void ndisc_recv_rs(struct sk_buff
*skb
)
1046 struct rs_msg
*rs_msg
= (struct rs_msg
*)skb_transport_header(skb
);
1047 unsigned long ndoptlen
= skb
->len
- sizeof(*rs_msg
);
1048 struct neighbour
*neigh
;
1049 struct inet6_dev
*idev
;
1050 struct in6_addr
*saddr
= &ipv6_hdr(skb
)->saddr
;
1051 struct ndisc_options ndopts
;
1054 if (skb
->len
< sizeof(*rs_msg
))
1057 idev
= in6_dev_get(skb
->dev
);
1059 if (net_ratelimit())
1060 ND_PRINTK1("ICMP6 RS: can't find in6 device\n");
1064 /* Don't accept RS if we're not in router mode */
1065 if (!idev
->cnf
.forwarding
)
1069 * Don't update NCE if src = ::;
1070 * this implies that the source node has no ip address assigned yet.
1072 if (ipv6_addr_any(saddr
))
1075 /* Parse ND options */
1076 if (!ndisc_parse_options(rs_msg
->opt
, ndoptlen
, &ndopts
)) {
1077 if (net_ratelimit())
1078 ND_PRINTK2("ICMP6 NS: invalid ND option, ignored\n");
1082 if (ndopts
.nd_opts_src_lladdr
) {
1083 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_src_lladdr
,
1089 neigh
= __neigh_lookup(&nd_tbl
, saddr
, skb
->dev
, 1);
1091 neigh_update(neigh
, lladdr
, NUD_STALE
,
1092 NEIGH_UPDATE_F_WEAK_OVERRIDE
|
1093 NEIGH_UPDATE_F_OVERRIDE
|
1094 NEIGH_UPDATE_F_OVERRIDE_ISROUTER
);
1095 neigh_release(neigh
);
1101 static void ndisc_router_discovery(struct sk_buff
*skb
)
1103 struct ra_msg
*ra_msg
= (struct ra_msg
*)skb_transport_header(skb
);
1104 struct neighbour
*neigh
= NULL
;
1105 struct inet6_dev
*in6_dev
;
1106 struct rt6_info
*rt
= NULL
;
1108 struct ndisc_options ndopts
;
1110 unsigned int pref
= 0;
1112 __u8
* opt
= (__u8
*)(ra_msg
+ 1);
1114 optlen
= (skb
->tail
- skb_transport_header(skb
)) -
1115 sizeof(struct ra_msg
);
1117 if (!(ipv6_addr_type(&ipv6_hdr(skb
)->saddr
) & IPV6_ADDR_LINKLOCAL
)) {
1118 ND_PRINTK2(KERN_WARNING
1119 "ICMPv6 RA: source address is not link-local.\n");
1123 ND_PRINTK2(KERN_WARNING
1124 "ICMPv6 RA: packet too short\n");
1129 * set the RA_RECV flag in the interface
1132 in6_dev
= in6_dev_get(skb
->dev
);
1133 if (in6_dev
== NULL
) {
1135 "ICMPv6 RA: can't find inet6 device for %s.\n",
1139 if (in6_dev
->cnf
.forwarding
|| !in6_dev
->cnf
.accept_ra
) {
1140 in6_dev_put(in6_dev
);
1144 if (!ndisc_parse_options(opt
, optlen
, &ndopts
)) {
1145 in6_dev_put(in6_dev
);
1146 ND_PRINTK2(KERN_WARNING
1147 "ICMP6 RA: invalid ND options\n");
1151 if (in6_dev
->if_flags
& IF_RS_SENT
) {
1153 * flag that an RA was received after an RS was sent
1154 * out on this interface.
1156 in6_dev
->if_flags
|= IF_RA_RCVD
;
1160 * Remember the managed/otherconf flags from most recently
1161 * received RA message (RFC 2462) -- yoshfuji
1163 in6_dev
->if_flags
= (in6_dev
->if_flags
& ~(IF_RA_MANAGED
|
1165 (ra_msg
->icmph
.icmp6_addrconf_managed
?
1166 IF_RA_MANAGED
: 0) |
1167 (ra_msg
->icmph
.icmp6_addrconf_other
?
1168 IF_RA_OTHERCONF
: 0);
1170 if (!in6_dev
->cnf
.accept_ra_defrtr
)
1173 lifetime
= ntohs(ra_msg
->icmph
.icmp6_rt_lifetime
);
1175 #ifdef CONFIG_IPV6_ROUTER_PREF
1176 pref
= ra_msg
->icmph
.icmp6_router_pref
;
1177 /* 10b is handled as if it were 00b (medium) */
1178 if (pref
== ICMPV6_ROUTER_PREF_INVALID
||
1179 in6_dev
->cnf
.accept_ra_rtr_pref
)
1180 pref
= ICMPV6_ROUTER_PREF_MEDIUM
;
1183 rt
= rt6_get_dflt_router(&ipv6_hdr(skb
)->saddr
, skb
->dev
);
1186 neigh
= rt
->rt6i_nexthop
;
1188 if (rt
&& lifetime
== 0) {
1194 if (rt
== NULL
&& lifetime
) {
1195 ND_PRINTK3(KERN_DEBUG
1196 "ICMPv6 RA: adding default router.\n");
1198 rt
= rt6_add_dflt_router(&ipv6_hdr(skb
)->saddr
, skb
->dev
, pref
);
1201 "ICMPv6 RA: %s() failed to add default route.\n",
1203 in6_dev_put(in6_dev
);
1207 neigh
= rt
->rt6i_nexthop
;
1208 if (neigh
== NULL
) {
1210 "ICMPv6 RA: %s() got default router without neighbour.\n",
1212 dst_release(&rt
->u
.dst
);
1213 in6_dev_put(in6_dev
);
1216 neigh
->flags
|= NTF_ROUTER
;
1218 rt
->rt6i_flags
|= (rt
->rt6i_flags
& ~RTF_PREF_MASK
) | RTF_PREF(pref
);
1222 rt
->rt6i_expires
= jiffies
+ (HZ
* lifetime
);
1224 if (ra_msg
->icmph
.icmp6_hop_limit
) {
1225 in6_dev
->cnf
.hop_limit
= ra_msg
->icmph
.icmp6_hop_limit
;
1227 rt
->u
.dst
.metrics
[RTAX_HOPLIMIT
-1] = ra_msg
->icmph
.icmp6_hop_limit
;
1233 * Update Reachable Time and Retrans Timer
1236 if (in6_dev
->nd_parms
) {
1237 unsigned long rtime
= ntohl(ra_msg
->retrans_timer
);
1239 if (rtime
&& rtime
/1000 < MAX_SCHEDULE_TIMEOUT
/HZ
) {
1240 rtime
= (rtime
*HZ
)/1000;
1243 in6_dev
->nd_parms
->retrans_time
= rtime
;
1244 in6_dev
->tstamp
= jiffies
;
1245 inet6_ifinfo_notify(RTM_NEWLINK
, in6_dev
);
1248 rtime
= ntohl(ra_msg
->reachable_time
);
1249 if (rtime
&& rtime
/1000 < MAX_SCHEDULE_TIMEOUT
/(3*HZ
)) {
1250 rtime
= (rtime
*HZ
)/1000;
1255 if (rtime
!= in6_dev
->nd_parms
->base_reachable_time
) {
1256 in6_dev
->nd_parms
->base_reachable_time
= rtime
;
1257 in6_dev
->nd_parms
->gc_staletime
= 3 * rtime
;
1258 in6_dev
->nd_parms
->reachable_time
= neigh_rand_reach_time(rtime
);
1259 in6_dev
->tstamp
= jiffies
;
1260 inet6_ifinfo_notify(RTM_NEWLINK
, in6_dev
);
1270 neigh
= __neigh_lookup(&nd_tbl
, &ipv6_hdr(skb
)->saddr
,
1274 if (ndopts
.nd_opts_src_lladdr
) {
1275 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_src_lladdr
,
1278 ND_PRINTK2(KERN_WARNING
1279 "ICMPv6 RA: invalid link-layer address length\n");
1283 neigh_update(neigh
, lladdr
, NUD_STALE
,
1284 NEIGH_UPDATE_F_WEAK_OVERRIDE
|
1285 NEIGH_UPDATE_F_OVERRIDE
|
1286 NEIGH_UPDATE_F_OVERRIDE_ISROUTER
|
1287 NEIGH_UPDATE_F_ISROUTER
);
1290 #ifdef CONFIG_IPV6_ROUTE_INFO
1291 if (in6_dev
->cnf
.accept_ra_rtr_pref
&& ndopts
.nd_opts_ri
) {
1292 struct nd_opt_hdr
*p
;
1293 for (p
= ndopts
.nd_opts_ri
;
1295 p
= ndisc_next_option(p
, ndopts
.nd_opts_ri_end
)) {
1296 if (((struct route_info
*)p
)->prefix_len
> in6_dev
->cnf
.accept_ra_rt_info_max_plen
)
1298 rt6_route_rcv(skb
->dev
, (u8
*)p
, (p
->nd_opt_len
) << 3,
1299 &ipv6_hdr(skb
)->saddr
);
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_opts_tgt_lladdr
|| ndopts
.nd_opts_rh
) {
1335 ND_PRINTK2(KERN_WARNING
1336 "ICMPv6 RA: invalid RA options");
1340 dst_release(&rt
->u
.dst
);
1342 neigh_release(neigh
);
1343 in6_dev_put(in6_dev
);
1346 static void ndisc_redirect_rcv(struct sk_buff
*skb
)
1348 struct inet6_dev
*in6_dev
;
1349 struct icmp6hdr
*icmph
;
1350 struct in6_addr
*dest
;
1351 struct in6_addr
*target
; /* new first hop to destination */
1352 struct neighbour
*neigh
;
1354 struct ndisc_options ndopts
;
1358 if (!(ipv6_addr_type(&ipv6_hdr(skb
)->saddr
) & IPV6_ADDR_LINKLOCAL
)) {
1359 ND_PRINTK2(KERN_WARNING
1360 "ICMPv6 Redirect: source address is not link-local.\n");
1364 optlen
= skb
->tail
- skb_transport_header(skb
);
1365 optlen
-= sizeof(struct icmp6hdr
) + 2 * sizeof(struct in6_addr
);
1368 ND_PRINTK2(KERN_WARNING
1369 "ICMPv6 Redirect: packet too short\n");
1373 icmph
= icmp6_hdr(skb
);
1374 target
= (struct in6_addr
*) (icmph
+ 1);
1377 if (ipv6_addr_is_multicast(dest
)) {
1378 ND_PRINTK2(KERN_WARNING
1379 "ICMPv6 Redirect: destination address is multicast.\n");
1383 if (ipv6_addr_equal(dest
, target
)) {
1385 } else if (!(ipv6_addr_type(target
) & IPV6_ADDR_LINKLOCAL
)) {
1386 ND_PRINTK2(KERN_WARNING
1387 "ICMPv6 Redirect: target address is not link-local.\n");
1391 in6_dev
= in6_dev_get(skb
->dev
);
1394 if (in6_dev
->cnf
.forwarding
|| !in6_dev
->cnf
.accept_redirects
) {
1395 in6_dev_put(in6_dev
);
1400 * The IP source address of the Redirect MUST be the same as the current
1401 * first-hop router for the specified ICMP Destination Address.
1404 if (!ndisc_parse_options((u8
*)(dest
+ 1), optlen
, &ndopts
)) {
1405 ND_PRINTK2(KERN_WARNING
1406 "ICMPv6 Redirect: invalid ND options\n");
1407 in6_dev_put(in6_dev
);
1410 if (ndopts
.nd_opts_tgt_lladdr
) {
1411 lladdr
= ndisc_opt_addr_data(ndopts
.nd_opts_tgt_lladdr
,
1414 ND_PRINTK2(KERN_WARNING
1415 "ICMPv6 Redirect: invalid link-layer address length\n");
1416 in6_dev_put(in6_dev
);
1421 neigh
= __neigh_lookup(&nd_tbl
, target
, skb
->dev
, 1);
1423 rt6_redirect(dest
, &ipv6_hdr(skb
)->daddr
,
1424 &ipv6_hdr(skb
)->saddr
, neigh
, lladdr
,
1426 neigh_release(neigh
);
1428 in6_dev_put(in6_dev
);
1431 void ndisc_send_redirect(struct sk_buff
*skb
, struct neighbour
*neigh
,
1432 struct in6_addr
*target
)
1434 struct sock
*sk
= ndisc_socket
->sk
;
1435 int len
= sizeof(struct icmp6hdr
) + 2 * sizeof(struct in6_addr
);
1436 struct sk_buff
*buff
;
1437 struct icmp6hdr
*icmph
;
1438 struct in6_addr saddr_buf
;
1439 struct in6_addr
*addrp
;
1440 struct net_device
*dev
;
1441 struct rt6_info
*rt
;
1442 struct dst_entry
*dst
;
1443 struct inet6_dev
*idev
;
1449 u8 ha_buf
[MAX_ADDR_LEN
], *ha
= NULL
;
1453 if (ipv6_get_lladdr(dev
, &saddr_buf
, IFA_F_TENTATIVE
)) {
1454 ND_PRINTK2(KERN_WARNING
1455 "ICMPv6 Redirect: no link-local address on %s\n",
1460 if (!ipv6_addr_equal(&ipv6_hdr(skb
)->daddr
, target
) &&
1461 !(ipv6_addr_type(target
) & IPV6_ADDR_LINKLOCAL
)) {
1462 ND_PRINTK2(KERN_WARNING
1463 "ICMPv6 Redirect: target address is not link-local.\n");
1467 ndisc_flow_init(&fl
, NDISC_REDIRECT
, &saddr_buf
, &ipv6_hdr(skb
)->saddr
,
1470 dst
= ip6_route_output(NULL
, &fl
);
1474 err
= xfrm_lookup(&dst
, &fl
, NULL
, 0);
1478 rt
= (struct rt6_info
*) dst
;
1480 if (rt
->rt6i_flags
& RTF_GATEWAY
) {
1481 ND_PRINTK2(KERN_WARNING
1482 "ICMPv6 Redirect: destination is not a neighbour.\n");
1486 if (!xrlim_allow(dst
, 1*HZ
)) {
1491 if (dev
->addr_len
) {
1492 read_lock_bh(&neigh
->lock
);
1493 if (neigh
->nud_state
& NUD_VALID
) {
1494 memcpy(ha_buf
, neigh
->ha
, dev
->addr_len
);
1495 read_unlock_bh(&neigh
->lock
);
1497 len
+= ndisc_opt_addr_space(dev
);
1499 read_unlock_bh(&neigh
->lock
);
1502 rd_len
= min_t(unsigned int,
1503 IPV6_MIN_MTU
-sizeof(struct ipv6hdr
)-len
, skb
->len
+ 8);
1507 buff
= sock_alloc_send_skb(sk
,
1508 (MAX_HEADER
+ sizeof(struct ipv6hdr
) +
1509 len
+ LL_RESERVED_SPACE(dev
)),
1513 "ICMPv6 Redirect: %s() failed to allocate an skb.\n",
1521 skb_reserve(buff
, LL_RESERVED_SPACE(dev
));
1522 ip6_nd_hdr(sk
, buff
, dev
, &saddr_buf
, &ipv6_hdr(skb
)->saddr
,
1523 IPPROTO_ICMPV6
, len
);
1525 skb_set_transport_header(buff
, buff
->tail
- buff
->data
);
1527 icmph
= icmp6_hdr(buff
);
1529 memset(icmph
, 0, sizeof(struct icmp6hdr
));
1530 icmph
->icmp6_type
= NDISC_REDIRECT
;
1533 * copy target and destination addresses
1536 addrp
= (struct in6_addr
*)(icmph
+ 1);
1537 ipv6_addr_copy(addrp
, target
);
1539 ipv6_addr_copy(addrp
, &ipv6_hdr(skb
)->daddr
);
1541 opt
= (u8
*) (addrp
+ 1);
1544 * include target_address option
1548 opt
= ndisc_fill_addr_option(opt
, ND_OPT_TARGET_LL_ADDR
, ha
,
1549 dev
->addr_len
, dev
->type
);
1552 * build redirect option and copy skb over to the new packet.
1556 *(opt
++) = ND_OPT_REDIRECT_HDR
;
1557 *(opt
++) = (rd_len
>> 3);
1560 memcpy(opt
, ipv6_hdr(skb
), rd_len
- 8);
1562 icmph
->icmp6_cksum
= csum_ipv6_magic(&saddr_buf
, &ipv6_hdr(skb
)->saddr
,
1563 len
, IPPROTO_ICMPV6
,
1564 csum_partial((u8
*) icmph
, len
, 0));
1567 idev
= in6_dev_get(dst
->dev
);
1568 IP6_INC_STATS(idev
, IPSTATS_MIB_OUTREQUESTS
);
1569 err
= NF_HOOK(PF_INET6
, NF_IP6_LOCAL_OUT
, buff
, NULL
, dst
->dev
, dst_output
);
1571 ICMP6_INC_STATS(idev
, ICMP6_MIB_OUTREDIRECTS
);
1572 ICMP6_INC_STATS(idev
, ICMP6_MIB_OUTMSGS
);
1575 if (likely(idev
!= NULL
))
1579 static void pndisc_redo(struct sk_buff
*skb
)
1585 int ndisc_rcv(struct sk_buff
*skb
)
1589 if (!pskb_may_pull(skb
, skb
->len
))
1592 msg
= (struct nd_msg
*)skb_transport_header(skb
);
1594 __skb_push(skb
, skb
->data
- skb_transport_header(skb
));
1596 if (ipv6_hdr(skb
)->hop_limit
!= 255) {
1597 ND_PRINTK2(KERN_WARNING
1598 "ICMPv6 NDISC: invalid hop-limit: %d\n",
1599 ipv6_hdr(skb
)->hop_limit
);
1603 if (msg
->icmph
.icmp6_code
!= 0) {
1604 ND_PRINTK2(KERN_WARNING
1605 "ICMPv6 NDISC: invalid ICMPv6 code: %d\n",
1606 msg
->icmph
.icmp6_code
);
1610 memset(NEIGH_CB(skb
), 0, sizeof(struct neighbour_cb
));
1612 switch (msg
->icmph
.icmp6_type
) {
1613 case NDISC_NEIGHBOUR_SOLICITATION
:
1617 case NDISC_NEIGHBOUR_ADVERTISEMENT
:
1621 case NDISC_ROUTER_SOLICITATION
:
1625 case NDISC_ROUTER_ADVERTISEMENT
:
1626 ndisc_router_discovery(skb
);
1629 case NDISC_REDIRECT
:
1630 ndisc_redirect_rcv(skb
);
1637 static int ndisc_netdev_event(struct notifier_block
*this, unsigned long event
, void *ptr
)
1639 struct net_device
*dev
= ptr
;
1642 case NETDEV_CHANGEADDR
:
1643 neigh_changeaddr(&nd_tbl
, dev
);
1647 neigh_ifdown(&nd_tbl
, dev
);
1657 static struct notifier_block ndisc_netdev_notifier
= {
1658 .notifier_call
= ndisc_netdev_event
,
1661 #ifdef CONFIG_SYSCTL
1662 static void ndisc_warn_deprecated_sysctl(struct ctl_table
*ctl
,
1663 const char *func
, const char *dev_name
)
1665 static char warncomm
[TASK_COMM_LEN
];
1667 if (strcmp(warncomm
, current
->comm
) && warned
< 5) {
1668 strcpy(warncomm
, current
->comm
);
1670 "process `%s' is using deprecated sysctl (%s) "
1671 "net.ipv6.neigh.%s.%s; "
1672 "Use net.ipv6.neigh.%s.%s_ms "
1675 dev_name
, ctl
->procname
,
1676 dev_name
, ctl
->procname
);
1681 int ndisc_ifinfo_sysctl_change(struct ctl_table
*ctl
, int write
, struct file
* filp
, void __user
*buffer
, size_t *lenp
, loff_t
*ppos
)
1683 struct net_device
*dev
= ctl
->extra1
;
1684 struct inet6_dev
*idev
;
1687 if (ctl
->ctl_name
== NET_NEIGH_RETRANS_TIME
||
1688 ctl
->ctl_name
== NET_NEIGH_REACHABLE_TIME
)
1689 ndisc_warn_deprecated_sysctl(ctl
, "syscall", dev
? dev
->name
: "default");
1691 switch (ctl
->ctl_name
) {
1692 case NET_NEIGH_RETRANS_TIME
:
1693 ret
= proc_dointvec(ctl
, write
, filp
, buffer
, lenp
, ppos
);
1695 case NET_NEIGH_REACHABLE_TIME
:
1696 ret
= proc_dointvec_jiffies(ctl
, write
,
1697 filp
, buffer
, lenp
, ppos
);
1699 case NET_NEIGH_RETRANS_TIME_MS
:
1700 case NET_NEIGH_REACHABLE_TIME_MS
:
1701 ret
= proc_dointvec_ms_jiffies(ctl
, write
,
1702 filp
, buffer
, lenp
, ppos
);
1708 if (write
&& ret
== 0 && dev
&& (idev
= in6_dev_get(dev
)) != NULL
) {
1709 if (ctl
->ctl_name
== NET_NEIGH_REACHABLE_TIME
||
1710 ctl
->ctl_name
== NET_NEIGH_REACHABLE_TIME_MS
)
1711 idev
->nd_parms
->reachable_time
= neigh_rand_reach_time(idev
->nd_parms
->base_reachable_time
);
1712 idev
->tstamp
= jiffies
;
1713 inet6_ifinfo_notify(RTM_NEWLINK
, idev
);
1719 static int ndisc_ifinfo_sysctl_strategy(ctl_table
*ctl
, int __user
*name
,
1720 int nlen
, void __user
*oldval
,
1721 size_t __user
*oldlenp
,
1722 void __user
*newval
, size_t newlen
)
1724 struct net_device
*dev
= ctl
->extra1
;
1725 struct inet6_dev
*idev
;
1728 if (ctl
->ctl_name
== NET_NEIGH_RETRANS_TIME
||
1729 ctl
->ctl_name
== NET_NEIGH_REACHABLE_TIME
)
1730 ndisc_warn_deprecated_sysctl(ctl
, "procfs", dev
? dev
->name
: "default");
1732 switch (ctl
->ctl_name
) {
1733 case NET_NEIGH_REACHABLE_TIME
:
1734 ret
= sysctl_jiffies(ctl
, name
, nlen
,
1735 oldval
, oldlenp
, newval
, newlen
);
1737 case NET_NEIGH_RETRANS_TIME_MS
:
1738 case NET_NEIGH_REACHABLE_TIME_MS
:
1739 ret
= sysctl_ms_jiffies(ctl
, name
, nlen
,
1740 oldval
, oldlenp
, newval
, newlen
);
1746 if (newval
&& newlen
&& ret
> 0 &&
1747 dev
&& (idev
= in6_dev_get(dev
)) != NULL
) {
1748 if (ctl
->ctl_name
== NET_NEIGH_REACHABLE_TIME
||
1749 ctl
->ctl_name
== NET_NEIGH_REACHABLE_TIME_MS
)
1750 idev
->nd_parms
->reachable_time
= neigh_rand_reach_time(idev
->nd_parms
->base_reachable_time
);
1751 idev
->tstamp
= jiffies
;
1752 inet6_ifinfo_notify(RTM_NEWLINK
, idev
);
1761 int __init
ndisc_init(struct net_proto_family
*ops
)
1763 struct ipv6_pinfo
*np
;
1767 err
= sock_create_kern(PF_INET6
, SOCK_RAW
, IPPROTO_ICMPV6
, &ndisc_socket
);
1770 "ICMPv6 NDISC: Failed to initialize the control socket (err %d).\n",
1772 ndisc_socket
= NULL
; /* For safety. */
1776 sk
= ndisc_socket
->sk
;
1778 sk
->sk_allocation
= GFP_ATOMIC
;
1779 np
->hop_limit
= 255;
1780 /* Do not loopback ndisc messages */
1782 sk
->sk_prot
->unhash(sk
);
1785 * Initialize the neighbour table
1788 neigh_table_init(&nd_tbl
);
1790 #ifdef CONFIG_SYSCTL
1791 neigh_sysctl_register(NULL
, &nd_tbl
.parms
, NET_IPV6
, NET_IPV6_NEIGH
,
1793 &ndisc_ifinfo_sysctl_change
,
1794 &ndisc_ifinfo_sysctl_strategy
);
1797 register_netdevice_notifier(&ndisc_netdev_notifier
);
1801 void ndisc_cleanup(void)
1803 unregister_netdevice_notifier(&ndisc_netdev_notifier
);
1804 #ifdef CONFIG_SYSCTL
1805 neigh_sysctl_unregister(&nd_tbl
.parms
);
1807 neigh_table_clear(&nd_tbl
);
1808 sock_release(ndisc_socket
);
1809 ndisc_socket
= NULL
; /* For safety. */