blob: 4ae661bc3677b4efc9a5a205086f4922d8c6806e [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043
44#ifdef CONFIG_SYSCTL
45#include <linux/sysctl.h>
46#endif
47
48#include <linux/inet.h>
49#include <linux/netdevice.h>
50#include <linux/icmpv6.h>
51
52#include <net/ip.h>
53#include <net/sock.h>
54
55#include <net/ipv6.h>
56#include <net/ip6_checksum.h>
57#include <net/protocol.h>
58#include <net/raw.h>
59#include <net/rawv6.h>
60#include <net/transp_v6.h>
61#include <net/ip6_route.h>
62#include <net/addrconf.h>
63#include <net/icmp.h>
Herbert Xu8b7817f2007-12-12 10:44:43 -080064#include <net/xfrm.h>
Denis V. Lunev1ed85162008-04-03 14:31:03 -070065#include <net/inet_common.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
67#include <asm/uaccess.h>
68#include <asm/system.h>
69
Eric Dumazetba899662005-08-26 12:05:31 -070070DEFINE_SNMP_STAT(struct icmpv6_mib, icmpv6_statistics) __read_mostly;
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +090071EXPORT_SYMBOL(icmpv6_statistics);
David L Stevens14878f72007-09-16 16:52:35 -070072DEFINE_SNMP_STAT(struct icmpv6msg_mib, icmpv6msg_statistics) __read_mostly;
73EXPORT_SYMBOL(icmpv6msg_statistics);
Linus Torvalds1da177e2005-04-16 15:20:36 -070074
75/*
76 * The ICMP socket(s). This is the most convenient way to flow control
77 * our ICMP output as well as maintain a clean interface throughout
78 * all layers. All Socketless IP sends will soon be gone.
79 *
80 * On SMP we have one ICMP socket per-cpu.
81 */
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -080082static inline struct sock *icmpv6_sk(struct net *net)
83{
84 return net->ipv6.icmp_sk[smp_processor_id()];
85}
Linus Torvalds1da177e2005-04-16 15:20:36 -070086
Herbert Xue5bbef22007-10-15 12:50:28 -070087static int icmpv6_rcv(struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
Alexey Dobriyan41135cc2009-09-14 12:22:28 +000089static const struct inet6_protocol icmpv6_protocol = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 .handler = icmpv6_rcv,
Herbert Xu8b7817f2007-12-12 10:44:43 -080091 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
Linus Torvalds1da177e2005-04-16 15:20:36 -070092};
93
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -070094static __inline__ struct sock *icmpv6_xmit_lock(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -070095{
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -070096 struct sock *sk;
97
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 local_bh_disable();
99
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700100 sk = icmpv6_sk(net);
Denis V. Lunev405666d2008-02-29 11:16:46 -0800101 if (unlikely(!spin_trylock(&sk->sk_lock.slock))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 /* This can happen if the output path (f.e. SIT or
103 * ip6ip6 tunnel) signals dst_link_failure() for an
104 * outgoing ICMP6 packet.
105 */
106 local_bh_enable();
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700107 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 }
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700109 return sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110}
111
Denis V. Lunev405666d2008-02-29 11:16:46 -0800112static __inline__ void icmpv6_xmit_unlock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113{
Denis V. Lunev405666d2008-02-29 11:16:46 -0800114 spin_unlock_bh(&sk->sk_lock.slock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115}
116
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900117/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 * Slightly more convenient version of icmpv6_send.
119 */
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700120void icmpv6_param_prob(struct sk_buff *skb, u8 code, int pos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121{
122 icmpv6_send(skb, ICMPV6_PARAMPROB, code, pos, skb->dev);
123 kfree_skb(skb);
124}
125
126/*
127 * Figure out, may we reply to this packet with icmp error.
128 *
129 * We do not reply, if:
130 * - it was icmp error message.
131 * - it is truncated, so that it is known, that protocol is ICMPV6
132 * (i.e. in the middle of some exthdr)
133 *
134 * --ANK (980726)
135 */
136
137static int is_ineligible(struct sk_buff *skb)
138{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700139 int ptr = (u8 *)(ipv6_hdr(skb) + 1) - skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 int len = skb->len - ptr;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700141 __u8 nexthdr = ipv6_hdr(skb)->nexthdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142
143 if (len < 0)
144 return 1;
145
Herbert Xu0d3d0772005-04-24 20:16:19 -0700146 ptr = ipv6_skip_exthdr(skb, ptr, &nexthdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 if (ptr < 0)
148 return 0;
149 if (nexthdr == IPPROTO_ICMPV6) {
150 u8 _type, *tp;
151 tp = skb_header_pointer(skb,
152 ptr+offsetof(struct icmp6hdr, icmp6_type),
153 sizeof(_type), &_type);
154 if (tp == NULL ||
155 !(*tp & ICMPV6_INFOMSG_MASK))
156 return 1;
157 }
158 return 0;
159}
160
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900161/*
162 * Check the ICMP output rate limit
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 */
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700164static inline int icmpv6_xrlim_allow(struct sock *sk, u8 type,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 struct flowi *fl)
166{
167 struct dst_entry *dst;
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900168 struct net *net = sock_net(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 int res = 0;
170
171 /* Informational messages are not limited. */
172 if (type & ICMPV6_INFOMSG_MASK)
173 return 1;
174
175 /* Do not limit pmtu discovery, it would break it. */
176 if (type == ICMPV6_PKT_TOOBIG)
177 return 1;
178
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900179 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 * Look up the output route.
181 * XXX: perhaps the expire for routing entries cloned by
182 * this lookup should be more aggressive (not longer than timeout).
183 */
Benjamin Thery9a43b702008-03-05 10:49:18 -0800184 dst = ip6_route_output(net, sk, fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 if (dst->error) {
Denis V. Lunev3bd653c2008-10-08 10:54:51 -0700186 IP6_INC_STATS(net, ip6_dst_idev(dst),
YOSHIFUJI Hideakia11d2062006-11-04 20:11:37 +0900187 IPSTATS_MIB_OUTNOROUTES);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 } else if (dst->dev && (dst->dev->flags&IFF_LOOPBACK)) {
189 res = 1;
190 } else {
191 struct rt6_info *rt = (struct rt6_info *)dst;
Benjamin Thery9a43b702008-03-05 10:49:18 -0800192 int tmo = net->ipv6.sysctl.icmpv6_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193
194 /* Give more bandwidth to wider prefixes. */
195 if (rt->rt6i_dst.plen < 128)
196 tmo >>= ((128 - rt->rt6i_dst.plen)>>5);
197
198 res = xrlim_allow(dst, tmo);
199 }
200 dst_release(dst);
201 return res;
202}
203
204/*
205 * an inline helper for the "simple" if statement below
206 * checks if parameter problem report is caused by an
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900207 * unrecognized IPv6 option that has the Option Type
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 * highest-order two bits set to 10
209 */
210
211static __inline__ int opt_unrec(struct sk_buff *skb, __u32 offset)
212{
213 u8 _optval, *op;
214
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -0300215 offset += skb_network_offset(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 op = skb_header_pointer(skb, offset, sizeof(_optval), &_optval);
217 if (op == NULL)
218 return 1;
219 return (*op & 0xC0) == 0x80;
220}
221
222static int icmpv6_push_pending_frames(struct sock *sk, struct flowi *fl, struct icmp6hdr *thdr, int len)
223{
224 struct sk_buff *skb;
225 struct icmp6hdr *icmp6h;
226 int err = 0;
227
228 if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
229 goto out;
230
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300231 icmp6h = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 memcpy(icmp6h, thdr, sizeof(struct icmp6hdr));
233 icmp6h->icmp6_cksum = 0;
234
235 if (skb_queue_len(&sk->sk_write_queue) == 1) {
Joe Perches07f07572008-11-19 15:44:53 -0800236 skb->csum = csum_partial(icmp6h,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 sizeof(struct icmp6hdr), skb->csum);
238 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl->fl6_src,
239 &fl->fl6_dst,
240 len, fl->proto,
241 skb->csum);
242 } else {
Al Viro868c86b2006-11-14 21:35:48 -0800243 __wsum tmp_csum = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244
245 skb_queue_walk(&sk->sk_write_queue, skb) {
246 tmp_csum = csum_add(tmp_csum, skb->csum);
247 }
248
Joe Perches07f07572008-11-19 15:44:53 -0800249 tmp_csum = csum_partial(icmp6h,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 sizeof(struct icmp6hdr), tmp_csum);
Al Viro868c86b2006-11-14 21:35:48 -0800251 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl->fl6_src,
252 &fl->fl6_dst,
253 len, fl->proto,
254 tmp_csum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 ip6_push_pending_frames(sk);
257out:
258 return err;
259}
260
261struct icmpv6_msg {
262 struct sk_buff *skb;
263 int offset;
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800264 uint8_t type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265};
266
267static int icmpv6_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb)
268{
269 struct icmpv6_msg *msg = (struct icmpv6_msg *) from;
270 struct sk_buff *org_skb = msg->skb;
Al Viro5f92a732006-11-14 21:36:54 -0800271 __wsum csum = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
273 csum = skb_copy_and_csum_bits(org_skb, msg->offset + offset,
274 to, len, csum);
275 skb->csum = csum_block_add(skb->csum, csum, odd);
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800276 if (!(msg->type & ICMPV6_INFOMSG_MASK))
277 nf_ct_attach(skb, org_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 return 0;
279}
280
Masahide NAKAMURA59fbb3a62007-06-26 23:56:32 -0700281#if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700282static void mip6_addr_swap(struct sk_buff *skb)
283{
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700284 struct ipv6hdr *iph = ipv6_hdr(skb);
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700285 struct inet6_skb_parm *opt = IP6CB(skb);
286 struct ipv6_destopt_hao *hao;
287 struct in6_addr tmp;
288 int off;
289
290 if (opt->dsthao) {
291 off = ipv6_find_tlv(skb, opt->dsthao, IPV6_TLV_HAO);
292 if (likely(off >= 0)) {
Arnaldo Carvalho de Melod56f90a2007-04-10 20:50:43 -0700293 hao = (struct ipv6_destopt_hao *)
294 (skb_network_header(skb) + off);
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700295 ipv6_addr_copy(&tmp, &iph->saddr);
296 ipv6_addr_copy(&iph->saddr, &hao->addr);
297 ipv6_addr_copy(&hao->addr, &tmp);
298 }
299 }
300}
301#else
302static inline void mip6_addr_swap(struct sk_buff *skb) {}
303#endif
304
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305/*
306 * Send an ICMP message in response to a packet in error
307 */
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700308void icmpv6_send(struct sk_buff *skb, u8 type, u8 code, __u32 info,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 struct net_device *dev)
310{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900311 struct net *net = dev_net(skb->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 struct inet6_dev *idev = NULL;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700313 struct ipv6hdr *hdr = ipv6_hdr(skb);
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700314 struct sock *sk;
315 struct ipv6_pinfo *np;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 struct in6_addr *saddr = NULL;
317 struct dst_entry *dst;
Herbert Xu8b7817f2007-12-12 10:44:43 -0800318 struct dst_entry *dst2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 struct icmp6hdr tmp_hdr;
320 struct flowi fl;
Herbert Xu8b7817f2007-12-12 10:44:43 -0800321 struct flowi fl2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 struct icmpv6_msg msg;
323 int iif = 0;
324 int addr_type = 0;
325 int len;
Gerrit Renkere651f032009-08-09 08:12:48 +0000326 int hlimit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 int err = 0;
328
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700329 if ((u8 *)hdr < skb->head ||
330 (skb->network_header + sizeof(*hdr)) > skb->tail)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 return;
332
333 /*
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900334 * Make sure we respect the rules
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 * i.e. RFC 1885 2.4(e)
336 * Rule (e.1) is enforced by not using icmpv6_send
337 * in any code that processes icmp errors.
338 */
339 addr_type = ipv6_addr_type(&hdr->daddr);
340
Benjamin Thery9a43b702008-03-05 10:49:18 -0800341 if (ipv6_chk_addr(net, &hdr->daddr, skb->dev, 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 saddr = &hdr->daddr;
343
344 /*
345 * Dest addr check
346 */
347
348 if ((addr_type & IPV6_ADDR_MULTICAST || skb->pkt_type != PACKET_HOST)) {
349 if (type != ICMPV6_PKT_TOOBIG &&
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900350 !(type == ICMPV6_PARAMPROB &&
351 code == ICMPV6_UNK_OPTION &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 (opt_unrec(skb, info))))
353 return;
354
355 saddr = NULL;
356 }
357
358 addr_type = ipv6_addr_type(&hdr->saddr);
359
360 /*
361 * Source addr check
362 */
363
364 if (addr_type & IPV6_ADDR_LINKLOCAL)
365 iif = skb->dev->ifindex;
366
367 /*
YOSHIFUJI Hideaki8de33512005-12-21 22:57:06 +0900368 * Must not send error if the source does not uniquely
369 * identify a single node (RFC2463 Section 2.4).
370 * We check unspecified / multicast addresses here,
371 * and anycast addresses will be checked later.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 */
373 if ((addr_type == IPV6_ADDR_ANY) || (addr_type & IPV6_ADDR_MULTICAST)) {
Patrick McHardy64ce2072005-08-09 20:50:53 -0700374 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: addr_any/mcast source\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 return;
376 }
377
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900378 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 * Never answer to a ICMP packet.
380 */
381 if (is_ineligible(skb)) {
Patrick McHardy64ce2072005-08-09 20:50:53 -0700382 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: no reply to icmp error\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 return;
384 }
385
Masahide NAKAMURA79383232006-08-23 19:27:25 -0700386 mip6_addr_swap(skb);
387
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 memset(&fl, 0, sizeof(fl));
389 fl.proto = IPPROTO_ICMPV6;
390 ipv6_addr_copy(&fl.fl6_dst, &hdr->saddr);
391 if (saddr)
392 ipv6_addr_copy(&fl.fl6_src, saddr);
393 fl.oif = iif;
394 fl.fl_icmp_type = type;
395 fl.fl_icmp_code = code;
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -0700396 security_skb_classify_flow(skb, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700398 sk = icmpv6_xmit_lock(net);
399 if (sk == NULL)
Denis V. Lunev405666d2008-02-29 11:16:46 -0800400 return;
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700401 np = inet6_sk(sk);
Denis V. Lunev405666d2008-02-29 11:16:46 -0800402
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 if (!icmpv6_xrlim_allow(sk, type, &fl))
404 goto out;
405
406 tmp_hdr.icmp6_type = type;
407 tmp_hdr.icmp6_code = code;
408 tmp_hdr.icmp6_cksum = 0;
409 tmp_hdr.icmp6_pointer = htonl(info);
410
411 if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
412 fl.oif = np->mcast_oif;
413
414 err = ip6_dst_lookup(sk, &dst, &fl);
415 if (err)
416 goto out;
YOSHIFUJI Hideaki8de33512005-12-21 22:57:06 +0900417
418 /*
419 * We won't send icmp if the destination is known
420 * anycast.
421 */
422 if (((struct rt6_info *)dst)->rt6i_flags & RTF_ANYCAST) {
423 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: acast source\n");
424 goto out_dst_release;
425 }
426
Herbert Xu8b7817f2007-12-12 10:44:43 -0800427 /* No need to clone since we're just using its address. */
428 dst2 = dst;
429
Alexey Dobriyan52479b62008-11-25 17:35:18 -0800430 err = xfrm_lookup(net, &dst, &fl, sk, 0);
Herbert Xu8b7817f2007-12-12 10:44:43 -0800431 switch (err) {
432 case 0:
433 if (dst != dst2)
434 goto route_done;
435 break;
436 case -EPERM:
437 dst = NULL;
438 break;
439 default:
440 goto out;
441 }
442
443 if (xfrm_decode_session_reverse(skb, &fl2, AF_INET6))
Herbert Xuaf268182008-04-03 12:52:19 -0700444 goto relookup_failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445
Jiri Pirko6c06a472009-01-27 22:30:19 -0800446 if (ip6_dst_lookup(sk, &dst2, &fl2))
Herbert Xuaf268182008-04-03 12:52:19 -0700447 goto relookup_failed;
Herbert Xu8b7817f2007-12-12 10:44:43 -0800448
Jiri Pirko6c06a472009-01-27 22:30:19 -0800449 err = xfrm_lookup(net, &dst2, &fl2, sk, XFRM_LOOKUP_ICMP);
Herbert Xuaf268182008-04-03 12:52:19 -0700450 switch (err) {
451 case 0:
452 dst_release(dst);
453 dst = dst2;
454 break;
455 case -EPERM:
456 goto out_dst_release;
457 default:
458relookup_failed:
Herbert Xu8b7817f2007-12-12 10:44:43 -0800459 if (!dst)
460 goto out;
Herbert Xuaf268182008-04-03 12:52:19 -0700461 break;
Herbert Xu8b7817f2007-12-12 10:44:43 -0800462 }
463
Herbert Xu8b7817f2007-12-12 10:44:43 -0800464route_done:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 if (ipv6_addr_is_multicast(&fl.fl6_dst))
466 hlimit = np->mcast_hops;
467 else
468 hlimit = np->hop_limit;
469 if (hlimit < 0)
YOSHIFUJI Hideaki6b75d092008-03-10 06:00:30 -0400470 hlimit = ip6_dst_hoplimit(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471
472 msg.skb = skb;
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -0300473 msg.offset = skb_network_offset(skb);
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800474 msg.type = type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475
476 len = skb->len - msg.offset;
477 len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) -sizeof(struct icmp6hdr));
478 if (len < 0) {
Patrick McHardy64ce2072005-08-09 20:50:53 -0700479 LIMIT_NETDEBUG(KERN_DEBUG "icmp: len problem\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 goto out_dst_release;
481 }
482
483 idev = in6_dev_get(skb->dev);
484
485 err = ip6_append_data(sk, icmpv6_getfrag, &msg,
486 len + sizeof(struct icmp6hdr),
Gerrit Renkere651f032009-08-09 08:12:48 +0000487 sizeof(struct icmp6hdr), hlimit,
488 np->tclass, NULL, &fl, (struct rt6_info*)dst,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 MSG_DONTWAIT);
490 if (err) {
491 ip6_flush_pending_frames(sk);
492 goto out_put;
493 }
494 err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, len + sizeof(struct icmp6hdr));
495
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496out_put:
497 if (likely(idev != NULL))
498 in6_dev_put(idev);
499out_dst_release:
500 dst_release(dst);
501out:
Denis V. Lunev405666d2008-02-29 11:16:46 -0800502 icmpv6_xmit_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503}
504
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900505EXPORT_SYMBOL(icmpv6_send);
506
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507static void icmpv6_echo_reply(struct sk_buff *skb)
508{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900509 struct net *net = dev_net(skb->dev);
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700510 struct sock *sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 struct inet6_dev *idev;
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700512 struct ipv6_pinfo *np;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 struct in6_addr *saddr = NULL;
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300514 struct icmp6hdr *icmph = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 struct icmp6hdr tmp_hdr;
516 struct flowi fl;
517 struct icmpv6_msg msg;
518 struct dst_entry *dst;
519 int err = 0;
520 int hlimit;
521
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700522 saddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523
524 if (!ipv6_unicast_destination(skb))
525 saddr = NULL;
526
527 memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
528 tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;
529
530 memset(&fl, 0, sizeof(fl));
531 fl.proto = IPPROTO_ICMPV6;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700532 ipv6_addr_copy(&fl.fl6_dst, &ipv6_hdr(skb)->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 if (saddr)
534 ipv6_addr_copy(&fl.fl6_src, saddr);
535 fl.oif = skb->dev->ifindex;
536 fl.fl_icmp_type = ICMPV6_ECHO_REPLY;
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -0700537 security_skb_classify_flow(skb, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700539 sk = icmpv6_xmit_lock(net);
540 if (sk == NULL)
Denis V. Lunev405666d2008-02-29 11:16:46 -0800541 return;
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700542 np = inet6_sk(sk);
Denis V. Lunev405666d2008-02-29 11:16:46 -0800543
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
545 fl.oif = np->mcast_oif;
546
547 err = ip6_dst_lookup(sk, &dst, &fl);
548 if (err)
549 goto out;
Alexey Dobriyan52479b62008-11-25 17:35:18 -0800550 if ((err = xfrm_lookup(net, &dst, &fl, sk, 0)) < 0)
Patrick McHardye104411b2005-09-08 15:11:55 -0700551 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552
553 if (ipv6_addr_is_multicast(&fl.fl6_dst))
554 hlimit = np->mcast_hops;
555 else
556 hlimit = np->hop_limit;
557 if (hlimit < 0)
YOSHIFUJI Hideaki6b75d092008-03-10 06:00:30 -0400558 hlimit = ip6_dst_hoplimit(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559
560 idev = in6_dev_get(skb->dev);
561
562 msg.skb = skb;
563 msg.offset = 0;
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800564 msg.type = ICMPV6_ECHO_REPLY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565
566 err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
Gerrit Renkere651f032009-08-09 08:12:48 +0000567 sizeof(struct icmp6hdr), hlimit, np->tclass, NULL, &fl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 (struct rt6_info*)dst, MSG_DONTWAIT);
569
570 if (err) {
571 ip6_flush_pending_frames(sk);
572 goto out_put;
573 }
574 err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, skb->len + sizeof(struct icmp6hdr));
575
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900576out_put:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 if (likely(idev != NULL))
578 in6_dev_put(idev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 dst_release(dst);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900580out:
Denis V. Lunev405666d2008-02-29 11:16:46 -0800581 icmpv6_xmit_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582}
583
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700584static void icmpv6_notify(struct sk_buff *skb, u8 type, u8 code, __be32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585{
Alexey Dobriyan41135cc2009-09-14 12:22:28 +0000586 const struct inet6_protocol *ipprot;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 int inner_offset;
588 int hash;
589 u8 nexthdr;
590
591 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
592 return;
593
594 nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
595 if (ipv6_ext_hdr(nexthdr)) {
596 /* now skip over extension headers */
Herbert Xu0d3d0772005-04-24 20:16:19 -0700597 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr), &nexthdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 if (inner_offset<0)
599 return;
600 } else {
601 inner_offset = sizeof(struct ipv6hdr);
602 }
603
604 /* Checkin header including 8 bytes of inner protocol header. */
605 if (!pskb_may_pull(skb, inner_offset+8))
606 return;
607
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
609 Without this we will not able f.e. to make source routed
610 pmtu discovery.
611 Corresponding argument (opt) to notifiers is already added.
612 --ANK (980726)
613 */
614
615 hash = nexthdr & (MAX_INET_PROTOS - 1);
616
617 rcu_read_lock();
618 ipprot = rcu_dereference(inet6_protos[hash]);
619 if (ipprot && ipprot->err_handler)
620 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
621 rcu_read_unlock();
622
Pavel Emelyanov69d6da02007-11-19 22:35:57 -0800623 raw6_icmp_error(skb, nexthdr, type, code, inner_offset, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624}
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900625
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626/*
627 * Handle icmp messages
628 */
629
Herbert Xue5bbef22007-10-15 12:50:28 -0700630static int icmpv6_rcv(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 struct net_device *dev = skb->dev;
633 struct inet6_dev *idev = __in6_dev_get(dev);
634 struct in6_addr *saddr, *daddr;
635 struct ipv6hdr *orig_hdr;
636 struct icmp6hdr *hdr;
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700637 u8 type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638
Herbert Xuaebcf822007-12-12 18:54:16 -0800639 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -0700640 struct sec_path *sp = skb_sec_path(skb);
Herbert Xu8b7817f2007-12-12 10:44:43 -0800641 int nh;
642
Alexey Dobriyandef8b4f2008-10-28 13:24:06 -0700643 if (!(sp && sp->xvec[sp->len - 1]->props.flags &
Herbert Xuaebcf822007-12-12 18:54:16 -0800644 XFRM_STATE_ICMP))
645 goto drop_no_count;
646
Herbert Xu8b7817f2007-12-12 10:44:43 -0800647 if (!pskb_may_pull(skb, sizeof(*hdr) + sizeof(*orig_hdr)))
648 goto drop_no_count;
649
650 nh = skb_network_offset(skb);
651 skb_set_network_header(skb, sizeof(*hdr));
652
653 if (!xfrm6_policy_check_reverse(NULL, XFRM_POLICY_IN, skb))
654 goto drop_no_count;
655
656 skb_set_network_header(skb, nh);
657 }
658
Denis V. Luneve41b5362008-10-08 10:33:26 -0700659 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INMSGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700661 saddr = &ipv6_hdr(skb)->saddr;
662 daddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663
664 /* Perform checksum. */
Herbert Xufb286bb2005-11-10 13:01:24 -0800665 switch (skb->ip_summed) {
Patrick McHardy84fa7932006-08-29 16:44:56 -0700666 case CHECKSUM_COMPLETE:
Herbert Xufb286bb2005-11-10 13:01:24 -0800667 if (!csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
668 skb->csum))
669 break;
670 /* fall through */
671 case CHECKSUM_NONE:
Al Viro868c86b2006-11-14 21:35:48 -0800672 skb->csum = ~csum_unfold(csum_ipv6_magic(saddr, daddr, skb->len,
673 IPPROTO_ICMPV6, 0));
Herbert Xufb286bb2005-11-10 13:01:24 -0800674 if (__skb_checksum_complete(skb)) {
Harvey Harrison5b095d9892008-10-29 12:52:50 -0700675 LIMIT_NETDEBUG(KERN_DEBUG "ICMPv6 checksum failed [%pI6 > %pI6]\n",
Harvey Harrison0c6ce782008-10-28 16:09:23 -0700676 saddr, daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 goto discard_it;
678 }
679 }
680
Herbert Xu8cf22942008-02-05 03:15:50 -0800681 if (!pskb_pull(skb, sizeof(*hdr)))
682 goto discard_it;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300684 hdr = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685
686 type = hdr->icmp6_type;
687
Denis V. Lunev55d43802008-10-08 10:34:54 -0700688 ICMP6MSGIN_INC_STATS_BH(dev_net(dev), idev, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689
690 switch (type) {
691 case ICMPV6_ECHO_REQUEST:
692 icmpv6_echo_reply(skb);
693 break;
694
695 case ICMPV6_ECHO_REPLY:
696 /* we couldn't care less */
697 break;
698
699 case ICMPV6_PKT_TOOBIG:
700 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
701 standard destination cache. Seems, only "advanced"
702 destination cache will allow to solve this problem
703 --ANK (980726)
704 */
705 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
706 goto discard_it;
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300707 hdr = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 orig_hdr = (struct ipv6hdr *) (hdr + 1);
709 rt6_pmtu_discovery(&orig_hdr->daddr, &orig_hdr->saddr, dev,
710 ntohl(hdr->icmp6_mtu));
711
712 /*
713 * Drop through to notify
714 */
715
716 case ICMPV6_DEST_UNREACH:
717 case ICMPV6_TIME_EXCEED:
718 case ICMPV6_PARAMPROB:
719 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
720 break;
721
722 case NDISC_ROUTER_SOLICITATION:
723 case NDISC_ROUTER_ADVERTISEMENT:
724 case NDISC_NEIGHBOUR_SOLICITATION:
725 case NDISC_NEIGHBOUR_ADVERTISEMENT:
726 case NDISC_REDIRECT:
727 ndisc_rcv(skb);
728 break;
729
730 case ICMPV6_MGM_QUERY:
731 igmp6_event_query(skb);
732 break;
733
734 case ICMPV6_MGM_REPORT:
735 igmp6_event_report(skb);
736 break;
737
738 case ICMPV6_MGM_REDUCTION:
739 case ICMPV6_NI_QUERY:
740 case ICMPV6_NI_REPLY:
741 case ICMPV6_MLD2_REPORT:
742 case ICMPV6_DHAAD_REQUEST:
743 case ICMPV6_DHAAD_REPLY:
744 case ICMPV6_MOBILE_PREFIX_SOL:
745 case ICMPV6_MOBILE_PREFIX_ADV:
746 break;
747
748 default:
Patrick McHardy64ce2072005-08-09 20:50:53 -0700749 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6: msg of unknown type\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750
751 /* informational */
752 if (type & ICMPV6_INFOMSG_MASK)
753 break;
754
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900755 /*
756 * error of unknown type.
757 * must pass to upper level
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 */
759
760 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700761 }
762
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 kfree_skb(skb);
764 return 0;
765
766discard_it:
Denis V. Luneve41b5362008-10-08 10:33:26 -0700767 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INERRORS);
Herbert Xu8b7817f2007-12-12 10:44:43 -0800768drop_no_count:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 kfree_skb(skb);
770 return 0;
771}
772
YOSHIFUJI Hideaki95e41e92007-12-06 15:43:30 -0800773void icmpv6_flow_init(struct sock *sk, struct flowi *fl,
774 u8 type,
775 const struct in6_addr *saddr,
776 const struct in6_addr *daddr,
777 int oif)
778{
779 memset(fl, 0, sizeof(*fl));
780 ipv6_addr_copy(&fl->fl6_src, saddr);
781 ipv6_addr_copy(&fl->fl6_dst, daddr);
782 fl->proto = IPPROTO_ICMPV6;
783 fl->fl_icmp_type = type;
784 fl->fl_icmp_code = 0;
785 fl->oif = oif;
786 security_sk_classify_flow(sk, fl);
787}
788
Ingo Molnar640c41c2006-08-15 00:06:56 -0700789/*
Denis V. Lunevb7e729c2008-02-29 11:16:08 -0800790 * Special lock-class for __icmpv6_sk:
Ingo Molnar640c41c2006-08-15 00:06:56 -0700791 */
792static struct lock_class_key icmpv6_socket_sk_dst_lock_key;
793
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800794static int __net_init icmpv6_sk_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795{
796 struct sock *sk;
797 int err, i, j;
798
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800799 net->ipv6.icmp_sk =
800 kzalloc(nr_cpu_ids * sizeof(struct sock *), GFP_KERNEL);
801 if (net->ipv6.icmp_sk == NULL)
Denis V. Lunev79c91152008-02-29 11:17:11 -0800802 return -ENOMEM;
803
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -0700804 for_each_possible_cpu(i) {
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700805 err = inet_ctl_sock_create(&sk, PF_INET6,
806 SOCK_RAW, IPPROTO_ICMPV6, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 if (err < 0) {
808 printk(KERN_ERR
809 "Failed to initialize the ICMP6 control socket "
810 "(err %d).\n",
811 err);
812 goto fail;
813 }
814
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700815 net->ipv6.icmp_sk[i] = sk;
Denis V. Lunev5c8cafd2008-02-29 11:19:22 -0800816
Ingo Molnar640c41c2006-08-15 00:06:56 -0700817 /*
818 * Split off their lock-class, because sk->sk_dst_lock
819 * gets used from softirqs, which is safe for
Denis V. Lunevb7e729c2008-02-29 11:16:08 -0800820 * __icmpv6_sk (because those never get directly used
Ingo Molnar640c41c2006-08-15 00:06:56 -0700821 * via userspace syscalls), but unsafe for normal sockets.
822 */
823 lockdep_set_class(&sk->sk_dst_lock,
824 &icmpv6_socket_sk_dst_lock_key);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825
826 /* Enough space for 2 64K ICMP packets, including
827 * sk_buff struct overhead.
828 */
829 sk->sk_sndbuf =
830 (2 * ((64 * 1024) + sizeof(struct sk_buff)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 return 0;
833
834 fail:
Denis V. Lunev5c8cafd2008-02-29 11:19:22 -0800835 for (j = 0; j < i; j++)
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700836 inet_ctl_sock_destroy(net->ipv6.icmp_sk[j]);
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800837 kfree(net->ipv6.icmp_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 return err;
839}
840
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800841static void __net_exit icmpv6_sk_exit(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842{
843 int i;
844
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -0700845 for_each_possible_cpu(i) {
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700846 inet_ctl_sock_destroy(net->ipv6.icmp_sk[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 }
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800848 kfree(net->ipv6.icmp_sk);
849}
850
Alexey Dobriyan8ed7edc2008-03-03 12:02:54 -0800851static struct pernet_operations icmpv6_sk_ops = {
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800852 .init = icmpv6_sk_init,
853 .exit = icmpv6_sk_exit,
854};
855
856int __init icmpv6_init(void)
857{
858 int err;
859
860 err = register_pernet_subsys(&icmpv6_sk_ops);
861 if (err < 0)
862 return err;
863
864 err = -EAGAIN;
865 if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0)
866 goto fail;
867 return 0;
868
869fail:
870 printk(KERN_ERR "Failed to register ICMP6 protocol\n");
871 unregister_pernet_subsys(&icmpv6_sk_ops);
872 return err;
873}
874
Alexey Dobriyan8ed7edc2008-03-03 12:02:54 -0800875void icmpv6_cleanup(void)
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800876{
877 unregister_pernet_subsys(&icmpv6_sk_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
879}
880
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800881
Arjan van de Ven9b5b5cf2005-11-29 16:21:38 -0800882static const struct icmp6_err {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 int err;
884 int fatal;
885} tab_unreach[] = {
886 { /* NOROUTE */
887 .err = ENETUNREACH,
888 .fatal = 0,
889 },
890 { /* ADM_PROHIBITED */
891 .err = EACCES,
892 .fatal = 1,
893 },
894 { /* Was NOT_NEIGHBOUR, now reserved */
895 .err = EHOSTUNREACH,
896 .fatal = 0,
897 },
898 { /* ADDR_UNREACH */
899 .err = EHOSTUNREACH,
900 .fatal = 0,
901 },
902 { /* PORT_UNREACH */
903 .err = ECONNREFUSED,
904 .fatal = 1,
905 },
906};
907
Brian Haleyd5fdd6b2009-06-23 04:31:07 -0700908int icmpv6_err_convert(u8 type, u8 code, int *err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909{
910 int fatal = 0;
911
912 *err = EPROTO;
913
914 switch (type) {
915 case ICMPV6_DEST_UNREACH:
916 fatal = 1;
917 if (code <= ICMPV6_PORT_UNREACH) {
918 *err = tab_unreach[code].err;
919 fatal = tab_unreach[code].fatal;
920 }
921 break;
922
923 case ICMPV6_PKT_TOOBIG:
924 *err = EMSGSIZE;
925 break;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900926
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 case ICMPV6_PARAMPROB:
928 *err = EPROTO;
929 fatal = 1;
930 break;
931
932 case ICMPV6_TIME_EXCEED:
933 *err = EHOSTUNREACH;
934 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700935 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936
937 return fatal;
938}
939
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900940EXPORT_SYMBOL(icmpv6_err_convert);
941
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942#ifdef CONFIG_SYSCTL
Daniel Lezcano760f2d02008-01-10 02:53:43 -0800943ctl_table ipv6_icmp_table_template[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 .procname = "ratelimit",
Daniel Lezcano41a76902008-01-10 03:02:40 -0800946 .data = &init_net.ipv6.sysctl.icmpv6_time,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 .maxlen = sizeof(int),
948 .mode = 0644,
Alexey Dobriyan6d9f2392008-11-03 18:21:05 -0800949 .proc_handler = proc_dointvec_ms_jiffies,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 },
Eric W. Biedermanf8572d82009-11-05 13:32:03 -0800951 { },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952};
Daniel Lezcano760f2d02008-01-10 02:53:43 -0800953
954struct ctl_table *ipv6_icmp_sysctl_init(struct net *net)
955{
956 struct ctl_table *table;
957
958 table = kmemdup(ipv6_icmp_table_template,
959 sizeof(ipv6_icmp_table_template),
960 GFP_KERNEL);
YOSHIFUJI Hideaki5ee09102008-02-28 00:24:28 +0900961
962 if (table)
963 table[0].data = &net->ipv6.sysctl.icmpv6_time;
964
Daniel Lezcano760f2d02008-01-10 02:53:43 -0800965 return table;
966}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967#endif
968