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