[IPV6]: Repair Incoming Interface Handling for Raw Socket.
[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/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
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, unsigned int *nhoffp);
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 = 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(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
203 static __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
214 static 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);
251 out:
252         return err;
253 }
254
255 struct icmpv6_msg {
256         struct sk_buff  *skb;
257         int             offset;
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         __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  */
275 void 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;
280         struct sock *sk;
281         struct ipv6_pinfo *np;
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(KERN_DEBUG "icmpv6_send: addr_any/mcast source\n");
336                 return;
337         }
338
339         /* 
340          *      Never answer to a ICMP packet.
341          */
342         if (is_ineligible(skb)) {
343                 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: no reply to icmp error\n");
344                 return;
345         }
346
347         memset(&fl, 0, sizeof(fl));
348         fl.proto = IPPROTO_ICMPV6;
349         ipv6_addr_copy(&fl.fl6_dst, &hdr->saddr);
350         if (saddr)
351                 ipv6_addr_copy(&fl.fl6_src, saddr);
352         fl.oif = iif;
353         fl.fl_icmp_type = type;
354         fl.fl_icmp_code = code;
355
356         if (icmpv6_xmit_lock())
357                 return;
358
359         sk = icmpv6_socket->sk;
360         np = inet6_sk(sk);
361
362         if (!icmpv6_xrlim_allow(sk, type, &fl))
363                 goto out;
364
365         tmp_hdr.icmp6_type = type;
366         tmp_hdr.icmp6_code = code;
367         tmp_hdr.icmp6_cksum = 0;
368         tmp_hdr.icmp6_pointer = htonl(info);
369
370         if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
371                 fl.oif = np->mcast_oif;
372
373         err = ip6_dst_lookup(sk, &dst, &fl);
374         if (err)
375                 goto out;
376         if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
377                 goto out_dst_release;
378
379         if (ipv6_addr_is_multicast(&fl.fl6_dst))
380                 hlimit = np->mcast_hops;
381         else
382                 hlimit = np->hop_limit;
383         if (hlimit < 0)
384                 hlimit = dst_metric(dst, RTAX_HOPLIMIT);
385         if (hlimit < 0)
386                 hlimit = ipv6_get_hoplimit(dst->dev);
387
388         msg.skb = skb;
389         msg.offset = skb->nh.raw - skb->data;
390
391         len = skb->len - msg.offset;
392         len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) -sizeof(struct icmp6hdr));
393         if (len < 0) {
394                 LIMIT_NETDEBUG(KERN_DEBUG "icmp: len problem\n");
395                 goto out_dst_release;
396         }
397
398         idev = in6_dev_get(skb->dev);
399
400         err = ip6_append_data(sk, icmpv6_getfrag, &msg,
401                               len + sizeof(struct icmp6hdr),
402                               sizeof(struct icmp6hdr),
403                               hlimit, NULL, &fl, (struct rt6_info*)dst,
404                               MSG_DONTWAIT);
405         if (err) {
406                 ip6_flush_pending_frames(sk);
407                 goto out_put;
408         }
409         err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, len + sizeof(struct icmp6hdr));
410
411         if (type >= ICMPV6_DEST_UNREACH && type <= ICMPV6_PARAMPROB)
412                 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_OUTDESTUNREACHS, type - ICMPV6_DEST_UNREACH);
413         ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTMSGS);
414
415 out_put:
416         if (likely(idev != NULL))
417                 in6_dev_put(idev);
418 out_dst_release:
419         dst_release(dst);
420 out:
421         icmpv6_xmit_unlock();
422 }
423
424 static void icmpv6_echo_reply(struct sk_buff *skb)
425 {
426         struct sock *sk;
427         struct inet6_dev *idev;
428         struct ipv6_pinfo *np;
429         struct in6_addr *saddr = NULL;
430         struct icmp6hdr *icmph = (struct icmp6hdr *) skb->h.raw;
431         struct icmp6hdr tmp_hdr;
432         struct flowi fl;
433         struct icmpv6_msg msg;
434         struct dst_entry *dst;
435         int err = 0;
436         int hlimit;
437
438         saddr = &skb->nh.ipv6h->daddr;
439
440         if (!ipv6_unicast_destination(skb))
441                 saddr = NULL;
442
443         memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
444         tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;
445
446         memset(&fl, 0, sizeof(fl));
447         fl.proto = IPPROTO_ICMPV6;
448         ipv6_addr_copy(&fl.fl6_dst, &skb->nh.ipv6h->saddr);
449         if (saddr)
450                 ipv6_addr_copy(&fl.fl6_src, saddr);
451         fl.oif = skb->dev->ifindex;
452         fl.fl_icmp_type = ICMPV6_ECHO_REPLY;
453
454         if (icmpv6_xmit_lock())
455                 return;
456
457         sk = icmpv6_socket->sk;
458         np = inet6_sk(sk);
459
460         if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
461                 fl.oif = np->mcast_oif;
462
463         err = ip6_dst_lookup(sk, &dst, &fl);
464         if (err)
465                 goto out;
466         if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
467                 goto out_dst_release;
468
469         if (ipv6_addr_is_multicast(&fl.fl6_dst))
470                 hlimit = np->mcast_hops;
471         else
472                 hlimit = np->hop_limit;
473         if (hlimit < 0)
474                 hlimit = dst_metric(dst, RTAX_HOPLIMIT);
475         if (hlimit < 0)
476                 hlimit = ipv6_get_hoplimit(dst->dev);
477
478         idev = in6_dev_get(skb->dev);
479
480         msg.skb = skb;
481         msg.offset = 0;
482
483         err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
484                                 sizeof(struct icmp6hdr), hlimit, NULL, &fl,
485                                 (struct rt6_info*)dst, MSG_DONTWAIT);
486
487         if (err) {
488                 ip6_flush_pending_frames(sk);
489                 goto out_put;
490         }
491         err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, skb->len + sizeof(struct icmp6hdr));
492
493         ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTECHOREPLIES);
494         ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTMSGS);
495
496 out_put: 
497         if (likely(idev != NULL))
498                 in6_dev_put(idev);
499 out_dst_release:
500         dst_release(dst);
501 out: 
502         icmpv6_xmit_unlock();
503 }
504
505 static void icmpv6_notify(struct sk_buff *skb, int type, int code, u32 info)
506 {
507         struct in6_addr *saddr, *daddr;
508         struct inet6_protocol *ipprot;
509         struct sock *sk;
510         int inner_offset;
511         int hash;
512         u8 nexthdr;
513
514         if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
515                 return;
516
517         nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
518         if (ipv6_ext_hdr(nexthdr)) {
519                 /* now skip over extension headers */
520                 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr), &nexthdr);
521                 if (inner_offset<0)
522                         return;
523         } else {
524                 inner_offset = sizeof(struct ipv6hdr);
525         }
526
527         /* Checkin header including 8 bytes of inner protocol header. */
528         if (!pskb_may_pull(skb, inner_offset+8))
529                 return;
530
531         saddr = &skb->nh.ipv6h->saddr;
532         daddr = &skb->nh.ipv6h->daddr;
533
534         /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
535            Without this we will not able f.e. to make source routed
536            pmtu discovery.
537            Corresponding argument (opt) to notifiers is already added.
538            --ANK (980726)
539          */
540
541         hash = nexthdr & (MAX_INET_PROTOS - 1);
542
543         rcu_read_lock();
544         ipprot = rcu_dereference(inet6_protos[hash]);
545         if (ipprot && ipprot->err_handler)
546                 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
547         rcu_read_unlock();
548
549         read_lock(&raw_v6_lock);
550         if ((sk = sk_head(&raw_v6_htable[hash])) != NULL) {
551                 while((sk = __raw_v6_lookup(sk, nexthdr, daddr, saddr,
552                                             IP6CB(skb)->iif))) {
553                         rawv6_err(sk, skb, NULL, type, code, inner_offset, info);
554                         sk = sk_next(sk);
555                 }
556         }
557         read_unlock(&raw_v6_lock);
558 }
559   
560 /*
561  *      Handle icmp messages
562  */
563
564 static int icmpv6_rcv(struct sk_buff **pskb, unsigned int *nhoffp)
565 {
566         struct sk_buff *skb = *pskb;
567         struct net_device *dev = skb->dev;
568         struct inet6_dev *idev = __in6_dev_get(dev);
569         struct in6_addr *saddr, *daddr;
570         struct ipv6hdr *orig_hdr;
571         struct icmp6hdr *hdr;
572         int type;
573
574         ICMP6_INC_STATS_BH(idev, ICMP6_MIB_INMSGS);
575
576         saddr = &skb->nh.ipv6h->saddr;
577         daddr = &skb->nh.ipv6h->daddr;
578
579         /* Perform checksum. */
580         if (skb->ip_summed == CHECKSUM_HW) {
581                 skb->ip_summed = CHECKSUM_UNNECESSARY;
582                 if (csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
583                                     skb->csum)) {
584                         LIMIT_NETDEBUG(KERN_DEBUG "ICMPv6 hw checksum failed\n");
585                         skb->ip_summed = CHECKSUM_NONE;
586                 }
587         }
588         if (skb->ip_summed == CHECKSUM_NONE) {
589                 if (csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
590                                     skb_checksum(skb, 0, skb->len, 0))) {
591                         LIMIT_NETDEBUG(KERN_DEBUG "ICMPv6 checksum failed [%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x > %04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x]\n",
592                                        NIP6(*saddr), NIP6(*daddr));
593                         goto discard_it;
594                 }
595         }
596
597         if (!pskb_pull(skb, sizeof(struct icmp6hdr)))
598                 goto discard_it;
599
600         hdr = (struct icmp6hdr *) skb->h.raw;
601
602         type = hdr->icmp6_type;
603
604         if (type >= ICMPV6_DEST_UNREACH && type <= ICMPV6_PARAMPROB)
605                 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_INDESTUNREACHS, type - ICMPV6_DEST_UNREACH);
606         else if (type >= ICMPV6_ECHO_REQUEST && type <= NDISC_REDIRECT)
607                 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_INECHOS, type - ICMPV6_ECHO_REQUEST);
608
609         switch (type) {
610         case ICMPV6_ECHO_REQUEST:
611                 icmpv6_echo_reply(skb);
612                 break;
613
614         case ICMPV6_ECHO_REPLY:
615                 /* we couldn't care less */
616                 break;
617
618         case ICMPV6_PKT_TOOBIG:
619                 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
620                    standard destination cache. Seems, only "advanced"
621                    destination cache will allow to solve this problem
622                    --ANK (980726)
623                  */
624                 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
625                         goto discard_it;
626                 hdr = (struct icmp6hdr *) skb->h.raw;
627                 orig_hdr = (struct ipv6hdr *) (hdr + 1);
628                 rt6_pmtu_discovery(&orig_hdr->daddr, &orig_hdr->saddr, dev,
629                                    ntohl(hdr->icmp6_mtu));
630
631                 /*
632                  *      Drop through to notify
633                  */
634
635         case ICMPV6_DEST_UNREACH:
636         case ICMPV6_TIME_EXCEED:
637         case ICMPV6_PARAMPROB:
638                 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
639                 break;
640
641         case NDISC_ROUTER_SOLICITATION:
642         case NDISC_ROUTER_ADVERTISEMENT:
643         case NDISC_NEIGHBOUR_SOLICITATION:
644         case NDISC_NEIGHBOUR_ADVERTISEMENT:
645         case NDISC_REDIRECT:
646                 ndisc_rcv(skb);
647                 break;
648
649         case ICMPV6_MGM_QUERY:
650                 igmp6_event_query(skb);
651                 break;
652
653         case ICMPV6_MGM_REPORT:
654                 igmp6_event_report(skb);
655                 break;
656
657         case ICMPV6_MGM_REDUCTION:
658         case ICMPV6_NI_QUERY:
659         case ICMPV6_NI_REPLY:
660         case ICMPV6_MLD2_REPORT:
661         case ICMPV6_DHAAD_REQUEST:
662         case ICMPV6_DHAAD_REPLY:
663         case ICMPV6_MOBILE_PREFIX_SOL:
664         case ICMPV6_MOBILE_PREFIX_ADV:
665                 break;
666
667         default:
668                 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6: msg of unknown type\n");
669
670                 /* informational */
671                 if (type & ICMPV6_INFOMSG_MASK)
672                         break;
673
674                 /* 
675                  * error of unknown type. 
676                  * must pass to upper level 
677                  */
678
679                 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
680         };
681         kfree_skb(skb);
682         return 0;
683
684 discard_it:
685         ICMP6_INC_STATS_BH(idev, ICMP6_MIB_INERRORS);
686         kfree_skb(skb);
687         return 0;
688 }
689
690 int __init icmpv6_init(struct net_proto_family *ops)
691 {
692         struct sock *sk;
693         int err, i, j;
694
695         for (i = 0; i < NR_CPUS; i++) {
696                 if (!cpu_possible(i))
697                         continue;
698
699                 err = sock_create_kern(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6,
700                                        &per_cpu(__icmpv6_socket, i));
701                 if (err < 0) {
702                         printk(KERN_ERR
703                                "Failed to initialize the ICMP6 control socket "
704                                "(err %d).\n",
705                                err);
706                         goto fail;
707                 }
708
709                 sk = per_cpu(__icmpv6_socket, i)->sk;
710                 sk->sk_allocation = GFP_ATOMIC;
711
712                 /* Enough space for 2 64K ICMP packets, including
713                  * sk_buff struct overhead.
714                  */
715                 sk->sk_sndbuf =
716                         (2 * ((64 * 1024) + sizeof(struct sk_buff)));
717
718                 sk->sk_prot->unhash(sk);
719         }
720
721
722         if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0) {
723                 printk(KERN_ERR "Failed to register ICMP6 protocol\n");
724                 err = -EAGAIN;
725                 goto fail;
726         }
727
728         return 0;
729
730  fail:
731         for (j = 0; j < i; j++) {
732                 if (!cpu_possible(j))
733                         continue;
734                 sock_release(per_cpu(__icmpv6_socket, j));
735         }
736
737         return err;
738 }
739
740 void icmpv6_cleanup(void)
741 {
742         int i;
743
744         for (i = 0; i < NR_CPUS; i++) {
745                 if (!cpu_possible(i))
746                         continue;
747                 sock_release(per_cpu(__icmpv6_socket, i));
748         }
749         inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
750 }
751
752 static struct icmp6_err {
753         int err;
754         int fatal;
755 } tab_unreach[] = {
756         {       /* NOROUTE */
757                 .err    = ENETUNREACH,
758                 .fatal  = 0,
759         },
760         {       /* ADM_PROHIBITED */
761                 .err    = EACCES,
762                 .fatal  = 1,
763         },
764         {       /* Was NOT_NEIGHBOUR, now reserved */
765                 .err    = EHOSTUNREACH,
766                 .fatal  = 0,
767         },
768         {       /* ADDR_UNREACH */
769                 .err    = EHOSTUNREACH,
770                 .fatal  = 0,
771         },
772         {       /* PORT_UNREACH */
773                 .err    = ECONNREFUSED,
774                 .fatal  = 1,
775         },
776 };
777
778 int icmpv6_err_convert(int type, int code, int *err)
779 {
780         int fatal = 0;
781
782         *err = EPROTO;
783
784         switch (type) {
785         case ICMPV6_DEST_UNREACH:
786                 fatal = 1;
787                 if (code <= ICMPV6_PORT_UNREACH) {
788                         *err  = tab_unreach[code].err;
789                         fatal = tab_unreach[code].fatal;
790                 }
791                 break;
792
793         case ICMPV6_PKT_TOOBIG:
794                 *err = EMSGSIZE;
795                 break;
796                 
797         case ICMPV6_PARAMPROB:
798                 *err = EPROTO;
799                 fatal = 1;
800                 break;
801
802         case ICMPV6_TIME_EXCEED:
803                 *err = EHOSTUNREACH;
804                 break;
805         };
806
807         return fatal;
808 }
809
810 #ifdef CONFIG_SYSCTL
811 ctl_table ipv6_icmp_table[] = {
812         {
813                 .ctl_name       = NET_IPV6_ICMP_RATELIMIT,
814                 .procname       = "ratelimit",
815                 .data           = &sysctl_icmpv6_time,
816                 .maxlen         = sizeof(int),
817                 .mode           = 0644,
818                 .proc_handler   = &proc_dointvec
819         },
820         { .ctl_name = 0 },
821 };
822 #endif
823