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 * $Id: af_inet6.c,v 1.66 2002/02/01 22:01:04 davem Exp $ 11 * 12 * Fixes: 13 * piggy, Karl Knutson : Socket protocol table 14 * Hideaki YOSHIFUJI : sin6_scope_id support 15 * Arnaldo Melo : check proc_net_create return, cleanups 16 * 17 * This program is free software; you can redistribute it and/or 18 * modify it under the terms of the GNU General Public License 19 * as published by the Free Software Foundation; either version 20 * 2 of the License, or (at your option) any later version. 21 */ 22 23 24 #include <linux/module.h> 25 #include <linux/config.h> 26 #include <linux/errno.h> 27 #include <linux/types.h> 28 #include <linux/socket.h> 29 #include <linux/in.h> 30 #include <linux/kernel.h> 31 #include <linux/sched.h> 32 #include <linux/timer.h> 33 #include <linux/string.h> 34 #include <linux/sockios.h> 35 #include <linux/net.h> 36 #include <linux/fcntl.h> 37 #include <linux/mm.h> 38 #include <linux/interrupt.h> 39 #include <linux/proc_fs.h> 40 #include <linux/stat.h> 41 #include <linux/init.h> 42 43 #include <linux/inet.h> 44 #include <linux/netdevice.h> 45 #include <linux/icmpv6.h> 46 #include <linux/smp_lock.h> 47 #include <linux/netfilter_ipv6.h> 48 49 #include <net/ip.h> 50 #include <net/ipv6.h> 51 #include <net/udp.h> 52 #include <net/tcp.h> 53 #include <net/ipip.h> 54 #include <net/protocol.h> 55 #include <net/inet_common.h> 56 #include <net/transp_v6.h> 57 #include <net/ip6_route.h> 58 #include <net/addrconf.h> 59 #ifdef CONFIG_IPV6_TUNNEL 60 #include <net/ip6_tunnel.h> 61 #endif 62 63 #include <asm/uaccess.h> 64 #include <asm/system.h> 65 66 MODULE_AUTHOR("Cast of dozens"); 67 MODULE_DESCRIPTION("IPv6 protocol stack for Linux"); 68 MODULE_LICENSE("GPL"); 69 70 int sysctl_ipv6_bindv6only; 71 72 /* The inetsw table contains everything that inet_create needs to 73 * build a new socket. 74 */ 75 static struct list_head inetsw6[SOCK_MAX]; 76 static DEFINE_SPINLOCK(inetsw6_lock); 77 78 static __inline__ struct ipv6_pinfo *inet6_sk_generic(struct sock *sk) 79 { 80 const int offset = sk->sk_prot->obj_size - sizeof(struct ipv6_pinfo); 81 82 return (struct ipv6_pinfo *)(((u8 *)sk) + offset); 83 } 84 85 static int inet6_create(struct socket *sock, int protocol) 86 { 87 struct inet_sock *inet; 88 struct ipv6_pinfo *np; 89 struct sock *sk; 90 struct list_head *p; 91 struct inet_protosw *answer; 92 struct proto *answer_prot; 93 unsigned char answer_flags; 94 char answer_no_check; 95 int try_loading_module = 0; 96 int err; 97 98 /* Look for the requested type/protocol pair. */ 99 answer = NULL; 100 lookup_protocol: 101 err = -ESOCKTNOSUPPORT; 102 rcu_read_lock(); 103 list_for_each_rcu(p, &inetsw6[sock->type]) { 104 answer = list_entry(p, struct inet_protosw, list); 105 106 /* Check the non-wild match. */ 107 if (protocol == answer->protocol) { 108 if (protocol != IPPROTO_IP) 109 break; 110 } else { 111 /* Check for the two wild cases. */ 112 if (IPPROTO_IP == protocol) { 113 protocol = answer->protocol; 114 break; 115 } 116 if (IPPROTO_IP == answer->protocol) 117 break; 118 } 119 err = -EPROTONOSUPPORT; 120 answer = NULL; 121 } 122 123 if (!answer) { 124 if (try_loading_module < 2) { 125 rcu_read_unlock(); 126 /* 127 * Be more specific, e.g. net-pf-10-proto-132-type-1 128 * (net-pf-PF_INET6-proto-IPPROTO_SCTP-type-SOCK_STREAM) 129 */ 130 if (++try_loading_module == 1) 131 request_module("net-pf-%d-proto-%d-type-%d", 132 PF_INET6, protocol, sock->type); 133 /* 134 * Fall back to generic, e.g. net-pf-10-proto-132 135 * (net-pf-PF_INET6-proto-IPPROTO_SCTP) 136 */ 137 else 138 request_module("net-pf-%d-proto-%d", 139 PF_INET6, protocol); 140 goto lookup_protocol; 141 } else 142 goto out_rcu_unlock; 143 } 144 145 err = -EPERM; 146 if (answer->capability > 0 && !capable(answer->capability)) 147 goto out_rcu_unlock; 148 149 sock->ops = answer->ops; 150 answer_prot = answer->prot; 151 answer_no_check = answer->no_check; 152 answer_flags = answer->flags; 153 rcu_read_unlock(); 154 155 BUG_TRAP(answer_prot->slab != NULL); 156 157 err = -ENOBUFS; 158 sk = sk_alloc(PF_INET6, GFP_KERNEL, answer_prot, 1); 159 if (sk == NULL) 160 goto out; 161 162 sock_init_data(sock, sk); 163 164 err = 0; 165 sk->sk_no_check = answer_no_check; 166 if (INET_PROTOSW_REUSE & answer_flags) 167 sk->sk_reuse = 1; 168 169 inet = inet_sk(sk); 170 171 if (SOCK_RAW == sock->type) { 172 inet->num = protocol; 173 if (IPPROTO_RAW == protocol) 174 inet->hdrincl = 1; 175 } 176 177 sk->sk_destruct = inet_sock_destruct; 178 sk->sk_family = PF_INET6; 179 sk->sk_protocol = protocol; 180 181 sk->sk_backlog_rcv = answer->prot->backlog_rcv; 182 183 inet_sk(sk)->pinet6 = np = inet6_sk_generic(sk); 184 np->hop_limit = -1; 185 np->mcast_hops = -1; 186 np->mc_loop = 1; 187 np->pmtudisc = IPV6_PMTUDISC_WANT; 188 np->ipv6only = sysctl_ipv6_bindv6only; 189 190 /* Init the ipv4 part of the socket since we can have sockets 191 * using v6 API for ipv4. 192 */ 193 inet->uc_ttl = -1; 194 195 inet->mc_loop = 1; 196 inet->mc_ttl = 1; 197 inet->mc_index = 0; 198 inet->mc_list = NULL; 199 200 if (ipv4_config.no_pmtu_disc) 201 inet->pmtudisc = IP_PMTUDISC_DONT; 202 else 203 inet->pmtudisc = IP_PMTUDISC_WANT; 204 /* 205 * Increment only the relevant sk_prot->socks debug field, this changes 206 * the previous behaviour of incrementing both the equivalent to 207 * answer->prot->socks (inet6_sock_nr) and inet_sock_nr. 208 * 209 * This allows better debug granularity as we'll know exactly how many 210 * UDPv6, TCPv6, etc socks were allocated, not the sum of all IPv6 211 * transport protocol socks. -acme 212 */ 213 sk_refcnt_debug_inc(sk); 214 215 if (inet->num) { 216 /* It assumes that any protocol which allows 217 * the user to assign a number at socket 218 * creation time automatically shares. 219 */ 220 inet->sport = ntohs(inet->num); 221 sk->sk_prot->hash(sk); 222 } 223 if (sk->sk_prot->init) { 224 err = sk->sk_prot->init(sk); 225 if (err) { 226 sk_common_release(sk); 227 goto out; 228 } 229 } 230 out: 231 return err; 232 out_rcu_unlock: 233 rcu_read_unlock(); 234 goto out; 235 } 236 237 238 /* bind for INET6 API */ 239 int inet6_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) 240 { 241 struct sockaddr_in6 *addr=(struct sockaddr_in6 *)uaddr; 242 struct sock *sk = sock->sk; 243 struct inet_sock *inet = inet_sk(sk); 244 struct ipv6_pinfo *np = inet6_sk(sk); 245 __u32 v4addr = 0; 246 unsigned short snum; 247 int addr_type = 0; 248 int err = 0; 249 250 /* If the socket has its own bind function then use it. */ 251 if (sk->sk_prot->bind) 252 return sk->sk_prot->bind(sk, uaddr, addr_len); 253 254 if (addr_len < SIN6_LEN_RFC2133) 255 return -EINVAL; 256 addr_type = ipv6_addr_type(&addr->sin6_addr); 257 if ((addr_type & IPV6_ADDR_MULTICAST) && sock->type == SOCK_STREAM) 258 return -EINVAL; 259 260 snum = ntohs(addr->sin6_port); 261 if (snum && snum < PROT_SOCK && !capable(CAP_NET_BIND_SERVICE)) 262 return -EACCES; 263 264 lock_sock(sk); 265 266 /* Check these errors (active socket, double bind). */ 267 if (sk->sk_state != TCP_CLOSE || inet->num) { 268 err = -EINVAL; 269 goto out; 270 } 271 272 /* Check if the address belongs to the host. */ 273 if (addr_type == IPV6_ADDR_MAPPED) { 274 v4addr = addr->sin6_addr.s6_addr32[3]; 275 if (inet_addr_type(v4addr) != RTN_LOCAL) { 276 err = -EADDRNOTAVAIL; 277 goto out; 278 } 279 } else { 280 if (addr_type != IPV6_ADDR_ANY) { 281 struct net_device *dev = NULL; 282 283 if (addr_type & IPV6_ADDR_LINKLOCAL) { 284 if (addr_len >= sizeof(struct sockaddr_in6) && 285 addr->sin6_scope_id) { 286 /* Override any existing binding, if another one 287 * is supplied by user. 288 */ 289 sk->sk_bound_dev_if = addr->sin6_scope_id; 290 } 291 292 /* Binding to link-local address requires an interface */ 293 if (!sk->sk_bound_dev_if) { 294 err = -EINVAL; 295 goto out; 296 } 297 dev = dev_get_by_index(sk->sk_bound_dev_if); 298 if (!dev) { 299 err = -ENODEV; 300 goto out; 301 } 302 } 303 304 /* ipv4 addr of the socket is invalid. Only the 305 * unspecified and mapped address have a v4 equivalent. 306 */ 307 v4addr = LOOPBACK4_IPV6; 308 if (!(addr_type & IPV6_ADDR_MULTICAST)) { 309 if (!ipv6_chk_addr(&addr->sin6_addr, dev, 0)) { 310 if (dev) 311 dev_put(dev); 312 err = -EADDRNOTAVAIL; 313 goto out; 314 } 315 } 316 if (dev) 317 dev_put(dev); 318 } 319 } 320 321 inet->rcv_saddr = v4addr; 322 inet->saddr = v4addr; 323 324 ipv6_addr_copy(&np->rcv_saddr, &addr->sin6_addr); 325 326 if (!(addr_type & IPV6_ADDR_MULTICAST)) 327 ipv6_addr_copy(&np->saddr, &addr->sin6_addr); 328 329 /* Make sure we are allowed to bind here. */ 330 if (sk->sk_prot->get_port(sk, snum)) { 331 inet_reset_saddr(sk); 332 err = -EADDRINUSE; 333 goto out; 334 } 335 336 if (addr_type != IPV6_ADDR_ANY) 337 sk->sk_userlocks |= SOCK_BINDADDR_LOCK; 338 if (snum) 339 sk->sk_userlocks |= SOCK_BINDPORT_LOCK; 340 inet->sport = ntohs(inet->num); 341 inet->dport = 0; 342 inet->daddr = 0; 343 out: 344 release_sock(sk); 345 return err; 346 } 347 348 int inet6_release(struct socket *sock) 349 { 350 struct sock *sk = sock->sk; 351 352 if (sk == NULL) 353 return -EINVAL; 354 355 /* Free mc lists */ 356 ipv6_sock_mc_close(sk); 357 358 /* Free ac lists */ 359 ipv6_sock_ac_close(sk); 360 361 return inet_release(sock); 362 } 363 364 int inet6_destroy_sock(struct sock *sk) 365 { 366 struct ipv6_pinfo *np = inet6_sk(sk); 367 struct sk_buff *skb; 368 struct ipv6_txoptions *opt; 369 370 /* 371 * Release destination entry 372 */ 373 374 sk_dst_reset(sk); 375 376 /* Release rx options */ 377 378 if ((skb = xchg(&np->pktoptions, NULL)) != NULL) 379 kfree_skb(skb); 380 381 /* Free flowlabels */ 382 fl6_free_socklist(sk); 383 384 /* Free tx options */ 385 386 if ((opt = xchg(&np->opt, NULL)) != NULL) 387 sock_kfree_s(sk, opt, opt->tot_len); 388 389 return 0; 390 } 391 392 /* 393 * This does both peername and sockname. 394 */ 395 396 int inet6_getname(struct socket *sock, struct sockaddr *uaddr, 397 int *uaddr_len, int peer) 398 { 399 struct sockaddr_in6 *sin=(struct sockaddr_in6 *)uaddr; 400 struct sock *sk = sock->sk; 401 struct inet_sock *inet = inet_sk(sk); 402 struct ipv6_pinfo *np = inet6_sk(sk); 403 404 sin->sin6_family = AF_INET6; 405 sin->sin6_flowinfo = 0; 406 sin->sin6_scope_id = 0; 407 if (peer) { 408 if (!inet->dport) 409 return -ENOTCONN; 410 if (((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_SYN_SENT)) && 411 peer == 1) 412 return -ENOTCONN; 413 sin->sin6_port = inet->dport; 414 ipv6_addr_copy(&sin->sin6_addr, &np->daddr); 415 if (np->sndflow) 416 sin->sin6_flowinfo = np->flow_label; 417 } else { 418 if (ipv6_addr_any(&np->rcv_saddr)) 419 ipv6_addr_copy(&sin->sin6_addr, &np->saddr); 420 else 421 ipv6_addr_copy(&sin->sin6_addr, &np->rcv_saddr); 422 423 sin->sin6_port = inet->sport; 424 } 425 if (ipv6_addr_type(&sin->sin6_addr) & IPV6_ADDR_LINKLOCAL) 426 sin->sin6_scope_id = sk->sk_bound_dev_if; 427 *uaddr_len = sizeof(*sin); 428 return(0); 429 } 430 431 int inet6_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 432 { 433 struct sock *sk = sock->sk; 434 int err = -EINVAL; 435 436 switch(cmd) 437 { 438 case SIOCGSTAMP: 439 return sock_get_timestamp(sk, (struct timeval __user *)arg); 440 441 case SIOCADDRT: 442 case SIOCDELRT: 443 444 return(ipv6_route_ioctl(cmd,(void __user *)arg)); 445 446 case SIOCSIFADDR: 447 return addrconf_add_ifaddr((void __user *) arg); 448 case SIOCDIFADDR: 449 return addrconf_del_ifaddr((void __user *) arg); 450 case SIOCSIFDSTADDR: 451 return addrconf_set_dstaddr((void __user *) arg); 452 default: 453 if (!sk->sk_prot->ioctl || 454 (err = sk->sk_prot->ioctl(sk, cmd, arg)) == -ENOIOCTLCMD) 455 return(dev_ioctl(cmd,(void __user *) arg)); 456 return err; 457 } 458 /*NOTREACHED*/ 459 return(0); 460 } 461 462 struct proto_ops inet6_stream_ops = { 463 .family = PF_INET6, 464 .owner = THIS_MODULE, 465 .release = inet6_release, 466 .bind = inet6_bind, 467 .connect = inet_stream_connect, /* ok */ 468 .socketpair = sock_no_socketpair, /* a do nothing */ 469 .accept = inet_accept, /* ok */ 470 .getname = inet6_getname, 471 .poll = tcp_poll, /* ok */ 472 .ioctl = inet6_ioctl, /* must change */ 473 .listen = inet_listen, /* ok */ 474 .shutdown = inet_shutdown, /* ok */ 475 .setsockopt = sock_common_setsockopt, /* ok */ 476 .getsockopt = sock_common_getsockopt, /* ok */ 477 .sendmsg = inet_sendmsg, /* ok */ 478 .recvmsg = sock_common_recvmsg, /* ok */ 479 .mmap = sock_no_mmap, 480 .sendpage = tcp_sendpage 481 }; 482 483 struct proto_ops inet6_dgram_ops = { 484 .family = PF_INET6, 485 .owner = THIS_MODULE, 486 .release = inet6_release, 487 .bind = inet6_bind, 488 .connect = inet_dgram_connect, /* ok */ 489 .socketpair = sock_no_socketpair, /* a do nothing */ 490 .accept = sock_no_accept, /* a do nothing */ 491 .getname = inet6_getname, 492 .poll = udp_poll, /* ok */ 493 .ioctl = inet6_ioctl, /* must change */ 494 .listen = sock_no_listen, /* ok */ 495 .shutdown = inet_shutdown, /* ok */ 496 .setsockopt = sock_common_setsockopt, /* ok */ 497 .getsockopt = sock_common_getsockopt, /* ok */ 498 .sendmsg = inet_sendmsg, /* ok */ 499 .recvmsg = sock_common_recvmsg, /* ok */ 500 .mmap = sock_no_mmap, 501 .sendpage = sock_no_sendpage, 502 }; 503 504 static struct net_proto_family inet6_family_ops = { 505 .family = PF_INET6, 506 .create = inet6_create, 507 .owner = THIS_MODULE, 508 }; 509 510 /* Same as inet6_dgram_ops, sans udp_poll. */ 511 static struct proto_ops inet6_sockraw_ops = { 512 .family = PF_INET6, 513 .owner = THIS_MODULE, 514 .release = inet6_release, 515 .bind = inet6_bind, 516 .connect = inet_dgram_connect, /* ok */ 517 .socketpair = sock_no_socketpair, /* a do nothing */ 518 .accept = sock_no_accept, /* a do nothing */ 519 .getname = inet6_getname, 520 .poll = datagram_poll, /* ok */ 521 .ioctl = inet6_ioctl, /* must change */ 522 .listen = sock_no_listen, /* ok */ 523 .shutdown = inet_shutdown, /* ok */ 524 .setsockopt = sock_common_setsockopt, /* ok */ 525 .getsockopt = sock_common_getsockopt, /* ok */ 526 .sendmsg = inet_sendmsg, /* ok */ 527 .recvmsg = sock_common_recvmsg, /* ok */ 528 .mmap = sock_no_mmap, 529 .sendpage = sock_no_sendpage, 530 }; 531 532 static struct inet_protosw rawv6_protosw = { 533 .type = SOCK_RAW, 534 .protocol = IPPROTO_IP, /* wild card */ 535 .prot = &rawv6_prot, 536 .ops = &inet6_sockraw_ops, 537 .capability = CAP_NET_RAW, 538 .no_check = UDP_CSUM_DEFAULT, 539 .flags = INET_PROTOSW_REUSE, 540 }; 541 542 void 543 inet6_register_protosw(struct inet_protosw *p) 544 { 545 struct list_head *lh; 546 struct inet_protosw *answer; 547 int protocol = p->protocol; 548 struct list_head *last_perm; 549 550 spin_lock_bh(&inetsw6_lock); 551 552 if (p->type >= SOCK_MAX) 553 goto out_illegal; 554 555 /* If we are trying to override a permanent protocol, bail. */ 556 answer = NULL; 557 last_perm = &inetsw6[p->type]; 558 list_for_each(lh, &inetsw6[p->type]) { 559 answer = list_entry(lh, struct inet_protosw, list); 560 561 /* Check only the non-wild match. */ 562 if (INET_PROTOSW_PERMANENT & answer->flags) { 563 if (protocol == answer->protocol) 564 break; 565 last_perm = lh; 566 } 567 568 answer = NULL; 569 } 570 if (answer) 571 goto out_permanent; 572 573 /* Add the new entry after the last permanent entry if any, so that 574 * the new entry does not override a permanent entry when matched with 575 * a wild-card protocol. But it is allowed to override any existing 576 * non-permanent entry. This means that when we remove this entry, the 577 * system automatically returns to the old behavior. 578 */ 579 list_add_rcu(&p->list, last_perm); 580 out: 581 spin_unlock_bh(&inetsw6_lock); 582 return; 583 584 out_permanent: 585 printk(KERN_ERR "Attempt to override permanent protocol %d.\n", 586 protocol); 587 goto out; 588 589 out_illegal: 590 printk(KERN_ERR 591 "Ignoring attempt to register invalid socket type %d.\n", 592 p->type); 593 goto out; 594 } 595 596 void 597 inet6_unregister_protosw(struct inet_protosw *p) 598 { 599 if (INET_PROTOSW_PERMANENT & p->flags) { 600 printk(KERN_ERR 601 "Attempt to unregister permanent protocol %d.\n", 602 p->protocol); 603 } else { 604 spin_lock_bh(&inetsw6_lock); 605 list_del_rcu(&p->list); 606 spin_unlock_bh(&inetsw6_lock); 607 608 synchronize_net(); 609 } 610 } 611 612 int 613 snmp6_mib_init(void *ptr[2], size_t mibsize, size_t mibalign) 614 { 615 if (ptr == NULL) 616 return -EINVAL; 617 618 ptr[0] = __alloc_percpu(mibsize, mibalign); 619 if (!ptr[0]) 620 goto err0; 621 622 ptr[1] = __alloc_percpu(mibsize, mibalign); 623 if (!ptr[1]) 624 goto err1; 625 626 return 0; 627 628 err1: 629 free_percpu(ptr[0]); 630 ptr[0] = NULL; 631 err0: 632 return -ENOMEM; 633 } 634 635 void 636 snmp6_mib_free(void *ptr[2]) 637 { 638 if (ptr == NULL) 639 return; 640 if (ptr[0]) 641 free_percpu(ptr[0]); 642 if (ptr[1]) 643 free_percpu(ptr[1]); 644 ptr[0] = ptr[1] = NULL; 645 } 646 647 static int __init init_ipv6_mibs(void) 648 { 649 if (snmp6_mib_init((void **)ipv6_statistics, sizeof (struct ipstats_mib), 650 __alignof__(struct ipstats_mib)) < 0) 651 goto err_ip_mib; 652 if (snmp6_mib_init((void **)icmpv6_statistics, sizeof (struct icmpv6_mib), 653 __alignof__(struct icmpv6_mib)) < 0) 654 goto err_icmp_mib; 655 if (snmp6_mib_init((void **)udp_stats_in6, sizeof (struct udp_mib), 656 __alignof__(struct udp_mib)) < 0) 657 goto err_udp_mib; 658 return 0; 659 660 err_udp_mib: 661 snmp6_mib_free((void **)icmpv6_statistics); 662 err_icmp_mib: 663 snmp6_mib_free((void **)ipv6_statistics); 664 err_ip_mib: 665 return -ENOMEM; 666 667 } 668 669 static void cleanup_ipv6_mibs(void) 670 { 671 snmp6_mib_free((void **)ipv6_statistics); 672 snmp6_mib_free((void **)icmpv6_statistics); 673 snmp6_mib_free((void **)udp_stats_in6); 674 } 675 676 static int __init inet6_init(void) 677 { 678 struct sk_buff *dummy_skb; 679 struct list_head *r; 680 int err; 681 682 #ifdef MODULE 683 #if 0 /* FIXME --RR */ 684 if (!mod_member_present(&__this_module, can_unload)) 685 return -EINVAL; 686 687 __this_module.can_unload = &ipv6_unload; 688 #endif 689 #endif 690 691 if (sizeof(struct inet6_skb_parm) > sizeof(dummy_skb->cb)) { 692 printk(KERN_CRIT "inet6_proto_init: size fault\n"); 693 return -EINVAL; 694 } 695 696 err = proto_register(&tcpv6_prot, 1); 697 if (err) 698 goto out; 699 700 err = proto_register(&udpv6_prot, 1); 701 if (err) 702 goto out_unregister_tcp_proto; 703 704 err = proto_register(&rawv6_prot, 1); 705 if (err) 706 goto out_unregister_udp_proto; 707 708 709 /* Register the socket-side information for inet6_create. */ 710 for(r = &inetsw6[0]; r < &inetsw6[SOCK_MAX]; ++r) 711 INIT_LIST_HEAD(r); 712 713 /* We MUST register RAW sockets before we create the ICMP6, 714 * IGMP6, or NDISC control sockets. 715 */ 716 inet6_register_protosw(&rawv6_protosw); 717 718 /* Register the family here so that the init calls below will 719 * be able to create sockets. (?? is this dangerous ??) 720 */ 721 err = sock_register(&inet6_family_ops); 722 if (err) 723 goto out_unregister_raw_proto; 724 725 /* Initialise ipv6 mibs */ 726 err = init_ipv6_mibs(); 727 if (err) 728 goto out_unregister_sock; 729 730 /* 731 * ipngwg API draft makes clear that the correct semantics 732 * for TCP and UDP is to consider one TCP and UDP instance 733 * in a host availiable by both INET and INET6 APIs and 734 * able to communicate via both network protocols. 735 */ 736 737 #ifdef CONFIG_SYSCTL 738 ipv6_sysctl_register(); 739 #endif 740 err = icmpv6_init(&inet6_family_ops); 741 if (err) 742 goto icmp_fail; 743 err = ndisc_init(&inet6_family_ops); 744 if (err) 745 goto ndisc_fail; 746 err = igmp6_init(&inet6_family_ops); 747 if (err) 748 goto igmp_fail; 749 err = ipv6_netfilter_init(); 750 if (err) 751 goto netfilter_fail; 752 /* Create /proc/foo6 entries. */ 753 #ifdef CONFIG_PROC_FS 754 err = -ENOMEM; 755 if (raw6_proc_init()) 756 goto proc_raw6_fail; 757 if (tcp6_proc_init()) 758 goto proc_tcp6_fail; 759 if (udp6_proc_init()) 760 goto proc_udp6_fail; 761 if (ipv6_misc_proc_init()) 762 goto proc_misc6_fail; 763 764 if (ac6_proc_init()) 765 goto proc_anycast6_fail; 766 if (if6_proc_init()) 767 goto proc_if6_fail; 768 #endif 769 ip6_route_init(); 770 ip6_flowlabel_init(); 771 err = addrconf_init(); 772 if (err) 773 goto addrconf_fail; 774 sit_init(); 775 776 /* Init v6 extension headers. */ 777 ipv6_rthdr_init(); 778 ipv6_frag_init(); 779 ipv6_nodata_init(); 780 ipv6_destopt_init(); 781 782 /* Init v6 transport protocols. */ 783 udpv6_init(); 784 tcpv6_init(); 785 786 ipv6_packet_init(); 787 err = 0; 788 out: 789 return err; 790 791 addrconf_fail: 792 ip6_flowlabel_cleanup(); 793 ip6_route_cleanup(); 794 #ifdef CONFIG_PROC_FS 795 if6_proc_exit(); 796 proc_if6_fail: 797 ac6_proc_exit(); 798 proc_anycast6_fail: 799 ipv6_misc_proc_exit(); 800 proc_misc6_fail: 801 udp6_proc_exit(); 802 proc_udp6_fail: 803 tcp6_proc_exit(); 804 proc_tcp6_fail: 805 raw6_proc_exit(); 806 proc_raw6_fail: 807 #endif 808 ipv6_netfilter_fini(); 809 netfilter_fail: 810 igmp6_cleanup(); 811 igmp_fail: 812 ndisc_cleanup(); 813 ndisc_fail: 814 icmpv6_cleanup(); 815 icmp_fail: 816 #ifdef CONFIG_SYSCTL 817 ipv6_sysctl_unregister(); 818 #endif 819 cleanup_ipv6_mibs(); 820 out_unregister_sock: 821 sock_unregister(PF_INET6); 822 out_unregister_raw_proto: 823 proto_unregister(&rawv6_prot); 824 out_unregister_udp_proto: 825 proto_unregister(&udpv6_prot); 826 out_unregister_tcp_proto: 827 proto_unregister(&tcpv6_prot); 828 goto out; 829 } 830 module_init(inet6_init); 831 832 static void __exit inet6_exit(void) 833 { 834 /* First of all disallow new sockets creation. */ 835 sock_unregister(PF_INET6); 836 #ifdef CONFIG_PROC_FS 837 if6_proc_exit(); 838 ac6_proc_exit(); 839 ipv6_misc_proc_exit(); 840 udp6_proc_exit(); 841 tcp6_proc_exit(); 842 raw6_proc_exit(); 843 #endif 844 /* Cleanup code parts. */ 845 sit_cleanup(); 846 ip6_flowlabel_cleanup(); 847 addrconf_cleanup(); 848 ip6_route_cleanup(); 849 ipv6_packet_cleanup(); 850 igmp6_cleanup(); 851 ipv6_netfilter_fini(); 852 ndisc_cleanup(); 853 icmpv6_cleanup(); 854 #ifdef CONFIG_SYSCTL 855 ipv6_sysctl_unregister(); 856 #endif 857 cleanup_ipv6_mibs(); 858 proto_unregister(&rawv6_prot); 859 proto_unregister(&udpv6_prot); 860 proto_unregister(&tcpv6_prot); 861 } 862 module_exit(inet6_exit); 863 864 MODULE_ALIAS_NETPROTO(PF_INET6); 865