1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Internet Control Message Protocol (ICMPv6)
4 * Linux INET6 implementation
7 * Pedro Roque <roque@di.fc.ul.pt>
9 * Based on net/ipv4/icmp.c
17 * Andi Kleen : exception handling
18 * Andi Kleen add rate limits. never reply to a icmp.
19 * add more length checks and other fixes.
20 * yoshfuji : ensure to sent parameter problem for
22 * YOSHIFUJI Hideaki @USAGI: added sysctl for icmp rate limit.
24 * YOSHIFUJI Hideaki @USAGI: Per-interface statistics support
25 * Kazunori MIYAZAWA @USAGI: change output process to use ip6_append_data
28 #define pr_fmt(fmt) "IPv6: " fmt
30 #include <linux/module.h>
31 #include <linux/errno.h>
32 #include <linux/types.h>
33 #include <linux/socket.h>
35 #include <linux/kernel.h>
36 #include <linux/sockios.h>
37 #include <linux/net.h>
38 #include <linux/skbuff.h>
39 #include <linux/init.h>
40 #include <linux/netfilter.h>
41 #include <linux/slab.h>
44 #include <linux/sysctl.h>
47 #include <linux/inet.h>
48 #include <linux/netdevice.h>
49 #include <linux/icmpv6.h>
55 #include <net/ip6_checksum.h>
57 #include <net/protocol.h>
59 #include <net/rawv6.h>
60 #include <net/transp_v6.h>
61 #include <net/ip6_route.h>
62 #include <net/addrconf.h>
65 #include <net/inet_common.h>
66 #include <net/dsfield.h>
67 #include <net/l3mdev.h>
69 #include <linux/uaccess.h>
72 * The ICMP socket(s). This is the most convenient way to flow control
73 * our ICMP output as well as maintain a clean interface throughout
74 * all layers. All Socketless IP sends will soon be gone.
76 * On SMP we have one ICMP socket per-cpu.
78 static struct sock *icmpv6_sk(struct net *net)
80 return this_cpu_read(*net->ipv6.icmp_sk);
83 static int icmpv6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
84 u8 type, u8 code, int offset, __be32 info)
86 /* icmpv6_notify checks 8 bytes can be pulled, icmp6hdr is 8 bytes */
87 struct icmp6hdr *icmp6 = (struct icmp6hdr *) (skb->data + offset);
88 struct net *net = dev_net(skb->dev);
90 if (type == ICMPV6_PKT_TOOBIG)
91 ip6_update_pmtu(skb, net, info, skb->dev->ifindex, 0, sock_net_uid(net, NULL));
92 else if (type == NDISC_REDIRECT)
93 ip6_redirect(skb, net, skb->dev->ifindex, 0,
94 sock_net_uid(net, NULL));
96 if (!(type & ICMPV6_INFOMSG_MASK))
97 if (icmp6->icmp6_type == ICMPV6_ECHO_REQUEST)
98 ping_err(skb, offset, ntohl(info));
103 static int icmpv6_rcv(struct sk_buff *skb);
105 static const struct inet6_protocol icmpv6_protocol = {
106 .handler = icmpv6_rcv,
107 .err_handler = icmpv6_err,
108 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
111 /* Called with BH disabled */
112 static __inline__ struct sock *icmpv6_xmit_lock(struct net *net)
117 if (unlikely(!spin_trylock(&sk->sk_lock.slock))) {
118 /* This can happen if the output path (f.e. SIT or
119 * ip6ip6 tunnel) signals dst_link_failure() for an
120 * outgoing ICMP6 packet.
127 static __inline__ void icmpv6_xmit_unlock(struct sock *sk)
129 spin_unlock(&sk->sk_lock.slock);
133 * Figure out, may we reply to this packet with icmp error.
135 * We do not reply, if:
136 * - it was icmp error message.
137 * - it is truncated, so that it is known, that protocol is ICMPV6
138 * (i.e. in the middle of some exthdr)
143 static bool is_ineligible(const struct sk_buff *skb)
145 int ptr = (u8 *)(ipv6_hdr(skb) + 1) - skb->data;
146 int len = skb->len - ptr;
147 __u8 nexthdr = ipv6_hdr(skb)->nexthdr;
153 ptr = ipv6_skip_exthdr(skb, ptr, &nexthdr, &frag_off);
156 if (nexthdr == IPPROTO_ICMPV6) {
158 tp = skb_header_pointer(skb,
159 ptr+offsetof(struct icmp6hdr, icmp6_type),
160 sizeof(_type), &_type);
162 /* Based on RFC 8200, Section 4.5 Fragment Header, return
163 * false if this is a fragment packet with no icmp header info.
165 if (!tp && frag_off != 0)
167 else if (!tp || !(*tp & ICMPV6_INFOMSG_MASK))
173 static bool icmpv6_mask_allow(struct net *net, int type)
175 if (type > ICMPV6_MSG_MAX)
178 /* Limit if icmp type is set in ratemask. */
179 if (!test_bit(type, net->ipv6.sysctl.icmpv6_ratemask))
185 static bool icmpv6_global_allow(struct net *net, int type)
187 if (icmpv6_mask_allow(net, type))
190 if (icmp_global_allow())
197 * Check the ICMP output rate limit
199 static bool icmpv6_xrlim_allow(struct sock *sk, u8 type,
202 struct net *net = sock_net(sk);
203 struct dst_entry *dst;
206 if (icmpv6_mask_allow(net, type))
210 * Look up the output route.
211 * XXX: perhaps the expire for routing entries cloned by
212 * this lookup should be more aggressive (not longer than timeout).
214 dst = ip6_route_output(net, sk, fl6);
216 IP6_INC_STATS(net, ip6_dst_idev(dst),
217 IPSTATS_MIB_OUTNOROUTES);
218 } else if (dst->dev && (dst->dev->flags&IFF_LOOPBACK)) {
221 struct rt6_info *rt = (struct rt6_info *)dst;
222 int tmo = net->ipv6.sysctl.icmpv6_time;
223 struct inet_peer *peer;
225 /* Give more bandwidth to wider prefixes. */
226 if (rt->rt6i_dst.plen < 128)
227 tmo >>= ((128 - rt->rt6i_dst.plen)>>5);
229 peer = inet_getpeer_v6(net->ipv6.peers, &fl6->daddr, 1);
230 res = inet_peer_xrlim_allow(peer, tmo);
239 * an inline helper for the "simple" if statement below
240 * checks if parameter problem report is caused by an
241 * unrecognized IPv6 option that has the Option Type
242 * highest-order two bits set to 10
245 static bool opt_unrec(struct sk_buff *skb, __u32 offset)
249 offset += skb_network_offset(skb);
250 op = skb_header_pointer(skb, offset, sizeof(_optval), &_optval);
253 return (*op & 0xC0) == 0x80;
256 void icmpv6_push_pending_frames(struct sock *sk, struct flowi6 *fl6,
257 struct icmp6hdr *thdr, int len)
260 struct icmp6hdr *icmp6h;
262 skb = skb_peek(&sk->sk_write_queue);
266 icmp6h = icmp6_hdr(skb);
267 memcpy(icmp6h, thdr, sizeof(struct icmp6hdr));
268 icmp6h->icmp6_cksum = 0;
270 if (skb_queue_len(&sk->sk_write_queue) == 1) {
271 skb->csum = csum_partial(icmp6h,
272 sizeof(struct icmp6hdr), skb->csum);
273 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
275 len, fl6->flowi6_proto,
280 skb_queue_walk(&sk->sk_write_queue, skb) {
281 tmp_csum = csum_add(tmp_csum, skb->csum);
284 tmp_csum = csum_partial(icmp6h,
285 sizeof(struct icmp6hdr), tmp_csum);
286 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
288 len, fl6->flowi6_proto,
291 ip6_push_pending_frames(sk);
300 static int icmpv6_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb)
302 struct icmpv6_msg *msg = (struct icmpv6_msg *) from;
303 struct sk_buff *org_skb = msg->skb;
306 csum = skb_copy_and_csum_bits(org_skb, msg->offset + offset,
308 skb->csum = csum_block_add(skb->csum, csum, odd);
309 if (!(msg->type & ICMPV6_INFOMSG_MASK))
310 nf_ct_attach(skb, org_skb);
314 #if IS_ENABLED(CONFIG_IPV6_MIP6)
315 static void mip6_addr_swap(struct sk_buff *skb, const struct inet6_skb_parm *opt)
317 struct ipv6hdr *iph = ipv6_hdr(skb);
318 struct ipv6_destopt_hao *hao;
323 off = ipv6_find_tlv(skb, opt->dsthao, IPV6_TLV_HAO);
324 if (likely(off >= 0)) {
325 hao = (struct ipv6_destopt_hao *)
326 (skb_network_header(skb) + off);
328 iph->saddr = hao->addr;
334 static inline void mip6_addr_swap(struct sk_buff *skb, const struct inet6_skb_parm *opt) {}
337 static struct dst_entry *icmpv6_route_lookup(struct net *net,
342 struct dst_entry *dst, *dst2;
346 err = ip6_dst_lookup(net, sk, &dst, fl6);
351 * We won't send icmp if the destination is known
354 if (ipv6_anycast_destination(dst, &fl6->daddr)) {
355 net_dbg_ratelimited("icmp6_send: acast source\n");
357 return ERR_PTR(-EINVAL);
360 /* No need to clone since we're just using its address. */
363 dst = xfrm_lookup(net, dst, flowi6_to_flowi(fl6), sk, 0);
368 if (PTR_ERR(dst) == -EPERM)
374 err = xfrm_decode_session_reverse(skb, flowi6_to_flowi(&fl2), AF_INET6);
376 goto relookup_failed;
378 err = ip6_dst_lookup(net, sk, &dst2, &fl2);
380 goto relookup_failed;
382 dst2 = xfrm_lookup(net, dst2, flowi6_to_flowi(&fl2), sk, XFRM_LOOKUP_ICMP);
392 goto relookup_failed;
401 static struct net_device *icmp6_dev(const struct sk_buff *skb)
403 struct net_device *dev = skb->dev;
405 /* for local traffic to local address, skb dev is the loopback
406 * device. Check if there is a dst attached to the skb and if so
407 * get the real device index. Same is needed for replies to a link
408 * local address on a device enslaved to an L3 master device
410 if (unlikely(dev->ifindex == LOOPBACK_IFINDEX || netif_is_l3_master(skb->dev))) {
411 const struct rt6_info *rt6 = skb_rt6_info(skb);
414 dev = rt6->rt6i_idev->dev;
420 static int icmp6_iif(const struct sk_buff *skb)
422 return icmp6_dev(skb)->ifindex;
426 * Send an ICMP message in response to a packet in error
428 void icmp6_send(struct sk_buff *skb, u8 type, u8 code, __u32 info,
429 const struct in6_addr *force_saddr,
430 const struct inet6_skb_parm *parm)
432 struct inet6_dev *idev = NULL;
433 struct ipv6hdr *hdr = ipv6_hdr(skb);
436 struct ipv6_pinfo *np;
437 const struct in6_addr *saddr = NULL;
438 struct dst_entry *dst;
439 struct icmp6hdr tmp_hdr;
441 struct icmpv6_msg msg;
442 struct ipcm6_cookie ipc6;
448 if ((u8 *)hdr < skb->head ||
449 (skb_network_header(skb) + sizeof(*hdr)) > skb_tail_pointer(skb))
454 net = dev_net(skb->dev);
455 mark = IP6_REPLY_MARK(net, skb->mark);
457 * Make sure we respect the rules
458 * i.e. RFC 1885 2.4(e)
459 * Rule (e.1) is enforced by not using icmp6_send
460 * in any code that processes icmp errors.
462 addr_type = ipv6_addr_type(&hdr->daddr);
464 if (ipv6_chk_addr(net, &hdr->daddr, skb->dev, 0) ||
465 ipv6_chk_acast_addr_src(net, skb->dev, &hdr->daddr))
472 if (addr_type & IPV6_ADDR_MULTICAST || skb->pkt_type != PACKET_HOST) {
473 if (type != ICMPV6_PKT_TOOBIG &&
474 !(type == ICMPV6_PARAMPROB &&
475 code == ICMPV6_UNK_OPTION &&
476 (opt_unrec(skb, info))))
482 addr_type = ipv6_addr_type(&hdr->saddr);
488 if (__ipv6_addr_needs_scope_id(addr_type)) {
489 iif = icmp6_iif(skb);
492 iif = l3mdev_master_ifindex(dst ? dst->dev : skb->dev);
496 * Must not send error if the source does not uniquely
497 * identify a single node (RFC2463 Section 2.4).
498 * We check unspecified / multicast addresses here,
499 * and anycast addresses will be checked later.
501 if ((addr_type == IPV6_ADDR_ANY) || (addr_type & IPV6_ADDR_MULTICAST)) {
502 net_dbg_ratelimited("icmp6_send: addr_any/mcast source [%pI6c > %pI6c]\n",
503 &hdr->saddr, &hdr->daddr);
508 * Never answer to a ICMP packet.
510 if (is_ineligible(skb)) {
511 net_dbg_ratelimited("icmp6_send: no reply to icmp error [%pI6c > %pI6c]\n",
512 &hdr->saddr, &hdr->daddr);
516 /* Needed by both icmp_global_allow and icmpv6_xmit_lock */
519 /* Check global sysctl_icmp_msgs_per_sec ratelimit */
520 if (!(skb->dev->flags & IFF_LOOPBACK) && !icmpv6_global_allow(net, type))
523 mip6_addr_swap(skb, parm);
525 memset(&fl6, 0, sizeof(fl6));
526 fl6.flowi6_proto = IPPROTO_ICMPV6;
527 fl6.daddr = hdr->saddr;
532 fl6.flowi6_mark = mark;
533 fl6.flowi6_oif = iif;
534 fl6.fl6_icmp_type = type;
535 fl6.fl6_icmp_code = code;
536 fl6.flowi6_uid = sock_net_uid(net, NULL);
537 fl6.mp_hash = rt6_multipath_hash(net, &fl6, skb, NULL);
538 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
540 sk = icmpv6_xmit_lock(net);
546 if (!icmpv6_xrlim_allow(sk, type, &fl6))
549 tmp_hdr.icmp6_type = type;
550 tmp_hdr.icmp6_code = code;
551 tmp_hdr.icmp6_cksum = 0;
552 tmp_hdr.icmp6_pointer = htonl(info);
554 if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
555 fl6.flowi6_oif = np->mcast_oif;
556 else if (!fl6.flowi6_oif)
557 fl6.flowi6_oif = np->ucast_oif;
559 ipcm6_init_sk(&ipc6, np);
560 ipc6.sockc.mark = mark;
561 fl6.flowlabel = ip6_make_flowinfo(ipc6.tclass, fl6.flowlabel);
563 dst = icmpv6_route_lookup(net, skb, sk, &fl6);
567 ipc6.hlimit = ip6_sk_dst_hoplimit(np, &fl6, dst);
570 msg.offset = skb_network_offset(skb);
573 len = skb->len - msg.offset;
574 len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) - sizeof(struct icmp6hdr));
576 net_dbg_ratelimited("icmp: len problem [%pI6c > %pI6c]\n",
577 &hdr->saddr, &hdr->daddr);
578 goto out_dst_release;
582 idev = __in6_dev_get(skb->dev);
584 if (ip6_append_data(sk, icmpv6_getfrag, &msg,
585 len + sizeof(struct icmp6hdr),
586 sizeof(struct icmp6hdr),
587 &ipc6, &fl6, (struct rt6_info *)dst,
589 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTERRORS);
590 ip6_flush_pending_frames(sk);
592 icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
593 len + sizeof(struct icmp6hdr));
599 icmpv6_xmit_unlock(sk);
603 EXPORT_SYMBOL(icmp6_send);
605 /* Slightly more convenient version of icmp6_send.
607 void icmpv6_param_prob(struct sk_buff *skb, u8 code, int pos)
609 icmp6_send(skb, ICMPV6_PARAMPROB, code, pos, NULL, IP6CB(skb));
613 /* Generate icmpv6 with type/code ICMPV6_DEST_UNREACH/ICMPV6_ADDR_UNREACH
614 * if sufficient data bytes are available
615 * @nhs is the size of the tunnel header(s) :
616 * Either an IPv4 header for SIT encap
617 * an IPv4 header + GRE header for GRE encap
619 int ip6_err_gen_icmpv6_unreach(struct sk_buff *skb, int nhs, int type,
620 unsigned int data_len)
622 struct in6_addr temp_saddr;
624 struct sk_buff *skb2;
627 if (!pskb_may_pull(skb, nhs + sizeof(struct ipv6hdr) + 8))
630 /* RFC 4884 (partial) support for ICMP extensions */
631 if (data_len < 128 || (data_len & 7) || skb->len < data_len)
634 skb2 = data_len ? skb_copy(skb, GFP_ATOMIC) : skb_clone(skb, GFP_ATOMIC);
641 skb_reset_network_header(skb2);
643 rt = rt6_lookup(dev_net(skb->dev), &ipv6_hdr(skb2)->saddr, NULL, 0,
646 if (rt && rt->dst.dev)
647 skb2->dev = rt->dst.dev;
649 ipv6_addr_set_v4mapped(ip_hdr(skb)->saddr, &temp_saddr);
652 /* RFC 4884 (partial) support :
653 * insert 0 padding at the end, before the extensions
655 __skb_push(skb2, nhs);
656 skb_reset_network_header(skb2);
657 memmove(skb2->data, skb2->data + nhs, data_len - nhs);
658 memset(skb2->data + data_len - nhs, 0, nhs);
659 /* RFC 4884 4.5 : Length is measured in 64-bit words,
660 * and stored in reserved[0]
662 info = (data_len/8) << 24;
664 if (type == ICMP_TIME_EXCEEDED)
665 icmp6_send(skb2, ICMPV6_TIME_EXCEED, ICMPV6_EXC_HOPLIMIT,
666 info, &temp_saddr, IP6CB(skb2));
668 icmp6_send(skb2, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH,
669 info, &temp_saddr, IP6CB(skb2));
677 EXPORT_SYMBOL(ip6_err_gen_icmpv6_unreach);
679 static void icmpv6_echo_reply(struct sk_buff *skb)
681 struct net *net = dev_net(skb->dev);
683 struct inet6_dev *idev;
684 struct ipv6_pinfo *np;
685 const struct in6_addr *saddr = NULL;
686 struct icmp6hdr *icmph = icmp6_hdr(skb);
687 struct icmp6hdr tmp_hdr;
689 struct icmpv6_msg msg;
690 struct dst_entry *dst;
691 struct ipcm6_cookie ipc6;
692 u32 mark = IP6_REPLY_MARK(net, skb->mark);
695 if (ipv6_addr_is_multicast(&ipv6_hdr(skb)->daddr) &&
696 net->ipv6.sysctl.icmpv6_echo_ignore_multicast)
699 saddr = &ipv6_hdr(skb)->daddr;
701 acast = ipv6_anycast_destination(skb_dst(skb), saddr);
702 if (acast && net->ipv6.sysctl.icmpv6_echo_ignore_anycast)
705 if (!ipv6_unicast_destination(skb) &&
706 !(net->ipv6.sysctl.anycast_src_echo_reply && acast))
709 memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
710 tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;
712 memset(&fl6, 0, sizeof(fl6));
713 if (net->ipv6.sysctl.flowlabel_reflect & FLOWLABEL_REFLECT_ICMPV6_ECHO_REPLIES)
714 fl6.flowlabel = ip6_flowlabel(ipv6_hdr(skb));
716 fl6.flowi6_proto = IPPROTO_ICMPV6;
717 fl6.daddr = ipv6_hdr(skb)->saddr;
720 fl6.flowi6_oif = icmp6_iif(skb);
721 fl6.fl6_icmp_type = ICMPV6_ECHO_REPLY;
722 fl6.flowi6_mark = mark;
723 fl6.flowi6_uid = sock_net_uid(net, NULL);
724 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
727 sk = icmpv6_xmit_lock(net);
732 if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
733 fl6.flowi6_oif = np->mcast_oif;
734 else if (!fl6.flowi6_oif)
735 fl6.flowi6_oif = np->ucast_oif;
737 if (ip6_dst_lookup(net, sk, &dst, &fl6))
739 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), sk, 0);
743 /* Check the ratelimit */
744 if ((!(skb->dev->flags & IFF_LOOPBACK) && !icmpv6_global_allow(net, ICMPV6_ECHO_REPLY)) ||
745 !icmpv6_xrlim_allow(sk, ICMPV6_ECHO_REPLY, &fl6))
746 goto out_dst_release;
748 idev = __in6_dev_get(skb->dev);
752 msg.type = ICMPV6_ECHO_REPLY;
754 ipcm6_init_sk(&ipc6, np);
755 ipc6.hlimit = ip6_sk_dst_hoplimit(np, &fl6, dst);
756 ipc6.tclass = ipv6_get_dsfield(ipv6_hdr(skb));
757 ipc6.sockc.mark = mark;
759 if (ip6_append_data(sk, icmpv6_getfrag, &msg,
760 skb->len + sizeof(struct icmp6hdr),
761 sizeof(struct icmp6hdr), &ipc6, &fl6,
762 (struct rt6_info *)dst, MSG_DONTWAIT)) {
763 __ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTERRORS);
764 ip6_flush_pending_frames(sk);
766 icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
767 skb->len + sizeof(struct icmp6hdr));
772 icmpv6_xmit_unlock(sk);
777 void icmpv6_notify(struct sk_buff *skb, u8 type, u8 code, __be32 info)
779 const struct inet6_protocol *ipprot;
783 struct net *net = dev_net(skb->dev);
785 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
788 nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
789 if (ipv6_ext_hdr(nexthdr)) {
790 /* now skip over extension headers */
791 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr),
792 &nexthdr, &frag_off);
793 if (inner_offset < 0)
796 inner_offset = sizeof(struct ipv6hdr);
799 /* Checkin header including 8 bytes of inner protocol header. */
800 if (!pskb_may_pull(skb, inner_offset+8))
803 /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
804 Without this we will not able f.e. to make source routed
806 Corresponding argument (opt) to notifiers is already added.
810 ipprot = rcu_dereference(inet6_protos[nexthdr]);
811 if (ipprot && ipprot->err_handler)
812 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
814 raw6_icmp_error(skb, nexthdr, type, code, inner_offset, info);
818 __ICMP6_INC_STATS(net, __in6_dev_get(skb->dev), ICMP6_MIB_INERRORS);
822 * Handle icmp messages
825 static int icmpv6_rcv(struct sk_buff *skb)
827 struct net *net = dev_net(skb->dev);
828 struct net_device *dev = icmp6_dev(skb);
829 struct inet6_dev *idev = __in6_dev_get(dev);
830 const struct in6_addr *saddr, *daddr;
831 struct icmp6hdr *hdr;
833 bool success = false;
835 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
836 struct sec_path *sp = skb_sec_path(skb);
839 if (!(sp && sp->xvec[sp->len - 1]->props.flags &
843 if (!pskb_may_pull(skb, sizeof(*hdr) + sizeof(struct ipv6hdr)))
846 nh = skb_network_offset(skb);
847 skb_set_network_header(skb, sizeof(*hdr));
849 if (!xfrm6_policy_check_reverse(NULL, XFRM_POLICY_IN, skb))
852 skb_set_network_header(skb, nh);
855 __ICMP6_INC_STATS(dev_net(dev), idev, ICMP6_MIB_INMSGS);
857 saddr = &ipv6_hdr(skb)->saddr;
858 daddr = &ipv6_hdr(skb)->daddr;
860 if (skb_checksum_validate(skb, IPPROTO_ICMPV6, ip6_compute_pseudo)) {
861 net_dbg_ratelimited("ICMPv6 checksum failed [%pI6c > %pI6c]\n",
866 if (!pskb_pull(skb, sizeof(*hdr)))
869 hdr = icmp6_hdr(skb);
871 type = hdr->icmp6_type;
873 ICMP6MSGIN_INC_STATS(dev_net(dev), idev, type);
876 case ICMPV6_ECHO_REQUEST:
877 if (!net->ipv6.sysctl.icmpv6_echo_ignore_all)
878 icmpv6_echo_reply(skb);
881 case ICMPV6_ECHO_REPLY:
882 success = ping_rcv(skb);
885 case ICMPV6_PKT_TOOBIG:
886 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
887 standard destination cache. Seems, only "advanced"
888 destination cache will allow to solve this problem
891 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
893 hdr = icmp6_hdr(skb);
897 case ICMPV6_DEST_UNREACH:
898 case ICMPV6_TIME_EXCEED:
899 case ICMPV6_PARAMPROB:
900 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
903 case NDISC_ROUTER_SOLICITATION:
904 case NDISC_ROUTER_ADVERTISEMENT:
905 case NDISC_NEIGHBOUR_SOLICITATION:
906 case NDISC_NEIGHBOUR_ADVERTISEMENT:
911 case ICMPV6_MGM_QUERY:
912 igmp6_event_query(skb);
915 case ICMPV6_MGM_REPORT:
916 igmp6_event_report(skb);
919 case ICMPV6_MGM_REDUCTION:
920 case ICMPV6_NI_QUERY:
921 case ICMPV6_NI_REPLY:
922 case ICMPV6_MLD2_REPORT:
923 case ICMPV6_DHAAD_REQUEST:
924 case ICMPV6_DHAAD_REPLY:
925 case ICMPV6_MOBILE_PREFIX_SOL:
926 case ICMPV6_MOBILE_PREFIX_ADV:
931 if (type & ICMPV6_INFOMSG_MASK)
934 net_dbg_ratelimited("icmpv6: msg of unknown type [%pI6c > %pI6c]\n",
938 * error of unknown type.
939 * must pass to upper level
942 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
945 /* until the v6 path can be better sorted assume failure and
946 * preserve the status quo behaviour for the rest of the paths to here
956 __ICMP6_INC_STATS(dev_net(dev), idev, ICMP6_MIB_CSUMERRORS);
958 __ICMP6_INC_STATS(dev_net(dev), idev, ICMP6_MIB_INERRORS);
964 void icmpv6_flow_init(struct sock *sk, struct flowi6 *fl6,
966 const struct in6_addr *saddr,
967 const struct in6_addr *daddr,
970 memset(fl6, 0, sizeof(*fl6));
973 fl6->flowi6_proto = IPPROTO_ICMPV6;
974 fl6->fl6_icmp_type = type;
975 fl6->fl6_icmp_code = 0;
976 fl6->flowi6_oif = oif;
977 security_sk_classify_flow(sk, flowi6_to_flowi(fl6));
980 static void __net_exit icmpv6_sk_exit(struct net *net)
984 for_each_possible_cpu(i)
985 inet_ctl_sock_destroy(*per_cpu_ptr(net->ipv6.icmp_sk, i));
986 free_percpu(net->ipv6.icmp_sk);
989 static int __net_init icmpv6_sk_init(struct net *net)
994 net->ipv6.icmp_sk = alloc_percpu(struct sock *);
995 if (!net->ipv6.icmp_sk)
998 for_each_possible_cpu(i) {
999 err = inet_ctl_sock_create(&sk, PF_INET6,
1000 SOCK_RAW, IPPROTO_ICMPV6, net);
1002 pr_err("Failed to initialize the ICMP6 control socket (err %d)\n",
1007 *per_cpu_ptr(net->ipv6.icmp_sk, i) = sk;
1009 /* Enough space for 2 64K ICMP packets, including
1010 * sk_buff struct overhead.
1012 sk->sk_sndbuf = 2 * SKB_TRUESIZE(64 * 1024);
1017 icmpv6_sk_exit(net);
1021 static struct pernet_operations icmpv6_sk_ops = {
1022 .init = icmpv6_sk_init,
1023 .exit = icmpv6_sk_exit,
1026 int __init icmpv6_init(void)
1030 err = register_pernet_subsys(&icmpv6_sk_ops);
1035 if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0)
1038 err = inet6_register_icmp_sender(icmp6_send);
1040 goto sender_reg_err;
1044 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
1046 pr_err("Failed to register ICMP6 protocol\n");
1047 unregister_pernet_subsys(&icmpv6_sk_ops);
1051 void icmpv6_cleanup(void)
1053 inet6_unregister_icmp_sender(icmp6_send);
1054 unregister_pernet_subsys(&icmpv6_sk_ops);
1055 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
1059 static const struct icmp6_err {
1067 { /* ADM_PROHIBITED */
1071 { /* Was NOT_NEIGHBOUR, now reserved */
1072 .err = EHOSTUNREACH,
1075 { /* ADDR_UNREACH */
1076 .err = EHOSTUNREACH,
1079 { /* PORT_UNREACH */
1080 .err = ECONNREFUSED,
1087 { /* REJECT_ROUTE */
1093 int icmpv6_err_convert(u8 type, u8 code, int *err)
1100 case ICMPV6_DEST_UNREACH:
1102 if (code < ARRAY_SIZE(tab_unreach)) {
1103 *err = tab_unreach[code].err;
1104 fatal = tab_unreach[code].fatal;
1108 case ICMPV6_PKT_TOOBIG:
1112 case ICMPV6_PARAMPROB:
1117 case ICMPV6_TIME_EXCEED:
1118 *err = EHOSTUNREACH;
1124 EXPORT_SYMBOL(icmpv6_err_convert);
1126 #ifdef CONFIG_SYSCTL
1127 static struct ctl_table ipv6_icmp_table_template[] = {
1129 .procname = "ratelimit",
1130 .data = &init_net.ipv6.sysctl.icmpv6_time,
1131 .maxlen = sizeof(int),
1133 .proc_handler = proc_dointvec_ms_jiffies,
1136 .procname = "echo_ignore_all",
1137 .data = &init_net.ipv6.sysctl.icmpv6_echo_ignore_all,
1138 .maxlen = sizeof(int),
1140 .proc_handler = proc_dointvec,
1143 .procname = "echo_ignore_multicast",
1144 .data = &init_net.ipv6.sysctl.icmpv6_echo_ignore_multicast,
1145 .maxlen = sizeof(int),
1147 .proc_handler = proc_dointvec,
1150 .procname = "echo_ignore_anycast",
1151 .data = &init_net.ipv6.sysctl.icmpv6_echo_ignore_anycast,
1152 .maxlen = sizeof(int),
1154 .proc_handler = proc_dointvec,
1157 .procname = "ratemask",
1158 .data = &init_net.ipv6.sysctl.icmpv6_ratemask_ptr,
1159 .maxlen = ICMPV6_MSG_MAX + 1,
1161 .proc_handler = proc_do_large_bitmap,
1166 struct ctl_table * __net_init ipv6_icmp_sysctl_init(struct net *net)
1168 struct ctl_table *table;
1170 table = kmemdup(ipv6_icmp_table_template,
1171 sizeof(ipv6_icmp_table_template),
1175 table[0].data = &net->ipv6.sysctl.icmpv6_time;
1176 table[1].data = &net->ipv6.sysctl.icmpv6_echo_ignore_all;
1177 table[2].data = &net->ipv6.sysctl.icmpv6_echo_ignore_multicast;
1178 table[3].data = &net->ipv6.sysctl.icmpv6_echo_ignore_anycast;
1179 table[4].data = &net->ipv6.sysctl.icmpv6_ratemask_ptr;