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