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 #include <linux/module.h> 33 #include <linux/errno.h> 34 #include <linux/types.h> 35 #include <linux/socket.h> 36 #include <linux/in.h> 37 #include <linux/kernel.h> 38 #include <linux/sockios.h> 39 #include <linux/net.h> 40 #include <linux/skbuff.h> 41 #include <linux/init.h> 42 #include <linux/netfilter.h> 43 44 #ifdef CONFIG_SYSCTL 45 #include <linux/sysctl.h> 46 #endif 47 48 #include <linux/inet.h> 49 #include <linux/netdevice.h> 50 #include <linux/icmpv6.h> 51 52 #include <net/ip.h> 53 #include <net/sock.h> 54 55 #include <net/ipv6.h> 56 #include <net/ip6_checksum.h> 57 #include <net/protocol.h> 58 #include <net/raw.h> 59 #include <net/rawv6.h> 60 #include <net/transp_v6.h> 61 #include <net/ip6_route.h> 62 #include <net/addrconf.h> 63 #include <net/icmp.h> 64 #include <net/xfrm.h> 65 #include <net/inet_common.h> 66 67 #include <asm/uaccess.h> 68 #include <asm/system.h> 69 70 DEFINE_SNMP_STAT(struct icmpv6_mib, icmpv6_statistics) __read_mostly; 71 EXPORT_SYMBOL(icmpv6_statistics); 72 DEFINE_SNMP_STAT(struct icmpv6msg_mib, icmpv6msg_statistics) __read_mostly; 73 EXPORT_SYMBOL(icmpv6msg_statistics); 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_rcv(struct sk_buff *skb); 88 89 static const struct inet6_protocol icmpv6_protocol = { 90 .handler = icmpv6_rcv, 91 .flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL, 92 }; 93 94 static __inline__ struct sock *icmpv6_xmit_lock(struct net *net) 95 { 96 struct sock *sk; 97 98 local_bh_disable(); 99 100 sk = icmpv6_sk(net); 101 if (unlikely(!spin_trylock(&sk->sk_lock.slock))) { 102 /* This can happen if the output path (f.e. SIT or 103 * ip6ip6 tunnel) signals dst_link_failure() for an 104 * outgoing ICMP6 packet. 105 */ 106 local_bh_enable(); 107 return NULL; 108 } 109 return sk; 110 } 111 112 static __inline__ void icmpv6_xmit_unlock(struct sock *sk) 113 { 114 spin_unlock_bh(&sk->sk_lock.slock); 115 } 116 117 /* 118 * Slightly more convenient version of icmpv6_send. 119 */ 120 void icmpv6_param_prob(struct sk_buff *skb, u8 code, int pos) 121 { 122 icmpv6_send(skb, ICMPV6_PARAMPROB, code, pos, skb->dev); 123 kfree_skb(skb); 124 } 125 126 /* 127 * Figure out, may we reply to this packet with icmp error. 128 * 129 * We do not reply, if: 130 * - it was icmp error message. 131 * - it is truncated, so that it is known, that protocol is ICMPV6 132 * (i.e. in the middle of some exthdr) 133 * 134 * --ANK (980726) 135 */ 136 137 static int is_ineligible(struct sk_buff *skb) 138 { 139 int ptr = (u8 *)(ipv6_hdr(skb) + 1) - skb->data; 140 int len = skb->len - ptr; 141 __u8 nexthdr = ipv6_hdr(skb)->nexthdr; 142 143 if (len < 0) 144 return 1; 145 146 ptr = ipv6_skip_exthdr(skb, ptr, &nexthdr); 147 if (ptr < 0) 148 return 0; 149 if (nexthdr == IPPROTO_ICMPV6) { 150 u8 _type, *tp; 151 tp = skb_header_pointer(skb, 152 ptr+offsetof(struct icmp6hdr, icmp6_type), 153 sizeof(_type), &_type); 154 if (tp == NULL || 155 !(*tp & ICMPV6_INFOMSG_MASK)) 156 return 1; 157 } 158 return 0; 159 } 160 161 /* 162 * Check the ICMP output rate limit 163 */ 164 static inline int icmpv6_xrlim_allow(struct sock *sk, u8 type, 165 struct flowi *fl) 166 { 167 struct dst_entry *dst; 168 struct net *net = sock_net(sk); 169 int res = 0; 170 171 /* Informational messages are not limited. */ 172 if (type & ICMPV6_INFOMSG_MASK) 173 return 1; 174 175 /* Do not limit pmtu discovery, it would break it. */ 176 if (type == ICMPV6_PKT_TOOBIG) 177 return 1; 178 179 /* 180 * Look up the output route. 181 * XXX: perhaps the expire for routing entries cloned by 182 * this lookup should be more aggressive (not longer than timeout). 183 */ 184 dst = ip6_route_output(net, sk, fl); 185 if (dst->error) { 186 IP6_INC_STATS(net, ip6_dst_idev(dst), 187 IPSTATS_MIB_OUTNOROUTES); 188 } else if (dst->dev && (dst->dev->flags&IFF_LOOPBACK)) { 189 res = 1; 190 } else { 191 struct rt6_info *rt = (struct rt6_info *)dst; 192 int tmo = net->ipv6.sysctl.icmpv6_time; 193 194 /* Give more bandwidth to wider prefixes. */ 195 if (rt->rt6i_dst.plen < 128) 196 tmo >>= ((128 - rt->rt6i_dst.plen)>>5); 197 198 res = xrlim_allow(dst, tmo); 199 } 200 dst_release(dst); 201 return res; 202 } 203 204 /* 205 * an inline helper for the "simple" if statement below 206 * checks if parameter problem report is caused by an 207 * unrecognized IPv6 option that has the Option Type 208 * highest-order two bits set to 10 209 */ 210 211 static __inline__ int opt_unrec(struct sk_buff *skb, __u32 offset) 212 { 213 u8 _optval, *op; 214 215 offset += skb_network_offset(skb); 216 op = skb_header_pointer(skb, offset, sizeof(_optval), &_optval); 217 if (op == NULL) 218 return 1; 219 return (*op & 0xC0) == 0x80; 220 } 221 222 static int icmpv6_push_pending_frames(struct sock *sk, struct flowi *fl, struct icmp6hdr *thdr, int len) 223 { 224 struct sk_buff *skb; 225 struct icmp6hdr *icmp6h; 226 int err = 0; 227 228 if ((skb = skb_peek(&sk->sk_write_queue)) == NULL) 229 goto out; 230 231 icmp6h = icmp6_hdr(skb); 232 memcpy(icmp6h, thdr, sizeof(struct icmp6hdr)); 233 icmp6h->icmp6_cksum = 0; 234 235 if (skb_queue_len(&sk->sk_write_queue) == 1) { 236 skb->csum = csum_partial(icmp6h, 237 sizeof(struct icmp6hdr), skb->csum); 238 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl->fl6_src, 239 &fl->fl6_dst, 240 len, fl->proto, 241 skb->csum); 242 } else { 243 __wsum tmp_csum = 0; 244 245 skb_queue_walk(&sk->sk_write_queue, skb) { 246 tmp_csum = csum_add(tmp_csum, skb->csum); 247 } 248 249 tmp_csum = csum_partial(icmp6h, 250 sizeof(struct icmp6hdr), tmp_csum); 251 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl->fl6_src, 252 &fl->fl6_dst, 253 len, fl->proto, 254 tmp_csum); 255 } 256 ip6_push_pending_frames(sk); 257 out: 258 return err; 259 } 260 261 struct icmpv6_msg { 262 struct sk_buff *skb; 263 int offset; 264 uint8_t type; 265 }; 266 267 static int icmpv6_getfrag(void *from, char *to, int offset, int len, int odd, struct sk_buff *skb) 268 { 269 struct icmpv6_msg *msg = (struct icmpv6_msg *) from; 270 struct sk_buff *org_skb = msg->skb; 271 __wsum csum = 0; 272 273 csum = skb_copy_and_csum_bits(org_skb, msg->offset + offset, 274 to, len, csum); 275 skb->csum = csum_block_add(skb->csum, csum, odd); 276 if (!(msg->type & ICMPV6_INFOMSG_MASK)) 277 nf_ct_attach(skb, org_skb); 278 return 0; 279 } 280 281 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE) 282 static void mip6_addr_swap(struct sk_buff *skb) 283 { 284 struct ipv6hdr *iph = ipv6_hdr(skb); 285 struct inet6_skb_parm *opt = IP6CB(skb); 286 struct ipv6_destopt_hao *hao; 287 struct in6_addr tmp; 288 int off; 289 290 if (opt->dsthao) { 291 off = ipv6_find_tlv(skb, opt->dsthao, IPV6_TLV_HAO); 292 if (likely(off >= 0)) { 293 hao = (struct ipv6_destopt_hao *) 294 (skb_network_header(skb) + off); 295 ipv6_addr_copy(&tmp, &iph->saddr); 296 ipv6_addr_copy(&iph->saddr, &hao->addr); 297 ipv6_addr_copy(&hao->addr, &tmp); 298 } 299 } 300 } 301 #else 302 static inline void mip6_addr_swap(struct sk_buff *skb) {} 303 #endif 304 305 /* 306 * Send an ICMP message in response to a packet in error 307 */ 308 void icmpv6_send(struct sk_buff *skb, u8 type, u8 code, __u32 info, 309 struct net_device *dev) 310 { 311 struct net *net = dev_net(skb->dev); 312 struct inet6_dev *idev = NULL; 313 struct ipv6hdr *hdr = ipv6_hdr(skb); 314 struct sock *sk; 315 struct ipv6_pinfo *np; 316 struct in6_addr *saddr = NULL; 317 struct dst_entry *dst; 318 struct dst_entry *dst2; 319 struct icmp6hdr tmp_hdr; 320 struct flowi fl; 321 struct flowi fl2; 322 struct icmpv6_msg msg; 323 int iif = 0; 324 int addr_type = 0; 325 int len; 326 int hlimit; 327 int err = 0; 328 329 if ((u8 *)hdr < skb->head || 330 (skb->network_header + sizeof(*hdr)) > skb->tail) 331 return; 332 333 /* 334 * Make sure we respect the rules 335 * i.e. RFC 1885 2.4(e) 336 * Rule (e.1) is enforced by not using icmpv6_send 337 * in any code that processes icmp errors. 338 */ 339 addr_type = ipv6_addr_type(&hdr->daddr); 340 341 if (ipv6_chk_addr(net, &hdr->daddr, skb->dev, 0)) 342 saddr = &hdr->daddr; 343 344 /* 345 * Dest addr check 346 */ 347 348 if ((addr_type & IPV6_ADDR_MULTICAST || skb->pkt_type != PACKET_HOST)) { 349 if (type != ICMPV6_PKT_TOOBIG && 350 !(type == ICMPV6_PARAMPROB && 351 code == ICMPV6_UNK_OPTION && 352 (opt_unrec(skb, info)))) 353 return; 354 355 saddr = NULL; 356 } 357 358 addr_type = ipv6_addr_type(&hdr->saddr); 359 360 /* 361 * Source addr check 362 */ 363 364 if (addr_type & IPV6_ADDR_LINKLOCAL) 365 iif = skb->dev->ifindex; 366 367 /* 368 * Must not send error if the source does not uniquely 369 * identify a single node (RFC2463 Section 2.4). 370 * We check unspecified / multicast addresses here, 371 * and anycast addresses will be checked later. 372 */ 373 if ((addr_type == IPV6_ADDR_ANY) || (addr_type & IPV6_ADDR_MULTICAST)) { 374 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: addr_any/mcast source\n"); 375 return; 376 } 377 378 /* 379 * Never answer to a ICMP packet. 380 */ 381 if (is_ineligible(skb)) { 382 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: no reply to icmp error\n"); 383 return; 384 } 385 386 mip6_addr_swap(skb); 387 388 memset(&fl, 0, sizeof(fl)); 389 fl.proto = IPPROTO_ICMPV6; 390 ipv6_addr_copy(&fl.fl6_dst, &hdr->saddr); 391 if (saddr) 392 ipv6_addr_copy(&fl.fl6_src, saddr); 393 fl.oif = iif; 394 fl.fl_icmp_type = type; 395 fl.fl_icmp_code = code; 396 security_skb_classify_flow(skb, &fl); 397 398 sk = icmpv6_xmit_lock(net); 399 if (sk == NULL) 400 return; 401 np = inet6_sk(sk); 402 403 if (!icmpv6_xrlim_allow(sk, type, &fl)) 404 goto out; 405 406 tmp_hdr.icmp6_type = type; 407 tmp_hdr.icmp6_code = code; 408 tmp_hdr.icmp6_cksum = 0; 409 tmp_hdr.icmp6_pointer = htonl(info); 410 411 if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst)) 412 fl.oif = np->mcast_oif; 413 414 err = ip6_dst_lookup(sk, &dst, &fl); 415 if (err) 416 goto out; 417 418 /* 419 * We won't send icmp if the destination is known 420 * anycast. 421 */ 422 if (((struct rt6_info *)dst)->rt6i_flags & RTF_ANYCAST) { 423 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: acast source\n"); 424 goto out_dst_release; 425 } 426 427 /* No need to clone since we're just using its address. */ 428 dst2 = dst; 429 430 err = xfrm_lookup(net, &dst, &fl, sk, 0); 431 switch (err) { 432 case 0: 433 if (dst != dst2) 434 goto route_done; 435 break; 436 case -EPERM: 437 dst = NULL; 438 break; 439 default: 440 goto out; 441 } 442 443 if (xfrm_decode_session_reverse(skb, &fl2, AF_INET6)) 444 goto relookup_failed; 445 446 if (ip6_dst_lookup(sk, &dst2, &fl2)) 447 goto relookup_failed; 448 449 err = xfrm_lookup(net, &dst2, &fl2, sk, XFRM_LOOKUP_ICMP); 450 switch (err) { 451 case 0: 452 dst_release(dst); 453 dst = dst2; 454 break; 455 case -EPERM: 456 goto out_dst_release; 457 default: 458 relookup_failed: 459 if (!dst) 460 goto out; 461 break; 462 } 463 464 route_done: 465 if (ipv6_addr_is_multicast(&fl.fl6_dst)) 466 hlimit = np->mcast_hops; 467 else 468 hlimit = np->hop_limit; 469 if (hlimit < 0) 470 hlimit = ip6_dst_hoplimit(dst); 471 472 msg.skb = skb; 473 msg.offset = skb_network_offset(skb); 474 msg.type = type; 475 476 len = skb->len - msg.offset; 477 len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) -sizeof(struct icmp6hdr)); 478 if (len < 0) { 479 LIMIT_NETDEBUG(KERN_DEBUG "icmp: len problem\n"); 480 goto out_dst_release; 481 } 482 483 idev = in6_dev_get(skb->dev); 484 485 err = ip6_append_data(sk, icmpv6_getfrag, &msg, 486 len + sizeof(struct icmp6hdr), 487 sizeof(struct icmp6hdr), hlimit, 488 np->tclass, NULL, &fl, (struct rt6_info*)dst, 489 MSG_DONTWAIT); 490 if (err) { 491 ip6_flush_pending_frames(sk); 492 goto out_put; 493 } 494 err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, len + sizeof(struct icmp6hdr)); 495 496 out_put: 497 if (likely(idev != NULL)) 498 in6_dev_put(idev); 499 out_dst_release: 500 dst_release(dst); 501 out: 502 icmpv6_xmit_unlock(sk); 503 } 504 505 EXPORT_SYMBOL(icmpv6_send); 506 507 static void icmpv6_echo_reply(struct sk_buff *skb) 508 { 509 struct net *net = dev_net(skb->dev); 510 struct sock *sk; 511 struct inet6_dev *idev; 512 struct ipv6_pinfo *np; 513 struct in6_addr *saddr = NULL; 514 struct icmp6hdr *icmph = icmp6_hdr(skb); 515 struct icmp6hdr tmp_hdr; 516 struct flowi fl; 517 struct icmpv6_msg msg; 518 struct dst_entry *dst; 519 int err = 0; 520 int hlimit; 521 522 saddr = &ipv6_hdr(skb)->daddr; 523 524 if (!ipv6_unicast_destination(skb)) 525 saddr = NULL; 526 527 memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr)); 528 tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY; 529 530 memset(&fl, 0, sizeof(fl)); 531 fl.proto = IPPROTO_ICMPV6; 532 ipv6_addr_copy(&fl.fl6_dst, &ipv6_hdr(skb)->saddr); 533 if (saddr) 534 ipv6_addr_copy(&fl.fl6_src, saddr); 535 fl.oif = skb->dev->ifindex; 536 fl.fl_icmp_type = ICMPV6_ECHO_REPLY; 537 security_skb_classify_flow(skb, &fl); 538 539 sk = icmpv6_xmit_lock(net); 540 if (sk == NULL) 541 return; 542 np = inet6_sk(sk); 543 544 if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst)) 545 fl.oif = np->mcast_oif; 546 547 err = ip6_dst_lookup(sk, &dst, &fl); 548 if (err) 549 goto out; 550 if ((err = xfrm_lookup(net, &dst, &fl, sk, 0)) < 0) 551 goto out; 552 553 if (ipv6_addr_is_multicast(&fl.fl6_dst)) 554 hlimit = np->mcast_hops; 555 else 556 hlimit = np->hop_limit; 557 if (hlimit < 0) 558 hlimit = ip6_dst_hoplimit(dst); 559 560 idev = in6_dev_get(skb->dev); 561 562 msg.skb = skb; 563 msg.offset = 0; 564 msg.type = ICMPV6_ECHO_REPLY; 565 566 err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr), 567 sizeof(struct icmp6hdr), hlimit, np->tclass, NULL, &fl, 568 (struct rt6_info*)dst, MSG_DONTWAIT); 569 570 if (err) { 571 ip6_flush_pending_frames(sk); 572 goto out_put; 573 } 574 err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, skb->len + sizeof(struct icmp6hdr)); 575 576 out_put: 577 if (likely(idev != NULL)) 578 in6_dev_put(idev); 579 dst_release(dst); 580 out: 581 icmpv6_xmit_unlock(sk); 582 } 583 584 static void icmpv6_notify(struct sk_buff *skb, u8 type, u8 code, __be32 info) 585 { 586 const struct inet6_protocol *ipprot; 587 int inner_offset; 588 int hash; 589 u8 nexthdr; 590 591 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr))) 592 return; 593 594 nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr; 595 if (ipv6_ext_hdr(nexthdr)) { 596 /* now skip over extension headers */ 597 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr), &nexthdr); 598 if (inner_offset<0) 599 return; 600 } else { 601 inner_offset = sizeof(struct ipv6hdr); 602 } 603 604 /* Checkin header including 8 bytes of inner protocol header. */ 605 if (!pskb_may_pull(skb, inner_offset+8)) 606 return; 607 608 /* BUGGG_FUTURE: we should try to parse exthdrs in this packet. 609 Without this we will not able f.e. to make source routed 610 pmtu discovery. 611 Corresponding argument (opt) to notifiers is already added. 612 --ANK (980726) 613 */ 614 615 hash = nexthdr & (MAX_INET_PROTOS - 1); 616 617 rcu_read_lock(); 618 ipprot = rcu_dereference(inet6_protos[hash]); 619 if (ipprot && ipprot->err_handler) 620 ipprot->err_handler(skb, NULL, type, code, inner_offset, info); 621 rcu_read_unlock(); 622 623 raw6_icmp_error(skb, nexthdr, type, code, inner_offset, info); 624 } 625 626 /* 627 * Handle icmp messages 628 */ 629 630 static int icmpv6_rcv(struct sk_buff *skb) 631 { 632 struct net_device *dev = skb->dev; 633 struct inet6_dev *idev = __in6_dev_get(dev); 634 struct in6_addr *saddr, *daddr; 635 struct ipv6hdr *orig_hdr; 636 struct icmp6hdr *hdr; 637 u8 type; 638 639 if (!xfrm6_policy_check(NULL, XFRM_POLICY_IN, skb)) { 640 struct sec_path *sp = skb_sec_path(skb); 641 int nh; 642 643 if (!(sp && sp->xvec[sp->len - 1]->props.flags & 644 XFRM_STATE_ICMP)) 645 goto drop_no_count; 646 647 if (!pskb_may_pull(skb, sizeof(*hdr) + sizeof(*orig_hdr))) 648 goto drop_no_count; 649 650 nh = skb_network_offset(skb); 651 skb_set_network_header(skb, sizeof(*hdr)); 652 653 if (!xfrm6_policy_check_reverse(NULL, XFRM_POLICY_IN, skb)) 654 goto drop_no_count; 655 656 skb_set_network_header(skb, nh); 657 } 658 659 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INMSGS); 660 661 saddr = &ipv6_hdr(skb)->saddr; 662 daddr = &ipv6_hdr(skb)->daddr; 663 664 /* Perform checksum. */ 665 switch (skb->ip_summed) { 666 case CHECKSUM_COMPLETE: 667 if (!csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6, 668 skb->csum)) 669 break; 670 /* fall through */ 671 case CHECKSUM_NONE: 672 skb->csum = ~csum_unfold(csum_ipv6_magic(saddr, daddr, skb->len, 673 IPPROTO_ICMPV6, 0)); 674 if (__skb_checksum_complete(skb)) { 675 LIMIT_NETDEBUG(KERN_DEBUG "ICMPv6 checksum failed [%pI6 > %pI6]\n", 676 saddr, daddr); 677 goto discard_it; 678 } 679 } 680 681 if (!pskb_pull(skb, sizeof(*hdr))) 682 goto discard_it; 683 684 hdr = icmp6_hdr(skb); 685 686 type = hdr->icmp6_type; 687 688 ICMP6MSGIN_INC_STATS_BH(dev_net(dev), idev, type); 689 690 switch (type) { 691 case ICMPV6_ECHO_REQUEST: 692 icmpv6_echo_reply(skb); 693 break; 694 695 case ICMPV6_ECHO_REPLY: 696 /* we couldn't care less */ 697 break; 698 699 case ICMPV6_PKT_TOOBIG: 700 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update 701 standard destination cache. Seems, only "advanced" 702 destination cache will allow to solve this problem 703 --ANK (980726) 704 */ 705 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr))) 706 goto discard_it; 707 hdr = icmp6_hdr(skb); 708 orig_hdr = (struct ipv6hdr *) (hdr + 1); 709 rt6_pmtu_discovery(&orig_hdr->daddr, &orig_hdr->saddr, dev, 710 ntohl(hdr->icmp6_mtu)); 711 712 /* 713 * Drop through to notify 714 */ 715 716 case ICMPV6_DEST_UNREACH: 717 case ICMPV6_TIME_EXCEED: 718 case ICMPV6_PARAMPROB: 719 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu); 720 break; 721 722 case NDISC_ROUTER_SOLICITATION: 723 case NDISC_ROUTER_ADVERTISEMENT: 724 case NDISC_NEIGHBOUR_SOLICITATION: 725 case NDISC_NEIGHBOUR_ADVERTISEMENT: 726 case NDISC_REDIRECT: 727 ndisc_rcv(skb); 728 break; 729 730 case ICMPV6_MGM_QUERY: 731 igmp6_event_query(skb); 732 break; 733 734 case ICMPV6_MGM_REPORT: 735 igmp6_event_report(skb); 736 break; 737 738 case ICMPV6_MGM_REDUCTION: 739 case ICMPV6_NI_QUERY: 740 case ICMPV6_NI_REPLY: 741 case ICMPV6_MLD2_REPORT: 742 case ICMPV6_DHAAD_REQUEST: 743 case ICMPV6_DHAAD_REPLY: 744 case ICMPV6_MOBILE_PREFIX_SOL: 745 case ICMPV6_MOBILE_PREFIX_ADV: 746 break; 747 748 default: 749 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6: msg of unknown type\n"); 750 751 /* informational */ 752 if (type & ICMPV6_INFOMSG_MASK) 753 break; 754 755 /* 756 * error of unknown type. 757 * must pass to upper level 758 */ 759 760 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu); 761 } 762 763 kfree_skb(skb); 764 return 0; 765 766 discard_it: 767 ICMP6_INC_STATS_BH(dev_net(dev), idev, ICMP6_MIB_INERRORS); 768 drop_no_count: 769 kfree_skb(skb); 770 return 0; 771 } 772 773 void icmpv6_flow_init(struct sock *sk, struct flowi *fl, 774 u8 type, 775 const struct in6_addr *saddr, 776 const struct in6_addr *daddr, 777 int oif) 778 { 779 memset(fl, 0, sizeof(*fl)); 780 ipv6_addr_copy(&fl->fl6_src, saddr); 781 ipv6_addr_copy(&fl->fl6_dst, daddr); 782 fl->proto = IPPROTO_ICMPV6; 783 fl->fl_icmp_type = type; 784 fl->fl_icmp_code = 0; 785 fl->oif = oif; 786 security_sk_classify_flow(sk, fl); 787 } 788 789 /* 790 * Special lock-class for __icmpv6_sk: 791 */ 792 static struct lock_class_key icmpv6_socket_sk_dst_lock_key; 793 794 static int __net_init icmpv6_sk_init(struct net *net) 795 { 796 struct sock *sk; 797 int err, i, j; 798 799 net->ipv6.icmp_sk = 800 kzalloc(nr_cpu_ids * sizeof(struct sock *), GFP_KERNEL); 801 if (net->ipv6.icmp_sk == NULL) 802 return -ENOMEM; 803 804 for_each_possible_cpu(i) { 805 err = inet_ctl_sock_create(&sk, PF_INET6, 806 SOCK_RAW, IPPROTO_ICMPV6, net); 807 if (err < 0) { 808 printk(KERN_ERR 809 "Failed to initialize the ICMP6 control socket " 810 "(err %d).\n", 811 err); 812 goto fail; 813 } 814 815 net->ipv6.icmp_sk[i] = sk; 816 817 /* 818 * Split off their lock-class, because sk->sk_dst_lock 819 * gets used from softirqs, which is safe for 820 * __icmpv6_sk (because those never get directly used 821 * via userspace syscalls), but unsafe for normal sockets. 822 */ 823 lockdep_set_class(&sk->sk_dst_lock, 824 &icmpv6_socket_sk_dst_lock_key); 825 826 /* Enough space for 2 64K ICMP packets, including 827 * sk_buff struct overhead. 828 */ 829 sk->sk_sndbuf = 830 (2 * ((64 * 1024) + sizeof(struct sk_buff))); 831 } 832 return 0; 833 834 fail: 835 for (j = 0; j < i; j++) 836 inet_ctl_sock_destroy(net->ipv6.icmp_sk[j]); 837 kfree(net->ipv6.icmp_sk); 838 return err; 839 } 840 841 static void __net_exit icmpv6_sk_exit(struct net *net) 842 { 843 int i; 844 845 for_each_possible_cpu(i) { 846 inet_ctl_sock_destroy(net->ipv6.icmp_sk[i]); 847 } 848 kfree(net->ipv6.icmp_sk); 849 } 850 851 static struct pernet_operations icmpv6_sk_ops = { 852 .init = icmpv6_sk_init, 853 .exit = icmpv6_sk_exit, 854 }; 855 856 int __init icmpv6_init(void) 857 { 858 int err; 859 860 err = register_pernet_subsys(&icmpv6_sk_ops); 861 if (err < 0) 862 return err; 863 864 err = -EAGAIN; 865 if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0) 866 goto fail; 867 return 0; 868 869 fail: 870 printk(KERN_ERR "Failed to register ICMP6 protocol\n"); 871 unregister_pernet_subsys(&icmpv6_sk_ops); 872 return err; 873 } 874 875 void icmpv6_cleanup(void) 876 { 877 unregister_pernet_subsys(&icmpv6_sk_ops); 878 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6); 879 } 880 881 882 static const struct icmp6_err { 883 int err; 884 int fatal; 885 } tab_unreach[] = { 886 { /* NOROUTE */ 887 .err = ENETUNREACH, 888 .fatal = 0, 889 }, 890 { /* ADM_PROHIBITED */ 891 .err = EACCES, 892 .fatal = 1, 893 }, 894 { /* Was NOT_NEIGHBOUR, now reserved */ 895 .err = EHOSTUNREACH, 896 .fatal = 0, 897 }, 898 { /* ADDR_UNREACH */ 899 .err = EHOSTUNREACH, 900 .fatal = 0, 901 }, 902 { /* PORT_UNREACH */ 903 .err = ECONNREFUSED, 904 .fatal = 1, 905 }, 906 }; 907 908 int icmpv6_err_convert(u8 type, u8 code, int *err) 909 { 910 int fatal = 0; 911 912 *err = EPROTO; 913 914 switch (type) { 915 case ICMPV6_DEST_UNREACH: 916 fatal = 1; 917 if (code <= ICMPV6_PORT_UNREACH) { 918 *err = tab_unreach[code].err; 919 fatal = tab_unreach[code].fatal; 920 } 921 break; 922 923 case ICMPV6_PKT_TOOBIG: 924 *err = EMSGSIZE; 925 break; 926 927 case ICMPV6_PARAMPROB: 928 *err = EPROTO; 929 fatal = 1; 930 break; 931 932 case ICMPV6_TIME_EXCEED: 933 *err = EHOSTUNREACH; 934 break; 935 } 936 937 return fatal; 938 } 939 940 EXPORT_SYMBOL(icmpv6_err_convert); 941 942 #ifdef CONFIG_SYSCTL 943 ctl_table ipv6_icmp_table_template[] = { 944 { 945 .ctl_name = NET_IPV6_ICMP_RATELIMIT, 946 .procname = "ratelimit", 947 .data = &init_net.ipv6.sysctl.icmpv6_time, 948 .maxlen = sizeof(int), 949 .mode = 0644, 950 .proc_handler = proc_dointvec_ms_jiffies, 951 .strategy = sysctl_ms_jiffies 952 }, 953 { .ctl_name = 0 }, 954 }; 955 956 struct ctl_table *ipv6_icmp_sysctl_init(struct net *net) 957 { 958 struct ctl_table *table; 959 960 table = kmemdup(ipv6_icmp_table_template, 961 sizeof(ipv6_icmp_table_template), 962 GFP_KERNEL); 963 964 if (table) 965 table[0].data = &net->ipv6.sysctl.icmpv6_time; 966 967 return table; 968 } 969 #endif 970 971