blob: 9b7d19ae5ced5c7aa50dc5e48b98d7d7007c8770 [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
89static struct inet6_protocol icmpv6_protocol = {
90 .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 */
120void icmpv6_param_prob(struct sk_buff *skb, int code, int pos)
121{
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 */
164static inline int icmpv6_xrlim_allow(struct sock *sk, int type,
165 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) {
236 skb->csum = csum_partial((char *)icmp6h,
237 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
249 tmp_csum = csum_partial((char *)icmp6h,
250 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 */
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900308void icmpv6_send(struct sk_buff *skb, int type, int 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;
YOSHIFUJI Hideaki41a1f8e2005-09-08 10:19:03 +0900326 int hlimit, tclass;
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
430 err = xfrm_lookup(&dst, &fl, sk, 0);
431 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
Herbert Xu8b7817f2007-12-12 10:44:43 -0800446 if (ip6_dst_lookup(sk, &dst2, &fl))
Herbert Xuaf268182008-04-03 12:52:19 -0700447 goto relookup_failed;
Herbert Xu8b7817f2007-12-12 10:44:43 -0800448
449 err = xfrm_lookup(&dst2, &fl, 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
YOSHIFUJI Hideakie012d512006-09-13 20:01:28 -0700472 tclass = np->tclass;
YOSHIFUJI Hideaki41a1f8e2005-09-08 10:19:03 +0900473 if (tclass < 0)
474 tclass = 0;
475
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 msg.skb = skb;
Arnaldo Carvalho de Melobbe735e2007-03-10 22:16:10 -0300477 msg.offset = skb_network_offset(skb);
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800478 msg.type = type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479
480 len = skb->len - msg.offset;
481 len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) -sizeof(struct icmp6hdr));
482 if (len < 0) {
Patrick McHardy64ce2072005-08-09 20:50:53 -0700483 LIMIT_NETDEBUG(KERN_DEBUG "icmp: len problem\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 goto out_dst_release;
485 }
486
487 idev = in6_dev_get(skb->dev);
488
489 err = ip6_append_data(sk, icmpv6_getfrag, &msg,
490 len + sizeof(struct icmp6hdr),
491 sizeof(struct icmp6hdr),
YOSHIFUJI Hideaki41a1f8e2005-09-08 10:19:03 +0900492 hlimit, tclass, NULL, &fl, (struct rt6_info*)dst,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 MSG_DONTWAIT);
494 if (err) {
495 ip6_flush_pending_frames(sk);
496 goto out_put;
497 }
498 err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, len + sizeof(struct icmp6hdr));
499
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500out_put:
501 if (likely(idev != NULL))
502 in6_dev_put(idev);
503out_dst_release:
504 dst_release(dst);
505out:
Denis V. Lunev405666d2008-02-29 11:16:46 -0800506 icmpv6_xmit_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507}
508
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900509EXPORT_SYMBOL(icmpv6_send);
510
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511static void icmpv6_echo_reply(struct sk_buff *skb)
512{
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900513 struct net *net = dev_net(skb->dev);
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700514 struct sock *sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 struct inet6_dev *idev;
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700516 struct ipv6_pinfo *np;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 struct in6_addr *saddr = NULL;
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300518 struct icmp6hdr *icmph = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 struct icmp6hdr tmp_hdr;
520 struct flowi fl;
521 struct icmpv6_msg msg;
522 struct dst_entry *dst;
523 int err = 0;
524 int hlimit;
YOSHIFUJI Hideaki41a1f8e2005-09-08 10:19:03 +0900525 int tclass;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700527 saddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528
529 if (!ipv6_unicast_destination(skb))
530 saddr = NULL;
531
532 memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
533 tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;
534
535 memset(&fl, 0, sizeof(fl));
536 fl.proto = IPPROTO_ICMPV6;
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700537 ipv6_addr_copy(&fl.fl6_dst, &ipv6_hdr(skb)->saddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 if (saddr)
539 ipv6_addr_copy(&fl.fl6_src, saddr);
540 fl.oif = skb->dev->ifindex;
541 fl.fl_icmp_type = ICMPV6_ECHO_REPLY;
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -0700542 security_skb_classify_flow(skb, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700544 sk = icmpv6_xmit_lock(net);
545 if (sk == NULL)
Denis V. Lunev405666d2008-02-29 11:16:46 -0800546 return;
Denis V. Lunevfdc0bde2008-08-23 04:43:33 -0700547 np = inet6_sk(sk);
Denis V. Lunev405666d2008-02-29 11:16:46 -0800548
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
550 fl.oif = np->mcast_oif;
551
552 err = ip6_dst_lookup(sk, &dst, &fl);
553 if (err)
554 goto out;
555 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
Patrick McHardye104411b2005-09-08 15:11:55 -0700556 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557
558 if (ipv6_addr_is_multicast(&fl.fl6_dst))
559 hlimit = np->mcast_hops;
560 else
561 hlimit = np->hop_limit;
562 if (hlimit < 0)
YOSHIFUJI Hideaki6b75d092008-03-10 06:00:30 -0400563 hlimit = ip6_dst_hoplimit(dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564
YOSHIFUJI Hideakie012d512006-09-13 20:01:28 -0700565 tclass = np->tclass;
YOSHIFUJI Hideaki41a1f8e2005-09-08 10:19:03 +0900566 if (tclass < 0)
567 tclass = 0;
568
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 idev = in6_dev_get(skb->dev);
570
571 msg.skb = skb;
572 msg.offset = 0;
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800573 msg.type = ICMPV6_ECHO_REPLY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574
575 err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
YOSHIFUJI Hideaki41a1f8e2005-09-08 10:19:03 +0900576 sizeof(struct icmp6hdr), hlimit, tclass, NULL, &fl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 (struct rt6_info*)dst, MSG_DONTWAIT);
578
579 if (err) {
580 ip6_flush_pending_frames(sk);
581 goto out_put;
582 }
583 err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, skb->len + sizeof(struct icmp6hdr));
584
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900585out_put:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 if (likely(idev != NULL))
587 in6_dev_put(idev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 dst_release(dst);
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900589out:
Denis V. Lunev405666d2008-02-29 11:16:46 -0800590 icmpv6_xmit_unlock(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591}
592
Al Viro04ce6902006-11-08 00:21:01 -0800593static void icmpv6_notify(struct sk_buff *skb, int type, int code, __be32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 struct inet6_protocol *ipprot;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 int inner_offset;
597 int hash;
598 u8 nexthdr;
599
600 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
601 return;
602
603 nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
604 if (ipv6_ext_hdr(nexthdr)) {
605 /* now skip over extension headers */
Herbert Xu0d3d0772005-04-24 20:16:19 -0700606 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr), &nexthdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 if (inner_offset<0)
608 return;
609 } else {
610 inner_offset = sizeof(struct ipv6hdr);
611 }
612
613 /* Checkin header including 8 bytes of inner protocol header. */
614 if (!pskb_may_pull(skb, inner_offset+8))
615 return;
616
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
618 Without this we will not able f.e. to make source routed
619 pmtu discovery.
620 Corresponding argument (opt) to notifiers is already added.
621 --ANK (980726)
622 */
623
624 hash = nexthdr & (MAX_INET_PROTOS - 1);
625
626 rcu_read_lock();
627 ipprot = rcu_dereference(inet6_protos[hash]);
628 if (ipprot && ipprot->err_handler)
629 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
630 rcu_read_unlock();
631
Pavel Emelyanov69d6da02007-11-19 22:35:57 -0800632 raw6_icmp_error(skb, nexthdr, type, code, inner_offset, info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633}
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900634
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635/*
636 * Handle icmp messages
637 */
638
Herbert Xue5bbef22007-10-15 12:50:28 -0700639static int icmpv6_rcv(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 struct net_device *dev = skb->dev;
642 struct inet6_dev *idev = __in6_dev_get(dev);
643 struct in6_addr *saddr, *daddr;
644 struct ipv6hdr *orig_hdr;
645 struct icmp6hdr *hdr;
646 int type;
647
Herbert Xuaebcf822007-12-12 18:54:16 -0800648 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
Herbert Xu8b7817f2007-12-12 10:44:43 -0800649 int nh;
650
Herbert Xuaebcf822007-12-12 18:54:16 -0800651 if (!(skb->sp && skb->sp->xvec[skb->sp->len - 1]->props.flags &
652 XFRM_STATE_ICMP))
653 goto drop_no_count;
654
Herbert Xu8b7817f2007-12-12 10:44:43 -0800655 if (!pskb_may_pull(skb, sizeof(*hdr) + sizeof(*orig_hdr)))
656 goto drop_no_count;
657
658 nh = skb_network_offset(skb);
659 skb_set_network_header(skb, sizeof(*hdr));
660
661 if (!xfrm6_policy_check_reverse(NULL, XFRM_POLICY_IN, skb))
662 goto drop_no_count;
663
664 skb_set_network_header(skb, nh);
665 }
666
Denis V. Luneve41b5362008-10-08 10:33:26 -0700667 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INMSGS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700669 saddr = &ipv6_hdr(skb)->saddr;
670 daddr = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671
672 /* Perform checksum. */
Herbert Xufb286bb2005-11-10 13:01:24 -0800673 switch (skb->ip_summed) {
Patrick McHardy84fa7932006-08-29 16:44:56 -0700674 case CHECKSUM_COMPLETE:
Herbert Xufb286bb2005-11-10 13:01:24 -0800675 if (!csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
676 skb->csum))
677 break;
678 /* fall through */
679 case CHECKSUM_NONE:
Al Viro868c86b2006-11-14 21:35:48 -0800680 skb->csum = ~csum_unfold(csum_ipv6_magic(saddr, daddr, skb->len,
681 IPPROTO_ICMPV6, 0));
Herbert Xufb286bb2005-11-10 13:01:24 -0800682 if (__skb_checksum_complete(skb)) {
Joe Perches46b86a22006-01-13 14:29:07 -0800683 LIMIT_NETDEBUG(KERN_DEBUG "ICMPv6 checksum failed [" NIP6_FMT " > " NIP6_FMT "]\n",
Patrick McHardy64ce2072005-08-09 20:50:53 -0700684 NIP6(*saddr), NIP6(*daddr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 goto discard_it;
686 }
687 }
688
Herbert Xu8cf22942008-02-05 03:15:50 -0800689 if (!pskb_pull(skb, sizeof(*hdr)))
690 goto discard_it;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300692 hdr = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693
694 type = hdr->icmp6_type;
695
Denis V. Lunev55d43802008-10-08 10:34:54 -0700696 ICMP6MSGIN_INC_STATS_BH(dev_net(dev), idev, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697
698 switch (type) {
699 case ICMPV6_ECHO_REQUEST:
700 icmpv6_echo_reply(skb);
701 break;
702
703 case ICMPV6_ECHO_REPLY:
704 /* we couldn't care less */
705 break;
706
707 case ICMPV6_PKT_TOOBIG:
708 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
709 standard destination cache. Seems, only "advanced"
710 destination cache will allow to solve this problem
711 --ANK (980726)
712 */
713 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
714 goto discard_it;
Arnaldo Carvalho de Melocc70ab22007-03-13 14:03:22 -0300715 hdr = icmp6_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 orig_hdr = (struct ipv6hdr *) (hdr + 1);
717 rt6_pmtu_discovery(&orig_hdr->daddr, &orig_hdr->saddr, dev,
718 ntohl(hdr->icmp6_mtu));
719
720 /*
721 * Drop through to notify
722 */
723
724 case ICMPV6_DEST_UNREACH:
725 case ICMPV6_TIME_EXCEED:
726 case ICMPV6_PARAMPROB:
727 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
728 break;
729
730 case NDISC_ROUTER_SOLICITATION:
731 case NDISC_ROUTER_ADVERTISEMENT:
732 case NDISC_NEIGHBOUR_SOLICITATION:
733 case NDISC_NEIGHBOUR_ADVERTISEMENT:
734 case NDISC_REDIRECT:
735 ndisc_rcv(skb);
736 break;
737
738 case ICMPV6_MGM_QUERY:
739 igmp6_event_query(skb);
740 break;
741
742 case ICMPV6_MGM_REPORT:
743 igmp6_event_report(skb);
744 break;
745
746 case ICMPV6_MGM_REDUCTION:
747 case ICMPV6_NI_QUERY:
748 case ICMPV6_NI_REPLY:
749 case ICMPV6_MLD2_REPORT:
750 case ICMPV6_DHAAD_REQUEST:
751 case ICMPV6_DHAAD_REPLY:
752 case ICMPV6_MOBILE_PREFIX_SOL:
753 case ICMPV6_MOBILE_PREFIX_ADV:
754 break;
755
756 default:
Patrick McHardy64ce2072005-08-09 20:50:53 -0700757 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6: msg of unknown type\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758
759 /* informational */
760 if (type & ICMPV6_INFOMSG_MASK)
761 break;
762
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900763 /*
764 * error of unknown type.
765 * must pass to upper level
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 */
767
768 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700769 }
770
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 kfree_skb(skb);
772 return 0;
773
774discard_it:
Denis V. Luneve41b5362008-10-08 10:33:26 -0700775 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INERRORS);
Herbert Xu8b7817f2007-12-12 10:44:43 -0800776drop_no_count:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 kfree_skb(skb);
778 return 0;
779}
780
YOSHIFUJI Hideaki95e41e92007-12-06 15:43:30 -0800781void icmpv6_flow_init(struct sock *sk, struct flowi *fl,
782 u8 type,
783 const struct in6_addr *saddr,
784 const struct in6_addr *daddr,
785 int oif)
786{
787 memset(fl, 0, sizeof(*fl));
788 ipv6_addr_copy(&fl->fl6_src, saddr);
789 ipv6_addr_copy(&fl->fl6_dst, daddr);
790 fl->proto = IPPROTO_ICMPV6;
791 fl->fl_icmp_type = type;
792 fl->fl_icmp_code = 0;
793 fl->oif = oif;
794 security_sk_classify_flow(sk, fl);
795}
796
Ingo Molnar640c41c2006-08-15 00:06:56 -0700797/*
Denis V. Lunevb7e729c2008-02-29 11:16:08 -0800798 * Special lock-class for __icmpv6_sk:
Ingo Molnar640c41c2006-08-15 00:06:56 -0700799 */
800static struct lock_class_key icmpv6_socket_sk_dst_lock_key;
801
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800802static int __net_init icmpv6_sk_init(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803{
804 struct sock *sk;
805 int err, i, j;
806
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800807 net->ipv6.icmp_sk =
808 kzalloc(nr_cpu_ids * sizeof(struct sock *), GFP_KERNEL);
809 if (net->ipv6.icmp_sk == NULL)
Denis V. Lunev79c91152008-02-29 11:17:11 -0800810 return -ENOMEM;
811
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -0700812 for_each_possible_cpu(i) {
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700813 err = inet_ctl_sock_create(&sk, PF_INET6,
814 SOCK_RAW, IPPROTO_ICMPV6, net);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 if (err < 0) {
816 printk(KERN_ERR
817 "Failed to initialize the ICMP6 control socket "
818 "(err %d).\n",
819 err);
820 goto fail;
821 }
822
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700823 net->ipv6.icmp_sk[i] = sk;
Denis V. Lunev5c8cafd2008-02-29 11:19:22 -0800824
Ingo Molnar640c41c2006-08-15 00:06:56 -0700825 /*
826 * Split off their lock-class, because sk->sk_dst_lock
827 * gets used from softirqs, which is safe for
Denis V. Lunevb7e729c2008-02-29 11:16:08 -0800828 * __icmpv6_sk (because those never get directly used
Ingo Molnar640c41c2006-08-15 00:06:56 -0700829 * via userspace syscalls), but unsafe for normal sockets.
830 */
831 lockdep_set_class(&sk->sk_dst_lock,
832 &icmpv6_socket_sk_dst_lock_key);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833
834 /* Enough space for 2 64K ICMP packets, including
835 * sk_buff struct overhead.
836 */
837 sk->sk_sndbuf =
838 (2 * ((64 * 1024) + sizeof(struct sk_buff)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 return 0;
841
842 fail:
Denis V. Lunev5c8cafd2008-02-29 11:19:22 -0800843 for (j = 0; j < i; j++)
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700844 inet_ctl_sock_destroy(net->ipv6.icmp_sk[j]);
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800845 kfree(net->ipv6.icmp_sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 return err;
847}
848
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800849static void __net_exit icmpv6_sk_exit(struct net *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850{
851 int i;
852
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -0700853 for_each_possible_cpu(i) {
Denis V. Lunev1ed85162008-04-03 14:31:03 -0700854 inet_ctl_sock_destroy(net->ipv6.icmp_sk[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 }
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800856 kfree(net->ipv6.icmp_sk);
857}
858
Alexey Dobriyan8ed7edc2008-03-03 12:02:54 -0800859static struct pernet_operations icmpv6_sk_ops = {
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800860 .init = icmpv6_sk_init,
861 .exit = icmpv6_sk_exit,
862};
863
864int __init icmpv6_init(void)
865{
866 int err;
867
868 err = register_pernet_subsys(&icmpv6_sk_ops);
869 if (err < 0)
870 return err;
871
872 err = -EAGAIN;
873 if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0)
874 goto fail;
875 return 0;
876
877fail:
878 printk(KERN_ERR "Failed to register ICMP6 protocol\n");
879 unregister_pernet_subsys(&icmpv6_sk_ops);
880 return err;
881}
882
Alexey Dobriyan8ed7edc2008-03-03 12:02:54 -0800883void icmpv6_cleanup(void)
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800884{
885 unregister_pernet_subsys(&icmpv6_sk_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
887}
888
Denis V. Lunev98c6d1b2008-02-29 11:21:22 -0800889
Arjan van de Ven9b5b5cf2005-11-29 16:21:38 -0800890static const struct icmp6_err {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 int err;
892 int fatal;
893} tab_unreach[] = {
894 { /* NOROUTE */
895 .err = ENETUNREACH,
896 .fatal = 0,
897 },
898 { /* ADM_PROHIBITED */
899 .err = EACCES,
900 .fatal = 1,
901 },
902 { /* Was NOT_NEIGHBOUR, now reserved */
903 .err = EHOSTUNREACH,
904 .fatal = 0,
905 },
906 { /* ADDR_UNREACH */
907 .err = EHOSTUNREACH,
908 .fatal = 0,
909 },
910 { /* PORT_UNREACH */
911 .err = ECONNREFUSED,
912 .fatal = 1,
913 },
914};
915
916int icmpv6_err_convert(int type, int code, int *err)
917{
918 int fatal = 0;
919
920 *err = EPROTO;
921
922 switch (type) {
923 case ICMPV6_DEST_UNREACH:
924 fatal = 1;
925 if (code <= ICMPV6_PORT_UNREACH) {
926 *err = tab_unreach[code].err;
927 fatal = tab_unreach[code].fatal;
928 }
929 break;
930
931 case ICMPV6_PKT_TOOBIG:
932 *err = EMSGSIZE;
933 break;
YOSHIFUJI Hideaki1ab14572007-02-09 23:24:49 +0900934
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935 case ICMPV6_PARAMPROB:
936 *err = EPROTO;
937 fatal = 1;
938 break;
939
940 case ICMPV6_TIME_EXCEED:
941 *err = EHOSTUNREACH;
942 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700943 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944
945 return fatal;
946}
947
YOSHIFUJI Hideaki71590392007-02-22 22:05:40 +0900948EXPORT_SYMBOL(icmpv6_err_convert);
949
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950#ifdef CONFIG_SYSCTL
Daniel Lezcano760f2d02008-01-10 02:53:43 -0800951ctl_table ipv6_icmp_table_template[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952 {
953 .ctl_name = NET_IPV6_ICMP_RATELIMIT,
954 .procname = "ratelimit",
Daniel Lezcano41a76902008-01-10 03:02:40 -0800955 .data = &init_net.ipv6.sysctl.icmpv6_time,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 .maxlen = sizeof(int),
957 .mode = 0644,
Stephen Hemminger6dbf4bc2008-07-01 19:29:07 -0700958 .proc_handler = &proc_dointvec_ms_jiffies,
959 .strategy = &sysctl_ms_jiffies
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 },
961 { .ctl_name = 0 },
962};
Daniel Lezcano760f2d02008-01-10 02:53:43 -0800963
964struct ctl_table *ipv6_icmp_sysctl_init(struct net *net)
965{
966 struct ctl_table *table;
967
968 table = kmemdup(ipv6_icmp_table_template,
969 sizeof(ipv6_icmp_table_template),
970 GFP_KERNEL);
YOSHIFUJI Hideaki5ee09102008-02-28 00:24:28 +0900971
972 if (table)
973 table[0].data = &net->ipv6.sysctl.icmpv6_time;
974
Daniel Lezcano760f2d02008-01-10 02:53:43 -0800975 return table;
976}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977#endif
978