blob: b4a9fd51dae74bd8143b2d32e791e089f1d8562f [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>
60#include <net/protocol.h>
61#include <net/raw.h>
62#include <net/rawv6.h>
63#include <net/transp_v6.h>
64#include <net/ip6_route.h>
65#include <net/addrconf.h>
66#include <net/icmp.h>
Herbert Xu8b7817f2007-12-12 10:44:43 -080067#include <net/xfrm.h>
Denis V. Lunev1ed85162008-04-03 14:31:03 -070068#include <net/inet_common.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070069
70#include <asm/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070071
Linus Torvalds1da177e2005-04-16 15:20:36 -070072/*
73 * The ICMP socket(s). This is the most convenient way to flow control
74 * our ICMP output as well as maintain a clean interface throughout
75 * all layers. All Socketless IP sends will soon be gone.
76 *
77 * On SMP we have one ICMP socket per-cpu.
78 */
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -080079static inline struct sock *icmpv6_sk(struct net *net)
80{
81 return net->ipv6.icmp_sk[smp_processor_id()];
82}
Linus Torvalds1da177e2005-04-16 15:20:36 -070083
Herbert Xue5bbef22007-10-15 12:50:28 -070084static int icmpv6_rcv(struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
Alexey Dobriyan41135cc2009-09-14 12:22:28 +000086static const struct inet6_protocol icmpv6_protocol = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 .handler = icmpv6_rcv,
Herbert Xu8b7817f2007-12-12 10:44:43 -080088 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
Linus Torvalds1da177e2005-04-16 15:20:36 -070089};
90
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -070091static __inline__ struct sock *icmpv6_xmit_lock(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -070092{
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -070093 struct sock *sk;
94
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 local_bh_disable();
96
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -070097 sk = icmpv6_sk(net);
Denis V. Lunev405666d2008-02-29 11:16:46 -080098 if (unlikely(!spin_trylock(&sk->sk_lock.slock))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 /* This can happen if the output path (f.e. SIT or
100 * ip6ip6 tunnel) signals dst_link_failure() for an
101 * outgoing ICMP6 packet.
102 */
103 local_bh_enable();
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700104 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 }
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700106 return sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107}
108
Denis V. Lunev405666d2008-02-29 11:16:46 -0800109static __inline__ void icmpv6_xmit_unlock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110{
Denis V. Lunev405666d2008-02-29 11:16:46 -0800111 spin_unlock_bh(&sk->sk_lock.slock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112}
113
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900114/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 * Slightly more convenient version of icmpv6_send.
116 */
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700117void icmpv6_param_prob(struct sk_buff *skb, u8 code, int pos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118{
Alexey Dobriyan3ffe5332010-02-18 08:25:24 +0000119 icmpv6_send(skb, ICMPV6_PARAMPROB, code, pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 kfree_skb(skb);
121}
122
123/*
124 * Figure out, may we reply to this packet with icmp error.
125 *
126 * We do not reply, if:
127 * - it was icmp error message.
128 * - it is truncated, so that it is known, that protocol is ICMPV6
129 * (i.e. in the middle of some exthdr)
130 *
131 * --ANK (980726)
132 */
133
Eric Dumazeta50feda2012-05-18 18:57:34 +0000134static bool is_ineligible(const struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700136 int ptr = (u8 *)(ipv6_hdr(skb) + 1) - skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 int len = skb->len - ptr;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700138 __u8 nexthdr = ipv6_hdr(skb)->nexthdr;
Jesse Gross75f28112011-11-30 17:05:51 -0800139 __be16 frag_off;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140
141 if (len < 0)
Eric Dumazeta50feda2012-05-18 18:57:34 +0000142 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143
Jesse Gross75f28112011-11-30 17:05:51 -0800144 ptr = ipv6_skip_exthdr(skb, ptr, &nexthdr, &frag_off);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 if (ptr < 0)
Eric Dumazeta50feda2012-05-18 18:57:34 +0000146 return false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 if (nexthdr == IPPROTO_ICMPV6) {
148 u8 _type, *tp;
149 tp = skb_header_pointer(skb,
150 ptr+offsetof(struct icmp6hdr, icmp6_type),
151 sizeof(_type), &_type);
152 if (tp == NULL ||
153 !(*tp & ICMPV6_INFOMSG_MASK))
Eric Dumazeta50feda2012-05-18 18:57:34 +0000154 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 }
Eric Dumazeta50feda2012-05-18 18:57:34 +0000156 return false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157}
158
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900159/*
160 * Check the ICMP output rate limit
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 */
David S. Miller92d86822011-02-04 15:55:25 -0800162static inline bool icmpv6_xrlim_allow(struct sock *sk, u8 type,
David S. Miller4c9483b2011-03-12 16:22:43 -0500163 struct flowi6 *fl6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164{
165 struct dst_entry *dst;
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900166 struct net *net = sock_net(sk);
David S. Miller92d86822011-02-04 15:55:25 -0800167 bool res = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168
169 /* Informational messages are not limited. */
170 if (type & ICMPV6_INFOMSG_MASK)
David S. Miller92d86822011-02-04 15:55:25 -0800171 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172
173 /* Do not limit pmtu discovery, it would break it. */
174 if (type == ICMPV6_PKT_TOOBIG)
David S. Miller92d86822011-02-04 15:55:25 -0800175 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900177 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 * Look up the output route.
179 * XXX: perhaps the expire for routing entries cloned by
180 * this lookup should be more aggressive (not longer than timeout).
181 */
David S. Miller4c9483b2011-03-12 16:22:43 -0500182 dst = ip6_route_output(net, sk, fl6);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 if (dst->error) {
Denis V. Lunev3bd653c2008-10-08 10:54:51 -0700184 IP6_INC_STATS(net, ip6_dst_idev(dst),
YOSHIFUJI Hideakia11d2062006-11-04 20:11:37 +0900185 IPSTATS_MIB_OUTNOROUTES);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 } else if (dst->dev && (dst->dev->flags&IFF_LOOPBACK)) {
David S. Miller92d86822011-02-04 15:55:25 -0800187 res = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 } else {
189 struct rt6_info *rt = (struct rt6_info *)dst;
Benjamin Thery9a43b702008-03-05 10:49:18 -0800190 int tmo = net->ipv6.sysctl.icmpv6_time;
David S. Millerfbfe95a2012-06-08 23:24:18 -0700191 struct inet_peer *peer;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192
193 /* Give more bandwidth to wider prefixes. */
194 if (rt->rt6i_dst.plen < 128)
195 tmo >>= ((128 - rt->rt6i_dst.plen)>>5);
196
David S. Miller1d861aa2012-07-10 03:58:16 -0700197 peer = inet_getpeer_v6(net->ipv6.peers, &rt->rt6i_dst.addr, 1);
David S. Millerfbfe95a2012-06-08 23:24:18 -0700198 res = inet_peer_xrlim_allow(peer, tmo);
David S. Miller1d861aa2012-07-10 03:58:16 -0700199 if (peer)
200 inet_putpeer(peer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 }
202 dst_release(dst);
203 return res;
204}
205
206/*
207 * an inline helper for the "simple" if statement below
208 * checks if parameter problem report is caused by an
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900209 * unrecognized IPv6 option that has the Option Type
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 * highest-order two bits set to 10
211 */
212
Eric Dumazeta50feda2012-05-18 18:57:34 +0000213static bool opt_unrec(struct sk_buff *skb, __u32 offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214{
215 u8 _optval, *op;
216
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -0300217 offset += skb_network_offset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 op = skb_header_pointer(skb, offset, sizeof(_optval), &_optval);
219 if (op == NULL)
Eric Dumazeta50feda2012-05-18 18:57:34 +0000220 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 return (*op & 0xC0) == 0x80;
222}
223
David S. Miller4c9483b2011-03-12 16:22:43 -0500224static int icmpv6_push_pending_frames(struct sock *sk, struct flowi6 *fl6, struct icmp6hdr *thdr, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225{
226 struct sk_buff *skb;
227 struct icmp6hdr *icmp6h;
228 int err = 0;
229
230 if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
231 goto out;
232
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300233 icmp6h = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 memcpy(icmp6h, thdr, sizeof(struct icmp6hdr));
235 icmp6h->icmp6_cksum = 0;
236
237 if (skb_queue_len(&sk->sk_write_queue) == 1) {
Joe Perches07f07572008-11-19 15:44:53 -0800238 skb->csum = csum_partial(icmp6h,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 sizeof(struct icmp6hdr), skb->csum);
David S. Miller4c9483b2011-03-12 16:22:43 -0500240 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
241 &fl6->daddr,
242 len, fl6->flowi6_proto,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 skb->csum);
244 } else {
Al Viro868c86b2006-11-14 21:35:48 -0800245 __wsum tmp_csum = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246
247 skb_queue_walk(&sk->sk_write_queue, skb) {
248 tmp_csum = csum_add(tmp_csum, skb->csum);
249 }
250
Joe Perches07f07572008-11-19 15:44:53 -0800251 tmp_csum = csum_partial(icmp6h,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 sizeof(struct icmp6hdr), tmp_csum);
David S. Miller4c9483b2011-03-12 16:22:43 -0500253 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
254 &fl6->daddr,
255 len, fl6->flowi6_proto,
Al Viro868c86b2006-11-14 21:35:48 -0800256 tmp_csum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 ip6_push_pending_frames(sk);
259out:
260 return err;
261}
262
263struct icmpv6_msg {
264 struct sk_buff *skb;
265 int offset;
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800266 uint8_t type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267};
268
269static int icmpv6_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb)
270{
271 struct icmpv6_msg *msg = (struct icmpv6_msg *) from;
272 struct sk_buff *org_skb = msg->skb;
Al Viro5f92a732006-11-14 21:36:54 -0800273 __wsum csum = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274
275 csum = skb_copy_and_csum_bits(org_skb, msg->offset + offset,
276 to, len, csum);
277 skb->csum = csum_block_add(skb->csum, csum, odd);
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800278 if (!(msg->type & ICMPV6_INFOMSG_MASK))
279 nf_ct_attach(skb, org_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 return 0;
281}
282
Amerigo Wang07a93622012-10-29 16:23:10 +0000283#if IS_ENABLED(CONFIG_IPV6_MIP6)
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700284static void mip6_addr_swap(struct sk_buff *skb)
285{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700286 struct ipv6hdr *iph = ipv6_hdr(skb);
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700287 struct inet6_skb_parm *opt = IP6CB(skb);
288 struct ipv6_destopt_hao *hao;
289 struct in6_addr tmp;
290 int off;
291
292 if (opt->dsthao) {
293 off = ipv6_find_tlv(skb, opt->dsthao, IPV6_TLV_HAO);
294 if (likely(off >= 0)) {
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700295 hao = (struct ipv6_destopt_hao *)
296 (skb_network_header(skb) + off);
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000297 tmp = iph->saddr;
298 iph->saddr = hao->addr;
299 hao->addr = tmp;
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700300 }
301 }
302}
303#else
304static inline void mip6_addr_swap(struct sk_buff *skb) {}
305#endif
306
David S. Millerb42835d2011-03-01 22:06:22 -0800307static struct dst_entry *icmpv6_route_lookup(struct net *net, struct sk_buff *skb,
David S. Miller4c9483b2011-03-12 16:22:43 -0500308 struct sock *sk, struct flowi6 *fl6)
David S. Millerb42835d2011-03-01 22:06:22 -0800309{
310 struct dst_entry *dst, *dst2;
David S. Miller4c9483b2011-03-12 16:22:43 -0500311 struct flowi6 fl2;
David S. Millerb42835d2011-03-01 22:06:22 -0800312 int err;
313
David S. Miller4c9483b2011-03-12 16:22:43 -0500314 err = ip6_dst_lookup(sk, &dst, fl6);
David S. Millerb42835d2011-03-01 22:06:22 -0800315 if (err)
316 return ERR_PTR(err);
317
318 /*
319 * We won't send icmp if the destination is known
320 * anycast.
321 */
322 if (((struct rt6_info *)dst)->rt6i_flags & RTF_ANYCAST) {
323 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: acast source\n");
324 dst_release(dst);
325 return ERR_PTR(-EINVAL);
326 }
327
328 /* No need to clone since we're just using its address. */
329 dst2 = dst;
330
David S. Miller4c9483b2011-03-12 16:22:43 -0500331 dst = xfrm_lookup(net, dst, flowi6_to_flowi(fl6), sk, 0);
David S. Miller452edd52011-03-02 13:27:41 -0800332 if (!IS_ERR(dst)) {
David S. Millerb42835d2011-03-01 22:06:22 -0800333 if (dst != dst2)
334 return dst;
David S. Miller452edd52011-03-02 13:27:41 -0800335 } else {
336 if (PTR_ERR(dst) == -EPERM)
337 dst = NULL;
338 else
339 return dst;
David S. Millerb42835d2011-03-01 22:06:22 -0800340 }
341
David S. Miller4c9483b2011-03-12 16:22:43 -0500342 err = xfrm_decode_session_reverse(skb, flowi6_to_flowi(&fl2), AF_INET6);
David S. Millerb42835d2011-03-01 22:06:22 -0800343 if (err)
344 goto relookup_failed;
345
346 err = ip6_dst_lookup(sk, &dst2, &fl2);
347 if (err)
348 goto relookup_failed;
349
David S. Miller4c9483b2011-03-12 16:22:43 -0500350 dst2 = xfrm_lookup(net, dst2, flowi6_to_flowi(&fl2), sk, XFRM_LOOKUP_ICMP);
David S. Miller452edd52011-03-02 13:27:41 -0800351 if (!IS_ERR(dst2)) {
David S. Millerb42835d2011-03-01 22:06:22 -0800352 dst_release(dst);
353 dst = dst2;
David S. Miller452edd52011-03-02 13:27:41 -0800354 } else {
355 err = PTR_ERR(dst2);
356 if (err == -EPERM) {
357 dst_release(dst);
358 return dst2;
359 } else
360 goto relookup_failed;
David S. Millerb42835d2011-03-01 22:06:22 -0800361 }
362
363relookup_failed:
364 if (dst)
365 return dst;
366 return ERR_PTR(err);
367}
368
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369/*
370 * Send an ICMP message in response to a packet in error
371 */
Alexey Dobriyan3ffe5332010-02-18 08:25:24 +0000372void icmpv6_send(struct sk_buff *skb, u8 type, u8 code, __u32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900374 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 struct inet6_dev *idev = NULL;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700376 struct ipv6hdr *hdr = ipv6_hdr(skb);
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700377 struct sock *sk;
378 struct ipv6_pinfo *np;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000379 const struct in6_addr *saddr = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 struct dst_entry *dst;
381 struct icmp6hdr tmp_hdr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500382 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 struct icmpv6_msg msg;
384 int iif = 0;
385 int addr_type = 0;
386 int len;
Gerrit Renkere651f032009-08-09 08:12:48 +0000387 int hlimit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 int err = 0;
389
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700390 if ((u8 *)hdr < skb->head ||
391 (skb->network_header + sizeof(*hdr)) > skb->tail)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 return;
393
394 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900395 * Make sure we respect the rules
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 * i.e. RFC 1885 2.4(e)
397 * Rule (e.1) is enforced by not using icmpv6_send
398 * in any code that processes icmp errors.
399 */
400 addr_type = ipv6_addr_type(&hdr->daddr);
401
Benjamin Thery9a43b702008-03-05 10:49:18 -0800402 if (ipv6_chk_addr(net, &hdr->daddr, skb->dev, 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 saddr = &hdr->daddr;
404
405 /*
406 * Dest addr check
407 */
408
409 if ((addr_type & IPV6_ADDR_MULTICAST || skb->pkt_type != PACKET_HOST)) {
410 if (type != ICMPV6_PKT_TOOBIG &&
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900411 !(type == ICMPV6_PARAMPROB &&
412 code == ICMPV6_UNK_OPTION &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 (opt_unrec(skb, info))))
414 return;
415
416 saddr = NULL;
417 }
418
419 addr_type = ipv6_addr_type(&hdr->saddr);
420
421 /*
422 * Source addr check
423 */
424
425 if (addr_type & IPV6_ADDR_LINKLOCAL)
426 iif = skb->dev->ifindex;
427
428 /*
YOSHIFUJI Hideaki8de33512005-12-21 22:57:06 +0900429 * Must not send error if the source does not uniquely
430 * identify a single node (RFC2463 Section 2.4).
431 * We check unspecified / multicast addresses here,
432 * and anycast addresses will be checked later.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 */
434 if ((addr_type == IPV6_ADDR_ANY) || (addr_type & IPV6_ADDR_MULTICAST)) {
Patrick McHardy64ce2072005-08-09 20:50:53 -0700435 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: addr_any/mcast source\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 return;
437 }
438
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900439 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 * Never answer to a ICMP packet.
441 */
442 if (is_ineligible(skb)) {
Patrick McHardy64ce2072005-08-09 20:50:53 -0700443 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: no reply to icmp error\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 return;
445 }
446
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700447 mip6_addr_swap(skb);
448
David S. Miller4c9483b2011-03-12 16:22:43 -0500449 memset(&fl6, 0, sizeof(fl6));
450 fl6.flowi6_proto = IPPROTO_ICMPV6;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000451 fl6.daddr = hdr->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 if (saddr)
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000453 fl6.saddr = *saddr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500454 fl6.flowi6_oif = iif;
David S. Miller1958b852011-03-12 16:36:19 -0500455 fl6.fl6_icmp_type = type;
456 fl6.fl6_icmp_code = code;
David S. Miller4c9483b2011-03-12 16:22:43 -0500457 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700459 sk = icmpv6_xmit_lock(net);
460 if (sk == NULL)
Denis V. Lunev405666d2008-02-29 11:16:46 -0800461 return;
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700462 np = inet6_sk(sk);
Denis V. Lunev405666d2008-02-29 11:16:46 -0800463
David S. Miller4c9483b2011-03-12 16:22:43 -0500464 if (!icmpv6_xrlim_allow(sk, type, &fl6))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 goto out;
466
467 tmp_hdr.icmp6_type = type;
468 tmp_hdr.icmp6_code = code;
469 tmp_hdr.icmp6_cksum = 0;
470 tmp_hdr.icmp6_pointer = htonl(info);
471
David S. Miller4c9483b2011-03-12 16:22:43 -0500472 if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
473 fl6.flowi6_oif = np->mcast_oif;
Erich E. Hooverc4062df2012-02-08 09:11:08 +0000474 else if (!fl6.flowi6_oif)
475 fl6.flowi6_oif = np->ucast_oif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476
David S. Miller4c9483b2011-03-12 16:22:43 -0500477 dst = icmpv6_route_lookup(net, skb, sk, &fl6);
David S. Millerb42835d2011-03-01 22:06:22 -0800478 if (IS_ERR(dst))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 goto out;
YOSHIFUJI Hideaki8de33512005-12-21 22:57:06 +0900480
David S. Miller4c9483b2011-03-12 16:22:43 -0500481 if (ipv6_addr_is_multicast(&fl6.daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 hlimit = np->mcast_hops;
483 else
484 hlimit = np->hop_limit;
485 if (hlimit < 0)
YOSHIFUJI Hideaki6b75d092008-03-10 06:00:30 -0400486 hlimit = ip6_dst_hoplimit(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487
488 msg.skb = skb;
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -0300489 msg.offset = skb_network_offset(skb);
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800490 msg.type = type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491
492 len = skb->len - msg.offset;
493 len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) -sizeof(struct icmp6hdr));
494 if (len < 0) {
Patrick McHardy64ce2072005-08-09 20:50:53 -0700495 LIMIT_NETDEBUG(KERN_DEBUG "icmp: len problem\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 goto out_dst_release;
497 }
498
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000499 rcu_read_lock();
500 idev = __in6_dev_get(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501
502 err = ip6_append_data(sk, icmpv6_getfrag, &msg,
503 len + sizeof(struct icmp6hdr),
Gerrit Renkere651f032009-08-09 08:12:48 +0000504 sizeof(struct icmp6hdr), hlimit,
Eldad Zacka2d91a02012-04-01 07:49:07 +0000505 np->tclass, NULL, &fl6, (struct rt6_info *)dst,
Brian Haley13b52cd2010-04-23 11:26:08 +0000506 MSG_DONTWAIT, np->dontfrag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 if (err) {
Eric Dumazet00d9d6a2010-06-07 22:24:44 +0000508 ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 ip6_flush_pending_frames(sk);
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000510 } else {
511 err = icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
512 len + sizeof(struct icmp6hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 }
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000514 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515out_dst_release:
516 dst_release(dst);
517out:
Denis V. Lunev405666d2008-02-29 11:16:46 -0800518 icmpv6_xmit_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519}
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900520EXPORT_SYMBOL(icmpv6_send);
521
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522static void icmpv6_echo_reply(struct sk_buff *skb)
523{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900524 struct net *net = dev_net(skb->dev);
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700525 struct sock *sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 struct inet6_dev *idev;
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700527 struct ipv6_pinfo *np;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000528 const struct in6_addr *saddr = NULL;
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300529 struct icmp6hdr *icmph = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 struct icmp6hdr tmp_hdr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500531 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 struct icmpv6_msg msg;
533 struct dst_entry *dst;
534 int err = 0;
535 int hlimit;
536
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700537 saddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538
539 if (!ipv6_unicast_destination(skb))
540 saddr = NULL;
541
542 memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
543 tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;
544
David S. Miller4c9483b2011-03-12 16:22:43 -0500545 memset(&fl6, 0, sizeof(fl6));
546 fl6.flowi6_proto = IPPROTO_ICMPV6;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000547 fl6.daddr = ipv6_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 if (saddr)
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000549 fl6.saddr = *saddr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500550 fl6.flowi6_oif = skb->dev->ifindex;
David S. Miller1958b852011-03-12 16:36:19 -0500551 fl6.fl6_icmp_type = ICMPV6_ECHO_REPLY;
David S. Miller4c9483b2011-03-12 16:22:43 -0500552 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700554 sk = icmpv6_xmit_lock(net);
555 if (sk == NULL)
Denis V. Lunev405666d2008-02-29 11:16:46 -0800556 return;
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700557 np = inet6_sk(sk);
Denis V. Lunev405666d2008-02-29 11:16:46 -0800558
David S. Miller4c9483b2011-03-12 16:22:43 -0500559 if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
560 fl6.flowi6_oif = np->mcast_oif;
Erich E. Hooverc4062df2012-02-08 09:11:08 +0000561 else if (!fl6.flowi6_oif)
562 fl6.flowi6_oif = np->ucast_oif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563
David S. Miller4c9483b2011-03-12 16:22:43 -0500564 err = ip6_dst_lookup(sk, &dst, &fl6);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 if (err)
566 goto out;
David S. Miller4c9483b2011-03-12 16:22:43 -0500567 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), sk, 0);
David S. Miller452edd52011-03-02 13:27:41 -0800568 if (IS_ERR(dst))
Patrick McHardye104411b2005-09-08 15:11:55 -0700569 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570
David S. Miller4c9483b2011-03-12 16:22:43 -0500571 if (ipv6_addr_is_multicast(&fl6.daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 hlimit = np->mcast_hops;
573 else
574 hlimit = np->hop_limit;
575 if (hlimit < 0)
YOSHIFUJI Hideaki6b75d092008-03-10 06:00:30 -0400576 hlimit = ip6_dst_hoplimit(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000578 idev = __in6_dev_get(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579
580 msg.skb = skb;
581 msg.offset = 0;
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800582 msg.type = ICMPV6_ECHO_REPLY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583
584 err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
David S. Miller4c9483b2011-03-12 16:22:43 -0500585 sizeof(struct icmp6hdr), hlimit, np->tclass, NULL, &fl6,
Eldad Zacka2d91a02012-04-01 07:49:07 +0000586 (struct rt6_info *)dst, MSG_DONTWAIT,
Brian Haley13b52cd2010-04-23 11:26:08 +0000587 np->dontfrag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588
589 if (err) {
Eric Dumazet00d9d6a2010-06-07 22:24:44 +0000590 ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 ip6_flush_pending_frames(sk);
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000592 } else {
593 err = icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
594 skb->len + sizeof(struct icmp6hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 dst_release(dst);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900597out:
Denis V. Lunev405666d2008-02-29 11:16:46 -0800598 icmpv6_xmit_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599}
600
David S. Millerb94f1c02012-07-12 00:33:37 -0700601void icmpv6_notify(struct sk_buff *skb, u8 type, u8 code, __be32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602{
Alexey Dobriyan41135cc2009-09-14 12:22:28 +0000603 const struct inet6_protocol *ipprot;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 int inner_offset;
Jesse Gross75f28112011-11-30 17:05:51 -0800605 __be16 frag_off;
David S. Millerf9242b62012-06-19 18:56:21 -0700606 u8 nexthdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607
608 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
609 return;
610
611 nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
612 if (ipv6_ext_hdr(nexthdr)) {
613 /* now skip over extension headers */
Jesse Gross75f28112011-11-30 17:05:51 -0800614 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr),
615 &nexthdr, &frag_off);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 if (inner_offset<0)
617 return;
618 } else {
619 inner_offset = sizeof(struct ipv6hdr);
620 }
621
622 /* Checkin header including 8 bytes of inner protocol header. */
623 if (!pskb_may_pull(skb, inner_offset+8))
624 return;
625
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
627 Without this we will not able f.e. to make source routed
628 pmtu discovery.
629 Corresponding argument (opt) to notifiers is already added.
630 --ANK (980726)
631 */
632
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 rcu_read_lock();
David S. Millerf9242b62012-06-19 18:56:21 -0700634 ipprot = rcu_dereference(inet6_protos[nexthdr]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 if (ipprot && ipprot->err_handler)
636 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
637 rcu_read_unlock();
638
Pavel Emelyanov69d6da02007-11-19 22:35:57 -0800639 raw6_icmp_error(skb, nexthdr, type, code, inner_offset, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640}
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900641
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642/*
643 * Handle icmp messages
644 */
645
Herbert Xue5bbef22007-10-15 12:50:28 -0700646static int icmpv6_rcv(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 struct net_device *dev = skb->dev;
649 struct inet6_dev *idev = __in6_dev_get(dev);
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000650 const struct in6_addr *saddr, *daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 struct icmp6hdr *hdr;
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700652 u8 type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653
Herbert Xuaebcf822007-12-12 18:54:16 -0800654 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -0700655 struct sec_path *sp = skb_sec_path(skb);
Herbert Xu8b7817f2007-12-12 10:44:43 -0800656 int nh;
657
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -0700658 if (!(sp && sp->xvec[sp->len - 1]->props.flags &
Herbert Xuaebcf822007-12-12 18:54:16 -0800659 XFRM_STATE_ICMP))
660 goto drop_no_count;
661
David S. Miller81aded22012-06-15 14:54:11 -0700662 if (!pskb_may_pull(skb, sizeof(*hdr) + sizeof(struct ipv6hdr)))
Herbert Xu8b7817f2007-12-12 10:44:43 -0800663 goto drop_no_count;
664
665 nh = skb_network_offset(skb);
666 skb_set_network_header(skb, sizeof(*hdr));
667
668 if (!xfrm6_policy_check_reverse(NULL, XFRM_POLICY_IN, skb))
669 goto drop_no_count;
670
671 skb_set_network_header(skb, nh);
672 }
673
Denis V. Luneve41b5362008-10-08 10:33:26 -0700674 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INMSGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700676 saddr = &ipv6_hdr(skb)->saddr;
677 daddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678
679 /* Perform checksum. */
Herbert Xufb286bb2005-11-10 13:01:24 -0800680 switch (skb->ip_summed) {
Patrick McHardy84fa7932006-08-29 16:44:56 -0700681 case CHECKSUM_COMPLETE:
Herbert Xufb286bb2005-11-10 13:01:24 -0800682 if (!csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
683 skb->csum))
684 break;
685 /* fall through */
686 case CHECKSUM_NONE:
Al Viro868c86b2006-11-14 21:35:48 -0800687 skb->csum = ~csum_unfold(csum_ipv6_magic(saddr, daddr, skb->len,
688 IPPROTO_ICMPV6, 0));
Herbert Xufb286bb2005-11-10 13:01:24 -0800689 if (__skb_checksum_complete(skb)) {
Harvey Harrison5b095d9892008-10-29 12:52:50 -0700690 LIMIT_NETDEBUG(KERN_DEBUG "ICMPv6 checksum failed [%pI6 > %pI6]\n",
Harvey Harrison0c6ce782008-10-28 16:09:23 -0700691 saddr, daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 goto discard_it;
693 }
694 }
695
Herbert Xu8cf22942008-02-05 03:15:50 -0800696 if (!pskb_pull(skb, sizeof(*hdr)))
697 goto discard_it;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300699 hdr = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700
701 type = hdr->icmp6_type;
702
Denis V. Lunev55d43802008-10-08 10:34:54 -0700703 ICMP6MSGIN_INC_STATS_BH(dev_net(dev), idev, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704
705 switch (type) {
706 case ICMPV6_ECHO_REQUEST:
707 icmpv6_echo_reply(skb);
708 break;
709
710 case ICMPV6_ECHO_REPLY:
711 /* we couldn't care less */
712 break;
713
714 case ICMPV6_PKT_TOOBIG:
715 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
716 standard destination cache. Seems, only "advanced"
717 destination cache will allow to solve this problem
718 --ANK (980726)
719 */
720 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
721 goto discard_it;
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300722 hdr = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723
724 /*
725 * Drop through to notify
726 */
727
728 case ICMPV6_DEST_UNREACH:
729 case ICMPV6_TIME_EXCEED:
730 case ICMPV6_PARAMPROB:
731 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
732 break;
733
734 case NDISC_ROUTER_SOLICITATION:
735 case NDISC_ROUTER_ADVERTISEMENT:
736 case NDISC_NEIGHBOUR_SOLICITATION:
737 case NDISC_NEIGHBOUR_ADVERTISEMENT:
738 case NDISC_REDIRECT:
739 ndisc_rcv(skb);
740 break;
741
742 case ICMPV6_MGM_QUERY:
743 igmp6_event_query(skb);
744 break;
745
746 case ICMPV6_MGM_REPORT:
747 igmp6_event_report(skb);
748 break;
749
750 case ICMPV6_MGM_REDUCTION:
751 case ICMPV6_NI_QUERY:
752 case ICMPV6_NI_REPLY:
753 case ICMPV6_MLD2_REPORT:
754 case ICMPV6_DHAAD_REQUEST:
755 case ICMPV6_DHAAD_REPLY:
756 case ICMPV6_MOBILE_PREFIX_SOL:
757 case ICMPV6_MOBILE_PREFIX_ADV:
758 break;
759
760 default:
Patrick McHardy64ce2072005-08-09 20:50:53 -0700761 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6: msg of unknown type\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762
763 /* informational */
764 if (type & ICMPV6_INFOMSG_MASK)
765 break;
766
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900767 /*
768 * error of unknown type.
769 * must pass to upper level
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 */
771
772 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700773 }
774
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 kfree_skb(skb);
776 return 0;
777
778discard_it:
Denis V. Luneve41b5362008-10-08 10:33:26 -0700779 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INERRORS);
Herbert Xu8b7817f2007-12-12 10:44:43 -0800780drop_no_count:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 kfree_skb(skb);
782 return 0;
783}
784
David S. Miller4c9483b2011-03-12 16:22:43 -0500785void icmpv6_flow_init(struct sock *sk, struct flowi6 *fl6,
YOSHIFUJI Hideaki95e41e92007-12-06 15:43:30 -0800786 u8 type,
787 const struct in6_addr *saddr,
788 const struct in6_addr *daddr,
789 int oif)
790{
David S. Miller4c9483b2011-03-12 16:22:43 -0500791 memset(fl6, 0, sizeof(*fl6));
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000792 fl6->saddr = *saddr;
793 fl6->daddr = *daddr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500794 fl6->flowi6_proto = IPPROTO_ICMPV6;
David S. Miller1958b852011-03-12 16:36:19 -0500795 fl6->fl6_icmp_type = type;
796 fl6->fl6_icmp_code = 0;
David S. Miller4c9483b2011-03-12 16:22:43 -0500797 fl6->flowi6_oif = oif;
798 security_sk_classify_flow(sk, flowi6_to_flowi(fl6));
YOSHIFUJI Hideaki95e41e92007-12-06 15:43:30 -0800799}
800
Ingo Molnar640c41c2006-08-15 00:06:56 -0700801/*
Denis V. Lunevb7e729c2008-02-29 11:16:08 -0800802 * Special lock-class for __icmpv6_sk:
Ingo Molnar640c41c2006-08-15 00:06:56 -0700803 */
804static struct lock_class_key icmpv6_socket_sk_dst_lock_key;
805
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800806static int __net_init icmpv6_sk_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807{
808 struct sock *sk;
809 int err, i, j;
810
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800811 net->ipv6.icmp_sk =
812 kzalloc(nr_cpu_ids * sizeof(struct sock *), GFP_KERNEL);
813 if (net->ipv6.icmp_sk == NULL)
Denis V. Lunev79c91152008-02-29 11:17:11 -0800814 return -ENOMEM;
815
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -0700816 for_each_possible_cpu(i) {
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700817 err = inet_ctl_sock_create(&sk, PF_INET6,
818 SOCK_RAW, IPPROTO_ICMPV6, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 if (err < 0) {
Joe Perchesf3213832012-05-15 14:11:53 +0000820 pr_err("Failed to initialize the ICMP6 control socket (err %d)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 err);
822 goto fail;
823 }
824
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700825 net->ipv6.icmp_sk[i] = sk;
Denis V. Lunev5c8cafd2008-02-29 11:19:22 -0800826
Ingo Molnar640c41c2006-08-15 00:06:56 -0700827 /*
828 * Split off their lock-class, because sk->sk_dst_lock
829 * gets used from softirqs, which is safe for
Denis V. Lunevb7e729c2008-02-29 11:16:08 -0800830 * __icmpv6_sk (because those never get directly used
Ingo Molnar640c41c2006-08-15 00:06:56 -0700831 * via userspace syscalls), but unsafe for normal sockets.
832 */
833 lockdep_set_class(&sk->sk_dst_lock,
834 &icmpv6_socket_sk_dst_lock_key);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835
836 /* Enough space for 2 64K ICMP packets, including
837 * sk_buff struct overhead.
838 */
Eric Dumazet87fb4b72011-10-13 07:28:54 +0000839 sk->sk_sndbuf = 2 * SKB_TRUESIZE(64 * 1024);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 return 0;
842
843 fail:
Denis V. Lunev5c8cafd2008-02-29 11:19:22 -0800844 for (j = 0; j < i; j++)
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700845 inet_ctl_sock_destroy(net->ipv6.icmp_sk[j]);
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800846 kfree(net->ipv6.icmp_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 return err;
848}
849
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800850static void __net_exit icmpv6_sk_exit(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851{
852 int i;
853
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -0700854 for_each_possible_cpu(i) {
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700855 inet_ctl_sock_destroy(net->ipv6.icmp_sk[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 }
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800857 kfree(net->ipv6.icmp_sk);
858}
859
Alexey Dobriyan8ed7edc2008-03-03 12:02:54 -0800860static struct pernet_operations icmpv6_sk_ops = {
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800861 .init = icmpv6_sk_init,
862 .exit = icmpv6_sk_exit,
863};
864
865int __init icmpv6_init(void)
866{
867 int err;
868
869 err = register_pernet_subsys(&icmpv6_sk_ops);
870 if (err < 0)
871 return err;
872
873 err = -EAGAIN;
874 if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0)
875 goto fail;
876 return 0;
877
878fail:
Joe Perchesf3213832012-05-15 14:11:53 +0000879 pr_err("Failed to register ICMP6 protocol\n");
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800880 unregister_pernet_subsys(&icmpv6_sk_ops);
881 return err;
882}
883
Alexey Dobriyan8ed7edc2008-03-03 12:02:54 -0800884void icmpv6_cleanup(void)
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800885{
886 unregister_pernet_subsys(&icmpv6_sk_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
888}
889
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800890
Arjan van de Ven9b5b5cf2005-11-29 16:21:38 -0800891static const struct icmp6_err {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 int err;
893 int fatal;
894} tab_unreach[] = {
895 { /* NOROUTE */
896 .err = ENETUNREACH,
897 .fatal = 0,
898 },
899 { /* ADM_PROHIBITED */
900 .err = EACCES,
901 .fatal = 1,
902 },
903 { /* Was NOT_NEIGHBOUR, now reserved */
904 .err = EHOSTUNREACH,
905 .fatal = 0,
906 },
907 { /* ADDR_UNREACH */
908 .err = EHOSTUNREACH,
909 .fatal = 0,
910 },
911 { /* PORT_UNREACH */
912 .err = ECONNREFUSED,
913 .fatal = 1,
914 },
915};
916
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700917int icmpv6_err_convert(u8 type, u8 code, int *err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918{
919 int fatal = 0;
920
921 *err = EPROTO;
922
923 switch (type) {
924 case ICMPV6_DEST_UNREACH:
925 fatal = 1;
926 if (code <= ICMPV6_PORT_UNREACH) {
927 *err = tab_unreach[code].err;
928 fatal = tab_unreach[code].fatal;
929 }
930 break;
931
932 case ICMPV6_PKT_TOOBIG:
933 *err = EMSGSIZE;
934 break;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900935
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 case ICMPV6_PARAMPROB:
937 *err = EPROTO;
938 fatal = 1;
939 break;
940
941 case ICMPV6_TIME_EXCEED:
942 *err = EHOSTUNREACH;
943 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700944 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945
946 return fatal;
947}
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900948EXPORT_SYMBOL(icmpv6_err_convert);
949
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950#ifdef CONFIG_SYSCTL
Daniel Lezcano760f2d02008-01-10 02:53:43 -0800951ctl_table ipv6_icmp_table_template[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953 .procname = "ratelimit",
Daniel Lezcano41a76902008-01-10 03:02:40 -0800954 .data = &init_net.ipv6.sysctl.icmpv6_time,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 .maxlen = sizeof(int),
956 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -0800957 .proc_handler = proc_dointvec_ms_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 },
Eric W. Biedermanf8572d82009-11-05 13:32:03 -0800959 { },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960};
Daniel Lezcano760f2d02008-01-10 02:53:43 -0800961
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +0000962struct ctl_table * __net_init ipv6_icmp_sysctl_init(struct net *net)
Daniel Lezcano760f2d02008-01-10 02:53:43 -0800963{
964 struct ctl_table *table;
965
966 table = kmemdup(ipv6_icmp_table_template,
967 sizeof(ipv6_icmp_table_template),
968 GFP_KERNEL);
YOSHIFUJI Hideaki5ee09102008-02-28 00:24:28 +0900969
970 if (table)
971 table[0].data = &net->ipv6.sysctl.icmpv6_time;
972
Daniel Lezcano760f2d02008-01-10 02:53:43 -0800973 return table;
974}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975#endif
976