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>
60 #include <net/protocol.h>
62 #include <net/rawv6.h>
63 #include <net/transp_v6.h>
64 #include <net/ip6_route.h>
65 #include <net/addrconf.h>
68 #include <net/inet_common.h>
70 #include <asm/uaccess.h>
73 * The ICMP socket(s). This is the most convenient way to flow control
74 * our ICMP output as well as maintain a clean interface throughout
75 * all layers. All Socketless IP sends will soon be gone.
77 * On SMP we have one ICMP socket per-cpu.
79 static inline struct sock *icmpv6_sk(struct net *net)
81 return net->ipv6.icmp_sk[smp_processor_id()];
84 static int icmpv6_rcv(struct sk_buff *skb);
86 static const struct inet6_protocol icmpv6_protocol = {
87 .handler = icmpv6_rcv,
88 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
91 static __inline__ struct sock *icmpv6_xmit_lock(struct net *net)
98 if (unlikely(!spin_trylock(&sk->sk_lock.slock))) {
99 /* This can happen if the output path (f.e. SIT or
100 * ip6ip6 tunnel) signals dst_link_failure() for an
101 * outgoing ICMP6 packet.
109 static __inline__ void icmpv6_xmit_unlock(struct sock *sk)
111 spin_unlock_bh(&sk->sk_lock.slock);
115 * Slightly more convenient version of icmpv6_send.
117 void icmpv6_param_prob(struct sk_buff *skb, u8 code, int pos)
119 icmpv6_send(skb, ICMPV6_PARAMPROB, code, pos);
124 * Figure out, may we reply to this packet with icmp error.
126 * We do not reply, if:
127 * - it was icmp error message.
128 * - it is truncated, so that it is known, that protocol is ICMPV6
129 * (i.e. in the middle of some exthdr)
134 static bool is_ineligible(const struct sk_buff *skb)
136 int ptr = (u8 *)(ipv6_hdr(skb) + 1) - skb->data;
137 int len = skb->len - ptr;
138 __u8 nexthdr = ipv6_hdr(skb)->nexthdr;
144 ptr = ipv6_skip_exthdr(skb, ptr, &nexthdr, &frag_off);
147 if (nexthdr == IPPROTO_ICMPV6) {
149 tp = skb_header_pointer(skb,
150 ptr+offsetof(struct icmp6hdr, icmp6_type),
151 sizeof(_type), &_type);
153 !(*tp & ICMPV6_INFOMSG_MASK))
160 * Check the ICMP output rate limit
162 static inline bool icmpv6_xrlim_allow(struct sock *sk, u8 type,
165 struct dst_entry *dst;
166 struct net *net = sock_net(sk);
169 /* Informational messages are not limited. */
170 if (type & ICMPV6_INFOMSG_MASK)
173 /* Do not limit pmtu discovery, it would break it. */
174 if (type == ICMPV6_PKT_TOOBIG)
178 * Look up the output route.
179 * XXX: perhaps the expire for routing entries cloned by
180 * this lookup should be more aggressive (not longer than timeout).
182 dst = ip6_route_output(net, sk, fl6);
184 IP6_INC_STATS(net, ip6_dst_idev(dst),
185 IPSTATS_MIB_OUTNOROUTES);
186 } else if (dst->dev && (dst->dev->flags&IFF_LOOPBACK)) {
189 struct rt6_info *rt = (struct rt6_info *)dst;
190 int tmo = net->ipv6.sysctl.icmpv6_time;
191 struct inet_peer *peer;
193 /* Give more bandwidth to wider prefixes. */
194 if (rt->rt6i_dst.plen < 128)
195 tmo >>= ((128 - rt->rt6i_dst.plen)>>5);
197 peer = rt6_get_peer_create(rt);
198 res = inet_peer_xrlim_allow(peer, tmo);
205 * an inline helper for the "simple" if statement below
206 * checks if parameter problem report is caused by an
207 * unrecognized IPv6 option that has the Option Type
208 * highest-order two bits set to 10
211 static bool opt_unrec(struct sk_buff *skb, __u32 offset)
215 offset += skb_network_offset(skb);
216 op = skb_header_pointer(skb, offset, sizeof(_optval), &_optval);
219 return (*op & 0xC0) == 0x80;
222 static int icmpv6_push_pending_frames(struct sock *sk, struct flowi6 *fl6, struct icmp6hdr *thdr, int len)
225 struct icmp6hdr *icmp6h;
228 if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
231 icmp6h = icmp6_hdr(skb);
232 memcpy(icmp6h, thdr, sizeof(struct icmp6hdr));
233 icmp6h->icmp6_cksum = 0;
235 if (skb_queue_len(&sk->sk_write_queue) == 1) {
236 skb->csum = csum_partial(icmp6h,
237 sizeof(struct icmp6hdr), skb->csum);
238 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
240 len, fl6->flowi6_proto,
245 skb_queue_walk(&sk->sk_write_queue, skb) {
246 tmp_csum = csum_add(tmp_csum, skb->csum);
249 tmp_csum = csum_partial(icmp6h,
250 sizeof(struct icmp6hdr), tmp_csum);
251 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
253 len, fl6->flowi6_proto,
256 ip6_push_pending_frames(sk);
267 static int icmpv6_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb)
269 struct icmpv6_msg *msg = (struct icmpv6_msg *) from;
270 struct sk_buff *org_skb = msg->skb;
273 csum = skb_copy_and_csum_bits(org_skb, msg->offset + offset,
275 skb->csum = csum_block_add(skb->csum, csum, odd);
276 if (!(msg->type & ICMPV6_INFOMSG_MASK))
277 nf_ct_attach(skb, org_skb);
281 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
282 static void mip6_addr_swap(struct sk_buff *skb)
284 struct ipv6hdr *iph = ipv6_hdr(skb);
285 struct inet6_skb_parm *opt = IP6CB(skb);
286 struct ipv6_destopt_hao *hao;
291 off = ipv6_find_tlv(skb, opt->dsthao, IPV6_TLV_HAO);
292 if (likely(off >= 0)) {
293 hao = (struct ipv6_destopt_hao *)
294 (skb_network_header(skb) + off);
296 iph->saddr = hao->addr;
302 static inline void mip6_addr_swap(struct sk_buff *skb) {}
305 static struct dst_entry *icmpv6_route_lookup(struct net *net, struct sk_buff *skb,
306 struct sock *sk, struct flowi6 *fl6)
308 struct dst_entry *dst, *dst2;
312 err = ip6_dst_lookup(sk, &dst, fl6);
317 * We won't send icmp if the destination is known
320 if (((struct rt6_info *)dst)->rt6i_flags & RTF_ANYCAST) {
321 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: acast source\n");
323 return ERR_PTR(-EINVAL);
326 /* No need to clone since we're just using its address. */
329 dst = xfrm_lookup(net, dst, flowi6_to_flowi(fl6), sk, 0);
334 if (PTR_ERR(dst) == -EPERM)
340 err = xfrm_decode_session_reverse(skb, flowi6_to_flowi(&fl2), AF_INET6);
342 goto relookup_failed;
344 err = ip6_dst_lookup(sk, &dst2, &fl2);
346 goto relookup_failed;
348 dst2 = xfrm_lookup(net, dst2, flowi6_to_flowi(&fl2), sk, XFRM_LOOKUP_ICMP);
358 goto relookup_failed;
368 * Send an ICMP message in response to a packet in error
370 void icmpv6_send(struct sk_buff *skb, u8 type, u8 code, __u32 info)
372 struct net *net = dev_net(skb->dev);
373 struct inet6_dev *idev = NULL;
374 struct ipv6hdr *hdr = ipv6_hdr(skb);
376 struct ipv6_pinfo *np;
377 const struct in6_addr *saddr = NULL;
378 struct dst_entry *dst;
379 struct icmp6hdr tmp_hdr;
381 struct icmpv6_msg msg;
388 if ((u8 *)hdr < skb->head ||
389 (skb->network_header + sizeof(*hdr)) > skb->tail)
393 * Make sure we respect the rules
394 * i.e. RFC 1885 2.4(e)
395 * Rule (e.1) is enforced by not using icmpv6_send
396 * in any code that processes icmp errors.
398 addr_type = ipv6_addr_type(&hdr->daddr);
400 if (ipv6_chk_addr(net, &hdr->daddr, skb->dev, 0))
407 if ((addr_type & IPV6_ADDR_MULTICAST || skb->pkt_type != PACKET_HOST)) {
408 if (type != ICMPV6_PKT_TOOBIG &&
409 !(type == ICMPV6_PARAMPROB &&
410 code == ICMPV6_UNK_OPTION &&
411 (opt_unrec(skb, info))))
417 addr_type = ipv6_addr_type(&hdr->saddr);
423 if (addr_type & IPV6_ADDR_LINKLOCAL)
424 iif = skb->dev->ifindex;
427 * Must not send error if the source does not uniquely
428 * identify a single node (RFC2463 Section 2.4).
429 * We check unspecified / multicast addresses here,
430 * and anycast addresses will be checked later.
432 if ((addr_type == IPV6_ADDR_ANY) || (addr_type & IPV6_ADDR_MULTICAST)) {
433 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: addr_any/mcast source\n");
438 * Never answer to a ICMP packet.
440 if (is_ineligible(skb)) {
441 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: no reply to icmp error\n");
447 memset(&fl6, 0, sizeof(fl6));
448 fl6.flowi6_proto = IPPROTO_ICMPV6;
449 fl6.daddr = hdr->saddr;
452 fl6.flowi6_oif = iif;
453 fl6.fl6_icmp_type = type;
454 fl6.fl6_icmp_code = code;
455 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
457 sk = icmpv6_xmit_lock(net);
462 if (!icmpv6_xrlim_allow(sk, type, &fl6))
465 tmp_hdr.icmp6_type = type;
466 tmp_hdr.icmp6_code = code;
467 tmp_hdr.icmp6_cksum = 0;
468 tmp_hdr.icmp6_pointer = htonl(info);
470 if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
471 fl6.flowi6_oif = np->mcast_oif;
472 else if (!fl6.flowi6_oif)
473 fl6.flowi6_oif = np->ucast_oif;
475 dst = icmpv6_route_lookup(net, skb, sk, &fl6);
479 if (ipv6_addr_is_multicast(&fl6.daddr))
480 hlimit = np->mcast_hops;
482 hlimit = np->hop_limit;
484 hlimit = ip6_dst_hoplimit(dst);
487 msg.offset = skb_network_offset(skb);
490 len = skb->len - msg.offset;
491 len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) -sizeof(struct icmp6hdr));
493 LIMIT_NETDEBUG(KERN_DEBUG "icmp: len problem\n");
494 goto out_dst_release;
498 idev = __in6_dev_get(skb->dev);
500 err = ip6_append_data(sk, icmpv6_getfrag, &msg,
501 len + sizeof(struct icmp6hdr),
502 sizeof(struct icmp6hdr), hlimit,
503 np->tclass, NULL, &fl6, (struct rt6_info *)dst,
504 MSG_DONTWAIT, np->dontfrag);
506 ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTERRORS);
507 ip6_flush_pending_frames(sk);
509 err = icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
510 len + sizeof(struct icmp6hdr));
516 icmpv6_xmit_unlock(sk);
518 EXPORT_SYMBOL(icmpv6_send);
520 static void icmpv6_echo_reply(struct sk_buff *skb)
522 struct net *net = dev_net(skb->dev);
524 struct inet6_dev *idev;
525 struct ipv6_pinfo *np;
526 const struct in6_addr *saddr = NULL;
527 struct icmp6hdr *icmph = icmp6_hdr(skb);
528 struct icmp6hdr tmp_hdr;
530 struct icmpv6_msg msg;
531 struct dst_entry *dst;
535 saddr = &ipv6_hdr(skb)->daddr;
537 if (!ipv6_unicast_destination(skb))
540 memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
541 tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;
543 memset(&fl6, 0, sizeof(fl6));
544 fl6.flowi6_proto = IPPROTO_ICMPV6;
545 fl6.daddr = ipv6_hdr(skb)->saddr;
548 fl6.flowi6_oif = skb->dev->ifindex;
549 fl6.fl6_icmp_type = ICMPV6_ECHO_REPLY;
550 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
552 sk = icmpv6_xmit_lock(net);
557 if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
558 fl6.flowi6_oif = np->mcast_oif;
559 else if (!fl6.flowi6_oif)
560 fl6.flowi6_oif = np->ucast_oif;
562 err = ip6_dst_lookup(sk, &dst, &fl6);
565 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), sk, 0);
569 if (ipv6_addr_is_multicast(&fl6.daddr))
570 hlimit = np->mcast_hops;
572 hlimit = np->hop_limit;
574 hlimit = ip6_dst_hoplimit(dst);
576 idev = __in6_dev_get(skb->dev);
580 msg.type = ICMPV6_ECHO_REPLY;
582 err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
583 sizeof(struct icmp6hdr), hlimit, np->tclass, NULL, &fl6,
584 (struct rt6_info *)dst, MSG_DONTWAIT,
588 ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTERRORS);
589 ip6_flush_pending_frames(sk);
591 err = icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
592 skb->len + sizeof(struct icmp6hdr));
596 icmpv6_xmit_unlock(sk);
599 static void icmpv6_notify(struct sk_buff *skb, u8 type, u8 code, __be32 info)
601 const struct inet6_protocol *ipprot;
607 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
610 nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
611 if (ipv6_ext_hdr(nexthdr)) {
612 /* now skip over extension headers */
613 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr),
614 &nexthdr, &frag_off);
618 inner_offset = sizeof(struct ipv6hdr);
621 /* Checkin header including 8 bytes of inner protocol header. */
622 if (!pskb_may_pull(skb, inner_offset+8))
625 /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
626 Without this we will not able f.e. to make source routed
628 Corresponding argument (opt) to notifiers is already added.
632 hash = nexthdr & (MAX_INET_PROTOS - 1);
635 ipprot = rcu_dereference(inet6_protos[hash]);
636 if (ipprot && ipprot->err_handler)
637 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
640 raw6_icmp_error(skb, nexthdr, type, code, inner_offset, info);
644 * Handle icmp messages
647 static int icmpv6_rcv(struct sk_buff *skb)
649 struct net_device *dev = skb->dev;
650 struct inet6_dev *idev = __in6_dev_get(dev);
651 const struct in6_addr *saddr, *daddr;
652 struct icmp6hdr *hdr;
655 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
656 struct sec_path *sp = skb_sec_path(skb);
659 if (!(sp && sp->xvec[sp->len - 1]->props.flags &
663 if (!pskb_may_pull(skb, sizeof(*hdr) + sizeof(struct ipv6hdr)))
666 nh = skb_network_offset(skb);
667 skb_set_network_header(skb, sizeof(*hdr));
669 if (!xfrm6_policy_check_reverse(NULL, XFRM_POLICY_IN, skb))
672 skb_set_network_header(skb, nh);
675 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INMSGS);
677 saddr = &ipv6_hdr(skb)->saddr;
678 daddr = &ipv6_hdr(skb)->daddr;
680 /* Perform checksum. */
681 switch (skb->ip_summed) {
682 case CHECKSUM_COMPLETE:
683 if (!csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
688 skb->csum = ~csum_unfold(csum_ipv6_magic(saddr, daddr, skb->len,
690 if (__skb_checksum_complete(skb)) {
691 LIMIT_NETDEBUG(KERN_DEBUG "ICMPv6 checksum failed [%pI6 > %pI6]\n",
697 if (!pskb_pull(skb, sizeof(*hdr)))
700 hdr = icmp6_hdr(skb);
702 type = hdr->icmp6_type;
704 ICMP6MSGIN_INC_STATS_BH(dev_net(dev), idev, type);
707 case ICMPV6_ECHO_REQUEST:
708 icmpv6_echo_reply(skb);
711 case ICMPV6_ECHO_REPLY:
712 /* we couldn't care less */
715 case ICMPV6_PKT_TOOBIG:
716 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
717 standard destination cache. Seems, only "advanced"
718 destination cache will allow to solve this problem
721 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
723 hdr = icmp6_hdr(skb);
726 * Drop through to notify
729 case ICMPV6_DEST_UNREACH:
730 case ICMPV6_TIME_EXCEED:
731 case ICMPV6_PARAMPROB:
732 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
735 case NDISC_ROUTER_SOLICITATION:
736 case NDISC_ROUTER_ADVERTISEMENT:
737 case NDISC_NEIGHBOUR_SOLICITATION:
738 case NDISC_NEIGHBOUR_ADVERTISEMENT:
743 case ICMPV6_MGM_QUERY:
744 igmp6_event_query(skb);
747 case ICMPV6_MGM_REPORT:
748 igmp6_event_report(skb);
751 case ICMPV6_MGM_REDUCTION:
752 case ICMPV6_NI_QUERY:
753 case ICMPV6_NI_REPLY:
754 case ICMPV6_MLD2_REPORT:
755 case ICMPV6_DHAAD_REQUEST:
756 case ICMPV6_DHAAD_REPLY:
757 case ICMPV6_MOBILE_PREFIX_SOL:
758 case ICMPV6_MOBILE_PREFIX_ADV:
762 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6: msg of unknown type\n");
765 if (type & ICMPV6_INFOMSG_MASK)
769 * error of unknown type.
770 * must pass to upper level
773 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
780 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INERRORS);
786 void icmpv6_flow_init(struct sock *sk, struct flowi6 *fl6,
788 const struct in6_addr *saddr,
789 const struct in6_addr *daddr,
792 memset(fl6, 0, sizeof(*fl6));
795 fl6->flowi6_proto = IPPROTO_ICMPV6;
796 fl6->fl6_icmp_type = type;
797 fl6->fl6_icmp_code = 0;
798 fl6->flowi6_oif = oif;
799 security_sk_classify_flow(sk, flowi6_to_flowi(fl6));
803 * Special lock-class for __icmpv6_sk:
805 static struct lock_class_key icmpv6_socket_sk_dst_lock_key;
807 static int __net_init icmpv6_sk_init(struct net *net)
813 kzalloc(nr_cpu_ids * sizeof(struct sock *), GFP_KERNEL);
814 if (net->ipv6.icmp_sk == NULL)
817 for_each_possible_cpu(i) {
818 err = inet_ctl_sock_create(&sk, PF_INET6,
819 SOCK_RAW, IPPROTO_ICMPV6, net);
821 pr_err("Failed to initialize the ICMP6 control socket (err %d)\n",
826 net->ipv6.icmp_sk[i] = sk;
829 * Split off their lock-class, because sk->sk_dst_lock
830 * gets used from softirqs, which is safe for
831 * __icmpv6_sk (because those never get directly used
832 * via userspace syscalls), but unsafe for normal sockets.
834 lockdep_set_class(&sk->sk_dst_lock,
835 &icmpv6_socket_sk_dst_lock_key);
837 /* Enough space for 2 64K ICMP packets, including
838 * sk_buff struct overhead.
840 sk->sk_sndbuf = 2 * SKB_TRUESIZE(64 * 1024);
845 for (j = 0; j < i; j++)
846 inet_ctl_sock_destroy(net->ipv6.icmp_sk[j]);
847 kfree(net->ipv6.icmp_sk);
851 static void __net_exit icmpv6_sk_exit(struct net *net)
855 for_each_possible_cpu(i) {
856 inet_ctl_sock_destroy(net->ipv6.icmp_sk[i]);
858 kfree(net->ipv6.icmp_sk);
861 static struct pernet_operations icmpv6_sk_ops = {
862 .init = icmpv6_sk_init,
863 .exit = icmpv6_sk_exit,
866 int __init icmpv6_init(void)
870 err = register_pernet_subsys(&icmpv6_sk_ops);
875 if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0)
880 pr_err("Failed to register ICMP6 protocol\n");
881 unregister_pernet_subsys(&icmpv6_sk_ops);
885 void icmpv6_cleanup(void)
887 unregister_pernet_subsys(&icmpv6_sk_ops);
888 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
892 static const struct icmp6_err {
900 { /* ADM_PROHIBITED */
904 { /* Was NOT_NEIGHBOUR, now reserved */
918 int icmpv6_err_convert(u8 type, u8 code, int *err)
925 case ICMPV6_DEST_UNREACH:
927 if (code <= ICMPV6_PORT_UNREACH) {
928 *err = tab_unreach[code].err;
929 fatal = tab_unreach[code].fatal;
933 case ICMPV6_PKT_TOOBIG:
937 case ICMPV6_PARAMPROB:
942 case ICMPV6_TIME_EXCEED:
949 EXPORT_SYMBOL(icmpv6_err_convert);
952 ctl_table ipv6_icmp_table_template[] = {
954 .procname = "ratelimit",
955 .data = &init_net.ipv6.sysctl.icmpv6_time,
956 .maxlen = sizeof(int),
958 .proc_handler = proc_dointvec_ms_jiffies,
963 struct ctl_table * __net_init ipv6_icmp_sysctl_init(struct net *net)
965 struct ctl_table *table;
967 table = kmemdup(ipv6_icmp_table_template,
968 sizeof(ipv6_icmp_table_template),
972 table[0].data = &net->ipv6.sysctl.icmpv6_time;