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