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