[PATCH] remove many unneeded #includes of sched.h
[linux-2.6.git] / net / ipv6 / icmp.c
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/sockios.h>
41 #include <linux/net.h>
42 #include <linux/skbuff.h>
43 #include <linux/init.h>
44 #include <linux/netfilter.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
70 DEFINE_SNMP_STAT(struct icmpv6_mib, icmpv6_statistics) __read_mostly;
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  */
79 static DEFINE_PER_CPU(struct socket *, __icmpv6_socket) = NULL;
80 #define icmpv6_socket   __get_cpu_var(__icmpv6_socket)
81
82 static int icmpv6_rcv(struct sk_buff **pskb);
83
84 static struct inet6_protocol icmpv6_protocol = {
85         .handler        =       icmpv6_rcv,
86         .flags          =       INET6_PROTO_FINAL,
87 };
88
89 static __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
104 static __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  */
112 void 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
129 static 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
138         ptr = ipv6_skip_exthdr(skb, ptr, &nexthdr);
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
153 static int sysctl_icmpv6_time __read_mostly = 1*HZ;
154
155 /*
156  * Check the ICMP output rate limit
157  */
158 static 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(ip6_dst_idev(dst),
180                               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
204 static __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
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;
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                 __wsum 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                 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl->fl6_src,
245                                                       &fl->fl6_dst,
246                                                       len, fl->proto,
247                                                       tmp_csum);
248         }
249         ip6_push_pending_frames(sk);
250 out:
251         return err;
252 }
253
254 struct icmpv6_msg {
255         struct sk_buff  *skb;
256         int             offset;
257         uint8_t         type;
258 };
259
260 static 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         __wsum 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         if (!(msg->type & ICMPV6_INFOMSG_MASK))
270                 nf_ct_attach(skb, org_skb);
271         return 0;
272 }
273
274 #ifdef CONFIG_IPV6_MIP6
275 static void mip6_addr_swap(struct sk_buff *skb)
276 {
277         struct ipv6hdr *iph = skb->nh.ipv6h;
278         struct inet6_skb_parm *opt = IP6CB(skb);
279         struct ipv6_destopt_hao *hao;
280         struct in6_addr tmp;
281         int off;
282
283         if (opt->dsthao) {
284                 off = ipv6_find_tlv(skb, opt->dsthao, IPV6_TLV_HAO);
285                 if (likely(off >= 0)) {
286                         hao = (struct ipv6_destopt_hao *)(skb->nh.raw + off);
287                         ipv6_addr_copy(&tmp, &iph->saddr);
288                         ipv6_addr_copy(&iph->saddr, &hao->addr);
289                         ipv6_addr_copy(&hao->addr, &tmp);
290                 }
291         }
292 }
293 #else
294 static inline void mip6_addr_swap(struct sk_buff *skb) {}
295 #endif
296
297 /*
298  *      Send an ICMP message in response to a packet in error
299  */
300 void icmpv6_send(struct sk_buff *skb, int type, int code, __u32 info,
301                  struct net_device *dev)
302 {
303         struct inet6_dev *idev = NULL;
304         struct ipv6hdr *hdr = skb->nh.ipv6h;
305         struct sock *sk;
306         struct ipv6_pinfo *np;
307         struct in6_addr *saddr = NULL;
308         struct dst_entry *dst;
309         struct icmp6hdr tmp_hdr;
310         struct flowi fl;
311         struct icmpv6_msg msg;
312         int iif = 0;
313         int addr_type = 0;
314         int len;
315         int hlimit, tclass;
316         int err = 0;
317
318         if ((u8*)hdr < skb->head || (u8*)(hdr+1) > skb->tail)
319                 return;
320
321         /*
322          *      Make sure we respect the rules
323          *      i.e. RFC 1885 2.4(e)
324          *      Rule (e.1) is enforced by not using icmpv6_send
325          *      in any code that processes icmp errors.
326          */
327         addr_type = ipv6_addr_type(&hdr->daddr);
328
329         if (ipv6_chk_addr(&hdr->daddr, skb->dev, 0))
330                 saddr = &hdr->daddr;
331
332         /*
333          *      Dest addr check
334          */
335
336         if ((addr_type & IPV6_ADDR_MULTICAST || skb->pkt_type != PACKET_HOST)) {
337                 if (type != ICMPV6_PKT_TOOBIG &&
338                     !(type == ICMPV6_PARAMPROB &&
339                       code == ICMPV6_UNK_OPTION &&
340                       (opt_unrec(skb, info))))
341                         return;
342
343                 saddr = NULL;
344         }
345
346         addr_type = ipv6_addr_type(&hdr->saddr);
347
348         /*
349          *      Source addr check
350          */
351
352         if (addr_type & IPV6_ADDR_LINKLOCAL)
353                 iif = skb->dev->ifindex;
354
355         /*
356          *      Must not send error if the source does not uniquely
357          *      identify a single node (RFC2463 Section 2.4).
358          *      We check unspecified / multicast addresses here,
359          *      and anycast addresses will be checked later.
360          */
361         if ((addr_type == IPV6_ADDR_ANY) || (addr_type & IPV6_ADDR_MULTICAST)) {
362                 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: addr_any/mcast source\n");
363                 return;
364         }
365
366         /*
367          *      Never answer to a ICMP packet.
368          */
369         if (is_ineligible(skb)) {
370                 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: no reply to icmp error\n");
371                 return;
372         }
373
374         mip6_addr_swap(skb);
375
376         memset(&fl, 0, sizeof(fl));
377         fl.proto = IPPROTO_ICMPV6;
378         ipv6_addr_copy(&fl.fl6_dst, &hdr->saddr);
379         if (saddr)
380                 ipv6_addr_copy(&fl.fl6_src, saddr);
381         fl.oif = iif;
382         fl.fl_icmp_type = type;
383         fl.fl_icmp_code = code;
384         security_skb_classify_flow(skb, &fl);
385
386         if (icmpv6_xmit_lock())
387                 return;
388
389         sk = icmpv6_socket->sk;
390         np = inet6_sk(sk);
391
392         if (!icmpv6_xrlim_allow(sk, type, &fl))
393                 goto out;
394
395         tmp_hdr.icmp6_type = type;
396         tmp_hdr.icmp6_code = code;
397         tmp_hdr.icmp6_cksum = 0;
398         tmp_hdr.icmp6_pointer = htonl(info);
399
400         if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
401                 fl.oif = np->mcast_oif;
402
403         err = ip6_dst_lookup(sk, &dst, &fl);
404         if (err)
405                 goto out;
406
407         /*
408          * We won't send icmp if the destination is known
409          * anycast.
410          */
411         if (((struct rt6_info *)dst)->rt6i_flags & RTF_ANYCAST) {
412                 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: acast source\n");
413                 goto out_dst_release;
414         }
415
416         if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
417                 goto out;
418
419         if (ipv6_addr_is_multicast(&fl.fl6_dst))
420                 hlimit = np->mcast_hops;
421         else
422                 hlimit = np->hop_limit;
423         if (hlimit < 0)
424                 hlimit = dst_metric(dst, RTAX_HOPLIMIT);
425         if (hlimit < 0)
426                 hlimit = ipv6_get_hoplimit(dst->dev);
427
428         tclass = np->tclass;
429         if (tclass < 0)
430                 tclass = 0;
431
432         msg.skb = skb;
433         msg.offset = skb->nh.raw - skb->data;
434         msg.type = type;
435
436         len = skb->len - msg.offset;
437         len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) -sizeof(struct icmp6hdr));
438         if (len < 0) {
439                 LIMIT_NETDEBUG(KERN_DEBUG "icmp: len problem\n");
440                 goto out_dst_release;
441         }
442
443         idev = in6_dev_get(skb->dev);
444
445         err = ip6_append_data(sk, icmpv6_getfrag, &msg,
446                               len + sizeof(struct icmp6hdr),
447                               sizeof(struct icmp6hdr),
448                               hlimit, tclass, NULL, &fl, (struct rt6_info*)dst,
449                               MSG_DONTWAIT);
450         if (err) {
451                 ip6_flush_pending_frames(sk);
452                 goto out_put;
453         }
454         err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, len + sizeof(struct icmp6hdr));
455
456         if (type >= ICMPV6_DEST_UNREACH && type <= ICMPV6_PARAMPROB)
457                 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_OUTDESTUNREACHS, type - ICMPV6_DEST_UNREACH);
458         ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTMSGS);
459
460 out_put:
461         if (likely(idev != NULL))
462                 in6_dev_put(idev);
463 out_dst_release:
464         dst_release(dst);
465 out:
466         icmpv6_xmit_unlock();
467 }
468
469 static void icmpv6_echo_reply(struct sk_buff *skb)
470 {
471         struct sock *sk;
472         struct inet6_dev *idev;
473         struct ipv6_pinfo *np;
474         struct in6_addr *saddr = NULL;
475         struct icmp6hdr *icmph = (struct icmp6hdr *) skb->h.raw;
476         struct icmp6hdr tmp_hdr;
477         struct flowi fl;
478         struct icmpv6_msg msg;
479         struct dst_entry *dst;
480         int err = 0;
481         int hlimit;
482         int tclass;
483
484         saddr = &skb->nh.ipv6h->daddr;
485
486         if (!ipv6_unicast_destination(skb))
487                 saddr = NULL;
488
489         memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
490         tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;
491
492         memset(&fl, 0, sizeof(fl));
493         fl.proto = IPPROTO_ICMPV6;
494         ipv6_addr_copy(&fl.fl6_dst, &skb->nh.ipv6h->saddr);
495         if (saddr)
496                 ipv6_addr_copy(&fl.fl6_src, saddr);
497         fl.oif = skb->dev->ifindex;
498         fl.fl_icmp_type = ICMPV6_ECHO_REPLY;
499         security_skb_classify_flow(skb, &fl);
500
501         if (icmpv6_xmit_lock())
502                 return;
503
504         sk = icmpv6_socket->sk;
505         np = inet6_sk(sk);
506
507         if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
508                 fl.oif = np->mcast_oif;
509
510         err = ip6_dst_lookup(sk, &dst, &fl);
511         if (err)
512                 goto out;
513         if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
514                 goto out;
515
516         if (ipv6_addr_is_multicast(&fl.fl6_dst))
517                 hlimit = np->mcast_hops;
518         else
519                 hlimit = np->hop_limit;
520         if (hlimit < 0)
521                 hlimit = dst_metric(dst, RTAX_HOPLIMIT);
522         if (hlimit < 0)
523                 hlimit = ipv6_get_hoplimit(dst->dev);
524
525         tclass = np->tclass;
526         if (tclass < 0)
527                 tclass = 0;
528
529         idev = in6_dev_get(skb->dev);
530
531         msg.skb = skb;
532         msg.offset = 0;
533         msg.type = ICMPV6_ECHO_REPLY;
534
535         err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
536                                 sizeof(struct icmp6hdr), hlimit, tclass, NULL, &fl,
537                                 (struct rt6_info*)dst, MSG_DONTWAIT);
538
539         if (err) {
540                 ip6_flush_pending_frames(sk);
541                 goto out_put;
542         }
543         err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, skb->len + sizeof(struct icmp6hdr));
544
545         ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTECHOREPLIES);
546         ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTMSGS);
547
548 out_put:
549         if (likely(idev != NULL))
550                 in6_dev_put(idev);
551         dst_release(dst);
552 out:
553         icmpv6_xmit_unlock();
554 }
555
556 static void icmpv6_notify(struct sk_buff *skb, int type, int code, __be32 info)
557 {
558         struct in6_addr *saddr, *daddr;
559         struct inet6_protocol *ipprot;
560         struct sock *sk;
561         int inner_offset;
562         int hash;
563         u8 nexthdr;
564
565         if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
566                 return;
567
568         nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
569         if (ipv6_ext_hdr(nexthdr)) {
570                 /* now skip over extension headers */
571                 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr), &nexthdr);
572                 if (inner_offset<0)
573                         return;
574         } else {
575                 inner_offset = sizeof(struct ipv6hdr);
576         }
577
578         /* Checkin header including 8 bytes of inner protocol header. */
579         if (!pskb_may_pull(skb, inner_offset+8))
580                 return;
581
582         saddr = &skb->nh.ipv6h->saddr;
583         daddr = &skb->nh.ipv6h->daddr;
584
585         /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
586            Without this we will not able f.e. to make source routed
587            pmtu discovery.
588            Corresponding argument (opt) to notifiers is already added.
589            --ANK (980726)
590          */
591
592         hash = nexthdr & (MAX_INET_PROTOS - 1);
593
594         rcu_read_lock();
595         ipprot = rcu_dereference(inet6_protos[hash]);
596         if (ipprot && ipprot->err_handler)
597                 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
598         rcu_read_unlock();
599
600         read_lock(&raw_v6_lock);
601         if ((sk = sk_head(&raw_v6_htable[hash])) != NULL) {
602                 while((sk = __raw_v6_lookup(sk, nexthdr, daddr, saddr,
603                                             IP6CB(skb)->iif))) {
604                         rawv6_err(sk, skb, NULL, type, code, inner_offset, info);
605                         sk = sk_next(sk);
606                 }
607         }
608         read_unlock(&raw_v6_lock);
609 }
610
611 /*
612  *      Handle icmp messages
613  */
614
615 static int icmpv6_rcv(struct sk_buff **pskb)
616 {
617         struct sk_buff *skb = *pskb;
618         struct net_device *dev = skb->dev;
619         struct inet6_dev *idev = __in6_dev_get(dev);
620         struct in6_addr *saddr, *daddr;
621         struct ipv6hdr *orig_hdr;
622         struct icmp6hdr *hdr;
623         int type;
624
625         ICMP6_INC_STATS_BH(idev, ICMP6_MIB_INMSGS);
626
627         saddr = &skb->nh.ipv6h->saddr;
628         daddr = &skb->nh.ipv6h->daddr;
629
630         /* Perform checksum. */
631         switch (skb->ip_summed) {
632         case CHECKSUM_COMPLETE:
633                 if (!csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
634                                      skb->csum))
635                         break;
636                 /* fall through */
637         case CHECKSUM_NONE:
638                 skb->csum = ~csum_unfold(csum_ipv6_magic(saddr, daddr, skb->len,
639                                              IPPROTO_ICMPV6, 0));
640                 if (__skb_checksum_complete(skb)) {
641                         LIMIT_NETDEBUG(KERN_DEBUG "ICMPv6 checksum failed [" NIP6_FMT " > " NIP6_FMT "]\n",
642                                        NIP6(*saddr), NIP6(*daddr));
643                         goto discard_it;
644                 }
645         }
646
647         if (!pskb_pull(skb, sizeof(struct icmp6hdr)))
648                 goto discard_it;
649
650         hdr = (struct icmp6hdr *) skb->h.raw;
651
652         type = hdr->icmp6_type;
653
654         if (type >= ICMPV6_DEST_UNREACH && type <= ICMPV6_PARAMPROB)
655                 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_INDESTUNREACHS, type - ICMPV6_DEST_UNREACH);
656         else if (type >= ICMPV6_ECHO_REQUEST && type <= NDISC_REDIRECT)
657                 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_INECHOS, type - ICMPV6_ECHO_REQUEST);
658
659         switch (type) {
660         case ICMPV6_ECHO_REQUEST:
661                 icmpv6_echo_reply(skb);
662                 break;
663
664         case ICMPV6_ECHO_REPLY:
665                 /* we couldn't care less */
666                 break;
667
668         case ICMPV6_PKT_TOOBIG:
669                 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
670                    standard destination cache. Seems, only "advanced"
671                    destination cache will allow to solve this problem
672                    --ANK (980726)
673                  */
674                 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
675                         goto discard_it;
676                 hdr = (struct icmp6hdr *) skb->h.raw;
677                 orig_hdr = (struct ipv6hdr *) (hdr + 1);
678                 rt6_pmtu_discovery(&orig_hdr->daddr, &orig_hdr->saddr, dev,
679                                    ntohl(hdr->icmp6_mtu));
680
681                 /*
682                  *      Drop through to notify
683                  */
684
685         case ICMPV6_DEST_UNREACH:
686         case ICMPV6_TIME_EXCEED:
687         case ICMPV6_PARAMPROB:
688                 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
689                 break;
690
691         case NDISC_ROUTER_SOLICITATION:
692         case NDISC_ROUTER_ADVERTISEMENT:
693         case NDISC_NEIGHBOUR_SOLICITATION:
694         case NDISC_NEIGHBOUR_ADVERTISEMENT:
695         case NDISC_REDIRECT:
696                 ndisc_rcv(skb);
697                 break;
698
699         case ICMPV6_MGM_QUERY:
700                 igmp6_event_query(skb);
701                 break;
702
703         case ICMPV6_MGM_REPORT:
704                 igmp6_event_report(skb);
705                 break;
706
707         case ICMPV6_MGM_REDUCTION:
708         case ICMPV6_NI_QUERY:
709         case ICMPV6_NI_REPLY:
710         case ICMPV6_MLD2_REPORT:
711         case ICMPV6_DHAAD_REQUEST:
712         case ICMPV6_DHAAD_REPLY:
713         case ICMPV6_MOBILE_PREFIX_SOL:
714         case ICMPV6_MOBILE_PREFIX_ADV:
715                 break;
716
717         default:
718                 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6: msg of unknown type\n");
719
720                 /* informational */
721                 if (type & ICMPV6_INFOMSG_MASK)
722                         break;
723
724                 /*
725                  * error of unknown type.
726                  * must pass to upper level
727                  */
728
729                 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
730         };
731         kfree_skb(skb);
732         return 0;
733
734 discard_it:
735         ICMP6_INC_STATS_BH(idev, ICMP6_MIB_INERRORS);
736         kfree_skb(skb);
737         return 0;
738 }
739
740 /*
741  * Special lock-class for __icmpv6_socket:
742  */
743 static struct lock_class_key icmpv6_socket_sk_dst_lock_key;
744
745 int __init icmpv6_init(struct net_proto_family *ops)
746 {
747         struct sock *sk;
748         int err, i, j;
749
750         for_each_possible_cpu(i) {
751                 err = sock_create_kern(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6,
752                                        &per_cpu(__icmpv6_socket, i));
753                 if (err < 0) {
754                         printk(KERN_ERR
755                                "Failed to initialize the ICMP6 control socket "
756                                "(err %d).\n",
757                                err);
758                         goto fail;
759                 }
760
761                 sk = per_cpu(__icmpv6_socket, i)->sk;
762                 sk->sk_allocation = GFP_ATOMIC;
763                 /*
764                  * Split off their lock-class, because sk->sk_dst_lock
765                  * gets used from softirqs, which is safe for
766                  * __icmpv6_socket (because those never get directly used
767                  * via userspace syscalls), but unsafe for normal sockets.
768                  */
769                 lockdep_set_class(&sk->sk_dst_lock,
770                                   &icmpv6_socket_sk_dst_lock_key);
771
772                 /* Enough space for 2 64K ICMP packets, including
773                  * sk_buff struct overhead.
774                  */
775                 sk->sk_sndbuf =
776                         (2 * ((64 * 1024) + sizeof(struct sk_buff)));
777
778                 sk->sk_prot->unhash(sk);
779         }
780
781
782         if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0) {
783                 printk(KERN_ERR "Failed to register ICMP6 protocol\n");
784                 err = -EAGAIN;
785                 goto fail;
786         }
787
788         return 0;
789
790  fail:
791         for (j = 0; j < i; j++) {
792                 if (!cpu_possible(j))
793                         continue;
794                 sock_release(per_cpu(__icmpv6_socket, j));
795         }
796
797         return err;
798 }
799
800 void icmpv6_cleanup(void)
801 {
802         int i;
803
804         for_each_possible_cpu(i) {
805                 sock_release(per_cpu(__icmpv6_socket, i));
806         }
807         inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
808 }
809
810 static const struct icmp6_err {
811         int err;
812         int fatal;
813 } tab_unreach[] = {
814         {       /* NOROUTE */
815                 .err    = ENETUNREACH,
816                 .fatal  = 0,
817         },
818         {       /* ADM_PROHIBITED */
819                 .err    = EACCES,
820                 .fatal  = 1,
821         },
822         {       /* Was NOT_NEIGHBOUR, now reserved */
823                 .err    = EHOSTUNREACH,
824                 .fatal  = 0,
825         },
826         {       /* ADDR_UNREACH */
827                 .err    = EHOSTUNREACH,
828                 .fatal  = 0,
829         },
830         {       /* PORT_UNREACH */
831                 .err    = ECONNREFUSED,
832                 .fatal  = 1,
833         },
834 };
835
836 int icmpv6_err_convert(int type, int code, int *err)
837 {
838         int fatal = 0;
839
840         *err = EPROTO;
841
842         switch (type) {
843         case ICMPV6_DEST_UNREACH:
844                 fatal = 1;
845                 if (code <= ICMPV6_PORT_UNREACH) {
846                         *err  = tab_unreach[code].err;
847                         fatal = tab_unreach[code].fatal;
848                 }
849                 break;
850
851         case ICMPV6_PKT_TOOBIG:
852                 *err = EMSGSIZE;
853                 break;
854
855         case ICMPV6_PARAMPROB:
856                 *err = EPROTO;
857                 fatal = 1;
858                 break;
859
860         case ICMPV6_TIME_EXCEED:
861                 *err = EHOSTUNREACH;
862                 break;
863         };
864
865         return fatal;
866 }
867
868 #ifdef CONFIG_SYSCTL
869 ctl_table ipv6_icmp_table[] = {
870         {
871                 .ctl_name       = NET_IPV6_ICMP_RATELIMIT,
872                 .procname       = "ratelimit",
873                 .data           = &sysctl_icmpv6_time,
874                 .maxlen         = sizeof(int),
875                 .mode           = 0644,
876                 .proc_handler   = &proc_dointvec
877         },
878         { .ctl_name = 0 },
879 };
880 #endif
881