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 #include <linux/netfilter.h>
  46
  47 #ifdef CONFIG_SYSCTL
  48 #include <linux/sysctl.h>
  49 #endif
  50
  51 #include <linux/inet.h>
  52 #include <linux/netdevice.h>
  53 #include <linux/icmpv6.h>
  54
  55 #include <net/ip.h>
  56 #include <net/sock.h>
  57
  58 #include <net/ipv6.h>
  59 #include <net/ip6_checksum.h>
  60 #include <net/protocol.h>
  61 #include <net/raw.h>
  62 #include <net/rawv6.h>
  63 #include <net/transp_v6.h>
  64 #include <net/ip6_route.h>
  65 #include <net/addrconf.h>
  66 #include <net/icmp.h>
  67
  68 #include <asm/uaccess.h>
  69 #include <asm/system.h>
  70
  71 DEFINE_SNMP_STAT(struct icmpv6_mib, icmpv6_statistics) __read_mostly;
  72
  73 /*
  74  *      The ICMP socket(s). This is the most convenient way to flow control
  75  *      our ICMP output as well as maintain a clean interface throughout
  76  *      all layers. All Socketless IP sends will soon be gone.
  77  *
  78  *      On SMP we have one ICMP socket per-cpu.
  79  */
  80 static DEFINE_PER_CPU(struct socket *, __icmpv6_socket) = NULL;
  81 #define icmpv6_socket   __get_cpu_var(__icmpv6_socket)
  82
  83 static int icmpv6_rcv(struct sk_buff **pskb);
  84
  85 static struct inet6_protocol icmpv6_protocol = {
  86         .handler        =       icmpv6_rcv,
  87         .flags          =       INET6_PROTO_FINAL,
  88 };
  89
  90 static __inline__ int icmpv6_xmit_lock(void)
  91 {
  92         local_bh_disable();
  93
  94         if (unlikely(!spin_trylock(&icmpv6_socket->sk->sk_lock.slock))) {
  95                 /* This can happen if the output path (f.e. SIT or
  96                  * ip6ip6 tunnel) signals dst_link_failure() for an
  97                  * outgoing ICMP6 packet.
  98                  */
  99                 local_bh_enable();
 100                 return 1;
 101         }
 102         return 0;
 103 }
 104
 105 static __inline__ void icmpv6_xmit_unlock(void)
 106 {
 107         spin_unlock_bh(&icmpv6_socket->sk->sk_lock.slock);
 108 }
 109
 110 /*
 111  * Slightly more convenient version of icmpv6_send.
 112  */
 113 void icmpv6_param_prob(struct sk_buff *skb, int code, int pos)
 114 {
 115         icmpv6_send(skb, ICMPV6_PARAMPROB, code, pos, skb->dev);
 116         kfree_skb(skb);
 117 }
 118
 119 /*
 120  * Figure out, may we reply to this packet with icmp error.
 121  *
 122  * We do not reply, if:
 123  *      - it was icmp error message.
 124  *      - it is truncated, so that it is known, that protocol is ICMPV6
 125  *        (i.e. in the middle of some exthdr)
 126  *
 127  *      --ANK (980726)
 128  */
 129
 130 static int is_ineligible(struct sk_buff *skb)
 131 {
 132         int ptr = (u8*)(skb->nh.ipv6h+1) - skb->data;
 133         int len = skb->len - ptr;
 134         __u8 nexthdr = skb->nh.ipv6h->nexthdr;
 135
 136         if (len < 0)
 137                 return 1;
 138
 139         ptr = ipv6_skip_exthdr(skb, ptr, &nexthdr);
 140         if (ptr < 0)
 141                 return 0;
 142         if (nexthdr == IPPROTO_ICMPV6) {
 143                 u8 _type, *tp;
 144                 tp = skb_header_pointer(skb,
 145                         ptr+offsetof(struct icmp6hdr, icmp6_type),
 146                         sizeof(_type), &_type);
 147                 if (tp == NULL ||
 148                     !(*tp & ICMPV6_INFOMSG_MASK))
 149                         return 1;
 150         }
 151         return 0;
 152 }
 153
 154 static int sysctl_icmpv6_time = 1*HZ;
 155
 156 /*
 157  * Check the ICMP output rate limit
 158  */
 159 static inline int icmpv6_xrlim_allow(struct sock *sk, int type,
 160                                      struct flowi *fl)
 161 {
 162         struct dst_entry *dst;
 163         int res = 0;
 164
 165         /* Informational messages are not limited. */
 166         if (type & ICMPV6_INFOMSG_MASK)
 167                 return 1;
 168
 169         /* Do not limit pmtu discovery, it would break it. */
 170         if (type == ICMPV6_PKT_TOOBIG)
 171                 return 1;
 172
 173         /*
 174          * Look up the output route.
 175          * XXX: perhaps the expire for routing entries cloned by
 176          * this lookup should be more aggressive (not longer than timeout).
 177          */
 178         dst = ip6_route_output(sk, fl);
 179         if (dst->error) {
 180                 IP6_INC_STATS(IPSTATS_MIB_OUTNOROUTES);
 181         } else if (dst->dev && (dst->dev->flags&IFF_LOOPBACK)) {
 182                 res = 1;
 183         } else {
 184                 struct rt6_info *rt = (struct rt6_info *)dst;
 185                 int tmo = sysctl_icmpv6_time;
 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                 u32 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                 tmp_csum = csum_ipv6_magic(&fl->fl6_src,
 245                                            &fl->fl6_dst,
 246                                            len, fl->proto, tmp_csum);
 247                 icmp6h->icmp6_cksum = tmp_csum;
 248         }
 249         if (icmp6h->icmp6_cksum == 0)
 250                 icmp6h->icmp6_cksum = -1;
 251         ip6_push_pending_frames(sk);
 252 out:
 253         return err;
 254 }
 255
 256 struct icmpv6_msg {
 257         struct sk_buff  *skb;
 258         int             offset;
 259         uint8_t         type;
 260 };
 261
 262 static int icmpv6_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb)
 263 {
 264         struct icmpv6_msg *msg = (struct icmpv6_msg *) from;
 265         struct sk_buff *org_skb = msg->skb;
 266         __u32 csum = 0;
 267
 268         csum = skb_copy_and_csum_bits(org_skb, msg->offset + offset,
 269                                       to, len, csum);
 270         skb->csum = csum_block_add(skb->csum, csum, odd);
 271         if (!(msg->type & ICMPV6_INFOMSG_MASK))
 272                 nf_ct_attach(skb, org_skb);
 273         return 0;
 274 }
 275
 276 /*
 277  *      Send an ICMP message in response to a packet in error
 278  */
 279 void icmpv6_send(struct sk_buff *skb, int type, int code, __u32 info,
 280                  struct net_device *dev)
 281 {
 282         struct inet6_dev *idev = NULL;
 283         struct ipv6hdr *hdr = skb->nh.ipv6h;
 284         struct sock *sk;
 285         struct ipv6_pinfo *np;
 286         struct in6_addr *saddr = NULL;
 287         struct dst_entry *dst;
 288         struct icmp6hdr tmp_hdr;
 289         struct flowi fl;
 290         struct icmpv6_msg msg;
 291         int iif = 0;
 292         int addr_type = 0;
 293         int len;
 294         int hlimit, tclass;
 295         int err = 0;
 296
 297         if ((u8*)hdr < skb->head || (u8*)(hdr+1) > skb->tail)
 298                 return;
 299
 300         /*
 301          *      Make sure we respect the rules
 302          *      i.e. RFC 1885 2.4(e)
 303          *      Rule (e.1) is enforced by not using icmpv6_send
 304          *      in any code that processes icmp errors.
 305          */
 306         addr_type = ipv6_addr_type(&hdr->daddr);
 307
 308         if (ipv6_chk_addr(&hdr->daddr, skb->dev, 0))
 309                 saddr = &hdr->daddr;
 310
 311         /*
 312          *      Dest addr check
 313          */
 314
 315         if ((addr_type & IPV6_ADDR_MULTICAST || skb->pkt_type != PACKET_HOST)) {
 316                 if (type != ICMPV6_PKT_TOOBIG &&
 317                     !(type == ICMPV6_PARAMPROB &&
 318                       code == ICMPV6_UNK_OPTION &&
 319                       (opt_unrec(skb, info))))
 320                         return;
 321
 322                 saddr = NULL;
 323         }
 324
 325         addr_type = ipv6_addr_type(&hdr->saddr);
 326
 327         /*
 328          *      Source addr check
 329          */
 330
 331         if (addr_type & IPV6_ADDR_LINKLOCAL)
 332                 iif = skb->dev->ifindex;
 333
 334         /*
 335          *      Must not send error if the source does not uniquely
 336          *      identify a single node (RFC2463 Section 2.4).
 337          *      We check unspecified / multicast addresses here,
 338          *      and anycast addresses will be checked later.
 339          */
 340         if ((addr_type == IPV6_ADDR_ANY) || (addr_type & IPV6_ADDR_MULTICAST)) {
 341                 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: addr_any/mcast source\n");
 342                 return;
 343         }
 344
 345         /*
 346          *      Never answer to a ICMP packet.
 347          */
 348         if (is_ineligible(skb)) {
 349                 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: no reply to icmp error\n");
 350                 return;
 351         }
 352
 353         memset(&fl, 0, sizeof(fl));
 354         fl.proto = IPPROTO_ICMPV6;
 355         ipv6_addr_copy(&fl.fl6_dst, &hdr->saddr);
 356         if (saddr)
 357                 ipv6_addr_copy(&fl.fl6_src, saddr);
 358         fl.oif = iif;
 359         fl.fl_icmp_type = type;
 360         fl.fl_icmp_code = code;
 361
 362         if (icmpv6_xmit_lock())
 363                 return;
 364
 365         sk = icmpv6_socket->sk;
 366         np = inet6_sk(sk);
 367
 368         if (!icmpv6_xrlim_allow(sk, type, &fl))
 369                 goto out;
 370
 371         tmp_hdr.icmp6_type = type;
 372         tmp_hdr.icmp6_code = code;
 373         tmp_hdr.icmp6_cksum = 0;
 374         tmp_hdr.icmp6_pointer = htonl(info);
 375
 376         if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
 377                 fl.oif = np->mcast_oif;
 378
 379         err = ip6_dst_lookup(sk, &dst, &fl);
 380         if (err)
 381                 goto out;
 382
 383         /*
 384          * We won't send icmp if the destination is known
 385          * anycast.
 386          */
 387         if (((struct rt6_info *)dst)->rt6i_flags & RTF_ANYCAST) {
 388                 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: acast source\n");
 389                 goto out_dst_release;
 390         }
 391
 392         if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
 393                 goto out;
 394
 395         if (ipv6_addr_is_multicast(&fl.fl6_dst))
 396                 hlimit = np->mcast_hops;
 397         else
 398                 hlimit = np->hop_limit;
 399         if (hlimit < 0)
 400                 hlimit = dst_metric(dst, RTAX_HOPLIMIT);
 401         if (hlimit < 0)
 402                 hlimit = ipv6_get_hoplimit(dst->dev);
 403
 404         tclass = np->cork.tclass;
 405         if (tclass < 0)
 406                 tclass = 0;
 407
 408         msg.skb = skb;
 409         msg.offset = skb->nh.raw - skb->data;
 410         msg.type = type;
 411
 412         len = skb->len - msg.offset;
 413         len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) -sizeof(struct icmp6hdr));
 414         if (len < 0) {
 415                 LIMIT_NETDEBUG(KERN_DEBUG "icmp: len problem\n");
 416                 goto out_dst_release;
 417         }
 418
 419         idev = in6_dev_get(skb->dev);
 420
 421         err = ip6_append_data(sk, icmpv6_getfrag, &msg,
 422                               len + sizeof(struct icmp6hdr),
 423                               sizeof(struct icmp6hdr),
 424                               hlimit, tclass, NULL, &fl, (struct rt6_info*)dst,
 425                               MSG_DONTWAIT);
 426         if (err) {
 427                 ip6_flush_pending_frames(sk);
 428                 goto out_put;
 429         }
 430         err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, len + sizeof(struct icmp6hdr));
 431
 432         if (type >= ICMPV6_DEST_UNREACH && type <= ICMPV6_PARAMPROB)
 433                 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_OUTDESTUNREACHS, type - ICMPV6_DEST_UNREACH);
 434         ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTMSGS);
 435
 436 out_put:
 437         if (likely(idev != NULL))
 438                 in6_dev_put(idev);
 439 out_dst_release:
 440         dst_release(dst);
 441 out:
 442         icmpv6_xmit_unlock();
 443 }
 444
 445 static void icmpv6_echo_reply(struct sk_buff *skb)
 446 {
 447         struct sock *sk;
 448         struct inet6_dev *idev;
 449         struct ipv6_pinfo *np;
 450         struct in6_addr *saddr = NULL;
 451         struct icmp6hdr *icmph = (struct icmp6hdr *) skb->h.raw;
 452         struct icmp6hdr tmp_hdr;
 453         struct flowi fl;
 454         struct icmpv6_msg msg;
 455         struct dst_entry *dst;
 456         int err = 0;
 457         int hlimit;
 458         int tclass;
 459
 460         saddr = &skb->nh.ipv6h->daddr;
 461
 462         if (!ipv6_unicast_destination(skb))
 463                 saddr = NULL;
 464
 465         memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
 466         tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;
 467
 468         memset(&fl, 0, sizeof(fl));
 469         fl.proto = IPPROTO_ICMPV6;
 470         ipv6_addr_copy(&fl.fl6_dst, &skb->nh.ipv6h->saddr);
 471         if (saddr)
 472                 ipv6_addr_copy(&fl.fl6_src, saddr);
 473         fl.oif = skb->dev->ifindex;
 474         fl.fl_icmp_type = ICMPV6_ECHO_REPLY;
 475
 476         if (icmpv6_xmit_lock())
 477                 return;
 478
 479         sk = icmpv6_socket->sk;
 480         np = inet6_sk(sk);
 481
 482         if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
 483                 fl.oif = np->mcast_oif;
 484
 485         err = ip6_dst_lookup(sk, &dst, &fl);
 486         if (err)
 487                 goto out;
 488         if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
 489                 goto out;
 490
 491         if (ipv6_addr_is_multicast(&fl.fl6_dst))
 492                 hlimit = np->mcast_hops;
 493         else
 494                 hlimit = np->hop_limit;
 495         if (hlimit < 0)
 496                 hlimit = dst_metric(dst, RTAX_HOPLIMIT);
 497         if (hlimit < 0)
 498                 hlimit = ipv6_get_hoplimit(dst->dev);
 499
 500         tclass = np->cork.tclass;
 501         if (tclass < 0)
 502                 tclass = 0;
 503
 504         idev = in6_dev_get(skb->dev);
 505
 506         msg.skb = skb;
 507         msg.offset = 0;
 508         msg.type = ICMPV6_ECHO_REPLY;
 509
 510         err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
 511                                 sizeof(struct icmp6hdr), hlimit, tclass, NULL, &fl,
 512                                 (struct rt6_info*)dst, MSG_DONTWAIT);
 513
 514         if (err) {
 515                 ip6_flush_pending_frames(sk);
 516                 goto out_put;
 517         }
 518         err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, skb->len + sizeof(struct icmp6hdr));
 519
 520         ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTECHOREPLIES);
 521         ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTMSGS);
 522
 523 out_put:
 524         if (likely(idev != NULL))
 525                 in6_dev_put(idev);
 526         dst_release(dst);
 527 out:
 528         icmpv6_xmit_unlock();
 529 }
 530
 531 static void icmpv6_notify(struct sk_buff *skb, int type, int code, u32 info)
 532 {
 533         struct in6_addr *saddr, *daddr;
 534         struct inet6_protocol *ipprot;
 535         struct sock *sk;
 536         int inner_offset;
 537         int hash;
 538         u8 nexthdr;
 539
 540         if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
 541                 return;
 542
 543         nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
 544         if (ipv6_ext_hdr(nexthdr)) {
 545                 /* now skip over extension headers */
 546                 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr), &nexthdr);
 547                 if (inner_offset<0)
 548                         return;
 549         } else {
 550                 inner_offset = sizeof(struct ipv6hdr);
 551         }
 552
 553         /* Checkin header including 8 bytes of inner protocol header. */
 554         if (!pskb_may_pull(skb, inner_offset+8))
 555                 return;
 556
 557         saddr = &skb->nh.ipv6h->saddr;
 558         daddr = &skb->nh.ipv6h->daddr;
 559
 560         /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
 561            Without this we will not able f.e. to make source routed
 562            pmtu discovery.
 563            Corresponding argument (opt) to notifiers is already added.
 564            --ANK (980726)
 565          */
 566
 567         hash = nexthdr & (MAX_INET_PROTOS - 1);
 568
 569         rcu_read_lock();
 570         ipprot = rcu_dereference(inet6_protos[hash]);
 571         if (ipprot && ipprot->err_handler)
 572                 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
 573         rcu_read_unlock();
 574
 575         read_lock(&raw_v6_lock);
 576         if ((sk = sk_head(&raw_v6_htable[hash])) != NULL) {
 577                 while((sk = __raw_v6_lookup(sk, nexthdr, daddr, saddr,
 578                                             IP6CB(skb)->iif))) {
 579                         rawv6_err(sk, skb, NULL, type, code, inner_offset, info);
 580                         sk = sk_next(sk);
 581                 }
 582         }
 583         read_unlock(&raw_v6_lock);
 584 }
 585
 586 /*
 587  *      Handle icmp messages
 588  */
 589
 590 static int icmpv6_rcv(struct sk_buff **pskb)
 591 {
 592         struct sk_buff *skb = *pskb;
 593         struct net_device *dev = skb->dev;
 594         struct inet6_dev *idev = __in6_dev_get(dev);
 595         struct in6_addr *saddr, *daddr;
 596         struct ipv6hdr *orig_hdr;
 597         struct icmp6hdr *hdr;
 598         int type;
 599
 600         ICMP6_INC_STATS_BH(idev, ICMP6_MIB_INMSGS);
 601
 602         saddr = &skb->nh.ipv6h->saddr;
 603         daddr = &skb->nh.ipv6h->daddr;
 604
 605         /* Perform checksum. */
 606         switch (skb->ip_summed) {
 607         case CHECKSUM_HW:
 608                 if (!csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
 609                                      skb->csum))
 610                         break;
 611                 /* fall through */
 612         case CHECKSUM_NONE:
 613                 skb->csum = ~csum_ipv6_magic(saddr, daddr, skb->len,
 614                                              IPPROTO_ICMPV6, 0);
 615                 if (__skb_checksum_complete(skb)) {
 616                         LIMIT_NETDEBUG(KERN_DEBUG "ICMPv6 checksum failed [" NIP6_FMT " > " NIP6_FMT "]\n",
 617                                        NIP6(*saddr), NIP6(*daddr));
 618                         goto discard_it;
 619                 }
 620         }
 621
 622         if (!pskb_pull(skb, sizeof(struct icmp6hdr)))
 623                 goto discard_it;
 624
 625         hdr = (struct icmp6hdr *) skb->h.raw;
 626
 627         type = hdr->icmp6_type;
 628
 629         if (type >= ICMPV6_DEST_UNREACH && type <= ICMPV6_PARAMPROB)
 630                 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_INDESTUNREACHS, type - ICMPV6_DEST_UNREACH);
 631         else if (type >= ICMPV6_ECHO_REQUEST && type <= NDISC_REDIRECT)
 632                 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_INECHOS, type - ICMPV6_ECHO_REQUEST);
 633
 634         switch (type) {
 635         case ICMPV6_ECHO_REQUEST:
 636                 icmpv6_echo_reply(skb);
 637                 break;
 638
 639         case ICMPV6_ECHO_REPLY:
 640                 /* we couldn't care less */
 641                 break;
 642
 643         case ICMPV6_PKT_TOOBIG:
 644                 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
 645                    standard destination cache. Seems, only "advanced"
 646                    destination cache will allow to solve this problem
 647                    --ANK (980726)
 648                  */
 649                 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
 650                         goto discard_it;
 651                 hdr = (struct icmp6hdr *) skb->h.raw;
 652                 orig_hdr = (struct ipv6hdr *) (hdr + 1);
 653                 rt6_pmtu_discovery(&orig_hdr->daddr, &orig_hdr->saddr, dev,
 654                                    ntohl(hdr->icmp6_mtu));
 655
 656                 /*
 657                  *      Drop through to notify
 658                  */
 659
 660         case ICMPV6_DEST_UNREACH:
 661         case ICMPV6_TIME_EXCEED:
 662         case ICMPV6_PARAMPROB:
 663                 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
 664                 break;
 665
 666         case NDISC_ROUTER_SOLICITATION:
 667         case NDISC_ROUTER_ADVERTISEMENT:
 668         case NDISC_NEIGHBOUR_SOLICITATION:
 669         case NDISC_NEIGHBOUR_ADVERTISEMENT:
 670         case NDISC_REDIRECT:
 671                 ndisc_rcv(skb);
 672                 break;
 673
 674         case ICMPV6_MGM_QUERY:
 675                 igmp6_event_query(skb);
 676                 break;
 677
 678         case ICMPV6_MGM_REPORT:
 679                 igmp6_event_report(skb);
 680                 break;
 681
 682         case ICMPV6_MGM_REDUCTION:
 683         case ICMPV6_NI_QUERY:
 684         case ICMPV6_NI_REPLY:
 685         case ICMPV6_MLD2_REPORT:
 686         case ICMPV6_DHAAD_REQUEST:
 687         case ICMPV6_DHAAD_REPLY:
 688         case ICMPV6_MOBILE_PREFIX_SOL:
 689         case ICMPV6_MOBILE_PREFIX_ADV:
 690                 break;
 691
 692         default:
 693                 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6: msg of unknown type\n");
 694
 695                 /* informational */
 696                 if (type & ICMPV6_INFOMSG_MASK)
 697                         break;
 698
 699                 /*
 700                  * error of unknown type.
 701                  * must pass to upper level
 702                  */
 703
 704                 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
 705         };
 706         kfree_skb(skb);
 707         return 0;
 708
 709 discard_it:
 710         ICMP6_INC_STATS_BH(idev, ICMP6_MIB_INERRORS);
 711         kfree_skb(skb);
 712         return 0;
 713 }
 714
 715 /*
 716  * Special lock-class for __icmpv6_socket:
 717  */
 718 static struct lock_class_key icmpv6_socket_sk_dst_lock_key;
 719
 720 int __init icmpv6_init(struct net_proto_family *ops)
 721 {
 722         struct sock *sk;
 723         int err, i, j;
 724
 725         for_each_possible_cpu(i) {
 726                 err = sock_create_kern(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6,
 727                                        &per_cpu(__icmpv6_socket, i));
 728                 if (err < 0) {
 729                         printk(KERN_ERR
 730                                "Failed to initialize the ICMP6 control socket "
 731                                "(err %d).\n",
 732                                err);
 733                         goto fail;
 734                 }
 735
 736                 sk = per_cpu(__icmpv6_socket, i)->sk;
 737                 sk->sk_allocation = GFP_ATOMIC;
 738                 /*
 739                  * Split off their lock-class, because sk->sk_dst_lock
 740                  * gets used from softirqs, which is safe for
 741                  * __icmpv6_socket (because those never get directly used
 742                  * via userspace syscalls), but unsafe for normal sockets.
 743                  */
 744                 lockdep_set_class(&sk->sk_dst_lock,
 745                                   &icmpv6_socket_sk_dst_lock_key);
 746
 747                 /* Enough space for 2 64K ICMP packets, including
 748                  * sk_buff struct overhead.
 749                  */
 750                 sk->sk_sndbuf =
 751                         (2 * ((64 * 1024) + sizeof(struct sk_buff)));
 752
 753                 sk->sk_prot->unhash(sk);
 754         }
 755
 756
 757         if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0) {
 758                 printk(KERN_ERR "Failed to register ICMP6 protocol\n");
 759                 err = -EAGAIN;
 760                 goto fail;
 761         }
 762
 763         return 0;
 764
 765  fail:
 766         for (j = 0; j < i; j++) {
 767                 if (!cpu_possible(j))
 768                         continue;
 769                 sock_release(per_cpu(__icmpv6_socket, j));
 770         }
 771
 772         return err;
 773 }
 774
 775 void icmpv6_cleanup(void)
 776 {
 777         int i;
 778
 779         for_each_possible_cpu(i) {
 780                 sock_release(per_cpu(__icmpv6_socket, i));
 781         }
 782         inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
 783 }
 784
 785 static const struct icmp6_err {
 786         int err;
 787         int fatal;
 788 } tab_unreach[] = {
 789         {       /* NOROUTE */
 790                 .err    = ENETUNREACH,
 791                 .fatal  = 0,
 792         },
 793         {       /* ADM_PROHIBITED */
 794                 .err    = EACCES,
 795                 .fatal  = 1,
 796         },
 797         {       /* Was NOT_NEIGHBOUR, now reserved */
 798                 .err    = EHOSTUNREACH,
 799                 .fatal  = 0,
 800         },
 801         {       /* ADDR_UNREACH */
 802                 .err    = EHOSTUNREACH,
 803                 .fatal  = 0,
 804         },
 805         {       /* PORT_UNREACH */
 806                 .err    = ECONNREFUSED,
 807                 .fatal  = 1,
 808         },
 809 };
 810
 811 int icmpv6_err_convert(int type, int code, int *err)
 812 {
 813         int fatal = 0;
 814
 815         *err = EPROTO;
 816
 817         switch (type) {
 818         case ICMPV6_DEST_UNREACH:
 819                 fatal = 1;
 820                 if (code <= ICMPV6_PORT_UNREACH) {
 821                         *err  = tab_unreach[code].err;
 822                         fatal = tab_unreach[code].fatal;
 823                 }
 824                 break;
 825
 826         case ICMPV6_PKT_TOOBIG:
 827                 *err = EMSGSIZE;
 828                 break;
 829
 830         case ICMPV6_PARAMPROB:
 831                 *err = EPROTO;
 832                 fatal = 1;
 833                 break;
 834
 835         case ICMPV6_TIME_EXCEED:
 836                 *err = EHOSTUNREACH;
 837                 break;
 838         };
 839
 840         return fatal;
 841 }
 842
 843 #ifdef CONFIG_SYSCTL
 844 ctl_table ipv6_icmp_table[] = {
 845         {
 846                 .ctl_name       = NET_IPV6_ICMP_RATELIMIT,
 847                 .procname       = "ratelimit",
 848                 .data           = &sysctl_icmpv6_time,
 849                 .maxlen         = sizeof(int),
 850                 .mode           = 0644,
 851                 .proc_handler   = &proc_dointvec
 852         },
 853         { .ctl_name = 0 },
 854 };
 855 #endif
 856