开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
af_inet6.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：17k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

af_inet6.c：源码内容
  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.65 2001/10/02 02:22:36 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.  */
  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/major.h>
  32. #include <linux/sched.h>
  33. #include <linux/timer.h>
  34. #include <linux/string.h>
  35. #include <linux/sockios.h>
  36. #include <linux/net.h>
  37. #include <linux/fcntl.h>
  38. #include <linux/mm.h>
  39. #include <linux/interrupt.h>
  40. #include <linux/proc_fs.h>
  41. #include <linux/stat.h>
  42. #include <linux/init.h>
  43. #include <linux/version.h>
  45. #include <linux/inet.h>
  46. #include <linux/netdevice.h>
  47. #include <linux/icmpv6.h>
  48. #include <linux/brlock.h>
  49. #include <linux/smp_lock.h>
  51. #include <net/ip.h>
  52. #include <net/ipv6.h>
  53. #include <net/udp.h>
  54. #include <net/tcp.h>
  55. #include <net/ipip.h>
  56. #include <net/protocol.h>
  57. #include <net/inet_common.h>
  58. #include <net/transp_v6.h>
  59. #include <net/ip6_route.h>
  60. #include <net/addrconf.h>
  62. #include <asm/uaccess.h>
  63. #include <asm/system.h>
  65. #ifdef MODULE
  66. static int unloadable = 0; /* XX: Turn to one when all is ok within the
  67.       module for allowing unload */
  68. #endif
  70. #if defined(MODULE) && LINUX_VERSION_CODE > 0x20115
  71. MODULE_AUTHOR("Cast of dozens");
  72. MODULE_DESCRIPTION("IPv6 protocol stack for Linux");
  73. MODULE_PARM(unloadable, "i");
  74. #endif
  76. /* IPv6 procfs goodies... */
  78. #ifdef CONFIG_PROC_FS
  79. extern int raw6_get_info(char *, char **, off_t, int);
  80. extern int tcp6_get_info(char *, char **, off_t, int);
  81. extern int udp6_get_info(char *, char **, off_t, int);
  82. extern int afinet6_get_info(char *, char **, off_t, int);
  83. extern int afinet6_get_snmp(char *, char **, off_t, int);
  84. #endif
  86. #ifdef CONFIG_SYSCTL
  87. extern void ipv6_sysctl_register(void);
  88. extern void ipv6_sysctl_unregister(void);
  89. #endif
  91. #ifdef INET_REFCNT_DEBUG
  92. atomic_t inet6_sock_nr;
  93. #endif
  95. /* The inetsw table contains everything that inet_create needs to
  96.  * build a new socket.
  97.  */
  98. struct list_head inetsw6[SOCK_MAX];
  100. static void inet6_sock_destruct(struct sock *sk)
  101. {
  102. inet_sock_destruct(sk);
  104. #ifdef INET_REFCNT_DEBUG
  105. atomic_dec(&inet6_sock_nr);
  106. #endif
  107. MOD_DEC_USE_COUNT;
  108. }
  110. static int inet6_create(struct socket *sock, int protocol)
  111. {
  112. struct sock *sk;
  113. struct list_head *p;
  114. struct inet_protosw *answer;
  116. sk = sk_alloc(PF_INET6, GFP_KERNEL, 1);
  117. if (sk == NULL) 
  118. goto do_oom;
  120. /* Look for the requested type/protocol pair. */
  121. answer = NULL;
  122. br_read_lock_bh(BR_NETPROTO_LOCK);
  123. list_for_each(p, &inetsw6[sock->type]) {
  124. answer = list_entry(p, struct inet_protosw, list);
  126. /* Check the non-wild match. */
  127. if (protocol == answer->protocol) {
  128. if (protocol != IPPROTO_IP)
  129. break;
  130. } else {
  131. /* Check for the two wild cases. */
  132. if (IPPROTO_IP == protocol) {
  133. protocol = answer->protocol;
  134. break;
  135. }
  136. if (IPPROTO_IP == answer->protocol)
  137. break;
  138. }
  139. answer = NULL;
  140. }
  141. br_read_unlock_bh(BR_NETPROTO_LOCK);
  143. if (!answer)
  144. goto free_and_badtype;
  145. if (answer->capability > 0 && !capable(answer->capability))
  146. goto free_and_badperm;
  147. if (!protocol)
  148. goto free_and_noproto;
  150. sock->ops = answer->ops;
  151. sock_init_data(sock, sk);
  153. sk->prot = answer->prot;
  154. sk->no_check = answer->no_check;
  155. if (INET_PROTOSW_REUSE & answer->flags)
  156. sk->reuse = 1;
  158. if (SOCK_RAW == sock->type) {
  159. sk->num = protocol;
  160. if (IPPROTO_RAW == protocol)
  161. sk->protinfo.af_inet.hdrincl = 1;
  162. }
  164. sk->destruct            = inet6_sock_destruct;
  165. sk->zapped = 0;
  166. sk->family = PF_INET6;
  167. sk->protocol = protocol;
  169. sk->backlog_rcv = answer->prot->backlog_rcv;
  171. sk->net_pinfo.af_inet6.hop_limit  = -1;
  172. sk->net_pinfo.af_inet6.mcast_hops = -1;
  173. sk->net_pinfo.af_inet6.mc_loop   = 1;
  174. sk->net_pinfo.af_inet6.pmtudisc   = IPV6_PMTUDISC_WANT;
  176. /* Init the ipv4 part of the socket since we can have sockets
  177.  * using v6 API for ipv4.
  178.  */
  179. sk->protinfo.af_inet.ttl = 64;
  181. sk->protinfo.af_inet.mc_loop = 1;
  182. sk->protinfo.af_inet.mc_ttl = 1;
  183. sk->protinfo.af_inet.mc_index = 0;
  184. sk->protinfo.af_inet.mc_list = NULL;
  186. if (ipv4_config.no_pmtu_disc)
  187. sk->protinfo.af_inet.pmtudisc = IP_PMTUDISC_DONT;
  188. else
  189. sk->protinfo.af_inet.pmtudisc = IP_PMTUDISC_WANT;
  192. #ifdef INET_REFCNT_DEBUG
  193. atomic_inc(&inet6_sock_nr);
  194. atomic_inc(&inet_sock_nr);
  195. #endif
  196. MOD_INC_USE_COUNT;
  198. if (sk->num) {
  199. /* It assumes that any protocol which allows
  200.  * the user to assign a number at socket
  201.  * creation time automatically shares.
  202.  */
  203. sk->sport = ntohs(sk->num);
  204. sk->prot->hash(sk);
  205. }
  206. if (sk->prot->init) {
  207. int err = sk->prot->init(sk);
  208. if (err != 0) {
  209. MOD_DEC_USE_COUNT;
  210. inet_sock_release(sk);
  211. return err;
  212. }
  213. }
  214. return 0;
  216. free_and_badtype:
  217. sk_free(sk);
  218. return -ESOCKTNOSUPPORT;
  219. free_and_badperm:
  220. sk_free(sk);
  221. return -EPERM;
  222. free_and_noproto:
  223. sk_free(sk);
  224. return -EPROTONOSUPPORT;
  225. do_oom:
  226. return -ENOBUFS;
  227. }
  230. /* bind for INET6 API */
  231. static int inet6_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
  232. {
  233. struct sockaddr_in6 *addr=(struct sockaddr_in6 *)uaddr;
  234. struct sock *sk = sock->sk;
  235. __u32 v4addr = 0;
  236. unsigned short snum;
  237. int addr_type = 0;
  239. /* If the socket has its own bind function then use it. */
  240. if(sk->prot->bind)
  241. return sk->prot->bind(sk, uaddr, addr_len);
  243. if (addr_len < SIN6_LEN_RFC2133)
  244. return -EINVAL;
  245. addr_type = ipv6_addr_type(&addr->sin6_addr);
  246. if ((addr_type & IPV6_ADDR_MULTICAST) && sock->type == SOCK_STREAM)
  247. return -EINVAL;
  249. /* Check if the address belongs to the host. */
  250. if (addr_type == IPV6_ADDR_MAPPED) {
  251. v4addr = addr->sin6_addr.s6_addr32[3];
  252. if (inet_addr_type(v4addr) != RTN_LOCAL)
  253. return -EADDRNOTAVAIL;
  254. } else {
  255. if (addr_type != IPV6_ADDR_ANY) {
  256. /* ipv4 addr of the socket is invalid.  Only the
  257.  * unpecified and mapped address have a v4 equivalent.
  258.  */
  259. v4addr = LOOPBACK4_IPV6;
  260. if (!(addr_type & IPV6_ADDR_MULTICAST)) {
  261. if (!ipv6_chk_addr(&addr->sin6_addr, NULL))
  262. return -EADDRNOTAVAIL;
  263. }
  264. }
  265. }
  267. snum = ntohs(addr->sin6_port);
  268. if (snum && snum < PROT_SOCK && !capable(CAP_NET_BIND_SERVICE))
  269. return -EACCES;
  271. lock_sock(sk);
  273. /* Check these errors (active socket, double bind). */
  274. if ((sk->state != TCP_CLOSE) ||
  275.     (sk->num != 0)) {
  276. release_sock(sk);
  277. return -EINVAL;
  278. }
  280. if (addr_type & IPV6_ADDR_LINKLOCAL) {
  281. if (addr_len >= sizeof(struct sockaddr_in6) &&
  282.     addr->sin6_scope_id) {
  283. /* Override any existing binding, if another one
  284.  * is supplied by user.
  285.  */
  286. sk->bound_dev_if = addr->sin6_scope_id;
  287. }
  289. /* Binding to link-local address requires an interface */
  290. if (sk->bound_dev_if == 0) {
  291. release_sock(sk);
  292. return -EINVAL;
  293. }
  294. }
  296. sk->rcv_saddr = v4addr;
  297. sk->saddr = v4addr;
  299. ipv6_addr_copy(&sk->net_pinfo.af_inet6.rcv_saddr, &addr->sin6_addr);
  301. if (!(addr_type & IPV6_ADDR_MULTICAST))
  302. ipv6_addr_copy(&sk->net_pinfo.af_inet6.saddr, &addr->sin6_addr);
  304. /* Make sure we are allowed to bind here. */
  305. if (sk->prot->get_port(sk, snum) != 0) {
  306. sk->rcv_saddr = 0;
  307. sk->saddr = 0;
  308. memset(&sk->net_pinfo.af_inet6.rcv_saddr, 0, sizeof(struct in6_addr));
  309. memset(&sk->net_pinfo.af_inet6.saddr, 0, sizeof(struct in6_addr));
  311. release_sock(sk);
  312. return -EADDRINUSE;
  313. }
  315. if (addr_type != IPV6_ADDR_ANY)
  316. sk->userlocks |= SOCK_BINDADDR_LOCK;
  317. if (snum)
  318. sk->userlocks |= SOCK_BINDPORT_LOCK;
  319. sk->sport = ntohs(sk->num);
  320. sk->dport = 0;
  321. sk->daddr = 0;
  322. release_sock(sk);
  324. return 0;
  325. }
  327. static int inet6_release(struct socket *sock)
  328. {
  329. struct sock *sk = sock->sk;
  331. if (sk == NULL)
  332. return -EINVAL;
  334. /* Free mc lists */
  335. ipv6_sock_mc_close(sk);
  337. return inet_release(sock);
  338. }
  340. int inet6_destroy_sock(struct sock *sk)
  341. {
  342. struct sk_buff *skb;
  343. struct ipv6_txoptions *opt;
  345. /*
  346.  * Release destination entry
  347.  */
  349. sk_dst_reset(sk);
  351. /* Release rx options */
  353. if ((skb = xchg(&sk->net_pinfo.af_inet6.pktoptions, NULL)) != NULL)
  354. kfree_skb(skb);
  356. /* Free flowlabels */
  357. fl6_free_socklist(sk);
  359. /* Free tx options */
  361. if ((opt = xchg(&sk->net_pinfo.af_inet6.opt, NULL)) != NULL)
  362. sock_kfree_s(sk, opt, opt->tot_len);
  364. return 0;
  365. }
  367. /*
  368.  * This does both peername and sockname.
  369.  */
  370.  
  371. static int inet6_getname(struct socket *sock, struct sockaddr *uaddr,
  372.  int *uaddr_len, int peer)
  373. {
  374. struct sockaddr_in6 *sin=(struct sockaddr_in6 *)uaddr;
  375. struct sock *sk = sock->sk;
  376.   
  377. sin->sin6_family = AF_INET6;
  378. sin->sin6_flowinfo = 0;
  379. sin->sin6_scope_id = 0;
  380. if (peer) {
  381. if (!sk->dport)
  382. return -ENOTCONN;
  383. if (((1<<sk->state)&(TCPF_CLOSE|TCPF_SYN_SENT)) && peer == 1)
  384. return -ENOTCONN;
  385. sin->sin6_port = sk->dport;
  386. memcpy(&sin->sin6_addr, &sk->net_pinfo.af_inet6.daddr,
  387.        sizeof(struct in6_addr));
  388. if (sk->net_pinfo.af_inet6.sndflow)
  389. sin->sin6_flowinfo = sk->net_pinfo.af_inet6.flow_label;
  390. } else {
  391. if (ipv6_addr_type(&sk->net_pinfo.af_inet6.rcv_saddr) == IPV6_ADDR_ANY)
  392. memcpy(&sin->sin6_addr, 
  393.        &sk->net_pinfo.af_inet6.saddr,
  394.        sizeof(struct in6_addr));
  395. else
  396. memcpy(&sin->sin6_addr, 
  397.        &sk->net_pinfo.af_inet6.rcv_saddr,
  398.        sizeof(struct in6_addr));
  400. sin->sin6_port = sk->sport;
  401. }
  402. if (ipv6_addr_type(&sin->sin6_addr) & IPV6_ADDR_LINKLOCAL)
  403. sin->sin6_scope_id = sk->bound_dev_if;
  404. *uaddr_len = sizeof(*sin);
  405. return(0);
  406. }
  408. static int inet6_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
  409. {
  410. struct sock *sk = sock->sk;
  411. int err = -EINVAL;
  412. int pid;
  414. switch(cmd) 
  415. {
  416. case FIOSETOWN:
  417. case SIOCSPGRP:
  418. if (get_user(pid, (int *) arg))
  419. return -EFAULT;
  420. /* see sock_no_fcntl */
  421. if (current->pid != pid && current->pgrp != -pid && 
  422.     !capable(CAP_NET_ADMIN))
  423. return -EPERM;
  424. sk->proc = pid;
  425. return(0);
  426. case FIOGETOWN:
  427. case SIOCGPGRP:
  428. return put_user(sk->proc,(int *)arg);
  429. case SIOCGSTAMP:
  430. if(sk->stamp.tv_sec==0)
  431. return -ENOENT;
  432. err = copy_to_user((void *)arg, &sk->stamp,
  433.    sizeof(struct timeval));
  434. if (err)
  435. return -EFAULT;
  436. return 0;
  438. case SIOCADDRT:
  439. case SIOCDELRT:
  440.   
  441. return(ipv6_route_ioctl(cmd,(void *)arg));
  443. case SIOCSIFADDR:
  444. return addrconf_add_ifaddr((void *) arg);
  445. case SIOCDIFADDR:
  446. return addrconf_del_ifaddr((void *) arg);
  447. case SIOCSIFDSTADDR:
  448. return addrconf_set_dstaddr((void *) arg);
  449. default:
  450. if ((cmd >= SIOCDEVPRIVATE) &&
  451.     (cmd <= (SIOCDEVPRIVATE + 15)))
  452. return(dev_ioctl(cmd,(void *) arg));
  454. if(sk->prot->ioctl==0 || (err=sk->prot->ioctl(sk, cmd, arg))==-ENOIOCTLCMD)
  455. return(dev_ioctl(cmd,(void *) arg));
  456. return err;
  457. }
  458. /*NOTREACHED*/
  459. return(0);
  460. }
  462. struct proto_ops inet6_stream_ops = {
  463. family: PF_INET6,
  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: inet_setsockopt, /* ok */
  476. getsockopt: inet_getsockopt, /* ok */
  477. sendmsg: inet_sendmsg, /* ok */
  478. recvmsg: inet_recvmsg, /* ok */
  479. mmap: sock_no_mmap,
  480. sendpage: tcp_sendpage
  481. };
  483. struct proto_ops inet6_dgram_ops = {
  484. family: PF_INET6,
  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: datagram_poll, /* ok */
  493. ioctl: inet6_ioctl, /* must change  */
  494. listen: sock_no_listen, /* ok */
  495. shutdown: inet_shutdown, /* ok */
  496. setsockopt: inet_setsockopt, /* ok */
  497. getsockopt: inet_getsockopt, /* ok */
  498. sendmsg: inet_sendmsg, /* ok */
  499. recvmsg: inet_recvmsg, /* ok */
  500. mmap: sock_no_mmap,
  501. sendpage: sock_no_sendpage,
  502. };
  504. struct net_proto_family inet6_family_ops = {
  505. PF_INET6,
  506. inet6_create
  507. };
  509. #ifdef MODULE
  510. int ipv6_unload(void)
  511. {
  512. if (!unloadable) return 1;
  513. /* We keep internally 3 raw sockets */
  514. return atomic_read(&(__this_module.uc.usecount)) - 3;
  515. }
  516. #endif
  518. #if defined(MODULE) && defined(CONFIG_SYSCTL)
  519. extern void ipv6_sysctl_register(void);
  520. extern void ipv6_sysctl_unregister(void);
  521. #endif
  523. static struct inet_protosw rawv6_protosw = {
  524. type:        SOCK_RAW,
  525. protocol:    IPPROTO_IP, /* wild card */
  526. prot:        &rawv6_prot,
  527. ops:         &inet6_dgram_ops,
  528. capability:  CAP_NET_RAW,
  529. no_check:    UDP_CSUM_DEFAULT,
  530. flags:       INET_PROTOSW_REUSE,
  531. };
  533. #define INETSW6_ARRAY_LEN (sizeof(inetsw6_array) / sizeof(struct inet_protosw))
  535. void
  536. inet6_register_protosw(struct inet_protosw *p)
  537. {
  538. struct list_head *lh;
  539. struct inet_protosw *answer;
  540. int protocol = p->protocol;
  542. br_write_lock_bh(BR_NETPROTO_LOCK);
  544. if (p->type > SOCK_MAX)
  545. goto out_illegal;
  547. /* If we are trying to override a permanent protocol, bail. */
  548. answer = NULL;
  549. list_for_each(lh, &inetsw6[p->type]) {
  550. answer = list_entry(lh, struct inet_protosw, list);
  552. /* Check only the non-wild match. */
  553. if (protocol == answer->protocol &&
  554.     (INET_PROTOSW_PERMANENT & answer->flags))
  555. break;
  557. answer = NULL;
  558. }
  559. if (answer)
  560. goto out_permanent;
  562. /* Add to the BEGINNING so that we override any existing
  563.  * entry.  This means that when we remove this entry, the
  564.  * system automatically returns to the old behavior.
  565.  */
  566. list_add(&p->list, &inetsw6[p->type]);
  567. out:
  568. br_write_unlock_bh(BR_NETPROTO_LOCK);
  569. return;
  571. out_permanent:
  572. printk(KERN_ERR "Attempt to override permanent protocol %d.n",
  573.        protocol);
  574. goto out;
  576. out_illegal:
  577. printk(KERN_ERR
  578.        "Ignoring attempt to register illegal socket type %d.n",
  579.        p->type);
  580. goto out;
  581. }
  583. void
  584. inet6_unregister_protosw(struct inet_protosw *p)
  585. {
  586. inet_unregister_protosw(p);
  587. }
  589. static int __init inet6_init(void)
  590. {
  591. struct sk_buff *dummy_skb;
  592.         struct list_head *r;
  593. int err;
  595. #ifdef MODULE
  596. if (!mod_member_present(&__this_module, can_unload))
  597.   return -EINVAL;
  599. __this_module.can_unload = &ipv6_unload;
  600. #endif
  602. printk(KERN_INFO "IPv6 v0.8 for NET4.0n");
  604. if (sizeof(struct inet6_skb_parm) > sizeof(dummy_skb->cb))
  605. {
  606. printk(KERN_CRIT "inet6_proto_init: size faultn");
  607. return -EINVAL;
  608. }
  610. /* Register the socket-side information for inet6_create.  */
  611. for(r = &inetsw6[0]; r < &inetsw6[SOCK_MAX]; ++r)
  612. INIT_LIST_HEAD(r);
  614. /* We MUST register RAW sockets before we create the ICMP6,
  615.  * IGMP6, or NDISC control sockets.
  616.  */
  617. inet6_register_protosw(&rawv6_protosw);
  619. /*
  620.  * ipngwg API draft makes clear that the correct semantics
  621.  * for TCP and UDP is to consider one TCP and UDP instance
  622.  * in a host availiable by both INET and INET6 APIs and
  623.  * able to communicate via both network protocols.
  624.  */
  626. #if defined(MODULE) && defined(CONFIG_SYSCTL)
  627. ipv6_sysctl_register();
  628. #endif
  629. err = icmpv6_init(&inet6_family_ops);
  630. if (err)
  631. goto icmp_fail;
  632. err = ndisc_init(&inet6_family_ops);
  633. if (err)
  634. goto ndisc_fail;
  635. err = igmp6_init(&inet6_family_ops);
  636. if (err)
  637. goto igmp_fail;
  638. /* Create /proc/foo6 entries. */
  639. #ifdef CONFIG_PROC_FS
  640. err = -ENOMEM;
  641. if (!proc_net_create("raw6", 0, raw6_get_info))
  642. goto proc_raw6_fail;
  643. if (!proc_net_create("tcp6", 0, tcp6_get_info))
  644. goto proc_tcp6_fail;
  645. if (!proc_net_create("udp6", 0, udp6_get_info))
  646. goto proc_udp6_fail;
  647. if (!proc_net_create("sockstat6", 0, afinet6_get_info))
  648. goto proc_sockstat6_fail;
  649. if (!proc_net_create("snmp6", 0, afinet6_get_snmp))
  650. goto proc_snmp6_fail;
  651. #endif
  652. ipv6_netdev_notif_init();
  653. ipv6_packet_init();
  654. ip6_route_init();
  655. ip6_flowlabel_init();
  656. addrconf_init();
  657. sit_init();
  659. /* Init v6 transport protocols. */
  660. udpv6_init();
  661. tcpv6_init();
  663. /* Now the userspace is allowed to create INET6 sockets. */
  664. (void) sock_register(&inet6_family_ops);
  666. return 0;
  668. #ifdef CONFIG_PROC_FS
  669. proc_snmp6_fail:
  670. proc_net_remove("sockstat6");
  671. proc_sockstat6_fail:
  672. proc_net_remove("udp6");
  673. proc_udp6_fail:
  674. proc_net_remove("tcp6");
  675. proc_tcp6_fail:
  676.         proc_net_remove("raw6");
  677. proc_raw6_fail:
  678. igmp6_cleanup();
  679. #endif
  680. igmp_fail:
  681. ndisc_cleanup();
  682. ndisc_fail:
  683. icmpv6_cleanup();
  684. icmp_fail:
  685. #if defined(MODULE) && defined(CONFIG_SYSCTL)
  686. ipv6_sysctl_unregister();
  687. #endif
  688. return err;
  689. }
  690. module_init(inet6_init);
  693. #ifdef MODULE
  694. static void inet6_exit(void)
  695. {
  696. /* First of all disallow new sockets creation. */
  697. sock_unregister(PF_INET6);
  698. #ifdef CONFIG_PROC_FS
  699. proc_net_remove("raw6");
  700. proc_net_remove("tcp6");
  701. proc_net_remove("udp6");
  702. proc_net_remove("sockstat6");
  703. proc_net_remove("snmp6");
  704. #endif
  705. /* Cleanup code parts. */
  706. sit_cleanup();
  707. ipv6_netdev_notif_cleanup();
  708. ip6_flowlabel_cleanup();
  709. addrconf_cleanup();
  710. ip6_route_cleanup();
  711. ipv6_packet_cleanup();
  712. igmp6_cleanup();
  713. ndisc_cleanup();
  714. icmpv6_cleanup();
  715. #ifdef CONFIG_SYSCTL
  716. ipv6_sysctl_unregister();
  717. #endif
  718. }
  719. module_exit(inet6_exit);
  720. #endif /* MODULE */
  721. MODULE_LICENSE("GPL");