1 /* 2 * PF_INET6 socket protocol family 3 * Linux INET6 implementation 4 * 5 * Authors: 6 * Pedro Roque <roque@di.fc.ul.pt> 7 * 8 * Adapted from linux/net/ipv4/af_inet.c 9 * 10 * Fixes: 11 * piggy, Karl Knutson : Socket protocol table 12 * Hideaki YOSHIFUJI : sin6_scope_id support 13 * Arnaldo Melo : check proc_net_create return, cleanups 14 * 15 * This program is free software; you can redistribute it and/or 16 * modify it under the terms of the GNU General Public License 17 * as published by the Free Software Foundation; either version 18 * 2 of the License, or (at your option) any later version. 19 */ 20 21 22 #include <linux/module.h> 23 #include <linux/capability.h> 24 #include <linux/errno.h> 25 #include <linux/types.h> 26 #include <linux/socket.h> 27 #include <linux/in.h> 28 #include <linux/kernel.h> 29 #include <linux/timer.h> 30 #include <linux/string.h> 31 #include <linux/sockios.h> 32 #include <linux/net.h> 33 #include <linux/fcntl.h> 34 #include <linux/mm.h> 35 #include <linux/interrupt.h> 36 #include <linux/proc_fs.h> 37 #include <linux/stat.h> 38 #include <linux/init.h> 39 40 #include <linux/inet.h> 41 #include <linux/netdevice.h> 42 #include <linux/icmpv6.h> 43 #include <linux/netfilter_ipv6.h> 44 45 #include <net/ip.h> 46 #include <net/ipv6.h> 47 #include <net/udp.h> 48 #include <net/udplite.h> 49 #include <net/tcp.h> 50 #include <net/ipip.h> 51 #include <net/protocol.h> 52 #include <net/inet_common.h> 53 #include <net/route.h> 54 #include <net/transp_v6.h> 55 #include <net/ip6_route.h> 56 #include <net/addrconf.h> 57 #ifdef CONFIG_IPV6_TUNNEL 58 #include <net/ip6_tunnel.h> 59 #endif 60 61 #include <asm/uaccess.h> 62 #include <asm/system.h> 63 #include <linux/mroute6.h> 64 65 MODULE_AUTHOR("Cast of dozens"); 66 MODULE_DESCRIPTION("IPv6 protocol stack for Linux"); 67 MODULE_LICENSE("GPL"); 68 69 /* The inetsw6 table contains everything that inet6_create needs to 70 * build a new socket. 71 */ 72 static struct list_head inetsw6[SOCK_MAX]; 73 static DEFINE_SPINLOCK(inetsw6_lock); 74 75 struct ipv6_params ipv6_defaults = { 76 .disable_ipv6 = 0, 77 .autoconf = 1, 78 }; 79 80 static int disable_ipv6_mod = 0; 81 82 module_param_named(disable, disable_ipv6_mod, int, 0444); 83 MODULE_PARM_DESC(disable, "Disable IPv6 module such that it is non-functional"); 84 85 module_param_named(disable_ipv6, ipv6_defaults.disable_ipv6, int, 0444); 86 MODULE_PARM_DESC(disable_ipv6, "Disable IPv6 on all interfaces"); 87 88 module_param_named(autoconf, ipv6_defaults.autoconf, int, 0444); 89 MODULE_PARM_DESC(autoconf, "Enable IPv6 address autoconfiguration on all interfaces"); 90 91 static __inline__ struct ipv6_pinfo *inet6_sk_generic(struct sock *sk) 92 { 93 const int offset = sk->sk_prot->obj_size - sizeof(struct ipv6_pinfo); 94 95 return (struct ipv6_pinfo *)(((u8 *)sk) + offset); 96 } 97 98 static int inet6_create(struct net *net, struct socket *sock, int protocol, 99 int kern) 100 { 101 struct inet_sock *inet; 102 struct ipv6_pinfo *np; 103 struct sock *sk; 104 struct inet_protosw *answer; 105 struct proto *answer_prot; 106 unsigned char answer_flags; 107 char answer_no_check; 108 int try_loading_module = 0; 109 int err; 110 111 if (sock->type != SOCK_RAW && 112 sock->type != SOCK_DGRAM && 113 !inet_ehash_secret) 114 build_ehash_secret(); 115 116 /* Look for the requested type/protocol pair. */ 117 lookup_protocol: 118 err = -ESOCKTNOSUPPORT; 119 rcu_read_lock(); 120 list_for_each_entry_rcu(answer, &inetsw6[sock->type], list) { 121 122 err = 0; 123 /* Check the non-wild match. */ 124 if (protocol == answer->protocol) { 125 if (protocol != IPPROTO_IP) 126 break; 127 } else { 128 /* Check for the two wild cases. */ 129 if (IPPROTO_IP == protocol) { 130 protocol = answer->protocol; 131 break; 132 } 133 if (IPPROTO_IP == answer->protocol) 134 break; 135 } 136 err = -EPROTONOSUPPORT; 137 } 138 139 if (err) { 140 if (try_loading_module < 2) { 141 rcu_read_unlock(); 142 /* 143 * Be more specific, e.g. net-pf-10-proto-132-type-1 144 * (net-pf-PF_INET6-proto-IPPROTO_SCTP-type-SOCK_STREAM) 145 */ 146 if (++try_loading_module == 1) 147 request_module("net-pf-%d-proto-%d-type-%d", 148 PF_INET6, protocol, sock->type); 149 /* 150 * Fall back to generic, e.g. net-pf-10-proto-132 151 * (net-pf-PF_INET6-proto-IPPROTO_SCTP) 152 */ 153 else 154 request_module("net-pf-%d-proto-%d", 155 PF_INET6, protocol); 156 goto lookup_protocol; 157 } else 158 goto out_rcu_unlock; 159 } 160 161 err = -EPERM; 162 if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW)) 163 goto out_rcu_unlock; 164 165 sock->ops = answer->ops; 166 answer_prot = answer->prot; 167 answer_no_check = answer->no_check; 168 answer_flags = answer->flags; 169 rcu_read_unlock(); 170 171 WARN_ON(answer_prot->slab == NULL); 172 173 err = -ENOBUFS; 174 sk = sk_alloc(net, PF_INET6, GFP_KERNEL, answer_prot); 175 if (sk == NULL) 176 goto out; 177 178 sock_init_data(sock, sk); 179 180 err = 0; 181 sk->sk_no_check = answer_no_check; 182 if (INET_PROTOSW_REUSE & answer_flags) 183 sk->sk_reuse = 1; 184 185 inet = inet_sk(sk); 186 inet->is_icsk = (INET_PROTOSW_ICSK & answer_flags) != 0; 187 188 if (SOCK_RAW == sock->type) { 189 inet->inet_num = protocol; 190 if (IPPROTO_RAW == protocol) 191 inet->hdrincl = 1; 192 } 193 194 sk->sk_destruct = inet_sock_destruct; 195 sk->sk_family = PF_INET6; 196 sk->sk_protocol = protocol; 197 198 sk->sk_backlog_rcv = answer->prot->backlog_rcv; 199 200 inet_sk(sk)->pinet6 = np = inet6_sk_generic(sk); 201 np->hop_limit = -1; 202 np->mcast_hops = -1; 203 np->mc_loop = 1; 204 np->pmtudisc = IPV6_PMTUDISC_WANT; 205 np->ipv6only = net->ipv6.sysctl.bindv6only; 206 207 /* Init the ipv4 part of the socket since we can have sockets 208 * using v6 API for ipv4. 209 */ 210 inet->uc_ttl = -1; 211 212 inet->mc_loop = 1; 213 inet->mc_ttl = 1; 214 inet->mc_index = 0; 215 inet->mc_list = NULL; 216 217 if (ipv4_config.no_pmtu_disc) 218 inet->pmtudisc = IP_PMTUDISC_DONT; 219 else 220 inet->pmtudisc = IP_PMTUDISC_WANT; 221 /* 222 * Increment only the relevant sk_prot->socks debug field, this changes 223 * the previous behaviour of incrementing both the equivalent to 224 * answer->prot->socks (inet6_sock_nr) and inet_sock_nr. 225 * 226 * This allows better debug granularity as we'll know exactly how many 227 * UDPv6, TCPv6, etc socks were allocated, not the sum of all IPv6 228 * transport protocol socks. -acme 229 */ 230 sk_refcnt_debug_inc(sk); 231 232 if (inet->inet_num) { 233 /* It assumes that any protocol which allows 234 * the user to assign a number at socket 235 * creation time automatically shares. 236 */ 237 inet->inet_sport = htons(inet->inet_num); 238 sk->sk_prot->hash(sk); 239 } 240 if (sk->sk_prot->init) { 241 err = sk->sk_prot->init(sk); 242 if (err) { 243 sk_common_release(sk); 244 goto out; 245 } 246 } 247 out: 248 return err; 249 out_rcu_unlock: 250 rcu_read_unlock(); 251 goto out; 252 } 253 254 255 /* bind for INET6 API */ 256 int inet6_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) 257 { 258 struct sockaddr_in6 *addr=(struct sockaddr_in6 *)uaddr; 259 struct sock *sk = sock->sk; 260 struct inet_sock *inet = inet_sk(sk); 261 struct ipv6_pinfo *np = inet6_sk(sk); 262 struct net *net = sock_net(sk); 263 __be32 v4addr = 0; 264 unsigned short snum; 265 int addr_type = 0; 266 int err = 0; 267 268 /* If the socket has its own bind function then use it. */ 269 if (sk->sk_prot->bind) 270 return sk->sk_prot->bind(sk, uaddr, addr_len); 271 272 if (addr_len < SIN6_LEN_RFC2133) 273 return -EINVAL; 274 addr_type = ipv6_addr_type(&addr->sin6_addr); 275 if ((addr_type & IPV6_ADDR_MULTICAST) && sock->type == SOCK_STREAM) 276 return -EINVAL; 277 278 snum = ntohs(addr->sin6_port); 279 if (snum && snum < PROT_SOCK && !capable(CAP_NET_BIND_SERVICE)) 280 return -EACCES; 281 282 lock_sock(sk); 283 284 /* Check these errors (active socket, double bind). */ 285 if (sk->sk_state != TCP_CLOSE || inet->inet_num) { 286 err = -EINVAL; 287 goto out; 288 } 289 290 /* Check if the address belongs to the host. */ 291 if (addr_type == IPV6_ADDR_MAPPED) { 292 int chk_addr_ret; 293 294 /* Binding to v4-mapped address on a v6-only socket 295 * makes no sense 296 */ 297 if (np->ipv6only) { 298 err = -EINVAL; 299 goto out; 300 } 301 302 /* Reproduce AF_INET checks to make the bindings consitant */ 303 v4addr = addr->sin6_addr.s6_addr32[3]; 304 chk_addr_ret = inet_addr_type(net, v4addr); 305 if (!sysctl_ip_nonlocal_bind && 306 !(inet->freebind || inet->transparent) && 307 v4addr != htonl(INADDR_ANY) && 308 chk_addr_ret != RTN_LOCAL && 309 chk_addr_ret != RTN_MULTICAST && 310 chk_addr_ret != RTN_BROADCAST) { 311 err = -EADDRNOTAVAIL; 312 goto out; 313 } 314 } else { 315 if (addr_type != IPV6_ADDR_ANY) { 316 struct net_device *dev = NULL; 317 318 rcu_read_lock(); 319 if (addr_type & IPV6_ADDR_LINKLOCAL) { 320 if (addr_len >= sizeof(struct sockaddr_in6) && 321 addr->sin6_scope_id) { 322 /* Override any existing binding, if another one 323 * is supplied by user. 324 */ 325 sk->sk_bound_dev_if = addr->sin6_scope_id; 326 } 327 328 /* Binding to link-local address requires an interface */ 329 if (!sk->sk_bound_dev_if) { 330 err = -EINVAL; 331 goto out_unlock; 332 } 333 dev = dev_get_by_index_rcu(net, sk->sk_bound_dev_if); 334 if (!dev) { 335 err = -ENODEV; 336 goto out_unlock; 337 } 338 } 339 340 /* ipv4 addr of the socket is invalid. Only the 341 * unspecified and mapped address have a v4 equivalent. 342 */ 343 v4addr = LOOPBACK4_IPV6; 344 if (!(addr_type & IPV6_ADDR_MULTICAST)) { 345 if (!ipv6_chk_addr(net, &addr->sin6_addr, 346 dev, 0)) { 347 err = -EADDRNOTAVAIL; 348 goto out_unlock; 349 } 350 } 351 rcu_read_unlock(); 352 } 353 } 354 355 inet->inet_rcv_saddr = v4addr; 356 inet->inet_saddr = v4addr; 357 358 ipv6_addr_copy(&np->rcv_saddr, &addr->sin6_addr); 359 360 if (!(addr_type & IPV6_ADDR_MULTICAST)) 361 ipv6_addr_copy(&np->saddr, &addr->sin6_addr); 362 363 /* Make sure we are allowed to bind here. */ 364 if (sk->sk_prot->get_port(sk, snum)) { 365 inet_reset_saddr(sk); 366 err = -EADDRINUSE; 367 goto out; 368 } 369 370 if (addr_type != IPV6_ADDR_ANY) { 371 sk->sk_userlocks |= SOCK_BINDADDR_LOCK; 372 if (addr_type != IPV6_ADDR_MAPPED) 373 np->ipv6only = 1; 374 } 375 if (snum) 376 sk->sk_userlocks |= SOCK_BINDPORT_LOCK; 377 inet->inet_sport = htons(inet->inet_num); 378 inet->inet_dport = 0; 379 inet->inet_daddr = 0; 380 out: 381 release_sock(sk); 382 return err; 383 out_unlock: 384 rcu_read_unlock(); 385 goto out; 386 } 387 388 EXPORT_SYMBOL(inet6_bind); 389 390 int inet6_release(struct socket *sock) 391 { 392 struct sock *sk = sock->sk; 393 394 if (sk == NULL) 395 return -EINVAL; 396 397 /* Free mc lists */ 398 ipv6_sock_mc_close(sk); 399 400 /* Free ac lists */ 401 ipv6_sock_ac_close(sk); 402 403 return inet_release(sock); 404 } 405 406 EXPORT_SYMBOL(inet6_release); 407 408 void inet6_destroy_sock(struct sock *sk) 409 { 410 struct ipv6_pinfo *np = inet6_sk(sk); 411 struct sk_buff *skb; 412 struct ipv6_txoptions *opt; 413 414 /* Release rx options */ 415 416 if ((skb = xchg(&np->pktoptions, NULL)) != NULL) 417 kfree_skb(skb); 418 419 /* Free flowlabels */ 420 fl6_free_socklist(sk); 421 422 /* Free tx options */ 423 424 if ((opt = xchg(&np->opt, NULL)) != NULL) 425 sock_kfree_s(sk, opt, opt->tot_len); 426 } 427 428 EXPORT_SYMBOL_GPL(inet6_destroy_sock); 429 430 /* 431 * This does both peername and sockname. 432 */ 433 434 int inet6_getname(struct socket *sock, struct sockaddr *uaddr, 435 int *uaddr_len, int peer) 436 { 437 struct sockaddr_in6 *sin=(struct sockaddr_in6 *)uaddr; 438 struct sock *sk = sock->sk; 439 struct inet_sock *inet = inet_sk(sk); 440 struct ipv6_pinfo *np = inet6_sk(sk); 441 442 sin->sin6_family = AF_INET6; 443 sin->sin6_flowinfo = 0; 444 sin->sin6_scope_id = 0; 445 if (peer) { 446 if (!inet->inet_dport) 447 return -ENOTCONN; 448 if (((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_SYN_SENT)) && 449 peer == 1) 450 return -ENOTCONN; 451 sin->sin6_port = inet->inet_dport; 452 ipv6_addr_copy(&sin->sin6_addr, &np->daddr); 453 if (np->sndflow) 454 sin->sin6_flowinfo = np->flow_label; 455 } else { 456 if (ipv6_addr_any(&np->rcv_saddr)) 457 ipv6_addr_copy(&sin->sin6_addr, &np->saddr); 458 else 459 ipv6_addr_copy(&sin->sin6_addr, &np->rcv_saddr); 460 461 sin->sin6_port = inet->inet_sport; 462 } 463 if (ipv6_addr_type(&sin->sin6_addr) & IPV6_ADDR_LINKLOCAL) 464 sin->sin6_scope_id = sk->sk_bound_dev_if; 465 *uaddr_len = sizeof(*sin); 466 return(0); 467 } 468 469 EXPORT_SYMBOL(inet6_getname); 470 471 int inet6_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 472 { 473 struct sock *sk = sock->sk; 474 struct net *net = sock_net(sk); 475 476 switch(cmd) 477 { 478 case SIOCGSTAMP: 479 return sock_get_timestamp(sk, (struct timeval __user *)arg); 480 481 case SIOCGSTAMPNS: 482 return sock_get_timestampns(sk, (struct timespec __user *)arg); 483 484 case SIOCADDRT: 485 case SIOCDELRT: 486 487 return(ipv6_route_ioctl(net, cmd, (void __user *)arg)); 488 489 case SIOCSIFADDR: 490 return addrconf_add_ifaddr(net, (void __user *) arg); 491 case SIOCDIFADDR: 492 return addrconf_del_ifaddr(net, (void __user *) arg); 493 case SIOCSIFDSTADDR: 494 return addrconf_set_dstaddr(net, (void __user *) arg); 495 default: 496 if (!sk->sk_prot->ioctl) 497 return -ENOIOCTLCMD; 498 return sk->sk_prot->ioctl(sk, cmd, arg); 499 } 500 /*NOTREACHED*/ 501 return(0); 502 } 503 504 EXPORT_SYMBOL(inet6_ioctl); 505 506 const struct proto_ops inet6_stream_ops = { 507 .family = PF_INET6, 508 .owner = THIS_MODULE, 509 .release = inet6_release, 510 .bind = inet6_bind, 511 .connect = inet_stream_connect, /* ok */ 512 .socketpair = sock_no_socketpair, /* a do nothing */ 513 .accept = inet_accept, /* ok */ 514 .getname = inet6_getname, 515 .poll = tcp_poll, /* ok */ 516 .ioctl = inet6_ioctl, /* must change */ 517 .listen = inet_listen, /* ok */ 518 .shutdown = inet_shutdown, /* ok */ 519 .setsockopt = sock_common_setsockopt, /* ok */ 520 .getsockopt = sock_common_getsockopt, /* ok */ 521 .sendmsg = tcp_sendmsg, /* ok */ 522 .recvmsg = sock_common_recvmsg, /* ok */ 523 .mmap = sock_no_mmap, 524 .sendpage = tcp_sendpage, 525 .splice_read = tcp_splice_read, 526 #ifdef CONFIG_COMPAT 527 .compat_setsockopt = compat_sock_common_setsockopt, 528 .compat_getsockopt = compat_sock_common_getsockopt, 529 #endif 530 }; 531 532 const struct proto_ops inet6_dgram_ops = { 533 .family = PF_INET6, 534 .owner = THIS_MODULE, 535 .release = inet6_release, 536 .bind = inet6_bind, 537 .connect = inet_dgram_connect, /* ok */ 538 .socketpair = sock_no_socketpair, /* a do nothing */ 539 .accept = sock_no_accept, /* a do nothing */ 540 .getname = inet6_getname, 541 .poll = udp_poll, /* ok */ 542 .ioctl = inet6_ioctl, /* must change */ 543 .listen = sock_no_listen, /* ok */ 544 .shutdown = inet_shutdown, /* ok */ 545 .setsockopt = sock_common_setsockopt, /* ok */ 546 .getsockopt = sock_common_getsockopt, /* ok */ 547 .sendmsg = inet_sendmsg, /* ok */ 548 .recvmsg = sock_common_recvmsg, /* ok */ 549 .mmap = sock_no_mmap, 550 .sendpage = sock_no_sendpage, 551 #ifdef CONFIG_COMPAT 552 .compat_setsockopt = compat_sock_common_setsockopt, 553 .compat_getsockopt = compat_sock_common_getsockopt, 554 #endif 555 }; 556 557 static const struct net_proto_family inet6_family_ops = { 558 .family = PF_INET6, 559 .create = inet6_create, 560 .owner = THIS_MODULE, 561 }; 562 563 int inet6_register_protosw(struct inet_protosw *p) 564 { 565 struct list_head *lh; 566 struct inet_protosw *answer; 567 struct list_head *last_perm; 568 int protocol = p->protocol; 569 int ret; 570 571 spin_lock_bh(&inetsw6_lock); 572 573 ret = -EINVAL; 574 if (p->type >= SOCK_MAX) 575 goto out_illegal; 576 577 /* If we are trying to override a permanent protocol, bail. */ 578 answer = NULL; 579 ret = -EPERM; 580 last_perm = &inetsw6[p->type]; 581 list_for_each(lh, &inetsw6[p->type]) { 582 answer = list_entry(lh, struct inet_protosw, list); 583 584 /* Check only the non-wild match. */ 585 if (INET_PROTOSW_PERMANENT & answer->flags) { 586 if (protocol == answer->protocol) 587 break; 588 last_perm = lh; 589 } 590 591 answer = NULL; 592 } 593 if (answer) 594 goto out_permanent; 595 596 /* Add the new entry after the last permanent entry if any, so that 597 * the new entry does not override a permanent entry when matched with 598 * a wild-card protocol. But it is allowed to override any existing 599 * non-permanent entry. This means that when we remove this entry, the 600 * system automatically returns to the old behavior. 601 */ 602 list_add_rcu(&p->list, last_perm); 603 ret = 0; 604 out: 605 spin_unlock_bh(&inetsw6_lock); 606 return ret; 607 608 out_permanent: 609 printk(KERN_ERR "Attempt to override permanent protocol %d.\n", 610 protocol); 611 goto out; 612 613 out_illegal: 614 printk(KERN_ERR 615 "Ignoring attempt to register invalid socket type %d.\n", 616 p->type); 617 goto out; 618 } 619 620 EXPORT_SYMBOL(inet6_register_protosw); 621 622 void 623 inet6_unregister_protosw(struct inet_protosw *p) 624 { 625 if (INET_PROTOSW_PERMANENT & p->flags) { 626 printk(KERN_ERR 627 "Attempt to unregister permanent protocol %d.\n", 628 p->protocol); 629 } else { 630 spin_lock_bh(&inetsw6_lock); 631 list_del_rcu(&p->list); 632 spin_unlock_bh(&inetsw6_lock); 633 634 synchronize_net(); 635 } 636 } 637 638 EXPORT_SYMBOL(inet6_unregister_protosw); 639 640 int inet6_sk_rebuild_header(struct sock *sk) 641 { 642 int err; 643 struct dst_entry *dst; 644 struct ipv6_pinfo *np = inet6_sk(sk); 645 646 dst = __sk_dst_check(sk, np->dst_cookie); 647 648 if (dst == NULL) { 649 struct inet_sock *inet = inet_sk(sk); 650 struct in6_addr *final_p = NULL, final; 651 struct flowi fl; 652 653 memset(&fl, 0, sizeof(fl)); 654 fl.proto = sk->sk_protocol; 655 ipv6_addr_copy(&fl.fl6_dst, &np->daddr); 656 ipv6_addr_copy(&fl.fl6_src, &np->saddr); 657 fl.fl6_flowlabel = np->flow_label; 658 fl.oif = sk->sk_bound_dev_if; 659 fl.mark = sk->sk_mark; 660 fl.fl_ip_dport = inet->inet_dport; 661 fl.fl_ip_sport = inet->inet_sport; 662 security_sk_classify_flow(sk, &fl); 663 664 if (np->opt && np->opt->srcrt) { 665 struct rt0_hdr *rt0 = (struct rt0_hdr *) np->opt->srcrt; 666 ipv6_addr_copy(&final, &fl.fl6_dst); 667 ipv6_addr_copy(&fl.fl6_dst, rt0->addr); 668 final_p = &final; 669 } 670 671 err = ip6_dst_lookup(sk, &dst, &fl); 672 if (err) { 673 sk->sk_route_caps = 0; 674 return err; 675 } 676 if (final_p) 677 ipv6_addr_copy(&fl.fl6_dst, final_p); 678 679 if ((err = xfrm_lookup(sock_net(sk), &dst, &fl, sk, 0)) < 0) { 680 sk->sk_err_soft = -err; 681 return err; 682 } 683 684 __ip6_dst_store(sk, dst, NULL, NULL); 685 } 686 687 return 0; 688 } 689 690 EXPORT_SYMBOL_GPL(inet6_sk_rebuild_header); 691 692 int ipv6_opt_accepted(struct sock *sk, struct sk_buff *skb) 693 { 694 struct ipv6_pinfo *np = inet6_sk(sk); 695 struct inet6_skb_parm *opt = IP6CB(skb); 696 697 if (np->rxopt.all) { 698 if ((opt->hop && (np->rxopt.bits.hopopts || 699 np->rxopt.bits.ohopopts)) || 700 ((IPV6_FLOWINFO_MASK & 701 *(__be32 *)skb_network_header(skb)) && 702 np->rxopt.bits.rxflow) || 703 (opt->srcrt && (np->rxopt.bits.srcrt || 704 np->rxopt.bits.osrcrt)) || 705 ((opt->dst1 || opt->dst0) && 706 (np->rxopt.bits.dstopts || np->rxopt.bits.odstopts))) 707 return 1; 708 } 709 return 0; 710 } 711 712 EXPORT_SYMBOL_GPL(ipv6_opt_accepted); 713 714 static int ipv6_gso_pull_exthdrs(struct sk_buff *skb, int proto) 715 { 716 const struct inet6_protocol *ops = NULL; 717 718 for (;;) { 719 struct ipv6_opt_hdr *opth; 720 int len; 721 722 if (proto != NEXTHDR_HOP) { 723 ops = rcu_dereference(inet6_protos[proto]); 724 725 if (unlikely(!ops)) 726 break; 727 728 if (!(ops->flags & INET6_PROTO_GSO_EXTHDR)) 729 break; 730 } 731 732 if (unlikely(!pskb_may_pull(skb, 8))) 733 break; 734 735 opth = (void *)skb->data; 736 len = ipv6_optlen(opth); 737 738 if (unlikely(!pskb_may_pull(skb, len))) 739 break; 740 741 proto = opth->nexthdr; 742 __skb_pull(skb, len); 743 } 744 745 return proto; 746 } 747 748 static int ipv6_gso_send_check(struct sk_buff *skb) 749 { 750 struct ipv6hdr *ipv6h; 751 const struct inet6_protocol *ops; 752 int err = -EINVAL; 753 754 if (unlikely(!pskb_may_pull(skb, sizeof(*ipv6h)))) 755 goto out; 756 757 ipv6h = ipv6_hdr(skb); 758 __skb_pull(skb, sizeof(*ipv6h)); 759 err = -EPROTONOSUPPORT; 760 761 rcu_read_lock(); 762 ops = rcu_dereference(inet6_protos[ 763 ipv6_gso_pull_exthdrs(skb, ipv6h->nexthdr)]); 764 765 if (likely(ops && ops->gso_send_check)) { 766 skb_reset_transport_header(skb); 767 err = ops->gso_send_check(skb); 768 } 769 rcu_read_unlock(); 770 771 out: 772 return err; 773 } 774 775 static struct sk_buff *ipv6_gso_segment(struct sk_buff *skb, int features) 776 { 777 struct sk_buff *segs = ERR_PTR(-EINVAL); 778 struct ipv6hdr *ipv6h; 779 const struct inet6_protocol *ops; 780 int proto; 781 struct frag_hdr *fptr; 782 unsigned int unfrag_ip6hlen; 783 u8 *prevhdr; 784 int offset = 0; 785 786 if (!(features & NETIF_F_V6_CSUM)) 787 features &= ~NETIF_F_SG; 788 789 if (unlikely(skb_shinfo(skb)->gso_type & 790 ~(SKB_GSO_UDP | 791 SKB_GSO_DODGY | 792 SKB_GSO_TCP_ECN | 793 SKB_GSO_TCPV6 | 794 0))) 795 goto out; 796 797 if (unlikely(!pskb_may_pull(skb, sizeof(*ipv6h)))) 798 goto out; 799 800 ipv6h = ipv6_hdr(skb); 801 __skb_pull(skb, sizeof(*ipv6h)); 802 segs = ERR_PTR(-EPROTONOSUPPORT); 803 804 proto = ipv6_gso_pull_exthdrs(skb, ipv6h->nexthdr); 805 rcu_read_lock(); 806 ops = rcu_dereference(inet6_protos[proto]); 807 if (likely(ops && ops->gso_segment)) { 808 skb_reset_transport_header(skb); 809 segs = ops->gso_segment(skb, features); 810 } 811 rcu_read_unlock(); 812 813 if (unlikely(IS_ERR(segs))) 814 goto out; 815 816 for (skb = segs; skb; skb = skb->next) { 817 ipv6h = ipv6_hdr(skb); 818 ipv6h->payload_len = htons(skb->len - skb->mac_len - 819 sizeof(*ipv6h)); 820 if (proto == IPPROTO_UDP) { 821 unfrag_ip6hlen = ip6_find_1stfragopt(skb, &prevhdr); 822 fptr = (struct frag_hdr *)(skb_network_header(skb) + 823 unfrag_ip6hlen); 824 fptr->frag_off = htons(offset); 825 if (skb->next != NULL) 826 fptr->frag_off |= htons(IP6_MF); 827 offset += (ntohs(ipv6h->payload_len) - 828 sizeof(struct frag_hdr)); 829 } 830 } 831 832 out: 833 return segs; 834 } 835 836 struct ipv6_gro_cb { 837 struct napi_gro_cb napi; 838 int proto; 839 }; 840 841 #define IPV6_GRO_CB(skb) ((struct ipv6_gro_cb *)(skb)->cb) 842 843 static struct sk_buff **ipv6_gro_receive(struct sk_buff **head, 844 struct sk_buff *skb) 845 { 846 const struct inet6_protocol *ops; 847 struct sk_buff **pp = NULL; 848 struct sk_buff *p; 849 struct ipv6hdr *iph; 850 unsigned int nlen; 851 unsigned int hlen; 852 unsigned int off; 853 int flush = 1; 854 int proto; 855 __wsum csum; 856 857 off = skb_gro_offset(skb); 858 hlen = off + sizeof(*iph); 859 iph = skb_gro_header_fast(skb, off); 860 if (skb_gro_header_hard(skb, hlen)) { 861 iph = skb_gro_header_slow(skb, hlen, off); 862 if (unlikely(!iph)) 863 goto out; 864 } 865 866 skb_gro_pull(skb, sizeof(*iph)); 867 skb_set_transport_header(skb, skb_gro_offset(skb)); 868 869 flush += ntohs(iph->payload_len) != skb_gro_len(skb); 870 871 rcu_read_lock(); 872 proto = iph->nexthdr; 873 ops = rcu_dereference(inet6_protos[proto]); 874 if (!ops || !ops->gro_receive) { 875 __pskb_pull(skb, skb_gro_offset(skb)); 876 proto = ipv6_gso_pull_exthdrs(skb, proto); 877 skb_gro_pull(skb, -skb_transport_offset(skb)); 878 skb_reset_transport_header(skb); 879 __skb_push(skb, skb_gro_offset(skb)); 880 881 if (!ops || !ops->gro_receive) 882 goto out_unlock; 883 884 iph = ipv6_hdr(skb); 885 } 886 887 IPV6_GRO_CB(skb)->proto = proto; 888 889 flush--; 890 nlen = skb_network_header_len(skb); 891 892 for (p = *head; p; p = p->next) { 893 struct ipv6hdr *iph2; 894 895 if (!NAPI_GRO_CB(p)->same_flow) 896 continue; 897 898 iph2 = ipv6_hdr(p); 899 900 /* All fields must match except length. */ 901 if (nlen != skb_network_header_len(p) || 902 memcmp(iph, iph2, offsetof(struct ipv6hdr, payload_len)) || 903 memcmp(&iph->nexthdr, &iph2->nexthdr, 904 nlen - offsetof(struct ipv6hdr, nexthdr))) { 905 NAPI_GRO_CB(p)->same_flow = 0; 906 continue; 907 } 908 909 NAPI_GRO_CB(p)->flush |= flush; 910 } 911 912 NAPI_GRO_CB(skb)->flush |= flush; 913 914 csum = skb->csum; 915 skb_postpull_rcsum(skb, iph, skb_network_header_len(skb)); 916 917 pp = ops->gro_receive(head, skb); 918 919 skb->csum = csum; 920 921 out_unlock: 922 rcu_read_unlock(); 923 924 out: 925 NAPI_GRO_CB(skb)->flush |= flush; 926 927 return pp; 928 } 929 930 static int ipv6_gro_complete(struct sk_buff *skb) 931 { 932 const struct inet6_protocol *ops; 933 struct ipv6hdr *iph = ipv6_hdr(skb); 934 int err = -ENOSYS; 935 936 iph->payload_len = htons(skb->len - skb_network_offset(skb) - 937 sizeof(*iph)); 938 939 rcu_read_lock(); 940 ops = rcu_dereference(inet6_protos[IPV6_GRO_CB(skb)->proto]); 941 if (WARN_ON(!ops || !ops->gro_complete)) 942 goto out_unlock; 943 944 err = ops->gro_complete(skb); 945 946 out_unlock: 947 rcu_read_unlock(); 948 949 return err; 950 } 951 952 static struct packet_type ipv6_packet_type __read_mostly = { 953 .type = cpu_to_be16(ETH_P_IPV6), 954 .func = ipv6_rcv, 955 .gso_send_check = ipv6_gso_send_check, 956 .gso_segment = ipv6_gso_segment, 957 .gro_receive = ipv6_gro_receive, 958 .gro_complete = ipv6_gro_complete, 959 }; 960 961 static int __init ipv6_packet_init(void) 962 { 963 dev_add_pack(&ipv6_packet_type); 964 return 0; 965 } 966 967 static void ipv6_packet_cleanup(void) 968 { 969 dev_remove_pack(&ipv6_packet_type); 970 } 971 972 static int __net_init ipv6_init_mibs(struct net *net) 973 { 974 if (snmp_mib_init((void **)net->mib.udp_stats_in6, 975 sizeof (struct udp_mib)) < 0) 976 return -ENOMEM; 977 if (snmp_mib_init((void **)net->mib.udplite_stats_in6, 978 sizeof (struct udp_mib)) < 0) 979 goto err_udplite_mib; 980 if (snmp_mib_init((void **)net->mib.ipv6_statistics, 981 sizeof(struct ipstats_mib)) < 0) 982 goto err_ip_mib; 983 if (snmp_mib_init((void **)net->mib.icmpv6_statistics, 984 sizeof(struct icmpv6_mib)) < 0) 985 goto err_icmp_mib; 986 if (snmp_mib_init((void **)net->mib.icmpv6msg_statistics, 987 sizeof(struct icmpv6msg_mib)) < 0) 988 goto err_icmpmsg_mib; 989 return 0; 990 991 err_icmpmsg_mib: 992 snmp_mib_free((void **)net->mib.icmpv6_statistics); 993 err_icmp_mib: 994 snmp_mib_free((void **)net->mib.ipv6_statistics); 995 err_ip_mib: 996 snmp_mib_free((void **)net->mib.udplite_stats_in6); 997 err_udplite_mib: 998 snmp_mib_free((void **)net->mib.udp_stats_in6); 999 return -ENOMEM; 1000 } 1001 1002 static void __net_exit ipv6_cleanup_mibs(struct net *net) 1003 { 1004 snmp_mib_free((void **)net->mib.udp_stats_in6); 1005 snmp_mib_free((void **)net->mib.udplite_stats_in6); 1006 snmp_mib_free((void **)net->mib.ipv6_statistics); 1007 snmp_mib_free((void **)net->mib.icmpv6_statistics); 1008 snmp_mib_free((void **)net->mib.icmpv6msg_statistics); 1009 } 1010 1011 static int __net_init inet6_net_init(struct net *net) 1012 { 1013 int err = 0; 1014 1015 net->ipv6.sysctl.bindv6only = 0; 1016 net->ipv6.sysctl.icmpv6_time = 1*HZ; 1017 1018 err = ipv6_init_mibs(net); 1019 if (err) 1020 return err; 1021 #ifdef CONFIG_PROC_FS 1022 err = udp6_proc_init(net); 1023 if (err) 1024 goto out; 1025 err = tcp6_proc_init(net); 1026 if (err) 1027 goto proc_tcp6_fail; 1028 err = ac6_proc_init(net); 1029 if (err) 1030 goto proc_ac6_fail; 1031 #endif 1032 return err; 1033 1034 #ifdef CONFIG_PROC_FS 1035 proc_ac6_fail: 1036 tcp6_proc_exit(net); 1037 proc_tcp6_fail: 1038 udp6_proc_exit(net); 1039 out: 1040 ipv6_cleanup_mibs(net); 1041 return err; 1042 #endif 1043 } 1044 1045 static void inet6_net_exit(struct net *net) 1046 { 1047 #ifdef CONFIG_PROC_FS 1048 udp6_proc_exit(net); 1049 tcp6_proc_exit(net); 1050 ac6_proc_exit(net); 1051 #endif 1052 ipv6_cleanup_mibs(net); 1053 } 1054 1055 static struct pernet_operations inet6_net_ops = { 1056 .init = inet6_net_init, 1057 .exit = inet6_net_exit, 1058 }; 1059 1060 static int __init inet6_init(void) 1061 { 1062 struct sk_buff *dummy_skb; 1063 struct list_head *r; 1064 int err = 0; 1065 1066 BUILD_BUG_ON(sizeof(struct inet6_skb_parm) > sizeof(dummy_skb->cb)); 1067 1068 /* Register the socket-side information for inet6_create. */ 1069 for(r = &inetsw6[0]; r < &inetsw6[SOCK_MAX]; ++r) 1070 INIT_LIST_HEAD(r); 1071 1072 if (disable_ipv6_mod) { 1073 printk(KERN_INFO 1074 "IPv6: Loaded, but administratively disabled, " 1075 "reboot required to enable\n"); 1076 goto out; 1077 } 1078 1079 err = proto_register(&tcpv6_prot, 1); 1080 if (err) 1081 goto out; 1082 1083 err = proto_register(&udpv6_prot, 1); 1084 if (err) 1085 goto out_unregister_tcp_proto; 1086 1087 err = proto_register(&udplitev6_prot, 1); 1088 if (err) 1089 goto out_unregister_udp_proto; 1090 1091 err = proto_register(&rawv6_prot, 1); 1092 if (err) 1093 goto out_unregister_udplite_proto; 1094 1095 1096 /* We MUST register RAW sockets before we create the ICMP6, 1097 * IGMP6, or NDISC control sockets. 1098 */ 1099 err = rawv6_init(); 1100 if (err) 1101 goto out_unregister_raw_proto; 1102 1103 /* Register the family here so that the init calls below will 1104 * be able to create sockets. (?? is this dangerous ??) 1105 */ 1106 err = sock_register(&inet6_family_ops); 1107 if (err) 1108 goto out_sock_register_fail; 1109 1110 #ifdef CONFIG_SYSCTL 1111 err = ipv6_static_sysctl_register(); 1112 if (err) 1113 goto static_sysctl_fail; 1114 #endif 1115 /* 1116 * ipngwg API draft makes clear that the correct semantics 1117 * for TCP and UDP is to consider one TCP and UDP instance 1118 * in a host availiable by both INET and INET6 APIs and 1119 * able to communicate via both network protocols. 1120 */ 1121 1122 err = register_pernet_subsys(&inet6_net_ops); 1123 if (err) 1124 goto register_pernet_fail; 1125 err = icmpv6_init(); 1126 if (err) 1127 goto icmp_fail; 1128 err = ip6_mr_init(); 1129 if (err) 1130 goto ipmr_fail; 1131 err = ndisc_init(); 1132 if (err) 1133 goto ndisc_fail; 1134 err = igmp6_init(); 1135 if (err) 1136 goto igmp_fail; 1137 err = ipv6_netfilter_init(); 1138 if (err) 1139 goto netfilter_fail; 1140 /* Create /proc/foo6 entries. */ 1141 #ifdef CONFIG_PROC_FS 1142 err = -ENOMEM; 1143 if (raw6_proc_init()) 1144 goto proc_raw6_fail; 1145 if (udplite6_proc_init()) 1146 goto proc_udplite6_fail; 1147 if (ipv6_misc_proc_init()) 1148 goto proc_misc6_fail; 1149 if (if6_proc_init()) 1150 goto proc_if6_fail; 1151 #endif 1152 err = ip6_route_init(); 1153 if (err) 1154 goto ip6_route_fail; 1155 err = ip6_flowlabel_init(); 1156 if (err) 1157 goto ip6_flowlabel_fail; 1158 err = addrconf_init(); 1159 if (err) 1160 goto addrconf_fail; 1161 1162 /* Init v6 extension headers. */ 1163 err = ipv6_exthdrs_init(); 1164 if (err) 1165 goto ipv6_exthdrs_fail; 1166 1167 err = ipv6_frag_init(); 1168 if (err) 1169 goto ipv6_frag_fail; 1170 1171 /* Init v6 transport protocols. */ 1172 err = udpv6_init(); 1173 if (err) 1174 goto udpv6_fail; 1175 1176 err = udplitev6_init(); 1177 if (err) 1178 goto udplitev6_fail; 1179 1180 err = tcpv6_init(); 1181 if (err) 1182 goto tcpv6_fail; 1183 1184 err = ipv6_packet_init(); 1185 if (err) 1186 goto ipv6_packet_fail; 1187 1188 #ifdef CONFIG_SYSCTL 1189 err = ipv6_sysctl_register(); 1190 if (err) 1191 goto sysctl_fail; 1192 #endif 1193 out: 1194 return err; 1195 1196 #ifdef CONFIG_SYSCTL 1197 sysctl_fail: 1198 ipv6_packet_cleanup(); 1199 #endif 1200 ipv6_packet_fail: 1201 tcpv6_exit(); 1202 tcpv6_fail: 1203 udplitev6_exit(); 1204 udplitev6_fail: 1205 udpv6_exit(); 1206 udpv6_fail: 1207 ipv6_frag_exit(); 1208 ipv6_frag_fail: 1209 ipv6_exthdrs_exit(); 1210 ipv6_exthdrs_fail: 1211 addrconf_cleanup(); 1212 addrconf_fail: 1213 ip6_flowlabel_cleanup(); 1214 ip6_flowlabel_fail: 1215 ip6_route_cleanup(); 1216 ip6_route_fail: 1217 #ifdef CONFIG_PROC_FS 1218 if6_proc_exit(); 1219 proc_if6_fail: 1220 ipv6_misc_proc_exit(); 1221 proc_misc6_fail: 1222 udplite6_proc_exit(); 1223 proc_udplite6_fail: 1224 raw6_proc_exit(); 1225 proc_raw6_fail: 1226 #endif 1227 ipv6_netfilter_fini(); 1228 netfilter_fail: 1229 igmp6_cleanup(); 1230 igmp_fail: 1231 ndisc_cleanup(); 1232 ndisc_fail: 1233 ip6_mr_cleanup(); 1234 ipmr_fail: 1235 icmpv6_cleanup(); 1236 icmp_fail: 1237 unregister_pernet_subsys(&inet6_net_ops); 1238 register_pernet_fail: 1239 #ifdef CONFIG_SYSCTL 1240 ipv6_static_sysctl_unregister(); 1241 static_sysctl_fail: 1242 #endif 1243 sock_unregister(PF_INET6); 1244 rtnl_unregister_all(PF_INET6); 1245 out_sock_register_fail: 1246 rawv6_exit(); 1247 out_unregister_raw_proto: 1248 proto_unregister(&rawv6_prot); 1249 out_unregister_udplite_proto: 1250 proto_unregister(&udplitev6_prot); 1251 out_unregister_udp_proto: 1252 proto_unregister(&udpv6_prot); 1253 out_unregister_tcp_proto: 1254 proto_unregister(&tcpv6_prot); 1255 goto out; 1256 } 1257 module_init(inet6_init); 1258 1259 static void __exit inet6_exit(void) 1260 { 1261 if (disable_ipv6_mod) 1262 return; 1263 1264 /* First of all disallow new sockets creation. */ 1265 sock_unregister(PF_INET6); 1266 /* Disallow any further netlink messages */ 1267 rtnl_unregister_all(PF_INET6); 1268 1269 #ifdef CONFIG_SYSCTL 1270 ipv6_sysctl_unregister(); 1271 #endif 1272 udpv6_exit(); 1273 udplitev6_exit(); 1274 tcpv6_exit(); 1275 1276 /* Cleanup code parts. */ 1277 ipv6_packet_cleanup(); 1278 ipv6_frag_exit(); 1279 ipv6_exthdrs_exit(); 1280 addrconf_cleanup(); 1281 ip6_flowlabel_cleanup(); 1282 ip6_route_cleanup(); 1283 #ifdef CONFIG_PROC_FS 1284 1285 /* Cleanup code parts. */ 1286 if6_proc_exit(); 1287 ipv6_misc_proc_exit(); 1288 udplite6_proc_exit(); 1289 raw6_proc_exit(); 1290 #endif 1291 ipv6_netfilter_fini(); 1292 igmp6_cleanup(); 1293 ndisc_cleanup(); 1294 ip6_mr_cleanup(); 1295 icmpv6_cleanup(); 1296 rawv6_exit(); 1297 1298 unregister_pernet_subsys(&inet6_net_ops); 1299 #ifdef CONFIG_SYSCTL 1300 ipv6_static_sysctl_unregister(); 1301 #endif 1302 proto_unregister(&rawv6_prot); 1303 proto_unregister(&udplitev6_prot); 1304 proto_unregister(&udpv6_prot); 1305 proto_unregister(&tcpv6_prot); 1306 1307 rcu_barrier(); /* Wait for completion of call_rcu()'s */ 1308 } 1309 module_exit(inet6_exit); 1310 1311 MODULE_ALIAS_NETPROTO(PF_INET6); 1312