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 #define pr_fmt(fmt) "IPv6: " fmt
  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 #include <linux/slab.h>
  46
  47 #ifdef CONFIG_SYSCTL
  48 #include <linux/sysctl.h>
  49 #endif
  50
  51 #include <linux/inet.h>
  52 #include <linux/netdevice.h>
  53 #include <linux/icmpv6.h>
  54
  55 #include <net/ip.h>
  56 #include <net/sock.h>
  57
  58 #include <net/ipv6.h>
  59 #include <net/ip6_checksum.h>
  60 #include <net/ping.h>
  61 #include <net/protocol.h>
  62 #include <net/raw.h>
  63 #include <net/rawv6.h>
  64 #include <net/transp_v6.h>
  65 #include <net/ip6_route.h>
  66 #include <net/addrconf.h>
  67 #include <net/icmp.h>
  68 #include <net/xfrm.h>
  69 #include <net/inet_common.h>
  70 #include <net/dsfield.h>
  71 #include <net/l3mdev.h>
  72
  73 #include <linux/uaccess.h>
  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 void icmpv6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
  88                        u8 type, u8 code, int offset, __be32 info)
  89 {
  90         /* icmpv6_notify checks 8 bytes can be pulled, icmp6hdr is 8 bytes */
  91         struct icmp6hdr *icmp6 = (struct icmp6hdr *) (skb->data + offset);
  92         struct net *net = dev_net(skb->dev);
  93
  94         if (type == ICMPV6_PKT_TOOBIG)
  95                 ip6_update_pmtu(skb, net, info, 0, 0, sock_net_uid(net, NULL));
  96         else if (type == NDISC_REDIRECT)
  97                 ip6_redirect(skb, net, skb->dev->ifindex, 0,
  98                              sock_net_uid(net, NULL));
  99
 100         if (!(type & ICMPV6_INFOMSG_MASK))
 101                 if (icmp6->icmp6_type == ICMPV6_ECHO_REQUEST)
 102                         ping_err(skb, offset, ntohl(info));
 103 }
 104
 105 static int icmpv6_rcv(struct sk_buff *skb);
 106
 107 static const struct inet6_protocol icmpv6_protocol = {
 108         .handler        =       icmpv6_rcv,
 109         .err_handler    =       icmpv6_err,
 110         .flags          =       INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
 111 };
 112
 113 /* Called with BH disabled */
 114 static __inline__ struct sock *icmpv6_xmit_lock(struct net *net)
 115 {
 116         struct sock *sk;
 117
 118         sk = icmpv6_sk(net);
 119         if (unlikely(!spin_trylock(&sk->sk_lock.slock))) {
 120                 /* This can happen if the output path (f.e. SIT or
 121                  * ip6ip6 tunnel) signals dst_link_failure() for an
 122                  * outgoing ICMP6 packet.
 123                  */
 124                 return NULL;
 125         }
 126         return sk;
 127 }
 128
 129 static __inline__ void icmpv6_xmit_unlock(struct sock *sk)
 130 {
 131         spin_unlock(&sk->sk_lock.slock);
 132 }
 133
 134 /*
 135  * Figure out, may we reply to this packet with icmp error.
 136  *
 137  * We do not reply, if:
 138  *      - it was icmp error message.
 139  *      - it is truncated, so that it is known, that protocol is ICMPV6
 140  *        (i.e. in the middle of some exthdr)
 141  *
 142  *      --ANK (980726)
 143  */
 144
 145 static bool is_ineligible(const struct sk_buff *skb)
 146 {
 147         int ptr = (u8 *)(ipv6_hdr(skb) + 1) - skb->data;
 148         int len = skb->len - ptr;
 149         __u8 nexthdr = ipv6_hdr(skb)->nexthdr;
 150         __be16 frag_off;
 151
 152         if (len < 0)
 153                 return true;
 154
 155         ptr = ipv6_skip_exthdr(skb, ptr, &nexthdr, &frag_off);
 156         if (ptr < 0)
 157                 return false;
 158         if (nexthdr == IPPROTO_ICMPV6) {
 159                 u8 _type, *tp;
 160                 tp = skb_header_pointer(skb,
 161                         ptr+offsetof(struct icmp6hdr, icmp6_type),
 162                         sizeof(_type), &_type);
 163                 if (!tp || !(*tp & ICMPV6_INFOMSG_MASK))
 164                         return true;
 165         }
 166         return false;
 167 }
 168
 169 static bool icmpv6_mask_allow(int type)
 170 {
 171         /* Informational messages are not limited. */
 172         if (type & ICMPV6_INFOMSG_MASK)
 173                 return true;
 174
 175         /* Do not limit pmtu discovery, it would break it. */
 176         if (type == ICMPV6_PKT_TOOBIG)
 177                 return true;
 178
 179         return false;
 180 }
 181
 182 static bool icmpv6_global_allow(int type)
 183 {
 184         if (icmpv6_mask_allow(type))
 185                 return true;
 186
 187         if (icmp_global_allow())
 188                 return true;
 189
 190         return false;
 191 }
 192
 193 /*
 194  * Check the ICMP output rate limit
 195  */
 196 static bool icmpv6_xrlim_allow(struct sock *sk, u8 type,
 197                                struct flowi6 *fl6)
 198 {
 199         struct net *net = sock_net(sk);
 200         struct dst_entry *dst;
 201         bool res = false;
 202
 203         if (icmpv6_mask_allow(type))
 204                 return true;
 205
 206         /*
 207          * Look up the output route.
 208          * XXX: perhaps the expire for routing entries cloned by
 209          * this lookup should be more aggressive (not longer than timeout).
 210          */
 211         dst = ip6_route_output(net, sk, fl6);
 212         if (dst->error) {
 213                 IP6_INC_STATS(net, ip6_dst_idev(dst),
 214                               IPSTATS_MIB_OUTNOROUTES);
 215         } else if (dst->dev && (dst->dev->flags&IFF_LOOPBACK)) {
 216                 res = true;
 217         } else {
 218                 struct rt6_info *rt = (struct rt6_info *)dst;
 219                 int tmo = net->ipv6.sysctl.icmpv6_time;
 220                 struct inet_peer *peer;
 221
 222                 /* Give more bandwidth to wider prefixes. */
 223                 if (rt->rt6i_dst.plen < 128)
 224                         tmo >>= ((128 - rt->rt6i_dst.plen)>>5);
 225
 226                 peer = inet_getpeer_v6(net->ipv6.peers, &fl6->daddr, 1);
 227                 res = inet_peer_xrlim_allow(peer, tmo);
 228                 if (peer)
 229                         inet_putpeer(peer);
 230         }
 231         dst_release(dst);
 232         return res;
 233 }
 234
 235 /*
 236  *      an inline helper for the "simple" if statement below
 237  *      checks if parameter problem report is caused by an
 238  *      unrecognized IPv6 option that has the Option Type
 239  *      highest-order two bits set to 10
 240  */
 241
 242 static bool opt_unrec(struct sk_buff *skb, __u32 offset)
 243 {
 244         u8 _optval, *op;
 245
 246         offset += skb_network_offset(skb);
 247         op = skb_header_pointer(skb, offset, sizeof(_optval), &_optval);
 248         if (!op)
 249                 return true;
 250         return (*op & 0xC0) == 0x80;
 251 }
 252
 253 int icmpv6_push_pending_frames(struct sock *sk, struct flowi6 *fl6,
 254                                struct icmp6hdr *thdr, int len)
 255 {
 256         struct sk_buff *skb;
 257         struct icmp6hdr *icmp6h;
 258         int err = 0;
 259
 260         skb = skb_peek(&sk->sk_write_queue);
 261         if (!skb)
 262                 goto out;
 263
 264         icmp6h = icmp6_hdr(skb);
 265         memcpy(icmp6h, thdr, sizeof(struct icmp6hdr));
 266         icmp6h->icmp6_cksum = 0;
 267
 268         if (skb_queue_len(&sk->sk_write_queue) == 1) {
 269                 skb->csum = csum_partial(icmp6h,
 270                                         sizeof(struct icmp6hdr), skb->csum);
 271                 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
 272                                                       &fl6->daddr,
 273                                                       len, fl6->flowi6_proto,
 274                                                       skb->csum);
 275         } else {
 276                 __wsum tmp_csum = 0;
 277
 278                 skb_queue_walk(&sk->sk_write_queue, skb) {
 279                         tmp_csum = csum_add(tmp_csum, skb->csum);
 280                 }
 281
 282                 tmp_csum = csum_partial(icmp6h,
 283                                         sizeof(struct icmp6hdr), tmp_csum);
 284                 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
 285                                                       &fl6->daddr,
 286                                                       len, fl6->flowi6_proto,
 287                                                       tmp_csum);
 288         }
 289         ip6_push_pending_frames(sk);
 290 out:
 291         return err;
 292 }
 293
 294 struct icmpv6_msg {
 295         struct sk_buff  *skb;
 296         int             offset;
 297         uint8_t         type;
 298 };
 299
 300 static int icmpv6_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb)
 301 {
 302         struct icmpv6_msg *msg = (struct icmpv6_msg *) from;
 303         struct sk_buff *org_skb = msg->skb;
 304         __wsum csum = 0;
 305
 306         csum = skb_copy_and_csum_bits(org_skb, msg->offset + offset,
 307                                       to, len, csum);
 308         skb->csum = csum_block_add(skb->csum, csum, odd);
 309         if (!(msg->type & ICMPV6_INFOMSG_MASK))
 310                 nf_ct_attach(skb, org_skb);
 311         return 0;
 312 }
 313
 314 #if IS_ENABLED(CONFIG_IPV6_MIP6)
 315 static void mip6_addr_swap(struct sk_buff *skb, const struct inet6_skb_parm *opt)
 316 {
 317         struct ipv6hdr *iph = ipv6_hdr(skb);
 318         struct ipv6_destopt_hao *hao;
 319         struct in6_addr tmp;
 320         int off;
 321
 322         if (opt->dsthao) {
 323                 off = ipv6_find_tlv(skb, opt->dsthao, IPV6_TLV_HAO);
 324                 if (likely(off >= 0)) {
 325                         hao = (struct ipv6_destopt_hao *)
 326                                         (skb_network_header(skb) + off);
 327                         tmp = iph->saddr;
 328                         iph->saddr = hao->addr;
 329                         hao->addr = tmp;
 330                 }
 331         }
 332 }
 333 #else
 334 static inline void mip6_addr_swap(struct sk_buff *skb, const struct inet6_skb_parm *opt) {}
 335 #endif
 336
 337 static struct dst_entry *icmpv6_route_lookup(struct net *net,
 338                                              struct sk_buff *skb,
 339                                              struct sock *sk,
 340                                              struct flowi6 *fl6)
 341 {
 342         struct dst_entry *dst, *dst2;
 343         struct flowi6 fl2;
 344         int err;
 345
 346         err = ip6_dst_lookup(net, sk, &dst, fl6);
 347         if (err)
 348                 return ERR_PTR(err);
 349
 350         /*
 351          * We won't send icmp if the destination is known
 352          * anycast.
 353          */
 354         if (ipv6_anycast_destination(dst, &fl6->daddr)) {
 355                 net_dbg_ratelimited("icmp6_send: acast source\n");
 356                 dst_release(dst);
 357                 return ERR_PTR(-EINVAL);
 358         }
 359
 360         /* No need to clone since we're just using its address. */
 361         dst2 = dst;
 362
 363         dst = xfrm_lookup(net, dst, flowi6_to_flowi(fl6), sk, 0);
 364         if (!IS_ERR(dst)) {
 365                 if (dst != dst2)
 366                         return dst;
 367         } else {
 368                 if (PTR_ERR(dst) == -EPERM)
 369                         dst = NULL;
 370                 else
 371                         return dst;
 372         }
 373
 374         err = xfrm_decode_session_reverse(skb, flowi6_to_flowi(&fl2), AF_INET6);
 375         if (err)
 376                 goto relookup_failed;
 377
 378         err = ip6_dst_lookup(net, sk, &dst2, &fl2);
 379         if (err)
 380                 goto relookup_failed;
 381
 382         dst2 = xfrm_lookup(net, dst2, flowi6_to_flowi(&fl2), sk, XFRM_LOOKUP_ICMP);
 383         if (!IS_ERR(dst2)) {
 384                 dst_release(dst);
 385                 dst = dst2;
 386         } else {
 387                 err = PTR_ERR(dst2);
 388                 if (err == -EPERM) {
 389                         dst_release(dst);
 390                         return dst2;
 391                 } else
 392                         goto relookup_failed;
 393         }
 394
 395 relookup_failed:
 396         if (dst)
 397                 return dst;
 398         return ERR_PTR(err);
 399 }
 400
 401 static int icmp6_iif(const struct sk_buff *skb)
 402 {
 403         int iif = skb->dev->ifindex;
 404
 405         /* for local traffic to local address, skb dev is the loopback
 406          * device. Check if there is a dst attached to the skb and if so
 407          * get the real device index. Same is needed for replies to a link
 408          * local address on a device enslaved to an L3 master device
 409          */
 410         if (unlikely(iif == LOOPBACK_IFINDEX || netif_is_l3_master(skb->dev))) {
 411                 const struct rt6_info *rt6 = skb_rt6_info(skb);
 412
 413                 if (rt6)
 414                         iif = rt6->rt6i_idev->dev->ifindex;
 415         }
 416
 417         return iif;
 418 }
 419
 420 /*
 421  *      Send an ICMP message in response to a packet in error
 422  */
 423 void icmp6_send(struct sk_buff *skb, u8 type, u8 code, __u32 info,
 424                 const struct in6_addr *force_saddr,
 425                 const struct inet6_skb_parm *parm)
 426 {
 427         struct net *net = dev_net(skb->dev);
 428         struct inet6_dev *idev = NULL;
 429         struct ipv6hdr *hdr = ipv6_hdr(skb);
 430         struct sock *sk;
 431         struct ipv6_pinfo *np;
 432         const struct in6_addr *saddr = NULL;
 433         struct dst_entry *dst;
 434         struct icmp6hdr tmp_hdr;
 435         struct flowi6 fl6;
 436         struct icmpv6_msg msg;
 437         struct sockcm_cookie sockc_unused = {0};
 438         struct ipcm6_cookie ipc6;
 439         int iif = 0;
 440         int addr_type = 0;
 441         int len;
 442         int err = 0;
 443         u32 mark = IP6_REPLY_MARK(net, skb->mark);
 444
 445         if ((u8 *)hdr < skb->head ||
 446             (skb_network_header(skb) + sizeof(*hdr)) > skb_tail_pointer(skb))
 447                 return;
 448
 449         /*
 450          *      Make sure we respect the rules
 451          *      i.e. RFC 1885 2.4(e)
 452          *      Rule (e.1) is enforced by not using icmp6_send
 453          *      in any code that processes icmp errors.
 454          */
 455         addr_type = ipv6_addr_type(&hdr->daddr);
 456
 457         if (ipv6_chk_addr(net, &hdr->daddr, skb->dev, 0) ||
 458             ipv6_chk_acast_addr_src(net, skb->dev, &hdr->daddr))
 459                 saddr = &hdr->daddr;
 460
 461         /*
 462          *      Dest addr check
 463          */
 464
 465         if (addr_type & IPV6_ADDR_MULTICAST || skb->pkt_type != PACKET_HOST) {
 466                 if (type != ICMPV6_PKT_TOOBIG &&
 467                     !(type == ICMPV6_PARAMPROB &&
 468                       code == ICMPV6_UNK_OPTION &&
 469                       (opt_unrec(skb, info))))
 470                         return;
 471
 472                 saddr = NULL;
 473         }
 474
 475         addr_type = ipv6_addr_type(&hdr->saddr);
 476
 477         /*
 478          *      Source addr check
 479          */
 480
 481         if (__ipv6_addr_needs_scope_id(addr_type)) {
 482                 iif = icmp6_iif(skb);
 483         } else {
 484                 dst = skb_dst(skb);
 485                 iif = l3mdev_master_ifindex(dst ? dst->dev : skb->dev);
 486         }
 487
 488         /*
 489          *      Must not send error if the source does not uniquely
 490          *      identify a single node (RFC2463 Section 2.4).
 491          *      We check unspecified / multicast addresses here,
 492          *      and anycast addresses will be checked later.
 493          */
 494         if ((addr_type == IPV6_ADDR_ANY) || (addr_type & IPV6_ADDR_MULTICAST)) {
 495                 net_dbg_ratelimited("icmp6_send: addr_any/mcast source [%pI6c > %pI6c]\n",
 496                                     &hdr->saddr, &hdr->daddr);
 497                 return;
 498         }
 499
 500         /*
 501          *      Never answer to a ICMP packet.
 502          */
 503         if (is_ineligible(skb)) {
 504                 net_dbg_ratelimited("icmp6_send: no reply to icmp error [%pI6c > %pI6c]\n",
 505                                     &hdr->saddr, &hdr->daddr);
 506                 return;
 507         }
 508
 509         /* Needed by both icmp_global_allow and icmpv6_xmit_lock */
 510         local_bh_disable();
 511
 512         /* Check global sysctl_icmp_msgs_per_sec ratelimit */
 513         if (!(skb->dev->flags&IFF_LOOPBACK) && !icmpv6_global_allow(type))
 514                 goto out_bh_enable;
 515
 516         mip6_addr_swap(skb, parm);
 517
 518         memset(&fl6, 0, sizeof(fl6));
 519         fl6.flowi6_proto = IPPROTO_ICMPV6;
 520         fl6.daddr = hdr->saddr;
 521         if (force_saddr)
 522                 saddr = force_saddr;
 523         if (saddr)
 524                 fl6.saddr = *saddr;
 525         fl6.flowi6_mark = mark;
 526         fl6.flowi6_oif = iif;
 527         fl6.fl6_icmp_type = type;
 528         fl6.fl6_icmp_code = code;
 529         fl6.flowi6_uid = sock_net_uid(net, NULL);
 530         fl6.mp_hash = rt6_multipath_hash(&fl6, skb);
 531         security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
 532
 533         sk = icmpv6_xmit_lock(net);
 534         if (!sk)
 535                 goto out_bh_enable;
 536
 537         sk->sk_mark = mark;
 538         np = inet6_sk(sk);
 539
 540         if (!icmpv6_xrlim_allow(sk, type, &fl6))
 541                 goto out;
 542
 543         tmp_hdr.icmp6_type = type;
 544         tmp_hdr.icmp6_code = code;
 545         tmp_hdr.icmp6_cksum = 0;
 546         tmp_hdr.icmp6_pointer = htonl(info);
 547
 548         if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
 549                 fl6.flowi6_oif = np->mcast_oif;
 550         else if (!fl6.flowi6_oif)
 551                 fl6.flowi6_oif = np->ucast_oif;
 552
 553         ipc6.tclass = np->tclass;
 554         fl6.flowlabel = ip6_make_flowinfo(ipc6.tclass, fl6.flowlabel);
 555
 556         dst = icmpv6_route_lookup(net, skb, sk, &fl6);
 557         if (IS_ERR(dst))
 558                 goto out;
 559
 560         ipc6.hlimit = ip6_sk_dst_hoplimit(np, &fl6, dst);
 561         ipc6.dontfrag = np->dontfrag;
 562         ipc6.opt = NULL;
 563
 564         msg.skb = skb;
 565         msg.offset = skb_network_offset(skb);
 566         msg.type = type;
 567
 568         len = skb->len - msg.offset;
 569         len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) - sizeof(struct icmp6hdr));
 570         if (len < 0) {
 571                 net_dbg_ratelimited("icmp: len problem [%pI6c > %pI6c]\n",
 572                                     &hdr->saddr, &hdr->daddr);
 573                 goto out_dst_release;
 574         }
 575
 576         rcu_read_lock();
 577         idev = __in6_dev_get(skb->dev);
 578
 579         err = ip6_append_data(sk, icmpv6_getfrag, &msg,
 580                               len + sizeof(struct icmp6hdr),
 581                               sizeof(struct icmp6hdr),
 582                               &ipc6, &fl6, (struct rt6_info *)dst,
 583                               MSG_DONTWAIT, &sockc_unused);
 584         if (err) {
 585                 ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTERRORS);
 586                 ip6_flush_pending_frames(sk);
 587         } else {
 588                 err = icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
 589                                                  len + sizeof(struct icmp6hdr));
 590         }
 591         rcu_read_unlock();
 592 out_dst_release:
 593         dst_release(dst);
 594 out:
 595         icmpv6_xmit_unlock(sk);
 596 out_bh_enable:
 597         local_bh_enable();
 598 }
 599 EXPORT_SYMBOL(icmp6_send);
 600
 601 /* Slightly more convenient version of icmp6_send.
 602  */
 603 void icmpv6_param_prob(struct sk_buff *skb, u8 code, int pos)
 604 {
 605         icmp6_send(skb, ICMPV6_PARAMPROB, code, pos, NULL, IP6CB(skb));
 606         kfree_skb(skb);
 607 }
 608
 609 /* Generate icmpv6 with type/code ICMPV6_DEST_UNREACH/ICMPV6_ADDR_UNREACH
 610  * if sufficient data bytes are available
 611  * @nhs is the size of the tunnel header(s) :
 612  *  Either an IPv4 header for SIT encap
 613  *         an IPv4 header + GRE header for GRE encap
 614  */
 615 int ip6_err_gen_icmpv6_unreach(struct sk_buff *skb, int nhs, int type,
 616                                unsigned int data_len)
 617 {
 618         struct in6_addr temp_saddr;
 619         struct rt6_info *rt;
 620         struct sk_buff *skb2;
 621         u32 info = 0;
 622
 623         if (!pskb_may_pull(skb, nhs + sizeof(struct ipv6hdr) + 8))
 624                 return 1;
 625
 626         /* RFC 4884 (partial) support for ICMP extensions */
 627         if (data_len < 128 || (data_len & 7) || skb->len < data_len)
 628                 data_len = 0;
 629
 630         skb2 = data_len ? skb_copy(skb, GFP_ATOMIC) : skb_clone(skb, GFP_ATOMIC);
 631
 632         if (!skb2)
 633                 return 1;
 634
 635         skb_dst_drop(skb2);
 636         skb_pull(skb2, nhs);
 637         skb_reset_network_header(skb2);
 638
 639         rt = rt6_lookup(dev_net(skb->dev), &ipv6_hdr(skb2)->saddr, NULL, 0, 0);
 640
 641         if (rt && rt->dst.dev)
 642                 skb2->dev = rt->dst.dev;
 643
 644         ipv6_addr_set_v4mapped(ip_hdr(skb)->saddr, &temp_saddr);
 645
 646         if (data_len) {
 647                 /* RFC 4884 (partial) support :
 648                  * insert 0 padding at the end, before the extensions
 649                  */
 650                 __skb_push(skb2, nhs);
 651                 skb_reset_network_header(skb2);
 652                 memmove(skb2->data, skb2->data + nhs, data_len - nhs);
 653                 memset(skb2->data + data_len - nhs, 0, nhs);
 654                 /* RFC 4884 4.5 : Length is measured in 64-bit words,
 655                  * and stored in reserved[0]
 656                  */
 657                 info = (data_len/8) << 24;
 658         }
 659         if (type == ICMP_TIME_EXCEEDED)
 660                 icmp6_send(skb2, ICMPV6_TIME_EXCEED, ICMPV6_EXC_HOPLIMIT,
 661                            info, &temp_saddr, IP6CB(skb2));
 662         else
 663                 icmp6_send(skb2, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH,
 664                            info, &temp_saddr, IP6CB(skb2));
 665         if (rt)
 666                 ip6_rt_put(rt);
 667
 668         kfree_skb(skb2);
 669
 670         return 0;
 671 }
 672 EXPORT_SYMBOL(ip6_err_gen_icmpv6_unreach);
 673
 674 static void icmpv6_echo_reply(struct sk_buff *skb)
 675 {
 676         struct net *net = dev_net(skb->dev);
 677         struct sock *sk;
 678         struct inet6_dev *idev;
 679         struct ipv6_pinfo *np;
 680         const struct in6_addr *saddr = NULL;
 681         struct icmp6hdr *icmph = icmp6_hdr(skb);
 682         struct icmp6hdr tmp_hdr;
 683         struct flowi6 fl6;
 684         struct icmpv6_msg msg;
 685         struct dst_entry *dst;
 686         struct ipcm6_cookie ipc6;
 687         int err = 0;
 688         u32 mark = IP6_REPLY_MARK(net, skb->mark);
 689         struct sockcm_cookie sockc_unused = {0};
 690
 691         saddr = &ipv6_hdr(skb)->daddr;
 692
 693         if (!ipv6_unicast_destination(skb) &&
 694             !(net->ipv6.sysctl.anycast_src_echo_reply &&
 695               ipv6_anycast_destination(skb_dst(skb), saddr)))
 696                 saddr = NULL;
 697
 698         memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
 699         tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;
 700
 701         memset(&fl6, 0, sizeof(fl6));
 702         fl6.flowi6_proto = IPPROTO_ICMPV6;
 703         fl6.daddr = ipv6_hdr(skb)->saddr;
 704         if (saddr)
 705                 fl6.saddr = *saddr;
 706         fl6.flowi6_oif = icmp6_iif(skb);
 707         fl6.fl6_icmp_type = ICMPV6_ECHO_REPLY;
 708         fl6.flowi6_mark = mark;
 709         fl6.flowi6_uid = sock_net_uid(net, NULL);
 710         security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
 711
 712         local_bh_disable();
 713         sk = icmpv6_xmit_lock(net);
 714         if (!sk)
 715                 goto out_bh_enable;
 716         sk->sk_mark = mark;
 717         np = inet6_sk(sk);
 718
 719         if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
 720                 fl6.flowi6_oif = np->mcast_oif;
 721         else if (!fl6.flowi6_oif)
 722                 fl6.flowi6_oif = np->ucast_oif;
 723
 724         err = ip6_dst_lookup(net, sk, &dst, &fl6);
 725         if (err)
 726                 goto out;
 727         dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), sk, 0);
 728         if (IS_ERR(dst))
 729                 goto out;
 730
 731         idev = __in6_dev_get(skb->dev);
 732
 733         msg.skb = skb;
 734         msg.offset = 0;
 735         msg.type = ICMPV6_ECHO_REPLY;
 736
 737         ipc6.hlimit = ip6_sk_dst_hoplimit(np, &fl6, dst);
 738         ipc6.tclass = ipv6_get_dsfield(ipv6_hdr(skb));
 739         ipc6.dontfrag = np->dontfrag;
 740         ipc6.opt = NULL;
 741
 742         err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr),
 743                                 sizeof(struct icmp6hdr), &ipc6, &fl6,
 744                                 (struct rt6_info *)dst, MSG_DONTWAIT,
 745                                 &sockc_unused);
 746
 747         if (err) {
 748                 __ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTERRORS);
 749                 ip6_flush_pending_frames(sk);
 750         } else {
 751                 err = icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
 752                                                  skb->len + sizeof(struct icmp6hdr));
 753         }
 754         dst_release(dst);
 755 out:
 756         icmpv6_xmit_unlock(sk);
 757 out_bh_enable:
 758         local_bh_enable();
 759 }
 760
 761 void icmpv6_notify(struct sk_buff *skb, u8 type, u8 code, __be32 info)
 762 {
 763         const struct inet6_protocol *ipprot;
 764         int inner_offset;
 765         __be16 frag_off;
 766         u8 nexthdr;
 767         struct net *net = dev_net(skb->dev);
 768
 769         if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
 770                 goto out;
 771
 772         nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
 773         if (ipv6_ext_hdr(nexthdr)) {
 774                 /* now skip over extension headers */
 775                 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr),
 776                                                 &nexthdr, &frag_off);
 777                 if (inner_offset < 0)
 778                         goto out;
 779         } else {
 780                 inner_offset = sizeof(struct ipv6hdr);
 781         }
 782
 783         /* Checkin header including 8 bytes of inner protocol header. */
 784         if (!pskb_may_pull(skb, inner_offset+8))
 785                 goto out;
 786
 787         /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
 788            Without this we will not able f.e. to make source routed
 789            pmtu discovery.
 790            Corresponding argument (opt) to notifiers is already added.
 791            --ANK (980726)
 792          */
 793
 794         ipprot = rcu_dereference(inet6_protos[nexthdr]);
 795         if (ipprot && ipprot->err_handler)
 796                 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
 797
 798         raw6_icmp_error(skb, nexthdr, type, code, inner_offset, info);
 799         return;
 800
 801 out:
 802         __ICMP6_INC_STATS(net, __in6_dev_get(skb->dev), ICMP6_MIB_INERRORS);
 803 }
 804
 805 /*
 806  *      Handle icmp messages
 807  */
 808
 809 static int icmpv6_rcv(struct sk_buff *skb)
 810 {
 811         struct net_device *dev = skb->dev;
 812         struct inet6_dev *idev = __in6_dev_get(dev);
 813         const struct in6_addr *saddr, *daddr;
 814         struct icmp6hdr *hdr;
 815         u8 type;
 816         bool success = false;
 817
 818         if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
 819                 struct sec_path *sp = skb_sec_path(skb);
 820                 int nh;
 821
 822                 if (!(sp && sp->xvec[sp->len - 1]->props.flags &
 823                                  XFRM_STATE_ICMP))
 824                         goto drop_no_count;
 825
 826                 if (!pskb_may_pull(skb, sizeof(*hdr) + sizeof(struct ipv6hdr)))
 827                         goto drop_no_count;
 828
 829                 nh = skb_network_offset(skb);
 830                 skb_set_network_header(skb, sizeof(*hdr));
 831
 832                 if (!xfrm6_policy_check_reverse(NULL, XFRM_POLICY_IN, skb))
 833                         goto drop_no_count;
 834
 835                 skb_set_network_header(skb, nh);
 836         }
 837
 838         __ICMP6_INC_STATS(dev_net(dev), idev, ICMP6_MIB_INMSGS);
 839
 840         saddr = &ipv6_hdr(skb)->saddr;
 841         daddr = &ipv6_hdr(skb)->daddr;
 842
 843         if (skb_checksum_validate(skb, IPPROTO_ICMPV6, ip6_compute_pseudo)) {
 844                 net_dbg_ratelimited("ICMPv6 checksum failed [%pI6c > %pI6c]\n",
 845                                     saddr, daddr);
 846                 goto csum_error;
 847         }
 848
 849         if (!pskb_pull(skb, sizeof(*hdr)))
 850                 goto discard_it;
 851
 852         hdr = icmp6_hdr(skb);
 853
 854         type = hdr->icmp6_type;
 855
 856         ICMP6MSGIN_INC_STATS(dev_net(dev), idev, type);
 857
 858         switch (type) {
 859         case ICMPV6_ECHO_REQUEST:
 860                 icmpv6_echo_reply(skb);
 861                 break;
 862
 863         case ICMPV6_ECHO_REPLY:
 864                 success = ping_rcv(skb);
 865                 break;
 866
 867         case ICMPV6_PKT_TOOBIG:
 868                 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
 869                    standard destination cache. Seems, only "advanced"
 870                    destination cache will allow to solve this problem
 871                    --ANK (980726)
 872                  */
 873                 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
 874                         goto discard_it;
 875                 hdr = icmp6_hdr(skb);
 876
 877                 /*
 878                  *      Drop through to notify
 879                  */
 880
 881         case ICMPV6_DEST_UNREACH:
 882         case ICMPV6_TIME_EXCEED:
 883         case ICMPV6_PARAMPROB:
 884                 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
 885                 break;
 886
 887         case NDISC_ROUTER_SOLICITATION:
 888         case NDISC_ROUTER_ADVERTISEMENT:
 889         case NDISC_NEIGHBOUR_SOLICITATION:
 890         case NDISC_NEIGHBOUR_ADVERTISEMENT:
 891         case NDISC_REDIRECT:
 892                 ndisc_rcv(skb);
 893                 break;
 894
 895         case ICMPV6_MGM_QUERY:
 896                 igmp6_event_query(skb);
 897                 break;
 898
 899         case ICMPV6_MGM_REPORT:
 900                 igmp6_event_report(skb);
 901                 break;
 902
 903         case ICMPV6_MGM_REDUCTION:
 904         case ICMPV6_NI_QUERY:
 905         case ICMPV6_NI_REPLY:
 906         case ICMPV6_MLD2_REPORT:
 907         case ICMPV6_DHAAD_REQUEST:
 908         case ICMPV6_DHAAD_REPLY:
 909         case ICMPV6_MOBILE_PREFIX_SOL:
 910         case ICMPV6_MOBILE_PREFIX_ADV:
 911                 break;
 912
 913         default:
 914                 /* informational */
 915                 if (type & ICMPV6_INFOMSG_MASK)
 916                         break;
 917
 918                 net_dbg_ratelimited("icmpv6: msg of unknown type [%pI6c > %pI6c]\n",
 919                                     saddr, daddr);
 920
 921                 /*
 922                  * error of unknown type.
 923                  * must pass to upper level
 924                  */
 925
 926                 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
 927         }
 928
 929         /* until the v6 path can be better sorted assume failure and
 930          * preserve the status quo behaviour for the rest of the paths to here
 931          */
 932         if (success)
 933                 consume_skb(skb);
 934         else
 935                 kfree_skb(skb);
 936
 937         return 0;
 938
 939 csum_error:
 940         __ICMP6_INC_STATS(dev_net(dev), idev, ICMP6_MIB_CSUMERRORS);
 941 discard_it:
 942         __ICMP6_INC_STATS(dev_net(dev), idev, ICMP6_MIB_INERRORS);
 943 drop_no_count:
 944         kfree_skb(skb);
 945         return 0;
 946 }
 947
 948 void icmpv6_flow_init(struct sock *sk, struct flowi6 *fl6,
 949                       u8 type,
 950                       const struct in6_addr *saddr,
 951                       const struct in6_addr *daddr,
 952                       int oif)
 953 {
 954         memset(fl6, 0, sizeof(*fl6));
 955         fl6->saddr = *saddr;
 956         fl6->daddr = *daddr;
 957         fl6->flowi6_proto       = IPPROTO_ICMPV6;
 958         fl6->fl6_icmp_type      = type;
 959         fl6->fl6_icmp_code      = 0;
 960         fl6->flowi6_oif         = oif;
 961         security_sk_classify_flow(sk, flowi6_to_flowi(fl6));
 962 }
 963
 964 static int __net_init icmpv6_sk_init(struct net *net)
 965 {
 966         struct sock *sk;
 967         int err, i, j;
 968
 969         net->ipv6.icmp_sk =
 970                 kzalloc(nr_cpu_ids * sizeof(struct sock *), GFP_KERNEL);
 971         if (!net->ipv6.icmp_sk)
 972                 return -ENOMEM;
 973
 974         for_each_possible_cpu(i) {
 975                 err = inet_ctl_sock_create(&sk, PF_INET6,
 976                                            SOCK_RAW, IPPROTO_ICMPV6, net);
 977                 if (err < 0) {
 978                         pr_err("Failed to initialize the ICMP6 control socket (err %d)\n",
 979                                err);
 980                         goto fail;
 981                 }
 982
 983                 net->ipv6.icmp_sk[i] = sk;
 984
 985                 /* Enough space for 2 64K ICMP packets, including
 986                  * sk_buff struct overhead.
 987                  */
 988                 sk->sk_sndbuf = 2 * SKB_TRUESIZE(64 * 1024);
 989         }
 990         return 0;
 991
 992  fail:
 993         for (j = 0; j < i; j++)
 994                 inet_ctl_sock_destroy(net->ipv6.icmp_sk[j]);
 995         kfree(net->ipv6.icmp_sk);
 996         return err;
 997 }
 998
 999 static void __net_exit icmpv6_sk_exit(struct net *net)
1000 {
1001         int i;
1002
1003         for_each_possible_cpu(i) {
1004                 inet_ctl_sock_destroy(net->ipv6.icmp_sk[i]);
1005         }
1006         kfree(net->ipv6.icmp_sk);
1007 }
1008
1009 static struct pernet_operations icmpv6_sk_ops = {
1010         .init = icmpv6_sk_init,
1011         .exit = icmpv6_sk_exit,
1012 };
1013
1014 int __init icmpv6_init(void)
1015 {
1016         int err;
1017
1018         err = register_pernet_subsys(&icmpv6_sk_ops);
1019         if (err < 0)
1020                 return err;
1021
1022         err = -EAGAIN;
1023         if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0)
1024                 goto fail;
1025
1026         err = inet6_register_icmp_sender(icmp6_send);
1027         if (err)
1028                 goto sender_reg_err;
1029         return 0;
1030
1031 sender_reg_err:
1032         inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
1033 fail:
1034         pr_err("Failed to register ICMP6 protocol\n");
1035         unregister_pernet_subsys(&icmpv6_sk_ops);
1036         return err;
1037 }
1038
1039 void icmpv6_cleanup(void)
1040 {
1041         inet6_unregister_icmp_sender(icmp6_send);
1042         unregister_pernet_subsys(&icmpv6_sk_ops);
1043         inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
1044 }
1045
1046
1047 static const struct icmp6_err {
1048         int err;
1049         int fatal;
1050 } tab_unreach[] = {
1051         {       /* NOROUTE */
1052                 .err    = ENETUNREACH,
1053                 .fatal  = 0,
1054         },
1055         {       /* ADM_PROHIBITED */
1056                 .err    = EACCES,
1057                 .fatal  = 1,
1058         },
1059         {       /* Was NOT_NEIGHBOUR, now reserved */
1060                 .err    = EHOSTUNREACH,
1061                 .fatal  = 0,
1062         },
1063         {       /* ADDR_UNREACH */
1064                 .err    = EHOSTUNREACH,
1065                 .fatal  = 0,
1066         },
1067         {       /* PORT_UNREACH */
1068                 .err    = ECONNREFUSED,
1069                 .fatal  = 1,
1070         },
1071         {       /* POLICY_FAIL */
1072                 .err    = EACCES,
1073                 .fatal  = 1,
1074         },
1075         {       /* REJECT_ROUTE */
1076                 .err    = EACCES,
1077                 .fatal  = 1,
1078         },
1079 };
1080
1081 int icmpv6_err_convert(u8 type, u8 code, int *err)
1082 {
1083         int fatal = 0;
1084
1085         *err = EPROTO;
1086
1087         switch (type) {
1088         case ICMPV6_DEST_UNREACH:
1089                 fatal = 1;
1090                 if (code < ARRAY_SIZE(tab_unreach)) {
1091                         *err  = tab_unreach[code].err;
1092                         fatal = tab_unreach[code].fatal;
1093                 }
1094                 break;
1095
1096         case ICMPV6_PKT_TOOBIG:
1097                 *err = EMSGSIZE;
1098                 break;
1099
1100         case ICMPV6_PARAMPROB:
1101                 *err = EPROTO;
1102                 fatal = 1;
1103                 break;
1104
1105         case ICMPV6_TIME_EXCEED:
1106                 *err = EHOSTUNREACH;
1107                 break;
1108         }
1109
1110         return fatal;
1111 }
1112 EXPORT_SYMBOL(icmpv6_err_convert);
1113
1114 #ifdef CONFIG_SYSCTL
1115 static struct ctl_table ipv6_icmp_table_template[] = {
1116         {
1117                 .procname       = "ratelimit",
1118                 .data           = &init_net.ipv6.sysctl.icmpv6_time,
1119                 .maxlen         = sizeof(int),
1120                 .mode           = 0644,
1121                 .proc_handler   = proc_dointvec_ms_jiffies,
1122         },
1123         { },
1124 };
1125
1126 struct ctl_table * __net_init ipv6_icmp_sysctl_init(struct net *net)
1127 {
1128         struct ctl_table *table;
1129
1130         table = kmemdup(ipv6_icmp_table_template,
1131                         sizeof(ipv6_icmp_table_template),
1132                         GFP_KERNEL);
1133
1134         if (table)
1135                 table[0].data = &net->ipv6.sysctl.icmpv6_time;
1136
1137         return table;
1138 }
1139 #endif