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 err = xfrm_lookup(net, &dst, fl, sk, 0);
340 err = xfrm_decode_session_reverse(skb, &fl2, AF_INET6);
342 goto relookup_failed;
344 err = ip6_dst_lookup(sk, &dst2, &fl2);
346 goto relookup_failed;
348 err = xfrm_lookup(net, &dst2, &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 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(&fl, 0, sizeof(fl));
448 fl.proto = IPPROTO_ICMPV6;
449 ipv6_addr_copy(&fl.fl6_dst, &hdr->saddr);
451 ipv6_addr_copy(&fl.fl6_src, saddr);
453 fl.fl_icmp_type = type;
454 fl.fl_icmp_code = code;
455 security_skb_classify_flow(skb, &fl);
457 sk = icmpv6_xmit_lock(net);
462 if (!icmpv6_xrlim_allow(sk, type, &fl))
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 (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
471 fl.oif = np->mcast_oif;
473 dst = icmpv6_route_lookup(net, skb, sk, &fl);
477 if (ipv6_addr_is_multicast(&fl.fl6_dst))
478 hlimit = np->mcast_hops;
480 hlimit = np->hop_limit;
482 hlimit = ip6_dst_hoplimit(dst);
485 msg.offset = skb_network_offset(skb);
488 len = skb->len - msg.offset;
489 len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) -sizeof(struct icmp6hdr));
491 LIMIT_NETDEBUG(KERN_DEBUG "icmp: len problem\n");
492 goto out_dst_release;
495 idev = in6_dev_get(skb->dev);
497 err = ip6_append_data(sk, icmpv6_getfrag, &msg,
498 len + sizeof(struct icmp6hdr),
499 sizeof(struct icmp6hdr), hlimit,
500 np->tclass, NULL, &fl, (struct rt6_info*)dst,
501 MSG_DONTWAIT, np->dontfrag);
503 ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTERRORS);
504 ip6_flush_pending_frames(sk);
507 err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, len + sizeof(struct icmp6hdr));
510 if (likely(idev != NULL))
515 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 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(&fl, 0, sizeof(fl));
544 fl.proto = IPPROTO_ICMPV6;
545 ipv6_addr_copy(&fl.fl6_dst, &ipv6_hdr(skb)->saddr);
547 ipv6_addr_copy(&fl.fl6_src, saddr);
548 fl.oif = skb->dev->ifindex;
549 fl.fl_icmp_type = ICMPV6_ECHO_REPLY;
550 security_skb_classify_flow(skb, &fl);
552 sk = icmpv6_xmit_lock(net);
557 if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
558 fl.oif = np->mcast_oif;
560 err = ip6_dst_lookup(sk, &dst, &fl);
563 if ((err = xfrm_lookup(net, &dst, &fl, sk, 0)) < 0)
566 if (ipv6_addr_is_multicast(&fl.fl6_dst))
567 hlimit = np->mcast_hops;
569 hlimit = np->hop_limit;
571 hlimit = ip6_dst_hoplimit(dst);
573 idev = in6_dev_get(skb->dev);
577 msg.type = ICMPV6_ECHO_REPLY;
579 err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
580 sizeof(struct icmp6hdr), hlimit, np->tclass, NULL, &fl,
581 (struct rt6_info*)dst, MSG_DONTWAIT,
585 ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTERRORS);
586 ip6_flush_pending_frames(sk);
589 err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, skb->len + sizeof(struct icmp6hdr));
592 if (likely(idev != NULL))
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;
606 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
609 nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
610 if (ipv6_ext_hdr(nexthdr)) {
611 /* now skip over extension headers */
612 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr), &nexthdr);
616 inner_offset = sizeof(struct ipv6hdr);
619 /* Checkin header including 8 bytes of inner protocol header. */
620 if (!pskb_may_pull(skb, inner_offset+8))
623 /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
624 Without this we will not able f.e. to make source routed
626 Corresponding argument (opt) to notifiers is already added.
630 hash = nexthdr & (MAX_INET_PROTOS - 1);
633 ipprot = rcu_dereference(inet6_protos[hash]);
634 if (ipprot && ipprot->err_handler)
635 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
638 raw6_icmp_error(skb, nexthdr, type, code, inner_offset, info);
642 * Handle icmp messages
645 static int icmpv6_rcv(struct sk_buff *skb)
647 struct net_device *dev = skb->dev;
648 struct inet6_dev *idev = __in6_dev_get(dev);
649 struct in6_addr *saddr, *daddr;
650 struct ipv6hdr *orig_hdr;
651 struct icmp6hdr *hdr;
654 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
655 struct sec_path *sp = skb_sec_path(skb);
658 if (!(sp && sp->xvec[sp->len - 1]->props.flags &
662 if (!pskb_may_pull(skb, sizeof(*hdr) + sizeof(*orig_hdr)))
665 nh = skb_network_offset(skb);
666 skb_set_network_header(skb, sizeof(*hdr));
668 if (!xfrm6_policy_check_reverse(NULL, XFRM_POLICY_IN, skb))
671 skb_set_network_header(skb, nh);
674 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INMSGS);
676 saddr = &ipv6_hdr(skb)->saddr;
677 daddr = &ipv6_hdr(skb)->daddr;
679 /* Perform checksum. */
680 switch (skb->ip_summed) {
681 case CHECKSUM_COMPLETE:
682 if (!csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
687 skb->csum = ~csum_unfold(csum_ipv6_magic(saddr, daddr, skb->len,
689 if (__skb_checksum_complete(skb)) {
690 LIMIT_NETDEBUG(KERN_DEBUG "ICMPv6 checksum failed [%pI6 > %pI6]\n",
696 if (!pskb_pull(skb, sizeof(*hdr)))
699 hdr = icmp6_hdr(skb);
701 type = hdr->icmp6_type;
703 ICMP6MSGIN_INC_STATS_BH(dev_net(dev), idev, type);
706 case ICMPV6_ECHO_REQUEST:
707 icmpv6_echo_reply(skb);
710 case ICMPV6_ECHO_REPLY:
711 /* we couldn't care less */
714 case ICMPV6_PKT_TOOBIG:
715 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
716 standard destination cache. Seems, only "advanced"
717 destination cache will allow to solve this problem
720 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
722 hdr = icmp6_hdr(skb);
723 orig_hdr = (struct ipv6hdr *) (hdr + 1);
724 rt6_pmtu_discovery(&orig_hdr->daddr, &orig_hdr->saddr, dev,
725 ntohl(hdr->icmp6_mtu));
728 * Drop through to notify
731 case ICMPV6_DEST_UNREACH:
732 case ICMPV6_TIME_EXCEED:
733 case ICMPV6_PARAMPROB:
734 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
737 case NDISC_ROUTER_SOLICITATION:
738 case NDISC_ROUTER_ADVERTISEMENT:
739 case NDISC_NEIGHBOUR_SOLICITATION:
740 case NDISC_NEIGHBOUR_ADVERTISEMENT:
745 case ICMPV6_MGM_QUERY:
746 igmp6_event_query(skb);
749 case ICMPV6_MGM_REPORT:
750 igmp6_event_report(skb);
753 case ICMPV6_MGM_REDUCTION:
754 case ICMPV6_NI_QUERY:
755 case ICMPV6_NI_REPLY:
756 case ICMPV6_MLD2_REPORT:
757 case ICMPV6_DHAAD_REQUEST:
758 case ICMPV6_DHAAD_REPLY:
759 case ICMPV6_MOBILE_PREFIX_SOL:
760 case ICMPV6_MOBILE_PREFIX_ADV:
764 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6: msg of unknown type\n");
767 if (type & ICMPV6_INFOMSG_MASK)
771 * error of unknown type.
772 * must pass to upper level
775 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
782 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INERRORS);
788 void icmpv6_flow_init(struct sock *sk, struct flowi *fl,
790 const struct in6_addr *saddr,
791 const struct in6_addr *daddr,
794 memset(fl, 0, sizeof(*fl));
795 ipv6_addr_copy(&fl->fl6_src, saddr);
796 ipv6_addr_copy(&fl->fl6_dst, daddr);
797 fl->proto = IPPROTO_ICMPV6;
798 fl->fl_icmp_type = type;
799 fl->fl_icmp_code = 0;
801 security_sk_classify_flow(sk, fl);
805 * Special lock-class for __icmpv6_sk:
807 static struct lock_class_key icmpv6_socket_sk_dst_lock_key;
809 static int __net_init icmpv6_sk_init(struct net *net)
815 kzalloc(nr_cpu_ids * sizeof(struct sock *), GFP_KERNEL);
816 if (net->ipv6.icmp_sk == NULL)
819 for_each_possible_cpu(i) {
820 err = inet_ctl_sock_create(&sk, PF_INET6,
821 SOCK_RAW, IPPROTO_ICMPV6, net);
824 "Failed to initialize the ICMP6 control socket "
830 net->ipv6.icmp_sk[i] = sk;
833 * Split off their lock-class, because sk->sk_dst_lock
834 * gets used from softirqs, which is safe for
835 * __icmpv6_sk (because those never get directly used
836 * via userspace syscalls), but unsafe for normal sockets.
838 lockdep_set_class(&sk->sk_dst_lock,
839 &icmpv6_socket_sk_dst_lock_key);
841 /* Enough space for 2 64K ICMP packets, including
842 * sk_buff struct overhead.
845 (2 * ((64 * 1024) + sizeof(struct sk_buff)));
850 for (j = 0; j < i; j++)
851 inet_ctl_sock_destroy(net->ipv6.icmp_sk[j]);
852 kfree(net->ipv6.icmp_sk);
856 static void __net_exit icmpv6_sk_exit(struct net *net)
860 for_each_possible_cpu(i) {
861 inet_ctl_sock_destroy(net->ipv6.icmp_sk[i]);
863 kfree(net->ipv6.icmp_sk);
866 static struct pernet_operations icmpv6_sk_ops = {
867 .init = icmpv6_sk_init,
868 .exit = icmpv6_sk_exit,
871 int __init icmpv6_init(void)
875 err = register_pernet_subsys(&icmpv6_sk_ops);
880 if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0)
885 printk(KERN_ERR "Failed to register ICMP6 protocol\n");
886 unregister_pernet_subsys(&icmpv6_sk_ops);
890 void icmpv6_cleanup(void)
892 unregister_pernet_subsys(&icmpv6_sk_ops);
893 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
897 static const struct icmp6_err {
905 { /* ADM_PROHIBITED */
909 { /* Was NOT_NEIGHBOUR, now reserved */
923 int icmpv6_err_convert(u8 type, u8 code, int *err)
930 case ICMPV6_DEST_UNREACH:
932 if (code <= ICMPV6_PORT_UNREACH) {
933 *err = tab_unreach[code].err;
934 fatal = tab_unreach[code].fatal;
938 case ICMPV6_PKT_TOOBIG:
942 case ICMPV6_PARAMPROB:
947 case ICMPV6_TIME_EXCEED:
955 EXPORT_SYMBOL(icmpv6_err_convert);
958 ctl_table ipv6_icmp_table_template[] = {
960 .procname = "ratelimit",
961 .data = &init_net.ipv6.sysctl.icmpv6_time,
962 .maxlen = sizeof(int),
964 .proc_handler = proc_dointvec_ms_jiffies,
969 struct ctl_table * __net_init ipv6_icmp_sysctl_init(struct net *net)
971 struct ctl_table *table;
973 table = kmemdup(ipv6_icmp_table_template,
974 sizeof(ipv6_icmp_table_template),
978 table[0].data = &net->ipv6.sysctl.icmpv6_time;