2 * Internet Control Message Protocol (ICMPv6)
3 * Linux INET6 implementation
6 * Pedro Roque <roque@di.fc.ul.pt>
8 * Based on net/ipv4/icmp.c
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version
15 * 2 of the License, or (at your option) any later version.
21 * Andi Kleen : exception handling
22 * Andi Kleen add rate limits. never reply to a icmp.
23 * add more length checks and other fixes.
24 * yoshfuji : ensure to sent parameter problem for
26 * YOSHIFUJI Hideaki @USAGI: added sysctl for icmp rate limit.
28 * YOSHIFUJI Hideaki @USAGI: Per-interface statistics support
29 * Kazunori MIYAZAWA @USAGI: change output process to use ip6_append_data
32 #define pr_fmt(fmt) "IPv6: " fmt
34 #include <linux/module.h>
35 #include <linux/errno.h>
36 #include <linux/types.h>
37 #include <linux/socket.h>
39 #include <linux/kernel.h>
40 #include <linux/sockios.h>
41 #include <linux/net.h>
42 #include <linux/skbuff.h>
43 #include <linux/init.h>
44 #include <linux/netfilter.h>
45 #include <linux/slab.h>
48 #include <linux/sysctl.h>
51 #include <linux/inet.h>
52 #include <linux/netdevice.h>
53 #include <linux/icmpv6.h>
59 #include <net/ip6_checksum.h>
61 #include <net/protocol.h>
63 #include <net/rawv6.h>
64 #include <net/transp_v6.h>
65 #include <net/ip6_route.h>
66 #include <net/addrconf.h>
69 #include <net/inet_common.h>
70 #include <net/dsfield.h>
71 #include <net/l3mdev.h>
73 #include <linux/uaccess.h>
76 * The ICMP socket(s). This is the most convenient way to flow control
77 * our ICMP output as well as maintain a clean interface throughout
78 * all layers. All Socketless IP sends will soon be gone.
80 * On SMP we have one ICMP socket per-cpu.
82 static inline struct sock *icmpv6_sk(struct net *net)
84 return net->ipv6.icmp_sk[smp_processor_id()];
87 static void icmpv6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
88 u8 type, u8 code, int offset, __be32 info)
90 /* icmpv6_notify checks 8 bytes can be pulled, icmp6hdr is 8 bytes */
91 struct icmp6hdr *icmp6 = (struct icmp6hdr *) (skb->data + offset);
92 struct net *net = dev_net(skb->dev);
94 if (type == ICMPV6_PKT_TOOBIG)
95 ip6_update_pmtu(skb, net, info, skb->dev->ifindex, 0, sock_net_uid(net, NULL));
96 else if (type == NDISC_REDIRECT)
97 ip6_redirect(skb, net, skb->dev->ifindex, 0,
98 sock_net_uid(net, NULL));
100 if (!(type & ICMPV6_INFOMSG_MASK))
101 if (icmp6->icmp6_type == ICMPV6_ECHO_REQUEST)
102 ping_err(skb, offset, ntohl(info));
105 static int icmpv6_rcv(struct sk_buff *skb);
107 static const struct inet6_protocol icmpv6_protocol = {
108 .handler = icmpv6_rcv,
109 .err_handler = icmpv6_err,
110 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
113 /* Called with BH disabled */
114 static __inline__ struct sock *icmpv6_xmit_lock(struct net *net)
119 if (unlikely(!spin_trylock(&sk->sk_lock.slock))) {
120 /* This can happen if the output path (f.e. SIT or
121 * ip6ip6 tunnel) signals dst_link_failure() for an
122 * outgoing ICMP6 packet.
129 static __inline__ void icmpv6_xmit_unlock(struct sock *sk)
131 spin_unlock(&sk->sk_lock.slock);
135 * Figure out, may we reply to this packet with icmp error.
137 * We do not reply, if:
138 * - it was icmp error message.
139 * - it is truncated, so that it is known, that protocol is ICMPV6
140 * (i.e. in the middle of some exthdr)
145 static bool is_ineligible(const struct sk_buff *skb)
147 int ptr = (u8 *)(ipv6_hdr(skb) + 1) - skb->data;
148 int len = skb->len - ptr;
149 __u8 nexthdr = ipv6_hdr(skb)->nexthdr;
155 ptr = ipv6_skip_exthdr(skb, ptr, &nexthdr, &frag_off);
158 if (nexthdr == IPPROTO_ICMPV6) {
160 tp = skb_header_pointer(skb,
161 ptr+offsetof(struct icmp6hdr, icmp6_type),
162 sizeof(_type), &_type);
163 if (!tp || !(*tp & ICMPV6_INFOMSG_MASK))
169 static bool icmpv6_mask_allow(int type)
171 /* Informational messages are not limited. */
172 if (type & ICMPV6_INFOMSG_MASK)
175 /* Do not limit pmtu discovery, it would break it. */
176 if (type == ICMPV6_PKT_TOOBIG)
182 static bool icmpv6_global_allow(int type)
184 if (icmpv6_mask_allow(type))
187 if (icmp_global_allow())
194 * Check the ICMP output rate limit
196 static bool icmpv6_xrlim_allow(struct sock *sk, u8 type,
199 struct net *net = sock_net(sk);
200 struct dst_entry *dst;
203 if (icmpv6_mask_allow(type))
207 * Look up the output route.
208 * XXX: perhaps the expire for routing entries cloned by
209 * this lookup should be more aggressive (not longer than timeout).
211 dst = ip6_route_output(net, sk, fl6);
213 IP6_INC_STATS(net, ip6_dst_idev(dst),
214 IPSTATS_MIB_OUTNOROUTES);
215 } else if (dst->dev && (dst->dev->flags&IFF_LOOPBACK)) {
218 struct rt6_info *rt = (struct rt6_info *)dst;
219 int tmo = net->ipv6.sysctl.icmpv6_time;
220 struct inet_peer *peer;
222 /* Give more bandwidth to wider prefixes. */
223 if (rt->rt6i_dst.plen < 128)
224 tmo >>= ((128 - rt->rt6i_dst.plen)>>5);
226 peer = inet_getpeer_v6(net->ipv6.peers, &fl6->daddr, 1);
227 res = inet_peer_xrlim_allow(peer, tmo);
236 * an inline helper for the "simple" if statement below
237 * checks if parameter problem report is caused by an
238 * unrecognized IPv6 option that has the Option Type
239 * highest-order two bits set to 10
242 static bool opt_unrec(struct sk_buff *skb, __u32 offset)
246 offset += skb_network_offset(skb);
247 op = skb_header_pointer(skb, offset, sizeof(_optval), &_optval);
250 return (*op & 0xC0) == 0x80;
253 void icmpv6_push_pending_frames(struct sock *sk, struct flowi6 *fl6,
254 struct icmp6hdr *thdr, int len)
257 struct icmp6hdr *icmp6h;
259 skb = skb_peek(&sk->sk_write_queue);
263 icmp6h = icmp6_hdr(skb);
264 memcpy(icmp6h, thdr, sizeof(struct icmp6hdr));
265 icmp6h->icmp6_cksum = 0;
267 if (skb_queue_len(&sk->sk_write_queue) == 1) {
268 skb->csum = csum_partial(icmp6h,
269 sizeof(struct icmp6hdr), skb->csum);
270 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
272 len, fl6->flowi6_proto,
277 skb_queue_walk(&sk->sk_write_queue, skb) {
278 tmp_csum = csum_add(tmp_csum, skb->csum);
281 tmp_csum = csum_partial(icmp6h,
282 sizeof(struct icmp6hdr), tmp_csum);
283 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
285 len, fl6->flowi6_proto,
288 ip6_push_pending_frames(sk);
297 static int icmpv6_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb)
299 struct icmpv6_msg *msg = (struct icmpv6_msg *) from;
300 struct sk_buff *org_skb = msg->skb;
303 csum = skb_copy_and_csum_bits(org_skb, msg->offset + offset,
305 skb->csum = csum_block_add(skb->csum, csum, odd);
306 if (!(msg->type & ICMPV6_INFOMSG_MASK))
307 nf_ct_attach(skb, org_skb);
311 #if IS_ENABLED(CONFIG_IPV6_MIP6)
312 static void mip6_addr_swap(struct sk_buff *skb, const struct inet6_skb_parm *opt)
314 struct ipv6hdr *iph = ipv6_hdr(skb);
315 struct ipv6_destopt_hao *hao;
320 off = ipv6_find_tlv(skb, opt->dsthao, IPV6_TLV_HAO);
321 if (likely(off >= 0)) {
322 hao = (struct ipv6_destopt_hao *)
323 (skb_network_header(skb) + off);
325 iph->saddr = hao->addr;
331 static inline void mip6_addr_swap(struct sk_buff *skb, const struct inet6_skb_parm *opt) {}
334 static struct dst_entry *icmpv6_route_lookup(struct net *net,
339 struct dst_entry *dst, *dst2;
343 err = ip6_dst_lookup(net, sk, &dst, fl6);
348 * We won't send icmp if the destination is known
351 if (ipv6_anycast_destination(dst, &fl6->daddr)) {
352 net_dbg_ratelimited("icmp6_send: acast source\n");
354 return ERR_PTR(-EINVAL);
357 /* No need to clone since we're just using its address. */
360 dst = xfrm_lookup(net, dst, flowi6_to_flowi(fl6), sk, 0);
365 if (PTR_ERR(dst) == -EPERM)
371 err = xfrm_decode_session_reverse(skb, flowi6_to_flowi(&fl2), AF_INET6);
373 goto relookup_failed;
375 err = ip6_dst_lookup(net, sk, &dst2, &fl2);
377 goto relookup_failed;
379 dst2 = xfrm_lookup(net, dst2, flowi6_to_flowi(&fl2), sk, XFRM_LOOKUP_ICMP);
389 goto relookup_failed;
398 static int icmp6_iif(const struct sk_buff *skb)
400 int iif = skb->dev->ifindex;
402 /* for local traffic to local address, skb dev is the loopback
403 * device. Check if there is a dst attached to the skb and if so
404 * get the real device index. Same is needed for replies to a link
405 * local address on a device enslaved to an L3 master device
407 if (unlikely(iif == LOOPBACK_IFINDEX || netif_is_l3_master(skb->dev))) {
408 const struct rt6_info *rt6 = skb_rt6_info(skb);
411 iif = rt6->rt6i_idev->dev->ifindex;
418 * Send an ICMP message in response to a packet in error
420 void icmp6_send(struct sk_buff *skb, u8 type, u8 code, __u32 info,
421 const struct in6_addr *force_saddr,
422 const struct inet6_skb_parm *parm)
424 struct inet6_dev *idev = NULL;
425 struct ipv6hdr *hdr = ipv6_hdr(skb);
428 struct ipv6_pinfo *np;
429 const struct in6_addr *saddr = NULL;
430 struct dst_entry *dst;
431 struct icmp6hdr tmp_hdr;
433 struct icmpv6_msg msg;
434 struct ipcm6_cookie ipc6;
440 if ((u8 *)hdr < skb->head ||
441 (skb_network_header(skb) + sizeof(*hdr)) > skb_tail_pointer(skb))
446 net = dev_net(skb->dev);
447 mark = IP6_REPLY_MARK(net, skb->mark);
449 * Make sure we respect the rules
450 * i.e. RFC 1885 2.4(e)
451 * Rule (e.1) is enforced by not using icmp6_send
452 * in any code that processes icmp errors.
454 addr_type = ipv6_addr_type(&hdr->daddr);
456 if (ipv6_chk_addr(net, &hdr->daddr, skb->dev, 0) ||
457 ipv6_chk_acast_addr_src(net, skb->dev, &hdr->daddr))
464 if (addr_type & IPV6_ADDR_MULTICAST || skb->pkt_type != PACKET_HOST) {
465 if (type != ICMPV6_PKT_TOOBIG &&
466 !(type == ICMPV6_PARAMPROB &&
467 code == ICMPV6_UNK_OPTION &&
468 (opt_unrec(skb, info))))
474 addr_type = ipv6_addr_type(&hdr->saddr);
480 if (__ipv6_addr_needs_scope_id(addr_type)) {
481 iif = icmp6_iif(skb);
484 iif = l3mdev_master_ifindex(dst ? dst->dev : skb->dev);
488 * Must not send error if the source does not uniquely
489 * identify a single node (RFC2463 Section 2.4).
490 * We check unspecified / multicast addresses here,
491 * and anycast addresses will be checked later.
493 if ((addr_type == IPV6_ADDR_ANY) || (addr_type & IPV6_ADDR_MULTICAST)) {
494 net_dbg_ratelimited("icmp6_send: addr_any/mcast source [%pI6c > %pI6c]\n",
495 &hdr->saddr, &hdr->daddr);
500 * Never answer to a ICMP packet.
502 if (is_ineligible(skb)) {
503 net_dbg_ratelimited("icmp6_send: no reply to icmp error [%pI6c > %pI6c]\n",
504 &hdr->saddr, &hdr->daddr);
508 /* Needed by both icmp_global_allow and icmpv6_xmit_lock */
511 /* Check global sysctl_icmp_msgs_per_sec ratelimit */
512 if (!(skb->dev->flags&IFF_LOOPBACK) && !icmpv6_global_allow(type))
515 mip6_addr_swap(skb, parm);
517 memset(&fl6, 0, sizeof(fl6));
518 fl6.flowi6_proto = IPPROTO_ICMPV6;
519 fl6.daddr = hdr->saddr;
524 fl6.flowi6_mark = mark;
525 fl6.flowi6_oif = iif;
526 fl6.fl6_icmp_type = type;
527 fl6.fl6_icmp_code = code;
528 fl6.flowi6_uid = sock_net_uid(net, NULL);
529 fl6.mp_hash = rt6_multipath_hash(net, &fl6, skb, NULL);
530 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
532 sk = icmpv6_xmit_lock(net);
539 if (!icmpv6_xrlim_allow(sk, type, &fl6))
542 tmp_hdr.icmp6_type = type;
543 tmp_hdr.icmp6_code = code;
544 tmp_hdr.icmp6_cksum = 0;
545 tmp_hdr.icmp6_pointer = htonl(info);
547 if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
548 fl6.flowi6_oif = np->mcast_oif;
549 else if (!fl6.flowi6_oif)
550 fl6.flowi6_oif = np->ucast_oif;
552 ipcm6_init_sk(&ipc6, np);
553 fl6.flowlabel = ip6_make_flowinfo(ipc6.tclass, fl6.flowlabel);
555 dst = icmpv6_route_lookup(net, skb, sk, &fl6);
559 ipc6.hlimit = ip6_sk_dst_hoplimit(np, &fl6, dst);
562 msg.offset = skb_network_offset(skb);
565 len = skb->len - msg.offset;
566 len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) - sizeof(struct icmp6hdr));
568 net_dbg_ratelimited("icmp: len problem [%pI6c > %pI6c]\n",
569 &hdr->saddr, &hdr->daddr);
570 goto out_dst_release;
574 idev = __in6_dev_get(skb->dev);
576 if (ip6_append_data(sk, icmpv6_getfrag, &msg,
577 len + sizeof(struct icmp6hdr),
578 sizeof(struct icmp6hdr),
579 &ipc6, &fl6, (struct rt6_info *)dst,
581 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTERRORS);
582 ip6_flush_pending_frames(sk);
584 icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
585 len + sizeof(struct icmp6hdr));
591 icmpv6_xmit_unlock(sk);
595 EXPORT_SYMBOL(icmp6_send);
597 /* Slightly more convenient version of icmp6_send.
599 void icmpv6_param_prob(struct sk_buff *skb, u8 code, int pos)
601 icmp6_send(skb, ICMPV6_PARAMPROB, code, pos, NULL, IP6CB(skb));
605 /* Generate icmpv6 with type/code ICMPV6_DEST_UNREACH/ICMPV6_ADDR_UNREACH
606 * if sufficient data bytes are available
607 * @nhs is the size of the tunnel header(s) :
608 * Either an IPv4 header for SIT encap
609 * an IPv4 header + GRE header for GRE encap
611 int ip6_err_gen_icmpv6_unreach(struct sk_buff *skb, int nhs, int type,
612 unsigned int data_len)
614 struct in6_addr temp_saddr;
616 struct sk_buff *skb2;
619 if (!pskb_may_pull(skb, nhs + sizeof(struct ipv6hdr) + 8))
622 /* RFC 4884 (partial) support for ICMP extensions */
623 if (data_len < 128 || (data_len & 7) || skb->len < data_len)
626 skb2 = data_len ? skb_copy(skb, GFP_ATOMIC) : skb_clone(skb, GFP_ATOMIC);
633 skb_reset_network_header(skb2);
635 rt = rt6_lookup(dev_net(skb->dev), &ipv6_hdr(skb2)->saddr, NULL, 0,
638 if (rt && rt->dst.dev)
639 skb2->dev = rt->dst.dev;
641 ipv6_addr_set_v4mapped(ip_hdr(skb)->saddr, &temp_saddr);
644 /* RFC 4884 (partial) support :
645 * insert 0 padding at the end, before the extensions
647 __skb_push(skb2, nhs);
648 skb_reset_network_header(skb2);
649 memmove(skb2->data, skb2->data + nhs, data_len - nhs);
650 memset(skb2->data + data_len - nhs, 0, nhs);
651 /* RFC 4884 4.5 : Length is measured in 64-bit words,
652 * and stored in reserved[0]
654 info = (data_len/8) << 24;
656 if (type == ICMP_TIME_EXCEEDED)
657 icmp6_send(skb2, ICMPV6_TIME_EXCEED, ICMPV6_EXC_HOPLIMIT,
658 info, &temp_saddr, IP6CB(skb2));
660 icmp6_send(skb2, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH,
661 info, &temp_saddr, IP6CB(skb2));
669 EXPORT_SYMBOL(ip6_err_gen_icmpv6_unreach);
671 static void icmpv6_echo_reply(struct sk_buff *skb)
673 struct net *net = dev_net(skb->dev);
675 struct inet6_dev *idev;
676 struct ipv6_pinfo *np;
677 const struct in6_addr *saddr = NULL;
678 struct icmp6hdr *icmph = icmp6_hdr(skb);
679 struct icmp6hdr tmp_hdr;
681 struct icmpv6_msg msg;
682 struct dst_entry *dst;
683 struct ipcm6_cookie ipc6;
684 u32 mark = IP6_REPLY_MARK(net, skb->mark);
686 saddr = &ipv6_hdr(skb)->daddr;
688 if (!ipv6_unicast_destination(skb) &&
689 !(net->ipv6.sysctl.anycast_src_echo_reply &&
690 ipv6_anycast_destination(skb_dst(skb), saddr)))
693 memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
694 tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;
696 memset(&fl6, 0, sizeof(fl6));
697 fl6.flowi6_proto = IPPROTO_ICMPV6;
698 fl6.daddr = ipv6_hdr(skb)->saddr;
701 fl6.flowi6_oif = icmp6_iif(skb);
702 fl6.fl6_icmp_type = ICMPV6_ECHO_REPLY;
703 fl6.flowi6_mark = mark;
704 fl6.flowi6_uid = sock_net_uid(net, NULL);
705 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
708 sk = icmpv6_xmit_lock(net);
714 if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
715 fl6.flowi6_oif = np->mcast_oif;
716 else if (!fl6.flowi6_oif)
717 fl6.flowi6_oif = np->ucast_oif;
719 if (ip6_dst_lookup(net, sk, &dst, &fl6))
721 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), sk, 0);
725 idev = __in6_dev_get(skb->dev);
729 msg.type = ICMPV6_ECHO_REPLY;
731 ipcm6_init_sk(&ipc6, np);
732 ipc6.hlimit = ip6_sk_dst_hoplimit(np, &fl6, dst);
733 ipc6.tclass = ipv6_get_dsfield(ipv6_hdr(skb));
735 if (ip6_append_data(sk, icmpv6_getfrag, &msg,
736 skb->len + sizeof(struct icmp6hdr),
737 sizeof(struct icmp6hdr), &ipc6, &fl6,
738 (struct rt6_info *)dst, MSG_DONTWAIT)) {
739 __ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTERRORS);
740 ip6_flush_pending_frames(sk);
742 icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
743 skb->len + sizeof(struct icmp6hdr));
747 icmpv6_xmit_unlock(sk);
752 void icmpv6_notify(struct sk_buff *skb, u8 type, u8 code, __be32 info)
754 const struct inet6_protocol *ipprot;
758 struct net *net = dev_net(skb->dev);
760 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
763 nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
764 if (ipv6_ext_hdr(nexthdr)) {
765 /* now skip over extension headers */
766 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr),
767 &nexthdr, &frag_off);
768 if (inner_offset < 0)
771 inner_offset = sizeof(struct ipv6hdr);
774 /* Checkin header including 8 bytes of inner protocol header. */
775 if (!pskb_may_pull(skb, inner_offset+8))
778 /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
779 Without this we will not able f.e. to make source routed
781 Corresponding argument (opt) to notifiers is already added.
785 ipprot = rcu_dereference(inet6_protos[nexthdr]);
786 if (ipprot && ipprot->err_handler)
787 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
789 raw6_icmp_error(skb, nexthdr, type, code, inner_offset, info);
793 __ICMP6_INC_STATS(net, __in6_dev_get(skb->dev), ICMP6_MIB_INERRORS);
797 * Handle icmp messages
800 static int icmpv6_rcv(struct sk_buff *skb)
802 struct net *net = dev_net(skb->dev);
803 struct net_device *dev = skb->dev;
804 struct inet6_dev *idev = __in6_dev_get(dev);
805 const struct in6_addr *saddr, *daddr;
806 struct icmp6hdr *hdr;
808 bool success = false;
810 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
811 struct sec_path *sp = skb_sec_path(skb);
814 if (!(sp && sp->xvec[sp->len - 1]->props.flags &
818 if (!pskb_may_pull(skb, sizeof(*hdr) + sizeof(struct ipv6hdr)))
821 nh = skb_network_offset(skb);
822 skb_set_network_header(skb, sizeof(*hdr));
824 if (!xfrm6_policy_check_reverse(NULL, XFRM_POLICY_IN, skb))
827 skb_set_network_header(skb, nh);
830 __ICMP6_INC_STATS(dev_net(dev), idev, ICMP6_MIB_INMSGS);
832 saddr = &ipv6_hdr(skb)->saddr;
833 daddr = &ipv6_hdr(skb)->daddr;
835 if (skb_checksum_validate(skb, IPPROTO_ICMPV6, ip6_compute_pseudo)) {
836 net_dbg_ratelimited("ICMPv6 checksum failed [%pI6c > %pI6c]\n",
841 if (!pskb_pull(skb, sizeof(*hdr)))
844 hdr = icmp6_hdr(skb);
846 type = hdr->icmp6_type;
848 ICMP6MSGIN_INC_STATS(dev_net(dev), idev, type);
851 case ICMPV6_ECHO_REQUEST:
852 if (!net->ipv6.sysctl.icmpv6_echo_ignore_all)
853 icmpv6_echo_reply(skb);
856 case ICMPV6_ECHO_REPLY:
857 success = ping_rcv(skb);
860 case ICMPV6_PKT_TOOBIG:
861 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
862 standard destination cache. Seems, only "advanced"
863 destination cache will allow to solve this problem
866 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
868 hdr = icmp6_hdr(skb);
872 case ICMPV6_DEST_UNREACH:
873 case ICMPV6_TIME_EXCEED:
874 case ICMPV6_PARAMPROB:
875 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
878 case NDISC_ROUTER_SOLICITATION:
879 case NDISC_ROUTER_ADVERTISEMENT:
880 case NDISC_NEIGHBOUR_SOLICITATION:
881 case NDISC_NEIGHBOUR_ADVERTISEMENT:
886 case ICMPV6_MGM_QUERY:
887 igmp6_event_query(skb);
890 case ICMPV6_MGM_REPORT:
891 igmp6_event_report(skb);
894 case ICMPV6_MGM_REDUCTION:
895 case ICMPV6_NI_QUERY:
896 case ICMPV6_NI_REPLY:
897 case ICMPV6_MLD2_REPORT:
898 case ICMPV6_DHAAD_REQUEST:
899 case ICMPV6_DHAAD_REPLY:
900 case ICMPV6_MOBILE_PREFIX_SOL:
901 case ICMPV6_MOBILE_PREFIX_ADV:
906 if (type & ICMPV6_INFOMSG_MASK)
909 net_dbg_ratelimited("icmpv6: msg of unknown type [%pI6c > %pI6c]\n",
913 * error of unknown type.
914 * must pass to upper level
917 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
920 /* until the v6 path can be better sorted assume failure and
921 * preserve the status quo behaviour for the rest of the paths to here
931 __ICMP6_INC_STATS(dev_net(dev), idev, ICMP6_MIB_CSUMERRORS);
933 __ICMP6_INC_STATS(dev_net(dev), idev, ICMP6_MIB_INERRORS);
939 void icmpv6_flow_init(struct sock *sk, struct flowi6 *fl6,
941 const struct in6_addr *saddr,
942 const struct in6_addr *daddr,
945 memset(fl6, 0, sizeof(*fl6));
948 fl6->flowi6_proto = IPPROTO_ICMPV6;
949 fl6->fl6_icmp_type = type;
950 fl6->fl6_icmp_code = 0;
951 fl6->flowi6_oif = oif;
952 security_sk_classify_flow(sk, flowi6_to_flowi(fl6));
955 static int __net_init icmpv6_sk_init(struct net *net)
961 kcalloc(nr_cpu_ids, sizeof(struct sock *), GFP_KERNEL);
962 if (!net->ipv6.icmp_sk)
965 for_each_possible_cpu(i) {
966 err = inet_ctl_sock_create(&sk, PF_INET6,
967 SOCK_RAW, IPPROTO_ICMPV6, net);
969 pr_err("Failed to initialize the ICMP6 control socket (err %d)\n",
974 net->ipv6.icmp_sk[i] = sk;
976 /* Enough space for 2 64K ICMP packets, including
977 * sk_buff struct overhead.
979 sk->sk_sndbuf = 2 * SKB_TRUESIZE(64 * 1024);
984 for (j = 0; j < i; j++)
985 inet_ctl_sock_destroy(net->ipv6.icmp_sk[j]);
986 kfree(net->ipv6.icmp_sk);
990 static void __net_exit icmpv6_sk_exit(struct net *net)
994 for_each_possible_cpu(i) {
995 inet_ctl_sock_destroy(net->ipv6.icmp_sk[i]);
997 kfree(net->ipv6.icmp_sk);
1000 static struct pernet_operations icmpv6_sk_ops = {
1001 .init = icmpv6_sk_init,
1002 .exit = icmpv6_sk_exit,
1005 int __init icmpv6_init(void)
1009 err = register_pernet_subsys(&icmpv6_sk_ops);
1014 if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0)
1017 err = inet6_register_icmp_sender(icmp6_send);
1019 goto sender_reg_err;
1023 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
1025 pr_err("Failed to register ICMP6 protocol\n");
1026 unregister_pernet_subsys(&icmpv6_sk_ops);
1030 void icmpv6_cleanup(void)
1032 inet6_unregister_icmp_sender(icmp6_send);
1033 unregister_pernet_subsys(&icmpv6_sk_ops);
1034 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
1038 static const struct icmp6_err {
1046 { /* ADM_PROHIBITED */
1050 { /* Was NOT_NEIGHBOUR, now reserved */
1051 .err = EHOSTUNREACH,
1054 { /* ADDR_UNREACH */
1055 .err = EHOSTUNREACH,
1058 { /* PORT_UNREACH */
1059 .err = ECONNREFUSED,
1066 { /* REJECT_ROUTE */
1072 int icmpv6_err_convert(u8 type, u8 code, int *err)
1079 case ICMPV6_DEST_UNREACH:
1081 if (code < ARRAY_SIZE(tab_unreach)) {
1082 *err = tab_unreach[code].err;
1083 fatal = tab_unreach[code].fatal;
1087 case ICMPV6_PKT_TOOBIG:
1091 case ICMPV6_PARAMPROB:
1096 case ICMPV6_TIME_EXCEED:
1097 *err = EHOSTUNREACH;
1103 EXPORT_SYMBOL(icmpv6_err_convert);
1105 #ifdef CONFIG_SYSCTL
1106 static struct ctl_table ipv6_icmp_table_template[] = {
1108 .procname = "ratelimit",
1109 .data = &init_net.ipv6.sysctl.icmpv6_time,
1110 .maxlen = sizeof(int),
1112 .proc_handler = proc_dointvec_ms_jiffies,
1115 .procname = "echo_ignore_all",
1116 .data = &init_net.ipv6.sysctl.icmpv6_echo_ignore_all,
1117 .maxlen = sizeof(int),
1119 .proc_handler = proc_dointvec,
1124 struct ctl_table * __net_init ipv6_icmp_sysctl_init(struct net *net)
1126 struct ctl_table *table;
1128 table = kmemdup(ipv6_icmp_table_template,
1129 sizeof(ipv6_icmp_table_template),
1133 table[0].data = &net->ipv6.sysctl.icmpv6_time;
1134 table[1].data = &net->ipv6.sysctl.icmpv6_echo_ignore_all;