net/ipv6/icmp.c

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