blob: dbfce089e916d4088788fc00ccef432395390e93 [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 *
8 * $Id: icmp.c,v 1.38 2002/02/08 03:57:19 davem Exp $
9 *
10 * Based on net/ipv4/icmp.c
11 *
12 * RFC 1885
13 *
14 * This program is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU General Public License
16 * as published by the Free Software Foundation; either version
17 * 2 of the License, or (at your option) any later version.
18 */
19
20/*
21 * Changes:
22 *
23 * Andi Kleen : exception handling
24 * Andi Kleen add rate limits. never reply to a icmp.
25 * add more length checks and other fixes.
26 * yoshfuji : ensure to sent parameter problem for
27 * fragments.
28 * YOSHIFUJI Hideaki @USAGI: added sysctl for icmp rate limit.
29 * Randy Dunlap and
30 * YOSHIFUJI Hideaki @USAGI: Per-interface statistics support
31 * Kazunori MIYAZAWA @USAGI: change output process to use ip6_append_data
32 */
33
34#include <linux/module.h>
35#include <linux/errno.h>
36#include <linux/types.h>
37#include <linux/socket.h>
38#include <linux/in.h>
39#include <linux/kernel.h>
40#include <linux/sched.h>
41#include <linux/sockios.h>
42#include <linux/net.h>
43#include <linux/skbuff.h>
44#include <linux/init.h>
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -080045#include <linux/netfilter.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
47#ifdef CONFIG_SYSCTL
48#include <linux/sysctl.h>
49#endif
50
51#include <linux/inet.h>
52#include <linux/netdevice.h>
53#include <linux/icmpv6.h>
54
55#include <net/ip.h>
56#include <net/sock.h>
57
58#include <net/ipv6.h>
59#include <net/ip6_checksum.h>
60#include <net/protocol.h>
61#include <net/raw.h>
62#include <net/rawv6.h>
63#include <net/transp_v6.h>
64#include <net/ip6_route.h>
65#include <net/addrconf.h>
66#include <net/icmp.h>
67
68#include <asm/uaccess.h>
69#include <asm/system.h>
70
Eric Dumazetba899662005-08-26 12:05:31 -070071DEFINE_SNMP_STAT(struct icmpv6_mib, icmpv6_statistics) __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070072
73/*
74 * The ICMP socket(s). This is the most convenient way to flow control
75 * our ICMP output as well as maintain a clean interface throughout
76 * all layers. All Socketless IP sends will soon be gone.
77 *
78 * On SMP we have one ICMP socket per-cpu.
79 */
80static DEFINE_PER_CPU(struct socket *, __icmpv6_socket) = NULL;
81#define icmpv6_socket __get_cpu_var(__icmpv6_socket)
82
Patrick McHardy951dbc82006-01-06 23:02:34 -080083static int icmpv6_rcv(struct sk_buff **pskb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070084
85static struct inet6_protocol icmpv6_protocol = {
86 .handler = icmpv6_rcv,
87 .flags = INET6_PROTO_FINAL,
88};
89
90static __inline__ int icmpv6_xmit_lock(void)
91{
92 local_bh_disable();
93
94 if (unlikely(!spin_trylock(&icmpv6_socket->sk->sk_lock.slock))) {
95 /* This can happen if the output path (f.e. SIT or
96 * ip6ip6 tunnel) signals dst_link_failure() for an
97 * outgoing ICMP6 packet.
98 */
99 local_bh_enable();
100 return 1;
101 }
102 return 0;
103}
104
105static __inline__ void icmpv6_xmit_unlock(void)
106{
107 spin_unlock_bh(&icmpv6_socket->sk->sk_lock.slock);
108}
109
110/*
111 * Slightly more convenient version of icmpv6_send.
112 */
113void icmpv6_param_prob(struct sk_buff *skb, int code, int pos)
114{
115 icmpv6_send(skb, ICMPV6_PARAMPROB, code, pos, skb->dev);
116 kfree_skb(skb);
117}
118
119/*
120 * Figure out, may we reply to this packet with icmp error.
121 *
122 * We do not reply, if:
123 * - it was icmp error message.
124 * - it is truncated, so that it is known, that protocol is ICMPV6
125 * (i.e. in the middle of some exthdr)
126 *
127 * --ANK (980726)
128 */
129
130static int is_ineligible(struct sk_buff *skb)
131{
132 int ptr = (u8*)(skb->nh.ipv6h+1) - skb->data;
133 int len = skb->len - ptr;
134 __u8 nexthdr = skb->nh.ipv6h->nexthdr;
135
136 if (len < 0)
137 return 1;
138
Herbert Xu0d3d0772005-04-24 20:16:19 -0700139 ptr = ipv6_skip_exthdr(skb, ptr, &nexthdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 if (ptr < 0)
141 return 0;
142 if (nexthdr == IPPROTO_ICMPV6) {
143 u8 _type, *tp;
144 tp = skb_header_pointer(skb,
145 ptr+offsetof(struct icmp6hdr, icmp6_type),
146 sizeof(_type), &_type);
147 if (tp == NULL ||
148 !(*tp & ICMPV6_INFOMSG_MASK))
149 return 1;
150 }
151 return 0;
152}
153
154static int sysctl_icmpv6_time = 1*HZ;
155
156/*
157 * Check the ICMP output rate limit
158 */
159static inline int icmpv6_xrlim_allow(struct sock *sk, int type,
160 struct flowi *fl)
161{
162 struct dst_entry *dst;
163 int res = 0;
164
165 /* Informational messages are not limited. */
166 if (type & ICMPV6_INFOMSG_MASK)
167 return 1;
168
169 /* Do not limit pmtu discovery, it would break it. */
170 if (type == ICMPV6_PKT_TOOBIG)
171 return 1;
172
173 /*
174 * Look up the output route.
175 * XXX: perhaps the expire for routing entries cloned by
176 * this lookup should be more aggressive (not longer than timeout).
177 */
178 dst = ip6_route_output(sk, fl);
179 if (dst->error) {
180 IP6_INC_STATS(IPSTATS_MIB_OUTNOROUTES);
181 } else if (dst->dev && (dst->dev->flags&IFF_LOOPBACK)) {
182 res = 1;
183 } else {
184 struct rt6_info *rt = (struct rt6_info *)dst;
185 int tmo = sysctl_icmpv6_time;
186
187 /* Give more bandwidth to wider prefixes. */
188 if (rt->rt6i_dst.plen < 128)
189 tmo >>= ((128 - rt->rt6i_dst.plen)>>5);
190
191 res = xrlim_allow(dst, tmo);
192 }
193 dst_release(dst);
194 return res;
195}
196
197/*
198 * an inline helper for the "simple" if statement below
199 * checks if parameter problem report is caused by an
200 * unrecognized IPv6 option that has the Option Type
201 * highest-order two bits set to 10
202 */
203
204static __inline__ int opt_unrec(struct sk_buff *skb, __u32 offset)
205{
206 u8 _optval, *op;
207
208 offset += skb->nh.raw - skb->data;
209 op = skb_header_pointer(skb, offset, sizeof(_optval), &_optval);
210 if (op == NULL)
211 return 1;
212 return (*op & 0xC0) == 0x80;
213}
214
215static int icmpv6_push_pending_frames(struct sock *sk, struct flowi *fl, struct icmp6hdr *thdr, int len)
216{
217 struct sk_buff *skb;
218 struct icmp6hdr *icmp6h;
219 int err = 0;
220
221 if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
222 goto out;
223
224 icmp6h = (struct icmp6hdr*) skb->h.raw;
225 memcpy(icmp6h, thdr, sizeof(struct icmp6hdr));
226 icmp6h->icmp6_cksum = 0;
227
228 if (skb_queue_len(&sk->sk_write_queue) == 1) {
229 skb->csum = csum_partial((char *)icmp6h,
230 sizeof(struct icmp6hdr), skb->csum);
231 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl->fl6_src,
232 &fl->fl6_dst,
233 len, fl->proto,
234 skb->csum);
235 } else {
236 u32 tmp_csum = 0;
237
238 skb_queue_walk(&sk->sk_write_queue, skb) {
239 tmp_csum = csum_add(tmp_csum, skb->csum);
240 }
241
242 tmp_csum = csum_partial((char *)icmp6h,
243 sizeof(struct icmp6hdr), tmp_csum);
244 tmp_csum = csum_ipv6_magic(&fl->fl6_src,
245 &fl->fl6_dst,
246 len, fl->proto, tmp_csum);
247 icmp6h->icmp6_cksum = tmp_csum;
248 }
249 if (icmp6h->icmp6_cksum == 0)
250 icmp6h->icmp6_cksum = -1;
251 ip6_push_pending_frames(sk);
252out:
253 return err;
254}
255
256struct icmpv6_msg {
257 struct sk_buff *skb;
258 int offset;
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800259 uint8_t type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260};
261
262static int icmpv6_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb)
263{
264 struct icmpv6_msg *msg = (struct icmpv6_msg *) from;
265 struct sk_buff *org_skb = msg->skb;
266 __u32 csum = 0;
267
268 csum = skb_copy_and_csum_bits(org_skb, msg->offset + offset,
269 to, len, csum);
270 skb->csum = csum_block_add(skb->csum, csum, odd);
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800271 if (!(msg->type & ICMPV6_INFOMSG_MASK))
272 nf_ct_attach(skb, org_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 return 0;
274}
275
276/*
277 * Send an ICMP message in response to a packet in error
278 */
279void icmpv6_send(struct sk_buff *skb, int type, int code, __u32 info,
280 struct net_device *dev)
281{
282 struct inet6_dev *idev = NULL;
283 struct ipv6hdr *hdr = skb->nh.ipv6h;
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700284 struct sock *sk;
285 struct ipv6_pinfo *np;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 struct in6_addr *saddr = NULL;
287 struct dst_entry *dst;
288 struct icmp6hdr tmp_hdr;
289 struct flowi fl;
290 struct icmpv6_msg msg;
291 int iif = 0;
292 int addr_type = 0;
293 int len;
YOSHIFUJI Hideaki41a1f8e2005-09-08 10:19:03 +0900294 int hlimit, tclass;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 int err = 0;
296
297 if ((u8*)hdr < skb->head || (u8*)(hdr+1) > skb->tail)
298 return;
299
300 /*
301 * Make sure we respect the rules
302 * i.e. RFC 1885 2.4(e)
303 * Rule (e.1) is enforced by not using icmpv6_send
304 * in any code that processes icmp errors.
305 */
306 addr_type = ipv6_addr_type(&hdr->daddr);
307
308 if (ipv6_chk_addr(&hdr->daddr, skb->dev, 0))
309 saddr = &hdr->daddr;
310
311 /*
312 * Dest addr check
313 */
314
315 if ((addr_type & IPV6_ADDR_MULTICAST || skb->pkt_type != PACKET_HOST)) {
316 if (type != ICMPV6_PKT_TOOBIG &&
317 !(type == ICMPV6_PARAMPROB &&
318 code == ICMPV6_UNK_OPTION &&
319 (opt_unrec(skb, info))))
320 return;
321
322 saddr = NULL;
323 }
324
325 addr_type = ipv6_addr_type(&hdr->saddr);
326
327 /*
328 * Source addr check
329 */
330
331 if (addr_type & IPV6_ADDR_LINKLOCAL)
332 iif = skb->dev->ifindex;
333
334 /*
YOSHIFUJI Hideaki8de33512005-12-21 22:57:06 +0900335 * Must not send error if the source does not uniquely
336 * identify a single node (RFC2463 Section 2.4).
337 * We check unspecified / multicast addresses here,
338 * and anycast addresses will be checked later.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 */
340 if ((addr_type == IPV6_ADDR_ANY) || (addr_type & IPV6_ADDR_MULTICAST)) {
Patrick McHardy64ce2072005-08-09 20:50:53 -0700341 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: addr_any/mcast source\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 return;
343 }
344
345 /*
346 * Never answer to a ICMP packet.
347 */
348 if (is_ineligible(skb)) {
Patrick McHardy64ce2072005-08-09 20:50:53 -0700349 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: no reply to icmp error\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 return;
351 }
352
353 memset(&fl, 0, sizeof(fl));
354 fl.proto = IPPROTO_ICMPV6;
355 ipv6_addr_copy(&fl.fl6_dst, &hdr->saddr);
356 if (saddr)
357 ipv6_addr_copy(&fl.fl6_src, saddr);
358 fl.oif = iif;
359 fl.fl_icmp_type = type;
360 fl.fl_icmp_code = code;
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -0700361 security_skb_classify_flow(skb, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362
363 if (icmpv6_xmit_lock())
364 return;
365
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700366 sk = icmpv6_socket->sk;
367 np = inet6_sk(sk);
368
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 if (!icmpv6_xrlim_allow(sk, type, &fl))
370 goto out;
371
372 tmp_hdr.icmp6_type = type;
373 tmp_hdr.icmp6_code = code;
374 tmp_hdr.icmp6_cksum = 0;
375 tmp_hdr.icmp6_pointer = htonl(info);
376
377 if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
378 fl.oif = np->mcast_oif;
379
380 err = ip6_dst_lookup(sk, &dst, &fl);
381 if (err)
382 goto out;
YOSHIFUJI Hideaki8de33512005-12-21 22:57:06 +0900383
384 /*
385 * We won't send icmp if the destination is known
386 * anycast.
387 */
388 if (((struct rt6_info *)dst)->rt6i_flags & RTF_ANYCAST) {
389 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: acast source\n");
390 goto out_dst_release;
391 }
392
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
Patrick McHardye104411b2005-09-08 15:11:55 -0700394 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395
396 if (ipv6_addr_is_multicast(&fl.fl6_dst))
397 hlimit = np->mcast_hops;
398 else
399 hlimit = np->hop_limit;
400 if (hlimit < 0)
401 hlimit = dst_metric(dst, RTAX_HOPLIMIT);
402 if (hlimit < 0)
403 hlimit = ipv6_get_hoplimit(dst->dev);
404
YOSHIFUJI Hideakie012d512006-09-13 20:01:28 -0700405 tclass = np->tclass;
YOSHIFUJI Hideaki41a1f8e2005-09-08 10:19:03 +0900406 if (tclass < 0)
407 tclass = 0;
408
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 msg.skb = skb;
410 msg.offset = skb->nh.raw - skb->data;
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800411 msg.type = type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412
413 len = skb->len - msg.offset;
414 len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) -sizeof(struct icmp6hdr));
415 if (len < 0) {
Patrick McHardy64ce2072005-08-09 20:50:53 -0700416 LIMIT_NETDEBUG(KERN_DEBUG "icmp: len problem\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 goto out_dst_release;
418 }
419
420 idev = in6_dev_get(skb->dev);
421
422 err = ip6_append_data(sk, icmpv6_getfrag, &msg,
423 len + sizeof(struct icmp6hdr),
424 sizeof(struct icmp6hdr),
YOSHIFUJI Hideaki41a1f8e2005-09-08 10:19:03 +0900425 hlimit, tclass, NULL, &fl, (struct rt6_info*)dst,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 MSG_DONTWAIT);
427 if (err) {
428 ip6_flush_pending_frames(sk);
429 goto out_put;
430 }
431 err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, len + sizeof(struct icmp6hdr));
432
433 if (type >= ICMPV6_DEST_UNREACH && type <= ICMPV6_PARAMPROB)
434 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_OUTDESTUNREACHS, type - ICMPV6_DEST_UNREACH);
435 ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTMSGS);
436
437out_put:
438 if (likely(idev != NULL))
439 in6_dev_put(idev);
440out_dst_release:
441 dst_release(dst);
442out:
443 icmpv6_xmit_unlock();
444}
445
446static void icmpv6_echo_reply(struct sk_buff *skb)
447{
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700448 struct sock *sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 struct inet6_dev *idev;
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700450 struct ipv6_pinfo *np;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 struct in6_addr *saddr = NULL;
452 struct icmp6hdr *icmph = (struct icmp6hdr *) skb->h.raw;
453 struct icmp6hdr tmp_hdr;
454 struct flowi fl;
455 struct icmpv6_msg msg;
456 struct dst_entry *dst;
457 int err = 0;
458 int hlimit;
YOSHIFUJI Hideaki41a1f8e2005-09-08 10:19:03 +0900459 int tclass;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460
461 saddr = &skb->nh.ipv6h->daddr;
462
463 if (!ipv6_unicast_destination(skb))
464 saddr = NULL;
465
466 memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
467 tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;
468
469 memset(&fl, 0, sizeof(fl));
470 fl.proto = IPPROTO_ICMPV6;
471 ipv6_addr_copy(&fl.fl6_dst, &skb->nh.ipv6h->saddr);
472 if (saddr)
473 ipv6_addr_copy(&fl.fl6_src, saddr);
474 fl.oif = skb->dev->ifindex;
475 fl.fl_icmp_type = ICMPV6_ECHO_REPLY;
Venkat Yekkiralabeb8d132006-08-04 23:12:42 -0700476 security_skb_classify_flow(skb, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477
478 if (icmpv6_xmit_lock())
479 return;
480
YOSHIFUJI Hideaki84427d52005-06-13 14:59:44 -0700481 sk = icmpv6_socket->sk;
482 np = inet6_sk(sk);
483
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
485 fl.oif = np->mcast_oif;
486
487 err = ip6_dst_lookup(sk, &dst, &fl);
488 if (err)
489 goto out;
490 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
Patrick McHardye104411b2005-09-08 15:11:55 -0700491 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492
493 if (ipv6_addr_is_multicast(&fl.fl6_dst))
494 hlimit = np->mcast_hops;
495 else
496 hlimit = np->hop_limit;
497 if (hlimit < 0)
498 hlimit = dst_metric(dst, RTAX_HOPLIMIT);
499 if (hlimit < 0)
500 hlimit = ipv6_get_hoplimit(dst->dev);
501
YOSHIFUJI Hideakie012d512006-09-13 20:01:28 -0700502 tclass = np->tclass;
YOSHIFUJI Hideaki41a1f8e2005-09-08 10:19:03 +0900503 if (tclass < 0)
504 tclass = 0;
505
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 idev = in6_dev_get(skb->dev);
507
508 msg.skb = skb;
509 msg.offset = 0;
Yasuyuki Kozakai763ecff2006-02-15 15:24:15 -0800510 msg.type = ICMPV6_ECHO_REPLY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511
512 err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
YOSHIFUJI Hideaki41a1f8e2005-09-08 10:19:03 +0900513 sizeof(struct icmp6hdr), hlimit, tclass, NULL, &fl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 (struct rt6_info*)dst, MSG_DONTWAIT);
515
516 if (err) {
517 ip6_flush_pending_frames(sk);
518 goto out_put;
519 }
520 err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, skb->len + sizeof(struct icmp6hdr));
521
522 ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTECHOREPLIES);
523 ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTMSGS);
524
525out_put:
526 if (likely(idev != NULL))
527 in6_dev_put(idev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 dst_release(dst);
529out:
530 icmpv6_xmit_unlock();
531}
532
533static void icmpv6_notify(struct sk_buff *skb, int type, int code, u32 info)
534{
535 struct in6_addr *saddr, *daddr;
536 struct inet6_protocol *ipprot;
537 struct sock *sk;
538 int inner_offset;
539 int hash;
540 u8 nexthdr;
541
542 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
543 return;
544
545 nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
546 if (ipv6_ext_hdr(nexthdr)) {
547 /* now skip over extension headers */
Herbert Xu0d3d0772005-04-24 20:16:19 -0700548 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr), &nexthdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 if (inner_offset<0)
550 return;
551 } else {
552 inner_offset = sizeof(struct ipv6hdr);
553 }
554
555 /* Checkin header including 8 bytes of inner protocol header. */
556 if (!pskb_may_pull(skb, inner_offset+8))
557 return;
558
559 saddr = &skb->nh.ipv6h->saddr;
560 daddr = &skb->nh.ipv6h->daddr;
561
562 /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
563 Without this we will not able f.e. to make source routed
564 pmtu discovery.
565 Corresponding argument (opt) to notifiers is already added.
566 --ANK (980726)
567 */
568
569 hash = nexthdr & (MAX_INET_PROTOS - 1);
570
571 rcu_read_lock();
572 ipprot = rcu_dereference(inet6_protos[hash]);
573 if (ipprot && ipprot->err_handler)
574 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
575 rcu_read_unlock();
576
577 read_lock(&raw_v6_lock);
578 if ((sk = sk_head(&raw_v6_htable[hash])) != NULL) {
Andrew McDonald0bd1b592005-08-09 19:44:42 -0700579 while((sk = __raw_v6_lookup(sk, nexthdr, daddr, saddr,
YOSHIFUJI Hideaki2dac4b92005-09-01 17:44:49 -0700580 IP6CB(skb)->iif))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 rawv6_err(sk, skb, NULL, type, code, inner_offset, info);
582 sk = sk_next(sk);
583 }
584 }
585 read_unlock(&raw_v6_lock);
586}
587
588/*
589 * Handle icmp messages
590 */
591
Patrick McHardy951dbc82006-01-06 23:02:34 -0800592static int icmpv6_rcv(struct sk_buff **pskb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593{
594 struct sk_buff *skb = *pskb;
595 struct net_device *dev = skb->dev;
596 struct inet6_dev *idev = __in6_dev_get(dev);
597 struct in6_addr *saddr, *daddr;
598 struct ipv6hdr *orig_hdr;
599 struct icmp6hdr *hdr;
600 int type;
601
602 ICMP6_INC_STATS_BH(idev, ICMP6_MIB_INMSGS);
603
604 saddr = &skb->nh.ipv6h->saddr;
605 daddr = &skb->nh.ipv6h->daddr;
606
607 /* Perform checksum. */
Herbert Xufb286bb2005-11-10 13:01:24 -0800608 switch (skb->ip_summed) {
609 case CHECKSUM_HW:
610 if (!csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
611 skb->csum))
612 break;
613 /* fall through */
614 case CHECKSUM_NONE:
615 skb->csum = ~csum_ipv6_magic(saddr, daddr, skb->len,
616 IPPROTO_ICMPV6, 0);
617 if (__skb_checksum_complete(skb)) {
Joe Perches46b86a22006-01-13 14:29:07 -0800618 LIMIT_NETDEBUG(KERN_DEBUG "ICMPv6 checksum failed [" NIP6_FMT " > " NIP6_FMT "]\n",
Patrick McHardy64ce2072005-08-09 20:50:53 -0700619 NIP6(*saddr), NIP6(*daddr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 goto discard_it;
621 }
622 }
623
624 if (!pskb_pull(skb, sizeof(struct icmp6hdr)))
625 goto discard_it;
626
627 hdr = (struct icmp6hdr *) skb->h.raw;
628
629 type = hdr->icmp6_type;
630
631 if (type >= ICMPV6_DEST_UNREACH && type <= ICMPV6_PARAMPROB)
632 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_INDESTUNREACHS, type - ICMPV6_DEST_UNREACH);
633 else if (type >= ICMPV6_ECHO_REQUEST && type <= NDISC_REDIRECT)
634 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_INECHOS, type - ICMPV6_ECHO_REQUEST);
635
636 switch (type) {
637 case ICMPV6_ECHO_REQUEST:
638 icmpv6_echo_reply(skb);
639 break;
640
641 case ICMPV6_ECHO_REPLY:
642 /* we couldn't care less */
643 break;
644
645 case ICMPV6_PKT_TOOBIG:
646 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
647 standard destination cache. Seems, only "advanced"
648 destination cache will allow to solve this problem
649 --ANK (980726)
650 */
651 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
652 goto discard_it;
653 hdr = (struct icmp6hdr *) skb->h.raw;
654 orig_hdr = (struct ipv6hdr *) (hdr + 1);
655 rt6_pmtu_discovery(&orig_hdr->daddr, &orig_hdr->saddr, dev,
656 ntohl(hdr->icmp6_mtu));
657
658 /*
659 * Drop through to notify
660 */
661
662 case ICMPV6_DEST_UNREACH:
663 case ICMPV6_TIME_EXCEED:
664 case ICMPV6_PARAMPROB:
665 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
666 break;
667
668 case NDISC_ROUTER_SOLICITATION:
669 case NDISC_ROUTER_ADVERTISEMENT:
670 case NDISC_NEIGHBOUR_SOLICITATION:
671 case NDISC_NEIGHBOUR_ADVERTISEMENT:
672 case NDISC_REDIRECT:
673 ndisc_rcv(skb);
674 break;
675
676 case ICMPV6_MGM_QUERY:
677 igmp6_event_query(skb);
678 break;
679
680 case ICMPV6_MGM_REPORT:
681 igmp6_event_report(skb);
682 break;
683
684 case ICMPV6_MGM_REDUCTION:
685 case ICMPV6_NI_QUERY:
686 case ICMPV6_NI_REPLY:
687 case ICMPV6_MLD2_REPORT:
688 case ICMPV6_DHAAD_REQUEST:
689 case ICMPV6_DHAAD_REPLY:
690 case ICMPV6_MOBILE_PREFIX_SOL:
691 case ICMPV6_MOBILE_PREFIX_ADV:
692 break;
693
694 default:
Patrick McHardy64ce2072005-08-09 20:50:53 -0700695 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6: msg of unknown type\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696
697 /* informational */
698 if (type & ICMPV6_INFOMSG_MASK)
699 break;
700
701 /*
702 * error of unknown type.
703 * must pass to upper level
704 */
705
706 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
707 };
708 kfree_skb(skb);
709 return 0;
710
711discard_it:
712 ICMP6_INC_STATS_BH(idev, ICMP6_MIB_INERRORS);
713 kfree_skb(skb);
714 return 0;
715}
716
Ingo Molnar640c41c2006-08-15 00:06:56 -0700717/*
718 * Special lock-class for __icmpv6_socket:
719 */
720static struct lock_class_key icmpv6_socket_sk_dst_lock_key;
721
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722int __init icmpv6_init(struct net_proto_family *ops)
723{
724 struct sock *sk;
725 int err, i, j;
726
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -0700727 for_each_possible_cpu(i) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 err = sock_create_kern(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6,
729 &per_cpu(__icmpv6_socket, i));
730 if (err < 0) {
731 printk(KERN_ERR
732 "Failed to initialize the ICMP6 control socket "
733 "(err %d).\n",
734 err);
735 goto fail;
736 }
737
738 sk = per_cpu(__icmpv6_socket, i)->sk;
739 sk->sk_allocation = GFP_ATOMIC;
Ingo Molnar640c41c2006-08-15 00:06:56 -0700740 /*
741 * Split off their lock-class, because sk->sk_dst_lock
742 * gets used from softirqs, which is safe for
743 * __icmpv6_socket (because those never get directly used
744 * via userspace syscalls), but unsafe for normal sockets.
745 */
746 lockdep_set_class(&sk->sk_dst_lock,
747 &icmpv6_socket_sk_dst_lock_key);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748
749 /* Enough space for 2 64K ICMP packets, including
750 * sk_buff struct overhead.
751 */
752 sk->sk_sndbuf =
753 (2 * ((64 * 1024) + sizeof(struct sk_buff)));
754
755 sk->sk_prot->unhash(sk);
756 }
757
758
759 if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0) {
760 printk(KERN_ERR "Failed to register ICMP6 protocol\n");
761 err = -EAGAIN;
762 goto fail;
763 }
764
765 return 0;
766
767 fail:
768 for (j = 0; j < i; j++) {
769 if (!cpu_possible(j))
770 continue;
771 sock_release(per_cpu(__icmpv6_socket, j));
772 }
773
774 return err;
775}
776
777void icmpv6_cleanup(void)
778{
779 int i;
780
KAMEZAWA Hiroyuki6f912042006-04-10 22:52:50 -0700781 for_each_possible_cpu(i) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 sock_release(per_cpu(__icmpv6_socket, i));
783 }
784 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
785}
786
Arjan van de Ven9b5b5cf2005-11-29 16:21:38 -0800787static const struct icmp6_err {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 int err;
789 int fatal;
790} tab_unreach[] = {
791 { /* NOROUTE */
792 .err = ENETUNREACH,
793 .fatal = 0,
794 },
795 { /* ADM_PROHIBITED */
796 .err = EACCES,
797 .fatal = 1,
798 },
799 { /* Was NOT_NEIGHBOUR, now reserved */
800 .err = EHOSTUNREACH,
801 .fatal = 0,
802 },
803 { /* ADDR_UNREACH */
804 .err = EHOSTUNREACH,
805 .fatal = 0,
806 },
807 { /* PORT_UNREACH */
808 .err = ECONNREFUSED,
809 .fatal = 1,
810 },
811};
812
813int icmpv6_err_convert(int type, int code, int *err)
814{
815 int fatal = 0;
816
817 *err = EPROTO;
818
819 switch (type) {
820 case ICMPV6_DEST_UNREACH:
821 fatal = 1;
822 if (code <= ICMPV6_PORT_UNREACH) {
823 *err = tab_unreach[code].err;
824 fatal = tab_unreach[code].fatal;
825 }
826 break;
827
828 case ICMPV6_PKT_TOOBIG:
829 *err = EMSGSIZE;
830 break;
831
832 case ICMPV6_PARAMPROB:
833 *err = EPROTO;
834 fatal = 1;
835 break;
836
837 case ICMPV6_TIME_EXCEED:
838 *err = EHOSTUNREACH;
839 break;
840 };
841
842 return fatal;
843}
844
845#ifdef CONFIG_SYSCTL
846ctl_table ipv6_icmp_table[] = {
847 {
848 .ctl_name = NET_IPV6_ICMP_RATELIMIT,
849 .procname = "ratelimit",
850 .data = &sysctl_icmpv6_time,
851 .maxlen = sizeof(int),
852 .mode = 0644,
853 .proc_handler = &proc_dointvec
854 },
855 { .ctl_name = 0 },
856};
857#endif
858