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 const struct ipv6hdr *orig_hdr;
653 struct icmp6hdr *hdr;
656 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
657 struct sec_path *sp = skb_sec_path(skb);
660 if (!(sp && sp->xvec[sp->len - 1]->props.flags &
664 if (!pskb_may_pull(skb, sizeof(*hdr) + sizeof(*orig_hdr)))
667 nh = skb_network_offset(skb);
668 skb_set_network_header(skb, sizeof(*hdr));
670 if (!xfrm6_policy_check_reverse(NULL, XFRM_POLICY_IN, skb))
673 skb_set_network_header(skb, nh);
676 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INMSGS);
678 saddr = &ipv6_hdr(skb)->saddr;
679 daddr = &ipv6_hdr(skb)->daddr;
681 /* Perform checksum. */
682 switch (skb->ip_summed) {
683 case CHECKSUM_COMPLETE:
684 if (!csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
689 skb->csum = ~csum_unfold(csum_ipv6_magic(saddr, daddr, skb->len,
691 if (__skb_checksum_complete(skb)) {
692 LIMIT_NETDEBUG(KERN_DEBUG "ICMPv6 checksum failed [%pI6 > %pI6]\n",
698 if (!pskb_pull(skb, sizeof(*hdr)))
701 hdr = icmp6_hdr(skb);
703 type = hdr->icmp6_type;
705 ICMP6MSGIN_INC_STATS_BH(dev_net(dev), idev, type);
708 case ICMPV6_ECHO_REQUEST:
709 icmpv6_echo_reply(skb);
712 case ICMPV6_ECHO_REPLY:
713 /* we couldn't care less */
716 case ICMPV6_PKT_TOOBIG:
717 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
718 standard destination cache. Seems, only "advanced"
719 destination cache will allow to solve this problem
722 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
724 hdr = icmp6_hdr(skb);
725 orig_hdr = (struct ipv6hdr *) (hdr + 1);
726 rt6_pmtu_discovery(&orig_hdr->daddr, &orig_hdr->saddr, dev,
727 ntohl(hdr->icmp6_mtu));
730 * Drop through to notify
733 case ICMPV6_DEST_UNREACH:
734 case ICMPV6_TIME_EXCEED:
735 case ICMPV6_PARAMPROB:
736 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
739 case NDISC_ROUTER_SOLICITATION:
740 case NDISC_ROUTER_ADVERTISEMENT:
741 case NDISC_NEIGHBOUR_SOLICITATION:
742 case NDISC_NEIGHBOUR_ADVERTISEMENT:
747 case ICMPV6_MGM_QUERY:
748 igmp6_event_query(skb);
751 case ICMPV6_MGM_REPORT:
752 igmp6_event_report(skb);
755 case ICMPV6_MGM_REDUCTION:
756 case ICMPV6_NI_QUERY:
757 case ICMPV6_NI_REPLY:
758 case ICMPV6_MLD2_REPORT:
759 case ICMPV6_DHAAD_REQUEST:
760 case ICMPV6_DHAAD_REPLY:
761 case ICMPV6_MOBILE_PREFIX_SOL:
762 case ICMPV6_MOBILE_PREFIX_ADV:
766 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6: msg of unknown type\n");
769 if (type & ICMPV6_INFOMSG_MASK)
773 * error of unknown type.
774 * must pass to upper level
777 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
784 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INERRORS);
790 void icmpv6_flow_init(struct sock *sk, struct flowi6 *fl6,
792 const struct in6_addr *saddr,
793 const struct in6_addr *daddr,
796 memset(fl6, 0, sizeof(*fl6));
799 fl6->flowi6_proto = IPPROTO_ICMPV6;
800 fl6->fl6_icmp_type = type;
801 fl6->fl6_icmp_code = 0;
802 fl6->flowi6_oif = oif;
803 security_sk_classify_flow(sk, flowi6_to_flowi(fl6));
807 * Special lock-class for __icmpv6_sk:
809 static struct lock_class_key icmpv6_socket_sk_dst_lock_key;
811 static int __net_init icmpv6_sk_init(struct net *net)
817 kzalloc(nr_cpu_ids * sizeof(struct sock *), GFP_KERNEL);
818 if (net->ipv6.icmp_sk == NULL)
821 for_each_possible_cpu(i) {
822 err = inet_ctl_sock_create(&sk, PF_INET6,
823 SOCK_RAW, IPPROTO_ICMPV6, net);
825 pr_err("Failed to initialize the ICMP6 control socket (err %d)\n",
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.
844 sk->sk_sndbuf = 2 * SKB_TRUESIZE(64 * 1024);
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 pr_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:
953 EXPORT_SYMBOL(icmpv6_err_convert);
956 ctl_table ipv6_icmp_table_template[] = {
958 .procname = "ratelimit",
959 .data = &init_net.ipv6.sysctl.icmpv6_time,
960 .maxlen = sizeof(int),
962 .proc_handler = proc_dointvec_ms_jiffies,
967 struct ctl_table * __net_init ipv6_icmp_sysctl_init(struct net *net)
969 struct ctl_table *table;
971 table = kmemdup(ipv6_icmp_table_template,
972 sizeof(ipv6_icmp_table_template),
976 table[0].data = &net->ipv6.sysctl.icmpv6_time;