blob: f2610e15766027ce3a7408862d03f4c427c555ea [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 */
David S. Miller92d86822011-02-04 15:55:25 -0800173static inline bool icmpv6_xrlim_allow(struct sock *sk, u8 type,
David S. Miller4c9483b2011-03-12 16:22:43 -0500174 struct flowi6 *fl6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175{
176 struct dst_entry *dst;
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900177 struct net *net = sock_net(sk);
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;
David S. Millerfbfe95a2012-06-08 23:24:18 -0700202 struct inet_peer *peer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203
204 /* Give more bandwidth to wider prefixes. */
205 if (rt->rt6i_dst.plen < 128)
206 tmo >>= ((128 - rt->rt6i_dst.plen)>>5);
207
David S. Miller1d861aa2012-07-10 03:58:16 -0700208 peer = inet_getpeer_v6(net->ipv6.peers, &rt->rt6i_dst.addr, 1);
David S. Millerfbfe95a2012-06-08 23:24:18 -0700209 res = inet_peer_xrlim_allow(peer, tmo);
David S. Miller1d861aa2012-07-10 03:58:16 -0700210 if (peer)
211 inet_putpeer(peer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 }
213 dst_release(dst);
214 return res;
215}
216
217/*
218 * an inline helper for the "simple" if statement below
219 * checks if parameter problem report is caused by an
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900220 * unrecognized IPv6 option that has the Option Type
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 * highest-order two bits set to 10
222 */
223
Eric Dumazeta50feda2012-05-18 18:57:34 +0000224static bool opt_unrec(struct sk_buff *skb, __u32 offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225{
226 u8 _optval, *op;
227
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -0300228 offset += skb_network_offset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 op = skb_header_pointer(skb, offset, sizeof(_optval), &_optval);
230 if (op == NULL)
Eric Dumazeta50feda2012-05-18 18:57:34 +0000231 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 return (*op & 0xC0) == 0x80;
233}
234
Lorenzo Colitti6d0bfe22013-05-22 20:17:31 +0000235int icmpv6_push_pending_frames(struct sock *sk, struct flowi6 *fl6,
236 struct icmp6hdr *thdr, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237{
238 struct sk_buff *skb;
239 struct icmp6hdr *icmp6h;
240 int err = 0;
241
242 if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
243 goto out;
244
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300245 icmp6h = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 memcpy(icmp6h, thdr, sizeof(struct icmp6hdr));
247 icmp6h->icmp6_cksum = 0;
248
249 if (skb_queue_len(&sk->sk_write_queue) == 1) {
Joe Perches07f07572008-11-19 15:44:53 -0800250 skb->csum = csum_partial(icmp6h,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 sizeof(struct icmp6hdr), skb->csum);
David S. Miller4c9483b2011-03-12 16:22:43 -0500252 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
253 &fl6->daddr,
254 len, fl6->flowi6_proto,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 skb->csum);
256 } else {
Al Viro868c86b2006-11-14 21:35:48 -0800257 __wsum tmp_csum = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258
259 skb_queue_walk(&sk->sk_write_queue, skb) {
260 tmp_csum = csum_add(tmp_csum, skb->csum);
261 }
262
Joe Perches07f07572008-11-19 15:44:53 -0800263 tmp_csum = csum_partial(icmp6h,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 sizeof(struct icmp6hdr), tmp_csum);
David S. Miller4c9483b2011-03-12 16:22:43 -0500265 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
266 &fl6->daddr,
267 len, fl6->flowi6_proto,
Al Viro868c86b2006-11-14 21:35:48 -0800268 tmp_csum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 ip6_push_pending_frames(sk);
271out:
272 return err;
273}
274
275struct icmpv6_msg {
276 struct sk_buff *skb;
277 int offset;
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800278 uint8_t type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279};
280
281static int icmpv6_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb)
282{
283 struct icmpv6_msg *msg = (struct icmpv6_msg *) from;
284 struct sk_buff *org_skb = msg->skb;
Al Viro5f92a732006-11-14 21:36:54 -0800285 __wsum csum = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286
287 csum = skb_copy_and_csum_bits(org_skb, msg->offset + offset,
288 to, len, csum);
289 skb->csum = csum_block_add(skb->csum, csum, odd);
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800290 if (!(msg->type & ICMPV6_INFOMSG_MASK))
291 nf_ct_attach(skb, org_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 return 0;
293}
294
Amerigo Wang07a93622012-10-29 16:23:10 +0000295#if IS_ENABLED(CONFIG_IPV6_MIP6)
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700296static void mip6_addr_swap(struct sk_buff *skb)
297{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700298 struct ipv6hdr *iph = ipv6_hdr(skb);
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700299 struct inet6_skb_parm *opt = IP6CB(skb);
300 struct ipv6_destopt_hao *hao;
301 struct in6_addr tmp;
302 int off;
303
304 if (opt->dsthao) {
305 off = ipv6_find_tlv(skb, opt->dsthao, IPV6_TLV_HAO);
306 if (likely(off >= 0)) {
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700307 hao = (struct ipv6_destopt_hao *)
308 (skb_network_header(skb) + off);
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000309 tmp = iph->saddr;
310 iph->saddr = hao->addr;
311 hao->addr = tmp;
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700312 }
313 }
314}
315#else
316static inline void mip6_addr_swap(struct sk_buff *skb) {}
317#endif
318
stephen hemmingere8243532013-12-29 14:03:31 -0800319static struct dst_entry *icmpv6_route_lookup(struct net *net,
320 struct sk_buff *skb,
321 struct sock *sk,
322 struct flowi6 *fl6)
David S. Millerb42835d2011-03-01 22:06:22 -0800323{
324 struct dst_entry *dst, *dst2;
David S. Miller4c9483b2011-03-12 16:22:43 -0500325 struct flowi6 fl2;
David S. Millerb42835d2011-03-01 22:06:22 -0800326 int err;
327
David S. Miller4c9483b2011-03-12 16:22:43 -0500328 err = ip6_dst_lookup(sk, &dst, fl6);
David S. Millerb42835d2011-03-01 22:06:22 -0800329 if (err)
330 return ERR_PTR(err);
331
332 /*
333 * We won't send icmp if the destination is known
334 * anycast.
335 */
336 if (((struct rt6_info *)dst)->rt6i_flags & RTF_ANYCAST) {
Pravin B Shelar5f5624c2013-04-25 11:08:30 +0000337 LIMIT_NETDEBUG(KERN_DEBUG "icmp6_send: acast source\n");
David S. Millerb42835d2011-03-01 22:06:22 -0800338 dst_release(dst);
339 return ERR_PTR(-EINVAL);
340 }
341
342 /* No need to clone since we're just using its address. */
343 dst2 = dst;
344
David S. Miller4c9483b2011-03-12 16:22:43 -0500345 dst = xfrm_lookup(net, dst, flowi6_to_flowi(fl6), sk, 0);
David S. Miller452edd52011-03-02 13:27:41 -0800346 if (!IS_ERR(dst)) {
David S. Millerb42835d2011-03-01 22:06:22 -0800347 if (dst != dst2)
348 return dst;
David S. Miller452edd52011-03-02 13:27:41 -0800349 } else {
350 if (PTR_ERR(dst) == -EPERM)
351 dst = NULL;
352 else
353 return dst;
David S. Millerb42835d2011-03-01 22:06:22 -0800354 }
355
David S. Miller4c9483b2011-03-12 16:22:43 -0500356 err = xfrm_decode_session_reverse(skb, flowi6_to_flowi(&fl2), AF_INET6);
David S. Millerb42835d2011-03-01 22:06:22 -0800357 if (err)
358 goto relookup_failed;
359
360 err = ip6_dst_lookup(sk, &dst2, &fl2);
361 if (err)
362 goto relookup_failed;
363
David S. Miller4c9483b2011-03-12 16:22:43 -0500364 dst2 = xfrm_lookup(net, dst2, flowi6_to_flowi(&fl2), sk, XFRM_LOOKUP_ICMP);
David S. Miller452edd52011-03-02 13:27:41 -0800365 if (!IS_ERR(dst2)) {
David S. Millerb42835d2011-03-01 22:06:22 -0800366 dst_release(dst);
367 dst = dst2;
David S. Miller452edd52011-03-02 13:27:41 -0800368 } else {
369 err = PTR_ERR(dst2);
370 if (err == -EPERM) {
371 dst_release(dst);
372 return dst2;
373 } else
374 goto relookup_failed;
David S. Millerb42835d2011-03-01 22:06:22 -0800375 }
376
377relookup_failed:
378 if (dst)
379 return dst;
380 return ERR_PTR(err);
381}
382
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383/*
384 * Send an ICMP message in response to a packet in error
385 */
Pravin B Shelar5f5624c2013-04-25 11:08:30 +0000386static void icmp6_send(struct sk_buff *skb, u8 type, u8 code, __u32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900388 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 struct inet6_dev *idev = NULL;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700390 struct ipv6hdr *hdr = ipv6_hdr(skb);
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700391 struct sock *sk;
392 struct ipv6_pinfo *np;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000393 const struct in6_addr *saddr = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 struct dst_entry *dst;
395 struct icmp6hdr tmp_hdr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500396 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 struct icmpv6_msg msg;
398 int iif = 0;
399 int addr_type = 0;
400 int len;
Gerrit Renkere651f032009-08-09 08:12:48 +0000401 int hlimit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 int err = 0;
403
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700404 if ((u8 *)hdr < skb->head ||
Simon Horman29a3cad2013-05-28 20:34:26 +0000405 (skb_network_header(skb) + sizeof(*hdr)) > skb_tail_pointer(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 return;
407
408 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900409 * Make sure we respect the rules
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 * i.e. RFC 1885 2.4(e)
Pravin B Shelar5f5624c2013-04-25 11:08:30 +0000411 * Rule (e.1) is enforced by not using icmp6_send
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 * in any code that processes icmp errors.
413 */
414 addr_type = ipv6_addr_type(&hdr->daddr);
415
FX Le Bail446fab52014-01-19 17:00:36 +0100416 if (ipv6_chk_addr(net, &hdr->daddr, skb->dev, 0) ||
FX Le Baild94c1f92014-02-07 11:22:37 +0100417 ipv6_chk_acast_addr_src(net, skb->dev, &hdr->daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 saddr = &hdr->daddr;
419
420 /*
421 * Dest addr check
422 */
423
424 if ((addr_type & IPV6_ADDR_MULTICAST || skb->pkt_type != PACKET_HOST)) {
425 if (type != ICMPV6_PKT_TOOBIG &&
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900426 !(type == ICMPV6_PARAMPROB &&
427 code == ICMPV6_UNK_OPTION &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 (opt_unrec(skb, info))))
429 return;
430
431 saddr = NULL;
432 }
433
434 addr_type = ipv6_addr_type(&hdr->saddr);
435
436 /*
437 * Source addr check
438 */
439
Hannes Frederic Sowa842df072013-03-08 02:07:19 +0000440 if (__ipv6_addr_needs_scope_id(addr_type))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 iif = skb->dev->ifindex;
442
443 /*
YOSHIFUJI Hideaki8de33512005-12-21 22:57:06 +0900444 * Must not send error if the source does not uniquely
445 * identify a single node (RFC2463 Section 2.4).
446 * We check unspecified / multicast addresses here,
447 * and anycast addresses will be checked later.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 */
449 if ((addr_type == IPV6_ADDR_ANY) || (addr_type & IPV6_ADDR_MULTICAST)) {
Pravin B Shelar5f5624c2013-04-25 11:08:30 +0000450 LIMIT_NETDEBUG(KERN_DEBUG "icmp6_send: addr_any/mcast source\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 return;
452 }
453
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900454 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 * Never answer to a ICMP packet.
456 */
457 if (is_ineligible(skb)) {
Pravin B Shelar5f5624c2013-04-25 11:08:30 +0000458 LIMIT_NETDEBUG(KERN_DEBUG "icmp6_send: no reply to icmp error\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 return;
460 }
461
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700462 mip6_addr_swap(skb);
463
David S. Miller4c9483b2011-03-12 16:22:43 -0500464 memset(&fl6, 0, sizeof(fl6));
465 fl6.flowi6_proto = IPPROTO_ICMPV6;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000466 fl6.daddr = hdr->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 if (saddr)
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000468 fl6.saddr = *saddr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500469 fl6.flowi6_oif = iif;
David S. Miller1958b852011-03-12 16:36:19 -0500470 fl6.fl6_icmp_type = type;
471 fl6.fl6_icmp_code = code;
David S. Miller4c9483b2011-03-12 16:22:43 -0500472 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700474 sk = icmpv6_xmit_lock(net);
475 if (sk == NULL)
Denis V. Lunev405666d2008-02-29 11:16:46 -0800476 return;
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700477 np = inet6_sk(sk);
Denis V. Lunev405666d2008-02-29 11:16:46 -0800478
David S. Miller4c9483b2011-03-12 16:22:43 -0500479 if (!icmpv6_xrlim_allow(sk, type, &fl6))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 goto out;
481
482 tmp_hdr.icmp6_type = type;
483 tmp_hdr.icmp6_code = code;
484 tmp_hdr.icmp6_cksum = 0;
485 tmp_hdr.icmp6_pointer = htonl(info);
486
David S. Miller4c9483b2011-03-12 16:22:43 -0500487 if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
488 fl6.flowi6_oif = np->mcast_oif;
Erich E. Hooverc4062df2012-02-08 09:11:08 +0000489 else if (!fl6.flowi6_oif)
490 fl6.flowi6_oif = np->ucast_oif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491
David S. Miller4c9483b2011-03-12 16:22:43 -0500492 dst = icmpv6_route_lookup(net, skb, sk, &fl6);
David S. Millerb42835d2011-03-01 22:06:22 -0800493 if (IS_ERR(dst))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 goto out;
YOSHIFUJI Hideaki8de33512005-12-21 22:57:06 +0900495
David S. Miller4c9483b2011-03-12 16:22:43 -0500496 if (ipv6_addr_is_multicast(&fl6.daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 hlimit = np->mcast_hops;
498 else
499 hlimit = np->hop_limit;
500 if (hlimit < 0)
YOSHIFUJI Hideaki6b75d092008-03-10 06:00:30 -0400501 hlimit = ip6_dst_hoplimit(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502
503 msg.skb = skb;
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -0300504 msg.offset = skb_network_offset(skb);
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800505 msg.type = type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
507 len = skb->len - msg.offset;
508 len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) -sizeof(struct icmp6hdr));
509 if (len < 0) {
Patrick McHardy64ce2072005-08-09 20:50:53 -0700510 LIMIT_NETDEBUG(KERN_DEBUG "icmp: len problem\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 goto out_dst_release;
512 }
513
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000514 rcu_read_lock();
515 idev = __in6_dev_get(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516
517 err = ip6_append_data(sk, icmpv6_getfrag, &msg,
518 len + sizeof(struct icmp6hdr),
Gerrit Renkere651f032009-08-09 08:12:48 +0000519 sizeof(struct icmp6hdr), hlimit,
Eldad Zacka2d91a02012-04-01 07:49:07 +0000520 np->tclass, NULL, &fl6, (struct rt6_info *)dst,
Brian Haley13b52cd2010-04-23 11:26:08 +0000521 MSG_DONTWAIT, np->dontfrag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 if (err) {
Eric Dumazet00d9d6a2010-06-07 22:24:44 +0000523 ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 ip6_flush_pending_frames(sk);
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000525 } else {
526 err = icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
527 len + sizeof(struct icmp6hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 }
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000529 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530out_dst_release:
531 dst_release(dst);
532out:
Denis V. Lunev405666d2008-02-29 11:16:46 -0800533 icmpv6_xmit_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534}
Pravin B Shelar5f5624c2013-04-25 11:08:30 +0000535
536/* Slightly more convenient version of icmp6_send.
537 */
538void icmpv6_param_prob(struct sk_buff *skb, u8 code, int pos)
539{
540 icmp6_send(skb, ICMPV6_PARAMPROB, code, pos);
541 kfree_skb(skb);
542}
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900543
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544static void icmpv6_echo_reply(struct sk_buff *skb)
545{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900546 struct net *net = dev_net(skb->dev);
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700547 struct sock *sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 struct inet6_dev *idev;
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700549 struct ipv6_pinfo *np;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000550 const struct in6_addr *saddr = NULL;
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300551 struct icmp6hdr *icmph = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 struct icmp6hdr tmp_hdr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500553 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 struct icmpv6_msg msg;
555 struct dst_entry *dst;
556 int err = 0;
557 int hlimit;
Hannes Frederic Sowa825edac2014-01-11 11:55:46 +0100558 u8 tclass;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700560 saddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561
FX Le Bail509aba32014-01-07 14:57:27 +0100562 if (!ipv6_unicast_destination(skb) &&
FX Le Bailec35b612014-01-13 15:59:01 +0100563 !(net->ipv6.sysctl.anycast_src_echo_reply &&
FX Le Bail509aba32014-01-07 14:57:27 +0100564 ipv6_anycast_destination(skb)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 saddr = NULL;
566
567 memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
568 tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;
569
David S. Miller4c9483b2011-03-12 16:22:43 -0500570 memset(&fl6, 0, sizeof(fl6));
571 fl6.flowi6_proto = IPPROTO_ICMPV6;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000572 fl6.daddr = ipv6_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 if (saddr)
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000574 fl6.saddr = *saddr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500575 fl6.flowi6_oif = skb->dev->ifindex;
David S. Miller1958b852011-03-12 16:36:19 -0500576 fl6.fl6_icmp_type = ICMPV6_ECHO_REPLY;
David S. Miller4c9483b2011-03-12 16:22:43 -0500577 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700579 sk = icmpv6_xmit_lock(net);
580 if (sk == NULL)
Denis V. Lunev405666d2008-02-29 11:16:46 -0800581 return;
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700582 np = inet6_sk(sk);
Denis V. Lunev405666d2008-02-29 11:16:46 -0800583
David S. Miller4c9483b2011-03-12 16:22:43 -0500584 if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
585 fl6.flowi6_oif = np->mcast_oif;
Erich E. Hooverc4062df2012-02-08 09:11:08 +0000586 else if (!fl6.flowi6_oif)
587 fl6.flowi6_oif = np->ucast_oif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588
David S. Miller4c9483b2011-03-12 16:22:43 -0500589 err = ip6_dst_lookup(sk, &dst, &fl6);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 if (err)
591 goto out;
David S. Miller4c9483b2011-03-12 16:22:43 -0500592 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), sk, 0);
David S. Miller452edd52011-03-02 13:27:41 -0800593 if (IS_ERR(dst))
Patrick McHardye104411b2005-09-08 15:11:55 -0700594 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595
David S. Miller4c9483b2011-03-12 16:22:43 -0500596 if (ipv6_addr_is_multicast(&fl6.daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 hlimit = np->mcast_hops;
598 else
599 hlimit = np->hop_limit;
600 if (hlimit < 0)
YOSHIFUJI Hideaki6b75d092008-03-10 06:00:30 -0400601 hlimit = ip6_dst_hoplimit(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000603 idev = __in6_dev_get(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604
605 msg.skb = skb;
606 msg.offset = 0;
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800607 msg.type = ICMPV6_ECHO_REPLY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608
Hannes Frederic Sowa825edac2014-01-11 11:55:46 +0100609 tclass = ipv6_get_dsfield(ipv6_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
Hannes Frederic Sowa825edac2014-01-11 11:55:46 +0100611 sizeof(struct icmp6hdr), hlimit, tclass, NULL, &fl6,
Eldad Zacka2d91a02012-04-01 07:49:07 +0000612 (struct rt6_info *)dst, MSG_DONTWAIT,
Brian Haley13b52cd2010-04-23 11:26:08 +0000613 np->dontfrag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614
615 if (err) {
Eric Dumazet00d9d6a2010-06-07 22:24:44 +0000616 ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 ip6_flush_pending_frames(sk);
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000618 } else {
619 err = icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
620 skb->len + sizeof(struct icmp6hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 dst_release(dst);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900623out:
Denis V. Lunev405666d2008-02-29 11:16:46 -0800624 icmpv6_xmit_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625}
626
David S. Millerb94f1c02012-07-12 00:33:37 -0700627void icmpv6_notify(struct sk_buff *skb, u8 type, u8 code, __be32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628{
Alexey Dobriyan41135cc2009-09-14 12:22:28 +0000629 const struct inet6_protocol *ipprot;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 int inner_offset;
Jesse Gross75f28112011-11-30 17:05:51 -0800631 __be16 frag_off;
David S. Millerf9242b62012-06-19 18:56:21 -0700632 u8 nexthdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633
634 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
635 return;
636
637 nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
638 if (ipv6_ext_hdr(nexthdr)) {
639 /* now skip over extension headers */
Jesse Gross75f28112011-11-30 17:05:51 -0800640 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr),
641 &nexthdr, &frag_off);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 if (inner_offset<0)
643 return;
644 } else {
645 inner_offset = sizeof(struct ipv6hdr);
646 }
647
648 /* Checkin header including 8 bytes of inner protocol header. */
649 if (!pskb_may_pull(skb, inner_offset+8))
650 return;
651
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
653 Without this we will not able f.e. to make source routed
654 pmtu discovery.
655 Corresponding argument (opt) to notifiers is already added.
656 --ANK (980726)
657 */
658
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 rcu_read_lock();
David S. Millerf9242b62012-06-19 18:56:21 -0700660 ipprot = rcu_dereference(inet6_protos[nexthdr]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 if (ipprot && ipprot->err_handler)
662 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
663 rcu_read_unlock();
664
Pavel Emelyanov69d6da02007-11-19 22:35:57 -0800665 raw6_icmp_error(skb, nexthdr, type, code, inner_offset, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666}
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900667
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668/*
669 * Handle icmp messages
670 */
671
Herbert Xue5bbef22007-10-15 12:50:28 -0700672static int icmpv6_rcv(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 struct net_device *dev = skb->dev;
675 struct inet6_dev *idev = __in6_dev_get(dev);
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000676 const struct in6_addr *saddr, *daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 struct icmp6hdr *hdr;
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700678 u8 type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679
Herbert Xuaebcf822007-12-12 18:54:16 -0800680 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -0700681 struct sec_path *sp = skb_sec_path(skb);
Herbert Xu8b7817f2007-12-12 10:44:43 -0800682 int nh;
683
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -0700684 if (!(sp && sp->xvec[sp->len - 1]->props.flags &
Herbert Xuaebcf822007-12-12 18:54:16 -0800685 XFRM_STATE_ICMP))
686 goto drop_no_count;
687
David S. Miller81aded22012-06-15 14:54:11 -0700688 if (!pskb_may_pull(skb, sizeof(*hdr) + sizeof(struct ipv6hdr)))
Herbert Xu8b7817f2007-12-12 10:44:43 -0800689 goto drop_no_count;
690
691 nh = skb_network_offset(skb);
692 skb_set_network_header(skb, sizeof(*hdr));
693
694 if (!xfrm6_policy_check_reverse(NULL, XFRM_POLICY_IN, skb))
695 goto drop_no_count;
696
697 skb_set_network_header(skb, nh);
698 }
699
Denis V. Luneve41b5362008-10-08 10:33:26 -0700700 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INMSGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700702 saddr = &ipv6_hdr(skb)->saddr;
703 daddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704
705 /* Perform checksum. */
Herbert Xufb286bb2005-11-10 13:01:24 -0800706 switch (skb->ip_summed) {
Patrick McHardy84fa7932006-08-29 16:44:56 -0700707 case CHECKSUM_COMPLETE:
Herbert Xufb286bb2005-11-10 13:01:24 -0800708 if (!csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
709 skb->csum))
710 break;
711 /* fall through */
712 case CHECKSUM_NONE:
Al Viro868c86b2006-11-14 21:35:48 -0800713 skb->csum = ~csum_unfold(csum_ipv6_magic(saddr, daddr, skb->len,
714 IPPROTO_ICMPV6, 0));
Herbert Xufb286bb2005-11-10 13:01:24 -0800715 if (__skb_checksum_complete(skb)) {
Lorenzo Colitti6d0bfe22013-05-22 20:17:31 +0000716 LIMIT_NETDEBUG(KERN_DEBUG
717 "ICMPv6 checksum failed [%pI6c > %pI6c]\n",
Harvey Harrison0c6ce782008-10-28 16:09:23 -0700718 saddr, daddr);
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +0000719 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 }
721 }
722
Herbert Xu8cf22942008-02-05 03:15:50 -0800723 if (!pskb_pull(skb, sizeof(*hdr)))
724 goto discard_it;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300726 hdr = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727
728 type = hdr->icmp6_type;
729
Denis V. Lunev55d43802008-10-08 10:34:54 -0700730 ICMP6MSGIN_INC_STATS_BH(dev_net(dev), idev, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731
732 switch (type) {
733 case ICMPV6_ECHO_REQUEST:
734 icmpv6_echo_reply(skb);
735 break;
736
737 case ICMPV6_ECHO_REPLY:
Lorenzo Colitti6d0bfe22013-05-22 20:17:31 +0000738 ping_rcv(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 break;
740
741 case ICMPV6_PKT_TOOBIG:
742 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
743 standard destination cache. Seems, only "advanced"
744 destination cache will allow to solve this problem
745 --ANK (980726)
746 */
747 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
748 goto discard_it;
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300749 hdr = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750
751 /*
752 * Drop through to notify
753 */
754
755 case ICMPV6_DEST_UNREACH:
756 case ICMPV6_TIME_EXCEED:
757 case ICMPV6_PARAMPROB:
758 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
759 break;
760
761 case NDISC_ROUTER_SOLICITATION:
762 case NDISC_ROUTER_ADVERTISEMENT:
763 case NDISC_NEIGHBOUR_SOLICITATION:
764 case NDISC_NEIGHBOUR_ADVERTISEMENT:
765 case NDISC_REDIRECT:
766 ndisc_rcv(skb);
767 break;
768
769 case ICMPV6_MGM_QUERY:
770 igmp6_event_query(skb);
771 break;
772
773 case ICMPV6_MGM_REPORT:
774 igmp6_event_report(skb);
775 break;
776
777 case ICMPV6_MGM_REDUCTION:
778 case ICMPV6_NI_QUERY:
779 case ICMPV6_NI_REPLY:
780 case ICMPV6_MLD2_REPORT:
781 case ICMPV6_DHAAD_REQUEST:
782 case ICMPV6_DHAAD_REPLY:
783 case ICMPV6_MOBILE_PREFIX_SOL:
784 case ICMPV6_MOBILE_PREFIX_ADV:
785 break;
786
787 default:
Patrick McHardy64ce2072005-08-09 20:50:53 -0700788 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6: msg of unknown type\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789
790 /* informational */
791 if (type & ICMPV6_INFOMSG_MASK)
792 break;
793
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900794 /*
795 * error of unknown type.
796 * must pass to upper level
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 */
798
799 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700800 }
801
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 kfree_skb(skb);
803 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;
David S. Miller4c9483b2011-03-12 16:22:43 -0500823 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 = {
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800890 .init = icmpv6_sk_init,
891 .exit = icmpv6_sk_exit,
892};
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
1020