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/sched.h> 41 #include <linux/sockios.h> 42 #include <linux/net.h> 43 #include <linux/skbuff.h> 44 #include <linux/init.h> 45 #include <linux/netfilter.h> 46 47 #ifdef CONFIG_SYSCTL 48 #include <linux/sysctl.h> 49 #endif 50 51 #include <linux/inet.h> 52 #include <linux/netdevice.h> 53 #include <linux/icmpv6.h> 54 55 #include <net/ip.h> 56 #include <net/sock.h> 57 58 #include <net/ipv6.h> 59 #include <net/ip6_checksum.h> 60 #include <net/protocol.h> 61 #include <net/raw.h> 62 #include <net/rawv6.h> 63 #include <net/transp_v6.h> 64 #include <net/ip6_route.h> 65 #include <net/addrconf.h> 66 #include <net/icmp.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 73 /* 74 * The ICMP socket(s). This is the most convenient way to flow control 75 * our ICMP output as well as maintain a clean interface throughout 76 * all layers. All Socketless IP sends will soon be gone. 77 * 78 * On SMP we have one ICMP socket per-cpu. 79 */ 80 static DEFINE_PER_CPU(struct socket *, __icmpv6_socket) = NULL; 81 #define icmpv6_socket __get_cpu_var(__icmpv6_socket) 82 83 static int icmpv6_rcv(struct sk_buff **pskb); 84 85 static struct inet6_protocol icmpv6_protocol = { 86 .handler = icmpv6_rcv, 87 .flags = INET6_PROTO_FINAL, 88 }; 89 90 static __inline__ int icmpv6_xmit_lock(void) 91 { 92 local_bh_disable(); 93 94 if (unlikely(!spin_trylock(&icmpv6_socket->sk->sk_lock.slock))) { 95 /* This can happen if the output path (f.e. SIT or 96 * ip6ip6 tunnel) signals dst_link_failure() for an 97 * outgoing ICMP6 packet. 98 */ 99 local_bh_enable(); 100 return 1; 101 } 102 return 0; 103 } 104 105 static __inline__ void icmpv6_xmit_unlock(void) 106 { 107 spin_unlock_bh(&icmpv6_socket->sk->sk_lock.slock); 108 } 109 110 /* 111 * Slightly more convenient version of icmpv6_send. 112 */ 113 void icmpv6_param_prob(struct sk_buff *skb, int code, int pos) 114 { 115 icmpv6_send(skb, ICMPV6_PARAMPROB, code, pos, skb->dev); 116 kfree_skb(skb); 117 } 118 119 /* 120 * Figure out, may we reply to this packet with icmp error. 121 * 122 * We do not reply, if: 123 * - it was icmp error message. 124 * - it is truncated, so that it is known, that protocol is ICMPV6 125 * (i.e. in the middle of some exthdr) 126 * 127 * --ANK (980726) 128 */ 129 130 static int is_ineligible(struct sk_buff *skb) 131 { 132 int ptr = (u8*)(skb->nh.ipv6h+1) - skb->data; 133 int len = skb->len - ptr; 134 __u8 nexthdr = skb->nh.ipv6h->nexthdr; 135 136 if (len < 0) 137 return 1; 138 139 ptr = ipv6_skip_exthdr(skb, ptr, &nexthdr); 140 if (ptr < 0) 141 return 0; 142 if (nexthdr == IPPROTO_ICMPV6) { 143 u8 _type, *tp; 144 tp = skb_header_pointer(skb, 145 ptr+offsetof(struct icmp6hdr, icmp6_type), 146 sizeof(_type), &_type); 147 if (tp == NULL || 148 !(*tp & ICMPV6_INFOMSG_MASK)) 149 return 1; 150 } 151 return 0; 152 } 153 154 static int sysctl_icmpv6_time __read_mostly = 1*HZ; 155 156 /* 157 * Check the ICMP output rate limit 158 */ 159 static inline int icmpv6_xrlim_allow(struct sock *sk, int type, 160 struct flowi *fl) 161 { 162 struct dst_entry *dst; 163 int res = 0; 164 165 /* Informational messages are not limited. */ 166 if (type & ICMPV6_INFOMSG_MASK) 167 return 1; 168 169 /* Do not limit pmtu discovery, it would break it. */ 170 if (type == ICMPV6_PKT_TOOBIG) 171 return 1; 172 173 /* 174 * Look up the output route. 175 * XXX: perhaps the expire for routing entries cloned by 176 * this lookup should be more aggressive (not longer than timeout). 177 */ 178 dst = ip6_route_output(sk, fl); 179 if (dst->error) { 180 IP6_INC_STATS(IPSTATS_MIB_OUTNOROUTES); 181 } else if (dst->dev && (dst->dev->flags&IFF_LOOPBACK)) { 182 res = 1; 183 } else { 184 struct rt6_info *rt = (struct rt6_info *)dst; 185 int tmo = sysctl_icmpv6_time; 186 187 /* Give more bandwidth to wider prefixes. */ 188 if (rt->rt6i_dst.plen < 128) 189 tmo >>= ((128 - rt->rt6i_dst.plen)>>5); 190 191 res = xrlim_allow(dst, tmo); 192 } 193 dst_release(dst); 194 return res; 195 } 196 197 /* 198 * an inline helper for the "simple" if statement below 199 * checks if parameter problem report is caused by an 200 * unrecognized IPv6 option that has the Option Type 201 * highest-order two bits set to 10 202 */ 203 204 static __inline__ int opt_unrec(struct sk_buff *skb, __u32 offset) 205 { 206 u8 _optval, *op; 207 208 offset += skb->nh.raw - skb->data; 209 op = skb_header_pointer(skb, offset, sizeof(_optval), &_optval); 210 if (op == NULL) 211 return 1; 212 return (*op & 0xC0) == 0x80; 213 } 214 215 static int icmpv6_push_pending_frames(struct sock *sk, struct flowi *fl, struct icmp6hdr *thdr, int len) 216 { 217 struct sk_buff *skb; 218 struct icmp6hdr *icmp6h; 219 int err = 0; 220 221 if ((skb = skb_peek(&sk->sk_write_queue)) == NULL) 222 goto out; 223 224 icmp6h = (struct icmp6hdr*) skb->h.raw; 225 memcpy(icmp6h, thdr, sizeof(struct icmp6hdr)); 226 icmp6h->icmp6_cksum = 0; 227 228 if (skb_queue_len(&sk->sk_write_queue) == 1) { 229 skb->csum = csum_partial((char *)icmp6h, 230 sizeof(struct icmp6hdr), skb->csum); 231 icmp6h->icmp6_cksum = csum_ipv6_magic(&fl->fl6_src, 232 &fl->fl6_dst, 233 len, fl->proto, 234 skb->csum); 235 } else { 236 u32 tmp_csum = 0; 237 238 skb_queue_walk(&sk->sk_write_queue, skb) { 239 tmp_csum = csum_add(tmp_csum, skb->csum); 240 } 241 242 tmp_csum = csum_partial((char *)icmp6h, 243 sizeof(struct icmp6hdr), tmp_csum); 244 tmp_csum = csum_ipv6_magic(&fl->fl6_src, 245 &fl->fl6_dst, 246 len, fl->proto, tmp_csum); 247 icmp6h->icmp6_cksum = tmp_csum; 248 } 249 if (icmp6h->icmp6_cksum == 0) 250 icmp6h->icmp6_cksum = -1; 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 __u32 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 #ifdef CONFIG_IPV6_MIP6 277 static void mip6_addr_swap(struct sk_buff *skb) 278 { 279 struct ipv6hdr *iph = skb->nh.ipv6h; 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 *)(skb->nh.raw + off); 289 ipv6_addr_copy(&tmp, &iph->saddr); 290 ipv6_addr_copy(&iph->saddr, &hao->addr); 291 ipv6_addr_copy(&hao->addr, &tmp); 292 } 293 } 294 } 295 #else 296 static inline void mip6_addr_swap(struct sk_buff *skb) {} 297 #endif 298 299 /* 300 * Send an ICMP message in response to a packet in error 301 */ 302 void icmpv6_send(struct sk_buff *skb, int type, int code, __u32 info, 303 struct net_device *dev) 304 { 305 struct inet6_dev *idev = NULL; 306 struct ipv6hdr *hdr = skb->nh.ipv6h; 307 struct sock *sk; 308 struct ipv6_pinfo *np; 309 struct in6_addr *saddr = NULL; 310 struct dst_entry *dst; 311 struct icmp6hdr tmp_hdr; 312 struct flowi fl; 313 struct icmpv6_msg msg; 314 int iif = 0; 315 int addr_type = 0; 316 int len; 317 int hlimit, tclass; 318 int err = 0; 319 320 if ((u8*)hdr < skb->head || (u8*)(hdr+1) > skb->tail) 321 return; 322 323 /* 324 * Make sure we respect the rules 325 * i.e. RFC 1885 2.4(e) 326 * Rule (e.1) is enforced by not using icmpv6_send 327 * in any code that processes icmp errors. 328 */ 329 addr_type = ipv6_addr_type(&hdr->daddr); 330 331 if (ipv6_chk_addr(&hdr->daddr, skb->dev, 0)) 332 saddr = &hdr->daddr; 333 334 /* 335 * Dest addr check 336 */ 337 338 if ((addr_type & IPV6_ADDR_MULTICAST || skb->pkt_type != PACKET_HOST)) { 339 if (type != ICMPV6_PKT_TOOBIG && 340 !(type == ICMPV6_PARAMPROB && 341 code == ICMPV6_UNK_OPTION && 342 (opt_unrec(skb, info)))) 343 return; 344 345 saddr = NULL; 346 } 347 348 addr_type = ipv6_addr_type(&hdr->saddr); 349 350 /* 351 * Source addr check 352 */ 353 354 if (addr_type & IPV6_ADDR_LINKLOCAL) 355 iif = skb->dev->ifindex; 356 357 /* 358 * Must not send error if the source does not uniquely 359 * identify a single node (RFC2463 Section 2.4). 360 * We check unspecified / multicast addresses here, 361 * and anycast addresses will be checked later. 362 */ 363 if ((addr_type == IPV6_ADDR_ANY) || (addr_type & IPV6_ADDR_MULTICAST)) { 364 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: addr_any/mcast source\n"); 365 return; 366 } 367 368 /* 369 * Never answer to a ICMP packet. 370 */ 371 if (is_ineligible(skb)) { 372 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: no reply to icmp error\n"); 373 return; 374 } 375 376 mip6_addr_swap(skb); 377 378 memset(&fl, 0, sizeof(fl)); 379 fl.proto = IPPROTO_ICMPV6; 380 ipv6_addr_copy(&fl.fl6_dst, &hdr->saddr); 381 if (saddr) 382 ipv6_addr_copy(&fl.fl6_src, saddr); 383 fl.oif = iif; 384 fl.fl_icmp_type = type; 385 fl.fl_icmp_code = code; 386 security_skb_classify_flow(skb, &fl); 387 388 if (icmpv6_xmit_lock()) 389 return; 390 391 sk = icmpv6_socket->sk; 392 np = inet6_sk(sk); 393 394 if (!icmpv6_xrlim_allow(sk, type, &fl)) 395 goto out; 396 397 tmp_hdr.icmp6_type = type; 398 tmp_hdr.icmp6_code = code; 399 tmp_hdr.icmp6_cksum = 0; 400 tmp_hdr.icmp6_pointer = htonl(info); 401 402 if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst)) 403 fl.oif = np->mcast_oif; 404 405 err = ip6_dst_lookup(sk, &dst, &fl); 406 if (err) 407 goto out; 408 409 /* 410 * We won't send icmp if the destination is known 411 * anycast. 412 */ 413 if (((struct rt6_info *)dst)->rt6i_flags & RTF_ANYCAST) { 414 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: acast source\n"); 415 goto out_dst_release; 416 } 417 418 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0) 419 goto out; 420 421 if (ipv6_addr_is_multicast(&fl.fl6_dst)) 422 hlimit = np->mcast_hops; 423 else 424 hlimit = np->hop_limit; 425 if (hlimit < 0) 426 hlimit = dst_metric(dst, RTAX_HOPLIMIT); 427 if (hlimit < 0) 428 hlimit = ipv6_get_hoplimit(dst->dev); 429 430 tclass = np->tclass; 431 if (tclass < 0) 432 tclass = 0; 433 434 msg.skb = skb; 435 msg.offset = skb->nh.raw - skb->data; 436 msg.type = type; 437 438 len = skb->len - msg.offset; 439 len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) -sizeof(struct icmp6hdr)); 440 if (len < 0) { 441 LIMIT_NETDEBUG(KERN_DEBUG "icmp: len problem\n"); 442 goto out_dst_release; 443 } 444 445 idev = in6_dev_get(skb->dev); 446 447 err = ip6_append_data(sk, icmpv6_getfrag, &msg, 448 len + sizeof(struct icmp6hdr), 449 sizeof(struct icmp6hdr), 450 hlimit, tclass, NULL, &fl, (struct rt6_info*)dst, 451 MSG_DONTWAIT); 452 if (err) { 453 ip6_flush_pending_frames(sk); 454 goto out_put; 455 } 456 err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, len + sizeof(struct icmp6hdr)); 457 458 if (type >= ICMPV6_DEST_UNREACH && type <= ICMPV6_PARAMPROB) 459 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_OUTDESTUNREACHS, type - ICMPV6_DEST_UNREACH); 460 ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTMSGS); 461 462 out_put: 463 if (likely(idev != NULL)) 464 in6_dev_put(idev); 465 out_dst_release: 466 dst_release(dst); 467 out: 468 icmpv6_xmit_unlock(); 469 } 470 471 static void icmpv6_echo_reply(struct sk_buff *skb) 472 { 473 struct sock *sk; 474 struct inet6_dev *idev; 475 struct ipv6_pinfo *np; 476 struct in6_addr *saddr = NULL; 477 struct icmp6hdr *icmph = (struct icmp6hdr *) skb->h.raw; 478 struct icmp6hdr tmp_hdr; 479 struct flowi fl; 480 struct icmpv6_msg msg; 481 struct dst_entry *dst; 482 int err = 0; 483 int hlimit; 484 int tclass; 485 486 saddr = &skb->nh.ipv6h->daddr; 487 488 if (!ipv6_unicast_destination(skb)) 489 saddr = NULL; 490 491 memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr)); 492 tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY; 493 494 memset(&fl, 0, sizeof(fl)); 495 fl.proto = IPPROTO_ICMPV6; 496 ipv6_addr_copy(&fl.fl6_dst, &skb->nh.ipv6h->saddr); 497 if (saddr) 498 ipv6_addr_copy(&fl.fl6_src, saddr); 499 fl.oif = skb->dev->ifindex; 500 fl.fl_icmp_type = ICMPV6_ECHO_REPLY; 501 security_skb_classify_flow(skb, &fl); 502 503 if (icmpv6_xmit_lock()) 504 return; 505 506 sk = icmpv6_socket->sk; 507 np = inet6_sk(sk); 508 509 if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst)) 510 fl.oif = np->mcast_oif; 511 512 err = ip6_dst_lookup(sk, &dst, &fl); 513 if (err) 514 goto out; 515 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0) 516 goto out; 517 518 if (ipv6_addr_is_multicast(&fl.fl6_dst)) 519 hlimit = np->mcast_hops; 520 else 521 hlimit = np->hop_limit; 522 if (hlimit < 0) 523 hlimit = dst_metric(dst, RTAX_HOPLIMIT); 524 if (hlimit < 0) 525 hlimit = ipv6_get_hoplimit(dst->dev); 526 527 tclass = np->tclass; 528 if (tclass < 0) 529 tclass = 0; 530 531 idev = in6_dev_get(skb->dev); 532 533 msg.skb = skb; 534 msg.offset = 0; 535 msg.type = ICMPV6_ECHO_REPLY; 536 537 err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr), 538 sizeof(struct icmp6hdr), hlimit, tclass, NULL, &fl, 539 (struct rt6_info*)dst, MSG_DONTWAIT); 540 541 if (err) { 542 ip6_flush_pending_frames(sk); 543 goto out_put; 544 } 545 err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, skb->len + sizeof(struct icmp6hdr)); 546 547 ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTECHOREPLIES); 548 ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTMSGS); 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, u32 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 = &skb->nh.ipv6h->saddr; 585 daddr = &skb->nh.ipv6h->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, daddr, saddr, 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 = &skb->nh.ipv6h->saddr; 630 daddr = &skb->nh.ipv6h->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_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 = (struct icmp6hdr *) skb->h.raw; 653 654 type = hdr->icmp6_type; 655 656 if (type >= ICMPV6_DEST_UNREACH && type <= ICMPV6_PARAMPROB) 657 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_INDESTUNREACHS, type - ICMPV6_DEST_UNREACH); 658 else if (type >= ICMPV6_ECHO_REQUEST && type <= NDISC_REDIRECT) 659 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_INECHOS, type - ICMPV6_ECHO_REQUEST); 660 661 switch (type) { 662 case ICMPV6_ECHO_REQUEST: 663 icmpv6_echo_reply(skb); 664 break; 665 666 case ICMPV6_ECHO_REPLY: 667 /* we couldn't care less */ 668 break; 669 670 case ICMPV6_PKT_TOOBIG: 671 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update 672 standard destination cache. Seems, only "advanced" 673 destination cache will allow to solve this problem 674 --ANK (980726) 675 */ 676 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr))) 677 goto discard_it; 678 hdr = (struct icmp6hdr *) skb->h.raw; 679 orig_hdr = (struct ipv6hdr *) (hdr + 1); 680 rt6_pmtu_discovery(&orig_hdr->daddr, &orig_hdr->saddr, dev, 681 ntohl(hdr->icmp6_mtu)); 682 683 /* 684 * Drop through to notify 685 */ 686 687 case ICMPV6_DEST_UNREACH: 688 case ICMPV6_TIME_EXCEED: 689 case ICMPV6_PARAMPROB: 690 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu); 691 break; 692 693 case NDISC_ROUTER_SOLICITATION: 694 case NDISC_ROUTER_ADVERTISEMENT: 695 case NDISC_NEIGHBOUR_SOLICITATION: 696 case NDISC_NEIGHBOUR_ADVERTISEMENT: 697 case NDISC_REDIRECT: 698 ndisc_rcv(skb); 699 break; 700 701 case ICMPV6_MGM_QUERY: 702 igmp6_event_query(skb); 703 break; 704 705 case ICMPV6_MGM_REPORT: 706 igmp6_event_report(skb); 707 break; 708 709 case ICMPV6_MGM_REDUCTION: 710 case ICMPV6_NI_QUERY: 711 case ICMPV6_NI_REPLY: 712 case ICMPV6_MLD2_REPORT: 713 case ICMPV6_DHAAD_REQUEST: 714 case ICMPV6_DHAAD_REPLY: 715 case ICMPV6_MOBILE_PREFIX_SOL: 716 case ICMPV6_MOBILE_PREFIX_ADV: 717 break; 718 719 default: 720 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6: msg of unknown type\n"); 721 722 /* informational */ 723 if (type & ICMPV6_INFOMSG_MASK) 724 break; 725 726 /* 727 * error of unknown type. 728 * must pass to upper level 729 */ 730 731 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu); 732 }; 733 kfree_skb(skb); 734 return 0; 735 736 discard_it: 737 ICMP6_INC_STATS_BH(idev, ICMP6_MIB_INERRORS); 738 kfree_skb(skb); 739 return 0; 740 } 741 742 /* 743 * Special lock-class for __icmpv6_socket: 744 */ 745 static struct lock_class_key icmpv6_socket_sk_dst_lock_key; 746 747 int __init icmpv6_init(struct net_proto_family *ops) 748 { 749 struct sock *sk; 750 int err, i, j; 751 752 for_each_possible_cpu(i) { 753 err = sock_create_kern(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6, 754 &per_cpu(__icmpv6_socket, i)); 755 if (err < 0) { 756 printk(KERN_ERR 757 "Failed to initialize the ICMP6 control socket " 758 "(err %d).\n", 759 err); 760 goto fail; 761 } 762 763 sk = per_cpu(__icmpv6_socket, i)->sk; 764 sk->sk_allocation = GFP_ATOMIC; 765 /* 766 * Split off their lock-class, because sk->sk_dst_lock 767 * gets used from softirqs, which is safe for 768 * __icmpv6_socket (because those never get directly used 769 * via userspace syscalls), but unsafe for normal sockets. 770 */ 771 lockdep_set_class(&sk->sk_dst_lock, 772 &icmpv6_socket_sk_dst_lock_key); 773 774 /* Enough space for 2 64K ICMP packets, including 775 * sk_buff struct overhead. 776 */ 777 sk->sk_sndbuf = 778 (2 * ((64 * 1024) + sizeof(struct sk_buff))); 779 780 sk->sk_prot->unhash(sk); 781 } 782 783 784 if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0) { 785 printk(KERN_ERR "Failed to register ICMP6 protocol\n"); 786 err = -EAGAIN; 787 goto fail; 788 } 789 790 return 0; 791 792 fail: 793 for (j = 0; j < i; j++) { 794 if (!cpu_possible(j)) 795 continue; 796 sock_release(per_cpu(__icmpv6_socket, j)); 797 } 798 799 return err; 800 } 801 802 void icmpv6_cleanup(void) 803 { 804 int i; 805 806 for_each_possible_cpu(i) { 807 sock_release(per_cpu(__icmpv6_socket, i)); 808 } 809 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6); 810 } 811 812 static const struct icmp6_err { 813 int err; 814 int fatal; 815 } tab_unreach[] = { 816 { /* NOROUTE */ 817 .err = ENETUNREACH, 818 .fatal = 0, 819 }, 820 { /* ADM_PROHIBITED */ 821 .err = EACCES, 822 .fatal = 1, 823 }, 824 { /* Was NOT_NEIGHBOUR, now reserved */ 825 .err = EHOSTUNREACH, 826 .fatal = 0, 827 }, 828 { /* ADDR_UNREACH */ 829 .err = EHOSTUNREACH, 830 .fatal = 0, 831 }, 832 { /* PORT_UNREACH */ 833 .err = ECONNREFUSED, 834 .fatal = 1, 835 }, 836 }; 837 838 int icmpv6_err_convert(int type, int code, int *err) 839 { 840 int fatal = 0; 841 842 *err = EPROTO; 843 844 switch (type) { 845 case ICMPV6_DEST_UNREACH: 846 fatal = 1; 847 if (code <= ICMPV6_PORT_UNREACH) { 848 *err = tab_unreach[code].err; 849 fatal = tab_unreach[code].fatal; 850 } 851 break; 852 853 case ICMPV6_PKT_TOOBIG: 854 *err = EMSGSIZE; 855 break; 856 857 case ICMPV6_PARAMPROB: 858 *err = EPROTO; 859 fatal = 1; 860 break; 861 862 case ICMPV6_TIME_EXCEED: 863 *err = EHOSTUNREACH; 864 break; 865 }; 866 867 return fatal; 868 } 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