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 #include <linux/module.h>
33 #include <linux/errno.h>
34 #include <linux/types.h>
35 #include <linux/socket.h>
37 #include <linux/kernel.h>
38 #include <linux/sockios.h>
39 #include <linux/net.h>
40 #include <linux/skbuff.h>
41 #include <linux/init.h>
42 #include <linux/netfilter.h>
43 #include <linux/slab.h>
46 #include <linux/sysctl.h>
49 #include <linux/inet.h>
50 #include <linux/netdevice.h>
51 #include <linux/icmpv6.h>
57 #include <net/ip6_checksum.h>
58 #include <net/protocol.h>
60 #include <net/rawv6.h>
61 #include <net/transp_v6.h>
62 #include <net/ip6_route.h>
63 #include <net/addrconf.h>
66 #include <net/inet_common.h>
68 #include <asm/uaccess.h>
69 #include <asm/system.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 inline struct sock *icmpv6_sk(struct net *net)
80 return net->ipv6.icmp_sk[smp_processor_id()];
83 static int icmpv6_rcv(struct sk_buff *skb);
85 static const struct inet6_protocol icmpv6_protocol = {
86 .handler = icmpv6_rcv,
87 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
90 static __inline__ struct sock *icmpv6_xmit_lock(struct net *net)
97 if (unlikely(!spin_trylock(&sk->sk_lock.slock))) {
98 /* This can happen if the output path (f.e. SIT or
99 * ip6ip6 tunnel) signals dst_link_failure() for an
100 * outgoing ICMP6 packet.
108 static __inline__ void icmpv6_xmit_unlock(struct sock *sk)
110 spin_unlock_bh(&sk->sk_lock.slock);
114 * Slightly more convenient version of icmpv6_send.
116 void icmpv6_param_prob(struct sk_buff *skb, u8 code, int pos)
118 icmpv6_send(skb, ICMPV6_PARAMPROB, code, pos);
123 * Figure out, may we reply to this packet with icmp error.
125 * We do not reply, if:
126 * - it was icmp error message.
127 * - it is truncated, so that it is known, that protocol is ICMPV6
128 * (i.e. in the middle of some exthdr)
133 static int is_ineligible(struct sk_buff *skb)
135 int ptr = (u8 *)(ipv6_hdr(skb) + 1) - skb->data;
136 int len = skb->len - ptr;
137 __u8 nexthdr = ipv6_hdr(skb)->nexthdr;
142 ptr = ipv6_skip_exthdr(skb, ptr, &nexthdr);
145 if (nexthdr == IPPROTO_ICMPV6) {
147 tp = skb_header_pointer(skb,
148 ptr+offsetof(struct icmp6hdr, icmp6_type),
149 sizeof(_type), &_type);
151 !(*tp & ICMPV6_INFOMSG_MASK))
158 * Check the ICMP output rate limit
160 static inline bool icmpv6_xrlim_allow(struct sock *sk, u8 type,
163 struct dst_entry *dst;
164 struct net *net = sock_net(sk);
167 /* Informational messages are not limited. */
168 if (type & ICMPV6_INFOMSG_MASK)
171 /* Do not limit pmtu discovery, it would break it. */
172 if (type == ICMPV6_PKT_TOOBIG)
176 * Look up the output route.
177 * XXX: perhaps the expire for routing entries cloned by
178 * this lookup should be more aggressive (not longer than timeout).
180 dst = ip6_route_output(net, sk, fl);
182 IP6_INC_STATS(net, ip6_dst_idev(dst),
183 IPSTATS_MIB_OUTNOROUTES);
184 } else if (dst->dev && (dst->dev->flags&IFF_LOOPBACK)) {
187 struct rt6_info *rt = (struct rt6_info *)dst;
188 int tmo = net->ipv6.sysctl.icmpv6_time;
190 /* Give more bandwidth to wider prefixes. */
191 if (rt->rt6i_dst.plen < 128)
192 tmo >>= ((128 - rt->rt6i_dst.plen)>>5);
195 rt6_bind_peer(rt, 1);
196 res = inet_peer_xrlim_allow(rt->rt6i_peer, tmo);
203 * an inline helper for the "simple" if statement below
204 * checks if parameter problem report is caused by an
205 * unrecognized IPv6 option that has the Option Type
206 * highest-order two bits set to 10
209 static __inline__ int opt_unrec(struct sk_buff *skb, __u32 offset)
213 offset += skb_network_offset(skb);
214 op = skb_header_pointer(skb, offset, sizeof(_optval), &_optval);
217 return (*op & 0xC0) == 0x80;
220 static int icmpv6_push_pending_frames(struct sock *sk, struct flowi *fl, struct icmp6hdr *thdr, int len)
223 struct icmp6hdr *icmp6h;
226 if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
229 icmp6h = icmp6_hdr(skb);
230 memcpy(icmp6h, thdr, sizeof(struct icmp6hdr));
231 icmp6h->icmp6_cksum = 0;
233 if (skb_queue_len(&sk->sk_write_queue) == 1) {
234 skb->csum = csum_partial(icmp6h,
235 sizeof(struct icmp6hdr), skb->csum);
236 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl->fl6_src,
243 skb_queue_walk(&sk->sk_write_queue, skb) {
244 tmp_csum = csum_add(tmp_csum, skb->csum);
247 tmp_csum = csum_partial(icmp6h,
248 sizeof(struct icmp6hdr), tmp_csum);
249 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl->fl6_src,
254 ip6_push_pending_frames(sk);
265 static int icmpv6_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb)
267 struct icmpv6_msg *msg = (struct icmpv6_msg *) from;
268 struct sk_buff *org_skb = msg->skb;
271 csum = skb_copy_and_csum_bits(org_skb, msg->offset + offset,
273 skb->csum = csum_block_add(skb->csum, csum, odd);
274 if (!(msg->type & ICMPV6_INFOMSG_MASK))
275 nf_ct_attach(skb, org_skb);
279 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
280 static void mip6_addr_swap(struct sk_buff *skb)
282 struct ipv6hdr *iph = ipv6_hdr(skb);
283 struct inet6_skb_parm *opt = IP6CB(skb);
284 struct ipv6_destopt_hao *hao;
289 off = ipv6_find_tlv(skb, opt->dsthao, IPV6_TLV_HAO);
290 if (likely(off >= 0)) {
291 hao = (struct ipv6_destopt_hao *)
292 (skb_network_header(skb) + off);
293 ipv6_addr_copy(&tmp, &iph->saddr);
294 ipv6_addr_copy(&iph->saddr, &hao->addr);
295 ipv6_addr_copy(&hao->addr, &tmp);
300 static inline void mip6_addr_swap(struct sk_buff *skb) {}
303 static struct dst_entry *icmpv6_route_lookup(struct net *net, struct sk_buff *skb,
304 struct sock *sk, struct flowi *fl)
306 struct dst_entry *dst, *dst2;
310 err = ip6_dst_lookup(sk, &dst, fl);
315 * We won't send icmp if the destination is known
318 if (((struct rt6_info *)dst)->rt6i_flags & RTF_ANYCAST) {
319 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: acast source\n");
321 return ERR_PTR(-EINVAL);
324 /* No need to clone since we're just using its address. */
327 dst = xfrm_lookup(net, dst, fl, sk, 0);
332 if (PTR_ERR(dst) == -EPERM)
338 err = xfrm_decode_session_reverse(skb, &fl2, AF_INET6);
340 goto relookup_failed;
342 err = ip6_dst_lookup(sk, &dst2, &fl2);
344 goto relookup_failed;
346 dst2 = xfrm_lookup(net, dst2, &fl2, sk, XFRM_LOOKUP_ICMP);
356 goto relookup_failed;
366 * Send an ICMP message in response to a packet in error
368 void icmpv6_send(struct sk_buff *skb, u8 type, u8 code, __u32 info)
370 struct net *net = dev_net(skb->dev);
371 struct inet6_dev *idev = NULL;
372 struct ipv6hdr *hdr = ipv6_hdr(skb);
374 struct ipv6_pinfo *np;
375 struct in6_addr *saddr = NULL;
376 struct dst_entry *dst;
377 struct icmp6hdr tmp_hdr;
379 struct icmpv6_msg msg;
386 if ((u8 *)hdr < skb->head ||
387 (skb->network_header + sizeof(*hdr)) > skb->tail)
391 * Make sure we respect the rules
392 * i.e. RFC 1885 2.4(e)
393 * Rule (e.1) is enforced by not using icmpv6_send
394 * in any code that processes icmp errors.
396 addr_type = ipv6_addr_type(&hdr->daddr);
398 if (ipv6_chk_addr(net, &hdr->daddr, skb->dev, 0))
405 if ((addr_type & IPV6_ADDR_MULTICAST || skb->pkt_type != PACKET_HOST)) {
406 if (type != ICMPV6_PKT_TOOBIG &&
407 !(type == ICMPV6_PARAMPROB &&
408 code == ICMPV6_UNK_OPTION &&
409 (opt_unrec(skb, info))))
415 addr_type = ipv6_addr_type(&hdr->saddr);
421 if (addr_type & IPV6_ADDR_LINKLOCAL)
422 iif = skb->dev->ifindex;
425 * Must not send error if the source does not uniquely
426 * identify a single node (RFC2463 Section 2.4).
427 * We check unspecified / multicast addresses here,
428 * and anycast addresses will be checked later.
430 if ((addr_type == IPV6_ADDR_ANY) || (addr_type & IPV6_ADDR_MULTICAST)) {
431 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: addr_any/mcast source\n");
436 * Never answer to a ICMP packet.
438 if (is_ineligible(skb)) {
439 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: no reply to icmp error\n");
445 memset(&fl, 0, sizeof(fl));
446 fl.proto = IPPROTO_ICMPV6;
447 ipv6_addr_copy(&fl.fl6_dst, &hdr->saddr);
449 ipv6_addr_copy(&fl.fl6_src, saddr);
451 fl.fl_icmp_type = type;
452 fl.fl_icmp_code = code;
453 security_skb_classify_flow(skb, &fl);
455 sk = icmpv6_xmit_lock(net);
460 if (!icmpv6_xrlim_allow(sk, type, &fl))
463 tmp_hdr.icmp6_type = type;
464 tmp_hdr.icmp6_code = code;
465 tmp_hdr.icmp6_cksum = 0;
466 tmp_hdr.icmp6_pointer = htonl(info);
468 if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
469 fl.oif = np->mcast_oif;
471 dst = icmpv6_route_lookup(net, skb, sk, &fl);
475 if (ipv6_addr_is_multicast(&fl.fl6_dst))
476 hlimit = np->mcast_hops;
478 hlimit = np->hop_limit;
480 hlimit = ip6_dst_hoplimit(dst);
483 msg.offset = skb_network_offset(skb);
486 len = skb->len - msg.offset;
487 len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) -sizeof(struct icmp6hdr));
489 LIMIT_NETDEBUG(KERN_DEBUG "icmp: len problem\n");
490 goto out_dst_release;
493 idev = in6_dev_get(skb->dev);
495 err = ip6_append_data(sk, icmpv6_getfrag, &msg,
496 len + sizeof(struct icmp6hdr),
497 sizeof(struct icmp6hdr), hlimit,
498 np->tclass, NULL, &fl, (struct rt6_info*)dst,
499 MSG_DONTWAIT, np->dontfrag);
501 ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTERRORS);
502 ip6_flush_pending_frames(sk);
505 err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, len + sizeof(struct icmp6hdr));
508 if (likely(idev != NULL))
513 icmpv6_xmit_unlock(sk);
516 EXPORT_SYMBOL(icmpv6_send);
518 static void icmpv6_echo_reply(struct sk_buff *skb)
520 struct net *net = dev_net(skb->dev);
522 struct inet6_dev *idev;
523 struct ipv6_pinfo *np;
524 struct in6_addr *saddr = NULL;
525 struct icmp6hdr *icmph = icmp6_hdr(skb);
526 struct icmp6hdr tmp_hdr;
528 struct icmpv6_msg msg;
529 struct dst_entry *dst;
533 saddr = &ipv6_hdr(skb)->daddr;
535 if (!ipv6_unicast_destination(skb))
538 memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
539 tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;
541 memset(&fl, 0, sizeof(fl));
542 fl.proto = IPPROTO_ICMPV6;
543 ipv6_addr_copy(&fl.fl6_dst, &ipv6_hdr(skb)->saddr);
545 ipv6_addr_copy(&fl.fl6_src, saddr);
546 fl.oif = skb->dev->ifindex;
547 fl.fl_icmp_type = ICMPV6_ECHO_REPLY;
548 security_skb_classify_flow(skb, &fl);
550 sk = icmpv6_xmit_lock(net);
555 if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
556 fl.oif = np->mcast_oif;
558 err = ip6_dst_lookup(sk, &dst, &fl);
561 dst = xfrm_lookup(net, dst, &fl, sk, 0);
565 if (ipv6_addr_is_multicast(&fl.fl6_dst))
566 hlimit = np->mcast_hops;
568 hlimit = np->hop_limit;
570 hlimit = ip6_dst_hoplimit(dst);
572 idev = in6_dev_get(skb->dev);
576 msg.type = ICMPV6_ECHO_REPLY;
578 err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
579 sizeof(struct icmp6hdr), hlimit, np->tclass, NULL, &fl,
580 (struct rt6_info*)dst, MSG_DONTWAIT,
584 ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTERRORS);
585 ip6_flush_pending_frames(sk);
588 err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, skb->len + sizeof(struct icmp6hdr));
591 if (likely(idev != NULL))
595 icmpv6_xmit_unlock(sk);
598 static void icmpv6_notify(struct sk_buff *skb, u8 type, u8 code, __be32 info)
600 const struct inet6_protocol *ipprot;
605 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
608 nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
609 if (ipv6_ext_hdr(nexthdr)) {
610 /* now skip over extension headers */
611 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr), &nexthdr);
615 inner_offset = sizeof(struct ipv6hdr);
618 /* Checkin header including 8 bytes of inner protocol header. */
619 if (!pskb_may_pull(skb, inner_offset+8))
622 /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
623 Without this we will not able f.e. to make source routed
625 Corresponding argument (opt) to notifiers is already added.
629 hash = nexthdr & (MAX_INET_PROTOS - 1);
632 ipprot = rcu_dereference(inet6_protos[hash]);
633 if (ipprot && ipprot->err_handler)
634 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
637 raw6_icmp_error(skb, nexthdr, type, code, inner_offset, info);
641 * Handle icmp messages
644 static int icmpv6_rcv(struct sk_buff *skb)
646 struct net_device *dev = skb->dev;
647 struct inet6_dev *idev = __in6_dev_get(dev);
648 struct in6_addr *saddr, *daddr;
649 struct ipv6hdr *orig_hdr;
650 struct icmp6hdr *hdr;
653 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
654 struct sec_path *sp = skb_sec_path(skb);
657 if (!(sp && sp->xvec[sp->len - 1]->props.flags &
661 if (!pskb_may_pull(skb, sizeof(*hdr) + sizeof(*orig_hdr)))
664 nh = skb_network_offset(skb);
665 skb_set_network_header(skb, sizeof(*hdr));
667 if (!xfrm6_policy_check_reverse(NULL, XFRM_POLICY_IN, skb))
670 skb_set_network_header(skb, nh);
673 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INMSGS);
675 saddr = &ipv6_hdr(skb)->saddr;
676 daddr = &ipv6_hdr(skb)->daddr;
678 /* Perform checksum. */
679 switch (skb->ip_summed) {
680 case CHECKSUM_COMPLETE:
681 if (!csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
686 skb->csum = ~csum_unfold(csum_ipv6_magic(saddr, daddr, skb->len,
688 if (__skb_checksum_complete(skb)) {
689 LIMIT_NETDEBUG(KERN_DEBUG "ICMPv6 checksum failed [%pI6 > %pI6]\n",
695 if (!pskb_pull(skb, sizeof(*hdr)))
698 hdr = icmp6_hdr(skb);
700 type = hdr->icmp6_type;
702 ICMP6MSGIN_INC_STATS_BH(dev_net(dev), idev, type);
705 case ICMPV6_ECHO_REQUEST:
706 icmpv6_echo_reply(skb);
709 case ICMPV6_ECHO_REPLY:
710 /* we couldn't care less */
713 case ICMPV6_PKT_TOOBIG:
714 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
715 standard destination cache. Seems, only "advanced"
716 destination cache will allow to solve this problem
719 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
721 hdr = icmp6_hdr(skb);
722 orig_hdr = (struct ipv6hdr *) (hdr + 1);
723 rt6_pmtu_discovery(&orig_hdr->daddr, &orig_hdr->saddr, dev,
724 ntohl(hdr->icmp6_mtu));
727 * Drop through to notify
730 case ICMPV6_DEST_UNREACH:
731 case ICMPV6_TIME_EXCEED:
732 case ICMPV6_PARAMPROB:
733 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
736 case NDISC_ROUTER_SOLICITATION:
737 case NDISC_ROUTER_ADVERTISEMENT:
738 case NDISC_NEIGHBOUR_SOLICITATION:
739 case NDISC_NEIGHBOUR_ADVERTISEMENT:
744 case ICMPV6_MGM_QUERY:
745 igmp6_event_query(skb);
748 case ICMPV6_MGM_REPORT:
749 igmp6_event_report(skb);
752 case ICMPV6_MGM_REDUCTION:
753 case ICMPV6_NI_QUERY:
754 case ICMPV6_NI_REPLY:
755 case ICMPV6_MLD2_REPORT:
756 case ICMPV6_DHAAD_REQUEST:
757 case ICMPV6_DHAAD_REPLY:
758 case ICMPV6_MOBILE_PREFIX_SOL:
759 case ICMPV6_MOBILE_PREFIX_ADV:
763 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6: msg of unknown type\n");
766 if (type & ICMPV6_INFOMSG_MASK)
770 * error of unknown type.
771 * must pass to upper level
774 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
781 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INERRORS);
787 void icmpv6_flow_init(struct sock *sk, struct flowi *fl,
789 const struct in6_addr *saddr,
790 const struct in6_addr *daddr,
793 memset(fl, 0, sizeof(*fl));
794 ipv6_addr_copy(&fl->fl6_src, saddr);
795 ipv6_addr_copy(&fl->fl6_dst, daddr);
796 fl->proto = IPPROTO_ICMPV6;
797 fl->fl_icmp_type = type;
798 fl->fl_icmp_code = 0;
800 security_sk_classify_flow(sk, fl);
804 * Special lock-class for __icmpv6_sk:
806 static struct lock_class_key icmpv6_socket_sk_dst_lock_key;
808 static int __net_init icmpv6_sk_init(struct net *net)
814 kzalloc(nr_cpu_ids * sizeof(struct sock *), GFP_KERNEL);
815 if (net->ipv6.icmp_sk == NULL)
818 for_each_possible_cpu(i) {
819 err = inet_ctl_sock_create(&sk, PF_INET6,
820 SOCK_RAW, IPPROTO_ICMPV6, net);
823 "Failed to initialize the ICMP6 control socket "
829 net->ipv6.icmp_sk[i] = sk;
832 * Split off their lock-class, because sk->sk_dst_lock
833 * gets used from softirqs, which is safe for
834 * __icmpv6_sk (because those never get directly used
835 * via userspace syscalls), but unsafe for normal sockets.
837 lockdep_set_class(&sk->sk_dst_lock,
838 &icmpv6_socket_sk_dst_lock_key);
840 /* Enough space for 2 64K ICMP packets, including
841 * sk_buff struct overhead.
844 (2 * ((64 * 1024) + sizeof(struct sk_buff)));
849 for (j = 0; j < i; j++)
850 inet_ctl_sock_destroy(net->ipv6.icmp_sk[j]);
851 kfree(net->ipv6.icmp_sk);
855 static void __net_exit icmpv6_sk_exit(struct net *net)
859 for_each_possible_cpu(i) {
860 inet_ctl_sock_destroy(net->ipv6.icmp_sk[i]);
862 kfree(net->ipv6.icmp_sk);
865 static struct pernet_operations icmpv6_sk_ops = {
866 .init = icmpv6_sk_init,
867 .exit = icmpv6_sk_exit,
870 int __init icmpv6_init(void)
874 err = register_pernet_subsys(&icmpv6_sk_ops);
879 if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0)
884 printk(KERN_ERR "Failed to register ICMP6 protocol\n");
885 unregister_pernet_subsys(&icmpv6_sk_ops);
889 void icmpv6_cleanup(void)
891 unregister_pernet_subsys(&icmpv6_sk_ops);
892 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
896 static const struct icmp6_err {
904 { /* ADM_PROHIBITED */
908 { /* Was NOT_NEIGHBOUR, now reserved */
922 int icmpv6_err_convert(u8 type, u8 code, int *err)
929 case ICMPV6_DEST_UNREACH:
931 if (code <= ICMPV6_PORT_UNREACH) {
932 *err = tab_unreach[code].err;
933 fatal = tab_unreach[code].fatal;
937 case ICMPV6_PKT_TOOBIG:
941 case ICMPV6_PARAMPROB:
946 case ICMPV6_TIME_EXCEED:
954 EXPORT_SYMBOL(icmpv6_err_convert);
957 ctl_table ipv6_icmp_table_template[] = {
959 .procname = "ratelimit",
960 .data = &init_net.ipv6.sysctl.icmpv6_time,
961 .maxlen = sizeof(int),
963 .proc_handler = proc_dointvec_ms_jiffies,
968 struct ctl_table * __net_init ipv6_icmp_sysctl_init(struct net *net)
970 struct ctl_table *table;
972 table = kmemdup(ipv6_icmp_table_template,
973 sizeof(ipv6_icmp_table_template),
977 table[0].data = &net->ipv6.sysctl.icmpv6_time;