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 <asm/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 static __inline__ struct sock *icmpv6_xmit_lock(struct net *net)
120 if (unlikely(!spin_trylock(&sk->sk_lock.slock))) {
121 /* This can happen if the output path (f.e. SIT or
122 * ip6ip6 tunnel) signals dst_link_failure() for an
123 * outgoing ICMP6 packet.
131 static __inline__ void icmpv6_xmit_unlock(struct sock *sk)
133 spin_unlock_bh(&sk->sk_lock.slock);
137 * Figure out, may we reply to this packet with icmp error.
139 * We do not reply, if:
140 * - it was icmp error message.
141 * - it is truncated, so that it is known, that protocol is ICMPV6
142 * (i.e. in the middle of some exthdr)
147 static bool is_ineligible(const struct sk_buff *skb)
149 int ptr = (u8 *)(ipv6_hdr(skb) + 1) - skb->data;
150 int len = skb->len - ptr;
151 __u8 nexthdr = ipv6_hdr(skb)->nexthdr;
157 ptr = ipv6_skip_exthdr(skb, ptr, &nexthdr, &frag_off);
160 if (nexthdr == IPPROTO_ICMPV6) {
162 tp = skb_header_pointer(skb,
163 ptr+offsetof(struct icmp6hdr, icmp6_type),
164 sizeof(_type), &_type);
165 if (!tp || !(*tp & ICMPV6_INFOMSG_MASK))
172 * Check the ICMP output rate limit
174 static bool icmpv6_xrlim_allow(struct sock *sk, u8 type,
177 struct net *net = sock_net(sk);
178 struct dst_entry *dst;
181 /* Informational messages are not limited. */
182 if (type & ICMPV6_INFOMSG_MASK)
185 /* Do not limit pmtu discovery, it would break it. */
186 if (type == ICMPV6_PKT_TOOBIG)
190 * Look up the output route.
191 * XXX: perhaps the expire for routing entries cloned by
192 * this lookup should be more aggressive (not longer than timeout).
194 dst = ip6_route_output(net, sk, fl6);
196 IP6_INC_STATS(net, ip6_dst_idev(dst),
197 IPSTATS_MIB_OUTNOROUTES);
198 } else if (dst->dev && (dst->dev->flags&IFF_LOOPBACK)) {
201 struct rt6_info *rt = (struct rt6_info *)dst;
202 int tmo = net->ipv6.sysctl.icmpv6_time;
204 /* Give more bandwidth to wider prefixes. */
205 if (rt->rt6i_dst.plen < 128)
206 tmo >>= ((128 - rt->rt6i_dst.plen)>>5);
208 if (icmp_global_allow()) {
209 struct inet_peer *peer;
211 peer = inet_getpeer_v6(net->ipv6.peers,
213 res = inet_peer_xrlim_allow(peer, tmo);
223 * an inline helper for the "simple" if statement below
224 * checks if parameter problem report is caused by an
225 * unrecognized IPv6 option that has the Option Type
226 * highest-order two bits set to 10
229 static bool opt_unrec(struct sk_buff *skb, __u32 offset)
233 offset += skb_network_offset(skb);
234 op = skb_header_pointer(skb, offset, sizeof(_optval), &_optval);
237 return (*op & 0xC0) == 0x80;
240 int icmpv6_push_pending_frames(struct sock *sk, struct flowi6 *fl6,
241 struct icmp6hdr *thdr, int len)
244 struct icmp6hdr *icmp6h;
247 skb = skb_peek(&sk->sk_write_queue);
251 icmp6h = icmp6_hdr(skb);
252 memcpy(icmp6h, thdr, sizeof(struct icmp6hdr));
253 icmp6h->icmp6_cksum = 0;
255 if (skb_queue_len(&sk->sk_write_queue) == 1) {
256 skb->csum = csum_partial(icmp6h,
257 sizeof(struct icmp6hdr), skb->csum);
258 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
260 len, fl6->flowi6_proto,
265 skb_queue_walk(&sk->sk_write_queue, skb) {
266 tmp_csum = csum_add(tmp_csum, skb->csum);
269 tmp_csum = csum_partial(icmp6h,
270 sizeof(struct icmp6hdr), tmp_csum);
271 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
273 len, fl6->flowi6_proto,
276 ip6_push_pending_frames(sk);
287 static int icmpv6_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb)
289 struct icmpv6_msg *msg = (struct icmpv6_msg *) from;
290 struct sk_buff *org_skb = msg->skb;
293 csum = skb_copy_and_csum_bits(org_skb, msg->offset + offset,
295 skb->csum = csum_block_add(skb->csum, csum, odd);
296 if (!(msg->type & ICMPV6_INFOMSG_MASK))
297 nf_ct_attach(skb, org_skb);
301 #if IS_ENABLED(CONFIG_IPV6_MIP6)
302 static void mip6_addr_swap(struct sk_buff *skb)
304 struct ipv6hdr *iph = ipv6_hdr(skb);
305 struct inet6_skb_parm *opt = IP6CB(skb);
306 struct ipv6_destopt_hao *hao;
311 off = ipv6_find_tlv(skb, opt->dsthao, IPV6_TLV_HAO);
312 if (likely(off >= 0)) {
313 hao = (struct ipv6_destopt_hao *)
314 (skb_network_header(skb) + off);
316 iph->saddr = hao->addr;
322 static inline void mip6_addr_swap(struct sk_buff *skb) {}
325 static struct dst_entry *icmpv6_route_lookup(struct net *net,
330 struct dst_entry *dst, *dst2;
334 err = ip6_dst_lookup(net, sk, &dst, fl6);
339 * We won't send icmp if the destination is known
342 if (ipv6_anycast_destination(dst, &fl6->daddr)) {
343 net_dbg_ratelimited("icmp6_send: acast source\n");
345 return ERR_PTR(-EINVAL);
348 /* No need to clone since we're just using its address. */
351 dst = xfrm_lookup(net, dst, flowi6_to_flowi(fl6), sk, 0);
356 if (PTR_ERR(dst) == -EPERM)
362 err = xfrm_decode_session_reverse(skb, flowi6_to_flowi(&fl2), AF_INET6);
364 goto relookup_failed;
366 err = ip6_dst_lookup(net, sk, &dst2, &fl2);
368 goto relookup_failed;
370 dst2 = xfrm_lookup(net, dst2, flowi6_to_flowi(&fl2), sk, XFRM_LOOKUP_ICMP);
380 goto relookup_failed;
390 * Send an ICMP message in response to a packet in error
392 static void icmp6_send(struct sk_buff *skb, u8 type, u8 code, __u32 info)
394 struct net *net = dev_net(skb->dev);
395 struct inet6_dev *idev = NULL;
396 struct ipv6hdr *hdr = ipv6_hdr(skb);
398 struct ipv6_pinfo *np;
399 const struct in6_addr *saddr = NULL;
400 struct dst_entry *dst;
401 struct icmp6hdr tmp_hdr;
403 struct icmpv6_msg msg;
409 u32 mark = IP6_REPLY_MARK(net, skb->mark);
411 if ((u8 *)hdr < skb->head ||
412 (skb_network_header(skb) + sizeof(*hdr)) > skb_tail_pointer(skb))
416 * Make sure we respect the rules
417 * i.e. RFC 1885 2.4(e)
418 * Rule (e.1) is enforced by not using icmp6_send
419 * in any code that processes icmp errors.
421 addr_type = ipv6_addr_type(&hdr->daddr);
423 if (ipv6_chk_addr(net, &hdr->daddr, skb->dev, 0) ||
424 ipv6_chk_acast_addr_src(net, skb->dev, &hdr->daddr))
431 if (addr_type & IPV6_ADDR_MULTICAST || skb->pkt_type != PACKET_HOST) {
432 if (type != ICMPV6_PKT_TOOBIG &&
433 !(type == ICMPV6_PARAMPROB &&
434 code == ICMPV6_UNK_OPTION &&
435 (opt_unrec(skb, info))))
441 addr_type = ipv6_addr_type(&hdr->saddr);
447 if (__ipv6_addr_needs_scope_id(addr_type))
448 iif = skb->dev->ifindex;
451 * Must not send error if the source does not uniquely
452 * identify a single node (RFC2463 Section 2.4).
453 * We check unspecified / multicast addresses here,
454 * and anycast addresses will be checked later.
456 if ((addr_type == IPV6_ADDR_ANY) || (addr_type & IPV6_ADDR_MULTICAST)) {
457 net_dbg_ratelimited("icmp6_send: addr_any/mcast source [%pI6c > %pI6c]\n",
458 &hdr->saddr, &hdr->daddr);
463 * Never answer to a ICMP packet.
465 if (is_ineligible(skb)) {
466 net_dbg_ratelimited("icmp6_send: no reply to icmp error [%pI6c > %pI6c]\n",
467 &hdr->saddr, &hdr->daddr);
473 memset(&fl6, 0, sizeof(fl6));
474 fl6.flowi6_proto = IPPROTO_ICMPV6;
475 fl6.daddr = hdr->saddr;
478 fl6.flowi6_mark = mark;
479 fl6.flowi6_oif = iif;
480 fl6.fl6_icmp_type = type;
481 fl6.fl6_icmp_code = code;
482 fl6.flowi6_uid = sock_net_uid(net, NULL);
483 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
485 sk = icmpv6_xmit_lock(net);
491 if (!icmpv6_xrlim_allow(sk, type, &fl6))
494 tmp_hdr.icmp6_type = type;
495 tmp_hdr.icmp6_code = code;
496 tmp_hdr.icmp6_cksum = 0;
497 tmp_hdr.icmp6_pointer = htonl(info);
499 if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
500 fl6.flowi6_oif = np->mcast_oif;
501 else if (!fl6.flowi6_oif)
502 fl6.flowi6_oif = np->ucast_oif;
505 fl6.flowi6_oif = l3mdev_master_ifindex(skb->dev);
507 dst = icmpv6_route_lookup(net, skb, sk, &fl6);
511 hlimit = ip6_sk_dst_hoplimit(np, &fl6, dst);
514 msg.offset = skb_network_offset(skb);
517 len = skb->len - msg.offset;
518 len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) - sizeof(struct icmp6hdr));
520 net_dbg_ratelimited("icmp: len problem [%pI6c > %pI6c]\n",
521 &hdr->saddr, &hdr->daddr);
522 goto out_dst_release;
526 idev = __in6_dev_get(skb->dev);
528 err = ip6_append_data(sk, icmpv6_getfrag, &msg,
529 len + sizeof(struct icmp6hdr),
530 sizeof(struct icmp6hdr), hlimit,
531 np->tclass, NULL, &fl6, (struct rt6_info *)dst,
532 MSG_DONTWAIT, np->dontfrag);
534 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTERRORS);
535 ip6_flush_pending_frames(sk);
537 err = icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
538 len + sizeof(struct icmp6hdr));
544 icmpv6_xmit_unlock(sk);
547 /* Slightly more convenient version of icmp6_send.
549 void icmpv6_param_prob(struct sk_buff *skb, u8 code, int pos)
551 icmp6_send(skb, ICMPV6_PARAMPROB, code, pos);
555 static void icmpv6_echo_reply(struct sk_buff *skb)
557 struct net *net = dev_net(skb->dev);
559 struct inet6_dev *idev;
560 struct ipv6_pinfo *np;
561 const struct in6_addr *saddr = NULL;
562 struct icmp6hdr *icmph = icmp6_hdr(skb);
563 struct icmp6hdr tmp_hdr;
565 struct icmpv6_msg msg;
566 struct dst_entry *dst;
570 u32 mark = IP6_REPLY_MARK(net, skb->mark);
572 saddr = &ipv6_hdr(skb)->daddr;
574 if (!ipv6_unicast_destination(skb) &&
575 !(net->ipv6.sysctl.anycast_src_echo_reply &&
576 ipv6_anycast_destination(skb_dst(skb), saddr)))
579 memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
580 tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;
582 memset(&fl6, 0, sizeof(fl6));
583 fl6.flowi6_proto = IPPROTO_ICMPV6;
584 fl6.daddr = ipv6_hdr(skb)->saddr;
587 fl6.flowi6_oif = l3mdev_fib_oif(skb->dev);
588 fl6.fl6_icmp_type = ICMPV6_ECHO_REPLY;
589 fl6.flowi6_mark = mark;
590 fl6.flowi6_uid = sock_net_uid(net, NULL);
591 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
593 sk = icmpv6_xmit_lock(net);
599 if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
600 fl6.flowi6_oif = np->mcast_oif;
601 else if (!fl6.flowi6_oif)
602 fl6.flowi6_oif = np->ucast_oif;
604 err = ip6_dst_lookup(net, sk, &dst, &fl6);
607 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), sk, 0);
611 hlimit = ip6_sk_dst_hoplimit(np, &fl6, dst);
613 idev = __in6_dev_get(skb->dev);
617 msg.type = ICMPV6_ECHO_REPLY;
619 tclass = ipv6_get_dsfield(ipv6_hdr(skb));
620 err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
621 sizeof(struct icmp6hdr), hlimit, tclass, NULL, &fl6,
622 (struct rt6_info *)dst, MSG_DONTWAIT,
626 ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTERRORS);
627 ip6_flush_pending_frames(sk);
629 err = icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
630 skb->len + sizeof(struct icmp6hdr));
634 icmpv6_xmit_unlock(sk);
637 void icmpv6_notify(struct sk_buff *skb, u8 type, u8 code, __be32 info)
639 const struct inet6_protocol *ipprot;
643 struct net *net = dev_net(skb->dev);
645 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
648 nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
649 if (ipv6_ext_hdr(nexthdr)) {
650 /* now skip over extension headers */
651 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr),
652 &nexthdr, &frag_off);
653 if (inner_offset < 0)
656 inner_offset = sizeof(struct ipv6hdr);
659 /* Checkin header including 8 bytes of inner protocol header. */
660 if (!pskb_may_pull(skb, inner_offset+8))
663 /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
664 Without this we will not able f.e. to make source routed
666 Corresponding argument (opt) to notifiers is already added.
670 ipprot = rcu_dereference(inet6_protos[nexthdr]);
671 if (ipprot && ipprot->err_handler)
672 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
674 raw6_icmp_error(skb, nexthdr, type, code, inner_offset, info);
678 ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev), ICMP6_MIB_INERRORS);
682 * Handle icmp messages
685 static int icmpv6_rcv(struct sk_buff *skb)
687 struct net_device *dev = skb->dev;
688 struct inet6_dev *idev = __in6_dev_get(dev);
689 const struct in6_addr *saddr, *daddr;
690 struct icmp6hdr *hdr;
692 bool success = false;
694 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
695 struct sec_path *sp = skb_sec_path(skb);
698 if (!(sp && sp->xvec[sp->len - 1]->props.flags &
702 if (!pskb_may_pull(skb, sizeof(*hdr) + sizeof(struct ipv6hdr)))
705 nh = skb_network_offset(skb);
706 skb_set_network_header(skb, sizeof(*hdr));
708 if (!xfrm6_policy_check_reverse(NULL, XFRM_POLICY_IN, skb))
711 skb_set_network_header(skb, nh);
714 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INMSGS);
716 saddr = &ipv6_hdr(skb)->saddr;
717 daddr = &ipv6_hdr(skb)->daddr;
719 if (skb_checksum_validate(skb, IPPROTO_ICMPV6, ip6_compute_pseudo)) {
720 net_dbg_ratelimited("ICMPv6 checksum failed [%pI6c > %pI6c]\n",
725 if (!pskb_pull(skb, sizeof(*hdr)))
728 hdr = icmp6_hdr(skb);
730 type = hdr->icmp6_type;
732 ICMP6MSGIN_INC_STATS_BH(dev_net(dev), idev, type);
735 case ICMPV6_ECHO_REQUEST:
736 icmpv6_echo_reply(skb);
739 case ICMPV6_ECHO_REPLY:
740 success = ping_rcv(skb);
743 case ICMPV6_PKT_TOOBIG:
744 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
745 standard destination cache. Seems, only "advanced"
746 destination cache will allow to solve this problem
749 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
751 hdr = icmp6_hdr(skb);
754 * Drop through to notify
757 case ICMPV6_DEST_UNREACH:
758 case ICMPV6_TIME_EXCEED:
759 case ICMPV6_PARAMPROB:
760 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
763 case NDISC_ROUTER_SOLICITATION:
764 case NDISC_ROUTER_ADVERTISEMENT:
765 case NDISC_NEIGHBOUR_SOLICITATION:
766 case NDISC_NEIGHBOUR_ADVERTISEMENT:
771 case ICMPV6_MGM_QUERY:
772 igmp6_event_query(skb);
775 case ICMPV6_MGM_REPORT:
776 igmp6_event_report(skb);
779 case ICMPV6_MGM_REDUCTION:
780 case ICMPV6_NI_QUERY:
781 case ICMPV6_NI_REPLY:
782 case ICMPV6_MLD2_REPORT:
783 case ICMPV6_DHAAD_REQUEST:
784 case ICMPV6_DHAAD_REPLY:
785 case ICMPV6_MOBILE_PREFIX_SOL:
786 case ICMPV6_MOBILE_PREFIX_ADV:
791 if (type & ICMPV6_INFOMSG_MASK)
794 net_dbg_ratelimited("icmpv6: msg of unknown type [%pI6c > %pI6c]\n",
798 * error of unknown type.
799 * must pass to upper level
802 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
805 /* until the v6 path can be better sorted assume failure and
806 * preserve the status quo behaviour for the rest of the paths to here
816 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_CSUMERRORS);
818 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INERRORS);
824 void icmpv6_flow_init(struct sock *sk, struct flowi6 *fl6,
826 const struct in6_addr *saddr,
827 const struct in6_addr *daddr,
830 memset(fl6, 0, sizeof(*fl6));
833 fl6->flowi6_proto = IPPROTO_ICMPV6;
834 fl6->fl6_icmp_type = type;
835 fl6->fl6_icmp_code = 0;
836 fl6->flowi6_oif = oif;
837 security_sk_classify_flow(sk, flowi6_to_flowi(fl6));
840 static int __net_init icmpv6_sk_init(struct net *net)
846 kzalloc(nr_cpu_ids * sizeof(struct sock *), GFP_KERNEL);
847 if (!net->ipv6.icmp_sk)
850 for_each_possible_cpu(i) {
851 err = inet_ctl_sock_create(&sk, PF_INET6,
852 SOCK_RAW, IPPROTO_ICMPV6, net);
854 pr_err("Failed to initialize the ICMP6 control socket (err %d)\n",
859 net->ipv6.icmp_sk[i] = sk;
861 /* Enough space for 2 64K ICMP packets, including
862 * sk_buff struct overhead.
864 sk->sk_sndbuf = 2 * SKB_TRUESIZE(64 * 1024);
869 for (j = 0; j < i; j++)
870 inet_ctl_sock_destroy(net->ipv6.icmp_sk[j]);
871 kfree(net->ipv6.icmp_sk);
875 static void __net_exit icmpv6_sk_exit(struct net *net)
879 for_each_possible_cpu(i) {
880 inet_ctl_sock_destroy(net->ipv6.icmp_sk[i]);
882 kfree(net->ipv6.icmp_sk);
885 static struct pernet_operations icmpv6_sk_ops = {
886 .init = icmpv6_sk_init,
887 .exit = icmpv6_sk_exit,
890 int __init icmpv6_init(void)
894 err = register_pernet_subsys(&icmpv6_sk_ops);
899 if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0)
902 err = inet6_register_icmp_sender(icmp6_send);
908 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
910 pr_err("Failed to register ICMP6 protocol\n");
911 unregister_pernet_subsys(&icmpv6_sk_ops);
915 void icmpv6_cleanup(void)
917 inet6_unregister_icmp_sender(icmp6_send);
918 unregister_pernet_subsys(&icmpv6_sk_ops);
919 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
923 static const struct icmp6_err {
931 { /* ADM_PROHIBITED */
935 { /* Was NOT_NEIGHBOUR, now reserved */
957 int icmpv6_err_convert(u8 type, u8 code, int *err)
964 case ICMPV6_DEST_UNREACH:
966 if (code < ARRAY_SIZE(tab_unreach)) {
967 *err = tab_unreach[code].err;
968 fatal = tab_unreach[code].fatal;
972 case ICMPV6_PKT_TOOBIG:
976 case ICMPV6_PARAMPROB:
981 case ICMPV6_TIME_EXCEED:
988 EXPORT_SYMBOL(icmpv6_err_convert);
991 static struct ctl_table ipv6_icmp_table_template[] = {
993 .procname = "ratelimit",
994 .data = &init_net.ipv6.sysctl.icmpv6_time,
995 .maxlen = sizeof(int),
997 .proc_handler = proc_dointvec_ms_jiffies,
1002 struct ctl_table * __net_init ipv6_icmp_sysctl_init(struct net *net)
1004 struct ctl_table *table;
1006 table = kmemdup(ipv6_icmp_table_template,
1007 sizeof(ipv6_icmp_table_template),
1011 table[0].data = &net->ipv6.sysctl.icmpv6_time;