projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[IPV6]: Ensure to use icmpv6_socket in non-preemptive context.
[deliverable/linux.git] / net / ipv6 / icmp.c
CommitLineData
1da177e4
LT		 1/*
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>
45
46#ifdef CONFIG_SYSCTL
47#include <linux/sysctl.h>
48#endif
49
50#include <linux/inet.h>
51#include <linux/netdevice.h>
52#include <linux/icmpv6.h>
53
54#include <net/ip.h>
55#include <net/sock.h>
56
57#include <net/ipv6.h>
58#include <net/ip6_checksum.h>
59#include <net/protocol.h>
60#include <net/raw.h>
61#include <net/rawv6.h>
62#include <net/transp_v6.h>
63#include <net/ip6_route.h>
64#include <net/addrconf.h>
65#include <net/icmp.h>
66
67#include <asm/uaccess.h>
68#include <asm/system.h>
69
70DEFINE_SNMP_STAT(struct icmpv6_mib, icmpv6_statistics);
71
72/*
73 * The ICMP socket(s). This is the most convenient way to flow control
74 * our ICMP output as well as maintain a clean interface throughout
75 * all layers. All Socketless IP sends will soon be gone.
76 *
77 * On SMP we have one ICMP socket per-cpu.
78 */
79static DEFINE_PER_CPU(struct socket *, __icmpv6_socket) = NULL;
80#define icmpv6_socket __get_cpu_var(__icmpv6_socket)
81
82static int icmpv6_rcv(struct sk_buff **pskb, unsigned int *nhoffp);
83
84static struct inet6_protocol icmpv6_protocol = {
85 .handler = icmpv6_rcv,
86 .flags = INET6_PROTO_FINAL,
87};
88
89static __inline__ int icmpv6_xmit_lock(void)
90{
91 local_bh_disable();
92
93 if (unlikely(!spin_trylock(&icmpv6_socket->sk->sk_lock.slock))) {
94 /* This can happen if the output path (f.e. SIT or
95 * ip6ip6 tunnel) signals dst_link_failure() for an
96 * outgoing ICMP6 packet.
97 */
98 local_bh_enable();
99 return 1;
100 }
101 return 0;
102}
103
104static __inline__ void icmpv6_xmit_unlock(void)
105{
106 spin_unlock_bh(&icmpv6_socket->sk->sk_lock.slock);
107}
108
109/*
110 * Slightly more convenient version of icmpv6_send.
111 */
112void icmpv6_param_prob(struct sk_buff *skb, int code, int pos)
113{
114 icmpv6_send(skb, ICMPV6_PARAMPROB, code, pos, skb->dev);
115 kfree_skb(skb);
116}
117
118/*
119 * Figure out, may we reply to this packet with icmp error.
120 *
121 * We do not reply, if:
122 * - it was icmp error message.
123 * - it is truncated, so that it is known, that protocol is ICMPV6
124 * (i.e. in the middle of some exthdr)
125 *
126 * --ANK (980726)
127 */
128
129static int is_ineligible(struct sk_buff *skb)
130{
131 int ptr = (u8*)(skb->nh.ipv6h+1) - skb->data;
132 int len = skb->len - ptr;
133 __u8 nexthdr = skb->nh.ipv6h->nexthdr;
134
135 if (len < 0)
136 return 1;
137
0d3d077c 138 ptr = ipv6_skip_exthdr(skb, ptr, &nexthdr);
1da177e4
LT		 139 if (ptr < 0)
140 return 0;
141 if (nexthdr == IPPROTO_ICMPV6) {
142 u8 _type, *tp;
143 tp = skb_header_pointer(skb,
144 ptr+offsetof(struct icmp6hdr, icmp6_type),
145 sizeof(_type), &_type);
146 if (tp == NULL ||
147 !(*tp & ICMPV6_INFOMSG_MASK))
148 return 1;
149 }
150 return 0;
151}
152
153static int sysctl_icmpv6_time = 1*HZ;
154
155/*
156 * Check the ICMP output rate limit
157 */
158static inline int icmpv6_xrlim_allow(struct sock *sk, int type,
159 struct flowi *fl)
160{
161 struct dst_entry *dst;
162 int res = 0;
163
164 /* Informational messages are not limited. */
165 if (type & ICMPV6_INFOMSG_MASK)
166 return 1;
167
168 /* Do not limit pmtu discovery, it would break it. */
169 if (type == ICMPV6_PKT_TOOBIG)
170 return 1;
171
172 /*
173 * Look up the output route.
174 * XXX: perhaps the expire for routing entries cloned by
175 * this lookup should be more aggressive (not longer than timeout).
176 */
177 dst = ip6_route_output(sk, fl);
178 if (dst->error) {
179 IP6_INC_STATS(IPSTATS_MIB_OUTNOROUTES);
180 } else if (dst->dev && (dst->dev->flags&IFF_LOOPBACK)) {
181 res = 1;
182 } else {
183 struct rt6_info *rt = (struct rt6_info *)dst;
184 int tmo = sysctl_icmpv6_time;
185
186 /* Give more bandwidth to wider prefixes. */
187 if (rt->rt6i_dst.plen < 128)
188 tmo >>= ((128 - rt->rt6i_dst.plen)>>5);
189
190 res = xrlim_allow(dst, tmo);
191 }
192 dst_release(dst);
193 return res;
194}
195
196/*
197 * an inline helper for the "simple" if statement below
198 * checks if parameter problem report is caused by an
199 * unrecognized IPv6 option that has the Option Type
200 * highest-order two bits set to 10
201 */
202
203static __inline__ int opt_unrec(struct sk_buff *skb, __u32 offset)
204{
205 u8 _optval, *op;
206
207 offset += skb->nh.raw - skb->data;
208 op = skb_header_pointer(skb, offset, sizeof(_optval), &_optval);
209 if (op == NULL)
210 return 1;
211 return (*op & 0xC0) == 0x80;
212}
213
214static int icmpv6_push_pending_frames(struct sock *sk, struct flowi *fl, struct icmp6hdr *thdr, int len)
215{
216 struct sk_buff *skb;
217 struct icmp6hdr *icmp6h;
218 int err = 0;
219
220 if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
221 goto out;
222
223 icmp6h = (struct icmp6hdr*) skb->h.raw;
224 memcpy(icmp6h, thdr, sizeof(struct icmp6hdr));
225 icmp6h->icmp6_cksum = 0;
226
227 if (skb_queue_len(&sk->sk_write_queue) == 1) {
228 skb->csum = csum_partial((char *)icmp6h,
229 sizeof(struct icmp6hdr), skb->csum);
230 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl->fl6_src,
231 &fl->fl6_dst,
232 len, fl->proto,
233 skb->csum);
234 } else {
235 u32 tmp_csum = 0;
236
237 skb_queue_walk(&sk->sk_write_queue, skb) {
238 tmp_csum = csum_add(tmp_csum, skb->csum);
239 }
240
241 tmp_csum = csum_partial((char *)icmp6h,
242 sizeof(struct icmp6hdr), tmp_csum);
243 tmp_csum = csum_ipv6_magic(&fl->fl6_src,
244 &fl->fl6_dst,
245 len, fl->proto, tmp_csum);
246 icmp6h->icmp6_cksum = tmp_csum;
247 }
248 if (icmp6h->icmp6_cksum == 0)
249 icmp6h->icmp6_cksum = -1;
250 ip6_push_pending_frames(sk);
251out:
252 return err;
253}
254
255struct icmpv6_msg {
256 struct sk_buff *skb;
257 int offset;
258};
259
260static int icmpv6_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb)
261{
262 struct icmpv6_msg *msg = (struct icmpv6_msg *) from;
263 struct sk_buff *org_skb = msg->skb;
264 __u32 csum = 0;
265
266 csum = skb_copy_and_csum_bits(org_skb, msg->offset + offset,
267 to, len, csum);
268 skb->csum = csum_block_add(skb->csum, csum, odd);
269 return 0;
270}
271
272/*
273 * Send an ICMP message in response to a packet in error
274 */
275void icmpv6_send(struct sk_buff *skb, int type, int code, __u32 info,
276 struct net_device *dev)
277{
278 struct inet6_dev *idev = NULL;
279 struct ipv6hdr *hdr = skb->nh.ipv6h;
84427d53
YH		 280 struct sock *sk;
281 struct ipv6_pinfo *np;
1da177e4
LT		 282 struct in6_addr *saddr = NULL;
283 struct dst_entry *dst;
284 struct icmp6hdr tmp_hdr;
285 struct flowi fl;
286 struct icmpv6_msg msg;
287 int iif = 0;
288 int addr_type = 0;
289 int len;
290 int hlimit;
291 int err = 0;
292
293 if ((u8*)hdr < skb->head || (u8*)(hdr+1) > skb->tail)
294 return;
295
296 /*
297 * Make sure we respect the rules
298 * i.e. RFC 1885 2.4(e)
299 * Rule (e.1) is enforced by not using icmpv6_send
300 * in any code that processes icmp errors.
301 */
302 addr_type = ipv6_addr_type(&hdr->daddr);
303
304 if (ipv6_chk_addr(&hdr->daddr, skb->dev, 0))
305 saddr = &hdr->daddr;
306
307 /*
308 * Dest addr check
309 */
310
311 if ((addr_type & IPV6_ADDR_MULTICAST || skb->pkt_type != PACKET_HOST)) {
312 if (type != ICMPV6_PKT_TOOBIG &&
313 !(type == ICMPV6_PARAMPROB &&
314 code == ICMPV6_UNK_OPTION &&
315 (opt_unrec(skb, info))))
316 return;
317
318 saddr = NULL;
319 }
320
321 addr_type = ipv6_addr_type(&hdr->saddr);
322
323 /*
324 * Source addr check
325 */
326
327 if (addr_type & IPV6_ADDR_LINKLOCAL)
328 iif = skb->dev->ifindex;
329
330 /*
331 * Must not send if we know that source is Anycast also.
332 * for now we don't know that.
333 */
334 if ((addr_type == IPV6_ADDR_ANY) || (addr_type & IPV6_ADDR_MULTICAST)) {
335 LIMIT_NETDEBUG(
336 printk(KERN_DEBUG "icmpv6_send: addr_any/mcast source\n"));
337 return;
338 }
339
340 /*
341 * Never answer to a ICMP packet.
342 */
343 if (is_ineligible(skb)) {
344 LIMIT_NETDEBUG(
345 printk(KERN_DEBUG "icmpv6_send: no reply to icmp error\n"));
346 return;
347 }
348
349 memset(&fl, 0, sizeof(fl));
350 fl.proto = IPPROTO_ICMPV6;
351 ipv6_addr_copy(&fl.fl6_dst, &hdr->saddr);
352 if (saddr)
353 ipv6_addr_copy(&fl.fl6_src, saddr);
354 fl.oif = iif;
355 fl.fl_icmp_type = type;
356 fl.fl_icmp_code = code;
357
358 if (icmpv6_xmit_lock())
359 return;
360
84427d53
YH		 361 sk = icmpv6_socket->sk;
362 np = inet6_sk(sk);
363
1da177e4
LT		 364 if (!icmpv6_xrlim_allow(sk, type, &fl))
365 goto out;
366
367 tmp_hdr.icmp6_type = type;
368 tmp_hdr.icmp6_code = code;
369 tmp_hdr.icmp6_cksum = 0;
370 tmp_hdr.icmp6_pointer = htonl(info);
371
372 if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
373 fl.oif = np->mcast_oif;
374
375 err = ip6_dst_lookup(sk, &dst, &fl);
376 if (err)
377 goto out;
378 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
379 goto out_dst_release;
380
381 if (ipv6_addr_is_multicast(&fl.fl6_dst))
382 hlimit = np->mcast_hops;
383 else
384 hlimit = np->hop_limit;
385 if (hlimit < 0)
386 hlimit = dst_metric(dst, RTAX_HOPLIMIT);
387 if (hlimit < 0)
388 hlimit = ipv6_get_hoplimit(dst->dev);
389
390 msg.skb = skb;
391 msg.offset = skb->nh.raw - skb->data;
392
393 len = skb->len - msg.offset;
394 len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) -sizeof(struct icmp6hdr));
395 if (len < 0) {
396 LIMIT_NETDEBUG(
397 printk(KERN_DEBUG "icmp: len problem\n"));
398 goto out_dst_release;
399 }
400
401 idev = in6_dev_get(skb->dev);
402
403 err = ip6_append_data(sk, icmpv6_getfrag, &msg,
404 len + sizeof(struct icmp6hdr),
405 sizeof(struct icmp6hdr),
406 hlimit, NULL, &fl, (struct rt6_info*)dst,
407 MSG_DONTWAIT);
408 if (err) {
409 ip6_flush_pending_frames(sk);
410 goto out_put;
411 }
412 err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, len + sizeof(struct icmp6hdr));
413
414 if (type >= ICMPV6_DEST_UNREACH && type <= ICMPV6_PARAMPROB)
415 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_OUTDESTUNREACHS, type - ICMPV6_DEST_UNREACH);
416 ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTMSGS);
417
418out_put:
419 if (likely(idev != NULL))
420 in6_dev_put(idev);
421out_dst_release:
422 dst_release(dst);
423out:
424 icmpv6_xmit_unlock();
425}
426
427static void icmpv6_echo_reply(struct sk_buff *skb)
428{
84427d53 429 struct sock *sk;
1da177e4 430 struct inet6_dev *idev;
84427d53 431 struct ipv6_pinfo *np;
1da177e4
LT		 432 struct in6_addr *saddr = NULL;
433 struct icmp6hdr *icmph = (struct icmp6hdr *) skb->h.raw;
434 struct icmp6hdr tmp_hdr;
435 struct flowi fl;
436 struct icmpv6_msg msg;
437 struct dst_entry *dst;
438 int err = 0;
439 int hlimit;
440
441 saddr = &skb->nh.ipv6h->daddr;
442
443 if (!ipv6_unicast_destination(skb))
444 saddr = NULL;
445
446 memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
447 tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;
448
449 memset(&fl, 0, sizeof(fl));
450 fl.proto = IPPROTO_ICMPV6;
451 ipv6_addr_copy(&fl.fl6_dst, &skb->nh.ipv6h->saddr);
452 if (saddr)
453 ipv6_addr_copy(&fl.fl6_src, saddr);
454 fl.oif = skb->dev->ifindex;
455 fl.fl_icmp_type = ICMPV6_ECHO_REPLY;
456
457 if (icmpv6_xmit_lock())
458 return;
459
84427d53
YH		 460 sk = icmpv6_socket->sk;
461 np = inet6_sk(sk);
462
1da177e4
LT		 463 if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
464 fl.oif = np->mcast_oif;
465
466 err = ip6_dst_lookup(sk, &dst, &fl);
467 if (err)
468 goto out;
469 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
470 goto out_dst_release;
471
472 if (ipv6_addr_is_multicast(&fl.fl6_dst))
473 hlimit = np->mcast_hops;
474 else
475 hlimit = np->hop_limit;
476 if (hlimit < 0)
477 hlimit = dst_metric(dst, RTAX_HOPLIMIT);
478 if (hlimit < 0)
479 hlimit = ipv6_get_hoplimit(dst->dev);
480
481 idev = in6_dev_get(skb->dev);
482
483 msg.skb = skb;
484 msg.offset = 0;
485
486 err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
487 sizeof(struct icmp6hdr), hlimit, NULL, &fl,
488 (struct rt6_info*)dst, MSG_DONTWAIT);
489
490 if (err) {
491 ip6_flush_pending_frames(sk);
492 goto out_put;
493 }
494 err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, skb->len + sizeof(struct icmp6hdr));
495
496 ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTECHOREPLIES);
497 ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTMSGS);
498
499out_put:
500 if (likely(idev != NULL))
501 in6_dev_put(idev);
502out_dst_release:
503 dst_release(dst);
504out:
505 icmpv6_xmit_unlock();
506}
507
508static void icmpv6_notify(struct sk_buff *skb, int type, int code, u32 info)
509{
510 struct in6_addr *saddr, *daddr;
511 struct inet6_protocol *ipprot;
512 struct sock *sk;
513 int inner_offset;
514 int hash;
515 u8 nexthdr;
516
517 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
518 return;
519
520 nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
521 if (ipv6_ext_hdr(nexthdr)) {
522 /* now skip over extension headers */
0d3d077c 523 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr), &nexthdr);
1da177e4
LT		 524 if (inner_offset<0)
525 return;
526 } else {
527 inner_offset = sizeof(struct ipv6hdr);
528 }
529
530 /* Checkin header including 8 bytes of inner protocol header. */
531 if (!pskb_may_pull(skb, inner_offset+8))
532 return;
533
534 saddr = &skb->nh.ipv6h->saddr;
535 daddr = &skb->nh.ipv6h->daddr;
536
537 /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
538 Without this we will not able f.e. to make source routed
539 pmtu discovery.
540 Corresponding argument (opt) to notifiers is already added.
541 --ANK (980726)
542 */
543
544 hash = nexthdr & (MAX_INET_PROTOS - 1);
545
546 rcu_read_lock();
547 ipprot = rcu_dereference(inet6_protos[hash]);
548 if (ipprot && ipprot->err_handler)
549 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
550 rcu_read_unlock();
551
552 read_lock(&raw_v6_lock);
553 if ((sk = sk_head(&raw_v6_htable[hash])) != NULL) {
554 while((sk = __raw_v6_lookup(sk, nexthdr, daddr, saddr))) {
555 rawv6_err(sk, skb, NULL, type, code, inner_offset, info);
556 sk = sk_next(sk);
557 }
558 }
559 read_unlock(&raw_v6_lock);
560}
561
562/*
563 * Handle icmp messages
564 */
565
566static int icmpv6_rcv(struct sk_buff **pskb, unsigned int *nhoffp)
567{
568 struct sk_buff *skb = *pskb;
569 struct net_device *dev = skb->dev;
570 struct inet6_dev *idev = __in6_dev_get(dev);
571 struct in6_addr *saddr, *daddr;
572 struct ipv6hdr *orig_hdr;
573 struct icmp6hdr *hdr;
574 int type;
575
576 ICMP6_INC_STATS_BH(idev, ICMP6_MIB_INMSGS);
577
578 saddr = &skb->nh.ipv6h->saddr;
579 daddr = &skb->nh.ipv6h->daddr;
580
581 /* Perform checksum. */
582 if (skb->ip_summed == CHECKSUM_HW) {
583 skb->ip_summed = CHECKSUM_UNNECESSARY;
584 if (csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
585 skb->csum)) {
586 LIMIT_NETDEBUG(
587 printk(KERN_DEBUG "ICMPv6 hw checksum failed\n"));
588 skb->ip_summed = CHECKSUM_NONE;
589 }
590 }
591 if (skb->ip_summed == CHECKSUM_NONE) {
592 if (csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
593 skb_checksum(skb, 0, skb->len, 0))) {
594 LIMIT_NETDEBUG(
595 printk(KERN_DEBUG "ICMPv6 checksum failed [%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x > %04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x]\n",
596 NIP6(*saddr), NIP6(*daddr)));
597 goto discard_it;
598 }
599 }
600
601 if (!pskb_pull(skb, sizeof(struct icmp6hdr)))
602 goto discard_it;
603
604 hdr = (struct icmp6hdr *) skb->h.raw;
605
606 type = hdr->icmp6_type;
607
608 if (type >= ICMPV6_DEST_UNREACH && type <= ICMPV6_PARAMPROB)
609 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_INDESTUNREACHS, type - ICMPV6_DEST_UNREACH);
610 else if (type >= ICMPV6_ECHO_REQUEST && type <= NDISC_REDIRECT)
611 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_INECHOS, type - ICMPV6_ECHO_REQUEST);
612
613 switch (type) {
614 case ICMPV6_ECHO_REQUEST:
615 icmpv6_echo_reply(skb);
616 break;
617
618 case ICMPV6_ECHO_REPLY:
619 /* we couldn't care less */
620 break;
621
622 case ICMPV6_PKT_TOOBIG:
623 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
624 standard destination cache. Seems, only "advanced"
625 destination cache will allow to solve this problem
626 --ANK (980726)
627 */
628 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
629 goto discard_it;
630 hdr = (struct icmp6hdr *) skb->h.raw;
631 orig_hdr = (struct ipv6hdr *) (hdr + 1);
632 rt6_pmtu_discovery(&orig_hdr->daddr, &orig_hdr->saddr, dev,
633 ntohl(hdr->icmp6_mtu));
634
635 /*
636 * Drop through to notify
637 */
638
639 case ICMPV6_DEST_UNREACH:
640 case ICMPV6_TIME_EXCEED:
641 case ICMPV6_PARAMPROB:
642 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
643 break;
644
645 case NDISC_ROUTER_SOLICITATION:
646 case NDISC_ROUTER_ADVERTISEMENT:
647 case NDISC_NEIGHBOUR_SOLICITATION:
648 case NDISC_NEIGHBOUR_ADVERTISEMENT:
649 case NDISC_REDIRECT:
650 ndisc_rcv(skb);
651 break;
652
653 case ICMPV6_MGM_QUERY:
654 igmp6_event_query(skb);
655 break;
656
657 case ICMPV6_MGM_REPORT:
658 igmp6_event_report(skb);
659 break;
660
661 case ICMPV6_MGM_REDUCTION:
662 case ICMPV6_NI_QUERY:
663 case ICMPV6_NI_REPLY:
664 case ICMPV6_MLD2_REPORT:
665 case ICMPV6_DHAAD_REQUEST:
666 case ICMPV6_DHAAD_REPLY:
667 case ICMPV6_MOBILE_PREFIX_SOL:
668 case ICMPV6_MOBILE_PREFIX_ADV:
669 break;
670
671 default:
672 LIMIT_NETDEBUG(
673 printk(KERN_DEBUG "icmpv6: msg of unknown type\n"));
674
675 /* informational */
676 if (type & ICMPV6_INFOMSG_MASK)
677 break;
678
679 /*
680 * error of unknown type.
681 * must pass to upper level
682 */
683
684 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
685 };
686 kfree_skb(skb);
687 return 0;
688
689discard_it:
690 ICMP6_INC_STATS_BH(idev, ICMP6_MIB_INERRORS);
691 kfree_skb(skb);
692 return 0;
693}
694
695int __init icmpv6_init(struct net_proto_family *ops)
696{
697 struct sock *sk;
698 int err, i, j;
699
700 for (i = 0; i < NR_CPUS; i++) {
701 if (!cpu_possible(i))
702 continue;
703
704 err = sock_create_kern(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6,
705 &per_cpu(__icmpv6_socket, i));
706 if (err < 0) {
707 printk(KERN_ERR
708 "Failed to initialize the ICMP6 control socket "
709 "(err %d).\n",
710 err);
711 goto fail;
712 }
713
714 sk = per_cpu(__icmpv6_socket, i)->sk;
715 sk->sk_allocation = GFP_ATOMIC;
716
717 /* Enough space for 2 64K ICMP packets, including
718 * sk_buff struct overhead.
719 */
720 sk->sk_sndbuf =
721 (2 * ((64 * 1024) + sizeof(struct sk_buff)));
722
723 sk->sk_prot->unhash(sk);
724 }
725
726
727 if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0) {
728 printk(KERN_ERR "Failed to register ICMP6 protocol\n");
729 err = -EAGAIN;
730 goto fail;
731 }
732
733 return 0;
734
735 fail:
736 for (j = 0; j < i; j++) {
737 if (!cpu_possible(j))
738 continue;
739 sock_release(per_cpu(__icmpv6_socket, j));
740 }
741
742 return err;
743}
744
745void icmpv6_cleanup(void)
746{
747 int i;
748
749 for (i = 0; i < NR_CPUS; i++) {
750 if (!cpu_possible(i))
751 continue;
752 sock_release(per_cpu(__icmpv6_socket, i));
753 }
754 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
755}
756
757static struct icmp6_err {
758 int err;
759 int fatal;
760} tab_unreach[] = {
761 { /* NOROUTE */
762 .err = ENETUNREACH,
763 .fatal = 0,
764 },
765 { /* ADM_PROHIBITED */
766 .err = EACCES,
767 .fatal = 1,
768 },
769 { /* Was NOT_NEIGHBOUR, now reserved */
770 .err = EHOSTUNREACH,
771 .fatal = 0,
772 },
773 { /* ADDR_UNREACH */
774 .err = EHOSTUNREACH,
775 .fatal = 0,
776 },
777 { /* PORT_UNREACH */
778 .err = ECONNREFUSED,
779 .fatal = 1,
780 },
781};
782
783int icmpv6_err_convert(int type, int code, int *err)
784{
785 int fatal = 0;
786
787 *err = EPROTO;
788
789 switch (type) {
790 case ICMPV6_DEST_UNREACH:
791 fatal = 1;
792 if (code <= ICMPV6_PORT_UNREACH) {
793 *err = tab_unreach[code].err;
794 fatal = tab_unreach[code].fatal;
795 }
796 break;
797
798 case ICMPV6_PKT_TOOBIG:
799 *err = EMSGSIZE;
800 break;
801
802 case ICMPV6_PARAMPROB:
803 *err = EPROTO;
804 fatal = 1;
805 break;
806
807 case ICMPV6_TIME_EXCEED:
808 *err = EHOSTUNREACH;
809 break;
810 };
811
812 return fatal;
813}
814
815#ifdef CONFIG_SYSCTL
816ctl_table ipv6_icmp_table[] = {
817 {
818 .ctl_name = NET_IPV6_ICMP_RATELIMIT,
819 .procname = "ratelimit",
820 .data = &sysctl_icmpv6_time,
821 .maxlen = sizeof(int),
822 .mode = 0644,
823 .proc_handler = &proc_dointvec
824 },
825 { .ctl_name = 0 },
826};
827#endif
828
Linux kernel - Deliverables
This page took 0.068089 seconds and 5 git commands to generate.