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