blob: d674152b6ede5d6134f1a89cb8ebaa6a81308c73 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Internet Control Message Protocol (ICMPv6)
3 * Linux INET6 implementation
4 *
5 * Authors:
6 * Pedro Roque <roque@di.fc.ul.pt>
7 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 * Based on net/ipv4/icmp.c
9 *
10 * RFC 1885
11 *
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.
16 */
17
18/*
19 * Changes:
20 *
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
25 * fragments.
26 * YOSHIFUJI Hideaki @USAGI: added sysctl for icmp rate limit.
27 * Randy Dunlap and
28 * YOSHIFUJI Hideaki @USAGI: Per-interface statistics support
29 * Kazunori MIYAZAWA @USAGI: change output process to use ip6_append_data
30 */
31
Joe Perchesf3213832012-05-15 14:11:53 +000032#define pr_fmt(fmt) "IPv6: " fmt
33
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <linux/module.h>
35#include <linux/errno.h>
36#include <linux/types.h>
37#include <linux/socket.h>
38#include <linux/in.h>
39#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include <linux/sockios.h>
41#include <linux/net.h>
42#include <linux/skbuff.h>
43#include <linux/init.h>
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -080044#include <linux/netfilter.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090045#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
47#ifdef CONFIG_SYSCTL
48#include <linux/sysctl.h>
49#endif
50
51#include <linux/inet.h>
52#include <linux/netdevice.h>
53#include <linux/icmpv6.h>
54
55#include <net/ip.h>
56#include <net/sock.h>
57
58#include <net/ipv6.h>
59#include <net/ip6_checksum.h>
Lorenzo Colitti6d0bfe22013-05-22 20:17:31 +000060#include <net/ping.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070061#include <net/protocol.h>
62#include <net/raw.h>
63#include <net/rawv6.h>
64#include <net/transp_v6.h>
65#include <net/ip6_route.h>
66#include <net/addrconf.h>
67#include <net/icmp.h>
Herbert Xu8b7817f2007-12-12 10:44:43 -080068#include <net/xfrm.h>
Denis V. Lunev1ed85162008-04-03 14:31:03 -070069#include <net/inet_common.h>
Hannes Frederic Sowa825edac2014-01-11 11:55:46 +010070#include <net/dsfield.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070071
72#include <asm/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070073
Linus Torvalds1da177e2005-04-16 15:20:36 -070074/*
75 * The ICMP socket(s). This is the most convenient way to flow control
76 * our ICMP output as well as maintain a clean interface throughout
77 * all layers. All Socketless IP sends will soon be gone.
78 *
79 * On SMP we have one ICMP socket per-cpu.
80 */
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -080081static inline struct sock *icmpv6_sk(struct net *net)
82{
83 return net->ipv6.icmp_sk[smp_processor_id()];
84}
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
Steffen Klassert6f809da2013-01-16 22:09:49 +000086static void icmpv6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
87 u8 type, u8 code, int offset, __be32 info)
88{
Lorenzo Colitti6d0bfe22013-05-22 20:17:31 +000089 /* icmpv6_notify checks 8 bytes can be pulled, icmp6hdr is 8 bytes */
90 struct icmp6hdr *icmp6 = (struct icmp6hdr *) (skb->data + offset);
Steffen Klassert6f809da2013-01-16 22:09:49 +000091 struct net *net = dev_net(skb->dev);
92
93 if (type == ICMPV6_PKT_TOOBIG)
94 ip6_update_pmtu(skb, net, info, 0, 0);
95 else if (type == NDISC_REDIRECT)
Duan Jiongb55b76b2013-09-04 19:44:21 +080096 ip6_redirect(skb, net, skb->dev->ifindex, 0);
Lorenzo Colitti6d0bfe22013-05-22 20:17:31 +000097
98 if (!(type & ICMPV6_INFOMSG_MASK))
99 if (icmp6->icmp6_type == ICMPV6_ECHO_REQUEST)
100 ping_err(skb, offset, info);
Steffen Klassert6f809da2013-01-16 22:09:49 +0000101}
102
Herbert Xue5bbef22007-10-15 12:50:28 -0700103static int icmpv6_rcv(struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104
Alexey Dobriyan41135cc2009-09-14 12:22:28 +0000105static const struct inet6_protocol icmpv6_protocol = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 .handler = icmpv6_rcv,
Steffen Klassert6f809da2013-01-16 22:09:49 +0000107 .err_handler = icmpv6_err,
Herbert Xu8b7817f2007-12-12 10:44:43 -0800108 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109};
110
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700111static __inline__ struct sock *icmpv6_xmit_lock(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112{
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700113 struct sock *sk;
114
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 local_bh_disable();
116
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700117 sk = icmpv6_sk(net);
Denis V. Lunev405666d2008-02-29 11:16:46 -0800118 if (unlikely(!spin_trylock(&sk->sk_lock.slock))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 /* This can happen if the output path (f.e. SIT or
120 * ip6ip6 tunnel) signals dst_link_failure() for an
121 * outgoing ICMP6 packet.
122 */
123 local_bh_enable();
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700124 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 }
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700126 return sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127}
128
Denis V. Lunev405666d2008-02-29 11:16:46 -0800129static __inline__ void icmpv6_xmit_unlock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130{
Denis V. Lunev405666d2008-02-29 11:16:46 -0800131 spin_unlock_bh(&sk->sk_lock.slock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132}
133
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900134/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 * Figure out, may we reply to this packet with icmp error.
136 *
137 * We do not reply, if:
138 * - it was icmp error message.
139 * - it is truncated, so that it is known, that protocol is ICMPV6
140 * (i.e. in the middle of some exthdr)
141 *
142 * --ANK (980726)
143 */
144
Eric Dumazeta50feda2012-05-18 18:57:34 +0000145static bool is_ineligible(const struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700147 int ptr = (u8 *)(ipv6_hdr(skb) + 1) - skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 int len = skb->len - ptr;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700149 __u8 nexthdr = ipv6_hdr(skb)->nexthdr;
Jesse Gross75f28112011-11-30 17:05:51 -0800150 __be16 frag_off;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151
152 if (len < 0)
Eric Dumazeta50feda2012-05-18 18:57:34 +0000153 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
Jesse Gross75f28112011-11-30 17:05:51 -0800155 ptr = ipv6_skip_exthdr(skb, ptr, &nexthdr, &frag_off);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 if (ptr < 0)
Eric Dumazeta50feda2012-05-18 18:57:34 +0000157 return false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 if (nexthdr == IPPROTO_ICMPV6) {
159 u8 _type, *tp;
160 tp = skb_header_pointer(skb,
161 ptr+offsetof(struct icmp6hdr, icmp6_type),
162 sizeof(_type), &_type);
163 if (tp == NULL ||
164 !(*tp & ICMPV6_INFOMSG_MASK))
Eric Dumazeta50feda2012-05-18 18:57:34 +0000165 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 }
Eric Dumazeta50feda2012-05-18 18:57:34 +0000167 return false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168}
169
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900170/*
171 * Check the ICMP output rate limit
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 */
Eric Dumazet4cdf5072014-09-19 07:38:40 -0700173static bool icmpv6_xrlim_allow(struct sock *sk, u8 type,
174 struct flowi6 *fl6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175{
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900176 struct net *net = sock_net(sk);
Eric Dumazet4cdf5072014-09-19 07:38:40 -0700177 struct dst_entry *dst;
David S. Miller92d86822011-02-04 15:55:25 -0800178 bool res = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179
180 /* Informational messages are not limited. */
181 if (type & ICMPV6_INFOMSG_MASK)
David S. Miller92d86822011-02-04 15:55:25 -0800182 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183
184 /* Do not limit pmtu discovery, it would break it. */
185 if (type == ICMPV6_PKT_TOOBIG)
David S. Miller92d86822011-02-04 15:55:25 -0800186 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900188 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 * Look up the output route.
190 * XXX: perhaps the expire for routing entries cloned by
191 * this lookup should be more aggressive (not longer than timeout).
192 */
David S. Miller4c9483b2011-03-12 16:22:43 -0500193 dst = ip6_route_output(net, sk, fl6);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 if (dst->error) {
Denis V. Lunev3bd653c2008-10-08 10:54:51 -0700195 IP6_INC_STATS(net, ip6_dst_idev(dst),
YOSHIFUJI Hideakia11d2062006-11-04 20:11:37 +0900196 IPSTATS_MIB_OUTNOROUTES);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 } else if (dst->dev && (dst->dev->flags&IFF_LOOPBACK)) {
David S. Miller92d86822011-02-04 15:55:25 -0800198 res = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 } else {
200 struct rt6_info *rt = (struct rt6_info *)dst;
Benjamin Thery9a43b702008-03-05 10:49:18 -0800201 int tmo = net->ipv6.sysctl.icmpv6_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202
203 /* Give more bandwidth to wider prefixes. */
204 if (rt->rt6i_dst.plen < 128)
205 tmo >>= ((128 - rt->rt6i_dst.plen)>>5);
206
Eric Dumazet4cdf5072014-09-19 07:38:40 -0700207 if (icmp_global_allow()) {
208 struct inet_peer *peer;
209
210 peer = inet_getpeer_v6(net->ipv6.peers,
211 &rt->rt6i_dst.addr, 1);
212 res = inet_peer_xrlim_allow(peer, tmo);
213 if (peer)
214 inet_putpeer(peer);
215 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 }
217 dst_release(dst);
218 return res;
219}
220
221/*
222 * an inline helper for the "simple" if statement below
223 * checks if parameter problem report is caused by an
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900224 * unrecognized IPv6 option that has the Option Type
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 * highest-order two bits set to 10
226 */
227
Eric Dumazeta50feda2012-05-18 18:57:34 +0000228static bool opt_unrec(struct sk_buff *skb, __u32 offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229{
230 u8 _optval, *op;
231
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -0300232 offset += skb_network_offset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 op = skb_header_pointer(skb, offset, sizeof(_optval), &_optval);
234 if (op == NULL)
Eric Dumazeta50feda2012-05-18 18:57:34 +0000235 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 return (*op & 0xC0) == 0x80;
237}
238
Lorenzo Colitti6d0bfe22013-05-22 20:17:31 +0000239int icmpv6_push_pending_frames(struct sock *sk, struct flowi6 *fl6,
240 struct icmp6hdr *thdr, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241{
242 struct sk_buff *skb;
243 struct icmp6hdr *icmp6h;
244 int err = 0;
245
Ian Morrise5d08d72014-11-23 21:28:43 +0000246 skb = skb_peek(&sk->sk_write_queue);
247 if (skb == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 goto out;
249
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300250 icmp6h = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 memcpy(icmp6h, thdr, sizeof(struct icmp6hdr));
252 icmp6h->icmp6_cksum = 0;
253
254 if (skb_queue_len(&sk->sk_write_queue) == 1) {
Joe Perches07f07572008-11-19 15:44:53 -0800255 skb->csum = csum_partial(icmp6h,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 sizeof(struct icmp6hdr), skb->csum);
David S. Miller4c9483b2011-03-12 16:22:43 -0500257 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
258 &fl6->daddr,
259 len, fl6->flowi6_proto,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 skb->csum);
261 } else {
Al Viro868c86b2006-11-14 21:35:48 -0800262 __wsum tmp_csum = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
264 skb_queue_walk(&sk->sk_write_queue, skb) {
265 tmp_csum = csum_add(tmp_csum, skb->csum);
266 }
267
Joe Perches07f07572008-11-19 15:44:53 -0800268 tmp_csum = csum_partial(icmp6h,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 sizeof(struct icmp6hdr), tmp_csum);
David S. Miller4c9483b2011-03-12 16:22:43 -0500270 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
271 &fl6->daddr,
272 len, fl6->flowi6_proto,
Al Viro868c86b2006-11-14 21:35:48 -0800273 tmp_csum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 ip6_push_pending_frames(sk);
276out:
277 return err;
278}
279
280struct icmpv6_msg {
281 struct sk_buff *skb;
282 int offset;
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800283 uint8_t type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284};
285
286static int icmpv6_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb)
287{
288 struct icmpv6_msg *msg = (struct icmpv6_msg *) from;
289 struct sk_buff *org_skb = msg->skb;
Al Viro5f92a732006-11-14 21:36:54 -0800290 __wsum csum = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291
292 csum = skb_copy_and_csum_bits(org_skb, msg->offset + offset,
293 to, len, csum);
294 skb->csum = csum_block_add(skb->csum, csum, odd);
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800295 if (!(msg->type & ICMPV6_INFOMSG_MASK))
296 nf_ct_attach(skb, org_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 return 0;
298}
299
Amerigo Wang07a93622012-10-29 16:23:10 +0000300#if IS_ENABLED(CONFIG_IPV6_MIP6)
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700301static void mip6_addr_swap(struct sk_buff *skb)
302{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700303 struct ipv6hdr *iph = ipv6_hdr(skb);
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700304 struct inet6_skb_parm *opt = IP6CB(skb);
305 struct ipv6_destopt_hao *hao;
306 struct in6_addr tmp;
307 int off;
308
309 if (opt->dsthao) {
310 off = ipv6_find_tlv(skb, opt->dsthao, IPV6_TLV_HAO);
311 if (likely(off >= 0)) {
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700312 hao = (struct ipv6_destopt_hao *)
313 (skb_network_header(skb) + off);
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000314 tmp = iph->saddr;
315 iph->saddr = hao->addr;
316 hao->addr = tmp;
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700317 }
318 }
319}
320#else
321static inline void mip6_addr_swap(struct sk_buff *skb) {}
322#endif
323
stephen hemmingere8243532013-12-29 14:03:31 -0800324static struct dst_entry *icmpv6_route_lookup(struct net *net,
325 struct sk_buff *skb,
326 struct sock *sk,
327 struct flowi6 *fl6)
David S. Millerb42835d2011-03-01 22:06:22 -0800328{
329 struct dst_entry *dst, *dst2;
David S. Miller4c9483b2011-03-12 16:22:43 -0500330 struct flowi6 fl2;
David S. Millerb42835d2011-03-01 22:06:22 -0800331 int err;
332
David S. Miller4c9483b2011-03-12 16:22:43 -0500333 err = ip6_dst_lookup(sk, &dst, fl6);
David S. Millerb42835d2011-03-01 22:06:22 -0800334 if (err)
335 return ERR_PTR(err);
336
337 /*
338 * We won't send icmp if the destination is known
339 * anycast.
340 */
341 if (((struct rt6_info *)dst)->rt6i_flags & RTF_ANYCAST) {
Joe Perchesba7a46f2014-11-11 10:59:17 -0800342 net_dbg_ratelimited("icmp6_send: acast source\n");
David S. Millerb42835d2011-03-01 22:06:22 -0800343 dst_release(dst);
344 return ERR_PTR(-EINVAL);
345 }
346
347 /* No need to clone since we're just using its address. */
348 dst2 = dst;
349
David S. Miller4c9483b2011-03-12 16:22:43 -0500350 dst = xfrm_lookup(net, dst, flowi6_to_flowi(fl6), sk, 0);
David S. Miller452edd52011-03-02 13:27:41 -0800351 if (!IS_ERR(dst)) {
David S. Millerb42835d2011-03-01 22:06:22 -0800352 if (dst != dst2)
353 return dst;
David S. Miller452edd52011-03-02 13:27:41 -0800354 } else {
355 if (PTR_ERR(dst) == -EPERM)
356 dst = NULL;
357 else
358 return dst;
David S. Millerb42835d2011-03-01 22:06:22 -0800359 }
360
David S. Miller4c9483b2011-03-12 16:22:43 -0500361 err = xfrm_decode_session_reverse(skb, flowi6_to_flowi(&fl2), AF_INET6);
David S. Millerb42835d2011-03-01 22:06:22 -0800362 if (err)
363 goto relookup_failed;
364
365 err = ip6_dst_lookup(sk, &dst2, &fl2);
366 if (err)
367 goto relookup_failed;
368
David S. Miller4c9483b2011-03-12 16:22:43 -0500369 dst2 = xfrm_lookup(net, dst2, flowi6_to_flowi(&fl2), sk, XFRM_LOOKUP_ICMP);
David S. Miller452edd52011-03-02 13:27:41 -0800370 if (!IS_ERR(dst2)) {
David S. Millerb42835d2011-03-01 22:06:22 -0800371 dst_release(dst);
372 dst = dst2;
David S. Miller452edd52011-03-02 13:27:41 -0800373 } else {
374 err = PTR_ERR(dst2);
375 if (err == -EPERM) {
376 dst_release(dst);
377 return dst2;
378 } else
379 goto relookup_failed;
David S. Millerb42835d2011-03-01 22:06:22 -0800380 }
381
382relookup_failed:
383 if (dst)
384 return dst;
385 return ERR_PTR(err);
386}
387
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388/*
389 * Send an ICMP message in response to a packet in error
390 */
Pravin B Shelar5f5624c2013-04-25 11:08:30 +0000391static void icmp6_send(struct sk_buff *skb, u8 type, u8 code, __u32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900393 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 struct inet6_dev *idev = NULL;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700395 struct ipv6hdr *hdr = ipv6_hdr(skb);
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700396 struct sock *sk;
397 struct ipv6_pinfo *np;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000398 const struct in6_addr *saddr = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 struct dst_entry *dst;
400 struct icmp6hdr tmp_hdr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500401 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 struct icmpv6_msg msg;
403 int iif = 0;
404 int addr_type = 0;
405 int len;
Gerrit Renkere651f032009-08-09 08:12:48 +0000406 int hlimit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 int err = 0;
Lorenzo Colittie1108612014-05-13 10:17:33 -0700408 u32 mark = IP6_REPLY_MARK(net, skb->mark);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700410 if ((u8 *)hdr < skb->head ||
Simon Horman29a3cad2013-05-28 20:34:26 +0000411 (skb_network_header(skb) + sizeof(*hdr)) > skb_tail_pointer(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 return;
413
414 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900415 * Make sure we respect the rules
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 * i.e. RFC 1885 2.4(e)
Pravin B Shelar5f5624c2013-04-25 11:08:30 +0000417 * Rule (e.1) is enforced by not using icmp6_send
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 * in any code that processes icmp errors.
419 */
420 addr_type = ipv6_addr_type(&hdr->daddr);
421
FX Le Bail446fab52014-01-19 17:00:36 +0100422 if (ipv6_chk_addr(net, &hdr->daddr, skb->dev, 0) ||
FX Le Baild94c1f92014-02-07 11:22:37 +0100423 ipv6_chk_acast_addr_src(net, skb->dev, &hdr->daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 saddr = &hdr->daddr;
425
426 /*
427 * Dest addr check
428 */
429
430 if ((addr_type & IPV6_ADDR_MULTICAST || skb->pkt_type != PACKET_HOST)) {
431 if (type != ICMPV6_PKT_TOOBIG &&
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900432 !(type == ICMPV6_PARAMPROB &&
433 code == ICMPV6_UNK_OPTION &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 (opt_unrec(skb, info))))
435 return;
436
437 saddr = NULL;
438 }
439
440 addr_type = ipv6_addr_type(&hdr->saddr);
441
442 /*
443 * Source addr check
444 */
445
Hannes Frederic Sowa842df072013-03-08 02:07:19 +0000446 if (__ipv6_addr_needs_scope_id(addr_type))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 iif = skb->dev->ifindex;
448
449 /*
YOSHIFUJI Hideaki8de33512005-12-21 22:57:06 +0900450 * Must not send error if the source does not uniquely
451 * identify a single node (RFC2463 Section 2.4).
452 * We check unspecified / multicast addresses here,
453 * and anycast addresses will be checked later.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 */
455 if ((addr_type == IPV6_ADDR_ANY) || (addr_type & IPV6_ADDR_MULTICAST)) {
Joe Perchesba7a46f2014-11-11 10:59:17 -0800456 net_dbg_ratelimited("icmp6_send: addr_any/mcast source\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 return;
458 }
459
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900460 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 * Never answer to a ICMP packet.
462 */
463 if (is_ineligible(skb)) {
Joe Perchesba7a46f2014-11-11 10:59:17 -0800464 net_dbg_ratelimited("icmp6_send: no reply to icmp error\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 return;
466 }
467
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700468 mip6_addr_swap(skb);
469
David S. Miller4c9483b2011-03-12 16:22:43 -0500470 memset(&fl6, 0, sizeof(fl6));
471 fl6.flowi6_proto = IPPROTO_ICMPV6;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000472 fl6.daddr = hdr->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 if (saddr)
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000474 fl6.saddr = *saddr;
Lorenzo Colittie1108612014-05-13 10:17:33 -0700475 fl6.flowi6_mark = mark;
David S. Miller4c9483b2011-03-12 16:22:43 -0500476 fl6.flowi6_oif = iif;
David S. Miller1958b852011-03-12 16:36:19 -0500477 fl6.fl6_icmp_type = type;
478 fl6.fl6_icmp_code = code;
David S. Miller4c9483b2011-03-12 16:22:43 -0500479 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700481 sk = icmpv6_xmit_lock(net);
482 if (sk == NULL)
Denis V. Lunev405666d2008-02-29 11:16:46 -0800483 return;
Lorenzo Colittie1108612014-05-13 10:17:33 -0700484 sk->sk_mark = mark;
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700485 np = inet6_sk(sk);
Denis V. Lunev405666d2008-02-29 11:16:46 -0800486
David S. Miller4c9483b2011-03-12 16:22:43 -0500487 if (!icmpv6_xrlim_allow(sk, type, &fl6))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 goto out;
489
490 tmp_hdr.icmp6_type = type;
491 tmp_hdr.icmp6_code = code;
492 tmp_hdr.icmp6_cksum = 0;
493 tmp_hdr.icmp6_pointer = htonl(info);
494
David S. Miller4c9483b2011-03-12 16:22:43 -0500495 if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
496 fl6.flowi6_oif = np->mcast_oif;
Erich E. Hooverc4062df2012-02-08 09:11:08 +0000497 else if (!fl6.flowi6_oif)
498 fl6.flowi6_oif = np->ucast_oif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499
David S. Miller4c9483b2011-03-12 16:22:43 -0500500 dst = icmpv6_route_lookup(net, skb, sk, &fl6);
David S. Millerb42835d2011-03-01 22:06:22 -0800501 if (IS_ERR(dst))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 goto out;
YOSHIFUJI Hideaki8de33512005-12-21 22:57:06 +0900503
Lorenzo Colitti5c986312014-04-29 11:57:34 +0900504 hlimit = ip6_sk_dst_hoplimit(np, &fl6, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505
506 msg.skb = skb;
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -0300507 msg.offset = skb_network_offset(skb);
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800508 msg.type = type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509
510 len = skb->len - msg.offset;
Ian Morris67ba4152014-08-24 21:53:10 +0100511 len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) - sizeof(struct icmp6hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 if (len < 0) {
Joe Perchesba7a46f2014-11-11 10:59:17 -0800513 net_dbg_ratelimited("icmp: len problem\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 goto out_dst_release;
515 }
516
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000517 rcu_read_lock();
518 idev = __in6_dev_get(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519
520 err = ip6_append_data(sk, icmpv6_getfrag, &msg,
521 len + sizeof(struct icmp6hdr),
Gerrit Renkere651f032009-08-09 08:12:48 +0000522 sizeof(struct icmp6hdr), hlimit,
Eldad Zacka2d91a02012-04-01 07:49:07 +0000523 np->tclass, NULL, &fl6, (struct rt6_info *)dst,
Brian Haley13b52cd2010-04-23 11:26:08 +0000524 MSG_DONTWAIT, np->dontfrag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 if (err) {
Hannes Frederic Sowa43a43b62014-03-31 20:14:10 +0200526 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 ip6_flush_pending_frames(sk);
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000528 } else {
529 err = icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
530 len + sizeof(struct icmp6hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 }
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000532 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533out_dst_release:
534 dst_release(dst);
535out:
Denis V. Lunev405666d2008-02-29 11:16:46 -0800536 icmpv6_xmit_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537}
Pravin B Shelar5f5624c2013-04-25 11:08:30 +0000538
539/* Slightly more convenient version of icmp6_send.
540 */
541void icmpv6_param_prob(struct sk_buff *skb, u8 code, int pos)
542{
543 icmp6_send(skb, ICMPV6_PARAMPROB, code, pos);
544 kfree_skb(skb);
545}
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900546
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547static void icmpv6_echo_reply(struct sk_buff *skb)
548{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900549 struct net *net = dev_net(skb->dev);
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700550 struct sock *sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 struct inet6_dev *idev;
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700552 struct ipv6_pinfo *np;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000553 const struct in6_addr *saddr = NULL;
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300554 struct icmp6hdr *icmph = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 struct icmp6hdr tmp_hdr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500556 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 struct icmpv6_msg msg;
558 struct dst_entry *dst;
559 int err = 0;
560 int hlimit;
Hannes Frederic Sowa825edac2014-01-11 11:55:46 +0100561 u8 tclass;
Lorenzo Colittie1108612014-05-13 10:17:33 -0700562 u32 mark = IP6_REPLY_MARK(net, skb->mark);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700564 saddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565
FX Le Bail509aba32014-01-07 14:57:27 +0100566 if (!ipv6_unicast_destination(skb) &&
FX Le Bailec35b612014-01-13 15:59:01 +0100567 !(net->ipv6.sysctl.anycast_src_echo_reply &&
FX Le Bail509aba32014-01-07 14:57:27 +0100568 ipv6_anycast_destination(skb)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 saddr = NULL;
570
571 memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
572 tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;
573
David S. Miller4c9483b2011-03-12 16:22:43 -0500574 memset(&fl6, 0, sizeof(fl6));
575 fl6.flowi6_proto = IPPROTO_ICMPV6;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000576 fl6.daddr = ipv6_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 if (saddr)
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000578 fl6.saddr = *saddr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500579 fl6.flowi6_oif = skb->dev->ifindex;
David S. Miller1958b852011-03-12 16:36:19 -0500580 fl6.fl6_icmp_type = ICMPV6_ECHO_REPLY;
Lorenzo Colittie1108612014-05-13 10:17:33 -0700581 fl6.flowi6_mark = mark;
David S. Miller4c9483b2011-03-12 16:22:43 -0500582 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700584 sk = icmpv6_xmit_lock(net);
585 if (sk == NULL)
Denis V. Lunev405666d2008-02-29 11:16:46 -0800586 return;
Lorenzo Colittie1108612014-05-13 10:17:33 -0700587 sk->sk_mark = mark;
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700588 np = inet6_sk(sk);
Denis V. Lunev405666d2008-02-29 11:16:46 -0800589
David S. Miller4c9483b2011-03-12 16:22:43 -0500590 if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
591 fl6.flowi6_oif = np->mcast_oif;
Erich E. Hooverc4062df2012-02-08 09:11:08 +0000592 else if (!fl6.flowi6_oif)
593 fl6.flowi6_oif = np->ucast_oif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594
David S. Miller4c9483b2011-03-12 16:22:43 -0500595 err = ip6_dst_lookup(sk, &dst, &fl6);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 if (err)
597 goto out;
David S. Miller4c9483b2011-03-12 16:22:43 -0500598 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), sk, 0);
David S. Miller452edd52011-03-02 13:27:41 -0800599 if (IS_ERR(dst))
Patrick McHardye104411b2005-09-08 15:11:55 -0700600 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601
Lorenzo Colitti5c986312014-04-29 11:57:34 +0900602 hlimit = ip6_sk_dst_hoplimit(np, &fl6, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000604 idev = __in6_dev_get(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605
606 msg.skb = skb;
607 msg.offset = 0;
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800608 msg.type = ICMPV6_ECHO_REPLY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609
Hannes Frederic Sowa825edac2014-01-11 11:55:46 +0100610 tclass = ipv6_get_dsfield(ipv6_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
Hannes Frederic Sowa825edac2014-01-11 11:55:46 +0100612 sizeof(struct icmp6hdr), hlimit, tclass, NULL, &fl6,
Eldad Zacka2d91a02012-04-01 07:49:07 +0000613 (struct rt6_info *)dst, MSG_DONTWAIT,
Brian Haley13b52cd2010-04-23 11:26:08 +0000614 np->dontfrag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615
616 if (err) {
Eric Dumazet00d9d6a2010-06-07 22:24:44 +0000617 ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 ip6_flush_pending_frames(sk);
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000619 } else {
620 err = icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
621 skb->len + sizeof(struct icmp6hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 dst_release(dst);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900624out:
Denis V. Lunev405666d2008-02-29 11:16:46 -0800625 icmpv6_xmit_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626}
627
David S. Millerb94f1c02012-07-12 00:33:37 -0700628void icmpv6_notify(struct sk_buff *skb, u8 type, u8 code, __be32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629{
Alexey Dobriyan41135cc2009-09-14 12:22:28 +0000630 const struct inet6_protocol *ipprot;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 int inner_offset;
Jesse Gross75f28112011-11-30 17:05:51 -0800632 __be16 frag_off;
David S. Millerf9242b62012-06-19 18:56:21 -0700633 u8 nexthdr;
Duan Jiong7304fe42014-07-31 17:54:32 +0800634 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635
636 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
Duan Jiong7304fe42014-07-31 17:54:32 +0800637 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638
639 nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
640 if (ipv6_ext_hdr(nexthdr)) {
641 /* now skip over extension headers */
Jesse Gross75f28112011-11-30 17:05:51 -0800642 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr),
643 &nexthdr, &frag_off);
Ian Morris67ba4152014-08-24 21:53:10 +0100644 if (inner_offset < 0)
Duan Jiong7304fe42014-07-31 17:54:32 +0800645 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 } else {
647 inner_offset = sizeof(struct ipv6hdr);
648 }
649
650 /* Checkin header including 8 bytes of inner protocol header. */
651 if (!pskb_may_pull(skb, inner_offset+8))
Duan Jiong7304fe42014-07-31 17:54:32 +0800652 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
655 Without this we will not able f.e. to make source routed
656 pmtu discovery.
657 Corresponding argument (opt) to notifiers is already added.
658 --ANK (980726)
659 */
660
David S. Millerf9242b62012-06-19 18:56:21 -0700661 ipprot = rcu_dereference(inet6_protos[nexthdr]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 if (ipprot && ipprot->err_handler)
663 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664
Pavel Emelyanov69d6da02007-11-19 22:35:57 -0800665 raw6_icmp_error(skb, nexthdr, type, code, inner_offset, info);
Duan Jiong7304fe42014-07-31 17:54:32 +0800666 return;
667
668out:
669 ICMP6_INC_STATS_BH(net, __in6_dev_get(skb->dev), ICMP6_MIB_INERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670}
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900671
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672/*
673 * Handle icmp messages
674 */
675
Herbert Xue5bbef22007-10-15 12:50:28 -0700676static int icmpv6_rcv(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 struct net_device *dev = skb->dev;
679 struct inet6_dev *idev = __in6_dev_get(dev);
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000680 const struct in6_addr *saddr, *daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 struct icmp6hdr *hdr;
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700682 u8 type;
Rick Jonese3e32172014-11-17 14:04:29 -0800683 bool success = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684
Herbert Xuaebcf822007-12-12 18:54:16 -0800685 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -0700686 struct sec_path *sp = skb_sec_path(skb);
Herbert Xu8b7817f2007-12-12 10:44:43 -0800687 int nh;
688
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -0700689 if (!(sp && sp->xvec[sp->len - 1]->props.flags &
Herbert Xuaebcf822007-12-12 18:54:16 -0800690 XFRM_STATE_ICMP))
691 goto drop_no_count;
692
David S. Miller81aded22012-06-15 14:54:11 -0700693 if (!pskb_may_pull(skb, sizeof(*hdr) + sizeof(struct ipv6hdr)))
Herbert Xu8b7817f2007-12-12 10:44:43 -0800694 goto drop_no_count;
695
696 nh = skb_network_offset(skb);
697 skb_set_network_header(skb, sizeof(*hdr));
698
699 if (!xfrm6_policy_check_reverse(NULL, XFRM_POLICY_IN, skb))
700 goto drop_no_count;
701
702 skb_set_network_header(skb, nh);
703 }
704
Denis V. Luneve41b5362008-10-08 10:33:26 -0700705 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INMSGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700707 saddr = &ipv6_hdr(skb)->saddr;
708 daddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709
Tom Herbert39471ac2014-05-07 16:52:29 -0700710 if (skb_checksum_validate(skb, IPPROTO_ICMPV6, ip6_compute_pseudo)) {
Joe Perchesba7a46f2014-11-11 10:59:17 -0800711 net_dbg_ratelimited("ICMPv6 checksum failed [%pI6c > %pI6c]\n",
712 saddr, daddr);
Tom Herbert39471ac2014-05-07 16:52:29 -0700713 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 }
715
Herbert Xu8cf22942008-02-05 03:15:50 -0800716 if (!pskb_pull(skb, sizeof(*hdr)))
717 goto discard_it;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300719 hdr = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720
721 type = hdr->icmp6_type;
722
Denis V. Lunev55d43802008-10-08 10:34:54 -0700723 ICMP6MSGIN_INC_STATS_BH(dev_net(dev), idev, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724
725 switch (type) {
726 case ICMPV6_ECHO_REQUEST:
727 icmpv6_echo_reply(skb);
728 break;
729
730 case ICMPV6_ECHO_REPLY:
Rick Jonese3e32172014-11-17 14:04:29 -0800731 success = ping_rcv(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 break;
733
734 case ICMPV6_PKT_TOOBIG:
735 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
736 standard destination cache. Seems, only "advanced"
737 destination cache will allow to solve this problem
738 --ANK (980726)
739 */
740 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
741 goto discard_it;
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300742 hdr = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743
744 /*
745 * Drop through to notify
746 */
747
748 case ICMPV6_DEST_UNREACH:
749 case ICMPV6_TIME_EXCEED:
750 case ICMPV6_PARAMPROB:
751 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
752 break;
753
754 case NDISC_ROUTER_SOLICITATION:
755 case NDISC_ROUTER_ADVERTISEMENT:
756 case NDISC_NEIGHBOUR_SOLICITATION:
757 case NDISC_NEIGHBOUR_ADVERTISEMENT:
758 case NDISC_REDIRECT:
759 ndisc_rcv(skb);
760 break;
761
762 case ICMPV6_MGM_QUERY:
763 igmp6_event_query(skb);
764 break;
765
766 case ICMPV6_MGM_REPORT:
767 igmp6_event_report(skb);
768 break;
769
770 case ICMPV6_MGM_REDUCTION:
771 case ICMPV6_NI_QUERY:
772 case ICMPV6_NI_REPLY:
773 case ICMPV6_MLD2_REPORT:
774 case ICMPV6_DHAAD_REQUEST:
775 case ICMPV6_DHAAD_REPLY:
776 case ICMPV6_MOBILE_PREFIX_SOL:
777 case ICMPV6_MOBILE_PREFIX_ADV:
778 break;
779
780 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 /* informational */
782 if (type & ICMPV6_INFOMSG_MASK)
783 break;
784
Joe Perchesba7a46f2014-11-11 10:59:17 -0800785 net_dbg_ratelimited("icmpv6: msg of unknown type\n");
David S. Millerea85a0a2014-10-07 16:33:53 -0400786
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900787 /*
788 * error of unknown type.
789 * must pass to upper level
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 */
791
792 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700793 }
794
Rick Jonese3e32172014-11-17 14:04:29 -0800795 /* until the v6 path can be better sorted assume failure and
796 * preserve the status quo behaviour for the rest of the paths to here
797 */
798 if (success)
799 consume_skb(skb);
800 else
801 kfree_skb(skb);
802
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 return 0;
804
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +0000805csum_error:
806 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_CSUMERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807discard_it:
Denis V. Luneve41b5362008-10-08 10:33:26 -0700808 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INERRORS);
Herbert Xu8b7817f2007-12-12 10:44:43 -0800809drop_no_count:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 kfree_skb(skb);
811 return 0;
812}
813
David S. Miller4c9483b2011-03-12 16:22:43 -0500814void icmpv6_flow_init(struct sock *sk, struct flowi6 *fl6,
YOSHIFUJI Hideaki95e41e92007-12-06 15:43:30 -0800815 u8 type,
816 const struct in6_addr *saddr,
817 const struct in6_addr *daddr,
818 int oif)
819{
David S. Miller4c9483b2011-03-12 16:22:43 -0500820 memset(fl6, 0, sizeof(*fl6));
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000821 fl6->saddr = *saddr;
822 fl6->daddr = *daddr;
Ian Morris67ba4152014-08-24 21:53:10 +0100823 fl6->flowi6_proto = IPPROTO_ICMPV6;
David S. Miller1958b852011-03-12 16:36:19 -0500824 fl6->fl6_icmp_type = type;
825 fl6->fl6_icmp_code = 0;
David S. Miller4c9483b2011-03-12 16:22:43 -0500826 fl6->flowi6_oif = oif;
827 security_sk_classify_flow(sk, flowi6_to_flowi(fl6));
YOSHIFUJI Hideaki95e41e92007-12-06 15:43:30 -0800828}
829
Ingo Molnar640c41c2006-08-15 00:06:56 -0700830/*
Denis V. Lunevb7e729c2008-02-29 11:16:08 -0800831 * Special lock-class for __icmpv6_sk:
Ingo Molnar640c41c2006-08-15 00:06:56 -0700832 */
833static struct lock_class_key icmpv6_socket_sk_dst_lock_key;
834
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800835static int __net_init icmpv6_sk_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836{
837 struct sock *sk;
838 int err, i, j;
839
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800840 net->ipv6.icmp_sk =
841 kzalloc(nr_cpu_ids * sizeof(struct sock *), GFP_KERNEL);
842 if (net->ipv6.icmp_sk == NULL)
Denis V. Lunev79c91152008-02-29 11:17:11 -0800843 return -ENOMEM;
844
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -0700845 for_each_possible_cpu(i) {
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700846 err = inet_ctl_sock_create(&sk, PF_INET6,
847 SOCK_RAW, IPPROTO_ICMPV6, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 if (err < 0) {
Joe Perchesf3213832012-05-15 14:11:53 +0000849 pr_err("Failed to initialize the ICMP6 control socket (err %d)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 err);
851 goto fail;
852 }
853
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700854 net->ipv6.icmp_sk[i] = sk;
Denis V. Lunev5c8cafd2008-02-29 11:19:22 -0800855
Ingo Molnar640c41c2006-08-15 00:06:56 -0700856 /*
857 * Split off their lock-class, because sk->sk_dst_lock
858 * gets used from softirqs, which is safe for
Denis V. Lunevb7e729c2008-02-29 11:16:08 -0800859 * __icmpv6_sk (because those never get directly used
Ingo Molnar640c41c2006-08-15 00:06:56 -0700860 * via userspace syscalls), but unsafe for normal sockets.
861 */
862 lockdep_set_class(&sk->sk_dst_lock,
863 &icmpv6_socket_sk_dst_lock_key);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864
865 /* Enough space for 2 64K ICMP packets, including
866 * sk_buff struct overhead.
867 */
Eric Dumazet87fb4b72011-10-13 07:28:54 +0000868 sk->sk_sndbuf = 2 * SKB_TRUESIZE(64 * 1024);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 return 0;
871
872 fail:
Denis V. Lunev5c8cafd2008-02-29 11:19:22 -0800873 for (j = 0; j < i; j++)
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700874 inet_ctl_sock_destroy(net->ipv6.icmp_sk[j]);
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800875 kfree(net->ipv6.icmp_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 return err;
877}
878
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800879static void __net_exit icmpv6_sk_exit(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880{
881 int i;
882
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -0700883 for_each_possible_cpu(i) {
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700884 inet_ctl_sock_destroy(net->ipv6.icmp_sk[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 }
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800886 kfree(net->ipv6.icmp_sk);
887}
888
Alexey Dobriyan8ed7edc2008-03-03 12:02:54 -0800889static struct pernet_operations icmpv6_sk_ops = {
Ian Morris67ba4152014-08-24 21:53:10 +0100890 .init = icmpv6_sk_init,
891 .exit = icmpv6_sk_exit,
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800892};
893
894int __init icmpv6_init(void)
895{
896 int err;
897
898 err = register_pernet_subsys(&icmpv6_sk_ops);
899 if (err < 0)
900 return err;
901
902 err = -EAGAIN;
903 if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0)
904 goto fail;
Pravin B Shelar5f5624c2013-04-25 11:08:30 +0000905
906 err = inet6_register_icmp_sender(icmp6_send);
907 if (err)
908 goto sender_reg_err;
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800909 return 0;
910
Pravin B Shelar5f5624c2013-04-25 11:08:30 +0000911sender_reg_err:
912 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800913fail:
Joe Perchesf3213832012-05-15 14:11:53 +0000914 pr_err("Failed to register ICMP6 protocol\n");
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800915 unregister_pernet_subsys(&icmpv6_sk_ops);
916 return err;
917}
918
Alexey Dobriyan8ed7edc2008-03-03 12:02:54 -0800919void icmpv6_cleanup(void)
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800920{
Pravin B Shelar5f5624c2013-04-25 11:08:30 +0000921 inet6_unregister_icmp_sender(icmp6_send);
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800922 unregister_pernet_subsys(&icmpv6_sk_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
924}
925
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800926
Arjan van de Ven9b5b5cf2005-11-29 16:21:38 -0800927static const struct icmp6_err {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 int err;
929 int fatal;
930} tab_unreach[] = {
931 { /* NOROUTE */
932 .err = ENETUNREACH,
933 .fatal = 0,
934 },
935 { /* ADM_PROHIBITED */
936 .err = EACCES,
937 .fatal = 1,
938 },
939 { /* Was NOT_NEIGHBOUR, now reserved */
940 .err = EHOSTUNREACH,
941 .fatal = 0,
942 },
943 { /* ADDR_UNREACH */
944 .err = EHOSTUNREACH,
945 .fatal = 0,
946 },
947 { /* PORT_UNREACH */
948 .err = ECONNREFUSED,
949 .fatal = 1,
950 },
Jiri Bohac61e76b12013-08-30 11:18:45 +0200951 { /* POLICY_FAIL */
952 .err = EACCES,
953 .fatal = 1,
954 },
955 { /* REJECT_ROUTE */
956 .err = EACCES,
957 .fatal = 1,
958 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959};
960
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700961int icmpv6_err_convert(u8 type, u8 code, int *err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962{
963 int fatal = 0;
964
965 *err = EPROTO;
966
967 switch (type) {
968 case ICMPV6_DEST_UNREACH:
969 fatal = 1;
Jiri Bohac61e76b12013-08-30 11:18:45 +0200970 if (code < ARRAY_SIZE(tab_unreach)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 *err = tab_unreach[code].err;
972 fatal = tab_unreach[code].fatal;
973 }
974 break;
975
976 case ICMPV6_PKT_TOOBIG:
977 *err = EMSGSIZE;
978 break;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900979
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 case ICMPV6_PARAMPROB:
981 *err = EPROTO;
982 fatal = 1;
983 break;
984
985 case ICMPV6_TIME_EXCEED:
986 *err = EHOSTUNREACH;
987 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700988 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989
990 return fatal;
991}
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900992EXPORT_SYMBOL(icmpv6_err_convert);
993
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994#ifdef CONFIG_SYSCTL
stephen hemmingere8243532013-12-29 14:03:31 -0800995static struct ctl_table ipv6_icmp_table_template[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 .procname = "ratelimit",
Daniel Lezcano41a76902008-01-10 03:02:40 -0800998 .data = &init_net.ipv6.sysctl.icmpv6_time,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 .maxlen = sizeof(int),
1000 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -08001001 .proc_handler = proc_dointvec_ms_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 },
Eric W. Biedermanf8572d82009-11-05 13:32:03 -08001003 { },
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004};
Daniel Lezcano760f2d02008-01-10 02:53:43 -08001005
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001006struct ctl_table * __net_init ipv6_icmp_sysctl_init(struct net *net)
Daniel Lezcano760f2d02008-01-10 02:53:43 -08001007{
1008 struct ctl_table *table;
1009
1010 table = kmemdup(ipv6_icmp_table_template,
1011 sizeof(ipv6_icmp_table_template),
1012 GFP_KERNEL);
YOSHIFUJI Hideaki5ee09102008-02-28 00:24:28 +09001013
Eric W. Biedermanc027aab2012-11-16 03:03:10 +00001014 if (table)
YOSHIFUJI Hideaki5ee09102008-02-28 00:24:28 +09001015 table[0].data = &net->ipv6.sysctl.icmpv6_time;
1016
Daniel Lezcano760f2d02008-01-10 02:53:43 -08001017 return table;
1018}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019#endif