blob: 67ae4e0d40bf239e969792b1edeac7c6b1fbf4c8 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070070
71#include <asm/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070072
Linus Torvalds1da177e2005-04-16 15:20:36 -070073/*
74 * The ICMP socket(s). This is the most convenient way to flow control
75 * our ICMP output as well as maintain a clean interface throughout
76 * all layers. All Socketless IP sends will soon be gone.
77 *
78 * On SMP we have one ICMP socket per-cpu.
79 */
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -080080static inline struct sock *icmpv6_sk(struct net *net)
81{
82 return net->ipv6.icmp_sk[smp_processor_id()];
83}
Linus Torvalds1da177e2005-04-16 15:20:36 -070084
Steffen Klassert6f809da2013-01-16 22:09:49 +000085static void icmpv6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
86 u8 type, u8 code, int offset, __be32 info)
87{
Lorenzo Colitti6d0bfe22013-05-22 20:17:31 +000088 /* icmpv6_notify checks 8 bytes can be pulled, icmp6hdr is 8 bytes */
89 struct icmp6hdr *icmp6 = (struct icmp6hdr *) (skb->data + offset);
Steffen Klassert6f809da2013-01-16 22:09:49 +000090 struct net *net = dev_net(skb->dev);
91
92 if (type == ICMPV6_PKT_TOOBIG)
93 ip6_update_pmtu(skb, net, info, 0, 0);
94 else if (type == NDISC_REDIRECT)
95 ip6_redirect(skb, net, 0, 0);
Lorenzo Colitti6d0bfe22013-05-22 20:17:31 +000096
97 if (!(type & ICMPV6_INFOMSG_MASK))
98 if (icmp6->icmp6_type == ICMPV6_ECHO_REQUEST)
99 ping_err(skb, offset, info);
Steffen Klassert6f809da2013-01-16 22:09:49 +0000100}
101
Herbert Xue5bbef22007-10-15 12:50:28 -0700102static int icmpv6_rcv(struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103
Alexey Dobriyan41135cc2009-09-14 12:22:28 +0000104static const struct inet6_protocol icmpv6_protocol = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 .handler = icmpv6_rcv,
Steffen Klassert6f809da2013-01-16 22:09:49 +0000106 .err_handler = icmpv6_err,
Herbert Xu8b7817f2007-12-12 10:44:43 -0800107 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108};
109
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700110static __inline__ struct sock *icmpv6_xmit_lock(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111{
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700112 struct sock *sk;
113
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 local_bh_disable();
115
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700116 sk = icmpv6_sk(net);
Denis V. Lunev405666d2008-02-29 11:16:46 -0800117 if (unlikely(!spin_trylock(&sk->sk_lock.slock))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 /* This can happen if the output path (f.e. SIT or
119 * ip6ip6 tunnel) signals dst_link_failure() for an
120 * outgoing ICMP6 packet.
121 */
122 local_bh_enable();
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700123 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 }
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700125 return sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126}
127
Denis V. Lunev405666d2008-02-29 11:16:46 -0800128static __inline__ void icmpv6_xmit_unlock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129{
Denis V. Lunev405666d2008-02-29 11:16:46 -0800130 spin_unlock_bh(&sk->sk_lock.slock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131}
132
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900133/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 * Figure out, may we reply to this packet with icmp error.
135 *
136 * We do not reply, if:
137 * - it was icmp error message.
138 * - it is truncated, so that it is known, that protocol is ICMPV6
139 * (i.e. in the middle of some exthdr)
140 *
141 * --ANK (980726)
142 */
143
Eric Dumazeta50feda2012-05-18 18:57:34 +0000144static bool is_ineligible(const struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700146 int ptr = (u8 *)(ipv6_hdr(skb) + 1) - skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 int len = skb->len - ptr;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700148 __u8 nexthdr = ipv6_hdr(skb)->nexthdr;
Jesse Gross75f28112011-11-30 17:05:51 -0800149 __be16 frag_off;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150
151 if (len < 0)
Eric Dumazeta50feda2012-05-18 18:57:34 +0000152 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
Jesse Gross75f28112011-11-30 17:05:51 -0800154 ptr = ipv6_skip_exthdr(skb, ptr, &nexthdr, &frag_off);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 if (ptr < 0)
Eric Dumazeta50feda2012-05-18 18:57:34 +0000156 return false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 if (nexthdr == IPPROTO_ICMPV6) {
158 u8 _type, *tp;
159 tp = skb_header_pointer(skb,
160 ptr+offsetof(struct icmp6hdr, icmp6_type),
161 sizeof(_type), &_type);
162 if (tp == NULL ||
163 !(*tp & ICMPV6_INFOMSG_MASK))
Eric Dumazeta50feda2012-05-18 18:57:34 +0000164 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 }
Eric Dumazeta50feda2012-05-18 18:57:34 +0000166 return false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167}
168
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900169/*
170 * Check the ICMP output rate limit
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 */
David S. Miller92d86822011-02-04 15:55:25 -0800172static inline bool icmpv6_xrlim_allow(struct sock *sk, u8 type,
David S. Miller4c9483b2011-03-12 16:22:43 -0500173 struct flowi6 *fl6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174{
175 struct dst_entry *dst;
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900176 struct net *net = sock_net(sk);
David S. Miller92d86822011-02-04 15:55:25 -0800177 bool res = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178
179 /* Informational messages are not limited. */
180 if (type & ICMPV6_INFOMSG_MASK)
David S. Miller92d86822011-02-04 15:55:25 -0800181 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182
183 /* Do not limit pmtu discovery, it would break it. */
184 if (type == ICMPV6_PKT_TOOBIG)
David S. Miller92d86822011-02-04 15:55:25 -0800185 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900187 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 * Look up the output route.
189 * XXX: perhaps the expire for routing entries cloned by
190 * this lookup should be more aggressive (not longer than timeout).
191 */
David S. Miller4c9483b2011-03-12 16:22:43 -0500192 dst = ip6_route_output(net, sk, fl6);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 if (dst->error) {
Denis V. Lunev3bd653c2008-10-08 10:54:51 -0700194 IP6_INC_STATS(net, ip6_dst_idev(dst),
YOSHIFUJI Hideakia11d2062006-11-04 20:11:37 +0900195 IPSTATS_MIB_OUTNOROUTES);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 } else if (dst->dev && (dst->dev->flags&IFF_LOOPBACK)) {
David S. Miller92d86822011-02-04 15:55:25 -0800197 res = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 } else {
199 struct rt6_info *rt = (struct rt6_info *)dst;
Benjamin Thery9a43b702008-03-05 10:49:18 -0800200 int tmo = net->ipv6.sysctl.icmpv6_time;
David S. Millerfbfe95a2012-06-08 23:24:18 -0700201 struct inet_peer *peer;
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
David S. Miller1d861aa2012-07-10 03:58:16 -0700207 peer = inet_getpeer_v6(net->ipv6.peers, &rt->rt6i_dst.addr, 1);
David S. Millerfbfe95a2012-06-08 23:24:18 -0700208 res = inet_peer_xrlim_allow(peer, tmo);
David S. Miller1d861aa2012-07-10 03:58:16 -0700209 if (peer)
210 inet_putpeer(peer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 }
212 dst_release(dst);
213 return res;
214}
215
216/*
217 * an inline helper for the "simple" if statement below
218 * checks if parameter problem report is caused by an
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900219 * unrecognized IPv6 option that has the Option Type
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 * highest-order two bits set to 10
221 */
222
Eric Dumazeta50feda2012-05-18 18:57:34 +0000223static bool opt_unrec(struct sk_buff *skb, __u32 offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224{
225 u8 _optval, *op;
226
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -0300227 offset += skb_network_offset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 op = skb_header_pointer(skb, offset, sizeof(_optval), &_optval);
229 if (op == NULL)
Eric Dumazeta50feda2012-05-18 18:57:34 +0000230 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 return (*op & 0xC0) == 0x80;
232}
233
Lorenzo Colitti6d0bfe22013-05-22 20:17:31 +0000234int icmpv6_push_pending_frames(struct sock *sk, struct flowi6 *fl6,
235 struct icmp6hdr *thdr, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236{
237 struct sk_buff *skb;
238 struct icmp6hdr *icmp6h;
239 int err = 0;
240
241 if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
242 goto out;
243
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300244 icmp6h = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 memcpy(icmp6h, thdr, sizeof(struct icmp6hdr));
246 icmp6h->icmp6_cksum = 0;
247
248 if (skb_queue_len(&sk->sk_write_queue) == 1) {
Joe Perches07f07572008-11-19 15:44:53 -0800249 skb->csum = csum_partial(icmp6h,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 sizeof(struct icmp6hdr), skb->csum);
David S. Miller4c9483b2011-03-12 16:22:43 -0500251 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
252 &fl6->daddr,
253 len, fl6->flowi6_proto,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 skb->csum);
255 } else {
Al Viro868c86b2006-11-14 21:35:48 -0800256 __wsum tmp_csum = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257
258 skb_queue_walk(&sk->sk_write_queue, skb) {
259 tmp_csum = csum_add(tmp_csum, skb->csum);
260 }
261
Joe Perches07f07572008-11-19 15:44:53 -0800262 tmp_csum = csum_partial(icmp6h,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 sizeof(struct icmp6hdr), tmp_csum);
David S. Miller4c9483b2011-03-12 16:22:43 -0500264 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
265 &fl6->daddr,
266 len, fl6->flowi6_proto,
Al Viro868c86b2006-11-14 21:35:48 -0800267 tmp_csum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 ip6_push_pending_frames(sk);
270out:
271 return err;
272}
273
274struct icmpv6_msg {
275 struct sk_buff *skb;
276 int offset;
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800277 uint8_t type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278};
279
280static int icmpv6_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb)
281{
282 struct icmpv6_msg *msg = (struct icmpv6_msg *) from;
283 struct sk_buff *org_skb = msg->skb;
Al Viro5f92a732006-11-14 21:36:54 -0800284 __wsum csum = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285
286 csum = skb_copy_and_csum_bits(org_skb, msg->offset + offset,
287 to, len, csum);
288 skb->csum = csum_block_add(skb->csum, csum, odd);
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800289 if (!(msg->type & ICMPV6_INFOMSG_MASK))
290 nf_ct_attach(skb, org_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 return 0;
292}
293
Amerigo Wang07a93622012-10-29 16:23:10 +0000294#if IS_ENABLED(CONFIG_IPV6_MIP6)
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700295static void mip6_addr_swap(struct sk_buff *skb)
296{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700297 struct ipv6hdr *iph = ipv6_hdr(skb);
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700298 struct inet6_skb_parm *opt = IP6CB(skb);
299 struct ipv6_destopt_hao *hao;
300 struct in6_addr tmp;
301 int off;
302
303 if (opt->dsthao) {
304 off = ipv6_find_tlv(skb, opt->dsthao, IPV6_TLV_HAO);
305 if (likely(off >= 0)) {
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700306 hao = (struct ipv6_destopt_hao *)
307 (skb_network_header(skb) + off);
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000308 tmp = iph->saddr;
309 iph->saddr = hao->addr;
310 hao->addr = tmp;
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700311 }
312 }
313}
314#else
315static inline void mip6_addr_swap(struct sk_buff *skb) {}
316#endif
317
Lorenzo Colitti6d0bfe22013-05-22 20:17:31 +0000318struct dst_entry *icmpv6_route_lookup(struct net *net, struct sk_buff *skb,
319 struct sock *sk, struct flowi6 *fl6)
David S. Millerb42835d2011-03-01 22:06:22 -0800320{
321 struct dst_entry *dst, *dst2;
David S. Miller4c9483b2011-03-12 16:22:43 -0500322 struct flowi6 fl2;
David S. Millerb42835d2011-03-01 22:06:22 -0800323 int err;
324
David S. Miller4c9483b2011-03-12 16:22:43 -0500325 err = ip6_dst_lookup(sk, &dst, fl6);
David S. Millerb42835d2011-03-01 22:06:22 -0800326 if (err)
327 return ERR_PTR(err);
328
329 /*
330 * We won't send icmp if the destination is known
331 * anycast.
332 */
333 if (((struct rt6_info *)dst)->rt6i_flags & RTF_ANYCAST) {
Pravin B Shelar5f5624c2013-04-25 11:08:30 +0000334 LIMIT_NETDEBUG(KERN_DEBUG "icmp6_send: acast source\n");
David S. Millerb42835d2011-03-01 22:06:22 -0800335 dst_release(dst);
336 return ERR_PTR(-EINVAL);
337 }
338
339 /* No need to clone since we're just using its address. */
340 dst2 = dst;
341
David S. Miller4c9483b2011-03-12 16:22:43 -0500342 dst = xfrm_lookup(net, dst, flowi6_to_flowi(fl6), sk, 0);
David S. Miller452edd52011-03-02 13:27:41 -0800343 if (!IS_ERR(dst)) {
David S. Millerb42835d2011-03-01 22:06:22 -0800344 if (dst != dst2)
345 return dst;
David S. Miller452edd52011-03-02 13:27:41 -0800346 } else {
347 if (PTR_ERR(dst) == -EPERM)
348 dst = NULL;
349 else
350 return dst;
David S. Millerb42835d2011-03-01 22:06:22 -0800351 }
352
David S. Miller4c9483b2011-03-12 16:22:43 -0500353 err = xfrm_decode_session_reverse(skb, flowi6_to_flowi(&fl2), AF_INET6);
David S. Millerb42835d2011-03-01 22:06:22 -0800354 if (err)
355 goto relookup_failed;
356
357 err = ip6_dst_lookup(sk, &dst2, &fl2);
358 if (err)
359 goto relookup_failed;
360
David S. Miller4c9483b2011-03-12 16:22:43 -0500361 dst2 = xfrm_lookup(net, dst2, flowi6_to_flowi(&fl2), sk, XFRM_LOOKUP_ICMP);
David S. Miller452edd52011-03-02 13:27:41 -0800362 if (!IS_ERR(dst2)) {
David S. Millerb42835d2011-03-01 22:06:22 -0800363 dst_release(dst);
364 dst = dst2;
David S. Miller452edd52011-03-02 13:27:41 -0800365 } else {
366 err = PTR_ERR(dst2);
367 if (err == -EPERM) {
368 dst_release(dst);
369 return dst2;
370 } else
371 goto relookup_failed;
David S. Millerb42835d2011-03-01 22:06:22 -0800372 }
373
374relookup_failed:
375 if (dst)
376 return dst;
377 return ERR_PTR(err);
378}
379
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380/*
381 * Send an ICMP message in response to a packet in error
382 */
Pravin B Shelar5f5624c2013-04-25 11:08:30 +0000383static void icmp6_send(struct sk_buff *skb, u8 type, u8 code, __u32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900385 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 struct inet6_dev *idev = NULL;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700387 struct ipv6hdr *hdr = ipv6_hdr(skb);
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700388 struct sock *sk;
389 struct ipv6_pinfo *np;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000390 const struct in6_addr *saddr = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 struct dst_entry *dst;
392 struct icmp6hdr tmp_hdr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500393 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 struct icmpv6_msg msg;
395 int iif = 0;
396 int addr_type = 0;
397 int len;
Gerrit Renkere651f032009-08-09 08:12:48 +0000398 int hlimit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 int err = 0;
400
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700401 if ((u8 *)hdr < skb->head ||
Simon Horman29a3cad2013-05-28 20:34:26 +0000402 (skb_network_header(skb) + sizeof(*hdr)) > skb_tail_pointer(skb))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 return;
404
405 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900406 * Make sure we respect the rules
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 * i.e. RFC 1885 2.4(e)
Pravin B Shelar5f5624c2013-04-25 11:08:30 +0000408 * Rule (e.1) is enforced by not using icmp6_send
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 * in any code that processes icmp errors.
410 */
411 addr_type = ipv6_addr_type(&hdr->daddr);
412
Benjamin Thery9a43b702008-03-05 10:49:18 -0800413 if (ipv6_chk_addr(net, &hdr->daddr, skb->dev, 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 saddr = &hdr->daddr;
415
416 /*
417 * Dest addr check
418 */
419
420 if ((addr_type & IPV6_ADDR_MULTICAST || skb->pkt_type != PACKET_HOST)) {
421 if (type != ICMPV6_PKT_TOOBIG &&
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900422 !(type == ICMPV6_PARAMPROB &&
423 code == ICMPV6_UNK_OPTION &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 (opt_unrec(skb, info))))
425 return;
426
427 saddr = NULL;
428 }
429
430 addr_type = ipv6_addr_type(&hdr->saddr);
431
432 /*
433 * Source addr check
434 */
435
Hannes Frederic Sowa842df072013-03-08 02:07:19 +0000436 if (__ipv6_addr_needs_scope_id(addr_type))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 iif = skb->dev->ifindex;
438
439 /*
YOSHIFUJI Hideaki8de33512005-12-21 22:57:06 +0900440 * Must not send error if the source does not uniquely
441 * identify a single node (RFC2463 Section 2.4).
442 * We check unspecified / multicast addresses here,
443 * and anycast addresses will be checked later.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 */
445 if ((addr_type == IPV6_ADDR_ANY) || (addr_type & IPV6_ADDR_MULTICAST)) {
Pravin B Shelar5f5624c2013-04-25 11:08:30 +0000446 LIMIT_NETDEBUG(KERN_DEBUG "icmp6_send: addr_any/mcast source\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 return;
448 }
449
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900450 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 * Never answer to a ICMP packet.
452 */
453 if (is_ineligible(skb)) {
Pravin B Shelar5f5624c2013-04-25 11:08:30 +0000454 LIMIT_NETDEBUG(KERN_DEBUG "icmp6_send: no reply to icmp error\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 return;
456 }
457
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700458 mip6_addr_swap(skb);
459
David S. Miller4c9483b2011-03-12 16:22:43 -0500460 memset(&fl6, 0, sizeof(fl6));
461 fl6.flowi6_proto = IPPROTO_ICMPV6;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000462 fl6.daddr = hdr->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 if (saddr)
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000464 fl6.saddr = *saddr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500465 fl6.flowi6_oif = iif;
David S. Miller1958b852011-03-12 16:36:19 -0500466 fl6.fl6_icmp_type = type;
467 fl6.fl6_icmp_code = code;
David S. Miller4c9483b2011-03-12 16:22:43 -0500468 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700470 sk = icmpv6_xmit_lock(net);
471 if (sk == NULL)
Denis V. Lunev405666d2008-02-29 11:16:46 -0800472 return;
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700473 np = inet6_sk(sk);
Denis V. Lunev405666d2008-02-29 11:16:46 -0800474
David S. Miller4c9483b2011-03-12 16:22:43 -0500475 if (!icmpv6_xrlim_allow(sk, type, &fl6))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 goto out;
477
478 tmp_hdr.icmp6_type = type;
479 tmp_hdr.icmp6_code = code;
480 tmp_hdr.icmp6_cksum = 0;
481 tmp_hdr.icmp6_pointer = htonl(info);
482
David S. Miller4c9483b2011-03-12 16:22:43 -0500483 if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
484 fl6.flowi6_oif = np->mcast_oif;
Erich E. Hooverc4062df2012-02-08 09:11:08 +0000485 else if (!fl6.flowi6_oif)
486 fl6.flowi6_oif = np->ucast_oif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487
David S. Miller4c9483b2011-03-12 16:22:43 -0500488 dst = icmpv6_route_lookup(net, skb, sk, &fl6);
David S. Millerb42835d2011-03-01 22:06:22 -0800489 if (IS_ERR(dst))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 goto out;
YOSHIFUJI Hideaki8de33512005-12-21 22:57:06 +0900491
David S. Miller4c9483b2011-03-12 16:22:43 -0500492 if (ipv6_addr_is_multicast(&fl6.daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 hlimit = np->mcast_hops;
494 else
495 hlimit = np->hop_limit;
496 if (hlimit < 0)
YOSHIFUJI Hideaki6b75d092008-03-10 06:00:30 -0400497 hlimit = ip6_dst_hoplimit(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498
499 msg.skb = skb;
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -0300500 msg.offset = skb_network_offset(skb);
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800501 msg.type = type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502
503 len = skb->len - msg.offset;
504 len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) -sizeof(struct icmp6hdr));
505 if (len < 0) {
Patrick McHardy64ce2072005-08-09 20:50:53 -0700506 LIMIT_NETDEBUG(KERN_DEBUG "icmp: len problem\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 goto out_dst_release;
508 }
509
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000510 rcu_read_lock();
511 idev = __in6_dev_get(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512
513 err = ip6_append_data(sk, icmpv6_getfrag, &msg,
514 len + sizeof(struct icmp6hdr),
Gerrit Renkere651f032009-08-09 08:12:48 +0000515 sizeof(struct icmp6hdr), hlimit,
Eldad Zacka2d91a02012-04-01 07:49:07 +0000516 np->tclass, NULL, &fl6, (struct rt6_info *)dst,
Brian Haley13b52cd2010-04-23 11:26:08 +0000517 MSG_DONTWAIT, np->dontfrag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 if (err) {
Eric Dumazet00d9d6a2010-06-07 22:24:44 +0000519 ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 ip6_flush_pending_frames(sk);
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000521 } else {
522 err = icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
523 len + sizeof(struct icmp6hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 }
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000525 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526out_dst_release:
527 dst_release(dst);
528out:
Denis V. Lunev405666d2008-02-29 11:16:46 -0800529 icmpv6_xmit_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530}
Pravin B Shelar5f5624c2013-04-25 11:08:30 +0000531
532/* Slightly more convenient version of icmp6_send.
533 */
534void icmpv6_param_prob(struct sk_buff *skb, u8 code, int pos)
535{
536 icmp6_send(skb, ICMPV6_PARAMPROB, code, pos);
537 kfree_skb(skb);
538}
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900539
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540static void icmpv6_echo_reply(struct sk_buff *skb)
541{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900542 struct net *net = dev_net(skb->dev);
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700543 struct sock *sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 struct inet6_dev *idev;
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700545 struct ipv6_pinfo *np;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000546 const struct in6_addr *saddr = NULL;
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300547 struct icmp6hdr *icmph = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 struct icmp6hdr tmp_hdr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500549 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 struct icmpv6_msg msg;
551 struct dst_entry *dst;
552 int err = 0;
553 int hlimit;
554
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700555 saddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556
557 if (!ipv6_unicast_destination(skb))
558 saddr = NULL;
559
560 memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
561 tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;
562
David S. Miller4c9483b2011-03-12 16:22:43 -0500563 memset(&fl6, 0, sizeof(fl6));
564 fl6.flowi6_proto = IPPROTO_ICMPV6;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000565 fl6.daddr = ipv6_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 if (saddr)
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000567 fl6.saddr = *saddr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500568 fl6.flowi6_oif = skb->dev->ifindex;
David S. Miller1958b852011-03-12 16:36:19 -0500569 fl6.fl6_icmp_type = ICMPV6_ECHO_REPLY;
David S. Miller4c9483b2011-03-12 16:22:43 -0500570 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700572 sk = icmpv6_xmit_lock(net);
573 if (sk == NULL)
Denis V. Lunev405666d2008-02-29 11:16:46 -0800574 return;
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700575 np = inet6_sk(sk);
Denis V. Lunev405666d2008-02-29 11:16:46 -0800576
David S. Miller4c9483b2011-03-12 16:22:43 -0500577 if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
578 fl6.flowi6_oif = np->mcast_oif;
Erich E. Hooverc4062df2012-02-08 09:11:08 +0000579 else if (!fl6.flowi6_oif)
580 fl6.flowi6_oif = np->ucast_oif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581
David S. Miller4c9483b2011-03-12 16:22:43 -0500582 err = ip6_dst_lookup(sk, &dst, &fl6);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 if (err)
584 goto out;
David S. Miller4c9483b2011-03-12 16:22:43 -0500585 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), sk, 0);
David S. Miller452edd52011-03-02 13:27:41 -0800586 if (IS_ERR(dst))
Patrick McHardye104411b2005-09-08 15:11:55 -0700587 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588
David S. Miller4c9483b2011-03-12 16:22:43 -0500589 if (ipv6_addr_is_multicast(&fl6.daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 hlimit = np->mcast_hops;
591 else
592 hlimit = np->hop_limit;
593 if (hlimit < 0)
YOSHIFUJI Hideaki6b75d092008-03-10 06:00:30 -0400594 hlimit = ip6_dst_hoplimit(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000596 idev = __in6_dev_get(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597
598 msg.skb = skb;
599 msg.offset = 0;
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800600 msg.type = ICMPV6_ECHO_REPLY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601
602 err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
David S. Miller4c9483b2011-03-12 16:22:43 -0500603 sizeof(struct icmp6hdr), hlimit, np->tclass, NULL, &fl6,
Eldad Zacka2d91a02012-04-01 07:49:07 +0000604 (struct rt6_info *)dst, MSG_DONTWAIT,
Brian Haley13b52cd2010-04-23 11:26:08 +0000605 np->dontfrag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606
607 if (err) {
Eric Dumazet00d9d6a2010-06-07 22:24:44 +0000608 ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 ip6_flush_pending_frames(sk);
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000610 } else {
611 err = icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
612 skb->len + sizeof(struct icmp6hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 dst_release(dst);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900615out:
Denis V. Lunev405666d2008-02-29 11:16:46 -0800616 icmpv6_xmit_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617}
618
David S. Millerb94f1c02012-07-12 00:33:37 -0700619void icmpv6_notify(struct sk_buff *skb, u8 type, u8 code, __be32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620{
Alexey Dobriyan41135cc2009-09-14 12:22:28 +0000621 const struct inet6_protocol *ipprot;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 int inner_offset;
Jesse Gross75f28112011-11-30 17:05:51 -0800623 __be16 frag_off;
David S. Millerf9242b62012-06-19 18:56:21 -0700624 u8 nexthdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625
626 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
627 return;
628
629 nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
630 if (ipv6_ext_hdr(nexthdr)) {
631 /* now skip over extension headers */
Jesse Gross75f28112011-11-30 17:05:51 -0800632 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr),
633 &nexthdr, &frag_off);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 if (inner_offset<0)
635 return;
636 } else {
637 inner_offset = sizeof(struct ipv6hdr);
638 }
639
640 /* Checkin header including 8 bytes of inner protocol header. */
641 if (!pskb_may_pull(skb, inner_offset+8))
642 return;
643
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
645 Without this we will not able f.e. to make source routed
646 pmtu discovery.
647 Corresponding argument (opt) to notifiers is already added.
648 --ANK (980726)
649 */
650
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 rcu_read_lock();
David S. Millerf9242b62012-06-19 18:56:21 -0700652 ipprot = rcu_dereference(inet6_protos[nexthdr]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 if (ipprot && ipprot->err_handler)
654 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
655 rcu_read_unlock();
656
Pavel Emelyanov69d6da02007-11-19 22:35:57 -0800657 raw6_icmp_error(skb, nexthdr, type, code, inner_offset, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658}
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900659
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660/*
661 * Handle icmp messages
662 */
663
Herbert Xue5bbef22007-10-15 12:50:28 -0700664static int icmpv6_rcv(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 struct net_device *dev = skb->dev;
667 struct inet6_dev *idev = __in6_dev_get(dev);
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000668 const struct in6_addr *saddr, *daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 struct icmp6hdr *hdr;
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700670 u8 type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671
Herbert Xuaebcf822007-12-12 18:54:16 -0800672 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -0700673 struct sec_path *sp = skb_sec_path(skb);
Herbert Xu8b7817f2007-12-12 10:44:43 -0800674 int nh;
675
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -0700676 if (!(sp && sp->xvec[sp->len - 1]->props.flags &
Herbert Xuaebcf822007-12-12 18:54:16 -0800677 XFRM_STATE_ICMP))
678 goto drop_no_count;
679
David S. Miller81aded22012-06-15 14:54:11 -0700680 if (!pskb_may_pull(skb, sizeof(*hdr) + sizeof(struct ipv6hdr)))
Herbert Xu8b7817f2007-12-12 10:44:43 -0800681 goto drop_no_count;
682
683 nh = skb_network_offset(skb);
684 skb_set_network_header(skb, sizeof(*hdr));
685
686 if (!xfrm6_policy_check_reverse(NULL, XFRM_POLICY_IN, skb))
687 goto drop_no_count;
688
689 skb_set_network_header(skb, nh);
690 }
691
Denis V. Luneve41b5362008-10-08 10:33:26 -0700692 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INMSGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700694 saddr = &ipv6_hdr(skb)->saddr;
695 daddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696
697 /* Perform checksum. */
Herbert Xufb286bb2005-11-10 13:01:24 -0800698 switch (skb->ip_summed) {
Patrick McHardy84fa7932006-08-29 16:44:56 -0700699 case CHECKSUM_COMPLETE:
Herbert Xufb286bb2005-11-10 13:01:24 -0800700 if (!csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
701 skb->csum))
702 break;
703 /* fall through */
704 case CHECKSUM_NONE:
Al Viro868c86b2006-11-14 21:35:48 -0800705 skb->csum = ~csum_unfold(csum_ipv6_magic(saddr, daddr, skb->len,
706 IPPROTO_ICMPV6, 0));
Herbert Xufb286bb2005-11-10 13:01:24 -0800707 if (__skb_checksum_complete(skb)) {
Lorenzo Colitti6d0bfe22013-05-22 20:17:31 +0000708 LIMIT_NETDEBUG(KERN_DEBUG
709 "ICMPv6 checksum failed [%pI6c > %pI6c]\n",
Harvey Harrison0c6ce782008-10-28 16:09:23 -0700710 saddr, daddr);
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +0000711 goto csum_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 }
713 }
714
Herbert Xu8cf22942008-02-05 03:15:50 -0800715 if (!pskb_pull(skb, sizeof(*hdr)))
716 goto discard_it;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300718 hdr = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719
720 type = hdr->icmp6_type;
721
Denis V. Lunev55d43802008-10-08 10:34:54 -0700722 ICMP6MSGIN_INC_STATS_BH(dev_net(dev), idev, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723
724 switch (type) {
725 case ICMPV6_ECHO_REQUEST:
726 icmpv6_echo_reply(skb);
727 break;
728
729 case ICMPV6_ECHO_REPLY:
Lorenzo Colitti6d0bfe22013-05-22 20:17:31 +0000730 ping_rcv(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 break;
732
733 case ICMPV6_PKT_TOOBIG:
734 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
735 standard destination cache. Seems, only "advanced"
736 destination cache will allow to solve this problem
737 --ANK (980726)
738 */
739 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
740 goto discard_it;
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300741 hdr = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742
743 /*
744 * Drop through to notify
745 */
746
747 case ICMPV6_DEST_UNREACH:
748 case ICMPV6_TIME_EXCEED:
749 case ICMPV6_PARAMPROB:
750 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
751 break;
752
753 case NDISC_ROUTER_SOLICITATION:
754 case NDISC_ROUTER_ADVERTISEMENT:
755 case NDISC_NEIGHBOUR_SOLICITATION:
756 case NDISC_NEIGHBOUR_ADVERTISEMENT:
757 case NDISC_REDIRECT:
758 ndisc_rcv(skb);
759 break;
760
761 case ICMPV6_MGM_QUERY:
762 igmp6_event_query(skb);
763 break;
764
765 case ICMPV6_MGM_REPORT:
766 igmp6_event_report(skb);
767 break;
768
769 case ICMPV6_MGM_REDUCTION:
770 case ICMPV6_NI_QUERY:
771 case ICMPV6_NI_REPLY:
772 case ICMPV6_MLD2_REPORT:
773 case ICMPV6_DHAAD_REQUEST:
774 case ICMPV6_DHAAD_REPLY:
775 case ICMPV6_MOBILE_PREFIX_SOL:
776 case ICMPV6_MOBILE_PREFIX_ADV:
777 break;
778
779 default:
Patrick McHardy64ce2072005-08-09 20:50:53 -0700780 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6: msg of unknown type\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781
782 /* informational */
783 if (type & ICMPV6_INFOMSG_MASK)
784 break;
785
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900786 /*
787 * error of unknown type.
788 * must pass to upper level
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 */
790
791 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700792 }
793
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 kfree_skb(skb);
795 return 0;
796
Eric Dumazet6a5dc9e2013-04-29 08:39:56 +0000797csum_error:
798 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_CSUMERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799discard_it:
Denis V. Luneve41b5362008-10-08 10:33:26 -0700800 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INERRORS);
Herbert Xu8b7817f2007-12-12 10:44:43 -0800801drop_no_count:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 kfree_skb(skb);
803 return 0;
804}
805
David S. Miller4c9483b2011-03-12 16:22:43 -0500806void icmpv6_flow_init(struct sock *sk, struct flowi6 *fl6,
YOSHIFUJI Hideaki95e41e92007-12-06 15:43:30 -0800807 u8 type,
808 const struct in6_addr *saddr,
809 const struct in6_addr *daddr,
810 int oif)
811{
David S. Miller4c9483b2011-03-12 16:22:43 -0500812 memset(fl6, 0, sizeof(*fl6));
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000813 fl6->saddr = *saddr;
814 fl6->daddr = *daddr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500815 fl6->flowi6_proto = IPPROTO_ICMPV6;
David S. Miller1958b852011-03-12 16:36:19 -0500816 fl6->fl6_icmp_type = type;
817 fl6->fl6_icmp_code = 0;
David S. Miller4c9483b2011-03-12 16:22:43 -0500818 fl6->flowi6_oif = oif;
819 security_sk_classify_flow(sk, flowi6_to_flowi(fl6));
YOSHIFUJI Hideaki95e41e92007-12-06 15:43:30 -0800820}
821
Ingo Molnar640c41c2006-08-15 00:06:56 -0700822/*
Denis V. Lunevb7e729c2008-02-29 11:16:08 -0800823 * Special lock-class for __icmpv6_sk:
Ingo Molnar640c41c2006-08-15 00:06:56 -0700824 */
825static struct lock_class_key icmpv6_socket_sk_dst_lock_key;
826
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800827static int __net_init icmpv6_sk_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828{
829 struct sock *sk;
830 int err, i, j;
831
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800832 net->ipv6.icmp_sk =
833 kzalloc(nr_cpu_ids * sizeof(struct sock *), GFP_KERNEL);
834 if (net->ipv6.icmp_sk == NULL)
Denis V. Lunev79c91152008-02-29 11:17:11 -0800835 return -ENOMEM;
836
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -0700837 for_each_possible_cpu(i) {
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700838 err = inet_ctl_sock_create(&sk, PF_INET6,
839 SOCK_RAW, IPPROTO_ICMPV6, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 if (err < 0) {
Joe Perchesf3213832012-05-15 14:11:53 +0000841 pr_err("Failed to initialize the ICMP6 control socket (err %d)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 err);
843 goto fail;
844 }
845
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700846 net->ipv6.icmp_sk[i] = sk;
Denis V. Lunev5c8cafd2008-02-29 11:19:22 -0800847
Ingo Molnar640c41c2006-08-15 00:06:56 -0700848 /*
849 * Split off their lock-class, because sk->sk_dst_lock
850 * gets used from softirqs, which is safe for
Denis V. Lunevb7e729c2008-02-29 11:16:08 -0800851 * __icmpv6_sk (because those never get directly used
Ingo Molnar640c41c2006-08-15 00:06:56 -0700852 * via userspace syscalls), but unsafe for normal sockets.
853 */
854 lockdep_set_class(&sk->sk_dst_lock,
855 &icmpv6_socket_sk_dst_lock_key);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856
857 /* Enough space for 2 64K ICMP packets, including
858 * sk_buff struct overhead.
859 */
Eric Dumazet87fb4b72011-10-13 07:28:54 +0000860 sk->sk_sndbuf = 2 * SKB_TRUESIZE(64 * 1024);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 return 0;
863
864 fail:
Denis V. Lunev5c8cafd2008-02-29 11:19:22 -0800865 for (j = 0; j < i; j++)
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700866 inet_ctl_sock_destroy(net->ipv6.icmp_sk[j]);
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800867 kfree(net->ipv6.icmp_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 return err;
869}
870
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800871static void __net_exit icmpv6_sk_exit(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872{
873 int i;
874
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -0700875 for_each_possible_cpu(i) {
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700876 inet_ctl_sock_destroy(net->ipv6.icmp_sk[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 }
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800878 kfree(net->ipv6.icmp_sk);
879}
880
Alexey Dobriyan8ed7edc2008-03-03 12:02:54 -0800881static struct pernet_operations icmpv6_sk_ops = {
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800882 .init = icmpv6_sk_init,
883 .exit = icmpv6_sk_exit,
884};
885
886int __init icmpv6_init(void)
887{
888 int err;
889
890 err = register_pernet_subsys(&icmpv6_sk_ops);
891 if (err < 0)
892 return err;
893
894 err = -EAGAIN;
895 if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0)
896 goto fail;
Pravin B Shelar5f5624c2013-04-25 11:08:30 +0000897
898 err = inet6_register_icmp_sender(icmp6_send);
899 if (err)
900 goto sender_reg_err;
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800901 return 0;
902
Pravin B Shelar5f5624c2013-04-25 11:08:30 +0000903sender_reg_err:
904 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800905fail:
Joe Perchesf3213832012-05-15 14:11:53 +0000906 pr_err("Failed to register ICMP6 protocol\n");
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800907 unregister_pernet_subsys(&icmpv6_sk_ops);
908 return err;
909}
910
Alexey Dobriyan8ed7edc2008-03-03 12:02:54 -0800911void icmpv6_cleanup(void)
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800912{
Pravin B Shelar5f5624c2013-04-25 11:08:30 +0000913 inet6_unregister_icmp_sender(icmp6_send);
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800914 unregister_pernet_subsys(&icmpv6_sk_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
916}
917
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800918
Arjan van de Ven9b5b5cf2005-11-29 16:21:38 -0800919static const struct icmp6_err {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 int err;
921 int fatal;
922} tab_unreach[] = {
923 { /* NOROUTE */
924 .err = ENETUNREACH,
925 .fatal = 0,
926 },
927 { /* ADM_PROHIBITED */
928 .err = EACCES,
929 .fatal = 1,
930 },
931 { /* Was NOT_NEIGHBOUR, now reserved */
932 .err = EHOSTUNREACH,
933 .fatal = 0,
934 },
935 { /* ADDR_UNREACH */
936 .err = EHOSTUNREACH,
937 .fatal = 0,
938 },
939 { /* PORT_UNREACH */
940 .err = ECONNREFUSED,
941 .fatal = 1,
942 },
Jiri Bohac61e76b12013-08-30 11:18:45 +0200943 { /* POLICY_FAIL */
944 .err = EACCES,
945 .fatal = 1,
946 },
947 { /* REJECT_ROUTE */
948 .err = EACCES,
949 .fatal = 1,
950 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951};
952
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700953int icmpv6_err_convert(u8 type, u8 code, int *err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954{
955 int fatal = 0;
956
957 *err = EPROTO;
958
959 switch (type) {
960 case ICMPV6_DEST_UNREACH:
961 fatal = 1;
Jiri Bohac61e76b12013-08-30 11:18:45 +0200962 if (code < ARRAY_SIZE(tab_unreach)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 *err = tab_unreach[code].err;
964 fatal = tab_unreach[code].fatal;
965 }
966 break;
967
968 case ICMPV6_PKT_TOOBIG:
969 *err = EMSGSIZE;
970 break;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900971
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 case ICMPV6_PARAMPROB:
973 *err = EPROTO;
974 fatal = 1;
975 break;
976
977 case ICMPV6_TIME_EXCEED:
978 *err = EHOSTUNREACH;
979 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700980 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981
982 return fatal;
983}
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900984EXPORT_SYMBOL(icmpv6_err_convert);
985
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986#ifdef CONFIG_SYSCTL
Joe Perchesfe2c6332013-06-11 23:04:25 -0700987struct ctl_table ipv6_icmp_table_template[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 .procname = "ratelimit",
Daniel Lezcano41a76902008-01-10 03:02:40 -0800990 .data = &init_net.ipv6.sysctl.icmpv6_time,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 .maxlen = sizeof(int),
992 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -0800993 .proc_handler = proc_dointvec_ms_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 },
Eric W. Biedermanf8572d82009-11-05 13:32:03 -0800995 { },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996};
Daniel Lezcano760f2d02008-01-10 02:53:43 -0800997
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +0000998struct ctl_table * __net_init ipv6_icmp_sysctl_init(struct net *net)
Daniel Lezcano760f2d02008-01-10 02:53:43 -0800999{
1000 struct ctl_table *table;
1001
1002 table = kmemdup(ipv6_icmp_table_template,
1003 sizeof(ipv6_icmp_table_template),
1004 GFP_KERNEL);
YOSHIFUJI Hideaki5ee09102008-02-28 00:24:28 +09001005
Eric W. Biedermanc027aab2012-11-16 03:03:10 +00001006 if (table)
YOSHIFUJI Hideaki5ee09102008-02-28 00:24:28 +09001007 table[0].data = &net->ipv6.sysctl.icmpv6_time;
1008
Daniel Lezcano760f2d02008-01-10 02:53:43 -08001009 return table;
1010}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011#endif
1012