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