ia64/linux-2.6.18-xen.hg

view net/ipv6/icmp.c @ 673:3161879fdf22

[IA64] xencomm: support XENMEM_add_to_physmap and XENMEM_remove_from_phsymap

support XENMEM_add_to_physmap and XENMEM_remove_from_phsymap.

Signed-off-by: Isaku Yamahata <yamahata@valinux.co.jp>
author Isaku Yamahata <yamahata@valinux.co.jp>
date Tue Sep 16 21:26:15 2008 +0900 (2008-09-16)
parents 831230e53067
children
line source
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 */
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 */
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 #include <linux/netfilter.h>
47 #ifdef CONFIG_SYSCTL
48 #include <linux/sysctl.h>
49 #endif
51 #include <linux/inet.h>
52 #include <linux/netdevice.h>
53 #include <linux/icmpv6.h>
55 #include <net/ip.h>
56 #include <net/sock.h>
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>
68 #include <asm/uaccess.h>
69 #include <asm/system.h>
71 DEFINE_SNMP_STAT(struct icmpv6_mib, icmpv6_statistics) __read_mostly;
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 */
80 static DEFINE_PER_CPU(struct socket *, __icmpv6_socket) = NULL;
81 #define icmpv6_socket __get_cpu_var(__icmpv6_socket)
83 static int icmpv6_rcv(struct sk_buff **pskb);
85 static struct inet6_protocol icmpv6_protocol = {
86 .handler = icmpv6_rcv,
87 .flags = INET6_PROTO_FINAL,
88 };
90 static __inline__ int icmpv6_xmit_lock(void)
91 {
92 local_bh_disable();
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 }
105 static __inline__ void icmpv6_xmit_unlock(void)
106 {
107 spin_unlock_bh(&icmpv6_socket->sk->sk_lock.slock);
108 }
110 /*
111 * Slightly more convenient version of icmpv6_send.
112 */
113 void 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 }
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 */
130 static 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;
136 if (len < 0)
137 return 1;
139 ptr = ipv6_skip_exthdr(skb, ptr, &nexthdr);
140 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 }
154 static int sysctl_icmpv6_time = 1*HZ;
156 /*
157 * Check the ICMP output rate limit
158 */
159 static inline int icmpv6_xrlim_allow(struct sock *sk, int type,
160 struct flowi *fl)
161 {
162 struct dst_entry *dst;
163 int res = 0;
165 /* Informational messages are not limited. */
166 if (type & ICMPV6_INFOMSG_MASK)
167 return 1;
169 /* Do not limit pmtu discovery, it would break it. */
170 if (type == ICMPV6_PKT_TOOBIG)
171 return 1;
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;
187 /* Give more bandwidth to wider prefixes. */
188 if (rt->rt6i_dst.plen < 128)
189 tmo >>= ((128 - rt->rt6i_dst.plen)>>5);
191 res = xrlim_allow(dst, tmo);
192 }
193 dst_release(dst);
194 return res;
195 }
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 */
204 static __inline__ int opt_unrec(struct sk_buff *skb, __u32 offset)
205 {
206 u8 _optval, *op;
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 }
215 static 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;
221 if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
222 goto out;
224 icmp6h = (struct icmp6hdr*) skb->h.raw;
225 memcpy(icmp6h, thdr, sizeof(struct icmp6hdr));
226 icmp6h->icmp6_cksum = 0;
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;
238 skb_queue_walk(&sk->sk_write_queue, skb) {
239 tmp_csum = csum_add(tmp_csum, skb->csum);
240 }
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);
252 out:
253 return err;
254 }
256 struct icmpv6_msg {
257 struct sk_buff *skb;
258 int offset;
259 uint8_t type;
260 };
262 static 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;
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);
271 if (!(msg->type & ICMPV6_INFOMSG_MASK))
272 nf_ct_attach(skb, org_skb);
273 return 0;
274 }
276 /*
277 * Send an ICMP message in response to a packet in error
278 */
279 void 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;
284 struct sock *sk;
285 struct ipv6_pinfo *np;
286 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;
294 int hlimit, tclass;
295 int err = 0;
297 if ((u8*)hdr < skb->head || (u8*)(hdr+1) > skb->tail)
298 return;
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);
308 if (ipv6_chk_addr(&hdr->daddr, skb->dev, 0))
309 saddr = &hdr->daddr;
311 /*
312 * Dest addr check
313 */
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;
322 saddr = NULL;
323 }
325 addr_type = ipv6_addr_type(&hdr->saddr);
327 /*
328 * Source addr check
329 */
331 if (addr_type & IPV6_ADDR_LINKLOCAL)
332 iif = skb->dev->ifindex;
334 /*
335 * 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.
339 */
340 if ((addr_type == IPV6_ADDR_ANY) || (addr_type & IPV6_ADDR_MULTICAST)) {
341 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: addr_any/mcast source\n");
342 return;
343 }
345 /*
346 * Never answer to a ICMP packet.
347 */
348 if (is_ineligible(skb)) {
349 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: no reply to icmp error\n");
350 return;
351 }
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;
362 if (icmpv6_xmit_lock())
363 return;
365 sk = icmpv6_socket->sk;
366 np = inet6_sk(sk);
368 if (!icmpv6_xrlim_allow(sk, type, &fl))
369 goto out;
371 tmp_hdr.icmp6_type = type;
372 tmp_hdr.icmp6_code = code;
373 tmp_hdr.icmp6_cksum = 0;
374 tmp_hdr.icmp6_pointer = htonl(info);
376 if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
377 fl.oif = np->mcast_oif;
379 err = ip6_dst_lookup(sk, &dst, &fl);
380 if (err)
381 goto out;
383 /*
384 * We won't send icmp if the destination is known
385 * anycast.
386 */
387 if (((struct rt6_info *)dst)->rt6i_flags & RTF_ANYCAST) {
388 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: acast source\n");
389 goto out_dst_release;
390 }
392 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
393 goto out;
395 if (ipv6_addr_is_multicast(&fl.fl6_dst))
396 hlimit = np->mcast_hops;
397 else
398 hlimit = np->hop_limit;
399 if (hlimit < 0)
400 hlimit = dst_metric(dst, RTAX_HOPLIMIT);
401 if (hlimit < 0)
402 hlimit = ipv6_get_hoplimit(dst->dev);
404 tclass = np->tclass;
405 if (tclass < 0)
406 tclass = 0;
408 msg.skb = skb;
409 msg.offset = skb->nh.raw - skb->data;
410 msg.type = type;
412 len = skb->len - msg.offset;
413 len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) -sizeof(struct icmp6hdr));
414 if (len < 0) {
415 LIMIT_NETDEBUG(KERN_DEBUG "icmp: len problem\n");
416 goto out_dst_release;
417 }
419 idev = in6_dev_get(skb->dev);
421 err = ip6_append_data(sk, icmpv6_getfrag, &msg,
422 len + sizeof(struct icmp6hdr),
423 sizeof(struct icmp6hdr),
424 hlimit, tclass, NULL, &fl, (struct rt6_info*)dst,
425 MSG_DONTWAIT);
426 if (err) {
427 ip6_flush_pending_frames(sk);
428 goto out_put;
429 }
430 err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, len + sizeof(struct icmp6hdr));
432 if (type >= ICMPV6_DEST_UNREACH && type <= ICMPV6_PARAMPROB)
433 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_OUTDESTUNREACHS, type - ICMPV6_DEST_UNREACH);
434 ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTMSGS);
436 out_put:
437 if (likely(idev != NULL))
438 in6_dev_put(idev);
439 out_dst_release:
440 dst_release(dst);
441 out:
442 icmpv6_xmit_unlock();
443 }
445 static void icmpv6_echo_reply(struct sk_buff *skb)
446 {
447 struct sock *sk;
448 struct inet6_dev *idev;
449 struct ipv6_pinfo *np;
450 struct in6_addr *saddr = NULL;
451 struct icmp6hdr *icmph = (struct icmp6hdr *) skb->h.raw;
452 struct icmp6hdr tmp_hdr;
453 struct flowi fl;
454 struct icmpv6_msg msg;
455 struct dst_entry *dst;
456 int err = 0;
457 int hlimit;
458 int tclass;
460 saddr = &skb->nh.ipv6h->daddr;
462 if (!ipv6_unicast_destination(skb))
463 saddr = NULL;
465 memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
466 tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;
468 memset(&fl, 0, sizeof(fl));
469 fl.proto = IPPROTO_ICMPV6;
470 ipv6_addr_copy(&fl.fl6_dst, &skb->nh.ipv6h->saddr);
471 if (saddr)
472 ipv6_addr_copy(&fl.fl6_src, saddr);
473 fl.oif = skb->dev->ifindex;
474 fl.fl_icmp_type = ICMPV6_ECHO_REPLY;
476 if (icmpv6_xmit_lock())
477 return;
479 sk = icmpv6_socket->sk;
480 np = inet6_sk(sk);
482 if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
483 fl.oif = np->mcast_oif;
485 err = ip6_dst_lookup(sk, &dst, &fl);
486 if (err)
487 goto out;
488 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
489 goto out;
491 if (ipv6_addr_is_multicast(&fl.fl6_dst))
492 hlimit = np->mcast_hops;
493 else
494 hlimit = np->hop_limit;
495 if (hlimit < 0)
496 hlimit = dst_metric(dst, RTAX_HOPLIMIT);
497 if (hlimit < 0)
498 hlimit = ipv6_get_hoplimit(dst->dev);
500 tclass = np->tclass;
501 if (tclass < 0)
502 tclass = 0;
504 idev = in6_dev_get(skb->dev);
506 msg.skb = skb;
507 msg.offset = 0;
508 msg.type = ICMPV6_ECHO_REPLY;
510 err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
511 sizeof(struct icmp6hdr), hlimit, tclass, NULL, &fl,
512 (struct rt6_info*)dst, MSG_DONTWAIT);
514 if (err) {
515 ip6_flush_pending_frames(sk);
516 goto out_put;
517 }
518 err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, skb->len + sizeof(struct icmp6hdr));
520 ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTECHOREPLIES);
521 ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTMSGS);
523 out_put:
524 if (likely(idev != NULL))
525 in6_dev_put(idev);
526 dst_release(dst);
527 out:
528 icmpv6_xmit_unlock();
529 }
531 static void icmpv6_notify(struct sk_buff *skb, int type, int code, u32 info)
532 {
533 struct in6_addr *saddr, *daddr;
534 struct inet6_protocol *ipprot;
535 struct sock *sk;
536 int inner_offset;
537 int hash;
538 u8 nexthdr;
540 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
541 return;
543 nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
544 if (ipv6_ext_hdr(nexthdr)) {
545 /* now skip over extension headers */
546 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr), &nexthdr);
547 if (inner_offset<0)
548 return;
549 } else {
550 inner_offset = sizeof(struct ipv6hdr);
551 }
553 /* Checkin header including 8 bytes of inner protocol header. */
554 if (!pskb_may_pull(skb, inner_offset+8))
555 return;
557 saddr = &skb->nh.ipv6h->saddr;
558 daddr = &skb->nh.ipv6h->daddr;
560 /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
561 Without this we will not able f.e. to make source routed
562 pmtu discovery.
563 Corresponding argument (opt) to notifiers is already added.
564 --ANK (980726)
565 */
567 hash = nexthdr & (MAX_INET_PROTOS - 1);
569 rcu_read_lock();
570 ipprot = rcu_dereference(inet6_protos[hash]);
571 if (ipprot && ipprot->err_handler)
572 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
573 rcu_read_unlock();
575 read_lock(&raw_v6_lock);
576 if ((sk = sk_head(&raw_v6_htable[hash])) != NULL) {
577 while((sk = __raw_v6_lookup(sk, nexthdr, daddr, saddr,
578 IP6CB(skb)->iif))) {
579 rawv6_err(sk, skb, NULL, type, code, inner_offset, info);
580 sk = sk_next(sk);
581 }
582 }
583 read_unlock(&raw_v6_lock);
584 }
586 /*
587 * Handle icmp messages
588 */
590 static int icmpv6_rcv(struct sk_buff **pskb)
591 {
592 struct sk_buff *skb = *pskb;
593 struct net_device *dev = skb->dev;
594 struct inet6_dev *idev = __in6_dev_get(dev);
595 struct in6_addr *saddr, *daddr;
596 struct ipv6hdr *orig_hdr;
597 struct icmp6hdr *hdr;
598 int type;
600 ICMP6_INC_STATS_BH(idev, ICMP6_MIB_INMSGS);
602 saddr = &skb->nh.ipv6h->saddr;
603 daddr = &skb->nh.ipv6h->daddr;
605 /* Perform checksum. */
606 switch (skb->ip_summed) {
607 case CHECKSUM_HW:
608 if (!csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
609 skb->csum))
610 break;
611 /* fall through */
612 case CHECKSUM_NONE:
613 skb->csum = ~csum_ipv6_magic(saddr, daddr, skb->len,
614 IPPROTO_ICMPV6, 0);
615 if (__skb_checksum_complete(skb)) {
616 LIMIT_NETDEBUG(KERN_DEBUG "ICMPv6 checksum failed [" NIP6_FMT " > " NIP6_FMT "]\n",
617 NIP6(*saddr), NIP6(*daddr));
618 goto discard_it;
619 }
620 }
622 if (!pskb_pull(skb, sizeof(struct icmp6hdr)))
623 goto discard_it;
625 hdr = (struct icmp6hdr *) skb->h.raw;
627 type = hdr->icmp6_type;
629 if (type >= ICMPV6_DEST_UNREACH && type <= ICMPV6_PARAMPROB)
630 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_INDESTUNREACHS, type - ICMPV6_DEST_UNREACH);
631 else if (type >= ICMPV6_ECHO_REQUEST && type <= NDISC_REDIRECT)
632 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_INECHOS, type - ICMPV6_ECHO_REQUEST);
634 switch (type) {
635 case ICMPV6_ECHO_REQUEST:
636 icmpv6_echo_reply(skb);
637 break;
639 case ICMPV6_ECHO_REPLY:
640 /* we couldn't care less */
641 break;
643 case ICMPV6_PKT_TOOBIG:
644 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
645 standard destination cache. Seems, only "advanced"
646 destination cache will allow to solve this problem
647 --ANK (980726)
648 */
649 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
650 goto discard_it;
651 hdr = (struct icmp6hdr *) skb->h.raw;
652 orig_hdr = (struct ipv6hdr *) (hdr + 1);
653 rt6_pmtu_discovery(&orig_hdr->daddr, &orig_hdr->saddr, dev,
654 ntohl(hdr->icmp6_mtu));
656 /*
657 * Drop through to notify
658 */
660 case ICMPV6_DEST_UNREACH:
661 case ICMPV6_TIME_EXCEED:
662 case ICMPV6_PARAMPROB:
663 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
664 break;
666 case NDISC_ROUTER_SOLICITATION:
667 case NDISC_ROUTER_ADVERTISEMENT:
668 case NDISC_NEIGHBOUR_SOLICITATION:
669 case NDISC_NEIGHBOUR_ADVERTISEMENT:
670 case NDISC_REDIRECT:
671 ndisc_rcv(skb);
672 break;
674 case ICMPV6_MGM_QUERY:
675 igmp6_event_query(skb);
676 break;
678 case ICMPV6_MGM_REPORT:
679 igmp6_event_report(skb);
680 break;
682 case ICMPV6_MGM_REDUCTION:
683 case ICMPV6_NI_QUERY:
684 case ICMPV6_NI_REPLY:
685 case ICMPV6_MLD2_REPORT:
686 case ICMPV6_DHAAD_REQUEST:
687 case ICMPV6_DHAAD_REPLY:
688 case ICMPV6_MOBILE_PREFIX_SOL:
689 case ICMPV6_MOBILE_PREFIX_ADV:
690 break;
692 default:
693 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6: msg of unknown type\n");
695 /* informational */
696 if (type & ICMPV6_INFOMSG_MASK)
697 break;
699 /*
700 * error of unknown type.
701 * must pass to upper level
702 */
704 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
705 };
706 kfree_skb(skb);
707 return 0;
709 discard_it:
710 ICMP6_INC_STATS_BH(idev, ICMP6_MIB_INERRORS);
711 kfree_skb(skb);
712 return 0;
713 }
715 /*
716 * Special lock-class for __icmpv6_socket:
717 */
718 static struct lock_class_key icmpv6_socket_sk_dst_lock_key;
720 int __init icmpv6_init(struct net_proto_family *ops)
721 {
722 struct sock *sk;
723 int err, i, j;
725 for_each_possible_cpu(i) {
726 err = sock_create_kern(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6,
727 &per_cpu(__icmpv6_socket, i));
728 if (err < 0) {
729 printk(KERN_ERR
730 "Failed to initialize the ICMP6 control socket "
731 "(err %d).\n",
732 err);
733 goto fail;
734 }
736 sk = per_cpu(__icmpv6_socket, i)->sk;
737 sk->sk_allocation = GFP_ATOMIC;
738 /*
739 * Split off their lock-class, because sk->sk_dst_lock
740 * gets used from softirqs, which is safe for
741 * __icmpv6_socket (because those never get directly used
742 * via userspace syscalls), but unsafe for normal sockets.
743 */
744 lockdep_set_class(&sk->sk_dst_lock,
745 &icmpv6_socket_sk_dst_lock_key);
747 /* Enough space for 2 64K ICMP packets, including
748 * sk_buff struct overhead.
749 */
750 sk->sk_sndbuf =
751 (2 * ((64 * 1024) + sizeof(struct sk_buff)));
753 sk->sk_prot->unhash(sk);
754 }
757 if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0) {
758 printk(KERN_ERR "Failed to register ICMP6 protocol\n");
759 err = -EAGAIN;
760 goto fail;
761 }
763 return 0;
765 fail:
766 for (j = 0; j < i; j++) {
767 if (!cpu_possible(j))
768 continue;
769 sock_release(per_cpu(__icmpv6_socket, j));
770 }
772 return err;
773 }
775 void icmpv6_cleanup(void)
776 {
777 int i;
779 for_each_possible_cpu(i) {
780 sock_release(per_cpu(__icmpv6_socket, i));
781 }
782 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
783 }
785 static const struct icmp6_err {
786 int err;
787 int fatal;
788 } tab_unreach[] = {
789 { /* NOROUTE */
790 .err = ENETUNREACH,
791 .fatal = 0,
792 },
793 { /* ADM_PROHIBITED */
794 .err = EACCES,
795 .fatal = 1,
796 },
797 { /* Was NOT_NEIGHBOUR, now reserved */
798 .err = EHOSTUNREACH,
799 .fatal = 0,
800 },
801 { /* ADDR_UNREACH */
802 .err = EHOSTUNREACH,
803 .fatal = 0,
804 },
805 { /* PORT_UNREACH */
806 .err = ECONNREFUSED,
807 .fatal = 1,
808 },
809 };
811 int icmpv6_err_convert(int type, int code, int *err)
812 {
813 int fatal = 0;
815 *err = EPROTO;
817 switch (type) {
818 case ICMPV6_DEST_UNREACH:
819 fatal = 1;
820 if (code <= ICMPV6_PORT_UNREACH) {
821 *err = tab_unreach[code].err;
822 fatal = tab_unreach[code].fatal;
823 }
824 break;
826 case ICMPV6_PKT_TOOBIG:
827 *err = EMSGSIZE;
828 break;
830 case ICMPV6_PARAMPROB:
831 *err = EPROTO;
832 fatal = 1;
833 break;
835 case ICMPV6_TIME_EXCEED:
836 *err = EHOSTUNREACH;
837 break;
838 };
840 return fatal;
841 }
843 #ifdef CONFIG_SYSCTL
844 ctl_table ipv6_icmp_table[] = {
845 {
846 .ctl_name = NET_IPV6_ICMP_RATELIMIT,
847 .procname = "ratelimit",
848 .data = &sysctl_icmpv6_time,
849 .maxlen = sizeof(int),
850 .mode = 0644,
851 .proc_handler = &proc_dointvec
852 },
853 { .ctl_name = 0 },
854 };
855 #endif