blob: 01d46bff63c312b7804c8132d6860a1a749eb043 [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;
Jesse Gross75f28112011-11-30 17:05:51 -0800138 __be16 frag_off;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139
140 if (len < 0)
141 return 1;
142
Jesse Gross75f28112011-11-30 17:05:51 -0800143 ptr = ipv6_skip_exthdr(skb, ptr, &nexthdr, &frag_off);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 if (ptr < 0)
145 return 0;
146 if (nexthdr == IPPROTO_ICMPV6) {
147 u8 _type, *tp;
148 tp = skb_header_pointer(skb,
149 ptr+offsetof(struct icmp6hdr, icmp6_type),
150 sizeof(_type), &_type);
151 if (tp == NULL ||
152 !(*tp & ICMPV6_INFOMSG_MASK))
153 return 1;
154 }
155 return 0;
156}
157
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900158/*
159 * Check the ICMP output rate limit
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 */
David S. Miller92d86822011-02-04 15:55:25 -0800161static inline bool icmpv6_xrlim_allow(struct sock *sk, u8 type,
David S. Miller4c9483b2011-03-12 16:22:43 -0500162 struct flowi6 *fl6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163{
164 struct dst_entry *dst;
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900165 struct net *net = sock_net(sk);
David S. Miller92d86822011-02-04 15:55:25 -0800166 bool res = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167
168 /* Informational messages are not limited. */
169 if (type & ICMPV6_INFOMSG_MASK)
David S. Miller92d86822011-02-04 15:55:25 -0800170 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171
172 /* Do not limit pmtu discovery, it would break it. */
173 if (type == ICMPV6_PKT_TOOBIG)
David S. Miller92d86822011-02-04 15:55:25 -0800174 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900176 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 * Look up the output route.
178 * XXX: perhaps the expire for routing entries cloned by
179 * this lookup should be more aggressive (not longer than timeout).
180 */
David S. Miller4c9483b2011-03-12 16:22:43 -0500181 dst = ip6_route_output(net, sk, fl6);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 if (dst->error) {
Denis V. Lunev3bd653c2008-10-08 10:54:51 -0700183 IP6_INC_STATS(net, ip6_dst_idev(dst),
YOSHIFUJI Hideakia11d2062006-11-04 20:11:37 +0900184 IPSTATS_MIB_OUTNOROUTES);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 } else if (dst->dev && (dst->dev->flags&IFF_LOOPBACK)) {
David S. Miller92d86822011-02-04 15:55:25 -0800186 res = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 } else {
188 struct rt6_info *rt = (struct rt6_info *)dst;
Benjamin Thery9a43b702008-03-05 10:49:18 -0800189 int tmo = net->ipv6.sysctl.icmpv6_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190
191 /* Give more bandwidth to wider prefixes. */
192 if (rt->rt6i_dst.plen < 128)
193 tmo >>= ((128 - rt->rt6i_dst.plen)>>5);
194
David S. Miller92d86822011-02-04 15:55:25 -0800195 if (!rt->rt6i_peer)
196 rt6_bind_peer(rt, 1);
197 res = inet_peer_xrlim_allow(rt->rt6i_peer, tmo);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 }
199 dst_release(dst);
200 return res;
201}
202
203/*
204 * an inline helper for the "simple" if statement below
205 * checks if parameter problem report is caused by an
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900206 * unrecognized IPv6 option that has the Option Type
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 * highest-order two bits set to 10
208 */
209
210static __inline__ int opt_unrec(struct sk_buff *skb, __u32 offset)
211{
212 u8 _optval, *op;
213
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -0300214 offset += skb_network_offset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 op = skb_header_pointer(skb, offset, sizeof(_optval), &_optval);
216 if (op == NULL)
217 return 1;
218 return (*op & 0xC0) == 0x80;
219}
220
David S. Miller4c9483b2011-03-12 16:22:43 -0500221static int icmpv6_push_pending_frames(struct sock *sk, struct flowi6 *fl6, struct icmp6hdr *thdr, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222{
223 struct sk_buff *skb;
224 struct icmp6hdr *icmp6h;
225 int err = 0;
226
227 if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
228 goto out;
229
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300230 icmp6h = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 memcpy(icmp6h, thdr, sizeof(struct icmp6hdr));
232 icmp6h->icmp6_cksum = 0;
233
234 if (skb_queue_len(&sk->sk_write_queue) == 1) {
Joe Perches07f07572008-11-19 15:44:53 -0800235 skb->csum = csum_partial(icmp6h,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 sizeof(struct icmp6hdr), skb->csum);
David S. Miller4c9483b2011-03-12 16:22:43 -0500237 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
238 &fl6->daddr,
239 len, fl6->flowi6_proto,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 skb->csum);
241 } else {
Al Viro868c86b2006-11-14 21:35:48 -0800242 __wsum tmp_csum = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
244 skb_queue_walk(&sk->sk_write_queue, skb) {
245 tmp_csum = csum_add(tmp_csum, skb->csum);
246 }
247
Joe Perches07f07572008-11-19 15:44:53 -0800248 tmp_csum = csum_partial(icmp6h,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 sizeof(struct icmp6hdr), tmp_csum);
David S. Miller4c9483b2011-03-12 16:22:43 -0500250 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
251 &fl6->daddr,
252 len, fl6->flowi6_proto,
Al Viro868c86b2006-11-14 21:35:48 -0800253 tmp_csum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 ip6_push_pending_frames(sk);
256out:
257 return err;
258}
259
260struct icmpv6_msg {
261 struct sk_buff *skb;
262 int offset;
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800263 uint8_t type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264};
265
266static int icmpv6_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb)
267{
268 struct icmpv6_msg *msg = (struct icmpv6_msg *) from;
269 struct sk_buff *org_skb = msg->skb;
Al Viro5f92a732006-11-14 21:36:54 -0800270 __wsum csum = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271
272 csum = skb_copy_and_csum_bits(org_skb, msg->offset + offset,
273 to, len, csum);
274 skb->csum = csum_block_add(skb->csum, csum, odd);
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800275 if (!(msg->type & ICMPV6_INFOMSG_MASK))
276 nf_ct_attach(skb, org_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 return 0;
278}
279
Masahide NAKAMURA59fbb3a62007-06-26 23:56:32 -0700280#if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700281static void mip6_addr_swap(struct sk_buff *skb)
282{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700283 struct ipv6hdr *iph = ipv6_hdr(skb);
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700284 struct inet6_skb_parm *opt = IP6CB(skb);
285 struct ipv6_destopt_hao *hao;
286 struct in6_addr tmp;
287 int off;
288
289 if (opt->dsthao) {
290 off = ipv6_find_tlv(skb, opt->dsthao, IPV6_TLV_HAO);
291 if (likely(off >= 0)) {
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700292 hao = (struct ipv6_destopt_hao *)
293 (skb_network_header(skb) + off);
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000294 tmp = iph->saddr;
295 iph->saddr = hao->addr;
296 hao->addr = tmp;
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700297 }
298 }
299}
300#else
301static inline void mip6_addr_swap(struct sk_buff *skb) {}
302#endif
303
David S. Millerb42835d2011-03-01 22:06:22 -0800304static struct dst_entry *icmpv6_route_lookup(struct net *net, struct sk_buff *skb,
David S. Miller4c9483b2011-03-12 16:22:43 -0500305 struct sock *sk, struct flowi6 *fl6)
David S. Millerb42835d2011-03-01 22:06:22 -0800306{
307 struct dst_entry *dst, *dst2;
David S. Miller4c9483b2011-03-12 16:22:43 -0500308 struct flowi6 fl2;
David S. Millerb42835d2011-03-01 22:06:22 -0800309 int err;
310
David S. Miller4c9483b2011-03-12 16:22:43 -0500311 err = ip6_dst_lookup(sk, &dst, fl6);
David S. Millerb42835d2011-03-01 22:06:22 -0800312 if (err)
313 return ERR_PTR(err);
314
315 /*
316 * We won't send icmp if the destination is known
317 * anycast.
318 */
319 if (((struct rt6_info *)dst)->rt6i_flags & RTF_ANYCAST) {
320 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: acast source\n");
321 dst_release(dst);
322 return ERR_PTR(-EINVAL);
323 }
324
325 /* No need to clone since we're just using its address. */
326 dst2 = dst;
327
David S. Miller4c9483b2011-03-12 16:22:43 -0500328 dst = xfrm_lookup(net, dst, flowi6_to_flowi(fl6), sk, 0);
David S. Miller452edd52011-03-02 13:27:41 -0800329 if (!IS_ERR(dst)) {
David S. Millerb42835d2011-03-01 22:06:22 -0800330 if (dst != dst2)
331 return dst;
David S. Miller452edd52011-03-02 13:27:41 -0800332 } else {
333 if (PTR_ERR(dst) == -EPERM)
334 dst = NULL;
335 else
336 return dst;
David S. Millerb42835d2011-03-01 22:06:22 -0800337 }
338
David S. Miller4c9483b2011-03-12 16:22:43 -0500339 err = xfrm_decode_session_reverse(skb, flowi6_to_flowi(&fl2), AF_INET6);
David S. Millerb42835d2011-03-01 22:06:22 -0800340 if (err)
341 goto relookup_failed;
342
343 err = ip6_dst_lookup(sk, &dst2, &fl2);
344 if (err)
345 goto relookup_failed;
346
David S. Miller4c9483b2011-03-12 16:22:43 -0500347 dst2 = xfrm_lookup(net, dst2, flowi6_to_flowi(&fl2), sk, XFRM_LOOKUP_ICMP);
David S. Miller452edd52011-03-02 13:27:41 -0800348 if (!IS_ERR(dst2)) {
David S. Millerb42835d2011-03-01 22:06:22 -0800349 dst_release(dst);
350 dst = dst2;
David S. Miller452edd52011-03-02 13:27:41 -0800351 } else {
352 err = PTR_ERR(dst2);
353 if (err == -EPERM) {
354 dst_release(dst);
355 return dst2;
356 } else
357 goto relookup_failed;
David S. Millerb42835d2011-03-01 22:06:22 -0800358 }
359
360relookup_failed:
361 if (dst)
362 return dst;
363 return ERR_PTR(err);
364}
365
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366/*
367 * Send an ICMP message in response to a packet in error
368 */
Alexey Dobriyan3ffe5332010-02-18 08:25:24 +0000369void icmpv6_send(struct sk_buff *skb, u8 type, u8 code, __u32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900371 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 struct inet6_dev *idev = NULL;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700373 struct ipv6hdr *hdr = ipv6_hdr(skb);
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700374 struct sock *sk;
375 struct ipv6_pinfo *np;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000376 const struct in6_addr *saddr = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 struct dst_entry *dst;
378 struct icmp6hdr tmp_hdr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500379 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 struct icmpv6_msg msg;
381 int iif = 0;
382 int addr_type = 0;
383 int len;
Gerrit Renkere651f032009-08-09 08:12:48 +0000384 int hlimit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 int err = 0;
386
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700387 if ((u8 *)hdr < skb->head ||
388 (skb->network_header + sizeof(*hdr)) > skb->tail)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 return;
390
391 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900392 * Make sure we respect the rules
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 * i.e. RFC 1885 2.4(e)
394 * Rule (e.1) is enforced by not using icmpv6_send
395 * in any code that processes icmp errors.
396 */
397 addr_type = ipv6_addr_type(&hdr->daddr);
398
Benjamin Thery9a43b702008-03-05 10:49:18 -0800399 if (ipv6_chk_addr(net, &hdr->daddr, skb->dev, 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 saddr = &hdr->daddr;
401
402 /*
403 * Dest addr check
404 */
405
406 if ((addr_type & IPV6_ADDR_MULTICAST || skb->pkt_type != PACKET_HOST)) {
407 if (type != ICMPV6_PKT_TOOBIG &&
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900408 !(type == ICMPV6_PARAMPROB &&
409 code == ICMPV6_UNK_OPTION &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 (opt_unrec(skb, info))))
411 return;
412
413 saddr = NULL;
414 }
415
416 addr_type = ipv6_addr_type(&hdr->saddr);
417
418 /*
419 * Source addr check
420 */
421
422 if (addr_type & IPV6_ADDR_LINKLOCAL)
423 iif = skb->dev->ifindex;
424
425 /*
YOSHIFUJI Hideaki8de33512005-12-21 22:57:06 +0900426 * Must not send error if the source does not uniquely
427 * identify a single node (RFC2463 Section 2.4).
428 * We check unspecified / multicast addresses here,
429 * and anycast addresses will be checked later.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 */
431 if ((addr_type == IPV6_ADDR_ANY) || (addr_type & IPV6_ADDR_MULTICAST)) {
Patrick McHardy64ce2072005-08-09 20:50:53 -0700432 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: addr_any/mcast source\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 return;
434 }
435
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900436 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 * Never answer to a ICMP packet.
438 */
439 if (is_ineligible(skb)) {
Patrick McHardy64ce2072005-08-09 20:50:53 -0700440 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: no reply to icmp error\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 return;
442 }
443
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700444 mip6_addr_swap(skb);
445
David S. Miller4c9483b2011-03-12 16:22:43 -0500446 memset(&fl6, 0, sizeof(fl6));
447 fl6.flowi6_proto = IPPROTO_ICMPV6;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000448 fl6.daddr = hdr->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 if (saddr)
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000450 fl6.saddr = *saddr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500451 fl6.flowi6_oif = iif;
David S. Miller1958b852011-03-12 16:36:19 -0500452 fl6.fl6_icmp_type = type;
453 fl6.fl6_icmp_code = code;
David S. Miller4c9483b2011-03-12 16:22:43 -0500454 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700456 sk = icmpv6_xmit_lock(net);
457 if (sk == NULL)
Denis V. Lunev405666d2008-02-29 11:16:46 -0800458 return;
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700459 np = inet6_sk(sk);
Denis V. Lunev405666d2008-02-29 11:16:46 -0800460
David S. Miller4c9483b2011-03-12 16:22:43 -0500461 if (!icmpv6_xrlim_allow(sk, type, &fl6))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 goto out;
463
464 tmp_hdr.icmp6_type = type;
465 tmp_hdr.icmp6_code = code;
466 tmp_hdr.icmp6_cksum = 0;
467 tmp_hdr.icmp6_pointer = htonl(info);
468
David S. Miller4c9483b2011-03-12 16:22:43 -0500469 if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
470 fl6.flowi6_oif = np->mcast_oif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471
David S. Miller4c9483b2011-03-12 16:22:43 -0500472 dst = icmpv6_route_lookup(net, skb, sk, &fl6);
David S. Millerb42835d2011-03-01 22:06:22 -0800473 if (IS_ERR(dst))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 goto out;
YOSHIFUJI Hideaki8de33512005-12-21 22:57:06 +0900475
David S. Miller4c9483b2011-03-12 16:22:43 -0500476 if (ipv6_addr_is_multicast(&fl6.daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 hlimit = np->mcast_hops;
478 else
479 hlimit = np->hop_limit;
480 if (hlimit < 0)
YOSHIFUJI Hideaki6b75d092008-03-10 06:00:30 -0400481 hlimit = ip6_dst_hoplimit(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482
483 msg.skb = skb;
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -0300484 msg.offset = skb_network_offset(skb);
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800485 msg.type = type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486
487 len = skb->len - msg.offset;
488 len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) -sizeof(struct icmp6hdr));
489 if (len < 0) {
Patrick McHardy64ce2072005-08-09 20:50:53 -0700490 LIMIT_NETDEBUG(KERN_DEBUG "icmp: len problem\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 goto out_dst_release;
492 }
493
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000494 rcu_read_lock();
495 idev = __in6_dev_get(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496
497 err = ip6_append_data(sk, icmpv6_getfrag, &msg,
498 len + sizeof(struct icmp6hdr),
Gerrit Renkere651f032009-08-09 08:12:48 +0000499 sizeof(struct icmp6hdr), hlimit,
David S. Miller4c9483b2011-03-12 16:22:43 -0500500 np->tclass, NULL, &fl6, (struct rt6_info*)dst,
Brian Haley13b52cd2010-04-23 11:26:08 +0000501 MSG_DONTWAIT, np->dontfrag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 if (err) {
Eric Dumazet00d9d6a2010-06-07 22:24:44 +0000503 ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 ip6_flush_pending_frames(sk);
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000505 } else {
506 err = icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
507 len + sizeof(struct icmp6hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 }
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000509 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510out_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}
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900515EXPORT_SYMBOL(icmpv6_send);
516
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517static void icmpv6_echo_reply(struct sk_buff *skb)
518{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900519 struct net *net = dev_net(skb->dev);
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700520 struct sock *sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 struct inet6_dev *idev;
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700522 struct ipv6_pinfo *np;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000523 const struct in6_addr *saddr = NULL;
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300524 struct icmp6hdr *icmph = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 struct icmp6hdr tmp_hdr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500526 struct flowi6 fl6;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 struct icmpv6_msg msg;
528 struct dst_entry *dst;
529 int err = 0;
530 int hlimit;
531
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700532 saddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533
534 if (!ipv6_unicast_destination(skb))
535 saddr = NULL;
536
537 memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
538 tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;
539
David S. Miller4c9483b2011-03-12 16:22:43 -0500540 memset(&fl6, 0, sizeof(fl6));
541 fl6.flowi6_proto = IPPROTO_ICMPV6;
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000542 fl6.daddr = ipv6_hdr(skb)->saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 if (saddr)
Alexey Dobriyan4e3fd7a2011-11-21 03:39:03 +0000544 fl6.saddr = *saddr;
David S. Miller4c9483b2011-03-12 16:22:43 -0500545 fl6.flowi6_oif = skb->dev->ifindex;
David S. Miller1958b852011-03-12 16:36:19 -0500546 fl6.fl6_icmp_type = ICMPV6_ECHO_REPLY;
David S. Miller4c9483b2011-03-12 16:22:43 -0500547 security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700549 sk = icmpv6_xmit_lock(net);
550 if (sk == NULL)
Denis V. Lunev405666d2008-02-29 11:16:46 -0800551 return;
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700552 np = inet6_sk(sk);
Denis V. Lunev405666d2008-02-29 11:16:46 -0800553
David S. Miller4c9483b2011-03-12 16:22:43 -0500554 if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
555 fl6.flowi6_oif = np->mcast_oif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556
David S. Miller4c9483b2011-03-12 16:22:43 -0500557 err = ip6_dst_lookup(sk, &dst, &fl6);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 if (err)
559 goto out;
David S. Miller4c9483b2011-03-12 16:22:43 -0500560 dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), sk, 0);
David S. Miller452edd52011-03-02 13:27:41 -0800561 if (IS_ERR(dst))
Patrick McHardye104411b2005-09-08 15:11:55 -0700562 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563
David S. Miller4c9483b2011-03-12 16:22:43 -0500564 if (ipv6_addr_is_multicast(&fl6.daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 hlimit = np->mcast_hops;
566 else
567 hlimit = np->hop_limit;
568 if (hlimit < 0)
YOSHIFUJI Hideaki6b75d092008-03-10 06:00:30 -0400569 hlimit = ip6_dst_hoplimit(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000571 idev = __in6_dev_get(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572
573 msg.skb = skb;
574 msg.offset = 0;
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800575 msg.type = ICMPV6_ECHO_REPLY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576
577 err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
David S. Miller4c9483b2011-03-12 16:22:43 -0500578 sizeof(struct icmp6hdr), hlimit, np->tclass, NULL, &fl6,
Brian Haley13b52cd2010-04-23 11:26:08 +0000579 (struct rt6_info*)dst, MSG_DONTWAIT,
580 np->dontfrag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581
582 if (err) {
Eric Dumazet00d9d6a2010-06-07 22:24:44 +0000583 ICMP6_INC_STATS_BH(net, idev, ICMP6_MIB_OUTERRORS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 ip6_flush_pending_frames(sk);
Eric Dumazetcfdf7642011-07-27 21:13:03 +0000585 } else {
586 err = icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
587 skb->len + sizeof(struct icmp6hdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 dst_release(dst);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900590out:
Denis V. Lunev405666d2008-02-29 11:16:46 -0800591 icmpv6_xmit_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592}
593
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700594static void icmpv6_notify(struct sk_buff *skb, u8 type, u8 code, __be32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595{
Alexey Dobriyan41135cc2009-09-14 12:22:28 +0000596 const struct inet6_protocol *ipprot;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 int inner_offset;
598 int hash;
599 u8 nexthdr;
Jesse Gross75f28112011-11-30 17:05:51 -0800600 __be16 frag_off;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601
602 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
603 return;
604
605 nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
606 if (ipv6_ext_hdr(nexthdr)) {
607 /* now skip over extension headers */
Jesse Gross75f28112011-11-30 17:05:51 -0800608 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr),
609 &nexthdr, &frag_off);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 if (inner_offset<0)
611 return;
612 } else {
613 inner_offset = sizeof(struct ipv6hdr);
614 }
615
616 /* Checkin header including 8 bytes of inner protocol header. */
617 if (!pskb_may_pull(skb, inner_offset+8))
618 return;
619
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
621 Without this we will not able f.e. to make source routed
622 pmtu discovery.
623 Corresponding argument (opt) to notifiers is already added.
624 --ANK (980726)
625 */
626
627 hash = nexthdr & (MAX_INET_PROTOS - 1);
628
629 rcu_read_lock();
630 ipprot = rcu_dereference(inet6_protos[hash]);
631 if (ipprot && ipprot->err_handler)
632 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
633 rcu_read_unlock();
634
Pavel Emelyanov69d6da02007-11-19 22:35:57 -0800635 raw6_icmp_error(skb, nexthdr, type, code, inner_offset, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636}
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900637
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638/*
639 * Handle icmp messages
640 */
641
Herbert Xue5bbef22007-10-15 12:50:28 -0700642static int icmpv6_rcv(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 struct net_device *dev = skb->dev;
645 struct inet6_dev *idev = __in6_dev_get(dev);
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000646 const struct in6_addr *saddr, *daddr;
647 const struct ipv6hdr *orig_hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 struct icmp6hdr *hdr;
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700649 u8 type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650
Herbert Xuaebcf822007-12-12 18:54:16 -0800651 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -0700652 struct sec_path *sp = skb_sec_path(skb);
Herbert Xu8b7817f2007-12-12 10:44:43 -0800653 int nh;
654
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -0700655 if (!(sp && sp->xvec[sp->len - 1]->props.flags &
Herbert Xuaebcf822007-12-12 18:54:16 -0800656 XFRM_STATE_ICMP))
657 goto drop_no_count;
658
Herbert Xu8b7817f2007-12-12 10:44:43 -0800659 if (!pskb_may_pull(skb, sizeof(*hdr) + sizeof(*orig_hdr)))
660 goto drop_no_count;
661
662 nh = skb_network_offset(skb);
663 skb_set_network_header(skb, sizeof(*hdr));
664
665 if (!xfrm6_policy_check_reverse(NULL, XFRM_POLICY_IN, skb))
666 goto drop_no_count;
667
668 skb_set_network_header(skb, nh);
669 }
670
Denis V. Luneve41b5362008-10-08 10:33:26 -0700671 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INMSGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700673 saddr = &ipv6_hdr(skb)->saddr;
674 daddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675
676 /* Perform checksum. */
Herbert Xufb286bb2005-11-10 13:01:24 -0800677 switch (skb->ip_summed) {
Patrick McHardy84fa7932006-08-29 16:44:56 -0700678 case CHECKSUM_COMPLETE:
Herbert Xufb286bb2005-11-10 13:01:24 -0800679 if (!csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
680 skb->csum))
681 break;
682 /* fall through */
683 case CHECKSUM_NONE:
Al Viro868c86b2006-11-14 21:35:48 -0800684 skb->csum = ~csum_unfold(csum_ipv6_magic(saddr, daddr, skb->len,
685 IPPROTO_ICMPV6, 0));
Herbert Xufb286bb2005-11-10 13:01:24 -0800686 if (__skb_checksum_complete(skb)) {
Harvey Harrison5b095d9892008-10-29 12:52:50 -0700687 LIMIT_NETDEBUG(KERN_DEBUG "ICMPv6 checksum failed [%pI6 > %pI6]\n",
Harvey Harrison0c6ce782008-10-28 16:09:23 -0700688 saddr, daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 goto discard_it;
690 }
691 }
692
Herbert Xu8cf22942008-02-05 03:15:50 -0800693 if (!pskb_pull(skb, sizeof(*hdr)))
694 goto discard_it;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300696 hdr = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697
698 type = hdr->icmp6_type;
699
Denis V. Lunev55d43802008-10-08 10:34:54 -0700700 ICMP6MSGIN_INC_STATS_BH(dev_net(dev), idev, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701
702 switch (type) {
703 case ICMPV6_ECHO_REQUEST:
704 icmpv6_echo_reply(skb);
705 break;
706
707 case ICMPV6_ECHO_REPLY:
708 /* we couldn't care less */
709 break;
710
711 case ICMPV6_PKT_TOOBIG:
712 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
713 standard destination cache. Seems, only "advanced"
714 destination cache will allow to solve this problem
715 --ANK (980726)
716 */
717 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
718 goto discard_it;
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300719 hdr = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 orig_hdr = (struct ipv6hdr *) (hdr + 1);
721 rt6_pmtu_discovery(&orig_hdr->daddr, &orig_hdr->saddr, dev,
722 ntohl(hdr->icmp6_mtu));
723
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) {
820 printk(KERN_ERR
821 "Failed to initialize the ICMP6 control socket "
822 "(err %d).\n",
823 err);
824 goto fail;
825 }
826
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700827 net->ipv6.icmp_sk[i] = sk;
Denis V. Lunev5c8cafd2008-02-29 11:19:22 -0800828
Ingo Molnar640c41c2006-08-15 00:06:56 -0700829 /*
830 * Split off their lock-class, because sk->sk_dst_lock
831 * gets used from softirqs, which is safe for
Denis V. Lunevb7e729c2008-02-29 11:16:08 -0800832 * __icmpv6_sk (because those never get directly used
Ingo Molnar640c41c2006-08-15 00:06:56 -0700833 * via userspace syscalls), but unsafe for normal sockets.
834 */
835 lockdep_set_class(&sk->sk_dst_lock,
836 &icmpv6_socket_sk_dst_lock_key);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837
838 /* Enough space for 2 64K ICMP packets, including
839 * sk_buff struct overhead.
840 */
Eric Dumazet87fb4b72011-10-13 07:28:54 +0000841 sk->sk_sndbuf = 2 * SKB_TRUESIZE(64 * 1024);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 return 0;
844
845 fail:
Denis V. Lunev5c8cafd2008-02-29 11:19:22 -0800846 for (j = 0; j < i; j++)
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700847 inet_ctl_sock_destroy(net->ipv6.icmp_sk[j]);
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800848 kfree(net->ipv6.icmp_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 return err;
850}
851
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800852static void __net_exit icmpv6_sk_exit(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853{
854 int i;
855
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -0700856 for_each_possible_cpu(i) {
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700857 inet_ctl_sock_destroy(net->ipv6.icmp_sk[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 }
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800859 kfree(net->ipv6.icmp_sk);
860}
861
Alexey Dobriyan8ed7edc2008-03-03 12:02:54 -0800862static struct pernet_operations icmpv6_sk_ops = {
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800863 .init = icmpv6_sk_init,
864 .exit = icmpv6_sk_exit,
865};
866
867int __init icmpv6_init(void)
868{
869 int err;
870
871 err = register_pernet_subsys(&icmpv6_sk_ops);
872 if (err < 0)
873 return err;
874
875 err = -EAGAIN;
876 if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0)
877 goto fail;
878 return 0;
879
880fail:
881 printk(KERN_ERR "Failed to register ICMP6 protocol\n");
882 unregister_pernet_subsys(&icmpv6_sk_ops);
883 return err;
884}
885
Alexey Dobriyan8ed7edc2008-03-03 12:02:54 -0800886void icmpv6_cleanup(void)
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800887{
888 unregister_pernet_subsys(&icmpv6_sk_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
890}
891
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800892
Arjan van de Ven9b5b5cf2005-11-29 16:21:38 -0800893static const struct icmp6_err {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 int err;
895 int fatal;
896} tab_unreach[] = {
897 { /* NOROUTE */
898 .err = ENETUNREACH,
899 .fatal = 0,
900 },
901 { /* ADM_PROHIBITED */
902 .err = EACCES,
903 .fatal = 1,
904 },
905 { /* Was NOT_NEIGHBOUR, now reserved */
906 .err = EHOSTUNREACH,
907 .fatal = 0,
908 },
909 { /* ADDR_UNREACH */
910 .err = EHOSTUNREACH,
911 .fatal = 0,
912 },
913 { /* PORT_UNREACH */
914 .err = ECONNREFUSED,
915 .fatal = 1,
916 },
917};
918
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700919int icmpv6_err_convert(u8 type, u8 code, int *err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920{
921 int fatal = 0;
922
923 *err = EPROTO;
924
925 switch (type) {
926 case ICMPV6_DEST_UNREACH:
927 fatal = 1;
928 if (code <= ICMPV6_PORT_UNREACH) {
929 *err = tab_unreach[code].err;
930 fatal = tab_unreach[code].fatal;
931 }
932 break;
933
934 case ICMPV6_PKT_TOOBIG:
935 *err = EMSGSIZE;
936 break;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900937
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 case ICMPV6_PARAMPROB:
939 *err = EPROTO;
940 fatal = 1;
941 break;
942
943 case ICMPV6_TIME_EXCEED:
944 *err = EHOSTUNREACH;
945 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700946 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947
948 return fatal;
949}
950
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900951EXPORT_SYMBOL(icmpv6_err_convert);
952
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953#ifdef CONFIG_SYSCTL
Daniel Lezcano760f2d02008-01-10 02:53:43 -0800954ctl_table ipv6_icmp_table_template[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 .procname = "ratelimit",
Daniel Lezcano41a76902008-01-10 03:02:40 -0800957 .data = &init_net.ipv6.sysctl.icmpv6_time,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 .maxlen = sizeof(int),
959 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -0800960 .proc_handler = proc_dointvec_ms_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961 },
Eric W. Biedermanf8572d82009-11-05 13:32:03 -0800962 { },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963};
Daniel Lezcano760f2d02008-01-10 02:53:43 -0800964
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +0000965struct ctl_table * __net_init ipv6_icmp_sysctl_init(struct net *net)
Daniel Lezcano760f2d02008-01-10 02:53:43 -0800966{
967 struct ctl_table *table;
968
969 table = kmemdup(ipv6_icmp_table_template,
970 sizeof(ipv6_icmp_table_template),
971 GFP_KERNEL);
YOSHIFUJI Hideaki5ee09102008-02-28 00:24:28 +0900972
973 if (table)
974 table[0].data = &net->ipv6.sysctl.icmpv6_time;
975
Daniel Lezcano760f2d02008-01-10 02:53:43 -0800976 return table;
977}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978#endif
979