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 int 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, skb->dev->ifindex, 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         return 0;
 105 }
 106
 107 static int icmpv6_rcv(struct sk_buff *skb);
 108
 109 static const struct inet6_protocol icmpv6_protocol = {
 110         .handler        =       icmpv6_rcv,
 111         .err_handler    =       icmpv6_err,
 112         .flags          =       INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
 113 };
 114
 115 /* Called with BH disabled */
 116 static __inline__ struct sock *icmpv6_xmit_lock(struct net *net)
 117 {
 118         struct sock *sk;
 119
 120         sk = icmpv6_sk(net);
 121         if (unlikely(!spin_trylock(&sk->sk_lock.slock))) {
 122                 /* This can happen if the output path (f.e. SIT or
 123                  * ip6ip6 tunnel) signals dst_link_failure() for an
 124                  * outgoing ICMP6 packet.
 125                  */
 126                 return NULL;
 127         }
 128         return sk;
 129 }
 130
 131 static __inline__ void icmpv6_xmit_unlock(struct sock *sk)
 132 {
 133         spin_unlock(&sk->sk_lock.slock);
 134 }
 135
 136 /*
 137  * Figure out, may we reply to this packet with icmp error.
 138  *
 139  * We do not reply, if:
 140  *      - it was icmp error message.
 141  *      - it is truncated, so that it is known, that protocol is ICMPV6
 142  *        (i.e. in the middle of some exthdr)
 143  *
 144  *      --ANK (980726)
 145  */
 146
 147 static bool is_ineligible(const struct sk_buff *skb)
 148 {
 149         int ptr = (u8 *)(ipv6_hdr(skb) + 1) - skb->data;
 150         int len = skb->len - ptr;
 151         __u8 nexthdr = ipv6_hdr(skb)->nexthdr;
 152         __be16 frag_off;
 153
 154         if (len < 0)
 155                 return true;
 156
 157         ptr = ipv6_skip_exthdr(skb, ptr, &nexthdr, &frag_off);
 158         if (ptr < 0)
 159                 return false;
 160         if (nexthdr == IPPROTO_ICMPV6) {
 161                 u8 _type, *tp;
 162                 tp = skb_header_pointer(skb,
 163                         ptr+offsetof(struct icmp6hdr, icmp6_type),
 164                         sizeof(_type), &_type);
 165                 if (!tp || !(*tp & ICMPV6_INFOMSG_MASK))
 166                         return true;
 167         }
 168         return false;
 169 }
 170
 171 static bool icmpv6_mask_allow(int type)
 172 {
 173         /* Informational messages are not limited. */
 174         if (type & ICMPV6_INFOMSG_MASK)
 175                 return true;
 176
 177         /* Do not limit pmtu discovery, it would break it. */
 178         if (type == ICMPV6_PKT_TOOBIG)
 179                 return true;
 180
 181         return false;
 182 }
 183
 184 static bool icmpv6_global_allow(int type)
 185 {
 186         if (icmpv6_mask_allow(type))
 187                 return true;
 188
 189         if (icmp_global_allow())
 190                 return true;
 191
 192         return false;
 193 }
 194
 195 /*
 196  * Check the ICMP output rate limit
 197  */
 198 static bool icmpv6_xrlim_allow(struct sock *sk, u8 type,
 199                                struct flowi6 *fl6)
 200 {
 201         struct net *net = sock_net(sk);
 202         struct dst_entry *dst;
 203         bool res = false;
 204
 205         if (icmpv6_mask_allow(type))
 206                 return true;
 207
 208         /*
 209          * Look up the output route.
 210          * XXX: perhaps the expire for routing entries cloned by
 211          * this lookup should be more aggressive (not longer than timeout).
 212          */
 213         dst = ip6_route_output(net, sk, fl6);
 214         if (dst->error) {
 215                 IP6_INC_STATS(net, ip6_dst_idev(dst),
 216                               IPSTATS_MIB_OUTNOROUTES);
 217         } else if (dst->dev && (dst->dev->flags&IFF_LOOPBACK)) {
 218                 res = true;
 219         } else {
 220                 struct rt6_info *rt = (struct rt6_info *)dst;
 221                 int tmo = net->ipv6.sysctl.icmpv6_time;
 222                 struct inet_peer *peer;
 223
 224                 /* Give more bandwidth to wider prefixes. */
 225                 if (rt->rt6i_dst.plen < 128)
 226                         tmo >>= ((128 - rt->rt6i_dst.plen)>>5);
 227
 228                 peer = inet_getpeer_v6(net->ipv6.peers, &fl6->daddr, 1);
 229                 res = inet_peer_xrlim_allow(peer, tmo);
 230                 if (peer)
 231                         inet_putpeer(peer);
 232         }
 233         dst_release(dst);
 234         return res;
 235 }
 236
 237 /*
 238  *      an inline helper for the "simple" if statement below
 239  *      checks if parameter problem report is caused by an
 240  *      unrecognized IPv6 option that has the Option Type
 241  *      highest-order two bits set to 10
 242  */
 243
 244 static bool opt_unrec(struct sk_buff *skb, __u32 offset)
 245 {
 246         u8 _optval, *op;
 247
 248         offset += skb_network_offset(skb);
 249         op = skb_header_pointer(skb, offset, sizeof(_optval), &_optval);
 250         if (!op)
 251                 return true;
 252         return (*op & 0xC0) == 0x80;
 253 }
 254
 255 void icmpv6_push_pending_frames(struct sock *sk, struct flowi6 *fl6,
 256                                 struct icmp6hdr *thdr, int len)
 257 {
 258         struct sk_buff *skb;
 259         struct icmp6hdr *icmp6h;
 260
 261         skb = skb_peek(&sk->sk_write_queue);
 262         if (!skb)
 263                 return;
 264
 265         icmp6h = icmp6_hdr(skb);
 266         memcpy(icmp6h, thdr, sizeof(struct icmp6hdr));
 267         icmp6h->icmp6_cksum = 0;
 268
 269         if (skb_queue_len(&sk->sk_write_queue) == 1) {
 270                 skb->csum = csum_partial(icmp6h,
 271                                         sizeof(struct icmp6hdr), skb->csum);
 272                 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
 273                                                       &fl6->daddr,
 274                                                       len, fl6->flowi6_proto,
 275                                                       skb->csum);
 276         } else {
 277                 __wsum tmp_csum = 0;
 278
 279                 skb_queue_walk(&sk->sk_write_queue, skb) {
 280                         tmp_csum = csum_add(tmp_csum, skb->csum);
 281                 }
 282
 283                 tmp_csum = csum_partial(icmp6h,
 284                                         sizeof(struct icmp6hdr), tmp_csum);
 285                 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl6->saddr,
 286                                                       &fl6->daddr,
 287                                                       len, fl6->flowi6_proto,
 288                                                       tmp_csum);
 289         }
 290         ip6_push_pending_frames(sk);
 291 }
 292
 293 struct icmpv6_msg {
 294         struct sk_buff  *skb;
 295         int             offset;
 296         uint8_t         type;
 297 };
 298
 299 static int icmpv6_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb)
 300 {
 301         struct icmpv6_msg *msg = (struct icmpv6_msg *) from;
 302         struct sk_buff *org_skb = msg->skb;
 303         __wsum csum = 0;
 304
 305         csum = skb_copy_and_csum_bits(org_skb, msg->offset + offset,
 306                                       to, len, csum);
 307         skb->csum = csum_block_add(skb->csum, csum, odd);
 308         if (!(msg->type & ICMPV6_INFOMSG_MASK))
 309                 nf_ct_attach(skb, org_skb);
 310         return 0;
 311 }
 312
 313 #if IS_ENABLED(CONFIG_IPV6_MIP6)
 314 static void mip6_addr_swap(struct sk_buff *skb)
 315 {
 316         struct ipv6hdr *iph = ipv6_hdr(skb);
 317         struct inet6_skb_parm *opt = IP6CB(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) {}
 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 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(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
 687         saddr = &ipv6_hdr(skb)->daddr;
 688
 689         if (!ipv6_unicast_destination(skb) &&
 690             !(net->ipv6.sysctl.anycast_src_echo_reply &&
 691               ipv6_anycast_destination(skb_dst(skb), saddr)))
 692                 saddr = NULL;
 693
 694         memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr));
 695         tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY;
 696
 697         memset(&fl6, 0, sizeof(fl6));
 698         fl6.flowi6_proto = IPPROTO_ICMPV6;
 699         fl6.daddr = ipv6_hdr(skb)->saddr;
 700         if (saddr)
 701                 fl6.saddr = *saddr;
 702         fl6.flowi6_oif = icmp6_iif(skb);
 703         fl6.fl6_icmp_type = ICMPV6_ECHO_REPLY;
 704         fl6.flowi6_mark = mark;
 705         fl6.flowi6_uid = sock_net_uid(net, NULL);
 706         security_skb_classify_flow(skb, flowi6_to_flowi(&fl6));
 707
 708         local_bh_disable();
 709         sk = icmpv6_xmit_lock(net);
 710         if (!sk)
 711                 goto out_bh_enable;
 712         sk->sk_mark = mark;
 713         np = inet6_sk(sk);
 714
 715         if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
 716                 fl6.flowi6_oif = np->mcast_oif;
 717         else if (!fl6.flowi6_oif)
 718                 fl6.flowi6_oif = np->ucast_oif;
 719
 720         if (ip6_dst_lookup(net, sk, &dst, &fl6))
 721                 goto out;
 722         dst = xfrm_lookup(net, dst, flowi6_to_flowi(&fl6), sk, 0);
 723         if (IS_ERR(dst))
 724                 goto out;
 725
 726         idev = __in6_dev_get(skb->dev);
 727
 728         msg.skb = skb;
 729         msg.offset = 0;
 730         msg.type = ICMPV6_ECHO_REPLY;
 731
 732         ipcm6_init_sk(&ipc6, np);
 733         ipc6.hlimit = ip6_sk_dst_hoplimit(np, &fl6, dst);
 734         ipc6.tclass = ipv6_get_dsfield(ipv6_hdr(skb));
 735
 736         if (ip6_append_data(sk, icmpv6_getfrag, &msg,
 737                             skb->len + sizeof(struct icmp6hdr),
 738                             sizeof(struct icmp6hdr), &ipc6, &fl6,
 739                             (struct rt6_info *)dst, MSG_DONTWAIT)) {
 740                 __ICMP6_INC_STATS(net, idev, ICMP6_MIB_OUTERRORS);
 741                 ip6_flush_pending_frames(sk);
 742         } else {
 743                 icmpv6_push_pending_frames(sk, &fl6, &tmp_hdr,
 744                                            skb->len + sizeof(struct icmp6hdr));
 745         }
 746         dst_release(dst);
 747 out:
 748         icmpv6_xmit_unlock(sk);
 749 out_bh_enable:
 750         local_bh_enable();
 751 }
 752
 753 void icmpv6_notify(struct sk_buff *skb, u8 type, u8 code, __be32 info)
 754 {
 755         const struct inet6_protocol *ipprot;
 756         int inner_offset;
 757         __be16 frag_off;
 758         u8 nexthdr;
 759         struct net *net = dev_net(skb->dev);
 760
 761         if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
 762                 goto out;
 763
 764         nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr;
 765         if (ipv6_ext_hdr(nexthdr)) {
 766                 /* now skip over extension headers */
 767                 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr),
 768                                                 &nexthdr, &frag_off);
 769                 if (inner_offset < 0)
 770                         goto out;
 771         } else {
 772                 inner_offset = sizeof(struct ipv6hdr);
 773         }
 774
 775         /* Checkin header including 8 bytes of inner protocol header. */
 776         if (!pskb_may_pull(skb, inner_offset+8))
 777                 goto out;
 778
 779         /* BUGGG_FUTURE: we should try to parse exthdrs in this packet.
 780            Without this we will not able f.e. to make source routed
 781            pmtu discovery.
 782            Corresponding argument (opt) to notifiers is already added.
 783            --ANK (980726)
 784          */
 785
 786         ipprot = rcu_dereference(inet6_protos[nexthdr]);
 787         if (ipprot && ipprot->err_handler)
 788                 ipprot->err_handler(skb, NULL, type, code, inner_offset, info);
 789
 790         raw6_icmp_error(skb, nexthdr, type, code, inner_offset, info);
 791         return;
 792
 793 out:
 794         __ICMP6_INC_STATS(net, __in6_dev_get(skb->dev), ICMP6_MIB_INERRORS);
 795 }
 796
 797 /*
 798  *      Handle icmp messages
 799  */
 800
 801 static int icmpv6_rcv(struct sk_buff *skb)
 802 {
 803         struct net *net = dev_net(skb->dev);
 804         struct net_device *dev = skb->dev;
 805         struct inet6_dev *idev = __in6_dev_get(dev);
 806         const struct in6_addr *saddr, *daddr;
 807         struct icmp6hdr *hdr;
 808         u8 type;
 809         bool success = false;
 810
 811         if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) {
 812                 struct sec_path *sp = skb_sec_path(skb);
 813                 int nh;
 814
 815                 if (!(sp && sp->xvec[sp->len - 1]->props.flags &
 816                                  XFRM_STATE_ICMP))
 817                         goto drop_no_count;
 818
 819                 if (!pskb_may_pull(skb, sizeof(*hdr) + sizeof(struct ipv6hdr)))
 820                         goto drop_no_count;
 821
 822                 nh = skb_network_offset(skb);
 823                 skb_set_network_header(skb, sizeof(*hdr));
 824
 825                 if (!xfrm6_policy_check_reverse(NULL, XFRM_POLICY_IN, skb))
 826                         goto drop_no_count;
 827
 828                 skb_set_network_header(skb, nh);
 829         }
 830
 831         __ICMP6_INC_STATS(dev_net(dev), idev, ICMP6_MIB_INMSGS);
 832
 833         saddr = &ipv6_hdr(skb)->saddr;
 834         daddr = &ipv6_hdr(skb)->daddr;
 835
 836         if (skb_checksum_validate(skb, IPPROTO_ICMPV6, ip6_compute_pseudo)) {
 837                 net_dbg_ratelimited("ICMPv6 checksum failed [%pI6c > %pI6c]\n",
 838                                     saddr, daddr);
 839                 goto csum_error;
 840         }
 841
 842         if (!pskb_pull(skb, sizeof(*hdr)))
 843                 goto discard_it;
 844
 845         hdr = icmp6_hdr(skb);
 846
 847         type = hdr->icmp6_type;
 848
 849         ICMP6MSGIN_INC_STATS(dev_net(dev), idev, type);
 850
 851         switch (type) {
 852         case ICMPV6_ECHO_REQUEST:
 853                 if (!net->ipv6.sysctl.icmpv6_echo_ignore_all)
 854                         icmpv6_echo_reply(skb);
 855                 break;
 856
 857         case ICMPV6_ECHO_REPLY:
 858                 success = ping_rcv(skb);
 859                 break;
 860
 861         case ICMPV6_PKT_TOOBIG:
 862                 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update
 863                    standard destination cache. Seems, only "advanced"
 864                    destination cache will allow to solve this problem
 865                    --ANK (980726)
 866                  */
 867                 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
 868                         goto discard_it;
 869                 hdr = icmp6_hdr(skb);
 870
 871                 /* to notify */
 872                 /* fall through */
 873         case ICMPV6_DEST_UNREACH:
 874         case ICMPV6_TIME_EXCEED:
 875         case ICMPV6_PARAMPROB:
 876                 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
 877                 break;
 878
 879         case NDISC_ROUTER_SOLICITATION:
 880         case NDISC_ROUTER_ADVERTISEMENT:
 881         case NDISC_NEIGHBOUR_SOLICITATION:
 882         case NDISC_NEIGHBOUR_ADVERTISEMENT:
 883         case NDISC_REDIRECT:
 884                 ndisc_rcv(skb);
 885                 break;
 886
 887         case ICMPV6_MGM_QUERY:
 888                 igmp6_event_query(skb);
 889                 break;
 890
 891         case ICMPV6_MGM_REPORT:
 892                 igmp6_event_report(skb);
 893                 break;
 894
 895         case ICMPV6_MGM_REDUCTION:
 896         case ICMPV6_NI_QUERY:
 897         case ICMPV6_NI_REPLY:
 898         case ICMPV6_MLD2_REPORT:
 899         case ICMPV6_DHAAD_REQUEST:
 900         case ICMPV6_DHAAD_REPLY:
 901         case ICMPV6_MOBILE_PREFIX_SOL:
 902         case ICMPV6_MOBILE_PREFIX_ADV:
 903                 break;
 904
 905         default:
 906                 /* informational */
 907                 if (type & ICMPV6_INFOMSG_MASK)
 908                         break;
 909
 910                 net_dbg_ratelimited("icmpv6: msg of unknown type [%pI6c > %pI6c]\n",
 911                                     saddr, daddr);
 912
 913                 /*
 914                  * error of unknown type.
 915                  * must pass to upper level
 916                  */
 917
 918                 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu);
 919         }
 920
 921         /* until the v6 path can be better sorted assume failure and
 922          * preserve the status quo behaviour for the rest of the paths to here
 923          */
 924         if (success)
 925                 consume_skb(skb);
 926         else
 927                 kfree_skb(skb);
 928
 929         return 0;
 930
 931 csum_error:
 932         __ICMP6_INC_STATS(dev_net(dev), idev, ICMP6_MIB_CSUMERRORS);
 933 discard_it:
 934         __ICMP6_INC_STATS(dev_net(dev), idev, ICMP6_MIB_INERRORS);
 935 drop_no_count:
 936         kfree_skb(skb);
 937         return 0;
 938 }
 939
 940 void icmpv6_flow_init(struct sock *sk, struct flowi6 *fl6,
 941                       u8 type,
 942                       const struct in6_addr *saddr,
 943                       const struct in6_addr *daddr,
 944                       int oif)
 945 {
 946         memset(fl6, 0, sizeof(*fl6));
 947         fl6->saddr = *saddr;
 948         fl6->daddr = *daddr;
 949         fl6->flowi6_proto       = IPPROTO_ICMPV6;
 950         fl6->fl6_icmp_type      = type;
 951         fl6->fl6_icmp_code      = 0;
 952         fl6->flowi6_oif         = oif;
 953         security_sk_classify_flow(sk, flowi6_to_flowi(fl6));
 954 }
 955
 956 static int __net_init icmpv6_sk_init(struct net *net)
 957 {
 958         struct sock *sk;
 959         int err, i, j;
 960
 961         net->ipv6.icmp_sk =
 962                 kcalloc(nr_cpu_ids, sizeof(struct sock *), GFP_KERNEL);
 963         if (!net->ipv6.icmp_sk)
 964                 return -ENOMEM;
 965
 966         for_each_possible_cpu(i) {
 967                 err = inet_ctl_sock_create(&sk, PF_INET6,
 968                                            SOCK_RAW, IPPROTO_ICMPV6, net);
 969                 if (err < 0) {
 970                         pr_err("Failed to initialize the ICMP6 control socket (err %d)\n",
 971                                err);
 972                         goto fail;
 973                 }
 974
 975                 net->ipv6.icmp_sk[i] = sk;
 976
 977                 /* Enough space for 2 64K ICMP packets, including
 978                  * sk_buff struct overhead.
 979                  */
 980                 sk->sk_sndbuf = 2 * SKB_TRUESIZE(64 * 1024);
 981         }
 982         return 0;
 983
 984  fail:
 985         for (j = 0; j < i; j++)
 986                 inet_ctl_sock_destroy(net->ipv6.icmp_sk[j]);
 987         kfree(net->ipv6.icmp_sk);
 988         return err;
 989 }
 990
 991 static void __net_exit icmpv6_sk_exit(struct net *net)
 992 {
 993         int i;
 994
 995         for_each_possible_cpu(i) {
 996                 inet_ctl_sock_destroy(net->ipv6.icmp_sk[i]);
 997         }
 998         kfree(net->ipv6.icmp_sk);
 999 }
1000
1001 static struct pernet_operations icmpv6_sk_ops = {
1002         .init = icmpv6_sk_init,
1003         .exit = icmpv6_sk_exit,
1004 };
1005
1006 int __init icmpv6_init(void)
1007 {
1008         int err;
1009
1010         err = register_pernet_subsys(&icmpv6_sk_ops);
1011         if (err < 0)
1012                 return err;
1013
1014         err = -EAGAIN;
1015         if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0)
1016                 goto fail;
1017
1018         err = inet6_register_icmp_sender(icmp6_send);
1019         if (err)
1020                 goto sender_reg_err;
1021         return 0;
1022
1023 sender_reg_err:
1024         inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
1025 fail:
1026         pr_err("Failed to register ICMP6 protocol\n");
1027         unregister_pernet_subsys(&icmpv6_sk_ops);
1028         return err;
1029 }
1030
1031 void icmpv6_cleanup(void)
1032 {
1033         inet6_unregister_icmp_sender(icmp6_send);
1034         unregister_pernet_subsys(&icmpv6_sk_ops);
1035         inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6);
1036 }
1037
1038
1039 static const struct icmp6_err {
1040         int err;
1041         int fatal;
1042 } tab_unreach[] = {
1043         {       /* NOROUTE */
1044                 .err    = ENETUNREACH,
1045                 .fatal  = 0,
1046         },
1047         {       /* ADM_PROHIBITED */
1048                 .err    = EACCES,
1049                 .fatal  = 1,
1050         },
1051         {       /* Was NOT_NEIGHBOUR, now reserved */
1052                 .err    = EHOSTUNREACH,
1053                 .fatal  = 0,
1054         },
1055         {       /* ADDR_UNREACH */
1056                 .err    = EHOSTUNREACH,
1057                 .fatal  = 0,
1058         },
1059         {       /* PORT_UNREACH */
1060                 .err    = ECONNREFUSED,
1061                 .fatal  = 1,
1062         },
1063         {       /* POLICY_FAIL */
1064                 .err    = EACCES,
1065                 .fatal  = 1,
1066         },
1067         {       /* REJECT_ROUTE */
1068                 .err    = EACCES,
1069                 .fatal  = 1,
1070         },
1071 };
1072
1073 int icmpv6_err_convert(u8 type, u8 code, int *err)
1074 {
1075         int fatal = 0;
1076
1077         *err = EPROTO;
1078
1079         switch (type) {
1080         case ICMPV6_DEST_UNREACH:
1081                 fatal = 1;
1082                 if (code < ARRAY_SIZE(tab_unreach)) {
1083                         *err  = tab_unreach[code].err;
1084                         fatal = tab_unreach[code].fatal;
1085                 }
1086                 break;
1087
1088         case ICMPV6_PKT_TOOBIG:
1089                 *err = EMSGSIZE;
1090                 break;
1091
1092         case ICMPV6_PARAMPROB:
1093                 *err = EPROTO;
1094                 fatal = 1;
1095                 break;
1096
1097         case ICMPV6_TIME_EXCEED:
1098                 *err = EHOSTUNREACH;
1099                 break;
1100         }
1101
1102         return fatal;
1103 }
1104 EXPORT_SYMBOL(icmpv6_err_convert);
1105
1106 #ifdef CONFIG_SYSCTL
1107 static struct ctl_table ipv6_icmp_table_template[] = {
1108         {
1109                 .procname       = "ratelimit",
1110                 .data           = &init_net.ipv6.sysctl.icmpv6_time,
1111                 .maxlen         = sizeof(int),
1112                 .mode           = 0644,
1113                 .proc_handler   = proc_dointvec_ms_jiffies,
1114         },
1115         {
1116                 .procname       = "echo_ignore_all",
1117                 .data           = &init_net.ipv6.sysctl.icmpv6_echo_ignore_all,
1118                 .maxlen         = sizeof(int),
1119                 .mode           = 0644,
1120                 .proc_handler = proc_dointvec,
1121         },
1122         { },
1123 };
1124
1125 struct ctl_table * __net_init ipv6_icmp_sysctl_init(struct net *net)
1126 {
1127         struct ctl_table *table;
1128
1129         table = kmemdup(ipv6_icmp_table_template,
1130                         sizeof(ipv6_icmp_table_template),
1131                         GFP_KERNEL);
1132
1133         if (table) {
1134                 table[0].data = &net->ipv6.sysctl.icmpv6_time;
1135                 table[1].data = &net->ipv6.sysctl.icmpv6_echo_ignore_all;
1136         }
1137         return table;
1138 }
1139 #endif