Merge branch 'x86/debug' into x86/cpu
[linux-2.6] / 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  *      Based on net/ipv4/icmp.c
9  *
10  *      RFC 1885
11  *
12  *      This program is free software; you can redistribute it and/or
13  *      modify it under the terms of the GNU General Public License
14  *      as published by the Free Software Foundation; either version
15  *      2 of the License, or (at your option) any later version.
16  */
17
18 /*
19  *      Changes:
20  *
21  *      Andi Kleen              :       exception handling
22  *      Andi Kleen                      add rate limits. never reply to a icmp.
23  *                                      add more length checks and other fixes.
24  *      yoshfuji                :       ensure to sent parameter problem for
25  *                                      fragments.
26  *      YOSHIFUJI Hideaki @USAGI:       added sysctl for icmp rate limit.
27  *      Randy Dunlap and
28  *      YOSHIFUJI Hideaki @USAGI:       Per-interface statistics support
29  *      Kazunori MIYAZAWA @USAGI:       change output process to use ip6_append_data
30  */
31
32 #include <linux/module.h>
33 #include <linux/errno.h>
34 #include <linux/types.h>
35 #include <linux/socket.h>
36 #include <linux/in.h>
37 #include <linux/kernel.h>
38 #include <linux/sockios.h>
39 #include <linux/net.h>
40 #include <linux/skbuff.h>
41 #include <linux/init.h>
42 #include <linux/netfilter.h>
43
44 #ifdef CONFIG_SYSCTL
45 #include <linux/sysctl.h>
46 #endif
47
48 #include <linux/inet.h>
49 #include <linux/netdevice.h>
50 #include <linux/icmpv6.h>
51
52 #include <net/ip.h>
53 #include <net/sock.h>
54
55 #include <net/ipv6.h>
56 #include <net/ip6_checksum.h>
57 #include <net/protocol.h>
58 #include <net/raw.h>
59 #include <net/rawv6.h>
60 #include <net/transp_v6.h>
61 #include <net/ip6_route.h>
62 #include <net/addrconf.h>
63 #include <net/icmp.h>
64 #include <net/xfrm.h>
65 #include <net/inet_common.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 EXPORT_SYMBOL(icmpv6_statistics);
72 DEFINE_SNMP_STAT(struct icmpv6msg_mib, icmpv6msg_statistics) __read_mostly;
73 EXPORT_SYMBOL(icmpv6msg_statistics);
74
75 /*
76  *      The ICMP socket(s). This is the most convenient way to flow control
77  *      our ICMP output as well as maintain a clean interface throughout
78  *      all layers. All Socketless IP sends will soon be gone.
79  *
80  *      On SMP we have one ICMP socket per-cpu.
81  */
82 static inline struct sock *icmpv6_sk(struct net *net)
83 {
84         return net->ipv6.icmp_sk[smp_processor_id()];
85 }
86
87 static int icmpv6_rcv(struct sk_buff *skb);
88
89 static struct inet6_protocol icmpv6_protocol = {
90         .handler        =       icmpv6_rcv,
91         .flags          =       INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
92 };
93
94 static __inline__ struct sock *icmpv6_xmit_lock(struct net *net)
95 {
96         struct sock *sk;
97
98         local_bh_disable();
99
100         sk = icmpv6_sk(net);
101         if (unlikely(!spin_trylock(&sk->sk_lock.slock))) {
102                 /* This can happen if the output path (f.e. SIT or
103                  * ip6ip6 tunnel) signals dst_link_failure() for an
104                  * outgoing ICMP6 packet.
105                  */
106                 local_bh_enable();
107                 return NULL;
108         }
109         return sk;
110 }
111
112 static __inline__ void icmpv6_xmit_unlock(struct sock *sk)
113 {
114         spin_unlock_bh(&sk->sk_lock.slock);
115 }
116
117 /*
118  * Slightly more convenient version of icmpv6_send.
119  */
120 void icmpv6_param_prob(struct sk_buff *skb, int code, int pos)
121 {
122         icmpv6_send(skb, ICMPV6_PARAMPROB, code, pos, skb->dev);
123         kfree_skb(skb);
124 }
125
126 /*
127  * Figure out, may we reply to this packet with icmp error.
128  *
129  * We do not reply, if:
130  *      - it was icmp error message.
131  *      - it is truncated, so that it is known, that protocol is ICMPV6
132  *        (i.e. in the middle of some exthdr)
133  *
134  *      --ANK (980726)
135  */
136
137 static int is_ineligible(struct sk_buff *skb)
138 {
139         int ptr = (u8 *)(ipv6_hdr(skb) + 1) - skb->data;
140         int len = skb->len - ptr;
141         __u8 nexthdr = ipv6_hdr(skb)->nexthdr;
142
143         if (len < 0)
144                 return 1;
145
146         ptr = ipv6_skip_exthdr(skb, ptr, &nexthdr);
147         if (ptr < 0)
148                 return 0;
149         if (nexthdr == IPPROTO_ICMPV6) {
150                 u8 _type, *tp;
151                 tp = skb_header_pointer(skb,
152                         ptr+offsetof(struct icmp6hdr, icmp6_type),
153                         sizeof(_type), &_type);
154                 if (tp == NULL ||
155                     !(*tp & ICMPV6_INFOMSG_MASK))
156                         return 1;
157         }
158         return 0;
159 }
160
161 /*
162  * Check the ICMP output rate limit
163  */
164 static inline int icmpv6_xrlim_allow(struct sock *sk, int type,
165                                      struct flowi *fl)
166 {
167         struct dst_entry *dst;
168         struct net *net = sock_net(sk);
169         int res = 0;
170
171         /* Informational messages are not limited. */
172         if (type & ICMPV6_INFOMSG_MASK)
173                 return 1;
174
175         /* Do not limit pmtu discovery, it would break it. */
176         if (type == ICMPV6_PKT_TOOBIG)
177                 return 1;
178
179         /*
180          * Look up the output route.
181          * XXX: perhaps the expire for routing entries cloned by
182          * this lookup should be more aggressive (not longer than timeout).
183          */
184         dst = ip6_route_output(net, sk, fl);
185         if (dst->error) {
186                 IP6_INC_STATS(ip6_dst_idev(dst),
187                               IPSTATS_MIB_OUTNOROUTES);
188         } else if (dst->dev && (dst->dev->flags&IFF_LOOPBACK)) {
189                 res = 1;
190         } else {
191                 struct rt6_info *rt = (struct rt6_info *)dst;
192                 int tmo = net->ipv6.sysctl.icmpv6_time;
193
194                 /* Give more bandwidth to wider prefixes. */
195                 if (rt->rt6i_dst.plen < 128)
196                         tmo >>= ((128 - rt->rt6i_dst.plen)>>5);
197
198                 res = xrlim_allow(dst, tmo);
199         }
200         dst_release(dst);
201         return res;
202 }
203
204 /*
205  *      an inline helper for the "simple" if statement below
206  *      checks if parameter problem report is caused by an
207  *      unrecognized IPv6 option that has the Option Type
208  *      highest-order two bits set to 10
209  */
210
211 static __inline__ int opt_unrec(struct sk_buff *skb, __u32 offset)
212 {
213         u8 _optval, *op;
214
215         offset += skb_network_offset(skb);
216         op = skb_header_pointer(skb, offset, sizeof(_optval), &_optval);
217         if (op == NULL)
218                 return 1;
219         return (*op & 0xC0) == 0x80;
220 }
221
222 static int icmpv6_push_pending_frames(struct sock *sk, struct flowi *fl, struct icmp6hdr *thdr, int len)
223 {
224         struct sk_buff *skb;
225         struct icmp6hdr *icmp6h;
226         int err = 0;
227
228         if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
229                 goto out;
230
231         icmp6h = icmp6_hdr(skb);
232         memcpy(icmp6h, thdr, sizeof(struct icmp6hdr));
233         icmp6h->icmp6_cksum = 0;
234
235         if (skb_queue_len(&sk->sk_write_queue) == 1) {
236                 skb->csum = csum_partial((char *)icmp6h,
237                                         sizeof(struct icmp6hdr), skb->csum);
238                 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl->fl6_src,
239                                                       &fl->fl6_dst,
240                                                       len, fl->proto,
241                                                       skb->csum);
242         } else {
243                 __wsum tmp_csum = 0;
244
245                 skb_queue_walk(&sk->sk_write_queue, skb) {
246                         tmp_csum = csum_add(tmp_csum, skb->csum);
247                 }
248
249                 tmp_csum = csum_partial((char *)icmp6h,
250                                         sizeof(struct icmp6hdr), tmp_csum);
251                 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl->fl6_src,
252                                                       &fl->fl6_dst,
253                                                       len, fl->proto,
254                                                       tmp_csum);
255         }
256         ip6_push_pending_frames(sk);
257 out:
258         return err;
259 }
260
261 struct icmpv6_msg {
262         struct sk_buff  *skb;
263         int             offset;
264         uint8_t         type;
265 };
266
267 static int icmpv6_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb)
268 {
269         struct icmpv6_msg *msg = (struct icmpv6_msg *) from;
270         struct sk_buff *org_skb = msg->skb;
271         __wsum csum = 0;
272
273         csum = skb_copy_and_csum_bits(org_skb, msg->offset + offset,
274                                       to, len, csum);
275         skb->csum = csum_block_add(skb->csum, csum, odd);
276         if (!(msg->type & ICMPV6_INFOMSG_MASK))
277                 nf_ct_attach(skb, org_skb);
278         return 0;
279 }
280
281 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
282 static void mip6_addr_swap(struct sk_buff *skb)
283 {
284         struct ipv6hdr *iph = ipv6_hdr(skb);
285         struct inet6_skb_parm *opt = IP6CB(skb);
286         struct ipv6_destopt_hao *hao;
287         struct in6_addr tmp;
288         int off;
289
290         if (opt->dsthao) {
291                 off = ipv6_find_tlv(skb, opt->dsthao, IPV6_TLV_HAO);
292                 if (likely(off >= 0)) {
293                         hao = (struct ipv6_destopt_hao *)
294                                         (skb_network_header(skb) + off);
295                         ipv6_addr_copy(&tmp, &iph->saddr);
296                         ipv6_addr_copy(&iph->saddr, &hao->addr);
297                         ipv6_addr_copy(&hao->addr, &tmp);
298                 }
299         }
300 }
301 #else
302 static inline void mip6_addr_swap(struct sk_buff *skb) {}
303 #endif
304
305 /*
306  *      Send an ICMP message in response to a packet in error
307  */
308 void icmpv6_send(struct sk_buff *skb, int type, int code, __u32 info,
309                  struct net_device *dev)
310 {
311         struct net *net = dev_net(skb->dev);
312         struct inet6_dev *idev = NULL;
313         struct ipv6hdr *hdr = ipv6_hdr(skb);
314         struct sock *sk;
315         struct ipv6_pinfo *np;
316         struct in6_addr *saddr = NULL;
317         struct dst_entry *dst;
318         struct dst_entry *dst2;
319         struct icmp6hdr tmp_hdr;
320         struct flowi fl;
321         struct flowi fl2;
322         struct icmpv6_msg msg;
323         int iif = 0;
324         int addr_type = 0;
325         int len;
326         int hlimit, tclass;
327         int err = 0;
328
329         if ((u8 *)hdr < skb->head ||
330             (skb->network_header + sizeof(*hdr)) > skb->tail)
331                 return;
332
333         /*
334          *      Make sure we respect the rules
335          *      i.e. RFC 1885 2.4(e)
336          *      Rule (e.1) is enforced by not using icmpv6_send
337          *      in any code that processes icmp errors.
338          */
339         addr_type = ipv6_addr_type(&hdr->daddr);
340
341         if (ipv6_chk_addr(net, &hdr->daddr, skb->dev, 0))
342                 saddr = &hdr->daddr;
343
344         /*
345          *      Dest addr check
346          */
347
348         if ((addr_type & IPV6_ADDR_MULTICAST || skb->pkt_type != PACKET_HOST)) {
349                 if (type != ICMPV6_PKT_TOOBIG &&
350                     !(type == ICMPV6_PARAMPROB &&
351                       code == ICMPV6_UNK_OPTION &&
352                       (opt_unrec(skb, info))))
353                         return;
354
355                 saddr = NULL;
356         }
357
358         addr_type = ipv6_addr_type(&hdr->saddr);
359
360         /*
361          *      Source addr check
362          */
363
364         if (addr_type & IPV6_ADDR_LINKLOCAL)
365                 iif = skb->dev->ifindex;
366
367         /*
368          *      Must not send error if the source does not uniquely
369          *      identify a single node (RFC2463 Section 2.4).
370          *      We check unspecified / multicast addresses here,
371          *      and anycast addresses will be checked later.
372          */
373         if ((addr_type == IPV6_ADDR_ANY) || (addr_type & IPV6_ADDR_MULTICAST)) {
374                 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: addr_any/mcast source\n");
375                 return;
376         }
377
378         /*
379          *      Never answer to a ICMP packet.
380          */
381         if (is_ineligible(skb)) {
382                 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: no reply to icmp error\n");
383                 return;
384         }
385
386         mip6_addr_swap(skb);
387
388         memset(&fl, 0, sizeof(fl));
389         fl.proto = IPPROTO_ICMPV6;
390         ipv6_addr_copy(&fl.fl6_dst, &hdr->saddr);
391         if (saddr)
392                 ipv6_addr_copy(&fl.fl6_src, saddr);
393         fl.oif = iif;
394         fl.fl_icmp_type = type;
395         fl.fl_icmp_code = code;
396         security_skb_classify_flow(skb, &fl);
397
398         sk = icmpv6_xmit_lock(net);
399         if (sk == NULL)
400                 return;
401         np = inet6_sk(sk);
402
403         if (!icmpv6_xrlim_allow(sk, type, &fl))
404                 goto out;
405
406         tmp_hdr.icmp6_type = type;
407         tmp_hdr.icmp6_code = code;
408         tmp_hdr.icmp6_cksum = 0;
409         tmp_hdr.icmp6_pointer = htonl(info);
410
411         if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
412                 fl.oif = np->mcast_oif;
413
414         err = ip6_dst_lookup(sk, &dst, &fl);
415         if (err)
416                 goto out;
417
418         /*
419          * We won't send icmp if the destination is known
420          * anycast.
421          */
422         if (((struct rt6_info *)dst)->rt6i_flags & RTF_ANYCAST) {
423                 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: acast source\n");
424                 goto out_dst_release;
425         }
426
427         /* No need to clone since we're just using its address. */
428         dst2 = dst;
429
430         err = xfrm_lookup(&dst, &fl, sk, 0);
431         switch (err) {
432         case 0:
433                 if (dst != dst2)
434                         goto route_done;
435                 break;
436         case -EPERM:
437                 dst = NULL;
438                 break;
439         default:
440                 goto out;
441         }
442
443         if (xfrm_decode_session_reverse(skb, &fl2, AF_INET6))
444                 goto relookup_failed;
445
446         if (ip6_dst_lookup(sk, &dst2, &fl))
447                 goto relookup_failed;
448
449         err = xfrm_lookup(&dst2, &fl, sk, XFRM_LOOKUP_ICMP);
450         switch (err) {
451         case 0:
452                 dst_release(dst);
453                 dst = dst2;
454                 break;
455         case -EPERM:
456                 goto out_dst_release;
457         default:
458 relookup_failed:
459                 if (!dst)
460                         goto out;
461                 break;
462         }
463
464 route_done:
465         if (ipv6_addr_is_multicast(&fl.fl6_dst))
466                 hlimit = np->mcast_hops;
467         else
468                 hlimit = np->hop_limit;
469         if (hlimit < 0)
470                 hlimit = ip6_dst_hoplimit(dst);
471
472         tclass = np->tclass;
473         if (tclass < 0)
474                 tclass = 0;
475
476         msg.skb = skb;
477         msg.offset = skb_network_offset(skb);
478         msg.type = type;
479
480         len = skb->len - msg.offset;
481         len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) -sizeof(struct icmp6hdr));
482         if (len < 0) {
483                 LIMIT_NETDEBUG(KERN_DEBUG "icmp: len problem\n");
484                 goto out_dst_release;
485         }
486
487         idev = in6_dev_get(skb->dev);
488
489         err = ip6_append_data(sk, icmpv6_getfrag, &msg,
490                               len + sizeof(struct icmp6hdr),
491                               sizeof(struct icmp6hdr),
492                               hlimit, tclass, NULL, &fl, (struct rt6_info*)dst,
493                               MSG_DONTWAIT);
494         if (err) {
495                 ip6_flush_pending_frames(sk);
496                 goto out_put;
497         }
498         err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, len + sizeof(struct icmp6hdr));
499
500 out_put:
501         if (likely(idev != NULL))
502                 in6_dev_put(idev);
503 out_dst_release:
504         dst_release(dst);
505 out:
506         icmpv6_xmit_unlock(sk);
507 }
508
509 EXPORT_SYMBOL(icmpv6_send);
510
511 static void icmpv6_echo_reply(struct sk_buff *skb)
512 {
513         struct net *net = dev_net(skb->dev);
514         struct sock *sk;
515         struct inet6_dev *idev;
516         struct ipv6_pinfo *np;
517         struct in6_addr *saddr = NULL;
518         struct icmp6hdr *icmph = icmp6_hdr(skb);
519         struct icmp6hdr tmp_hdr;
520         struct flowi fl;
521         struct icmpv6_msg msg;
522         struct dst_entry *dst;
523         int err = 0;
524         int hlimit;
525         int tclass;
526
527         saddr = &ipv6_hdr(skb)->daddr;
528
529         if (!ipv6_unicast_destination(skb))
530                 saddr = NULL;
531
532         memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
533         tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;
534
535         memset(&fl, 0, sizeof(fl));
536         fl.proto = IPPROTO_ICMPV6;
537         ipv6_addr_copy(&fl.fl6_dst, &ipv6_hdr(skb)->saddr);
538         if (saddr)
539                 ipv6_addr_copy(&fl.fl6_src, saddr);
540         fl.oif = skb->dev->ifindex;
541         fl.fl_icmp_type = ICMPV6_ECHO_REPLY;
542         security_skb_classify_flow(skb, &fl);
543
544         sk = icmpv6_xmit_lock(net);
545         if (sk == NULL)
546                 return;
547         np = inet6_sk(sk);
548
549         if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
550                 fl.oif = np->mcast_oif;
551
552         err = ip6_dst_lookup(sk, &dst, &fl);
553         if (err)
554                 goto out;
555         if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
556                 goto out;
557
558         if (ipv6_addr_is_multicast(&fl.fl6_dst))
559                 hlimit = np->mcast_hops;
560         else
561                 hlimit = np->hop_limit;
562         if (hlimit < 0)
563                 hlimit = ip6_dst_hoplimit(dst);
564
565         tclass = np->tclass;
566         if (tclass < 0)
567                 tclass = 0;
568
569         idev = in6_dev_get(skb->dev);
570
571         msg.skb = skb;
572         msg.offset = 0;
573         msg.type = ICMPV6_ECHO_REPLY;
574
575         err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
576                                 sizeof(struct icmp6hdr), hlimit, tclass, NULL, &fl,
577                                 (struct rt6_info*)dst, MSG_DONTWAIT);
578
579         if (err) {
580                 ip6_flush_pending_frames(sk);
581                 goto out_put;
582         }
583         err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, skb->len + sizeof(struct icmp6hdr));
584
585 out_put:
586         if (likely(idev != NULL))
587                 in6_dev_put(idev);
588         dst_release(dst);
589 out:
590         icmpv6_xmit_unlock(sk);
591 }
592
593 static void icmpv6_notify(struct sk_buff *skb, int type, int code, __be32 info)
594 {
595         struct inet6_protocol *ipprot;
596         int inner_offset;
597         int hash;
598         u8 nexthdr;
599
600         if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
601                 return;
602
603         nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
604         if (ipv6_ext_hdr(nexthdr)) {
605                 /* now skip over extension headers */
606                 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr), &nexthdr);
607                 if (inner_offset<0)
608                         return;
609         } else {
610                 inner_offset = sizeof(struct ipv6hdr);
611         }
612
613         /* Checkin header including 8 bytes of inner protocol header. */
614         if (!pskb_may_pull(skb, inner_offset+8))
615                 return;
616
617         /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
618            Without this we will not able f.e. to make source routed
619            pmtu discovery.
620            Corresponding argument (opt) to notifiers is already added.
621            --ANK (980726)
622          */
623
624         hash = nexthdr & (MAX_INET_PROTOS - 1);
625
626         rcu_read_lock();
627         ipprot = rcu_dereference(inet6_protos[hash]);
628         if (ipprot && ipprot->err_handler)
629                 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
630         rcu_read_unlock();
631
632         raw6_icmp_error(skb, nexthdr, type, code, inner_offset, info);
633 }
634
635 /*
636  *      Handle icmp messages
637  */
638
639 static int icmpv6_rcv(struct sk_buff *skb)
640 {
641         struct net_device *dev = skb->dev;
642         struct inet6_dev *idev = __in6_dev_get(dev);
643         struct in6_addr *saddr, *daddr;
644         struct ipv6hdr *orig_hdr;
645         struct icmp6hdr *hdr;
646         int type;
647
648         if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
649                 int nh;
650
651                 if (!(skb->sp && skb->sp->xvec[skb->sp->len - 1]->props.flags &
652                                  XFRM_STATE_ICMP))
653                         goto drop_no_count;
654
655                 if (!pskb_may_pull(skb, sizeof(*hdr) + sizeof(*orig_hdr)))
656                         goto drop_no_count;
657
658                 nh = skb_network_offset(skb);
659                 skb_set_network_header(skb, sizeof(*hdr));
660
661                 if (!xfrm6_policy_check_reverse(NULL, XFRM_POLICY_IN, skb))
662                         goto drop_no_count;
663
664                 skb_set_network_header(skb, nh);
665         }
666
667         ICMP6_INC_STATS_BH(idev, ICMP6_MIB_INMSGS);
668
669         saddr = &ipv6_hdr(skb)->saddr;
670         daddr = &ipv6_hdr(skb)->daddr;
671
672         /* Perform checksum. */
673         switch (skb->ip_summed) {
674         case CHECKSUM_COMPLETE:
675                 if (!csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
676                                      skb->csum))
677                         break;
678                 /* fall through */
679         case CHECKSUM_NONE:
680                 skb->csum = ~csum_unfold(csum_ipv6_magic(saddr, daddr, skb->len,
681                                              IPPROTO_ICMPV6, 0));
682                 if (__skb_checksum_complete(skb)) {
683                         LIMIT_NETDEBUG(KERN_DEBUG "ICMPv6 checksum failed [" NIP6_FMT " > " NIP6_FMT "]\n",
684                                        NIP6(*saddr), NIP6(*daddr));
685                         goto discard_it;
686                 }
687         }
688
689         if (!pskb_pull(skb, sizeof(*hdr)))
690                 goto discard_it;
691
692         hdr = icmp6_hdr(skb);
693
694         type = hdr->icmp6_type;
695
696         ICMP6MSGIN_INC_STATS_BH(idev, type);
697
698         switch (type) {
699         case ICMPV6_ECHO_REQUEST:
700                 icmpv6_echo_reply(skb);
701                 break;
702
703         case ICMPV6_ECHO_REPLY:
704                 /* we couldn't care less */
705                 break;
706
707         case ICMPV6_PKT_TOOBIG:
708                 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
709                    standard destination cache. Seems, only "advanced"
710                    destination cache will allow to solve this problem
711                    --ANK (980726)
712                  */
713                 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
714                         goto discard_it;
715                 hdr = icmp6_hdr(skb);
716                 orig_hdr = (struct ipv6hdr *) (hdr + 1);
717                 rt6_pmtu_discovery(&orig_hdr->daddr, &orig_hdr->saddr, dev,
718                                    ntohl(hdr->icmp6_mtu));
719
720                 /*
721                  *      Drop through to notify
722                  */
723
724         case ICMPV6_DEST_UNREACH:
725         case ICMPV6_TIME_EXCEED:
726         case ICMPV6_PARAMPROB:
727                 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
728                 break;
729
730         case NDISC_ROUTER_SOLICITATION:
731         case NDISC_ROUTER_ADVERTISEMENT:
732         case NDISC_NEIGHBOUR_SOLICITATION:
733         case NDISC_NEIGHBOUR_ADVERTISEMENT:
734         case NDISC_REDIRECT:
735                 ndisc_rcv(skb);
736                 break;
737
738         case ICMPV6_MGM_QUERY:
739                 igmp6_event_query(skb);
740                 break;
741
742         case ICMPV6_MGM_REPORT:
743                 igmp6_event_report(skb);
744                 break;
745
746         case ICMPV6_MGM_REDUCTION:
747         case ICMPV6_NI_QUERY:
748         case ICMPV6_NI_REPLY:
749         case ICMPV6_MLD2_REPORT:
750         case ICMPV6_DHAAD_REQUEST:
751         case ICMPV6_DHAAD_REPLY:
752         case ICMPV6_MOBILE_PREFIX_SOL:
753         case ICMPV6_MOBILE_PREFIX_ADV:
754                 break;
755
756         default:
757                 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6: msg of unknown type\n");
758
759                 /* informational */
760                 if (type & ICMPV6_INFOMSG_MASK)
761                         break;
762
763                 /*
764                  * error of unknown type.
765                  * must pass to upper level
766                  */
767
768                 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
769         }
770
771         kfree_skb(skb);
772         return 0;
773
774 discard_it:
775         ICMP6_INC_STATS_BH(idev, ICMP6_MIB_INERRORS);
776 drop_no_count:
777         kfree_skb(skb);
778         return 0;
779 }
780
781 void icmpv6_flow_init(struct sock *sk, struct flowi *fl,
782                       u8 type,
783                       const struct in6_addr *saddr,
784                       const struct in6_addr *daddr,
785                       int oif)
786 {
787         memset(fl, 0, sizeof(*fl));
788         ipv6_addr_copy(&fl->fl6_src, saddr);
789         ipv6_addr_copy(&fl->fl6_dst, daddr);
790         fl->proto               = IPPROTO_ICMPV6;
791         fl->fl_icmp_type        = type;
792         fl->fl_icmp_code        = 0;
793         fl->oif                 = oif;
794         security_sk_classify_flow(sk, fl);
795 }
796
797 /*
798  * Special lock-class for __icmpv6_sk:
799  */
800 static struct lock_class_key icmpv6_socket_sk_dst_lock_key;
801
802 static int __net_init icmpv6_sk_init(struct net *net)
803 {
804         struct sock *sk;
805         int err, i, j;
806
807         net->ipv6.icmp_sk =
808                 kzalloc(nr_cpu_ids * sizeof(struct sock *), GFP_KERNEL);
809         if (net->ipv6.icmp_sk == NULL)
810                 return -ENOMEM;
811
812         for_each_possible_cpu(i) {
813                 err = inet_ctl_sock_create(&sk, PF_INET6,
814                                            SOCK_RAW, IPPROTO_ICMPV6, net);
815                 if (err < 0) {
816                         printk(KERN_ERR
817                                "Failed to initialize the ICMP6 control socket "
818                                "(err %d).\n",
819                                err);
820                         goto fail;
821                 }
822
823                 net->ipv6.icmp_sk[i] = sk;
824
825                 /*
826                  * Split off their lock-class, because sk->sk_dst_lock
827                  * gets used from softirqs, which is safe for
828                  * __icmpv6_sk (because those never get directly used
829                  * via userspace syscalls), but unsafe for normal sockets.
830                  */
831                 lockdep_set_class(&sk->sk_dst_lock,
832                                   &icmpv6_socket_sk_dst_lock_key);
833
834                 /* Enough space for 2 64K ICMP packets, including
835                  * sk_buff struct overhead.
836                  */
837                 sk->sk_sndbuf =
838                         (2 * ((64 * 1024) + sizeof(struct sk_buff)));
839         }
840         return 0;
841
842  fail:
843         for (j = 0; j < i; j++)
844                 inet_ctl_sock_destroy(net->ipv6.icmp_sk[j]);
845         kfree(net->ipv6.icmp_sk);
846         return err;
847 }
848
849 static void __net_exit icmpv6_sk_exit(struct net *net)
850 {
851         int i;
852
853         for_each_possible_cpu(i) {
854                 inet_ctl_sock_destroy(net->ipv6.icmp_sk[i]);
855         }
856         kfree(net->ipv6.icmp_sk);
857 }
858
859 static struct pernet_operations icmpv6_sk_ops = {
860        .init = icmpv6_sk_init,
861        .exit = icmpv6_sk_exit,
862 };
863
864 int __init icmpv6_init(void)
865 {
866         int err;
867
868         err = register_pernet_subsys(&icmpv6_sk_ops);
869         if (err < 0)
870                 return err;
871
872         err = -EAGAIN;
873         if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0)
874                 goto fail;
875         return 0;
876
877 fail:
878         printk(KERN_ERR "Failed to register ICMP6 protocol\n");
879         unregister_pernet_subsys(&icmpv6_sk_ops);
880         return err;
881 }
882
883 void icmpv6_cleanup(void)
884 {
885         unregister_pernet_subsys(&icmpv6_sk_ops);
886         inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
887 }
888
889
890 static const struct icmp6_err {
891         int err;
892         int fatal;
893 } tab_unreach[] = {
894         {       /* NOROUTE */
895                 .err    = ENETUNREACH,
896                 .fatal  = 0,
897         },
898         {       /* ADM_PROHIBITED */
899                 .err    = EACCES,
900                 .fatal  = 1,
901         },
902         {       /* Was NOT_NEIGHBOUR, now reserved */
903                 .err    = EHOSTUNREACH,
904                 .fatal  = 0,
905         },
906         {       /* ADDR_UNREACH */
907                 .err    = EHOSTUNREACH,
908                 .fatal  = 0,
909         },
910         {       /* PORT_UNREACH */
911                 .err    = ECONNREFUSED,
912                 .fatal  = 1,
913         },
914 };
915
916 int icmpv6_err_convert(int type, int code, int *err)
917 {
918         int fatal = 0;
919
920         *err = EPROTO;
921
922         switch (type) {
923         case ICMPV6_DEST_UNREACH:
924                 fatal = 1;
925                 if (code <= ICMPV6_PORT_UNREACH) {
926                         *err  = tab_unreach[code].err;
927                         fatal = tab_unreach[code].fatal;
928                 }
929                 break;
930
931         case ICMPV6_PKT_TOOBIG:
932                 *err = EMSGSIZE;
933                 break;
934
935         case ICMPV6_PARAMPROB:
936                 *err = EPROTO;
937                 fatal = 1;
938                 break;
939
940         case ICMPV6_TIME_EXCEED:
941                 *err = EHOSTUNREACH;
942                 break;
943         }
944
945         return fatal;
946 }
947
948 EXPORT_SYMBOL(icmpv6_err_convert);
949
950 #ifdef CONFIG_SYSCTL
951 ctl_table ipv6_icmp_table_template[] = {
952         {
953                 .ctl_name       = NET_IPV6_ICMP_RATELIMIT,
954                 .procname       = "ratelimit",
955                 .data           = &init_net.ipv6.sysctl.icmpv6_time,
956                 .maxlen         = sizeof(int),
957                 .mode           = 0644,
958                 .proc_handler   = &proc_dointvec_ms_jiffies,
959                 .strategy       = &sysctl_ms_jiffies
960         },
961         { .ctl_name = 0 },
962 };
963
964 struct ctl_table *ipv6_icmp_sysctl_init(struct net *net)
965 {
966         struct ctl_table *table;
967
968         table = kmemdup(ipv6_icmp_table_template,
969                         sizeof(ipv6_icmp_table_template),
970                         GFP_KERNEL);
971
972         if (table)
973                 table[0].data = &net->ipv6.sysctl.icmpv6_time;
974
975         return table;
976 }
977 #endif
978