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