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, 0, 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 int icmpv6_push_pending_frames(struct sock *sk, struct flowi6 *fl6,
254 struct icmp6hdr *thdr, int len)
257 struct icmp6hdr *icmp6h;
260 skb = skb_peek(&sk->sk_write_queue);
264 icmp6h = icmp6_hdr(skb);
265 memcpy(icmp6h, thdr, sizeof(struct icmp6hdr));
266 icmp6h->icmp6_cksum = 0;
268 if (skb_queue_len(&sk->sk_write_queue) == 1) {
269 skb->csum = csum_partial(icmp6h,
270 sizeof(struct icmp6hdr), skb->csum);
271 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
273 len, fl6->flowi6_proto,
278 skb_queue_walk(&sk->sk_write_queue, skb) {
279 tmp_csum = csum_add(tmp_csum, skb->csum);
282 tmp_csum = csum_partial(icmp6h,
283 sizeof(struct icmp6hdr), tmp_csum);
284 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
286 len, fl6->flowi6_proto,
289 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 int icmp6_iif(const struct sk_buff *skb)
403 int iif = skb->dev->ifindex;
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(iif == LOOPBACK_IFINDEX || netif_is_l3_master(skb->dev))) {
411 const struct rt6_info *rt6 = skb_rt6_info(skb);
414 iif = rt6->rt6i_idev->dev->ifindex;
421 * Send an ICMP message in response to a packet in error
423 void icmp6_send(struct sk_buff *skb, u8 type, u8 code, __u32 info,
424 const struct in6_addr *force_saddr,
425 const struct inet6_skb_parm *parm)
427 struct net *net = dev_net(skb->dev);
428 struct inet6_dev *idev = NULL;
429 struct ipv6hdr *hdr = ipv6_hdr(skb);
431 struct ipv6_pinfo *np;
432 const struct in6_addr *saddr = NULL;
433 struct dst_entry *dst;
434 struct icmp6hdr tmp_hdr;
436 struct icmpv6_msg msg;
437 struct sockcm_cookie sockc_unused = {0};
438 struct ipcm6_cookie ipc6;
443 u32 mark = IP6_REPLY_MARK(net, skb->mark);
445 if ((u8 *)hdr < skb->head ||
446 (skb_network_header(skb) + sizeof(*hdr)) > skb_tail_pointer(skb))
450 * Make sure we respect the rules
451 * i.e. RFC 1885 2.4(e)
452 * Rule (e.1) is enforced by not using icmp6_send
453 * in any code that processes icmp errors.
455 addr_type = ipv6_addr_type(&hdr->daddr);
457 if (ipv6_chk_addr(net, &hdr->daddr, skb->dev, 0) ||
458 ipv6_chk_acast_addr_src(net, skb->dev, &hdr->daddr))
465 if (addr_type & IPV6_ADDR_MULTICAST || skb->pkt_type != PACKET_HOST) {
466 if (type != ICMPV6_PKT_TOOBIG &&
467 !(type == ICMPV6_PARAMPROB &&
468 code == ICMPV6_UNK_OPTION &&
469 (opt_unrec(skb, info))))
475 addr_type = ipv6_addr_type(&hdr->saddr);
481 if (__ipv6_addr_needs_scope_id(addr_type)) {
482 iif = icmp6_iif(skb);
485 iif = l3mdev_master_ifindex(dst ? dst->dev : skb->dev);
489 * Must not send error if the source does not uniquely
490 * identify a single node (RFC2463 Section 2.4).
491 * We check unspecified / multicast addresses here,
492 * and anycast addresses will be checked later.
494 if ((addr_type == IPV6_ADDR_ANY) || (addr_type & IPV6_ADDR_MULTICAST)) {
495 net_dbg_ratelimited("icmp6_send: addr_any/mcast source [%pI6c > %pI6c]\n",
496 &hdr->saddr, &hdr->daddr);
501 * Never answer to a ICMP packet.
503 if (is_ineligible(skb)) {
504 net_dbg_ratelimited("icmp6_send: no reply to icmp error [%pI6c > %pI6c]\n",
505 &hdr->saddr, &hdr->daddr);
509 /* Needed by both icmp_global_allow and icmpv6_xmit_lock */
512 /* Check global sysctl_icmp_msgs_per_sec ratelimit */
513 if (!(skb->dev->flags&IFF_LOOPBACK) && !icmpv6_global_allow(type))
516 mip6_addr_swap(skb, parm);
518 memset(&fl6, 0, sizeof(fl6));
519 fl6.flowi6_proto = IPPROTO_ICMPV6;
520 fl6.daddr = hdr->saddr;
525 fl6.flowi6_mark = mark;
526 fl6.flowi6_oif = iif;
527 fl6.fl6_icmp_type = type;
528 fl6.fl6_icmp_code = code;
529 fl6.flowi6_uid = sock_net_uid(net, NULL);
530 fl6.mp_hash = rt6_multipath_hash(&fl6, skb);
531 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
533 sk = icmpv6_xmit_lock(net);
540 if (!icmpv6_xrlim_allow(sk, type, &fl6))
543 tmp_hdr.icmp6_type = type;
544 tmp_hdr.icmp6_code = code;
545 tmp_hdr.icmp6_cksum = 0;
546 tmp_hdr.icmp6_pointer = htonl(info);
548 if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
549 fl6.flowi6_oif = np->mcast_oif;
550 else if (!fl6.flowi6_oif)
551 fl6.flowi6_oif = np->ucast_oif;
553 ipc6.tclass = np->tclass;
554 fl6.flowlabel = ip6_make_flowinfo(ipc6.tclass, fl6.flowlabel);
556 dst = icmpv6_route_lookup(net, skb, sk, &fl6);
560 ipc6.hlimit = ip6_sk_dst_hoplimit(np, &fl6, dst);
561 ipc6.dontfrag = np->dontfrag;
565 msg.offset = skb_network_offset(skb);
568 len = skb->len - msg.offset;
569 len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) - sizeof(struct icmp6hdr));
571 net_dbg_ratelimited("icmp: len problem [%pI6c > %pI6c]\n",
572 &hdr->saddr, &hdr->daddr);
573 goto out_dst_release;
577 idev = __in6_dev_get(skb->dev);
579 err = ip6_append_data(sk, icmpv6_getfrag, &msg,
580 len + sizeof(struct icmp6hdr),
581 sizeof(struct icmp6hdr),
582 &ipc6, &fl6, (struct rt6_info *)dst,
583 MSG_DONTWAIT, &sockc_unused);
585 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTERRORS);
586 ip6_flush_pending_frames(sk);
588 err = icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
589 len + sizeof(struct icmp6hdr));
595 icmpv6_xmit_unlock(sk);
599 EXPORT_SYMBOL(icmp6_send);
601 /* Slightly more convenient version of icmp6_send.
603 void icmpv6_param_prob(struct sk_buff *skb, u8 code, int pos)
605 icmp6_send(skb, ICMPV6_PARAMPROB, code, pos, NULL, IP6CB(skb));
609 /* Generate icmpv6 with type/code ICMPV6_DEST_UNREACH/ICMPV6_ADDR_UNREACH
610 * if sufficient data bytes are available
611 * @nhs is the size of the tunnel header(s) :
612 * Either an IPv4 header for SIT encap
613 * an IPv4 header + GRE header for GRE encap
615 int ip6_err_gen_icmpv6_unreach(struct sk_buff *skb, int nhs, int type,
616 unsigned int data_len)
618 struct in6_addr temp_saddr;
620 struct sk_buff *skb2;
623 if (!pskb_may_pull(skb, nhs + sizeof(struct ipv6hdr) + 8))
626 /* RFC 4884 (partial) support for ICMP extensions */
627 if (data_len < 128 || (data_len & 7) || skb->len < data_len)
630 skb2 = data_len ? skb_copy(skb, GFP_ATOMIC) : skb_clone(skb, GFP_ATOMIC);
637 skb_reset_network_header(skb2);
639 rt = rt6_lookup(dev_net(skb->dev), &ipv6_hdr(skb2)->saddr, NULL, 0, 0);
641 if (rt && rt->dst.dev)
642 skb2->dev = rt->dst.dev;
644 ipv6_addr_set_v4mapped(ip_hdr(skb)->saddr, &temp_saddr);
647 /* RFC 4884 (partial) support :
648 * insert 0 padding at the end, before the extensions
650 __skb_push(skb2, nhs);
651 skb_reset_network_header(skb2);
652 memmove(skb2->data, skb2->data + nhs, data_len - nhs);
653 memset(skb2->data + data_len - nhs, 0, nhs);
654 /* RFC 4884 4.5 : Length is measured in 64-bit words,
655 * and stored in reserved[0]
657 info = (data_len/8) << 24;
659 if (type == ICMP_TIME_EXCEEDED)
660 icmp6_send(skb2, ICMPV6_TIME_EXCEED, ICMPV6_EXC_HOPLIMIT,
661 info, &temp_saddr, IP6CB(skb2));
663 icmp6_send(skb2, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH,
664 info, &temp_saddr, IP6CB(skb2));
672 EXPORT_SYMBOL(ip6_err_gen_icmpv6_unreach);
674 static void icmpv6_echo_reply(struct sk_buff *skb)
676 struct net *net = dev_net(skb->dev);
678 struct inet6_dev *idev;
679 struct ipv6_pinfo *np;
680 const struct in6_addr *saddr = NULL;
681 struct icmp6hdr *icmph = icmp6_hdr(skb);
682 struct icmp6hdr tmp_hdr;
684 struct icmpv6_msg msg;
685 struct dst_entry *dst;
686 struct ipcm6_cookie ipc6;
688 u32 mark = IP6_REPLY_MARK(net, skb->mark);
689 struct sockcm_cookie sockc_unused = {0};
691 saddr = &ipv6_hdr(skb)->daddr;
693 if (!ipv6_unicast_destination(skb) &&
694 !(net->ipv6.sysctl.anycast_src_echo_reply &&
695 ipv6_anycast_destination(skb_dst(skb), saddr)))
698 memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
699 tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;
701 memset(&fl6, 0, sizeof(fl6));
702 fl6.flowi6_proto = IPPROTO_ICMPV6;
703 fl6.daddr = ipv6_hdr(skb)->saddr;
706 fl6.flowi6_oif = icmp6_iif(skb);
707 fl6.fl6_icmp_type = ICMPV6_ECHO_REPLY;
708 fl6.flowi6_mark = mark;
709 fl6.flowi6_uid = sock_net_uid(net, NULL);
710 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
713 sk = icmpv6_xmit_lock(net);
719 if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
720 fl6.flowi6_oif = np->mcast_oif;
721 else if (!fl6.flowi6_oif)
722 fl6.flowi6_oif = np->ucast_oif;
724 err = ip6_dst_lookup(net, sk, &dst, &fl6);
727 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), sk, 0);
731 idev = __in6_dev_get(skb->dev);
735 msg.type = ICMPV6_ECHO_REPLY;
737 ipc6.hlimit = ip6_sk_dst_hoplimit(np, &fl6, dst);
738 ipc6.tclass = ipv6_get_dsfield(ipv6_hdr(skb));
739 ipc6.dontfrag = np->dontfrag;
742 err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
743 sizeof(struct icmp6hdr), &ipc6, &fl6,
744 (struct rt6_info *)dst, MSG_DONTWAIT,
748 __ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTERRORS);
749 ip6_flush_pending_frames(sk);
751 err = icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
752 skb->len + sizeof(struct icmp6hdr));
756 icmpv6_xmit_unlock(sk);
761 void icmpv6_notify(struct sk_buff *skb, u8 type, u8 code, __be32 info)
763 const struct inet6_protocol *ipprot;
767 struct net *net = dev_net(skb->dev);
769 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
772 nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
773 if (ipv6_ext_hdr(nexthdr)) {
774 /* now skip over extension headers */
775 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr),
776 &nexthdr, &frag_off);
777 if (inner_offset < 0)
780 inner_offset = sizeof(struct ipv6hdr);
783 /* Checkin header including 8 bytes of inner protocol header. */
784 if (!pskb_may_pull(skb, inner_offset+8))
787 /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
788 Without this we will not able f.e. to make source routed
790 Corresponding argument (opt) to notifiers is already added.
794 ipprot = rcu_dereference(inet6_protos[nexthdr]);
795 if (ipprot && ipprot->err_handler)
796 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
798 raw6_icmp_error(skb, nexthdr, type, code, inner_offset, info);
802 __ICMP6_INC_STATS(net, __in6_dev_get(skb->dev), ICMP6_MIB_INERRORS);
806 * Handle icmp messages
809 static int icmpv6_rcv(struct sk_buff *skb)
811 struct net_device *dev = skb->dev;
812 struct inet6_dev *idev = __in6_dev_get(dev);
813 const struct in6_addr *saddr, *daddr;
814 struct icmp6hdr *hdr;
816 bool success = false;
818 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
819 struct sec_path *sp = skb_sec_path(skb);
822 if (!(sp && sp->xvec[sp->len - 1]->props.flags &
826 if (!pskb_may_pull(skb, sizeof(*hdr) + sizeof(struct ipv6hdr)))
829 nh = skb_network_offset(skb);
830 skb_set_network_header(skb, sizeof(*hdr));
832 if (!xfrm6_policy_check_reverse(NULL, XFRM_POLICY_IN, skb))
835 skb_set_network_header(skb, nh);
838 __ICMP6_INC_STATS(dev_net(dev), idev, ICMP6_MIB_INMSGS);
840 saddr = &ipv6_hdr(skb)->saddr;
841 daddr = &ipv6_hdr(skb)->daddr;
843 if (skb_checksum_validate(skb, IPPROTO_ICMPV6, ip6_compute_pseudo)) {
844 net_dbg_ratelimited("ICMPv6 checksum failed [%pI6c > %pI6c]\n",
849 if (!pskb_pull(skb, sizeof(*hdr)))
852 hdr = icmp6_hdr(skb);
854 type = hdr->icmp6_type;
856 ICMP6MSGIN_INC_STATS(dev_net(dev), idev, type);
859 case ICMPV6_ECHO_REQUEST:
860 icmpv6_echo_reply(skb);
863 case ICMPV6_ECHO_REPLY:
864 success = ping_rcv(skb);
867 case ICMPV6_PKT_TOOBIG:
868 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
869 standard destination cache. Seems, only "advanced"
870 destination cache will allow to solve this problem
873 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
875 hdr = icmp6_hdr(skb);
878 * Drop through to notify
881 case ICMPV6_DEST_UNREACH:
882 case ICMPV6_TIME_EXCEED:
883 case ICMPV6_PARAMPROB:
884 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
887 case NDISC_ROUTER_SOLICITATION:
888 case NDISC_ROUTER_ADVERTISEMENT:
889 case NDISC_NEIGHBOUR_SOLICITATION:
890 case NDISC_NEIGHBOUR_ADVERTISEMENT:
895 case ICMPV6_MGM_QUERY:
896 igmp6_event_query(skb);
899 case ICMPV6_MGM_REPORT:
900 igmp6_event_report(skb);
903 case ICMPV6_MGM_REDUCTION:
904 case ICMPV6_NI_QUERY:
905 case ICMPV6_NI_REPLY:
906 case ICMPV6_MLD2_REPORT:
907 case ICMPV6_DHAAD_REQUEST:
908 case ICMPV6_DHAAD_REPLY:
909 case ICMPV6_MOBILE_PREFIX_SOL:
910 case ICMPV6_MOBILE_PREFIX_ADV:
915 if (type & ICMPV6_INFOMSG_MASK)
918 net_dbg_ratelimited("icmpv6: msg of unknown type [%pI6c > %pI6c]\n",
922 * error of unknown type.
923 * must pass to upper level
926 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
929 /* until the v6 path can be better sorted assume failure and
930 * preserve the status quo behaviour for the rest of the paths to here
940 __ICMP6_INC_STATS(dev_net(dev), idev, ICMP6_MIB_CSUMERRORS);
942 __ICMP6_INC_STATS(dev_net(dev), idev, ICMP6_MIB_INERRORS);
948 void icmpv6_flow_init(struct sock *sk, struct flowi6 *fl6,
950 const struct in6_addr *saddr,
951 const struct in6_addr *daddr,
954 memset(fl6, 0, sizeof(*fl6));
957 fl6->flowi6_proto = IPPROTO_ICMPV6;
958 fl6->fl6_icmp_type = type;
959 fl6->fl6_icmp_code = 0;
960 fl6->flowi6_oif = oif;
961 security_sk_classify_flow(sk, flowi6_to_flowi(fl6));
964 static int __net_init icmpv6_sk_init(struct net *net)
970 kzalloc(nr_cpu_ids * sizeof(struct sock *), GFP_KERNEL);
971 if (!net->ipv6.icmp_sk)
974 for_each_possible_cpu(i) {
975 err = inet_ctl_sock_create(&sk, PF_INET6,
976 SOCK_RAW, IPPROTO_ICMPV6, net);
978 pr_err("Failed to initialize the ICMP6 control socket (err %d)\n",
983 net->ipv6.icmp_sk[i] = sk;
985 /* Enough space for 2 64K ICMP packets, including
986 * sk_buff struct overhead.
988 sk->sk_sndbuf = 2 * SKB_TRUESIZE(64 * 1024);
993 for (j = 0; j < i; j++)
994 inet_ctl_sock_destroy(net->ipv6.icmp_sk[j]);
995 kfree(net->ipv6.icmp_sk);
999 static void __net_exit icmpv6_sk_exit(struct net *net)
1003 for_each_possible_cpu(i) {
1004 inet_ctl_sock_destroy(net->ipv6.icmp_sk[i]);
1006 kfree(net->ipv6.icmp_sk);
1009 static struct pernet_operations icmpv6_sk_ops = {
1010 .init = icmpv6_sk_init,
1011 .exit = icmpv6_sk_exit,
1014 int __init icmpv6_init(void)
1018 err = register_pernet_subsys(&icmpv6_sk_ops);
1023 if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0)
1026 err = inet6_register_icmp_sender(icmp6_send);
1028 goto sender_reg_err;
1032 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
1034 pr_err("Failed to register ICMP6 protocol\n");
1035 unregister_pernet_subsys(&icmpv6_sk_ops);
1039 void icmpv6_cleanup(void)
1041 inet6_unregister_icmp_sender(icmp6_send);
1042 unregister_pernet_subsys(&icmpv6_sk_ops);
1043 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
1047 static const struct icmp6_err {
1055 { /* ADM_PROHIBITED */
1059 { /* Was NOT_NEIGHBOUR, now reserved */
1060 .err = EHOSTUNREACH,
1063 { /* ADDR_UNREACH */
1064 .err = EHOSTUNREACH,
1067 { /* PORT_UNREACH */
1068 .err = ECONNREFUSED,
1075 { /* REJECT_ROUTE */
1081 int icmpv6_err_convert(u8 type, u8 code, int *err)
1088 case ICMPV6_DEST_UNREACH:
1090 if (code < ARRAY_SIZE(tab_unreach)) {
1091 *err = tab_unreach[code].err;
1092 fatal = tab_unreach[code].fatal;
1096 case ICMPV6_PKT_TOOBIG:
1100 case ICMPV6_PARAMPROB:
1105 case ICMPV6_TIME_EXCEED:
1106 *err = EHOSTUNREACH;
1112 EXPORT_SYMBOL(icmpv6_err_convert);
1114 #ifdef CONFIG_SYSCTL
1115 static struct ctl_table ipv6_icmp_table_template[] = {
1117 .procname = "ratelimit",
1118 .data = &init_net.ipv6.sysctl.icmpv6_time,
1119 .maxlen = sizeof(int),
1121 .proc_handler = proc_dointvec_ms_jiffies,
1126 struct ctl_table * __net_init ipv6_icmp_sysctl_init(struct net *net)
1128 struct ctl_table *table;
1130 table = kmemdup(ipv6_icmp_table_template,
1131 sizeof(ipv6_icmp_table_template),
1135 table[0].data = &net->ipv6.sysctl.icmpv6_time;