net/ipv6/icmp.c

   1 /*
   2  *      Internet Control Message Protocol (ICMPv6)
   3  *      Linux INET6 implementation
   4  *
   5  *      Authors:
   6  *      Pedro Roque             <roque@di.fc.ul.pt>
   7  *
   8  *      $Id: icmp.c,v 1.38 2002/02/08 03:57:19 davem Exp $
   9  *
  10  *      Based on net/ipv4/icmp.c
  11  *
  12  *      RFC 1885
  13  *
  14  *      This program is free software; you can redistribute it and/or
  15  *      modify it under the terms of the GNU General Public License
  16  *      as published by the Free Software Foundation; either version
  17  *      2 of the License, or (at your option) any later version.
  18  */
  19
  20 /*
  21  *      Changes:
  22  *
  23  *      Andi Kleen              :       exception handling
  24  *      Andi Kleen                      add rate limits. never reply to a icmp.
  25  *                                      add more length checks and other fixes.
  26  *      yoshfuji                :       ensure to sent parameter problem for
  27  *                                      fragments.
  28  *      YOSHIFUJI Hideaki @USAGI:       added sysctl for icmp rate limit.
  29  *      Randy Dunlap and
  30  *      YOSHIFUJI Hideaki @USAGI:       Per-interface statistics support
  31  *      Kazunori MIYAZAWA @USAGI:       change output process to use ip6_append_data
  32  */
  33
  34 #include <linux/module.h>
  35 #include <linux/errno.h>
  36 #include <linux/types.h>
  37 #include <linux/socket.h>
  38 #include <linux/in.h>
  39 #include <linux/kernel.h>
  40 #include <linux/sched.h>
  41 #include <linux/sockios.h>
  42 #include <linux/net.h>
  43 #include <linux/skbuff.h>
  44 #include <linux/init.h>
  45
  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);
  71
  72 /*
  73  *      The ICMP socket(s). This is the most convenient way to flow control
  74  *      our ICMP output as well as maintain a clean interface throughout
  75  *      all layers. All Socketless IP sends will soon be gone.
  76  *
  77  *      On SMP we have one ICMP socket per-cpu.
  78  */
  79 static DEFINE_PER_CPU(struct socket *, __icmpv6_socket) = NULL;
  80 #define icmpv6_socket   __get_cpu_var(__icmpv6_socket)
  81
  82 static int icmpv6_rcv(struct sk_buff **pskb, unsigned int *nhoffp);
  83
  84 static struct inet6_protocol icmpv6_protocol = {
  85         .handler        =       icmpv6_rcv,
  86         .flags          =       INET6_PROTO_FINAL,
  87 };
  88
  89 static __inline__ int icmpv6_xmit_lock(void)
  90 {
  91         local_bh_disable();
  92
  93         if (unlikely(!spin_trylock(&icmpv6_socket->sk->sk_lock.slock))) {
  94                 /* This can happen if the output path (f.e. SIT or
  95                  * ip6ip6 tunnel) signals dst_link_failure() for an
  96                  * outgoing ICMP6 packet.
  97                  */
  98                 local_bh_enable();
  99                 return 1;
 100         }
 101         return 0;
 102 }
 103
 104 static __inline__ void icmpv6_xmit_unlock(void)
 105 {
 106         spin_unlock_bh(&icmpv6_socket->sk->sk_lock.slock);
 107 }
 108
 109 /*
 110  * Slightly more convenient version of icmpv6_send.
 111  */
 112 void icmpv6_param_prob(struct sk_buff *skb, int code, int pos)
 113 {
 114         icmpv6_send(skb, ICMPV6_PARAMPROB, code, pos, skb->dev);
 115         kfree_skb(skb);
 116 }
 117
 118 /*
 119  * Figure out, may we reply to this packet with icmp error.
 120  *
 121  * We do not reply, if:
 122  *      - it was icmp error message.
 123  *      - it is truncated, so that it is known, that protocol is ICMPV6
 124  *        (i.e. in the middle of some exthdr)
 125  *
 126  *      --ANK (980726)
 127  */
 128
 129 static int is_ineligible(struct sk_buff *skb)
 130 {
 131         int ptr = (u8*)(skb->nh.ipv6h+1) - skb->data;
 132         int len = skb->len - ptr;
 133         __u8 nexthdr = skb->nh.ipv6h->nexthdr;
 134
 135         if (len < 0)
 136                 return 1;
 137
 138         ptr = ipv6_skip_exthdr(skb, ptr, &nexthdr, len);
 139         if (ptr < 0)
 140                 return 0;
 141         if (nexthdr == IPPROTO_ICMPV6) {
 142                 u8 _type, *tp;
 143                 tp = skb_header_pointer(skb,
 144                         ptr+offsetof(struct icmp6hdr, icmp6_type),
 145                         sizeof(_type), &_type);
 146                 if (tp == NULL ||
 147                     !(*tp & ICMPV6_INFOMSG_MASK))
 148                         return 1;
 149         }
 150         return 0;
 151 }
 152
 153 static int sysctl_icmpv6_time = 1*HZ;
 154
 155 /*
 156  * Check the ICMP output rate limit
 157  */
 158 static inline int icmpv6_xrlim_allow(struct sock *sk, int type,
 159                                      struct flowi *fl)
 160 {
 161         struct dst_entry *dst;
 162         int res = 0;
 163
 164         /* Informational messages are not limited. */
 165         if (type & ICMPV6_INFOMSG_MASK)
 166                 return 1;
 167
 168         /* Do not limit pmtu discovery, it would break it. */
 169         if (type == ICMPV6_PKT_TOOBIG)
 170                 return 1;
 171
 172         /*
 173          * Look up the output route.
 174          * XXX: perhaps the expire for routing entries cloned by
 175          * this lookup should be more aggressive (not longer than timeout).
 176          */
 177         dst = ip6_route_output(sk, fl);
 178         if (dst->error) {
 179                 IP6_INC_STATS(IPSTATS_MIB_OUTNOROUTES);
 180         } else if (dst->dev && (dst->dev->flags&IFF_LOOPBACK)) {
 181                 res = 1;
 182         } else {
 183                 struct rt6_info *rt = (struct rt6_info *)dst;
 184                 int tmo = sysctl_icmpv6_time;
 185
 186                 /* Give more bandwidth to wider prefixes. */
 187                 if (rt->rt6i_dst.plen < 128)
 188                         tmo >>= ((128 - rt->rt6i_dst.plen)>>5);
 189
 190                 res = xrlim_allow(dst, tmo);
 191         }
 192         dst_release(dst);
 193         return res;
 194 }
 195
 196 /*
 197  *      an inline helper for the "simple" if statement below
 198  *      checks if parameter problem report is caused by an
 199  *      unrecognized IPv6 option that has the Option Type
 200  *      highest-order two bits set to 10
 201  */
 202
 203 static __inline__ int opt_unrec(struct sk_buff *skb, __u32 offset)
 204 {
 205         u8 _optval, *op;
 206
 207         offset += skb->nh.raw - skb->data;
 208         op = skb_header_pointer(skb, offset, sizeof(_optval), &_optval);
 209         if (op == NULL)
 210                 return 1;
 211         return (*op & 0xC0) == 0x80;
 212 }
 213
 214 static int icmpv6_push_pending_frames(struct sock *sk, struct flowi *fl, struct icmp6hdr *thdr, int len)
 215 {
 216         struct sk_buff *skb;
 217         struct icmp6hdr *icmp6h;
 218         int err = 0;
 219
 220         if ((skb = skb_peek(&sk->sk_write_queue)) == NULL)
 221                 goto out;
 222
 223         icmp6h = (struct icmp6hdr*) skb->h.raw;
 224         memcpy(icmp6h, thdr, sizeof(struct icmp6hdr));
 225         icmp6h->icmp6_cksum = 0;
 226
 227         if (skb_queue_len(&sk->sk_write_queue) == 1) {
 228                 skb->csum = csum_partial((char *)icmp6h,
 229                                         sizeof(struct icmp6hdr), skb->csum);
 230                 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl->fl6_src,
 231                                                       &fl->fl6_dst,
 232                                                       len, fl->proto,
 233                                                       skb->csum);
 234         } else {
 235                 u32 tmp_csum = 0;
 236
 237                 skb_queue_walk(&sk->sk_write_queue, skb) {
 238                         tmp_csum = csum_add(tmp_csum, skb->csum);
 239                 }
 240
 241                 tmp_csum = csum_partial((char *)icmp6h,
 242                                         sizeof(struct icmp6hdr), tmp_csum);
 243                 tmp_csum = csum_ipv6_magic(&fl->fl6_src,
 244                                            &fl->fl6_dst,
 245                                            len, fl->proto, tmp_csum);
 246                 icmp6h->icmp6_cksum = tmp_csum;
 247         }
 248         if (icmp6h->icmp6_cksum == 0)
 249                 icmp6h->icmp6_cksum = -1;
 250         ip6_push_pending_frames(sk);
 251 out:
 252         return err;
 253 }
 254
 255 struct icmpv6_msg {
 256         struct sk_buff  *skb;
 257         int             offset;
 258 };
 259
 260 static int icmpv6_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb)
 261 {
 262         struct icmpv6_msg *msg = (struct icmpv6_msg *) from;
 263         struct sk_buff *org_skb = msg->skb;
 264         __u32 csum = 0;
 265
 266         csum = skb_copy_and_csum_bits(org_skb, msg->offset + offset,
 267                                       to, len, csum);
 268         skb->csum = csum_block_add(skb->csum, csum, odd);
 269         return 0;
 270 }
 271
 272 /*
 273  *      Send an ICMP message in response to a packet in error
 274  */
 275 void icmpv6_send(struct sk_buff *skb, int type, int code, __u32 info,
 276                  struct net_device *dev)
 277 {
 278         struct inet6_dev *idev = NULL;
 279         struct ipv6hdr *hdr = skb->nh.ipv6h;
 280         struct sock *sk = icmpv6_socket->sk;
 281         struct ipv6_pinfo *np = inet6_sk(sk);
 282         struct in6_addr *saddr = NULL;
 283         struct dst_entry *dst;
 284         struct icmp6hdr tmp_hdr;
 285         struct flowi fl;
 286         struct icmpv6_msg msg;
 287         int iif = 0;
 288         int addr_type = 0;
 289         int len;
 290         int hlimit;
 291         int err = 0;
 292
 293         if ((u8*)hdr < skb->head || (u8*)(hdr+1) > skb->tail)
 294                 return;
 295
 296         /*
 297          *      Make sure we respect the rules
 298          *      i.e. RFC 1885 2.4(e)
 299          *      Rule (e.1) is enforced by not using icmpv6_send
 300          *      in any code that processes icmp errors.
 301          */
 302         addr_type = ipv6_addr_type(&hdr->daddr);
 303
 304         if (ipv6_chk_addr(&hdr->daddr, skb->dev, 0))
 305                 saddr = &hdr->daddr;
 306
 307         /*
 308          *      Dest addr check
 309          */
 310
 311         if ((addr_type & IPV6_ADDR_MULTICAST || skb->pkt_type != PACKET_HOST)) {
 312                 if (type != ICMPV6_PKT_TOOBIG &&
 313                     !(type == ICMPV6_PARAMPROB &&
 314                       code == ICMPV6_UNK_OPTION &&
 315                       (opt_unrec(skb, info))))
 316                         return;
 317
 318                 saddr = NULL;
 319         }
 320
 321         addr_type = ipv6_addr_type(&hdr->saddr);
 322
 323         /*
 324          *      Source addr check
 325          */
 326
 327         if (addr_type & IPV6_ADDR_LINKLOCAL)
 328                 iif = skb->dev->ifindex;
 329
 330         /*
 331          *      Must not send if we know that source is Anycast also.
 332          *      for now we don't know that.
 333          */
 334         if ((addr_type == IPV6_ADDR_ANY) || (addr_type & IPV6_ADDR_MULTICAST)) {
 335                 LIMIT_NETDEBUG(
 336                         printk(KERN_DEBUG "icmpv6_send: addr_any/mcast source\n"));
 337                 return;
 338         }
 339
 340         /*
 341          *      Never answer to a ICMP packet.
 342          */
 343         if (is_ineligible(skb)) {
 344                 LIMIT_NETDEBUG(
 345                         printk(KERN_DEBUG "icmpv6_send: no reply to icmp error\n"));
 346                 return;
 347         }
 348
 349         memset(&fl, 0, sizeof(fl));
 350         fl.proto = IPPROTO_ICMPV6;
 351         ipv6_addr_copy(&fl.fl6_dst, &hdr->saddr);
 352         if (saddr)
 353                 ipv6_addr_copy(&fl.fl6_src, saddr);
 354         fl.oif = iif;
 355         fl.fl_icmp_type = type;
 356         fl.fl_icmp_code = code;
 357
 358         if (icmpv6_xmit_lock())
 359                 return;
 360
 361         if (!icmpv6_xrlim_allow(sk, type, &fl))
 362                 goto out;
 363
 364         tmp_hdr.icmp6_type = type;
 365         tmp_hdr.icmp6_code = code;
 366         tmp_hdr.icmp6_cksum = 0;
 367         tmp_hdr.icmp6_pointer = htonl(info);
 368
 369         if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
 370                 fl.oif = np->mcast_oif;
 371
 372         err = ip6_dst_lookup(sk, &dst, &fl);
 373         if (err)
 374                 goto out;
 375         if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
 376                 goto out_dst_release;
 377
 378         if (ipv6_addr_is_multicast(&fl.fl6_dst))
 379                 hlimit = np->mcast_hops;
 380         else
 381                 hlimit = np->hop_limit;
 382         if (hlimit < 0)
 383                 hlimit = dst_metric(dst, RTAX_HOPLIMIT);
 384
 385         msg.skb = skb;
 386         msg.offset = skb->nh.raw - skb->data;
 387
 388         len = skb->len - msg.offset;
 389         len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) -sizeof(struct icmp6hdr));
 390         if (len < 0) {
 391                 LIMIT_NETDEBUG(
 392                         printk(KERN_DEBUG "icmp: len problem\n"));
 393                 goto out_dst_release;
 394         }
 395
 396         idev = in6_dev_get(skb->dev);
 397
 398         err = ip6_append_data(sk, icmpv6_getfrag, &msg,
 399                               len + sizeof(struct icmp6hdr),
 400                               sizeof(struct icmp6hdr),
 401                               hlimit, NULL, &fl, (struct rt6_info*)dst,
 402                               MSG_DONTWAIT);
 403         if (err) {
 404                 ip6_flush_pending_frames(sk);
 405                 goto out_put;
 406         }
 407         err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, len + sizeof(struct icmp6hdr));
 408
 409         if (type >= ICMPV6_DEST_UNREACH && type <= ICMPV6_PARAMPROB)
 410                 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_OUTDESTUNREACHS, type - ICMPV6_DEST_UNREACH);
 411         ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTMSGS);
 412
 413 out_put:
 414         if (likely(idev != NULL))
 415                 in6_dev_put(idev);
 416 out_dst_release:
 417         dst_release(dst);
 418 out:
 419         icmpv6_xmit_unlock();
 420 }
 421
 422 static void icmpv6_echo_reply(struct sk_buff *skb)
 423 {
 424         struct sock *sk = icmpv6_socket->sk;
 425         struct inet6_dev *idev;
 426         struct ipv6_pinfo *np = inet6_sk(sk);
 427         struct in6_addr *saddr = NULL;
 428         struct icmp6hdr *icmph = (struct icmp6hdr *) skb->h.raw;
 429         struct icmp6hdr tmp_hdr;
 430         struct flowi fl;
 431         struct icmpv6_msg msg;
 432         struct dst_entry *dst;
 433         int err = 0;
 434         int hlimit;
 435
 436         saddr = &skb->nh.ipv6h->daddr;
 437
 438         if (!ipv6_unicast_destination(skb))
 439                 saddr = NULL;
 440
 441         memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
 442         tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;
 443
 444         memset(&fl, 0, sizeof(fl));
 445         fl.proto = IPPROTO_ICMPV6;
 446         ipv6_addr_copy(&fl.fl6_dst, &skb->nh.ipv6h->saddr);
 447         if (saddr)
 448                 ipv6_addr_copy(&fl.fl6_src, saddr);
 449         fl.oif = skb->dev->ifindex;
 450         fl.fl_icmp_type = ICMPV6_ECHO_REPLY;
 451
 452         if (icmpv6_xmit_lock())
 453                 return;
 454
 455         if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst))
 456                 fl.oif = np->mcast_oif;
 457
 458         err = ip6_dst_lookup(sk, &dst, &fl);
 459         if (err)
 460                 goto out;
 461         if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0)
 462                 goto out_dst_release;
 463
 464         if (ipv6_addr_is_multicast(&fl.fl6_dst))
 465                 hlimit = np->mcast_hops;
 466         else
 467                 hlimit = np->hop_limit;
 468         if (hlimit < 0)
 469                 hlimit = dst_metric(dst, RTAX_HOPLIMIT);
 470
 471         idev = in6_dev_get(skb->dev);
 472
 473         msg.skb = skb;
 474         msg.offset = 0;
 475
 476         err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
 477                                 sizeof(struct icmp6hdr), hlimit, NULL, &fl,
 478                                 (struct rt6_info*)dst, MSG_DONTWAIT);
 479
 480         if (err) {
 481                 ip6_flush_pending_frames(sk);
 482                 goto out_put;
 483         }
 484         err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, skb->len + sizeof(struct icmp6hdr));
 485
 486         ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTECHOREPLIES);
 487         ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTMSGS);
 488
 489 out_put:
 490         if (likely(idev != NULL))
 491                 in6_dev_put(idev);
 492 out_dst_release:
 493         dst_release(dst);
 494 out:
 495         icmpv6_xmit_unlock();
 496 }
 497
 498 static void icmpv6_notify(struct sk_buff *skb, int type, int code, u32 info)
 499 {
 500         struct in6_addr *saddr, *daddr;
 501         struct inet6_protocol *ipprot;
 502         struct sock *sk;
 503         int inner_offset;
 504         int hash;
 505         u8 nexthdr;
 506
 507         if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
 508                 return;
 509
 510         nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
 511         if (ipv6_ext_hdr(nexthdr)) {
 512                 /* now skip over extension headers */
 513                 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr), &nexthdr, skb->len - sizeof(struct ipv6hdr));
 514                 if (inner_offset<0)
 515                         return;
 516         } else {
 517                 inner_offset = sizeof(struct ipv6hdr);
 518         }
 519
 520         /* Checkin header including 8 bytes of inner protocol header. */
 521         if (!pskb_may_pull(skb, inner_offset+8))
 522                 return;
 523
 524         saddr = &skb->nh.ipv6h->saddr;
 525         daddr = &skb->nh.ipv6h->daddr;
 526
 527         /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
 528            Without this we will not able f.e. to make source routed
 529            pmtu discovery.
 530            Corresponding argument (opt) to notifiers is already added.
 531            --ANK (980726)
 532          */
 533
 534         hash = nexthdr & (MAX_INET_PROTOS - 1);
 535
 536         rcu_read_lock();
 537         ipprot = rcu_dereference(inet6_protos[hash]);
 538         if (ipprot && ipprot->err_handler)
 539                 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
 540         rcu_read_unlock();
 541
 542         read_lock(&raw_v6_lock);
 543         if ((sk = sk_head(&raw_v6_htable[hash])) != NULL) {
 544                 while((sk = __raw_v6_lookup(sk, nexthdr, daddr, saddr))) {
 545                         rawv6_err(sk, skb, NULL, type, code, inner_offset, info);
 546                         sk = sk_next(sk);
 547                 }
 548         }
 549         read_unlock(&raw_v6_lock);
 550 }
 551
 552 /*
 553  *      Handle icmp messages
 554  */
 555
 556 static int icmpv6_rcv(struct sk_buff **pskb, unsigned int *nhoffp)
 557 {
 558         struct sk_buff *skb = *pskb;
 559         struct net_device *dev = skb->dev;
 560         struct inet6_dev *idev = __in6_dev_get(dev);
 561         struct in6_addr *saddr, *daddr;
 562         struct ipv6hdr *orig_hdr;
 563         struct icmp6hdr *hdr;
 564         int type;
 565
 566         ICMP6_INC_STATS_BH(idev, ICMP6_MIB_INMSGS);
 567
 568         saddr = &skb->nh.ipv6h->saddr;
 569         daddr = &skb->nh.ipv6h->daddr;
 570
 571         /* Perform checksum. */
 572         if (skb->ip_summed == CHECKSUM_HW) {
 573                 skb->ip_summed = CHECKSUM_UNNECESSARY;
 574                 if (csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
 575                                     skb->csum)) {
 576                         LIMIT_NETDEBUG(
 577                                 printk(KERN_DEBUG "ICMPv6 hw checksum failed\n"));
 578                         skb->ip_summed = CHECKSUM_NONE;
 579                 }
 580         }
 581         if (skb->ip_summed == CHECKSUM_NONE) {
 582                 if (csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6,
 583                                     skb_checksum(skb, 0, skb->len, 0))) {
 584                         LIMIT_NETDEBUG(
 585                                 printk(KERN_DEBUG "ICMPv6 checksum failed [%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x > %04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x]\n",
 586                                        NIP6(*saddr), NIP6(*daddr)));
 587                         goto discard_it;
 588                 }
 589         }
 590
 591         if (!pskb_pull(skb, sizeof(struct icmp6hdr)))
 592                 goto discard_it;
 593
 594         hdr = (struct icmp6hdr *) skb->h.raw;
 595
 596         type = hdr->icmp6_type;
 597
 598         if (type >= ICMPV6_DEST_UNREACH && type <= ICMPV6_PARAMPROB)
 599                 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_INDESTUNREACHS, type - ICMPV6_DEST_UNREACH);
 600         else if (type >= ICMPV6_ECHO_REQUEST && type <= NDISC_REDIRECT)
 601                 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_INECHOS, type - ICMPV6_ECHO_REQUEST);
 602
 603         switch (type) {
 604         case ICMPV6_ECHO_REQUEST:
 605                 icmpv6_echo_reply(skb);
 606                 break;
 607
 608         case ICMPV6_ECHO_REPLY:
 609                 /* we couldn't care less */
 610                 break;
 611
 612         case ICMPV6_PKT_TOOBIG:
 613                 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
 614                    standard destination cache. Seems, only "advanced"
 615                    destination cache will allow to solve this problem
 616                    --ANK (980726)
 617                  */
 618                 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
 619                         goto discard_it;
 620                 hdr = (struct icmp6hdr *) skb->h.raw;
 621                 orig_hdr = (struct ipv6hdr *) (hdr + 1);
 622                 rt6_pmtu_discovery(&orig_hdr->daddr, &orig_hdr->saddr, dev,
 623                                    ntohl(hdr->icmp6_mtu));
 624
 625                 /*
 626                  *      Drop through to notify
 627                  */
 628
 629         case ICMPV6_DEST_UNREACH:
 630         case ICMPV6_TIME_EXCEED:
 631         case ICMPV6_PARAMPROB:
 632                 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
 633                 break;
 634
 635         case NDISC_ROUTER_SOLICITATION:
 636         case NDISC_ROUTER_ADVERTISEMENT:
 637         case NDISC_NEIGHBOUR_SOLICITATION:
 638         case NDISC_NEIGHBOUR_ADVERTISEMENT:
 639         case NDISC_REDIRECT:
 640                 ndisc_rcv(skb);
 641                 break;
 642
 643         case ICMPV6_MGM_QUERY:
 644                 igmp6_event_query(skb);
 645                 break;
 646
 647         case ICMPV6_MGM_REPORT:
 648                 igmp6_event_report(skb);
 649                 break;
 650
 651         case ICMPV6_MGM_REDUCTION:
 652         case ICMPV6_NI_QUERY:
 653         case ICMPV6_NI_REPLY:
 654         case ICMPV6_MLD2_REPORT:
 655         case ICMPV6_DHAAD_REQUEST:
 656         case ICMPV6_DHAAD_REPLY:
 657         case ICMPV6_MOBILE_PREFIX_SOL:
 658         case ICMPV6_MOBILE_PREFIX_ADV:
 659                 break;
 660
 661         default:
 662                 LIMIT_NETDEBUG(
 663                         printk(KERN_DEBUG "icmpv6: msg of unknown type\n"));
 664
 665                 /* informational */
 666                 if (type & ICMPV6_INFOMSG_MASK)
 667                         break;
 668
 669                 /*
 670                  * error of unknown type.
 671                  * must pass to upper level
 672                  */
 673
 674                 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
 675         };
 676         kfree_skb(skb);
 677         return 0;
 678
 679 discard_it:
 680         ICMP6_INC_STATS_BH(idev, ICMP6_MIB_INERRORS);
 681         kfree_skb(skb);
 682         return 0;
 683 }
 684
 685 int __init icmpv6_init(struct net_proto_family *ops)
 686 {
 687         struct sock *sk;
 688         int err, i, j;
 689
 690         for (i = 0; i < NR_CPUS; i++) {
 691                 if (!cpu_possible(i))
 692                         continue;
 693
 694                 err = sock_create_kern(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6,
 695                                        &per_cpu(__icmpv6_socket, i));
 696                 if (err < 0) {
 697                         printk(KERN_ERR
 698                                "Failed to initialize the ICMP6 control socket "
 699                                "(err %d).\n",
 700                                err);
 701                         goto fail;
 702                 }
 703
 704                 sk = per_cpu(__icmpv6_socket, i)->sk;
 705                 sk->sk_allocation = GFP_ATOMIC;
 706
 707                 /* Enough space for 2 64K ICMP packets, including
 708                  * sk_buff struct overhead.
 709                  */
 710                 sk->sk_sndbuf =
 711                         (2 * ((64 * 1024) + sizeof(struct sk_buff)));
 712
 713                 sk->sk_prot->unhash(sk);
 714         }
 715
 716
 717         if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0) {
 718                 printk(KERN_ERR "Failed to register ICMP6 protocol\n");
 719                 err = -EAGAIN;
 720                 goto fail;
 721         }
 722
 723         return 0;
 724
 725  fail:
 726         for (j = 0; j < i; j++) {
 727                 if (!cpu_possible(j))
 728                         continue;
 729                 sock_release(per_cpu(__icmpv6_socket, j));
 730         }
 731
 732         return err;
 733 }
 734
 735 void icmpv6_cleanup(void)
 736 {
 737         int i;
 738
 739         for (i = 0; i < NR_CPUS; i++) {
 740                 if (!cpu_possible(i))
 741                         continue;
 742                 sock_release(per_cpu(__icmpv6_socket, i));
 743         }
 744         inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
 745 }
 746
 747 static struct icmp6_err {
 748         int err;
 749         int fatal;
 750 } tab_unreach[] = {
 751         {       /* NOROUTE */
 752                 .err    = ENETUNREACH,
 753                 .fatal  = 0,
 754         },
 755         {       /* ADM_PROHIBITED */
 756                 .err    = EACCES,
 757                 .fatal  = 1,
 758         },
 759         {       /* Was NOT_NEIGHBOUR, now reserved */
 760                 .err    = EHOSTUNREACH,
 761                 .fatal  = 0,
 762         },
 763         {       /* ADDR_UNREACH */
 764                 .err    = EHOSTUNREACH,
 765                 .fatal  = 0,
 766         },
 767         {       /* PORT_UNREACH */
 768                 .err    = ECONNREFUSED,
 769                 .fatal  = 1,
 770         },
 771 };
 772
 773 int icmpv6_err_convert(int type, int code, int *err)
 774 {
 775         int fatal = 0;
 776
 777         *err = EPROTO;
 778
 779         switch (type) {
 780         case ICMPV6_DEST_UNREACH:
 781                 fatal = 1;
 782                 if (code <= ICMPV6_PORT_UNREACH) {
 783                         *err  = tab_unreach[code].err;
 784                         fatal = tab_unreach[code].fatal;
 785                 }
 786                 break;
 787
 788         case ICMPV6_PKT_TOOBIG:
 789                 *err = EMSGSIZE;
 790                 break;
 791
 792         case ICMPV6_PARAMPROB:
 793                 *err = EPROTO;
 794                 fatal = 1;
 795                 break;
 796
 797         case ICMPV6_TIME_EXCEED:
 798                 *err = EHOSTUNREACH;
 799                 break;
 800         };
 801
 802         return fatal;
 803 }
 804
 805 #ifdef CONFIG_SYSCTL
 806 ctl_table ipv6_icmp_table[] = {
 807         {
 808                 .ctl_name       = NET_IPV6_ICMP_RATELIMIT,
 809                 .procname       = "ratelimit",
 810                 .data           = &sysctl_icmpv6_time,
 811                 .maxlen         = sizeof(int),
 812                 .mode           = 0644,
 813                 .proc_handler   = &proc_dointvec
 814         },
 815         { .ctl_name = 0 },
 816 };
 817 #endif
 818