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