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