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 = 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 /* 277 * Send an ICMP message in response to a packet in error 278 */ 279 void icmpv6_send(struct sk_buff *skb, int type, int code, __u32 info, 280 struct net_device *dev) 281 { 282 struct inet6_dev *idev = NULL; 283 struct ipv6hdr *hdr = skb->nh.ipv6h; 284 struct sock *sk; 285 struct ipv6_pinfo *np; 286 struct in6_addr *saddr = NULL; 287 struct dst_entry *dst; 288 struct icmp6hdr tmp_hdr; 289 struct flowi fl; 290 struct icmpv6_msg msg; 291 int iif = 0; 292 int addr_type = 0; 293 int len; 294 int hlimit, tclass; 295 int err = 0; 296 297 if ((u8*)hdr < skb->head || (u8*)(hdr+1) > skb->tail) 298 return; 299 300 /* 301 * Make sure we respect the rules 302 * i.e. RFC 1885 2.4(e) 303 * Rule (e.1) is enforced by not using icmpv6_send 304 * in any code that processes icmp errors. 305 */ 306 addr_type = ipv6_addr_type(&hdr->daddr); 307 308 if (ipv6_chk_addr(&hdr->daddr, skb->dev, 0)) 309 saddr = &hdr->daddr; 310 311 /* 312 * Dest addr check 313 */ 314 315 if ((addr_type & IPV6_ADDR_MULTICAST || skb->pkt_type != PACKET_HOST)) { 316 if (type != ICMPV6_PKT_TOOBIG && 317 !(type == ICMPV6_PARAMPROB && 318 code == ICMPV6_UNK_OPTION && 319 (opt_unrec(skb, info)))) 320 return; 321 322 saddr = NULL; 323 } 324 325 addr_type = ipv6_addr_type(&hdr->saddr); 326 327 /* 328 * Source addr check 329 */ 330 331 if (addr_type & IPV6_ADDR_LINKLOCAL) 332 iif = skb->dev->ifindex; 333 334 /* 335 * Must not send error if the source does not uniquely 336 * identify a single node (RFC2463 Section 2.4). 337 * We check unspecified / multicast addresses here, 338 * and anycast addresses will be checked later. 339 */ 340 if ((addr_type == IPV6_ADDR_ANY) || (addr_type & IPV6_ADDR_MULTICAST)) { 341 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: addr_any/mcast source\n"); 342 return; 343 } 344 345 /* 346 * Never answer to a ICMP packet. 347 */ 348 if (is_ineligible(skb)) { 349 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: no reply to icmp error\n"); 350 return; 351 } 352 353 memset(&fl, 0, sizeof(fl)); 354 fl.proto = IPPROTO_ICMPV6; 355 ipv6_addr_copy(&fl.fl6_dst, &hdr->saddr); 356 if (saddr) 357 ipv6_addr_copy(&fl.fl6_src, saddr); 358 fl.oif = iif; 359 fl.fl_icmp_type = type; 360 fl.fl_icmp_code = code; 361 362 if (icmpv6_xmit_lock()) 363 return; 364 365 sk = icmpv6_socket->sk; 366 np = inet6_sk(sk); 367 368 if (!icmpv6_xrlim_allow(sk, type, &fl)) 369 goto out; 370 371 tmp_hdr.icmp6_type = type; 372 tmp_hdr.icmp6_code = code; 373 tmp_hdr.icmp6_cksum = 0; 374 tmp_hdr.icmp6_pointer = htonl(info); 375 376 if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst)) 377 fl.oif = np->mcast_oif; 378 379 err = ip6_dst_lookup(sk, &dst, &fl); 380 if (err) 381 goto out; 382 383 /* 384 * We won't send icmp if the destination is known 385 * anycast. 386 */ 387 if (((struct rt6_info *)dst)->rt6i_flags & RTF_ANYCAST) { 388 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6_send: acast source\n"); 389 goto out_dst_release; 390 } 391 392 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0) 393 goto out; 394 395 if (ipv6_addr_is_multicast(&fl.fl6_dst)) 396 hlimit = np->mcast_hops; 397 else 398 hlimit = np->hop_limit; 399 if (hlimit < 0) 400 hlimit = dst_metric(dst, RTAX_HOPLIMIT); 401 if (hlimit < 0) 402 hlimit = ipv6_get_hoplimit(dst->dev); 403 404 tclass = np->cork.tclass; 405 if (tclass < 0) 406 tclass = 0; 407 408 msg.skb = skb; 409 msg.offset = skb->nh.raw - skb->data; 410 msg.type = type; 411 412 len = skb->len - msg.offset; 413 len = min_t(unsigned int, len, IPV6_MIN_MTU - sizeof(struct ipv6hdr) -sizeof(struct icmp6hdr)); 414 if (len < 0) { 415 LIMIT_NETDEBUG(KERN_DEBUG "icmp: len problem\n"); 416 goto out_dst_release; 417 } 418 419 idev = in6_dev_get(skb->dev); 420 421 err = ip6_append_data(sk, icmpv6_getfrag, &msg, 422 len + sizeof(struct icmp6hdr), 423 sizeof(struct icmp6hdr), 424 hlimit, tclass, NULL, &fl, (struct rt6_info*)dst, 425 MSG_DONTWAIT); 426 if (err) { 427 ip6_flush_pending_frames(sk); 428 goto out_put; 429 } 430 err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, len + sizeof(struct icmp6hdr)); 431 432 if (type >= ICMPV6_DEST_UNREACH && type <= ICMPV6_PARAMPROB) 433 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_OUTDESTUNREACHS, type - ICMPV6_DEST_UNREACH); 434 ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTMSGS); 435 436 out_put: 437 if (likely(idev != NULL)) 438 in6_dev_put(idev); 439 out_dst_release: 440 dst_release(dst); 441 out: 442 icmpv6_xmit_unlock(); 443 } 444 445 static void icmpv6_echo_reply(struct sk_buff *skb) 446 { 447 struct sock *sk; 448 struct inet6_dev *idev; 449 struct ipv6_pinfo *np; 450 struct in6_addr *saddr = NULL; 451 struct icmp6hdr *icmph = (struct icmp6hdr *) skb->h.raw; 452 struct icmp6hdr tmp_hdr; 453 struct flowi fl; 454 struct icmpv6_msg msg; 455 struct dst_entry *dst; 456 int err = 0; 457 int hlimit; 458 int tclass; 459 460 saddr = &skb->nh.ipv6h->daddr; 461 462 if (!ipv6_unicast_destination(skb)) 463 saddr = NULL; 464 465 memcpy(&tmp_hdr, icmph, sizeof(tmp_hdr)); 466 tmp_hdr.icmp6_type = ICMPV6_ECHO_REPLY; 467 468 memset(&fl, 0, sizeof(fl)); 469 fl.proto = IPPROTO_ICMPV6; 470 ipv6_addr_copy(&fl.fl6_dst, &skb->nh.ipv6h->saddr); 471 if (saddr) 472 ipv6_addr_copy(&fl.fl6_src, saddr); 473 fl.oif = skb->dev->ifindex; 474 fl.fl_icmp_type = ICMPV6_ECHO_REPLY; 475 476 if (icmpv6_xmit_lock()) 477 return; 478 479 sk = icmpv6_socket->sk; 480 np = inet6_sk(sk); 481 482 if (!fl.oif && ipv6_addr_is_multicast(&fl.fl6_dst)) 483 fl.oif = np->mcast_oif; 484 485 err = ip6_dst_lookup(sk, &dst, &fl); 486 if (err) 487 goto out; 488 if ((err = xfrm_lookup(&dst, &fl, sk, 0)) < 0) 489 goto out; 490 491 if (ipv6_addr_is_multicast(&fl.fl6_dst)) 492 hlimit = np->mcast_hops; 493 else 494 hlimit = np->hop_limit; 495 if (hlimit < 0) 496 hlimit = dst_metric(dst, RTAX_HOPLIMIT); 497 if (hlimit < 0) 498 hlimit = ipv6_get_hoplimit(dst->dev); 499 500 tclass = np->cork.tclass; 501 if (tclass < 0) 502 tclass = 0; 503 504 idev = in6_dev_get(skb->dev); 505 506 msg.skb = skb; 507 msg.offset = 0; 508 msg.type = ICMPV6_ECHO_REPLY; 509 510 err = ip6_append_data(sk, icmpv6_getfrag, &msg, skb->len + sizeof(struct icmp6hdr), 511 sizeof(struct icmp6hdr), hlimit, tclass, NULL, &fl, 512 (struct rt6_info*)dst, MSG_DONTWAIT); 513 514 if (err) { 515 ip6_flush_pending_frames(sk); 516 goto out_put; 517 } 518 err = icmpv6_push_pending_frames(sk, &fl, &tmp_hdr, skb->len + sizeof(struct icmp6hdr)); 519 520 ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTECHOREPLIES); 521 ICMP6_INC_STATS_BH(idev, ICMP6_MIB_OUTMSGS); 522 523 out_put: 524 if (likely(idev != NULL)) 525 in6_dev_put(idev); 526 dst_release(dst); 527 out: 528 icmpv6_xmit_unlock(); 529 } 530 531 static void icmpv6_notify(struct sk_buff *skb, int type, int code, u32 info) 532 { 533 struct in6_addr *saddr, *daddr; 534 struct inet6_protocol *ipprot; 535 struct sock *sk; 536 int inner_offset; 537 int hash; 538 u8 nexthdr; 539 540 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr))) 541 return; 542 543 nexthdr = ((struct ipv6hdr *)skb->data)->nexthdr; 544 if (ipv6_ext_hdr(nexthdr)) { 545 /* now skip over extension headers */ 546 inner_offset = ipv6_skip_exthdr(skb, sizeof(struct ipv6hdr), &nexthdr); 547 if (inner_offset<0) 548 return; 549 } else { 550 inner_offset = sizeof(struct ipv6hdr); 551 } 552 553 /* Checkin header including 8 bytes of inner protocol header. */ 554 if (!pskb_may_pull(skb, inner_offset+8)) 555 return; 556 557 saddr = &skb->nh.ipv6h->saddr; 558 daddr = &skb->nh.ipv6h->daddr; 559 560 /* BUGGG_FUTURE: we should try to parse exthdrs in this packet. 561 Without this we will not able f.e. to make source routed 562 pmtu discovery. 563 Corresponding argument (opt) to notifiers is already added. 564 --ANK (980726) 565 */ 566 567 hash = nexthdr & (MAX_INET_PROTOS - 1); 568 569 rcu_read_lock(); 570 ipprot = rcu_dereference(inet6_protos[hash]); 571 if (ipprot && ipprot->err_handler) 572 ipprot->err_handler(skb, NULL, type, code, inner_offset, info); 573 rcu_read_unlock(); 574 575 read_lock(&raw_v6_lock); 576 if ((sk = sk_head(&raw_v6_htable[hash])) != NULL) { 577 while((sk = __raw_v6_lookup(sk, nexthdr, daddr, saddr, 578 IP6CB(skb)->iif))) { 579 rawv6_err(sk, skb, NULL, type, code, inner_offset, info); 580 sk = sk_next(sk); 581 } 582 } 583 read_unlock(&raw_v6_lock); 584 } 585 586 /* 587 * Handle icmp messages 588 */ 589 590 static int icmpv6_rcv(struct sk_buff **pskb) 591 { 592 struct sk_buff *skb = *pskb; 593 struct net_device *dev = skb->dev; 594 struct inet6_dev *idev = __in6_dev_get(dev); 595 struct in6_addr *saddr, *daddr; 596 struct ipv6hdr *orig_hdr; 597 struct icmp6hdr *hdr; 598 int type; 599 600 ICMP6_INC_STATS_BH(idev, ICMP6_MIB_INMSGS); 601 602 saddr = &skb->nh.ipv6h->saddr; 603 daddr = &skb->nh.ipv6h->daddr; 604 605 /* Perform checksum. */ 606 switch (skb->ip_summed) { 607 case CHECKSUM_HW: 608 if (!csum_ipv6_magic(saddr, daddr, skb->len, IPPROTO_ICMPV6, 609 skb->csum)) 610 break; 611 /* fall through */ 612 case CHECKSUM_NONE: 613 skb->csum = ~csum_ipv6_magic(saddr, daddr, skb->len, 614 IPPROTO_ICMPV6, 0); 615 if (__skb_checksum_complete(skb)) { 616 LIMIT_NETDEBUG(KERN_DEBUG "ICMPv6 checksum failed [" NIP6_FMT " > " NIP6_FMT "]\n", 617 NIP6(*saddr), NIP6(*daddr)); 618 goto discard_it; 619 } 620 } 621 622 if (!pskb_pull(skb, sizeof(struct icmp6hdr))) 623 goto discard_it; 624 625 hdr = (struct icmp6hdr *) skb->h.raw; 626 627 type = hdr->icmp6_type; 628 629 if (type >= ICMPV6_DEST_UNREACH && type <= ICMPV6_PARAMPROB) 630 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_INDESTUNREACHS, type - ICMPV6_DEST_UNREACH); 631 else if (type >= ICMPV6_ECHO_REQUEST && type <= NDISC_REDIRECT) 632 ICMP6_INC_STATS_OFFSET_BH(idev, ICMP6_MIB_INECHOS, type - ICMPV6_ECHO_REQUEST); 633 634 switch (type) { 635 case ICMPV6_ECHO_REQUEST: 636 icmpv6_echo_reply(skb); 637 break; 638 639 case ICMPV6_ECHO_REPLY: 640 /* we couldn't care less */ 641 break; 642 643 case ICMPV6_PKT_TOOBIG: 644 /* BUGGG_FUTURE: if packet contains rthdr, we cannot update 645 standard destination cache. Seems, only "advanced" 646 destination cache will allow to solve this problem 647 --ANK (980726) 648 */ 649 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr))) 650 goto discard_it; 651 hdr = (struct icmp6hdr *) skb->h.raw; 652 orig_hdr = (struct ipv6hdr *) (hdr + 1); 653 rt6_pmtu_discovery(&orig_hdr->daddr, &orig_hdr->saddr, dev, 654 ntohl(hdr->icmp6_mtu)); 655 656 /* 657 * Drop through to notify 658 */ 659 660 case ICMPV6_DEST_UNREACH: 661 case ICMPV6_TIME_EXCEED: 662 case ICMPV6_PARAMPROB: 663 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu); 664 break; 665 666 case NDISC_ROUTER_SOLICITATION: 667 case NDISC_ROUTER_ADVERTISEMENT: 668 case NDISC_NEIGHBOUR_SOLICITATION: 669 case NDISC_NEIGHBOUR_ADVERTISEMENT: 670 case NDISC_REDIRECT: 671 ndisc_rcv(skb); 672 break; 673 674 case ICMPV6_MGM_QUERY: 675 igmp6_event_query(skb); 676 break; 677 678 case ICMPV6_MGM_REPORT: 679 igmp6_event_report(skb); 680 break; 681 682 case ICMPV6_MGM_REDUCTION: 683 case ICMPV6_NI_QUERY: 684 case ICMPV6_NI_REPLY: 685 case ICMPV6_MLD2_REPORT: 686 case ICMPV6_DHAAD_REQUEST: 687 case ICMPV6_DHAAD_REPLY: 688 case ICMPV6_MOBILE_PREFIX_SOL: 689 case ICMPV6_MOBILE_PREFIX_ADV: 690 break; 691 692 default: 693 LIMIT_NETDEBUG(KERN_DEBUG "icmpv6: msg of unknown type\n"); 694 695 /* informational */ 696 if (type & ICMPV6_INFOMSG_MASK) 697 break; 698 699 /* 700 * error of unknown type. 701 * must pass to upper level 702 */ 703 704 icmpv6_notify(skb, type, hdr->icmp6_code, hdr->icmp6_mtu); 705 }; 706 kfree_skb(skb); 707 return 0; 708 709 discard_it: 710 ICMP6_INC_STATS_BH(idev, ICMP6_MIB_INERRORS); 711 kfree_skb(skb); 712 return 0; 713 } 714 715 int __init icmpv6_init(struct net_proto_family *ops) 716 { 717 struct sock *sk; 718 int err, i, j; 719 720 for_each_cpu(i) { 721 err = sock_create_kern(PF_INET6, SOCK_RAW, IPPROTO_ICMPV6, 722 &per_cpu(__icmpv6_socket, i)); 723 if (err < 0) { 724 printk(KERN_ERR 725 "Failed to initialize the ICMP6 control socket " 726 "(err %d).\n", 727 err); 728 goto fail; 729 } 730 731 sk = per_cpu(__icmpv6_socket, i)->sk; 732 sk->sk_allocation = GFP_ATOMIC; 733 734 /* Enough space for 2 64K ICMP packets, including 735 * sk_buff struct overhead. 736 */ 737 sk->sk_sndbuf = 738 (2 * ((64 * 1024) + sizeof(struct sk_buff))); 739 740 sk->sk_prot->unhash(sk); 741 } 742 743 744 if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0) { 745 printk(KERN_ERR "Failed to register ICMP6 protocol\n"); 746 err = -EAGAIN; 747 goto fail; 748 } 749 750 return 0; 751 752 fail: 753 for (j = 0; j < i; j++) { 754 if (!cpu_possible(j)) 755 continue; 756 sock_release(per_cpu(__icmpv6_socket, j)); 757 } 758 759 return err; 760 } 761 762 void icmpv6_cleanup(void) 763 { 764 int i; 765 766 for_each_cpu(i) { 767 sock_release(per_cpu(__icmpv6_socket, i)); 768 } 769 inet6_del_protocol(&icmpv6_protocol, IPPROTO_ICMPV6); 770 } 771 772 static const struct icmp6_err { 773 int err; 774 int fatal; 775 } tab_unreach[] = { 776 { /* NOROUTE */ 777 .err = ENETUNREACH, 778 .fatal = 0, 779 }, 780 { /* ADM_PROHIBITED */ 781 .err = EACCES, 782 .fatal = 1, 783 }, 784 { /* Was NOT_NEIGHBOUR, now reserved */ 785 .err = EHOSTUNREACH, 786 .fatal = 0, 787 }, 788 { /* ADDR_UNREACH */ 789 .err = EHOSTUNREACH, 790 .fatal = 0, 791 }, 792 { /* PORT_UNREACH */ 793 .err = ECONNREFUSED, 794 .fatal = 1, 795 }, 796 }; 797 798 int icmpv6_err_convert(int type, int code, int *err) 799 { 800 int fatal = 0; 801 802 *err = EPROTO; 803 804 switch (type) { 805 case ICMPV6_DEST_UNREACH: 806 fatal = 1; 807 if (code <= ICMPV6_PORT_UNREACH) { 808 *err = tab_unreach[code].err; 809 fatal = tab_unreach[code].fatal; 810 } 811 break; 812 813 case ICMPV6_PKT_TOOBIG: 814 *err = EMSGSIZE; 815 break; 816 817 case ICMPV6_PARAMPROB: 818 *err = EPROTO; 819 fatal = 1; 820 break; 821 822 case ICMPV6_TIME_EXCEED: 823 *err = EHOSTUNREACH; 824 break; 825 }; 826 827 return fatal; 828 } 829 830 #ifdef CONFIG_SYSCTL 831 ctl_table ipv6_icmp_table[] = { 832 { 833 .ctl_name = NET_IPV6_ICMP_RATELIMIT, 834 .procname = "ratelimit", 835 .data = &sysctl_icmpv6_time, 836 .maxlen = sizeof(int), 837 .mode = 0644, 838 .proc_handler = &proc_dointvec 839 }, 840 { .ctl_name = 0 }, 841 }; 842 #endif 843 844