blob: 27ac95a6342927e5365af6616af82815e603619e [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
32#include <linux/module.h>
33#include <linux/errno.h>
34#include <linux/types.h>
35#include <linux/socket.h>
36#include <linux/in.h>
37#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <linux/sockios.h>
39#include <linux/net.h>
40#include <linux/skbuff.h>
41#include <linux/init.h>
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -080042#include <linux/netfilter.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090043#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
45#ifdef CONFIG_SYSCTL
46#include <linux/sysctl.h>
47#endif
48
49#include <linux/inet.h>
50#include <linux/netdevice.h>
51#include <linux/icmpv6.h>
52
53#include <net/ip.h>
54#include <net/sock.h>
55
56#include <net/ipv6.h>
57#include <net/ip6_checksum.h>
58#include <net/protocol.h>
59#include <net/raw.h>
60#include <net/rawv6.h>
61#include <net/transp_v6.h>
62#include <net/ip6_route.h>
63#include <net/addrconf.h>
64#include <net/icmp.h>
Herbert Xu8b7817f2007-12-12 10:44:43 -080065#include <net/xfrm.h>
Denis V. Lunev1ed85162008-04-03 14:31:03 -070066#include <net/inet_common.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
68#include <asm/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070069
Linus Torvalds1da177e2005-04-16 15:20:36 -070070/*
71 * The ICMP socket(s). This is the most convenient way to flow control
72 * our ICMP output as well as maintain a clean interface throughout
73 * all layers. All Socketless IP sends will soon be gone.
74 *
75 * On SMP we have one ICMP socket per-cpu.
76 */
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -080077static inline struct sock *icmpv6_sk(struct net *net)
78{
79 return net->ipv6.icmp_sk[smp_processor_id()];
80}
Linus Torvalds1da177e2005-04-16 15:20:36 -070081
Herbert Xue5bbef22007-10-15 12:50:28 -070082static int icmpv6_rcv(struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070083
Alexey Dobriyan41135cc2009-09-14 12:22:28 +000084static const struct inet6_protocol icmpv6_protocol = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070085 .handler = icmpv6_rcv,
Herbert Xu8b7817f2007-12-12 10:44:43 -080086 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
Linus Torvalds1da177e2005-04-16 15:20:36 -070087};
88
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -070089static __inline__ struct sock *icmpv6_xmit_lock(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -070090{
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -070091 struct sock *sk;
92
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 local_bh_disable();
94
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -070095 sk = icmpv6_sk(net);
Denis V. Lunev405666d2008-02-29 11:16:46 -080096 if (unlikely(!spin_trylock(&sk->sk_lock.slock))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 /* This can happen if the output path (f.e. SIT or
98 * ip6ip6 tunnel) signals dst_link_failure() for an
99 * outgoing ICMP6 packet.
100 */
101 local_bh_enable();
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700102 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 }
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700104 return sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105}
106
Denis V. Lunev405666d2008-02-29 11:16:46 -0800107static __inline__ void icmpv6_xmit_unlock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108{
Denis V. Lunev405666d2008-02-29 11:16:46 -0800109 spin_unlock_bh(&sk->sk_lock.slock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110}
111
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900112/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 * Slightly more convenient version of icmpv6_send.
114 */
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700115void icmpv6_param_prob(struct sk_buff *skb, u8 code, int pos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116{
Alexey Dobriyan3ffe5332010-02-18 08:25:24 +0000117 icmpv6_send(skb, ICMPV6_PARAMPROB, code, pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 kfree_skb(skb);
119}
120
121/*
122 * Figure out, may we reply to this packet with icmp error.
123 *
124 * We do not reply, if:
125 * - it was icmp error message.
126 * - it is truncated, so that it is known, that protocol is ICMPV6
127 * (i.e. in the middle of some exthdr)
128 *
129 * --ANK (980726)
130 */
131
132static int is_ineligible(struct sk_buff *skb)
133{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700134 int ptr = (u8 *)(ipv6_hdr(skb) + 1) - skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 int len = skb->len - ptr;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700136 __u8 nexthdr = ipv6_hdr(skb)->nexthdr;
Jesse Gross75f28112011-11-30 17:05:51 -0800137 __be16 frag_off;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138
139 if (len < 0)
140 return 1;
141
Jesse Gross75f28112011-11-30 17:05:51 -0800142 ptr = ipv6_skip_exthdr(skb, ptr, &nexthdr, &frag_off);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 if (ptr < 0)
144 return 0;
145 if (nexthdr == IPPROTO_ICMPV6) {
146 u8 _type, *tp;
147 tp = skb_header_pointer(skb,
148 ptr+offsetof(struct icmp6hdr, icmp6_type),
149 sizeof(_type), &_type);
150 if (tp == NULL ||
151 !(*tp & ICMPV6_INFOMSG_MASK))
152 return 1;
153 }
154 return 0;
155}
156
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900157/*
158 * Check the ICMP output rate limit
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 */
David S. Miller92d86822011-02-04 15:55:25 -0800160static inline bool icmpv6_xrlim_allow(struct sock *sk, u8 type,
David S. Miller4c9483b2011-03-12 16:22:43 -0500161 struct flowi6 *fl6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162{
163 struct dst_entry *dst;
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900164 struct net *net = sock_net(sk);
David S. Miller92d86822011-02-04 15:55:25 -0800165 bool res = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166
167 /* Informational messages are not limited. */
168 if (type & ICMPV6_INFOMSG_MASK)
David S. Miller92d86822011-02-04 15:55:25 -0800169 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
171 /* Do not limit pmtu discovery, it would break it. */
172 if (type == ICMPV6_PKT_TOOBIG)
David S. Miller92d86822011-02-04 15:55:25 -0800173 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900175 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 * Look up the output route.
177 * XXX: perhaps the expire for routing entries cloned by
178 * this lookup should be more aggressive (not longer than timeout).
179 */
David S. Miller4c9483b2011-03-12 16:22:43 -0500180 dst = ip6_route_output(net, sk, fl6);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 if (dst->error) {
Denis V. Lunev3bd653c2008-10-08 10:54:51 -0700182 IP6_INC_STATS(net, ip6_dst_idev(dst),
YOSHIFUJI Hideakia11d2062006-11-04 20:11:37 +0900183 IPSTATS_MIB_OUTNOROUTES);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 } else if (dst->dev && (dst->dev->flags&IFF_LOOPBACK)) {
David S. Miller92d86822011-02-04 15:55:25 -0800185 res = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 } else {
187 struct rt6_info *rt = (struct rt6_info *)dst;
Benjamin Thery9a43b702008-03-05 10:49:18 -0800188 int tmo = net->ipv6.sysctl.icmpv6_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189
190 /* Give more bandwidth to wider prefixes. */
191 if (rt->rt6i_dst.plen < 128)
192 tmo >>= ((128 - rt->rt6i_dst.plen)>>5);
193
David S. Miller92d86822011-02-04 15:55:25 -0800194 if (!rt->rt6i_peer)
195 rt6_bind_peer(rt, 1);
196 res = inet_peer_xrlim_allow(rt->rt6i_peer, tmo);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 }
198 dst_release(dst);
199 return res;
200}
201
202/*
203 * an inline helper for the "simple" if statement below
204 * checks if parameter problem report is caused by an
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900205 * unrecognized IPv6 option that has the Option Type
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 * highest-order two bits set to 10
207 */
208
209static __inline__ int opt_unrec(struct sk_buff *skb, __u32 offset)
210{
211 u8 _optval, *op;
212
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -0300213 offset += skb_network_offset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 op = skb_header_pointer(skb, offset, sizeof(_optval), &_optval);
215 if (op == NULL)
216 return 1;
217 return (*op & 0xC0) == 0x80;
218}
219
David S. Miller4c9483b2011-03-12 16:22:43 -0500220static int icmpv6_push_pending_frames(struct sock *sk, struct flowi6 *fl6, struct icmp6hdr *thdr, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221{
222 struct sk_buff *skb;
223 struct icmp6hdr *icmp6h;
224 int err = 0;
225
226 if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
227 goto out;
228
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300229 icmp6h = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 memcpy(icmp6h, thdr, sizeof(struct icmp6hdr));
231 icmp6h->icmp6_cksum = 0;
232
233 if (skb_queue_len(&sk->sk_write_queue) == 1) {
Joe Perches07f07572008-11-19 15:44:53 -0800234 skb->csum = csum_partial(icmp6h,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 sizeof(struct icmp6hdr), skb->csum);
David S. Miller4c9483b2011-03-12 16:22:43 -0500236 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
237 &fl6->daddr,
238 len, fl6->flowi6_proto,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 skb->csum);
240 } else {
Al Viro868c86b2006-11-14 21:35:48 -0800241 __wsum tmp_csum = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242
243 skb_queue_walk(&sk->sk_write_queue, skb) {
244 tmp_csum = csum_add(tmp_csum, skb->csum);
245 }
246
Joe Perches07f07572008-11-19 15:44:53 -0800247 tmp_csum = csum_partial(icmp6h,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 sizeof(struct icmp6hdr), tmp_csum);
David S. Miller4c9483b2011-03-12 16:22:43 -0500249 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
250 &fl6->daddr,
251 len, fl6->flowi6_proto,
Al Viro868c86b2006-11-14 21:35:48 -0800252 tmp_csum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 ip6_push_pending_frames(sk);
255out:
256 return err;
257}
258
259struct icmpv6_msg {
260 struct sk_buff *skb;
261 int offset;
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800262 uint8_t type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263};
264
265static int icmpv6_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb)
266{
267 struct icmpv6_msg *msg = (struct icmpv6_msg *) from;
268 struct sk_buff *org_skb = msg->skb;
Al Viro5f92a732006-11-14 21:36:54 -0800269 __wsum csum = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270
271 csum = skb_copy_and_csum_bits(org_skb, msg->offset + offset,
272 to, len, csum);
273 skb->csum = csum_block_add(skb->csum, csum, odd);
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800274 if (!(msg->type & ICMPV6_INFOMSG_MASK))
275 nf_ct_attach(skb, org_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 return 0;
277}
278
Masahide NAKAMURA59fbb3a2007-06-26 23:56:32 -0700279#if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700280static void mip6_addr_swap(struct sk_buff *skb)
281{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700282 struct ipv6hdr *iph = ipv6_hdr(skb);
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700283 struct inet6_skb_parm *opt = IP6CB(skb);
284 struct ipv6_destopt_hao *hao;
285 struct in6_addr tmp;
286 int off;
287
288 if (opt->dsthao) {
289 off = ipv6_find_tlv(skb, opt->dsthao, IPV6_TLV_HAO);
290 if (likely(off >= 0)) {
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700291 hao = (struct ipv6_destopt_hao *)
292 (skb_network_header(skb) + off);
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000293 tmp = iph->saddr;
294 iph->saddr = hao->addr;
295 hao->addr = tmp;
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700296 }
297 }
298}
299#else
300static inline void mip6_addr_swap(struct sk_buff *skb) {}
301#endif
302
David S. Millerb42835d2011-03-01 22:06:22 -0800303static struct dst_entry *icmpv6_route_lookup(struct net *net, struct sk_buff *skb,
David S. Miller4c9483b2011-03-12 16:22:43 -0500304 struct sock *sk, struct flowi6 *fl6)
David S. Millerb42835d2011-03-01 22:06:22 -0800305{
306 struct dst_entry *dst, *dst2;
David S. Miller4c9483b2011-03-12 16:22:43 -0500307 struct flowi6 fl2;
David S. Millerb42835d2011-03-01 22:06:22 -0800308 int err;
309
David S. Miller4c9483b2011-03-12 16:22:43 -0500310 err = ip6_dst_lookup(sk, &dst, fl6);
David S. Millerb42835d2011-03-01 22:06:22 -0800311 if (err)
312 return ERR_PTR(err);
313
314 /*
315 * We won't send icmp if the destination is known
316 * anycast.
317 */
318 if (((struct rt6_info *)dst)->rt6i_flags & RTF_ANYCAST) {
319 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: acast source\n");
320 dst_release(dst);
321 return ERR_PTR(-EINVAL);
322 }
323
324 /* No need to clone since we're just using its address. */
325 dst2 = dst;
326
David S. Miller4c9483b2011-03-12 16:22:43 -0500327 dst = xfrm_lookup(net, dst, flowi6_to_flowi(fl6), sk, 0);
David S. Miller452edd52011-03-02 13:27:41 -0800328 if (!IS_ERR(dst)) {
David S. Millerb42835d2011-03-01 22:06:22 -0800329 if (dst != dst2)
330 return dst;
David S. Miller452edd52011-03-02 13:27:41 -0800331 } else {
332 if (PTR_ERR(dst) == -EPERM)
333 dst = NULL;
334 else
335 return dst;
David S. Millerb42835d2011-03-01 22:06:22 -0800336 }
337
David S. Miller4c9483b2011-03-12 16:22:43 -0500338 err = xfrm_decode_session_reverse(skb, flowi6_to_flowi(&fl2), AF_INET6);
David S. Millerb42835d2011-03-01 22:06:22 -0800339 if (err)
340 goto relookup_failed;
341
342 err = ip6_dst_lookup(sk, &dst2, &fl2);
343 if (err)
344 goto relookup_failed;
345
David S. Miller4c9483b2011-03-12 16:22:43 -0500346 dst2 = xfrm_lookup(net, dst2, flowi6_to_flowi(&fl2), sk, XFRM_LOOKUP_ICMP);
David S. Miller452edd52011-03-02 13:27:41 -0800347 if (!IS_ERR(dst2)) {
David S. Millerb42835d2011-03-01 22:06:22 -0800348 dst_release(dst);
349 dst = dst2;
David S. Miller452edd52011-03-02 13:27:41 -0800350 } else {
351 err = PTR_ERR(dst2);
352 if (err == -EPERM) {
353 dst_release(dst);
354 return dst2;
355 } else
356 goto relookup_failed;
David S. Millerb42835d2011-03-01 22:06:22 -0800357 }
358
359relookup_failed:
360 if (dst)
361 return dst;
362 return ERR_PTR(err);
363}
364
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365/*
366 * Send an ICMP message in response to a packet in error
367 */
Alexey Dobriyan3ffe5332010-02-18 08:25:24 +0000368void icmpv6_send(struct sk_buff *skb, u8 type, u8 code, __u32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900370 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 struct inet6_dev *idev = NULL;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700372 struct ipv6hdr *hdr = ipv6_hdr(skb);
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700373 struct sock *sk;
374 struct ipv6_pinfo *np;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000375 const struct in6_addr *saddr = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 struct dst_entry *dst;
377 struct icmp6hdr tmp_hdr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500378 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 struct icmpv6_msg msg;
380 int iif = 0;
381 int addr_type = 0;
382 int len;
Gerrit Renkere651f032009-08-09 08:12:48 +0000383 int hlimit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 int err = 0;
385
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700386 if ((u8 *)hdr < skb->head ||
387 (skb->network_header + sizeof(*hdr)) > skb->tail)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 return;
389
390 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900391 * Make sure we respect the rules
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 * i.e. RFC 1885 2.4(e)
393 * Rule (e.1) is enforced by not using icmpv6_send
394 * in any code that processes icmp errors.
395 */
396 addr_type = ipv6_addr_type(&hdr->daddr);
397
Benjamin Thery9a43b702008-03-05 10:49:18 -0800398 if (ipv6_chk_addr(net, &hdr->daddr, skb->dev, 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 saddr = &hdr->daddr;
400
401 /*
402 * Dest addr check
403 */
404
405 if ((addr_type & IPV6_ADDR_MULTICAST || skb->pkt_type != PACKET_HOST)) {
406 if (type != ICMPV6_PKT_TOOBIG &&
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900407 !(type == ICMPV6_PARAMPROB &&
408 code == ICMPV6_UNK_OPTION &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 (opt_unrec(skb, info))))
410 return;
411
412 saddr = NULL;
413 }
414
415 addr_type = ipv6_addr_type(&hdr->saddr);
416
417 /*
418 * Source addr check
419 */
420
421 if (addr_type & IPV6_ADDR_LINKLOCAL)
422 iif = skb->dev->ifindex;
423
424 /*
YOSHIFUJI Hideaki8de33512005-12-21 22:57:06 +0900425 * Must not send error if the source does not uniquely
426 * identify a single node (RFC2463 Section 2.4).
427 * We check unspecified / multicast addresses here,
428 * and anycast addresses will be checked later.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 */
430 if ((addr_type == IPV6_ADDR_ANY) || (addr_type & IPV6_ADDR_MULTICAST)) {
Patrick McHardy64ce2072005-08-09 20:50:53 -0700431 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: addr_any/mcast source\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 return;
433 }
434
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900435 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 * Never answer to a ICMP packet.
437 */
438 if (is_ineligible(skb)) {
Patrick McHardy64ce2072005-08-09 20:50:53 -0700439 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: no reply to icmp error\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 return;
441 }
442
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700443 mip6_addr_swap(skb);
444
David S. Miller4c9483b2011-03-12 16:22:43 -0500445 memset(&fl6, 0, sizeof(fl6));
446 fl6.flowi6_proto = IPPROTO_ICMPV6;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000447 fl6.daddr = hdr->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 if (saddr)
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000449 fl6.saddr = *saddr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500450 fl6.flowi6_oif = iif;
David S. Miller1958b852011-03-12 16:36:19 -0500451 fl6.fl6_icmp_type = type;
452 fl6.fl6_icmp_code = code;
David S. Miller4c9483b2011-03-12 16:22:43 -0500453 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700455 sk = icmpv6_xmit_lock(net);
456 if (sk == NULL)
Denis V. Lunev405666d2008-02-29 11:16:46 -0800457 return;
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700458 np = inet6_sk(sk);
Denis V. Lunev405666d2008-02-29 11:16:46 -0800459
David S. Miller4c9483b2011-03-12 16:22:43 -0500460 if (!icmpv6_xrlim_allow(sk, type, &fl6))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 goto out;
462
463 tmp_hdr.icmp6_type = type;
464 tmp_hdr.icmp6_code = code;
465 tmp_hdr.icmp6_cksum = 0;
466 tmp_hdr.icmp6_pointer = htonl(info);
467
David S. Miller4c9483b2011-03-12 16:22:43 -0500468 if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
469 fl6.flowi6_oif = np->mcast_oif;
Erich E. Hooverc4062df2012-02-08 09:11:08 +0000470 else if (!fl6.flowi6_oif)
471 fl6.flowi6_oif = np->ucast_oif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
David S. Miller4c9483b2011-03-12 16:22:43 -0500473 dst = icmpv6_route_lookup(net, skb, sk, &fl6);
David S. Millerb42835d2011-03-01 22:06:22 -0800474 if (IS_ERR(dst))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 goto out;
YOSHIFUJI Hideaki8de33512005-12-21 22:57:06 +0900476
David S. Miller4c9483b2011-03-12 16:22:43 -0500477 if (ipv6_addr_is_multicast(&fl6.daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 hlimit = np->mcast_hops;
479 else
480 hlimit = np->hop_limit;
481 if (hlimit < 0)
YOSHIFUJI Hideaki6b75d092008-03-10 06:00:30 -0400482 hlimit = ip6_dst_hoplimit(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483
484 msg.skb = skb;
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -0300485 msg.offset = skb_network_offset(skb);
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800486 msg.type = type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487
488 len = skb->len - msg.offset;
489 len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) -sizeof(struct icmp6hdr));
490 if (len < 0) {
Patrick McHardy64ce2072005-08-09 20:50:53 -0700491 LIMIT_NETDEBUG(KERN_DEBUG "icmp: len problem\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 goto out_dst_release;
493 }
494
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000495 rcu_read_lock();
496 idev = __in6_dev_get(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497
498 err = ip6_append_data(sk, icmpv6_getfrag, &msg,
499 len + sizeof(struct icmp6hdr),
Gerrit Renkere651f032009-08-09 08:12:48 +0000500 sizeof(struct icmp6hdr), hlimit,
David S. Miller4c9483b2011-03-12 16:22:43 -0500501 np->tclass, NULL, &fl6, (struct rt6_info*)dst,
Brian Haley13b52cd2010-04-23 11:26:08 +0000502 MSG_DONTWAIT, np->dontfrag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 if (err) {
Eric Dumazet00d9d6a2010-06-07 22:24:44 +0000504 ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 ip6_flush_pending_frames(sk);
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000506 } else {
507 err = icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
508 len + sizeof(struct icmp6hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 }
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000510 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511out_dst_release:
512 dst_release(dst);
513out:
Denis V. Lunev405666d2008-02-29 11:16:46 -0800514 icmpv6_xmit_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515}
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900516EXPORT_SYMBOL(icmpv6_send);
517
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518static void icmpv6_echo_reply(struct sk_buff *skb)
519{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900520 struct net *net = dev_net(skb->dev);
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700521 struct sock *sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 struct inet6_dev *idev;
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700523 struct ipv6_pinfo *np;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000524 const struct in6_addr *saddr = NULL;
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300525 struct icmp6hdr *icmph = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 struct icmp6hdr tmp_hdr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500527 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 struct icmpv6_msg msg;
529 struct dst_entry *dst;
530 int err = 0;
531 int hlimit;
532
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700533 saddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534
535 if (!ipv6_unicast_destination(skb))
536 saddr = NULL;
537
538 memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
539 tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;
540
David S. Miller4c9483b2011-03-12 16:22:43 -0500541 memset(&fl6, 0, sizeof(fl6));
542 fl6.flowi6_proto = IPPROTO_ICMPV6;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000543 fl6.daddr = ipv6_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 if (saddr)
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000545 fl6.saddr = *saddr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500546 fl6.flowi6_oif = skb->dev->ifindex;
David S. Miller1958b852011-03-12 16:36:19 -0500547 fl6.fl6_icmp_type = ICMPV6_ECHO_REPLY;
David S. Miller4c9483b2011-03-12 16:22:43 -0500548 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700550 sk = icmpv6_xmit_lock(net);
551 if (sk == NULL)
Denis V. Lunev405666d2008-02-29 11:16:46 -0800552 return;
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700553 np = inet6_sk(sk);
Denis V. Lunev405666d2008-02-29 11:16:46 -0800554
David S. Miller4c9483b2011-03-12 16:22:43 -0500555 if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
556 fl6.flowi6_oif = np->mcast_oif;
Erich E. Hooverc4062df2012-02-08 09:11:08 +0000557 else if (!fl6.flowi6_oif)
558 fl6.flowi6_oif = np->ucast_oif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559
David S. Miller4c9483b2011-03-12 16:22:43 -0500560 err = ip6_dst_lookup(sk, &dst, &fl6);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 if (err)
562 goto out;
David S. Miller4c9483b2011-03-12 16:22:43 -0500563 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), sk, 0);
David S. Miller452edd52011-03-02 13:27:41 -0800564 if (IS_ERR(dst))
Patrick McHardye1044112005-09-08 15:11:55 -0700565 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566
David S. Miller4c9483b2011-03-12 16:22:43 -0500567 if (ipv6_addr_is_multicast(&fl6.daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 hlimit = np->mcast_hops;
569 else
570 hlimit = np->hop_limit;
571 if (hlimit < 0)
YOSHIFUJI Hideaki6b75d092008-03-10 06:00:30 -0400572 hlimit = ip6_dst_hoplimit(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000574 idev = __in6_dev_get(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575
576 msg.skb = skb;
577 msg.offset = 0;
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800578 msg.type = ICMPV6_ECHO_REPLY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579
580 err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
David S. Miller4c9483b2011-03-12 16:22:43 -0500581 sizeof(struct icmp6hdr), hlimit, np->tclass, NULL, &fl6,
Brian Haley13b52cd2010-04-23 11:26:08 +0000582 (struct rt6_info*)dst, MSG_DONTWAIT,
583 np->dontfrag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584
585 if (err) {
Eric Dumazet00d9d6a2010-06-07 22:24:44 +0000586 ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 ip6_flush_pending_frames(sk);
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000588 } else {
589 err = icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
590 skb->len + sizeof(struct icmp6hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 dst_release(dst);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900593out:
Denis V. Lunev405666d2008-02-29 11:16:46 -0800594 icmpv6_xmit_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595}
596
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700597static void icmpv6_notify(struct sk_buff *skb, u8 type, u8 code, __be32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598{
Alexey Dobriyan41135cc2009-09-14 12:22:28 +0000599 const struct inet6_protocol *ipprot;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 int inner_offset;
601 int hash;
602 u8 nexthdr;
Jesse Gross75f28112011-11-30 17:05:51 -0800603 __be16 frag_off;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604
605 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
606 return;
607
608 nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
609 if (ipv6_ext_hdr(nexthdr)) {
610 /* now skip over extension headers */
Jesse Gross75f28112011-11-30 17:05:51 -0800611 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr),
612 &nexthdr, &frag_off);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 if (inner_offset<0)
614 return;
615 } else {
616 inner_offset = sizeof(struct ipv6hdr);
617 }
618
619 /* Checkin header including 8 bytes of inner protocol header. */
620 if (!pskb_may_pull(skb, inner_offset+8))
621 return;
622
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
624 Without this we will not able f.e. to make source routed
625 pmtu discovery.
626 Corresponding argument (opt) to notifiers is already added.
627 --ANK (980726)
628 */
629
630 hash = nexthdr & (MAX_INET_PROTOS - 1);
631
632 rcu_read_lock();
633 ipprot = rcu_dereference(inet6_protos[hash]);
634 if (ipprot && ipprot->err_handler)
635 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
636 rcu_read_unlock();
637
Pavel Emelyanov69d6da02007-11-19 22:35:57 -0800638 raw6_icmp_error(skb, nexthdr, type, code, inner_offset, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639}
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900640
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641/*
642 * Handle icmp messages
643 */
644
Herbert Xue5bbef22007-10-15 12:50:28 -0700645static int icmpv6_rcv(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 struct net_device *dev = skb->dev;
648 struct inet6_dev *idev = __in6_dev_get(dev);
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000649 const struct in6_addr *saddr, *daddr;
650 const struct ipv6hdr *orig_hdr;
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
Herbert Xu8b7817f2007-12-12 10:44:43 -0800662 if (!pskb_may_pull(skb, sizeof(*hdr) + sizeof(*orig_hdr)))
663 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 orig_hdr = (struct ipv6hdr *) (hdr + 1);
724 rt6_pmtu_discovery(&orig_hdr->daddr, &orig_hdr->saddr, dev,
725 ntohl(hdr->icmp6_mtu));
726
727 /*
728 * Drop through to notify
729 */
730
731 case ICMPV6_DEST_UNREACH:
732 case ICMPV6_TIME_EXCEED:
733 case ICMPV6_PARAMPROB:
734 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
735 break;
736
737 case NDISC_ROUTER_SOLICITATION:
738 case NDISC_ROUTER_ADVERTISEMENT:
739 case NDISC_NEIGHBOUR_SOLICITATION:
740 case NDISC_NEIGHBOUR_ADVERTISEMENT:
741 case NDISC_REDIRECT:
742 ndisc_rcv(skb);
743 break;
744
745 case ICMPV6_MGM_QUERY:
746 igmp6_event_query(skb);
747 break;
748
749 case ICMPV6_MGM_REPORT:
750 igmp6_event_report(skb);
751 break;
752
753 case ICMPV6_MGM_REDUCTION:
754 case ICMPV6_NI_QUERY:
755 case ICMPV6_NI_REPLY:
756 case ICMPV6_MLD2_REPORT:
757 case ICMPV6_DHAAD_REQUEST:
758 case ICMPV6_DHAAD_REPLY:
759 case ICMPV6_MOBILE_PREFIX_SOL:
760 case ICMPV6_MOBILE_PREFIX_ADV:
761 break;
762
763 default:
Patrick McHardy64ce2072005-08-09 20:50:53 -0700764 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6: msg of unknown type\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765
766 /* informational */
767 if (type & ICMPV6_INFOMSG_MASK)
768 break;
769
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900770 /*
771 * error of unknown type.
772 * must pass to upper level
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 */
774
775 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700776 }
777
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 kfree_skb(skb);
779 return 0;
780
781discard_it:
Denis V. Luneve41b5362008-10-08 10:33:26 -0700782 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INERRORS);
Herbert Xu8b7817f2007-12-12 10:44:43 -0800783drop_no_count:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 kfree_skb(skb);
785 return 0;
786}
787
David S. Miller4c9483b2011-03-12 16:22:43 -0500788void icmpv6_flow_init(struct sock *sk, struct flowi6 *fl6,
YOSHIFUJI Hideaki95e41e92007-12-06 15:43:30 -0800789 u8 type,
790 const struct in6_addr *saddr,
791 const struct in6_addr *daddr,
792 int oif)
793{
David S. Miller4c9483b2011-03-12 16:22:43 -0500794 memset(fl6, 0, sizeof(*fl6));
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000795 fl6->saddr = *saddr;
796 fl6->daddr = *daddr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500797 fl6->flowi6_proto = IPPROTO_ICMPV6;
David S. Miller1958b852011-03-12 16:36:19 -0500798 fl6->fl6_icmp_type = type;
799 fl6->fl6_icmp_code = 0;
David S. Miller4c9483b2011-03-12 16:22:43 -0500800 fl6->flowi6_oif = oif;
801 security_sk_classify_flow(sk, flowi6_to_flowi(fl6));
YOSHIFUJI Hideaki95e41e92007-12-06 15:43:30 -0800802}
803
Ingo Molnar640c41c2006-08-15 00:06:56 -0700804/*
Denis V. Lunevb7e729c2008-02-29 11:16:08 -0800805 * Special lock-class for __icmpv6_sk:
Ingo Molnar640c41c2006-08-15 00:06:56 -0700806 */
807static struct lock_class_key icmpv6_socket_sk_dst_lock_key;
808
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800809static int __net_init icmpv6_sk_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810{
811 struct sock *sk;
812 int err, i, j;
813
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800814 net->ipv6.icmp_sk =
815 kzalloc(nr_cpu_ids * sizeof(struct sock *), GFP_KERNEL);
816 if (net->ipv6.icmp_sk == NULL)
Denis V. Lunev79c91152008-02-29 11:17:11 -0800817 return -ENOMEM;
818
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -0700819 for_each_possible_cpu(i) {
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700820 err = inet_ctl_sock_create(&sk, PF_INET6,
821 SOCK_RAW, IPPROTO_ICMPV6, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 if (err < 0) {
823 printk(KERN_ERR
824 "Failed to initialize the ICMP6 control socket "
825 "(err %d).\n",
826 err);
827 goto fail;
828 }
829
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700830 net->ipv6.icmp_sk[i] = sk;
Denis V. Lunev5c8cafd2008-02-29 11:19:22 -0800831
Ingo Molnar640c41c2006-08-15 00:06:56 -0700832 /*
833 * Split off their lock-class, because sk->sk_dst_lock
834 * gets used from softirqs, which is safe for
Denis V. Lunevb7e729c2008-02-29 11:16:08 -0800835 * __icmpv6_sk (because those never get directly used
Ingo Molnar640c41c2006-08-15 00:06:56 -0700836 * via userspace syscalls), but unsafe for normal sockets.
837 */
838 lockdep_set_class(&sk->sk_dst_lock,
839 &icmpv6_socket_sk_dst_lock_key);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840
841 /* Enough space for 2 64K ICMP packets, including
842 * sk_buff struct overhead.
843 */
Eric Dumazet87fb4b72011-10-13 07:28:54 +0000844 sk->sk_sndbuf = 2 * SKB_TRUESIZE(64 * 1024);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 return 0;
847
848 fail:
Denis V. Lunev5c8cafd2008-02-29 11:19:22 -0800849 for (j = 0; j < i; j++)
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700850 inet_ctl_sock_destroy(net->ipv6.icmp_sk[j]);
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800851 kfree(net->ipv6.icmp_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 return err;
853}
854
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800855static void __net_exit icmpv6_sk_exit(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856{
857 int i;
858
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -0700859 for_each_possible_cpu(i) {
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700860 inet_ctl_sock_destroy(net->ipv6.icmp_sk[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 }
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800862 kfree(net->ipv6.icmp_sk);
863}
864
Alexey Dobriyan8ed7edc2008-03-03 12:02:54 -0800865static struct pernet_operations icmpv6_sk_ops = {
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800866 .init = icmpv6_sk_init,
867 .exit = icmpv6_sk_exit,
868};
869
870int __init icmpv6_init(void)
871{
872 int err;
873
874 err = register_pernet_subsys(&icmpv6_sk_ops);
875 if (err < 0)
876 return err;
877
878 err = -EAGAIN;
879 if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0)
880 goto fail;
881 return 0;
882
883fail:
884 printk(KERN_ERR "Failed to register ICMP6 protocol\n");
885 unregister_pernet_subsys(&icmpv6_sk_ops);
886 return err;
887}
888
Alexey Dobriyan8ed7edc2008-03-03 12:02:54 -0800889void icmpv6_cleanup(void)
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800890{
891 unregister_pernet_subsys(&icmpv6_sk_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
893}
894
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800895
Arjan van de Ven9b5b5cf2005-11-29 16:21:38 -0800896static const struct icmp6_err {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 int err;
898 int fatal;
899} tab_unreach[] = {
900 { /* NOROUTE */
901 .err = ENETUNREACH,
902 .fatal = 0,
903 },
904 { /* ADM_PROHIBITED */
905 .err = EACCES,
906 .fatal = 1,
907 },
908 { /* Was NOT_NEIGHBOUR, now reserved */
909 .err = EHOSTUNREACH,
910 .fatal = 0,
911 },
912 { /* ADDR_UNREACH */
913 .err = EHOSTUNREACH,
914 .fatal = 0,
915 },
916 { /* PORT_UNREACH */
917 .err = ECONNREFUSED,
918 .fatal = 1,
919 },
920};
921
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700922int icmpv6_err_convert(u8 type, u8 code, int *err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923{
924 int fatal = 0;
925
926 *err = EPROTO;
927
928 switch (type) {
929 case ICMPV6_DEST_UNREACH:
930 fatal = 1;
931 if (code <= ICMPV6_PORT_UNREACH) {
932 *err = tab_unreach[code].err;
933 fatal = tab_unreach[code].fatal;
934 }
935 break;
936
937 case ICMPV6_PKT_TOOBIG:
938 *err = EMSGSIZE;
939 break;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900940
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941 case ICMPV6_PARAMPROB:
942 *err = EPROTO;
943 fatal = 1;
944 break;
945
946 case ICMPV6_TIME_EXCEED:
947 *err = EHOSTUNREACH;
948 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700949 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950
951 return fatal;
952}
953
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900954EXPORT_SYMBOL(icmpv6_err_convert);
955
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956#ifdef CONFIG_SYSCTL
Daniel Lezcano760f2d02008-01-10 02:53:43 -0800957ctl_table ipv6_icmp_table_template[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 .procname = "ratelimit",
Daniel Lezcano41a76902008-01-10 03:02:40 -0800960 .data = &init_net.ipv6.sysctl.icmpv6_time,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961 .maxlen = sizeof(int),
962 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -0800963 .proc_handler = proc_dointvec_ms_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 },
Eric W. Biedermanf8572d82009-11-05 13:32:03 -0800965 { },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966};
Daniel Lezcano760f2d02008-01-10 02:53:43 -0800967
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +0000968struct ctl_table * __net_init ipv6_icmp_sysctl_init(struct net *net)
Daniel Lezcano760f2d02008-01-10 02:53:43 -0800969{
970 struct ctl_table *table;
971
972 table = kmemdup(ipv6_icmp_table_template,
973 sizeof(ipv6_icmp_table_template),
974 GFP_KERNEL);
YOSHIFUJI Hideaki5ee09102008-02-28 00:24:28 +0900975
976 if (table)
977 table[0].data = &net->ipv6.sysctl.icmpv6_time;
978
Daniel Lezcano760f2d02008-01-10 02:53:43 -0800979 return table;
980}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981#endif
982