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