blob: 83cb4f9add81b433eedaa89aef58b8056cf1fccc [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>
69#include <asm/system.h>
70
Linus Torvalds1da177e2005-04-16 15:20:36 -070071/*
72 * The ICMP socket(s). This is the most convenient way to flow control
73 * our ICMP output as well as maintain a clean interface throughout
74 * all layers. All Socketless IP sends will soon be gone.
75 *
76 * On SMP we have one ICMP socket per-cpu.
77 */
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -080078static inline struct sock *icmpv6_sk(struct net *net)
79{
80 return net->ipv6.icmp_sk[smp_processor_id()];
81}
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
Herbert Xue5bbef22007-10-15 12:50:28 -070083static int icmpv6_rcv(struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070084
Alexey Dobriyan41135cc2009-09-14 12:22:28 +000085static const struct inet6_protocol icmpv6_protocol = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 .handler = icmpv6_rcv,
Herbert Xu8b7817f2007-12-12 10:44:43 -080087 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
Linus Torvalds1da177e2005-04-16 15:20:36 -070088};
89
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -070090static __inline__ struct sock *icmpv6_xmit_lock(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -070091{
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -070092 struct sock *sk;
93
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 local_bh_disable();
95
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -070096 sk = icmpv6_sk(net);
Denis V. Lunev405666d2008-02-29 11:16:46 -080097 if (unlikely(!spin_trylock(&sk->sk_lock.slock))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 /* This can happen if the output path (f.e. SIT or
99 * ip6ip6 tunnel) signals dst_link_failure() for an
100 * outgoing ICMP6 packet.
101 */
102 local_bh_enable();
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700103 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 }
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700105 return sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106}
107
Denis V. Lunev405666d2008-02-29 11:16:46 -0800108static __inline__ void icmpv6_xmit_unlock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109{
Denis V. Lunev405666d2008-02-29 11:16:46 -0800110 spin_unlock_bh(&sk->sk_lock.slock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111}
112
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900113/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 * Slightly more convenient version of icmpv6_send.
115 */
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700116void icmpv6_param_prob(struct sk_buff *skb, u8 code, int pos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117{
Alexey Dobriyan3ffe5332010-02-18 08:25:24 +0000118 icmpv6_send(skb, ICMPV6_PARAMPROB, code, pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 kfree_skb(skb);
120}
121
122/*
123 * Figure out, may we reply to this packet with icmp error.
124 *
125 * We do not reply, if:
126 * - it was icmp error message.
127 * - it is truncated, so that it is known, that protocol is ICMPV6
128 * (i.e. in the middle of some exthdr)
129 *
130 * --ANK (980726)
131 */
132
133static int is_ineligible(struct sk_buff *skb)
134{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700135 int ptr = (u8 *)(ipv6_hdr(skb) + 1) - skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 int len = skb->len - ptr;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700137 __u8 nexthdr = ipv6_hdr(skb)->nexthdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138
139 if (len < 0)
140 return 1;
141
Herbert Xu0d3d0772005-04-24 20:16:19 -0700142 ptr = ipv6_skip_exthdr(skb, ptr, &nexthdr);
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 NAKAMURA59fbb3a62007-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);
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700293 ipv6_addr_copy(&tmp, &iph->saddr);
294 ipv6_addr_copy(&iph->saddr, &hao->addr);
295 ipv6_addr_copy(&hao->addr, &tmp);
296 }
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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 struct in6_addr *saddr = NULL;
376 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;
447 ipv6_addr_copy(&fl6.daddr, &hdr->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 if (saddr)
David S. Miller4c9483b2011-03-12 16:22:43 -0500449 ipv6_addr_copy(&fl6.saddr, saddr);
450 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470
David S. Miller4c9483b2011-03-12 16:22:43 -0500471 dst = icmpv6_route_lookup(net, skb, sk, &fl6);
David S. Millerb42835d2011-03-01 22:06:22 -0800472 if (IS_ERR(dst))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 goto out;
YOSHIFUJI Hideaki8de33512005-12-21 22:57:06 +0900474
David S. Miller4c9483b2011-03-12 16:22:43 -0500475 if (ipv6_addr_is_multicast(&fl6.daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 hlimit = np->mcast_hops;
477 else
478 hlimit = np->hop_limit;
479 if (hlimit < 0)
YOSHIFUJI Hideaki6b75d092008-03-10 06:00:30 -0400480 hlimit = ip6_dst_hoplimit(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481
482 msg.skb = skb;
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -0300483 msg.offset = skb_network_offset(skb);
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800484 msg.type = type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485
486 len = skb->len - msg.offset;
487 len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) -sizeof(struct icmp6hdr));
488 if (len < 0) {
Patrick McHardy64ce2072005-08-09 20:50:53 -0700489 LIMIT_NETDEBUG(KERN_DEBUG "icmp: len problem\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 goto out_dst_release;
491 }
492
493 idev = in6_dev_get(skb->dev);
494
495 err = ip6_append_data(sk, icmpv6_getfrag, &msg,
496 len + sizeof(struct icmp6hdr),
Gerrit Renkere651f032009-08-09 08:12:48 +0000497 sizeof(struct icmp6hdr), hlimit,
David S. Miller4c9483b2011-03-12 16:22:43 -0500498 np->tclass, NULL, &fl6, (struct rt6_info*)dst,
Brian Haley13b52cd2010-04-23 11:26:08 +0000499 MSG_DONTWAIT, np->dontfrag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 if (err) {
Eric Dumazet00d9d6a2010-06-07 22:24:44 +0000501 ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 ip6_flush_pending_frames(sk);
503 goto out_put;
504 }
David S. Miller4c9483b2011-03-12 16:22:43 -0500505 err = icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr, len + sizeof(struct icmp6hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507out_put:
508 if (likely(idev != NULL))
509 in6_dev_put(idev);
510out_dst_release:
511 dst_release(dst);
512out:
Denis V. Lunev405666d2008-02-29 11:16:46 -0800513 icmpv6_xmit_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514}
515
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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 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;
543 ipv6_addr_copy(&fl6.daddr, &ipv6_hdr(skb)->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 if (saddr)
David S. Miller4c9483b2011-03-12 16:22:43 -0500545 ipv6_addr_copy(&fl6.saddr, saddr);
546 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557
David S. Miller4c9483b2011-03-12 16:22:43 -0500558 err = ip6_dst_lookup(sk, &dst, &fl6);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 if (err)
560 goto out;
David S. Miller4c9483b2011-03-12 16:22:43 -0500561 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), sk, 0);
David S. Miller452edd52011-03-02 13:27:41 -0800562 if (IS_ERR(dst))
Patrick McHardye104411b2005-09-08 15:11:55 -0700563 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564
David S. Miller4c9483b2011-03-12 16:22:43 -0500565 if (ipv6_addr_is_multicast(&fl6.daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 hlimit = np->mcast_hops;
567 else
568 hlimit = np->hop_limit;
569 if (hlimit < 0)
YOSHIFUJI Hideaki6b75d092008-03-10 06:00:30 -0400570 hlimit = ip6_dst_hoplimit(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571
572 idev = in6_dev_get(skb->dev);
573
574 msg.skb = skb;
575 msg.offset = 0;
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800576 msg.type = ICMPV6_ECHO_REPLY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577
578 err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
David S. Miller4c9483b2011-03-12 16:22:43 -0500579 sizeof(struct icmp6hdr), hlimit, np->tclass, NULL, &fl6,
Brian Haley13b52cd2010-04-23 11:26:08 +0000580 (struct rt6_info*)dst, MSG_DONTWAIT,
581 np->dontfrag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582
583 if (err) {
Eric Dumazet00d9d6a2010-06-07 22:24:44 +0000584 ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 ip6_flush_pending_frames(sk);
586 goto out_put;
587 }
David S. Miller4c9483b2011-03-12 16:22:43 -0500588 err = icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr, skb->len + sizeof(struct icmp6hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900590out_put:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 if (likely(idev != NULL))
592 in6_dev_put(idev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 dst_release(dst);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900594out:
Denis V. Lunev405666d2008-02-29 11:16:46 -0800595 icmpv6_xmit_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596}
597
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700598static void icmpv6_notify(struct sk_buff *skb, u8 type, u8 code, __be32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599{
Alexey Dobriyan41135cc2009-09-14 12:22:28 +0000600 const struct inet6_protocol *ipprot;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 int inner_offset;
602 int hash;
603 u8 nexthdr;
604
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 */
Herbert Xu0d3d0772005-04-24 20:16:19 -0700611 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr), &nexthdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 if (inner_offset<0)
613 return;
614 } else {
615 inner_offset = sizeof(struct ipv6hdr);
616 }
617
618 /* Checkin header including 8 bytes of inner protocol header. */
619 if (!pskb_may_pull(skb, inner_offset+8))
620 return;
621
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
623 Without this we will not able f.e. to make source routed
624 pmtu discovery.
625 Corresponding argument (opt) to notifiers is already added.
626 --ANK (980726)
627 */
628
629 hash = nexthdr & (MAX_INET_PROTOS - 1);
630
631 rcu_read_lock();
632 ipprot = rcu_dereference(inet6_protos[hash]);
633 if (ipprot && ipprot->err_handler)
634 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
635 rcu_read_unlock();
636
Pavel Emelyanov69d6da02007-11-19 22:35:57 -0800637 raw6_icmp_error(skb, nexthdr, type, code, inner_offset, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638}
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900639
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640/*
641 * Handle icmp messages
642 */
643
Herbert Xue5bbef22007-10-15 12:50:28 -0700644static int icmpv6_rcv(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 struct net_device *dev = skb->dev;
647 struct inet6_dev *idev = __in6_dev_get(dev);
648 struct in6_addr *saddr, *daddr;
649 struct ipv6hdr *orig_hdr;
650 struct icmp6hdr *hdr;
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700651 u8 type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652
Herbert Xuaebcf822007-12-12 18:54:16 -0800653 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -0700654 struct sec_path *sp = skb_sec_path(skb);
Herbert Xu8b7817f2007-12-12 10:44:43 -0800655 int nh;
656
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -0700657 if (!(sp && sp->xvec[sp->len - 1]->props.flags &
Herbert Xuaebcf822007-12-12 18:54:16 -0800658 XFRM_STATE_ICMP))
659 goto drop_no_count;
660
Herbert Xu8b7817f2007-12-12 10:44:43 -0800661 if (!pskb_may_pull(skb, sizeof(*hdr) + sizeof(*orig_hdr)))
662 goto drop_no_count;
663
664 nh = skb_network_offset(skb);
665 skb_set_network_header(skb, sizeof(*hdr));
666
667 if (!xfrm6_policy_check_reverse(NULL, XFRM_POLICY_IN, skb))
668 goto drop_no_count;
669
670 skb_set_network_header(skb, nh);
671 }
672
Denis V. Luneve41b5362008-10-08 10:33:26 -0700673 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INMSGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700675 saddr = &ipv6_hdr(skb)->saddr;
676 daddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677
678 /* Perform checksum. */
Herbert Xufb286bb2005-11-10 13:01:24 -0800679 switch (skb->ip_summed) {
Patrick McHardy84fa7932006-08-29 16:44:56 -0700680 case CHECKSUM_COMPLETE:
Herbert Xufb286bb2005-11-10 13:01:24 -0800681 if (!csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
682 skb->csum))
683 break;
684 /* fall through */
685 case CHECKSUM_NONE:
Al Viro868c86b2006-11-14 21:35:48 -0800686 skb->csum = ~csum_unfold(csum_ipv6_magic(saddr, daddr, skb->len,
687 IPPROTO_ICMPV6, 0));
Herbert Xufb286bb2005-11-10 13:01:24 -0800688 if (__skb_checksum_complete(skb)) {
Harvey Harrison5b095d9892008-10-29 12:52:50 -0700689 LIMIT_NETDEBUG(KERN_DEBUG "ICMPv6 checksum failed [%pI6 > %pI6]\n",
Harvey Harrison0c6ce782008-10-28 16:09:23 -0700690 saddr, daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 goto discard_it;
692 }
693 }
694
Herbert Xu8cf22942008-02-05 03:15:50 -0800695 if (!pskb_pull(skb, sizeof(*hdr)))
696 goto discard_it;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300698 hdr = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699
700 type = hdr->icmp6_type;
701
Denis V. Lunev55d43802008-10-08 10:34:54 -0700702 ICMP6MSGIN_INC_STATS_BH(dev_net(dev), idev, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703
704 switch (type) {
705 case ICMPV6_ECHO_REQUEST:
706 icmpv6_echo_reply(skb);
707 break;
708
709 case ICMPV6_ECHO_REPLY:
710 /* we couldn't care less */
711 break;
712
713 case ICMPV6_PKT_TOOBIG:
714 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
715 standard destination cache. Seems, only "advanced"
716 destination cache will allow to solve this problem
717 --ANK (980726)
718 */
719 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
720 goto discard_it;
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300721 hdr = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 orig_hdr = (struct ipv6hdr *) (hdr + 1);
723 rt6_pmtu_discovery(&orig_hdr->daddr, &orig_hdr->saddr, dev,
724 ntohl(hdr->icmp6_mtu));
725
726 /*
727 * Drop through to notify
728 */
729
730 case ICMPV6_DEST_UNREACH:
731 case ICMPV6_TIME_EXCEED:
732 case ICMPV6_PARAMPROB:
733 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
734 break;
735
736 case NDISC_ROUTER_SOLICITATION:
737 case NDISC_ROUTER_ADVERTISEMENT:
738 case NDISC_NEIGHBOUR_SOLICITATION:
739 case NDISC_NEIGHBOUR_ADVERTISEMENT:
740 case NDISC_REDIRECT:
741 ndisc_rcv(skb);
742 break;
743
744 case ICMPV6_MGM_QUERY:
745 igmp6_event_query(skb);
746 break;
747
748 case ICMPV6_MGM_REPORT:
749 igmp6_event_report(skb);
750 break;
751
752 case ICMPV6_MGM_REDUCTION:
753 case ICMPV6_NI_QUERY:
754 case ICMPV6_NI_REPLY:
755 case ICMPV6_MLD2_REPORT:
756 case ICMPV6_DHAAD_REQUEST:
757 case ICMPV6_DHAAD_REPLY:
758 case ICMPV6_MOBILE_PREFIX_SOL:
759 case ICMPV6_MOBILE_PREFIX_ADV:
760 break;
761
762 default:
Patrick McHardy64ce2072005-08-09 20:50:53 -0700763 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6: msg of unknown type\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764
765 /* informational */
766 if (type & ICMPV6_INFOMSG_MASK)
767 break;
768
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900769 /*
770 * error of unknown type.
771 * must pass to upper level
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 */
773
774 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700775 }
776
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 kfree_skb(skb);
778 return 0;
779
780discard_it:
Denis V. Luneve41b5362008-10-08 10:33:26 -0700781 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INERRORS);
Herbert Xu8b7817f2007-12-12 10:44:43 -0800782drop_no_count:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 kfree_skb(skb);
784 return 0;
785}
786
David S. Miller4c9483b2011-03-12 16:22:43 -0500787void icmpv6_flow_init(struct sock *sk, struct flowi6 *fl6,
YOSHIFUJI Hideaki95e41e92007-12-06 15:43:30 -0800788 u8 type,
789 const struct in6_addr *saddr,
790 const struct in6_addr *daddr,
791 int oif)
792{
David S. Miller4c9483b2011-03-12 16:22:43 -0500793 memset(fl6, 0, sizeof(*fl6));
794 ipv6_addr_copy(&fl6->saddr, saddr);
795 ipv6_addr_copy(&fl6->daddr, daddr);
796 fl6->flowi6_proto = IPPROTO_ICMPV6;
David S. Miller1958b852011-03-12 16:36:19 -0500797 fl6->fl6_icmp_type = type;
798 fl6->fl6_icmp_code = 0;
David S. Miller4c9483b2011-03-12 16:22:43 -0500799 fl6->flowi6_oif = oif;
800 security_sk_classify_flow(sk, flowi6_to_flowi(fl6));
YOSHIFUJI Hideaki95e41e92007-12-06 15:43:30 -0800801}
802
Ingo Molnar640c41c2006-08-15 00:06:56 -0700803/*
Denis V. Lunevb7e729c2008-02-29 11:16:08 -0800804 * Special lock-class for __icmpv6_sk:
Ingo Molnar640c41c2006-08-15 00:06:56 -0700805 */
806static struct lock_class_key icmpv6_socket_sk_dst_lock_key;
807
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800808static int __net_init icmpv6_sk_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809{
810 struct sock *sk;
811 int err, i, j;
812
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800813 net->ipv6.icmp_sk =
814 kzalloc(nr_cpu_ids * sizeof(struct sock *), GFP_KERNEL);
815 if (net->ipv6.icmp_sk == NULL)
Denis V. Lunev79c91152008-02-29 11:17:11 -0800816 return -ENOMEM;
817
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -0700818 for_each_possible_cpu(i) {
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700819 err = inet_ctl_sock_create(&sk, PF_INET6,
820 SOCK_RAW, IPPROTO_ICMPV6, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 if (err < 0) {
822 printk(KERN_ERR
823 "Failed to initialize the ICMP6 control socket "
824 "(err %d).\n",
825 err);
826 goto fail;
827 }
828
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700829 net->ipv6.icmp_sk[i] = sk;
Denis V. Lunev5c8cafd2008-02-29 11:19:22 -0800830
Ingo Molnar640c41c2006-08-15 00:06:56 -0700831 /*
832 * Split off their lock-class, because sk->sk_dst_lock
833 * gets used from softirqs, which is safe for
Denis V. Lunevb7e729c2008-02-29 11:16:08 -0800834 * __icmpv6_sk (because those never get directly used
Ingo Molnar640c41c2006-08-15 00:06:56 -0700835 * via userspace syscalls), but unsafe for normal sockets.
836 */
837 lockdep_set_class(&sk->sk_dst_lock,
838 &icmpv6_socket_sk_dst_lock_key);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839
840 /* Enough space for 2 64K ICMP packets, including
841 * sk_buff struct overhead.
842 */
843 sk->sk_sndbuf =
844 (2 * ((64 * 1024) + sizeof(struct sk_buff)));
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