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