add already generated debian policy files and debian package files

130 files changed, 19969 insertions, 0 deletions

diff --git a/gnutls-1.1.9/ChangeLog b/gnutls-1.1.9/ChangeLog
new file mode 100644
index 0000000..a6c9459
--- /dev/null
+++ b/gnutls-1.1.9/ChangeLog
@@ -0,0 +1,97 @@
+Changes in version 1.1.9
+------------------------
+
+  * Made loseConnection signature match the corresponding one from twisted
+  * Bumped debian standards version to 3.8.2
+  * Fixed lintian warning about missing misc:Depends dependency
+
+Changes in version 1.1.8
+------------------------
+
+  * Workaround for changed tcp.Server.__init__ signature in twisted 8.2.0
+  * Fixed DeprecationWarning when running with python2.6 or newer
+
+Changes in version 1.1.7
+------------------------
+
+  * Updated debian build dependency to libgnutls-dev 2.4.1 or newer
+  * Use the default python interpreter instead of /usr/bin/python in
+    example, test and setup scripts
+  * Improved detection of gnutls libraries by using libgnutls-config
+  * Fixed gnutls library location for Mac OSX installations
+
+Changes in version 1.1.6
+------------------------
+
+  * Require libgnutls version 2.4.1 or higher.
+
+Changes in version 1.1.5
+------------------------
+
+  * Added server name extension support.
+  * Fixed 64-bit issues with size_t and ssize_t.
+  * Require libgnutls version 2.2.2 or higher.
+
+Changes in version 1.1.4
+------------------------
+
+  * Better integration with twisted. The TLSClient and TLSServer
+    classes now declare that they implement ISSLTransport.
+
+Changes in version 1.1.3
+------------------------
+
+  * Better version headers for changelog entries.
+  * Check if C module initialization failed.
+
+Changes in version 1.1.2
+------------------------
+
+  * Added LICENSE file and updated copyright notices to reference it.
+  * Only included the relevant examples in the source distribution.
+  * Avoid multiple splits on name/value pairs in X509Name.
+
+Changes in version 1.1.1
+------------------------
+
+  * Removed a circular reference manifesting on handshake failures.
+
+Changes in version 1.1.0
+------------------------
+
+  * Send TLS bye if the client session peer certificate verification fails
+  * Based CertificateError on GNUTLSError and added 4 new certificate related
+    exceptions derived from it.
+  * Added the ability to send TLS alerts based on certain error conditions
+    Using this mechanism a python exception related to GNUTLS can be mapped
+    to a TLS alert and sent to the peer which will map it back to the original
+    python exception, making it possible to transfer error conditions and
+    raise their corresponding exception on the other side that becomes this
+    way aware of the errors that occured in the peer. Currently this is used
+    to map certificate related exceptions into TLS alerts and back to python
+    exceptions on the other side.
+  * Send a TLS alert before closing a connection as a result of an error in
+    the twisted interface.
+  * Preserve closing reason while sending the close alerts.
+  * Pass the proper exception when a client connection fails.
+  * Improved some exception messages related to certificate errors.
+  * Added the ability to specify the certificate name to use in exceptions
+    raised by certificate checking methods, which helps improve the clarity
+    of the error messages.
+  * Set transport on protocol after the TCP connection is made, because we
+    may call connectionLost without calling connectionMade if TLS negociation
+    fails (which in turn will call connectionLost on the protocol).
+  * Added _closeWriteConnection to handle half closed connections.
+
+Changes in version 1.0.2
+------------------------
+
+  * Avoid the need to handle bye timeouts in the twisted interface by not
+    waiting for the bye notification acknowledgement as we do not use the
+    TCP connection anymore after closing the TLS session.
+
+Changes in version 1.0.1
+------------------------
+
+  * Fixed typo in internal class name in the twisted interface
+
diff --git a/gnutls-1.1.9/LICENSE b/gnutls-1.1.9/LICENSE
new file mode 100644
index 0000000..a84c968
--- /dev/null
+++ b/gnutls-1.1.9/LICENSE
@@ -0,0 +1,20 @@
+
+Copyright (C) 2006-2007
+AG Projects
+Dan Pascu
+Mircea Amarascu
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library; if not, write to the Free Software Foundation,
+Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+
diff --git a/gnutls-1.1.9/MANIFEST.in b/gnutls-1.1.9/MANIFEST.in
new file mode 100644
index 0000000..e45dfeb
--- /dev/null
+++ b/gnutls-1.1.9/MANIFEST.in
@@ -0,0 +1,3 @@
+recursive-include examples README crypto.py client.py server.py twisted-*.py
+recursive-include examples certs/*.pem certs/valid.* certs/revoked.*
+include MANIFEST.in LICENSE ChangeLog Makefile build_inplace
diff --git a/gnutls-1.1.9/Makefile b/gnutls-1.1.9/Makefile
new file mode 100644
index 0000000..9f01426
--- /dev/null
+++ b/gnutls-1.1.9/Makefile
@@ -0,0 +1,35 @@
+
+export PYTHONPATH = $(PWD)
+
+HEADER_FILES = /usr/include/gnutls/gnutls.h /usr/include/gnutls/x509.h /usr/include/gnutls/openpgp.h /usr/include/gnutls/extra.h
+
+LIBRARIES = -lgnutls -lgnutls-extra
+
+all: gnutls-library
+
+gnutls-library: gnutls.xml
+	mv gnutls/library/__init__.py gnutls/library/__init__.py.tmp
+	touch gnutls/library/__init__.py
+	xml2py gnutls.xml -o gnutls/library/constants.py -v -kde -r ".*[Tt][Ll][Ss].*"
+	xml2py gnutls.xml -o gnutls/library/types.py -v -kst -r ".*[Tt][Ll][Ss].*" -m gnutls.library.constants
+	xml2py gnutls.xml -o gnutls/library/functions.py -v -kf -r ".*[Tt][Ll][Ss].*" $(LIBRARIES) -m gnutls.library.types -m gnutls.library.constants
+	mv gnutls/library/__init__.py.tmp gnutls/library/__init__.py
+	@echo "Fixing wrong argument types"
+	@CALLBACKS=`grep FUNCTYPE gnutls/library/types.py | cut -f 1 -d' '`; \
+	cp gnutls/library/functions.py gnutls/library/functions.py.bak; \
+	for cb in $$CALLBACKS; do \
+	    sed -i -r "s/POINTER\($$cb\)/$$cb/g" gnutls/library/functions.py; \
+	done
+	@echo "Fixing 64 bit architecture issues"
+	@cp gnutls/library/types.py gnutls/library/types.py.bak; \
+	sed -i -r "s/size_t = c_uint/size_t = c_size_t/g" gnutls/library/types.py; \
+	sed -i -r "s/__ssize_t = c_int/__ssize_t = c_long/g" gnutls/library/types.py
+
+gnutls.xml: $(HEADER_FILES)
+	h2xml $(HEADER_FILES) -o gnutls.xml -q -c
+
+clean::
+	rm -rf *~ gnutls.xml gnutls/__init__.pyc
+	(cd gnutls/library; rm -rf *.pyc constants.py types.py functions.py functions.py.bak)
+
+.PHONY: gnutls-library clean
diff --git a/gnutls-1.1.9/PKG-INFO b/gnutls-1.1.9/PKG-INFO
new file mode 100644
index 0000000..39109f3
--- /dev/null
+++ b/gnutls-1.1.9/PKG-INFO
@@ -0,0 +1,33 @@
+Metadata-Version: 1.0
+Name: python-gnutls
+Version: 1.1.9
+Summary: Python wrapper for the GNUTLS library
+Home-page: http://ag-projects.com/
+Author: Dan Pascu
+Author-email: dan@ag-projects.com
+License: LGPL
+Download-URL: http://cheeseshop.python.org/pypi/python-gnutls/1.1.9
+Description: This package provides a high level object oriented wrapper around libgnutls,
+        as well as low level bindings to the GNUTLS types and functions via ctypes.
+        The high level wrapper hides the details of accessing the GNUTLS library via
+        ctypes behind a set of classes that encapsulate GNUTLS sessions, certificates
+        and credentials and expose them to python applications using a simple API.
+        
+        The package also includes a Twisted interface that has seamless intergration
+        with Twisted, providing connectTLS and listenTLS methods on the Twisted
+        reactor once imported (the methods are automatically attached to the reactor
+        by simply importing the GNUTLS Twisted interface module).
+        
+        The high level wrapper is written using the GNUTLS library bindings that are
+        made available via ctypes. This makes the wrapper very powerful and flexible
+        as it has direct access to all the GNUTLS internals and is also very easy to
+        extend without any need to write C code or recompile anything.
+        
+        
+Platform: Platform Independent
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
diff --git a/gnutls-1.1.9/README b/gnutls-1.1.9/README
new file mode 100644
index 0000000..ef1052a
--- /dev/null
+++ b/gnutls-1.1.9/README
@@ -0,0 +1,19 @@
+
+Python wrapper for the GNUTLS library
+
+This package provides a high level object oriented wrapper around libgnutls,
+as well as low level bindings to the GNUTLS types and functions via ctypes.
+The high level wrapper hides the details of accessing the GNUTLS library via
+ctypes behind a set of classes that encapsulate GNUTLS sessions, certificates
+and credentials and expose them to python applications using a simple API.
+
+The package also includes a Twisted interface that has seamless intergration
+with Twisted, providing connectTLS and listenTLS methods on the Twisted
+reactor once imported (the methods are automatically attached to the reactor
+by simply importing the GNUTLS Twisted interface module).
+
+The high level wrapper is written using the GNUTLS library bindings that are
+made available via ctypes. This makes the wrapper very powerful and flexible
+as it has direct access to all the GNUTLS internals and is also very easy to
+extend without any need to write C code or recompile anything.
+
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/__init__.py b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/__init__.py
new file mode 100644
index 0000000..c72f309
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/__init__.py
@@ -0,0 +1,5 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+__version__ = '1.1.9'
+
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/connection.py b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/connection.py
new file mode 100644
index 0000000..5990bd4
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/connection.py
@@ -0,0 +1,500 @@
+# Copyright (C) 2007-2008 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS connection support"""
+
+__all__ = ['X509Credentials', 'ClientSession', 'ServerSession', 'ServerSessionFactory']
+
+from time import time
+from socket import SHUT_RDWR as SOCKET_SHUT_RDWR
+
+from _ctypes import PyObj_FromPtr
+from ctypes import *
+
+from gnutls.validators import *
+from gnutls.constants import *
+from gnutls.crypto import *
+from gnutls.errors import *
+
+from gnutls.library.constants import GNUTLS_SERVER, GNUTLS_CLIENT, GNUTLS_CRT_X509
+from gnutls.library.constants import GNUTLS_CERT_INVALID, GNUTLS_CERT_REVOKED, GNUTLS_CERT_INSECURE_ALGORITHM
+from gnutls.library.constants import GNUTLS_CERT_SIGNER_NOT_FOUND, GNUTLS_CERT_SIGNER_NOT_CA
+from gnutls.library.constants import GNUTLS_AL_FATAL, GNUTLS_A_BAD_CERTIFICATE
+from gnutls.library.constants import GNUTLS_A_UNKNOWN_CA, GNUTLS_A_INSUFFICIENT_SECURITY
+from gnutls.library.constants import GNUTLS_A_CERTIFICATE_EXPIRED, GNUTLS_A_CERTIFICATE_REVOKED
+from gnutls.library.constants import GNUTLS_NAME_DNS
+from gnutls.library.types     import gnutls_certificate_credentials_t, gnutls_session_t, gnutls_x509_crt_t
+from gnutls.library.types     import gnutls_certificate_server_retrieve_function
+from gnutls.library.functions import *
+
+
+@gnutls_certificate_server_retrieve_function
+def _retrieve_server_certificate(c_session, retr_st):
+    session = PyObj_FromPtr(gnutls_session_get_ptr(c_session))
+    identity = session.credentials.select_server_identity(session)
+    retr_st.contents.type = GNUTLS_CRT_X509
+    retr_st.contents.deinit_all = 0
+    if identity is None:
+        retr_st.contents.ncerts = 0
+    else:
+        retr_st.contents.ncerts = 1
+        retr_st.contents.cert.x509.contents = identity.cert._c_object
+        retr_st.contents.key.x509 = identity.key._c_object
+    return 0
+
+
+class _ServerNameIdentities(dict):
+    """Used internally by X509Credentials to map server names to X509 identities for the server name extension"""
+    def __init__(self, identities):
+        dict.__init__(self)
+        for identity in identities:
+            self.add(identity)
+    def add(self, identity):
+        for name in identity.cert.alternative_names.dns:
+            self[name.lower()] = identity
+        for ip in identity.cert.alternative_names.ip:
+            self[ip] = identity
+        subject = identity.cert.subject
+        if subject.CN is not None:
+            self[subject.CN.lower()] = identity
+    def get(self, server_name, default=None):
+        server_name = server_name.lower()
+        if server_name in self:
+            return self[server_name]
+        for name in (n for n in self if n.startswith('*.')):
+            suffix = name[1:]
+            if server_name.endswith(suffix) and '.' not in server_name[:-len(suffix)]:
+                return self[name]
+        return default
+
+
+class X509Credentials(object):
+    DH_BITS  = 1024
+    RSA_BITS = 1024
+
+    dh_params  = None
+    rsa_params = None
+
+    def __new__(cls, *args, **kwargs):
+        c_object = gnutls_certificate_credentials_t()
+        gnutls_certificate_allocate_credentials(byref(c_object))
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_certificate_free_credentials
+        instance._c_object = c_object
+        return instance
+
+    @method_args((X509Certificate, none), (X509PrivateKey, none), list_of(X509Certificate), list_of(X509CRL), list_of(X509Identity))
+    def __init__(self, cert=None, key=None, trusted=[], crl_list=[], identities=[]):
+        """Credentials contain a X509 certificate, a private key, a list of trusted CAs and a list of CRLs (all optional).
+        An optional list of additional X509 identities can be specified for applications that need more that one identity"""
+        if cert and key:
+            gnutls_certificate_set_x509_key(self._c_object, byref(cert._c_object), 1, key._c_object)
+        elif (cert, key) != (None, None):
+            raise ValueError("Specify neither or both the certificate and private key")
+        gnutls_certificate_server_set_retrieve_function(self._c_object, _retrieve_server_certificate)
+        self._max_depth = 5
+        self._max_bits  = 8200
+        self._type = CRED_CERTIFICATE
+        self._cert = cert
+        self._key = key
+        self._identities = tuple(identities)
+        self._trusted = ()
+        self.add_trusted(trusted)
+        self.crl_list = crl_list
+        self.server_name_identities = _ServerNameIdentities(identities)
+        if cert and key:
+            self.server_name_identities.add(X509Identity(cert, key))
+        self.session_params = SessionParams(self._type)
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
+    # Methods to alter the credentials at runtime
+
+    @method_args(list_of(X509Certificate))
+    def add_trusted(self, trusted):
+        size = len(trusted)
+        if size > 0:
+            ca_list = (gnutls_x509_crt_t * size)(*[cert._c_object for cert in trusted])
+            gnutls_certificate_set_x509_trust(self._c_object, cast(byref(ca_list), POINTER(gnutls_x509_crt_t)), size)
+            self._trusted = self._trusted + tuple(trusted)
+
+    def generate_dh_params(self, bits=DH_BITS):
+        reference = self.dh_params ## keep a reference to preserve it until replaced
+        X509Credentials.dh_params  = DHParams(bits)
+        del reference
+
+    def generate_rsa_params(self, bits=RSA_BITS):
+        reference = self.rsa_params ## keep a reference to preserve it until replaced
+        X509Credentials.rsa_params = RSAParams(bits)
+        del reference
+
+    # Properties
+
+    @property
+    def cert(self):
+        return self._cert
+
+    @property
+    def key(self):
+        return self._key
+
+    @property
+    def identities(self):
+        return self._identities
+
+    @property
+    def trusted(self):
+        return self._trusted
+
+    def _get_crl_list(self):
+        return self._crl_list
+    @method_args(list_of(X509CRL)) 
+    def _set_crl_list(self, crl_list):
+        self._crl_list = tuple(crl_list)
+    crl_list = property(_get_crl_list, _set_crl_list)
+    del _get_crl_list, _set_crl_list
+
+    def _get_max_verify_length(self):
+        return self._max_depth
+    @method_args(int) 
+    def _set_max_verify_length(self, max_depth):
+        gnutls_certificate_set_verify_limits(self._c_object, self._max_bits, max_depth)
+        self._max_depth = max_depth
+    max_verify_length = property(_get_max_verify_length, _set_max_verify_length)
+    del _get_max_verify_length, _set_max_verify_length
+
+    def _get_max_verify_bits(self):
+        return self._max_bits
+    @method_args(int) 
+    def _set_max_verify_bits(self, max_bits):
+        gnutls_certificate_set_verify_limits(self._c_object, max_bits, self._max_depth)
+        self._max_bits = max_bits
+    max_verify_bits = property(_get_max_verify_bits, _set_max_verify_bits)
+    del _get_max_verify_bits, _set_max_verify_bits
+
+    # Methods to select and validate certificates
+
+    def check_certificate(self, cert, cert_name='certificate'):
+        """Verify activation, expiration and revocation for the given certificate"""
+        now = time()
+        if cert.activation_time > now:
+            raise CertificateExpiredError("%s is not yet activated" % cert_name)
+        if cert.expiration_time < now:
+            raise CertificateExpiredError("%s has expired" % cert_name)
+        for crl in self.crl_list:
+            crl.check_revocation(cert, cert_name=cert_name)
+
+    def select_server_identity(self, session):
+        """Select which identity the server will use for a given session. The default selection algorithm uses
+        the server name extension. A subclass can overwrite it if a different selection algorithm is desired."""
+        server_name = session.server_name
+        if server_name is not None:
+            return self.server_name_identities.get(server_name)
+        elif self.cert and self.key:
+            return self ## since we have the cert and key attributes we can behave like a X509Identity
+        else:
+            return None
+
+
+class SessionParams(object):
+    _default_kx_algorithms = {
+        CRED_CERTIFICATE: (KX_RSA, KX_DHE_DSS, KX_DHE_RSA),
+        CRED_ANON: (KX_ANON_DH,)}
+    _all_kx_algorithms = {
+        CRED_CERTIFICATE: set((KX_RSA, KX_DHE_DSS, KX_DHE_RSA, KX_RSA_EXPORT)),
+        CRED_ANON: set((KX_ANON_DH,))}
+
+    def __new__(cls, credentials_type):
+        if credentials_type not in cls._default_kx_algorithms:
+            raise TypeError("Unknown credentials type: %r" % credentials_type)
+        return object.__new__(cls)
+
+    def __init__(self, credentials_type):
+        self._credentials_type = credentials_type
+        self._protocols = (PROTO_TLS1_1, PROTO_TLS1_0, PROTO_SSL3)
+        self._kx_algorithms = self._default_kx_algorithms[credentials_type]
+        self._ciphers = (CIPHER_AES_128_CBC, CIPHER_3DES_CBC, CIPHER_ARCFOUR_128)
+        self._mac_algorithms = (MAC_SHA1, MAC_MD5, MAC_RMD160)
+        self._compressions = (COMP_NULL,)
+
+    def _get_protocols(self):
+        return self._protocols
+    def _set_protocols(self, protocols):
+        self._protocols = ProtocolListValidator(protocols)
+    protocols = property(_get_protocols, _set_protocols)
+    del _get_protocols, _set_protocols
+
+    def _get_kx_algorithms(self):
+        return self._kx_algorithms
+    def _set_kx_algorithms(self, algorithms):
+        cred_type = self._credentials_type
+        algorithms = KeyExchangeListValidator(algorithms)
+        invalid = set(algorithms) - self._all_kx_algorithms[cred_type]
+        if invalid:
+            raise ValueError("Cannot specify %r with %r credentials" % (list(invalid), cred_type))
+        self._kx_algorithms = algorithms
+    kx_algorithms = property(_get_kx_algorithms, _set_kx_algorithms)
+    del _get_kx_algorithms, _set_kx_algorithms
+
+    def _get_ciphers(self):
+        return self._ciphers
+    def _set_ciphers(self, ciphers):
+        self._ciphers = CipherListValidator(ciphers)
+    ciphers = property(_get_ciphers, _set_ciphers)
+    del _get_ciphers, _set_ciphers
+
+    def _get_mac_algorithms(self):
+        return self._mac_algorithms
+    def _set_mac_algorithms(self, algorithms):
+        self._mac_algorithms = MACListValidator(algorithms)
+    mac_algorithms = property(_get_mac_algorithms, _set_mac_algorithms)
+    del _get_mac_algorithms, _set_mac_algorithms
+
+    def _get_compressions(self):
+        return self._compressions
+    def _set_compressions(self, compressions):
+        self._compressions = CompressionListValidator(compressions)
+    compressions = property(_get_compressions, _set_compressions)
+    del _get_compressions, _set_compressions
+
+
+class Session(object):
+    """Abstract class representing a TLS session created from a TCP socket
+       and a Credentials object."""
+
+    session_type = None ## placeholder for GNUTLS_SERVER or GNUTLS_CLIENT as defined by subclass
+
+    def __new__(cls, *args, **kwargs):
+        if cls is Session:
+            raise RuntimeError("Session cannot be instantiated directly")
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_deinit
+        instance._c_object = gnutls_session_t()
+        return instance
+
+    def __init__(self, socket, credentials):
+        gnutls_init(byref(self._c_object), self.session_type)
+        ## Store a pointer to self on the C session
+        gnutls_session_set_ptr(self._c_object, id(self))
+        # gnutls_dh_set_prime_bits(session, DH_BITS)?
+        gnutls_transport_set_ptr(self._c_object, socket.fileno())
+        gnutls_handshake_set_private_extensions(self._c_object, 1)
+        self.socket = socket
+        self.credentials = credentials
+        self._update_params()
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
+    def __getattr__(self, name):
+        ## Generic wrapper for the underlying socket methods and attributes.
+        return getattr(self.socket, name)
+
+    # Session properties
+
+    def _get_credentials(self):
+        return self._credentials
+    @method_args(X509Credentials)
+    def _set_credentials(self, credentials):
+        ## Release all credentials, otherwise gnutls will only release an existing credential of
+        ## the same type as the one being set and we can end up with multiple credentials in C.
+        gnutls_credentials_clear(self._c_object)
+        gnutls_credentials_set(self._c_object, credentials._type, cast(credentials._c_object, c_void_p))
+        self._credentials = credentials
+    credentials = property(_get_credentials, _set_credentials)
+    del _get_credentials, _set_credentials
+
+    @property
+    def protocol(self):
+        return gnutls_protocol_get_name(gnutls_protocol_get_version(self._c_object))
+
+    @property
+    def kx_algorithm(self):
+        return gnutls_kx_get_name(gnutls_kx_get(self._c_object))
+
+    @property
+    def cipher(self):
+        return gnutls_cipher_get_name(gnutls_cipher_get(self._c_object))
+
+    @property
+    def mac_algorithm(self):
+        return gnutls_mac_get_name(gnutls_mac_get(self._c_object))
+
+    @property
+    def compression(self):
+        return gnutls_compression_get_name(gnutls_compression_get(self._c_object))
+
+    @property
+    def peer_certificate(self):
+        if gnutls_certificate_type_get(self._c_object) != GNUTLS_CRT_X509:
+            return None
+        list_size = c_uint()
+        cert_list = gnutls_certificate_get_peers(self._c_object, byref(list_size))
+        if list_size.value == 0:
+            return None
+        cert = cert_list[0]
+        return X509Certificate(string_at(cert.data, cert.size), X509_FMT_DER)
+
+    # Status checking after an operation was interrupted (these properties are
+    # only useful to check after an operation was interrupted, otherwise their
+    # value is meaningless).
+
+    @property
+    def interrupted_while_writing(self):
+        """True if an operation was interrupted while writing"""
+        return gnutls_record_get_direction(self._c_object)==1
+
+    @property
+    def interrupted_while_reading(self):
+        """True if an operation was interrupted while reading"""
+        return gnutls_record_get_direction(self._c_object)==0
+
+    # Session methods
+
+    def _update_params(self):
+        """Update the priorities of the session params using the credentials."""
+        def c_priority_list(priorities):
+            size = len(priorities) + 1
+            return (c_int * size)(*priorities)
+        session_params = self.credentials.session_params
+        # protocol order in the priority list is irrelevant (it always uses newer protocols first)
+        # the protocol list only specifies what protocols are to be enabled.
+        gnutls_protocol_set_priority(self._c_object, c_priority_list(session_params.protocols))
+        gnutls_kx_set_priority(self._c_object, c_priority_list(session_params.kx_algorithms))
+        gnutls_cipher_set_priority(self._c_object, c_priority_list(session_params.ciphers))
+        gnutls_mac_set_priority(self._c_object, c_priority_list(session_params.mac_algorithms))
+        gnutls_compression_set_priority(self._c_object, c_priority_list(session_params.compressions))
+
+    def handshake(self):
+        gnutls_handshake(self._c_object)
+
+    #@method_args((basestring, buffer))
+    def send(self, data):
+        data = str(data)
+        return gnutls_record_send(self._c_object, data, len(data))
+
+    def sendall(self, data):
+        size = len(data)
+        while size > 0:
+            sent = self.send(data[-size:])
+            size -= sent
+
+    def recv(self, limit):
+        data = create_string_buffer(limit)
+        size = gnutls_record_recv(self._c_object, data, limit)
+        return data[:size]
+
+    def send_alert(self, exception):
+        alertdict = {
+            CertificateError: GNUTLS_A_BAD_CERTIFICATE,
+            CertificateAuthorityError: GNUTLS_A_UNKNOWN_CA,
+            CertificateSecurityError: GNUTLS_A_INSUFFICIENT_SECURITY,
+            CertificateExpiredError: GNUTLS_A_CERTIFICATE_EXPIRED,
+            CertificateRevokedError: GNUTLS_A_CERTIFICATE_REVOKED}
+        alert = alertdict.get(exception.__class__)
+        if alert:
+            gnutls_alert_send(self._c_object, GNUTLS_AL_FATAL, alert)
+
+    @method_args(one_of(SHUT_RDWR, SHUT_WR))
+    def bye(self, how=SHUT_RDWR):
+        gnutls_bye(self._c_object, how)
+
+    def shutdown(self, how=SOCKET_SHUT_RDWR):
+        self.socket.shutdown(how)
+
+    def close(self):
+        self.socket.close()
+
+    def verify_peer(self):
+        status = c_uint()
+        gnutls_certificate_verify_peers2(self._c_object, byref(status))
+        status = status.value
+        if status & GNUTLS_CERT_INVALID:
+            raise CertificateError("peer certificate is invalid")
+        elif status & GNUTLS_CERT_SIGNER_NOT_FOUND:
+            raise CertificateAuthorityError("peer certificate signer not found")
+        elif status & GNUTLS_CERT_SIGNER_NOT_CA:
+            raise CertificateAuthorityError("peer certificate signer is not a CA")
+        elif status & GNUTLS_CERT_INSECURE_ALGORITHM:
+            raise CertificateSecurityError("peer certificate uses an insecure algorithm")
+        elif status & GNUTLS_CERT_REVOKED:
+            raise CertificateRevokedError("peer certificate was revoked")
+
+
+class ClientSession(Session):
+    session_type = GNUTLS_CLIENT
+
+    def __init__(self, socket, credentials, server_name=None):
+        Session.__init__(self, socket, credentials)
+        self._server_name = None
+        if server_name is not None:
+            self.server_name = server_name
+
+    def _get_server_name(self):
+        return self._server_name
+    @method_args(str)
+    def _set_server_name(self, server_name):
+        gnutls_server_name_set(self._c_object, GNUTLS_NAME_DNS, c_char_p(server_name), len(server_name))
+        self._server_name = server_name
+    server_name = property(_get_server_name, _set_server_name)
+    del _get_server_name, _set_server_name
+
+
+class ServerSession(Session):
+    session_type = GNUTLS_SERVER
+
+    def __init__(self, socket, credentials):
+        Session.__init__(self, socket, credentials)
+        gnutls_certificate_server_set_request(self._c_object, CERT_REQUEST)
+
+    @property
+    def server_name(self):
+        data_length = c_size_t(256)
+        data = create_string_buffer(data_length.value)
+        hostname_type = c_uint()
+        for i in xrange(2**16):
+            try:
+                gnutls_server_name_get(self._c_object, data, byref(data_length), byref(hostname_type), i)
+            except RequestedDataNotAvailable:
+                break
+            except MemoryError:
+                data_length.value += 1 ## one extra byte for the terminating 0
+                data = create_string_buffer(data_length.value)
+                gnutls_server_name_get(self._c_object, data, byref(data_length), byref(hostname_type), i)
+            if hostname_type.value != GNUTLS_NAME_DNS:
+                continue
+            return data.value
+        return None
+
+
+class ServerSessionFactory(object):
+
+    def __init__(self, socket, credentials, session_class=ServerSession):
+        if not issubclass(session_class, ServerSession):
+            raise TypeError, "session_class must be a subclass of ServerSession"
+        self.socket = socket
+        self.credentials = credentials
+        self.session_class = session_class
+
+    def __getattr__(self, name):
+        ## Generic wrapper for the underlying socket methods and attributes
+        return getattr(self.socket, name)
+
+    def bind(self, address):
+        self.socket.bind(address)
+
+    def listen(self, backlog):
+        self.socket.listen(backlog)
+
+    def accept(self):
+        new_sock, address = self.socket.accept()
+        session = self.session_class(new_sock, self.credentials)
+        return (session, address)
+
+    def shutdown(self, how=SOCKET_SHUT_RDWR):
+        self.socket.shutdown(how)
+
+    def close(self):
+        self.socket.close()
+
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/constants.py b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/constants.py
new file mode 100644
index 0000000..4637a16
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/constants.py
@@ -0,0 +1,54 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS constants"""
+
+__all__ = [
+    ## GNUTLS session protocols
+    'PROTO_TLS1_1', 'PROTO_TLS1_0', 'PROTO_SSL3',
+    
+    ## Key exchange algorithms
+    'KX_RSA', 'KX_DHE_DSS', 'KX_DHE_RSA', 'KX_RSA_EXPORT', 'KX_ANON_DH',
+    
+    ## Ciphers
+    'CIPHER_AES_128_CBC', 'CIPHER_3DES_CBC', 'CIPHER_ARCFOUR_128', 'CIPHER_AES_256_CBC', 'CIPHER_DES_CBC',
+    
+    ## MAC algorithms
+    'MAC_SHA1', 'MAC_MD5', 'MAC_RMD160',
+    
+    ## Compressions
+    'COMP_DEFLATE', 'COMP_LZO', 'COMP_NULL',
+
+    ## Credential types
+    'CRED_CERTIFICATE', 'CRED_ANON',
+
+    ## X509 certificate/private key formats
+    'X509_FMT_DER', 'X509_FMT_PEM',
+
+    ## Miscellaneous
+    'CERT_REQUEST', 'CERT_REQUIRE', 'SHUT_RDWR', 'SHUT_WR'
+]
+
+__name_map__ = {
+    'PROTO_TLS1_1': 'TLS1_1', 'PROTO_TLS1_0': 'TLS1_0', 'PROTO_SSL3': 'SSL3',
+    'CRED_CERTIFICATE': 'CRD_CERTIFICATE', 'CRED_ANON': 'CRD_ANON'
+}
+
+
+from gnutls.library import constants
+
+class GNUTLSConstant(int):
+    def __new__(cls, name):
+        gnutls_name = 'GNUTLS_' + __name_map__.get(name, name)
+        instance = int.__new__(cls, getattr(constants, gnutls_name))
+        instance.name = name
+        return instance
+    def __repr__(self):
+        return self.name
+
+## Generate all exported constants
+code = '\n'.join(["%s = GNUTLSConstant('%s')" % (name, name) for name in __all__])
+exec code in locals(), globals()
+del code, name
+
+del constants
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/crypto.py b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/crypto.py
new file mode 100644
index 0000000..d330144
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/crypto.py
@@ -0,0 +1,317 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS crypto support"""
+
+__all__ = ['X509Name', 'X509Certificate', 'X509PrivateKey', 'X509Identity', 'X509CRL', 'DHParams', 'RSAParams']
+
+import re
+from ctypes import *
+
+from gnutls.validators import method_args, one_of
+from gnutls.constants import X509_FMT_DER, X509_FMT_PEM
+from gnutls.errors import *
+
+from gnutls.library.constants import GNUTLS_SAN_DNSNAME, GNUTLS_SAN_RFC822NAME, GNUTLS_SAN_URI
+from gnutls.library.constants import GNUTLS_SAN_IPADDRESS, GNUTLS_SAN_OTHERNAME, GNUTLS_SAN_DN
+from gnutls.library.constants import GNUTLS_E_SHORT_MEMORY_BUFFER
+from gnutls.library.types     import *
+from gnutls.library.functions import *
+
+
+class X509NameMeta(type):
+    long_names = {'country': 'C',
+                  'state': 'ST',
+                  'locality': 'L',
+                  'common_name': 'CN',
+                  'organization': 'O',
+                  'organization_unit': 'OU',
+                  'email': 'EMAIL'}
+    def __new__(cls, name, bases, dic):
+        instance = type.__new__(cls, name, bases, dic)
+        instance.ids = X509NameMeta.long_names.values()
+        for long_name, short_name in X509NameMeta.long_names.items():
+            ## Map a long_name property to the short_name attribute
+            cls.add_property(instance, long_name, short_name)
+        return instance
+    def add_property(instance, name, short_name):
+        setattr(instance, name, property(lambda self: getattr(self, short_name, None)))
+
+
+class X509Name(str):
+    __metaclass__ = X509NameMeta
+
+    def __init__(self, dname):
+        str.__init__(self)
+        pairs = [x.replace('\,', ',') for x in re.split(r'(?<!\\),\s*', dname)]
+        for pair in pairs:
+            try:
+                name, value = pair.split('=', 1)
+            except ValueError:
+                raise ValueError("Invalid X509 distinguished name: %s" % dname)
+            str.__setattr__(self, name, value)
+        for name in X509Name.ids:
+            if not hasattr(self, name):
+                str.__setattr__(self, name, None)
+    def __setattr__(self, name, value):
+        if name in X509Name.ids:
+            raise AttributeError("can't set attribute")
+        str.__setattr__(self, name, value)
+
+
+class AlternativeNames(object):
+    __slots__ = {'dns': GNUTLS_SAN_DNSNAME, 'email': GNUTLS_SAN_RFC822NAME, 'uri': GNUTLS_SAN_URI,
+                 'ip': GNUTLS_SAN_IPADDRESS, 'other': GNUTLS_SAN_OTHERNAME, 'dn': GNUTLS_SAN_DN}
+    def __init__(self, names):
+        object.__init__(self)
+        for name, key in self.__slots__.iteritems():
+            setattr(self, name, tuple(names.get(key, ())))
+
+
+class X509Certificate(object):
+
+    def __new__(cls, *args, **kwargs):
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_x509_crt_deinit
+        instance._c_object = gnutls_x509_crt_t()
+        instance._alternative_names = None
+        return instance
+
+    @method_args(str, one_of(X509_FMT_PEM, X509_FMT_DER))
+    def __init__(self, buf, format=X509_FMT_PEM):
+        gnutls_x509_crt_init(byref(self._c_object))
+        data = gnutls_datum_t(cast(c_char_p(buf), POINTER(c_ubyte)), c_uint(len(buf)))
+        gnutls_x509_crt_import(self._c_object, byref(data), format)
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
+    @property
+    def subject(self):
+        size = c_size_t(256)
+        dname = create_string_buffer(size.value)
+        try:
+            gnutls_x509_crt_get_dn(self._c_object, dname, byref(size))
+        except MemoryError:
+            dname = create_string_buffer(size.value)
+            gnutls_x509_crt_get_dn(self._c_object, dname, byref(size))
+        return X509Name(dname.value)
+
+    @property
+    def issuer(self):
+        size = c_size_t(256)
+        dname = create_string_buffer(size.value)
+        try:
+            gnutls_x509_crt_get_issuer_dn(self._c_object, dname, byref(size))
+        except MemoryError:
+            dname = create_string_buffer(size.value)
+            gnutls_x509_crt_get_issuer_dn(self._c_object, dname, byref(size))
+        return X509Name(dname.value)
+
+    @property
+    def alternative_names(self):
+        if self._alternative_names is not None:
+            return self._alternative_names
+        names = {}
+        size = c_size_t(256)
+        alt_name = create_string_buffer(size.value)
+        for i in xrange(65536):
+            try:
+                name_type = gnutls_x509_crt_get_subject_alt_name(self._c_object, i, alt_name, byref(size), None)
+            except RequestedDataNotAvailable:
+                break
+            except MemoryError:
+                alt_name = create_string_buffer(size.value)
+                name_type = gnutls_x509_crt_get_subject_alt_name(self._c_object, i, alt_name, byref(size), None)
+            names.setdefault(name_type, []).append(alt_name.value)
+        self._alternative_names = AlternativeNames(names)
+        return self._alternative_names
+
+    @property
+    def serial_number(self):
+        size = c_size_t(1)
+        serial = c_ulong()
+        try:
+            gnutls_x509_crt_get_serial(self._c_object, cast(byref(serial), c_void_p), byref(size))
+        except MemoryError:
+            import struct, sys
+            serial = create_string_buffer(size.value * sizeof(c_void_p))
+            gnutls_x509_crt_get_serial(self._c_object, cast(serial, c_void_p), byref(size))
+            pad = size.value * sizeof(c_void_p) - len(serial.value)
+            format = '@%dL' % size.value
+            numbers = list(struct.unpack(format, serial.value + pad*'\x00'))
+            if sys.byteorder == 'little':
+                numbers.reverse()
+            number = 0
+            offset = sizeof(c_void_p) * 8
+            for n in numbers:
+                number = (number<<offset) + n
+            return number
+        else:
+            return serial.value
+
+    @property
+    def activation_time(self):
+        return gnutls_x509_crt_get_activation_time(self._c_object)
+
+    @property
+    def expiration_time(self):
+        return gnutls_x509_crt_get_expiration_time(self._c_object)
+
+    @property
+    def version(self):
+        return gnutls_x509_crt_get_version(self._c_object)
+
+    #@method_args(X509Certificate)
+    def has_issuer(self, issuer):
+        """Return True if the certificate was issued by the given issuer, False otherwise."""
+        if not isinstance(issuer, X509Certificate):
+            raise TypeError("issuer must be an X509Certificate object")
+        return bool(gnutls_x509_crt_check_issuer(self._c_object, issuer._c_object))
+
+    @method_args(str)
+    def has_hostname(self, hostname):
+        """Return True if the hostname matches the DNSName/IPAddress subject alternative name extension
+           of this certificate, False otherwise."""
+        ## For details see http://www.ietf.org/rfc/rfc2459.txt, section 4.2.1.7 Subject Alternative Name
+        return bool(gnutls_x509_crt_check_hostname(self._c_object, hostname))
+
+    def check_issuer(self, issuer):
+        """Raise CertificateError if certificate was not issued by the given issuer"""
+        if not self.has_issuer(issuer):
+            raise CertificateError("certificate issuer doesn't match")
+
+    def check_hostname(self, hostname):
+        """Raise CertificateError if the certificate DNSName/IPAddress subject alternative name extension
+           doesn't match the given hostname"""
+        if not self.has_hostname(hostname):
+            raise CertificateError("certificate doesn't match hostname")
+
+
+class X509PrivateKey(object):
+    def __new__(cls, *args, **kwargs):
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_x509_privkey_deinit
+        instance._c_object = gnutls_x509_privkey_t()
+        return instance
+
+    @method_args(str, one_of(X509_FMT_PEM, X509_FMT_DER))
+    def __init__(self, buf, format=X509_FMT_PEM):
+        gnutls_x509_privkey_init(byref(self._c_object))
+        data = gnutls_datum_t(cast(c_char_p(buf), POINTER(c_ubyte)), c_uint(len(buf)))
+        gnutls_x509_privkey_import(self._c_object, byref(data), format)
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
+
+class X509Identity(object):
+    """A X509 identity represents a X509 certificate and private key pair"""
+    
+    __slots__ = ('cert', 'key')
+    
+    @method_args(X509Certificate, X509PrivateKey)
+    def __init__(self, cert, key):
+        self.cert = cert
+        self.key = key
+    
+    def __setattr__(self, name, value):
+        if name in self.__slots__ and hasattr(self, name):
+            raise AttributeError("can't set attribute")
+        object.__setattr__(self, name, value)
+
+    def __delattr__(self, name):
+        if name in self.__slots__:
+            raise AttributeError("can't delete attribute")
+        object.__delattr__(self, name)
+
+
+class X509CRL(object):
+    def __new__(cls, *args, **kwargs):
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_x509_crl_deinit
+        instance._c_object = gnutls_x509_crl_t()
+        return instance
+
+    @method_args(str, one_of(X509_FMT_PEM, X509_FMT_DER))
+    def __init__(self, buf, format=X509_FMT_PEM):
+        gnutls_x509_crl_init(byref(self._c_object))
+        data = gnutls_datum_t(cast(c_char_p(buf), POINTER(c_ubyte)), c_uint(len(buf)))
+        gnutls_x509_crl_import(self._c_object, byref(data), format)
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
+    @property
+    def count(self):
+        return gnutls_x509_crl_get_crt_count(self._c_object)
+
+    @property
+    def version(self):
+        return gnutls_x509_crl_get_version(self._c_object)
+
+    @property
+    def issuer(self):
+        size = c_size_t(256)
+        dname = create_string_buffer(size.value)
+        try:
+            gnutls_x509_crl_get_issuer_dn(self._c_object, dname, byref(size))
+        except MemoryError:
+            dname = create_string_buffer(size.value)
+            gnutls_x509_crl_get_issuer_dn(self._c_object, dname, byref(size))
+        return X509Name(dname.value)
+
+    @method_args(X509Certificate)
+    def is_revoked(self, cert):
+        """Return True if certificate is revoked, False otherwise"""
+        return bool(gnutls_x509_crt_check_revocation(cert._c_object, byref(self._c_object), 1))
+
+    def check_revocation(self, cert, cert_name='certificate'):
+        """Raise CertificateRevokedError if the given certificate is revoked"""
+        if self.is_revoked(cert):
+            raise CertificateRevokedError("%s was revoked" % cert_name)
+
+
+class DHParams(object):
+    def __new__(cls, *args, **kwargs):
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_dh_params_deinit
+        instance._c_object = gnutls_dh_params_t()
+        return instance
+
+    @method_args(int)
+    def __init__(self, bits=1024):
+        gnutls_dh_params_init(byref(self._c_object))
+        gnutls_dh_params_generate2(self._c_object, bits)
+
+    def __get__(self, obj, type_=None):
+        return self._c_object
+
+    def __set__(self, obj, value):
+        raise AttributeError("Read-only attribute")
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
+
+class RSAParams(object):
+    def __new__(cls, *args, **kwargs):
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_rsa_params_deinit
+        instance._c_object = gnutls_rsa_params_t()
+        return instance
+
+    @method_args(int)
+    def __init__(self, bits=1024):
+        gnutls_rsa_params_init(byref(self._c_object))
+        gnutls_rsa_params_generate2(self._c_object, bits)
+
+    def __get__(self, obj, type_=None):
+        return self._c_object
+
+    def __set__(self, obj, value):
+        raise AttributeError("Read-only attribute")
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/errors.py b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/errors.py
new file mode 100644
index 0000000..592ba1d
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/errors.py
@@ -0,0 +1,22 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS errors"""
+
+__all__ = ['Error', 'GNUTLSError', 'OperationWouldBlock', 'OperationInterrupted',
+           'CertificateError', 'CertificateAuthorityError', 'CertificateSecurityError',
+           'CertificateExpiredError', 'CertificateRevokedError', 'RequestedDataNotAvailable']
+
+class Error(Exception): pass
+
+class GNUTLSError(Error): pass
+class OperationWouldBlock(GNUTLSError): pass
+class OperationInterrupted(GNUTLSError): pass
+
+class CertificateError(GNUTLSError): pass
+class CertificateAuthorityError(CertificateError): pass
+class CertificateSecurityError(CertificateError): pass
+class CertificateExpiredError(CertificateError): pass
+class CertificateRevokedError(CertificateError): pass
+
+class RequestedDataNotAvailable(GNUTLSError): pass
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/interfaces/__init__.py b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/interfaces/__init__.py
new file mode 100644
index 0000000..dc64199
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/interfaces/__init__.py
@@ -0,0 +1,2 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/interfaces/twisted/__init__.py b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/interfaces/twisted/__init__.py
new file mode 100644
index 0000000..cee60bf
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/interfaces/twisted/__init__.py
@@ -0,0 +1,372 @@
+# Copyright (C) 2007-2008 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS Twisted interface"""
+
+__all__ = ['X509Credentials', 'connectTLS', 'listenTLS']
+
+import socket
+from time import time
+from errno import EWOULDBLOCK, EINTR
+
+from twisted.python import failure
+from twisted.internet import main, base, interfaces, address, tcp, error
+from twisted.internet.protocol import BaseProtocol
+
+from zope.interface import implements, implementsOnly, implementedBy
+
+from gnutls.connection import ClientSession, ServerSession, ServerSessionFactory
+from gnutls.connection import X509Credentials as _X509Credentials
+from gnutls.constants import SHUT_RDWR, SHUT_WR
+from gnutls.errors import *
+
+
+class KeepRunning:
+    """Return this class from a recurrent function to indicate that it should keep running"""
+    pass
+
+class RecurrentCall(object):
+    """Execute a function repeatedly at the given interval, until signaled to stop"""
+    def __init__(self, period, func, *args, **kwargs):
+        from twisted.internet import reactor
+        self.func = func
+        self.args = args
+        self.kwargs = kwargs
+        self.period = period
+        self.now = None
+        self.next = None
+        self.callid = reactor.callLater(period, self)
+    def __call__(self):
+        from twisted.internet import reactor
+        self.callid = None
+        if self.now is None:
+            self.now = time()
+            self.next = self.now + self.period
+        else:
+            self.now, self.next = self.next, self.next + self.period
+        result = self.func(*self.args, **self.kwargs)
+        if result is KeepRunning:
+            delay = max(self.next-time(), 0)
+            self.callid = reactor.callLater(delay, self)
+    def cancel(self):
+        if self.callid is not None:
+            try:
+                self.callid.cancel()
+            except ValueError:
+                pass
+            self.callid = None
+
+
+class CertificateOK: pass
+
+class X509Credentials(_X509Credentials):
+    """A Twisted enhanced X509Credentials"""
+    verify_peer = False
+    verify_period = None
+
+    def verify_callback(self, peer_cert, preverify_status=None):
+        """Verifies the peer certificate and raises an exception if it cannot be accepted"""
+        if isinstance(preverify_status, Exception):
+            raise preverify_status
+        self.check_certificate(peer_cert, cert_name='peer certificate')
+
+
+class TLSMixin:
+    """TLS specific functionality common to both clients and servers"""
+
+    def getPeerCertificate(self):
+        return self.socket.peer_certificate
+
+    def doRead(self):
+        try:
+            return tcp.Connection.doRead(self)
+        except (OperationWouldBlock, OperationInterrupted):
+            return
+        except GNUTLSError, e:
+            return e
+
+    def writeSomeData(self, data):
+        try:
+            return tcp.Connection.writeSomeData(self, data)
+        except OperationInterrupted:
+            return self.writeSomeData(data)
+        except OperationWouldBlock:
+            return 0
+        except GNUTLSError, e:
+            return e
+
+    def _sendCloseReason(self, reason):
+        try:
+            self.socket.send_alert(reason)
+        except OperationInterrupted:
+            self._sendCloseReason(reason)
+
+    def _sendCloseAlert(self, how=SHUT_RDWR):
+        try:
+            self.socket.bye(how)
+        except OperationInterrupted:
+            self._sendCloseAlert(how)
+
+    def closeTLSSession(self, reason):
+        try:
+            self._sendCloseReason(reason)
+            self._sendCloseAlert(SHUT_RDWR)
+        except Exception, e:
+            pass
+
+    def _postLoseConnection(self):
+        self.closeTLSSession(self._close_reason)
+        return self._close_reason
+
+    def endTLSWrite(self):
+        self.stopWriting()
+        try:
+            self._sendCloseAlert(SHUT_WR)
+        except OperationWouldBlock, e:
+            if self.socket.interrupted_while_writing:
+                self.startWriting()
+                return
+        except Exception, e:
+            return e
+        del self.doWrite
+
+    def _closeWriteConnection(self):
+        self.doWrite = self.endTLSWrite
+        result = self.endTLSWrite()
+        if isinstance(result, Exception):
+            return result
+        return tcp.Connection._closeWriteConnection(self)
+
+
+class TLSClient(TLSMixin, tcp.Client):
+    """Add TLS capabilities to a TCP client"""
+    
+    implementsOnly(interfaces.ISSLTransport, *[i for i in implementedBy(tcp.Client) if i != interfaces.ITLSTransport])
+    
+    def __init__(self, host, port, bindAddress, credentials, connector, reactor=None, server_name=None):
+        self.credentials = credentials
+        self.server_name = server_name
+        self.__watchdog = None
+        tcp.Client.__init__(self, host, port, bindAddress, connector, reactor)
+
+    def createInternetSocket(self):
+        sock = tcp.Client.createInternetSocket(self)
+        return ClientSession(sock, self.credentials, self.server_name)
+
+    def _recurrentVerify(self):
+        if not self.connected or self.disconnecting:
+            return
+        try:
+            self.credentials.verify_callback(self.socket.peer_certificate)
+        except Exception, e:
+            self.loseConnection(e)
+            return
+        else:
+            return KeepRunning
+
+    def _verifyPeer(self):
+        session = self.socket
+        credentials = self.credentials
+        if not credentials.verify_peer:
+            return
+        try:
+            session.verify_peer()
+        except Exception, e:
+            preverify_status = e
+        else:
+            preverify_status = CertificateOK
+        
+        credentials.verify_callback(session.peer_certificate, preverify_status)
+        
+        if credentials.verify_period > 0:
+            self.__watchdog = RecurrentCall(credentials.verify_period, self._recurrentVerify)
+
+    def doHandshake(self):
+        self.stopWriting()
+        try:
+            self.socket.handshake()
+        except (OperationWouldBlock, OperationInterrupted):
+            if self.socket.interrupted_while_writing:
+                self.startWriting()
+            return
+        except GNUTLSError, e:
+            del self.doRead
+            self.failIfNotConnected(err = e)
+            return
+        
+        ## reset any references to the old doRead
+        del self.doRead
+        self.stopReading()
+        
+        try:
+            self._verifyPeer()
+        except GNUTLSError, e:
+            self.closeTLSSession(e)
+            self.failIfNotConnected(err = e)
+            return
+        except Exception, e:
+            self.closeTLSSession(e)
+            self.failIfNotConnected(err = error.getConnectError(str(e)))
+            return
+        
+        ## TLS handshake (including certificate verification) finished succesfully
+        tcp.Client._connectDone(self)
+        
+    def startTLS(self):
+        self.doRead = self.doHandshake
+        self.startReading()
+        self.doHandshake()
+
+    def _connectDone(self):
+        self.startTLS()
+
+    def loseConnection(self, reason=failure.Failure(main.CONNECTION_DONE)):
+        reason = failure.Failure(reason) # accept python exceptions too
+        self._close_reason = reason.value
+        tcp.Client.loseConnection(self, reason)
+
+    def connectionLost(self, reason):
+        if self.__watchdog is not None:
+            self.__watchdog.cancel()
+            self.__watchdog = None
+        tcp.Client.connectionLost(self, reason)
+
+
+class TLSConnector(base.BaseConnector):
+    def __init__(self, host, port, factory, credentials, timeout, bindAddress, reactor=None, server_name=None):
+        self.host = host
+        self.port = port
+        self.bindAddress = bindAddress
+        self.credentials = credentials
+        self.server_name = server_name
+        base.BaseConnector.__init__(self, factory, timeout, reactor)
+
+    def _makeTransport(self):
+        return TLSClient(self.host, self.port, self.bindAddress, self.credentials, self, self.reactor, self.server_name)
+
+
+class TLSServer(TLSMixin, tcp.Server):
+    """Add TLS capabilities to a TCP server"""
+    
+    #implements(interfaces.ISSLTransport)
+    implementsOnly(interfaces.ISSLTransport, *[i for i in implementedBy(tcp.Server) if i != interfaces.ITLSTransport])
+    
+    def __init__(self, sock, protocol, client, server, sessionno, *args, **kw):
+        self.__watchdog = None
+        self.credentials = server.credentials
+        tcp.Server.__init__(self, sock, protocol, client, server, sessionno, *args, **kw)
+
+    def _recurrentVerify(self):
+        if not self.connected or self.disconnecting:
+            return
+        try:
+            self.credentials.verify_callback(self.socket.peer_certificate)
+        except Exception, e:
+            self.loseConnection(e)
+            return
+        else:
+            return KeepRunning
+
+    def _verifyPeer(self):
+        session = self.socket
+        credentials = self.credentials
+        if not credentials.verify_peer:
+            return
+        try:
+            session.verify_peer()
+        except Exception, e:
+            preverify_status = e
+        else:
+            preverify_status = CertificateOK
+        
+        credentials.verify_callback(session.peer_certificate, preverify_status)
+        
+        if credentials.verify_period > 0:
+            self.__watchdog = RecurrentCall(credentials.verify_period, self._recurrentVerify)
+
+    def doHandshake(self):
+        self.stopWriting()
+        try:
+            self.socket.handshake()
+        except (OperationWouldBlock, OperationInterrupted):
+            if self.socket.interrupted_while_writing:
+                self.startWriting()
+            return
+        except GNUTLSError, e:
+            del self.doRead
+            return e
+        
+        ## reset any references to the old doRead
+        del self.doRead
+        self.stopReading()
+        self.startReading()
+        
+        try:
+            self._verifyPeer()
+        except Exception, e:
+            self.loseConnection(e)
+            return
+        
+        ## TLS handshake (including certificate verification) finished succesfully
+        
+        del self.protocol.makeConnection
+        self.protocol.makeConnection(self)
+
+    def startTLS(self):
+        self.doRead = self.doHandshake
+        self.startReading()
+
+    def loseConnection(self, reason=failure.Failure(main.CONNECTION_DONE)):
+        reason = failure.Failure(reason) # accept python exceptions too
+        self._close_reason = reason.value
+        tcp.Server.loseConnection(self, reason)
+
+    def connectionLost(self, reason):
+        if self.__watchdog is not None:
+            self.__watchdog.cancel()
+            self.__watchdog = None
+        tcp.Server.connectionLost(self, reason)
+
+
+class TLSPort(tcp.Port):
+    """Add TLS capabilities to a TCP port"""
+
+    transport = TLSServer
+
+    def __init__(self, port, factory, credentials, backlog=50, interface='', reactor=None):
+        tcp.Port.__init__(self, port, factory, backlog, interface, reactor)
+        self.credentials = credentials
+
+    def createInternetSocket(self):
+        sock = tcp.Port.createInternetSocket(self)
+        return ServerSessionFactory(sock, self.credentials, ServerSession)
+
+    def _preMakeConnection(self, transport):
+        transport.protocol.makeConnection = lambda *args: None
+        transport.protocol.transport = transport ## because we may call connectionLost without connectionMade
+        transport.startTLS()
+        return tcp.Port._preMakeConnection(self, transport)
+
+
+def connectTLS(reactor, host, port, factory, credentials, timeout=30, bindAddress=None, server_name=None):
+    c = TLSConnector(host, port, factory, credentials, timeout, bindAddress, reactor, server_name)
+    c.connect()
+    return c
+
+
+def listenTLS(reactor, port, factory, credentials, backlog=50, interface=''):
+    p = TLSPort(port, factory, credentials, backlog, interface, reactor)
+    p.startListening()
+    return p
+
+## Add the connectTLS and listenTLS methods to the reactor
+
+import new
+from twisted.internet.posixbase import PosixReactorBase
+
+method = new.instancemethod(connectTLS, None, PosixReactorBase)
+setattr(PosixReactorBase, 'connectTLS', method)
+
+method = new.instancemethod(listenTLS, None, PosixReactorBase)
+setattr(PosixReactorBase, 'listenTLS', method)
+
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/library/__init__.py b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/library/__init__.py
new file mode 100644
index 0000000..494460f
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/library/__init__.py
@@ -0,0 +1,17 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+from gnutls.library import _gnutls_init
+from gnutls.library import constants
+from gnutls.library import types
+from gnutls.library import errors
+from gnutls.library import functions
+
+__need_version__ = '2.4.1'
+
+if functions.gnutls_check_version(__need_version__) is None:
+    version = functions.gnutls_check_version(None)
+    raise RuntimeError("Found GNUTLS library version %s, but at least version %s is required" % (version, __need_version__))
+if functions.gnutls_extra_check_version(__need_version__) is None:
+    version = functions.gnutls_extra_check_version(None)
+    raise RuntimeError("Found GNUTLS extra library version %s, but at least version %s is required" % (version, __need_version__))
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/library/_gnutls_init.so b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/library/_gnutls_init.so
new file mode 100755
index 0000000..b89dc90
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/library/_gnutls_init.so
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/library/constants.py b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/library/constants.py
new file mode 100644
index 0000000..43c82d3
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/library/constants.py
@@ -0,0 +1,648 @@
+from ctypes import *
+
+STRING = c_char_p
+
+
+GNUTLS_CRD_IA = 5
+GNUTLS_CERT_REQUIRE = 2
+GNUTLS_PKCS_USE_PKCS12_3DES = 2
+GNUTLS_CRD_CERTIFICATE = 1
+GNUTLS_HANDSHAKE_SERVER_HELLO_DONE = 14
+GNUTLS_SIGN_RSA_RMD160 = 5
+GNUTLS_PKCS_PLAIN = 1
+GNUTLS_A_UNKNOWN_CA = 48
+GNUTLS_CRT_PRINT_ONELINE = 1
+GNUTLS_PKCS_USE_PKCS12_ARCFOUR = 4
+GNUTLS_A_UNKNOWN_PSK_IDENTITY = 115
+GNUTLS_CRT_X509 = 1
+GNUTLS_KX_DHE_PSK = 10
+GNUTLS_PARAMS_RSA_EXPORT = 1
+GNUTLS_DIG_NULL = 1
+GNUTLS_KX_PSK = 9
+GNUTLS_CIPHER_RC2_40_CBC = 90
+GNUTLS_AL_WARNING = 1
+GNUTLS_DIG_SHA256 = 6
+GNUTLS_CERT_INSECURE_ALGORITHM = 256
+GNUTLS_SIGN_RSA_MD2 = 4
+GNUTLS_CRT_PRINT_UNSIGNED_FULL = 2
+GNUTLS_PK_DSA = 2
+GNUTLS_A_UNRECOGNIZED_NAME = 112
+GNUTLS_A_INNER_APPLICATION_FAILURE = 208
+GNUTLS_VERIFY_DO_NOT_ALLOW_SAME = 4
+GNUTLS_CIPHER_AES_128_CBC = 4
+GNUTLS_CRT_PRINT_FULL = 0
+GNUTLS_PKCS_USE_PBES2_3DES = 16
+GNUTLS_SSL3 = 1
+GNUTLS_SAN_OTHERNAME_XMPP = 1000
+GNUTLS_DIG_SHA384 = 7
+GNUTLS_MAC_UNKNOWN = 0
+GNUTLS_A_CERTIFICATE_UNOBTAINABLE = 111
+GNUTLS_OPENPGP_CERT_FINGERPRINT = 1
+GNUTLS_SIGN_RSA_SHA512 = 8
+GNUTLS_A_DECRYPT_ERROR = 51
+GNUTLS_SAN_DN = 6
+GNUTLS_SAN_DNSNAME = 1
+GNUTLS_CRT_UNKNOWN = 0
+GNUTLS_SERVER = 1
+GNUTLS_CIPHER_NULL = 1
+GNUTLS_CIPHER_DES_CBC = 91
+GNUTLS_A_USER_CANCELED = 90
+GNUTLS_TLS1_1 = 3
+GNUTLS_CRT_OPENPGP = 2
+GNUTLS_SHUT_WR = 1
+GNUTLS_KX_ANON_DH = 4
+GNUTLS_A_EXPORT_RESTRICTION = 60
+GNUTLS_HANDSHAKE_FINISHED = 20
+GNUTLS_KX_UNKNOWN = 0
+GNUTLS_MAC_NULL = 1
+GNUTLS_SAN_IPADDRESS = 4
+GNUTLS_HANDSHAKE_CLIENT_HELLO = 1
+GNUTLS_CRD_ANON = 2
+GNUTLS_SHUT_RDWR = 0
+GNUTLS_A_SSL3_NO_CERTIFICATE = 41
+GNUTLS_COMP_NULL = 1
+GNUTLS_TLS1_2 = 4
+GNUTLS_IA_APPLICATION_PAYLOAD = 0
+GNUTLS_SIGN_RSA_SHA224 = 9
+GNUTLS_HANDSHAKE_CERTIFICATE_PKT = 11
+GNUTLS_DIG_MD2 = 5
+GNUTLS_PK_RSA = 1
+GNUTLS_CIPHER_CAMELLIA_256_CBC = 8
+GNUTLS_HANDSHAKE_SUPPLEMENTAL = 23
+GNUTLS_SIGN_UNKNOWN = 0
+GNUTLS_PARAMS_DH = 2
+GNUTLS_PK_UNKNOWN = 0
+GNUTLS_A_INSUFFICIENT_SECURITY = 71
+GNUTLS_DIG_SHA512 = 8
+GNUTLS_SUPPLEMENTAL_USER_MAPPING_DATA = 0
+GNUTLS_KX_RSA = 1
+GNUTLS_SIGN_RSA_SHA384 = 7
+GNUTLS_A_RECORD_OVERFLOW = 22
+GNUTLS_KX_DHE_RSA = 3
+GNUTLS_COMP_LZO = 3
+GNUTLS_CERT_IGNORE = 0
+GNUTLS_SIGN_RSA_SHA1 = 1
+GNUTLS_A_ILLEGAL_PARAMETER = 47
+GNUTLS_A_NO_RENEGOTIATION = 100
+GNUTLS_A_PROTOCOL_VERSION = 70
+GNUTLS_A_DECOMPRESSION_FAILURE = 30
+GNUTLS_A_CERTIFICATE_REVOKED = 44
+GNUTLS_CIPHER_AES_256_CBC = 5
+GNUTLS_A_INTERNAL_ERROR = 80
+GNUTLS_HANDSHAKE_HELLO_REQUEST = 0
+GNUTLS_X509_FMT_DER = 0
+GNUTLS_HANDSHAKE_CERTIFICATE_REQUEST = 13
+GNUTLS_HANDSHAKE_SERVER_HELLO = 2
+GNUTLS_A_HANDSHAKE_FAILURE = 40
+GNUTLS_DIG_MD5 = 2
+GNUTLS_SIGN_RSA_MD5 = 3
+GNUTLS_MAC_SHA256 = 6
+GNUTLS_OPENPGP_CERT = 0
+GNUTLS_CERT_SIGNER_NOT_CA = 128
+GNUTLS_AL_FATAL = 2
+GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD2 = 16
+GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT = 2
+GNUTLS_CIPHER_3DES_CBC = 3
+GNUTLS_A_DECRYPTION_FAILED = 21
+GNUTLS_HANDSHAKE_CLIENT_KEY_EXCHANGE = 16
+GNUTLS_SAN_RFC822NAME = 2
+GNUTLS_CRD_PSK = 4
+GNUTLS_OPENPGP_FMT_RAW = 0
+GNUTLS_CERT_SIGNER_NOT_FOUND = 64
+GNUTLS_A_UNSUPPORTED_EXTENSION = 110
+GNUTLS_DIG_SHA1 = 3
+GNUTLS_DIG_RMD160 = 4
+GNUTLS_A_CLOSE_NOTIFY = 0
+GNUTLS_KX_SRP_RSA = 7
+GNUTLS_MAC_MD5 = 2
+GNUTLS_IA_FINAL_PHASE_FINISHED = 2
+GNUTLS_A_UNSUPPORTED_CERTIFICATE = 43
+GNUTLS_COMP_UNKNOWN = 0
+GNUTLS_PKCS_USE_PKCS12_RC2_40 = 8
+GNUTLS_CIPHER_UNKNOWN = 0
+GNUTLS_PSK_KEY_HEX = 1
+GNUTLS_KX_SRP_DSS = 8
+GNUTLS_MAC_SHA384 = 7
+GNUTLS_SAN_URI = 3
+GNUTLS_X509_FMT_PEM = 1
+GNUTLS_X509_CRT_LIST_IMPORT_FAIL_IF_EXCEED = 1
+GNUTLS_HANDSHAKE_CERTIFICATE_VERIFY = 15
+GNUTLS_A_DECODE_ERROR = 50
+GNUTLS_MAC_SHA1 = 3
+GNUTLS_HANDSHAKE_SERVER_KEY_EXCHANGE = 12
+GNUTLS_IA_INTERMEDIATE_PHASE_FINISHED = 1
+GNUTLS_A_CERTIFICATE_UNKNOWN = 46
+GNUTLS_OPENPGP_FMT_BASE64 = 1
+GNUTLS_CLIENT = 2
+GNUTLS_PSK_KEY_RAW = 0
+GNUTLS_A_UNEXPECTED_MESSAGE = 10
+GNUTLS_CERT_INVALID = 2
+GNUTLS_CRD_SRP = 3
+GNUTLS_A_BAD_RECORD_MAC = 20
+GNUTLS_MAC_RMD160 = 4
+GNUTLS_DIG_SHA224 = 9
+GNUTLS_TLS1_0 = 2
+GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD5 = 32
+GNUTLS_KX_SRP = 5
+GNUTLS_A_CERTIFICATE_EXPIRED = 45
+GNUTLS_MAC_MD2 = 5
+GNUTLS_VERIFY_ALLOW_ANY_X509_V1_CA_CRT = 8
+GNUTLS_A_ACCESS_DENIED = 49
+GNUTLS_VERIFY_DISABLE_CA_SIGN = 1
+GNUTLS_CIPHER_ARCFOUR_40 = 6
+GNUTLS_A_BAD_CERTIFICATE = 42
+GNUTLS_CERT_REVOKED = 32
+GNUTLS_CERT_REQUEST = 1
+GNUTLS_MAC_SHA512 = 8
+GNUTLS_SAN_OTHERNAME = 5
+GNUTLS_VERSION_UNKNOWN = 255
+GNUTLS_KX_RSA_EXPORT = 6
+GNUTLS_CIPHER_CAMELLIA_128_CBC = 7
+GNUTLS_COMP_DEFLATE = 2
+GNUTLS_NAME_DNS = 1
+GNUTLS_SIGN_DSA_SHA1 = 2
+GNUTLS_A_INNER_APPLICATION_VERIFICATION = 209
+GNUTLS_CIPHER_ARCFOUR_128 = 2
+GNUTLS_KX_DHE_DSS = 2
+GNUTLS_SIGN_RSA_SHA256 = 6
+GNUTLS_E_UNKNOWN_PK_ALGORITHM = -80 # Variable c_int
+TLS_MASTER_SIZE = 48 # Variable c_int
+LIBGNUTLS_VERSION_NUMBER = 132097 # Variable c_int
+GNUTLS_E_FATAL_ALERT_RECEIVED = -12 # Variable c_int
+GNUTLS_E_LARGE_PACKET = -7 # Variable c_int
+GNUTLS_E_ASN1_DER_OVERFLOW = -77 # Variable c_int
+GNUTLS_E_INCOMPATIBLE_LIBTASN1_LIBRARY = -203 # Variable c_int
+GNUTLS_E_SHORT_MEMORY_BUFFER = -51 # Variable c_int
+GNUTLS_E_UNKNOWN_ALGORITHM = -105 # Variable c_int
+GNUTLS_MAX_SESSION_ID = 32 # Variable c_int
+GNUTLS_E_OPENPGP_GETKEY_FAILED = -88 # Variable c_int
+GNUTLS_E_REHANDSHAKE = -37 # Variable c_int
+GNUTLS_E_ASN1_VALUE_NOT_FOUND = -70 # Variable c_int
+GNUTLS_E_SUCCESS = 0 # Variable c_int
+GNUTLS_E_ASN1_SYNTAX_ERROR = -76 # Variable c_int
+GNUTLS_OID_PKIX_COUNTRY_OF_RESIDENCE = '1.3.6.1.5.5.7.9.5' # Variable STRING
+GNUTLS_E_RECORD_LIMIT_REACHED = -39 # Variable c_int
+GNUTLS_E_WARNING_IA_FPHF_RECEIVED = -103 # Variable c_int
+GNUTLS_OID_X520_DN_QUALIFIER = '2.5.4.46' # Variable STRING
+GNUTLS_OID_X520_GIVEN_NAME = '2.5.4.42' # Variable STRING
+LIBGNUTLS_VERSION_MINOR = 4 # Variable c_int
+GNUTLS_E_ASN1_ELEMENT_NOT_FOUND = -67 # Variable c_int
+GNUTLS_E_CRYPTO_ALREADY_REGISTERED = -209 # Variable c_int
+GNUTLS_E_KEY_USAGE_VIOLATION = -48 # Variable c_int
+GNUTLS_E_WARNING_IA_IPHF_RECEIVED = -102 # Variable c_int
+GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM = -3 # Variable c_int
+GNUTLS_E_PK_DECRYPTION_FAILED = -45 # Variable c_int
+GNUTLS_CRL_REASON_CA_COMPROMISE = 32 # Variable c_int
+GNUTLS_E_UNKNOWN_PKCS_BAG_TYPE = -98 # Variable c_int
+GNUTLS_E_DECRYPTION_FAILED = -24 # Variable c_int
+GNUTLS_E_UNKNOWN_PKCS_CONTENT_TYPE = -97 # Variable c_int
+GNUTLS_KP_OCSP_SIGNING = '1.3.6.1.5.5.7.3.9' # Variable STRING
+GNUTLS_E_PK_SIGN_FAILED = -46 # Variable c_int
+GNUTLS_E_ASN1_TAG_IMPLICIT = -74 # Variable c_int
+GNUTLS_E_INIT_LIBEXTRA = -82 # Variable c_int
+GNUTLS_KP_TLS_WWW_SERVER = '1.3.6.1.5.5.7.3.1' # Variable STRING
+GNUTLS_E_OPENPGP_KEYRING_ERROR = -204 # Variable c_int
+GNUTLS_E_MEMORY_ERROR = -25 # Variable c_int
+GNUTLS_E_MAC_VERIFY_FAILED = -100 # Variable c_int
+GNUTLS_E_NO_TEMPORARY_DH_PARAMS = -93 # Variable c_int
+GNUTLS_KEY_NON_REPUDIATION = 64 # Variable c_int
+GNUTLS_MAX_ALGORITHM_NUM = 16 # Variable c_int
+GNUTLS_OID_X520_COUNTRY_NAME = '2.5.4.6' # Variable STRING
+GNUTLS_E_WARNING_ALERT_RECEIVED = -16 # Variable c_int
+GNUTLS_E_OPENPGP_UID_REVOKED = -79 # Variable c_int
+GNUTLS_E_PUSH_ERROR = -53 # Variable c_int
+GNUTLS_KEY_KEY_CERT_SIGN = 4 # Variable c_int
+GNUTLS_E_GOT_APPLICATION_DATA = -38 # Variable c_int
+GNUTLS_E_BASE64_DECODING_ERROR = -34 # Variable c_int
+GNUTLS_E_PULL_ERROR = -54 # Variable c_int
+GNUTLS_E_COMPRESSION_FAILED = -27 # Variable c_int
+GNUTLS_E_ASN1_DER_ERROR = -69 # Variable c_int
+GNUTLS_KEY_DECIPHER_ONLY = 32768 # Variable c_int
+GNUTLS_E_DECOMPRESSION_FAILED = -26 # Variable c_int
+LIBGNUTLS_VERSION_MAJOR = 2 # Variable c_int
+GNUTLS_E_NO_CIPHER_SUITES = -87 # Variable c_int
+GNUTLS_KEY_KEY_ENCIPHERMENT = 32 # Variable c_int
+GNUTLS_E_BASE64_UNEXPECTED_HEADER_ERROR = -207 # Variable c_int
+GNUTLS_E_ASN1_TYPE_ANY_ERROR = -75 # Variable c_int
+GNUTLS_OID_LDAP_UID = '0.9.2342.19200300.100.1.1' # Variable STRING
+GNUTLS_KEY_DATA_ENCIPHERMENT = 16 # Variable c_int
+GNUTLS_E_X509_UNSUPPORTED_OID = -205 # Variable c_int
+GNUTLS_E_NO_CERTIFICATE_FOUND = -49 # Variable c_int
+GNUTLS_E_UNIMPLEMENTED_FEATURE = -1250 # Variable c_int
+GNUTLS_E_UNSUPPORTED_VERSION_PACKET = -8 # Variable c_int
+GNUTLS_E_FILE_ERROR = -64 # Variable c_int
+GNUTLS_CRL_REASON_PRIVILEGE_WITHDRAWN = 1 # Variable c_int
+LIBGNUTLS_VERSION = '2.4.1' # Variable STRING
+GNUTLS_CRL_REASON_AFFILIATION_CHANGED = 16 # Variable c_int
+GNUTLS_OID_X520_ORGANIZATIONAL_UNIT_NAME = '2.5.4.11' # Variable STRING
+GNUTLS_OID_X520_COMMON_NAME = '2.5.4.3' # Variable STRING
+GNUTLS_E_HASH_FAILED = -33 # Variable c_int
+GNUTLS_E_PKCS1_WRONG_PAD = -57 # Variable c_int
+GNUTLS_OID_X520_GENERATION_QUALIFIER = '2.5.4.44' # Variable STRING
+GNUTLS_E_INCOMPATIBLE_CRYPTO_LIBRARY = -202 # Variable c_int
+GNUTLS_E_X509_UNSUPPORTED_CRITICAL_EXTENSION = -47 # Variable c_int
+GNUTLS_OID_X520_PSEUDONYM = '2.5.4.65' # Variable STRING
+GNUTLS_E_NO_COMPRESSION_ALGORITHMS = -86 # Variable c_int
+GNUTLS_E_UNEXPECTED_PACKET_LENGTH = -9 # Variable c_int
+GNUTLS_E_INCOMPATIBLE_GCRYPT_LIBRARY = -202 # Variable c_int
+GNUTLS_E_MPI_PRINT_FAILED = -35 # Variable c_int
+GNUTLS_E_INVALID_PASSWORD = -99 # Variable c_int
+GNUTLS_E_CERTIFICATE_KEY_MISMATCH = -60 # Variable c_int
+GNUTLS_OID_X520_STATE_OR_PROVINCE_NAME = '2.5.4.8' # Variable STRING
+GNUTLS_E_INSUFFICIENT_CREDENTIALS = -32 # Variable c_int
+GNUTLS_OID_X520_SURNAME = '2.5.4.4' # Variable STRING
+GNUTLS_E_X509_UNKNOWN_SAN = -62 # Variable c_int
+GNUTLS_KEY_CRL_SIGN = 2 # Variable c_int
+GNUTLS_E_PK_SIG_VERIFY_FAILED = -89 # Variable c_int
+GNUTLS_E_BASE64_ENCODING_ERROR = -201 # Variable c_int
+GNUTLS_E_ASN1_VALUE_NOT_VALID = -72 # Variable c_int
+GNUTLS_OID_X520_TITLE = '2.5.4.12' # Variable STRING
+GNUTLS_E_ENCRYPTION_FAILED = -40 # Variable c_int
+GNUTLS_OID_PKCS9_EMAIL = '1.2.840.113549.1.9.1' # Variable STRING
+GNUTLS_KP_ANY = '2.5.29.37.0' # Variable STRING
+GNUTLS_CRL_REASON_UNUSED = 128 # Variable c_int
+GNUTLS_E_OPENPGP_SUBKEY_ERROR = -208 # Variable c_int
+GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER = -55 # Variable c_int
+GNUTLS_E_EXPIRED = -29 # Variable c_int
+GNUTLS_E_DB_ERROR = -30 # Variable c_int
+GNUTLS_E_UNWANTED_ALGORITHM = -22 # Variable c_int
+GNUTLS_OID_PKIX_COUNTRY_OF_CITIZENSHIP = '1.3.6.1.5.5.7.9.4' # Variable STRING
+GNUTLS_E_APPLICATION_ERROR_MIN = -65500 # Variable c_int
+GNUTLS_E_INVALID_REQUEST = -50 # Variable c_int
+GNUTLS_E_ASN1_IDENTIFIER_NOT_FOUND = -68 # Variable c_int
+GNUTLS_OID_X520_INITIALS = '2.5.4.43' # Variable STRING
+GNUTLS_E_ASN1_TAG_ERROR = -73 # Variable c_int
+GNUTLS_E_X509_UNSUPPORTED_ATTRIBUTE = -95 # Variable c_int
+GNUTLS_KP_EMAIL_PROTECTION = '1.3.6.1.5.5.7.3.4' # Variable STRING
+GNUTLS_CRL_REASON_CESSATION_OF_OPERATION = 4 # Variable c_int
+GNUTLS_E_IA_VERIFY_FAILED = -104 # Variable c_int
+GNUTLS_KP_TIME_STAMPING = '1.3.6.1.5.5.7.3.8' # Variable STRING
+GNUTLS_E_INTERNAL_ERROR = -59 # Variable c_int
+GNUTLS_E_LZO_INIT_FAILED = -85 # Variable c_int
+GNUTLS_CRL_REASON_CERTIFICATE_HOLD = 2 # Variable c_int
+GNUTLS_OID_X520_ORGANIZATION_NAME = '2.5.4.10' # Variable STRING
+GNUTLS_CRL_REASON_KEY_COMPROMISE = 64 # Variable c_int
+GNUTLS_OID_PKIX_GENDER = '1.3.6.1.5.5.7.9.3' # Variable STRING
+GNUTLS_E_APPLICATION_ERROR_MAX = -65000 # Variable c_int
+GNUTLS_E_SRP_PWD_PARSING_ERROR = -91 # Variable c_int
+GNUTLS_E_NO_TEMPORARY_RSA_PARAMS = -84 # Variable c_int
+GNUTLS_OID_PKIX_PLACE_OF_BIRTH = '1.3.6.1.5.5.7.9.2' # Variable STRING
+GNUTLS_E_LIBRARY_VERSION_MISMATCH = -83 # Variable c_int
+GNUTLS_KEY_DIGITAL_SIGNATURE = 128 # Variable c_int
+GNUTLS_E_UNEXPECTED_HANDSHAKE_PACKET = -19 # Variable c_int
+GNUTLS_E_ASN1_GENERIC_ERROR = -71 # Variable c_int
+GNUTLS_E_ILLEGAL_SRP_USERNAME = -90 # Variable c_int
+_GNUTLS_GCC_VERSION = 40301 # Variable c_int
+GNUTLS_E_AGAIN = -28 # Variable c_int
+GNUTLS_E_DH_PRIME_UNACCEPTABLE = -63 # Variable c_int
+GNUTLS_E_UNSUPPORTED_CERTIFICATE_TYPE = -61 # Variable c_int
+GNUTLS_E_UNKNOWN_CIPHER_SUITE = -21 # Variable c_int
+GNUTLS_E_CONSTRAINT_ERROR = -101 # Variable c_int
+GNUTLS_E_UNEXPECTED_PACKET = -15 # Variable c_int
+TLS_RANDOM_SIZE = 32 # Variable c_int
+LIBGNUTLS_VERSION_PATCH = 1 # Variable c_int
+GNUTLS_E_RECEIVED_ILLEGAL_EXTENSION = -58 # Variable c_int
+GNUTLS_E_INVALID_SESSION = -10 # Variable c_int
+GNUTLS_KEY_KEY_AGREEMENT = 8 # Variable c_int
+GNUTLS_E_ERROR_IN_FINISHED_PACKET = -18 # Variable c_int
+GNUTLS_KEY_ENCIPHER_ONLY = 1 # Variable c_int
+GNUTLS_E_UNKNOWN_CIPHER_TYPE = -6 # Variable c_int
+GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE = -56 # Variable c_int
+GNUTLS_CRL_REASON_AA_COMPROMISE = 32768 # Variable c_int
+GNUTLS_E_CERTIFICATE_ERROR = -43 # Variable c_int
+GNUTLS_E_TOO_MANY_EMPTY_PACKETS = -78 # Variable c_int
+GNUTLS_OID_PKIX_DATE_OF_BIRTH = '1.3.6.1.5.5.7.9.1' # Variable STRING
+GNUTLS_E_PK_ENCRYPTION_FAILED = -44 # Variable c_int
+GNUTLS_OID_LDAP_DC = '0.9.2342.19200300.100.1.25' # Variable STRING
+GNUTLS_KP_TLS_WWW_CLIENT = '1.3.6.1.5.5.7.3.2' # Variable STRING
+GNUTLS_E_MPI_SCAN_FAILED = -23 # Variable c_int
+GNUTLS_E_OPENPGP_FINGERPRINT_UNSUPPORTED = -94 # Variable c_int
+GNUTLS_E_SRP_PWD_ERROR = -31 # Variable c_int
+GNUTLS_CRL_REASON_SUPERSEEDED = 8 # Variable c_int
+GNUTLS_E_INTERRUPTED = -52 # Variable c_int
+GNUTLS_OID_X520_LOCALITY_NAME = '2.5.4.7' # Variable STRING
+GNUTLS_E_UNKNOWN_HASH_ALGORITHM = -96 # Variable c_int
+GNUTLS_E_RANDOM_FAILED = -206 # Variable c_int
+GNUTLS_E_HANDSHAKE_TOO_LARGE = -210 # Variable c_int
+GNUTLS_KP_CODE_SIGNING = '1.3.6.1.5.5.7.3.3' # Variable STRING
+
+# values for enumeration 'gnutls_ia_apptype_t'
+gnutls_ia_apptype_t = c_int # enum
+
+# values for enumeration 'gnutls_cipher_algorithm_t'
+gnutls_cipher_algorithm_t = c_int # enum
+
+# values for enumeration 'gnutls_kx_algorithm_t'
+gnutls_kx_algorithm_t = c_int # enum
+
+# values for enumeration 'gnutls_params_type_t'
+gnutls_params_type_t = c_int # enum
+
+# values for enumeration 'gnutls_credentials_type_t'
+gnutls_credentials_type_t = c_int # enum
+
+# values for enumeration 'gnutls_mac_algorithm_t'
+gnutls_mac_algorithm_t = c_int # enum
+
+# values for enumeration 'gnutls_digest_algorithm_t'
+gnutls_digest_algorithm_t = c_int # enum
+
+# values for enumeration 'gnutls_compression_method_t'
+gnutls_compression_method_t = c_int # enum
+
+# values for enumeration 'gnutls_connection_end_t'
+gnutls_connection_end_t = c_int # enum
+
+# values for enumeration 'gnutls_alert_level_t'
+gnutls_alert_level_t = c_int # enum
+
+# values for enumeration 'gnutls_alert_description_t'
+gnutls_alert_description_t = c_int # enum
+
+# values for enumeration 'gnutls_handshake_description_t'
+gnutls_handshake_description_t = c_int # enum
+
+# values for enumeration 'gnutls_certificate_status_t'
+gnutls_certificate_status_t = c_int # enum
+
+# values for enumeration 'gnutls_certificate_request_t'
+gnutls_certificate_request_t = c_int # enum
+
+# values for enumeration 'gnutls_openpgp_crt_status_t'
+gnutls_openpgp_crt_status_t = c_int # enum
+
+# values for enumeration 'gnutls_close_request_t'
+gnutls_close_request_t = c_int # enum
+
+# values for enumeration 'gnutls_protocol_t'
+gnutls_protocol_t = c_int # enum
+
+# values for enumeration 'gnutls_certificate_type_t'
+gnutls_certificate_type_t = c_int # enum
+
+# values for enumeration 'gnutls_x509_crt_fmt_t'
+gnutls_x509_crt_fmt_t = c_int # enum
+
+# values for enumeration 'gnutls_certificate_print_formats'
+gnutls_certificate_print_formats = c_int # enum
+
+# values for enumeration 'gnutls_pk_algorithm_t'
+gnutls_pk_algorithm_t = c_int # enum
+
+# values for enumeration 'gnutls_sign_algorithm_t'
+gnutls_sign_algorithm_t = c_int # enum
+
+# values for enumeration 'gnutls_server_name_type_t'
+gnutls_server_name_type_t = c_int # enum
+
+# values for enumeration 'gnutls_supplemental_data_format_type_t'
+gnutls_supplemental_data_format_type_t = c_int # enum
+
+# values for enumeration 'gnutls_psk_key_flags'
+gnutls_psk_key_flags = c_int # enum
+
+# values for enumeration 'gnutls_x509_subject_alt_name_t'
+gnutls_x509_subject_alt_name_t = c_int # enum
+
+# values for enumeration 'gnutls_openpgp_crt_fmt'
+gnutls_openpgp_crt_fmt = c_int # enum
+
+# values for enumeration 'gnutls_certificate_import_flags'
+gnutls_certificate_import_flags = c_int # enum
+
+# values for enumeration 'gnutls_certificate_verify_flags'
+gnutls_certificate_verify_flags = c_int # enum
+
+# values for enumeration 'gnutls_pkcs_encrypt_flags_t'
+gnutls_pkcs_encrypt_flags_t = c_int # enum
+__all__ = ['GNUTLS_PKCS_USE_PKCS12_ARCFOUR',
+           'GNUTLS_HANDSHAKE_CLIENT_HELLO',
+           'GNUTLS_E_ASN1_DER_OVERFLOW',
+           'GNUTLS_CERT_INSECURE_ALGORITHM',
+           'GNUTLS_E_WARNING_ALERT_RECEIVED',
+           'GNUTLS_E_OPENPGP_GETKEY_FAILED', 'GNUTLS_KX_UNKNOWN',
+           'GNUTLS_E_SUCCESS', 'GNUTLS_CRT_PRINT_UNSIGNED_FULL',
+           'GNUTLS_DIG_NULL', 'GNUTLS_E_ASN1_IDENTIFIER_NOT_FOUND',
+           'GNUTLS_CIPHER_UNKNOWN', 'GNUTLS_KX_SRP_DSS',
+           'GNUTLS_A_UNSUPPORTED_EXTENSION',
+           'GNUTLS_E_WARNING_IA_IPHF_RECEIVED',
+           'GNUTLS_CRL_REASON_CA_COMPROMISE',
+           'GNUTLS_E_LZO_INIT_FAILED', 'gnutls_pkcs_encrypt_flags_t',
+           'GNUTLS_PKCS_USE_PKCS12_RC2_40',
+           'GNUTLS_A_CERTIFICATE_UNKNOWN',
+           'GNUTLS_E_MAC_VERIFY_FAILED', 'GNUTLS_OPENPGP_CERT',
+           'GNUTLS_E_NO_TEMPORARY_DH_PARAMS',
+           'GNUTLS_E_OPENPGP_UID_REVOKED', 'GNUTLS_KX_DHE_RSA',
+           'GNUTLS_E_PUSH_ERROR', 'GNUTLS_CRT_OPENPGP',
+           'GNUTLS_E_PULL_ERROR', 'GNUTLS_E_CONSTRAINT_ERROR',
+           'GNUTLS_KEY_DECIPHER_ONLY',
+           'GNUTLS_HANDSHAKE_HELLO_REQUEST',
+           'gnutls_certificate_verify_flags', 'GNUTLS_E_FILE_ERROR',
+           'GNUTLS_E_ASN1_TYPE_ANY_ERROR', 'GNUTLS_CERT_REVOKED',
+           'GNUTLS_E_NO_CERTIFICATE_FOUND', 'GNUTLS_SIGN_RSA_MD5',
+           'GNUTLS_E_DECOMPRESSION_FAILED', 'GNUTLS_DIG_MD5',
+           'GNUTLS_DIG_MD2', 'GNUTLS_A_HANDSHAKE_FAILURE',
+           'GNUTLS_E_ASN1_VALUE_NOT_FOUND',
+           'GNUTLS_VERIFY_ALLOW_ANY_X509_V1_CA_CRT',
+           'GNUTLS_E_PKCS1_WRONG_PAD', 'gnutls_params_type_t',
+           'GNUTLS_E_BASE64_DECODING_ERROR',
+           'GNUTLS_CIPHER_ARCFOUR_128', 'GNUTLS_X509_FMT_PEM',
+           'GNUTLS_E_CERTIFICATE_KEY_MISMATCH',
+           'GNUTLS_SIGN_RSA_SHA1', 'GNUTLS_DIG_SHA256',
+           'GNUTLS_HANDSHAKE_CERTIFICATE_REQUEST',
+           'LIBGNUTLS_VERSION', 'GNUTLS_OID_X520_TITLE',
+           'GNUTLS_MAC_SHA256', 'GNUTLS_E_DB_ERROR',
+           'GNUTLS_OID_PKIX_COUNTRY_OF_CITIZENSHIP',
+           'GNUTLS_SIGN_UNKNOWN', 'GNUTLS_DIG_SHA512',
+           'gnutls_x509_subject_alt_name_t', 'GNUTLS_AL_FATAL',
+           'GNUTLS_E_IA_VERIFY_FAILED', 'gnutls_certificate_type_t',
+           'GNUTLS_MAC_RMD160', 'GNUTLS_SIGN_RSA_SHA256',
+           'GNUTLS_CRT_PRINT_FULL',
+           'GNUTLS_E_LIBRARY_VERSION_MISMATCH',
+           'gnutls_pk_algorithm_t', 'GNUTLS_HANDSHAKE_SUPPLEMENTAL',
+           'GNUTLS_A_UNEXPECTED_MESSAGE',
+           'GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD5',
+           'GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD2',
+           'GNUTLS_E_UNEXPECTED_PACKET', 'GNUTLS_A_UNKNOWN_CA',
+           'gnutls_certificate_import_flags',
+           'LIBGNUTLS_VERSION_PATCH',
+           'GNUTLS_E_RECEIVED_ILLEGAL_EXTENSION',
+           'GNUTLS_SIGN_RSA_SHA512', 'GNUTLS_PKCS_USE_PBES2_3DES',
+           'GNUTLS_KEY_KEY_AGREEMENT',
+           'GNUTLS_E_DH_PRIME_UNACCEPTABLE',
+           'GNUTLS_E_INCOMPATIBLE_GCRYPT_LIBRARY',
+           'gnutls_cipher_algorithm_t',
+           'GNUTLS_IA_FINAL_PHASE_FINISHED', 'GNUTLS_SAN_DNSNAME',
+           'GNUTLS_E_PK_ENCRYPTION_FAILED',
+           'GNUTLS_E_MPI_SCAN_FAILED',
+           'GNUTLS_X509_CRT_LIST_IMPORT_FAIL_IF_EXCEED',
+           'GNUTLS_E_SRP_PWD_ERROR', 'gnutls_mac_algorithm_t',
+           'GNUTLS_PARAMS_RSA_EXPORT', 'GNUTLS_PSK_KEY_RAW',
+           'GNUTLS_E_UNKNOWN_HASH_ALGORITHM',
+           'GNUTLS_E_RANDOM_FAILED', 'GNUTLS_E_HANDSHAKE_TOO_LARGE',
+           'GNUTLS_A_NO_RENEGOTIATION', 'TLS_MASTER_SIZE',
+           'GNUTLS_E_FATAL_ALERT_RECEIVED', 'GNUTLS_E_LARGE_PACKET',
+           'GNUTLS_MAX_SESSION_ID',
+           'GNUTLS_A_INNER_APPLICATION_FAILURE',
+           'GNUTLS_E_RECORD_LIMIT_REACHED',
+           'GNUTLS_E_ASN1_ELEMENT_NOT_FOUND',
+           'GNUTLS_HANDSHAKE_CERTIFICATE_PKT',
+           'GNUTLS_A_INSUFFICIENT_SECURITY',
+           'GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM',
+           'GNUTLS_A_DECODE_ERROR',
+           'GNUTLS_A_INNER_APPLICATION_VERIFICATION',
+           'GNUTLS_E_UNKNOWN_PKCS_CONTENT_TYPE', 'GNUTLS_PK_RSA',
+           'GNUTLS_CRD_CERTIFICATE', 'GNUTLS_MAC_MD5',
+           'GNUTLS_MAC_MD2', 'GNUTLS_E_ASN1_TAG_IMPLICIT',
+           'GNUTLS_E_OPENPGP_KEYRING_ERROR', 'GNUTLS_SAN_OTHERNAME',
+           'GNUTLS_SAN_IPADDRESS', 'gnutls_compression_method_t',
+           'GNUTLS_SAN_DN', 'GNUTLS_COMP_NULL',
+           'GNUTLS_A_CERTIFICATE_EXPIRED',
+           'GNUTLS_OPENPGP_CERT_FINGERPRINT',
+           'GNUTLS_KEY_DATA_ENCIPHERMENT', 'GNUTLS_X509_FMT_DER',
+           'GNUTLS_CIPHER_AES_256_CBC', 'gnutls_sign_algorithm_t',
+           'GNUTLS_CRL_REASON_PRIVILEGE_WITHDRAWN', 'GNUTLS_SHUT_WR',
+           'GNUTLS_KX_DHE_PSK', 'GNUTLS_CLIENT', 'GNUTLS_DIG_SHA384',
+           'GNUTLS_E_X509_UNSUPPORTED_CRITICAL_EXTENSION',
+           'GNUTLS_E_UNKNOWN_CIPHER_TYPE',
+           'GNUTLS_E_MPI_PRINT_FAILED', 'GNUTLS_E_INVALID_PASSWORD',
+           'GNUTLS_CIPHER_3DES_CBC', 'gnutls_credentials_type_t',
+           'GNUTLS_SIGN_DSA_SHA1', 'GNUTLS_KEY_CRL_SIGN',
+           'GNUTLS_E_BASE64_ENCODING_ERROR', 'GNUTLS_A_CLOSE_NOTIFY',
+           'GNUTLS_OID_PKCS9_EMAIL', 'GNUTLS_CRL_REASON_UNUSED',
+           'GNUTLS_E_UNKNOWN_PK_ALGORITHM', 'GNUTLS_CERT_INVALID',
+           'GNUTLS_E_APPLICATION_ERROR_MIN',
+           'GNUTLS_HANDSHAKE_SERVER_HELLO_DONE',
+           'GNUTLS_E_OPENPGP_FINGERPRINT_UNSUPPORTED',
+           'GNUTLS_SAN_URI', 'GNUTLS_A_UNSUPPORTED_CERTIFICATE',
+           'GNUTLS_E_ASN1_TAG_ERROR', 'GNUTLS_E_INTERNAL_ERROR',
+           'GNUTLS_CRL_REASON_CERTIFICATE_HOLD',
+           'gnutls_certificate_status_t', 'GNUTLS_OID_PKIX_GENDER',
+           'GNUTLS_E_SRP_PWD_PARSING_ERROR', 'GNUTLS_MAC_SHA384',
+           'GNUTLS_COMP_DEFLATE', 'GNUTLS_E_ASN1_VALUE_NOT_VALID',
+           'GNUTLS_IA_INTERMEDIATE_PHASE_FINISHED',
+           'GNUTLS_COMP_UNKNOWN',
+           'GNUTLS_E_UNEXPECTED_HANDSHAKE_PACKET',
+           'GNUTLS_CIPHER_CAMELLIA_256_CBC',
+           'GNUTLS_CERT_SIGNER_NOT_FOUND',
+           'GNUTLS_A_PROTOCOL_VERSION', 'GNUTLS_E_AGAIN',
+           'GNUTLS_CIPHER_NULL', 'GNUTLS_KEY_ENCIPHER_ONLY',
+           'GNUTLS_NAME_DNS', 'GNUTLS_E_UNKNOWN_CIPHER_SUITE',
+           'gnutls_certificate_request_t',
+           'GNUTLS_CERT_SIGNER_NOT_CA', 'GNUTLS_A_USER_CANCELED',
+           'GNUTLS_E_PK_SIGN_FAILED',
+           'GNUTLS_E_ERROR_IN_FINISHED_PACKET',
+           'GNUTLS_CRL_REASON_AA_COMPROMISE', 'GNUTLS_MAC_SHA1',
+           'GNUTLS_CRD_ANON', 'GNUTLS_HANDSHAKE_SERVER_HELLO',
+           'GNUTLS_E_X509_UNSUPPORTED_ATTRIBUTE',
+           'GNUTLS_HANDSHAKE_CERTIFICATE_VERIFY',
+           'gnutls_ia_apptype_t', '_GNUTLS_GCC_VERSION',
+           'GNUTLS_CRL_REASON_SUPERSEEDED',
+           'gnutls_digest_algorithm_t', 'GNUTLS_A_DECRYPTION_FAILED',
+           'GNUTLS_MAC_NULL', 'GNUTLS_OID_PKIX_COUNTRY_OF_RESIDENCE',
+           'GNUTLS_E_ASN1_DER_ERROR', 'GNUTLS_PSK_KEY_HEX',
+           'GNUTLS_E_UNKNOWN_ALGORITHM', 'GNUTLS_DIG_SHA1',
+           'GNUTLS_E_INCOMPATIBLE_CRYPTO_LIBRARY',
+           'GNUTLS_E_ASN1_SYNTAX_ERROR',
+           'GNUTLS_E_WARNING_IA_FPHF_RECEIVED',
+           'GNUTLS_OID_X520_DN_QUALIFIER',
+           'GNUTLS_E_NO_CIPHER_SUITES', 'GNUTLS_KX_SRP',
+           'GNUTLS_E_CRYPTO_ALREADY_REGISTERED',
+           'GNUTLS_HANDSHAKE_FINISHED', 'GNUTLS_DIG_RMD160',
+           'gnutls_openpgp_crt_status_t', 'GNUTLS_KEY_KEY_CERT_SIGN',
+           'GNUTLS_CRD_SRP', 'GNUTLS_E_DECRYPTION_FAILED',
+           'GNUTLS_KX_SRP_RSA', 'gnutls_protocol_t',
+           'gnutls_openpgp_crt_fmt', 'GNUTLS_IA_APPLICATION_PAYLOAD',
+           'GNUTLS_SIGN_RSA_MD2', 'GNUTLS_A_CERTIFICATE_UNOBTAINABLE',
+           'GNUTLS_CIPHER_DES_CBC', 'GNUTLS_A_RECORD_OVERFLOW',
+           'GNUTLS_KX_DHE_DSS', 'GNUTLS_KEY_KEY_ENCIPHERMENT',
+           'GNUTLS_OID_LDAP_UID', 'GNUTLS_E_X509_UNSUPPORTED_OID',
+           'GNUTLS_VERIFY_DO_NOT_ALLOW_SAME',
+           'GNUTLS_E_UNIMPLEMENTED_FEATURE', 'GNUTLS_A_DECRYPT_ERROR',
+           'GNUTLS_TLS1_2', 'GNUTLS_TLS1_0', 'GNUTLS_TLS1_1',
+           'GNUTLS_CRL_REASON_AFFILIATION_CHANGED',
+           'GNUTLS_OPENPGP_FMT_RAW',
+           'GNUTLS_OID_X520_GENERATION_QUALIFIER',
+           'GNUTLS_OID_X520_PSEUDONYM',
+           'GNUTLS_A_DECOMPRESSION_FAILURE',
+           'GNUTLS_E_NO_COMPRESSION_ALGORITHMS',
+           'GNUTLS_E_UNEXPECTED_PACKET_LENGTH', 'GNUTLS_PK_UNKNOWN',
+           'GNUTLS_E_COMPRESSION_FAILED',
+           'GNUTLS_KEY_NON_REPUDIATION', 'GNUTLS_A_ACCESS_DENIED',
+           'GNUTLS_E_INSUFFICIENT_CREDENTIALS',
+           'gnutls_kx_algorithm_t', 'GNUTLS_OID_X520_COMMON_NAME',
+           'GNUTLS_OID_PKIX_PLACE_OF_BIRTH',
+           'GNUTLS_OID_X520_STATE_OR_PROVINCE_NAME',
+           'GNUTLS_VERIFY_DISABLE_CA_SIGN',
+           'GNUTLS_SAN_OTHERNAME_XMPP', 'GNUTLS_E_INVALID_REQUEST',
+           'GNUTLS_SSL3', 'GNUTLS_KP_TIME_STAMPING',
+           'GNUTLS_A_SSL3_NO_CERTIFICATE',
+           'GNUTLS_CRL_REASON_KEY_COMPROMISE',
+           'GNUTLS_E_APPLICATION_ERROR_MAX',
+           'GNUTLS_KEY_DIGITAL_SIGNATURE',
+           'gnutls_supplemental_data_format_type_t',
+           'gnutls_alert_description_t',
+           'GNUTLS_A_CERTIFICATE_REVOKED', 'gnutls_alert_level_t',
+           'gnutls_psk_key_flags', 'GNUTLS_A_BAD_CERTIFICATE',
+           'GNUTLS_MAC_UNKNOWN', 'GNUTLS_A_UNRECOGNIZED_NAME',
+           'TLS_RANDOM_SIZE', 'GNUTLS_E_INVALID_SESSION',
+           'GNUTLS_PARAMS_DH', 'GNUTLS_HANDSHAKE_CLIENT_KEY_EXCHANGE',
+           'gnutls_x509_crt_fmt_t', 'GNUTLS_KP_ANY',
+           'GNUTLS_E_TOO_MANY_EMPTY_PACKETS',
+           'GNUTLS_OID_PKIX_DATE_OF_BIRTH',
+           'GNUTLS_OPENPGP_FMT_BASE64',
+           'GNUTLS_E_NO_TEMPORARY_RSA_PARAMS',
+           'GNUTLS_VERSION_UNKNOWN', 'GNUTLS_E_INTERRUPTED',
+           'GNUTLS_COMP_LZO', 'GNUTLS_SERVER', 'GNUTLS_CRD_IA',
+           'GNUTLS_DIG_SHA224', 'GNUTLS_KX_RSA',
+           'LIBGNUTLS_VERSION_NUMBER', 'GNUTLS_CERT_IGNORE',
+           'GNUTLS_CERT_REQUEST', 'GNUTLS_MAC_SHA512',
+           'GNUTLS_E_SHORT_MEMORY_BUFFER', 'GNUTLS_SIGN_RSA_SHA224',
+           'GNUTLS_E_REHANDSHAKE', 'gnutls_close_request_t',
+           'GNUTLS_OID_X520_GIVEN_NAME', 'LIBGNUTLS_VERSION_MINOR',
+           'gnutls_handshake_description_t',
+           'GNUTLS_E_KEY_USAGE_VIOLATION',
+           'GNUTLS_E_PK_DECRYPTION_FAILED',
+           'GNUTLS_E_UNKNOWN_PKCS_BAG_TYPE', 'GNUTLS_KX_PSK',
+           'GNUTLS_SUPPLEMENTAL_USER_MAPPING_DATA',
+           'GNUTLS_KP_OCSP_SIGNING', 'GNUTLS_A_UNKNOWN_PSK_IDENTITY',
+           'GNUTLS_OID_X520_SURNAME', 'GNUTLS_E_MEMORY_ERROR',
+           'GNUTLS_CERT_REQUIRE', 'GNUTLS_KX_ANON_DH',
+           'GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT',
+           'GNUTLS_MAX_ALGORITHM_NUM', 'GNUTLS_A_EXPORT_RESTRICTION',
+           'GNUTLS_OID_X520_COUNTRY_NAME', 'GNUTLS_SHUT_RDWR',
+           'GNUTLS_AL_WARNING', 'GNUTLS_E_GOT_APPLICATION_DATA',
+           'LIBGNUTLS_VERSION_MAJOR', 'GNUTLS_CRT_UNKNOWN',
+           'GNUTLS_E_UNSUPPORTED_VERSION_PACKET',
+           'GNUTLS_KP_TLS_WWW_SERVER',
+           'GNUTLS_OID_X520_ORGANIZATIONAL_UNIT_NAME',
+           'GNUTLS_E_HASH_FAILED',
+           'GNUTLS_OID_X520_ORGANIZATION_NAME',
+           'gnutls_server_name_type_t', 'GNUTLS_E_ENCRYPTION_FAILED',
+           'GNUTLS_E_X509_UNKNOWN_SAN', 'GNUTLS_CRD_PSK',
+           'GNUTLS_E_PK_SIG_VERIFY_FAILED', 'GNUTLS_A_BAD_RECORD_MAC',
+           'GNUTLS_KX_RSA_EXPORT', 'GNUTLS_E_OPENPGP_SUBKEY_ERROR',
+           'GNUTLS_SIGN_RSA_SHA384', 'GNUTLS_CRT_X509',
+           'GNUTLS_E_EXPIRED', 'GNUTLS_E_UNWANTED_ALGORITHM',
+           'GNUTLS_SIGN_RSA_RMD160', 'GNUTLS_OID_X520_INITIALS',
+           'GNUTLS_KP_EMAIL_PROTECTION', 'gnutls_connection_end_t',
+           'GNUTLS_E_INIT_LIBEXTRA', 'GNUTLS_PKCS_PLAIN',
+           'GNUTLS_HANDSHAKE_SERVER_KEY_EXCHANGE',
+           'GNUTLS_CRL_REASON_CESSATION_OF_OPERATION',
+           'GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER',
+           'GNUTLS_CIPHER_CAMELLIA_128_CBC',
+           'GNUTLS_E_ASN1_GENERIC_ERROR',
+           'GNUTLS_E_ILLEGAL_SRP_USERNAME',
+           'GNUTLS_E_UNSUPPORTED_CERTIFICATE_TYPE', 'GNUTLS_PK_DSA',
+           'GNUTLS_E_INCOMPATIBLE_LIBTASN1_LIBRARY',
+           'GNUTLS_SAN_RFC822NAME',
+           'GNUTLS_E_BASE64_UNEXPECTED_HEADER_ERROR',
+           'GNUTLS_PKCS_USE_PKCS12_3DES', 'GNUTLS_CIPHER_ARCFOUR_40',
+           'GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE',
+           'GNUTLS_CIPHER_RC2_40_CBC', 'GNUTLS_CIPHER_AES_128_CBC',
+           'GNUTLS_OID_LDAP_DC', 'GNUTLS_KP_TLS_WWW_CLIENT',
+           'GNUTLS_A_INTERNAL_ERROR', 'GNUTLS_A_ILLEGAL_PARAMETER',
+           'gnutls_certificate_print_formats',
+           'GNUTLS_OID_X520_LOCALITY_NAME',
+           'GNUTLS_E_CERTIFICATE_ERROR', 'GNUTLS_CRT_PRINT_ONELINE',
+           'GNUTLS_KP_CODE_SIGNING']
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/library/errors.py b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/library/errors.py
new file mode 100644
index 0000000..1e4dea7
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/library/errors.py
@@ -0,0 +1,78 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS library errors"""
+
+from gnutls.errors import *
+from gnutls.errors import __all__
+
+from gnutls.library.constants import GNUTLS_E_AGAIN, GNUTLS_E_INTERRUPTED, GNUTLS_E_NO_CERTIFICATE_FOUND
+from gnutls.library.constants import GNUTLS_E_MEMORY_ERROR, GNUTLS_E_SHORT_MEMORY_BUFFER
+from gnutls.library.constants import GNUTLS_E_FATAL_ALERT_RECEIVED, GNUTLS_A_BAD_CERTIFICATE
+from gnutls.library.constants import GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE
+from gnutls.library.constants import GNUTLS_A_UNKNOWN_CA, GNUTLS_A_INSUFFICIENT_SECURITY
+from gnutls.library.constants import GNUTLS_A_CERTIFICATE_EXPIRED, GNUTLS_A_CERTIFICATE_REVOKED
+from gnutls.library.functions import gnutls_strerror, gnutls_alert_get
+
+class ErrorMessage(str):
+    def __new__(cls, code):
+        obj = str.__new__(cls, gnutls_strerror(code))
+        obj.code = code
+        return obj
+
+# Check functions which return an integer status code (negative codes being errors)
+#
+def _check_status(retcode, function, args):
+    if retcode >= 0:
+        return retcode
+    elif retcode == -1:
+        from gnutls.library import functions
+        if function in (functions.gnutls_certificate_activation_time_peers,
+                        functions.gnutls_x509_crt_get_activation_time,
+                        functions.gnutls_openpgp_key_get_creation_time):
+            raise GNUTLSError("cannot retrieve activation time")
+        elif function in (functions.gnutls_certificate_expiration_time_peers,
+                          functions.gnutls_x509_crt_get_expiration_time,
+                          functions.gnutls_openpgp_key_get_expiration_time):
+            raise GNUTLSError("cannot retrieve expiration time")
+        elif function in (functions.gnutls_x509_crl_get_this_update,
+                          functions.gnutls_x509_crl_get_next_update):
+            raise GNUTLSError("cannot retrieve CRL update time")
+        else:
+            raise GNUTLSError(ErrorMessage(retcode))
+    elif retcode == GNUTLS_E_AGAIN:
+        raise OperationWouldBlock(gnutls_strerror(retcode))
+    elif retcode == GNUTLS_E_INTERRUPTED:
+        raise OperationInterrupted(gnutls_strerror(retcode))
+    elif retcode in (GNUTLS_E_MEMORY_ERROR, GNUTLS_E_SHORT_MEMORY_BUFFER):
+        raise MemoryError(ErrorMessage(retcode))
+    elif retcode == GNUTLS_E_NO_CERTIFICATE_FOUND:
+        raise CertificateSecurityError(gnutls_strerror(retcode))
+    elif retcode == GNUTLS_E_FATAL_ALERT_RECEIVED:
+        alertdict = {
+            GNUTLS_A_BAD_CERTIFICATE: (CertificateError, "peer rejected our certificate as invalid"),
+            GNUTLS_A_UNKNOWN_CA: (CertificateAuthorityError, "peer does not trust our certificate authority"),
+            GNUTLS_A_INSUFFICIENT_SECURITY: (CertificateSecurityError, "peer rejected us on insufficient security"),
+            GNUTLS_A_CERTIFICATE_EXPIRED: (CertificateExpiredError, "peer rejected our certificate as expired"),
+            GNUTLS_A_CERTIFICATE_REVOKED: (CertificateRevokedError, "peer rejected our certificate as revoked")}
+        alert = gnutls_alert_get(args[0])
+        exception, reason = alertdict.get(alert, (GNUTLSError, ErrorMessage(retcode)))
+        raise exception(reason)
+    elif retcode == GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE:
+        raise RequestedDataNotAvailable(gnutls_strerror(retcode))
+    else:
+        raise GNUTLSError(ErrorMessage(retcode))
+
+# Attach the error checking function to all functions returning integers
+#
+from gnutls.library import functions
+from ctypes import c_int, c_long
+
+for func in functions.__dict__.values():
+    if not hasattr(func, 'errcheck'):
+        continue ## not a function
+    if func.restype in (c_int, c_long):
+        func.errcheck = _check_status
+
+del c_int, c_long, func, functions
+
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/library/functions.py b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/library/functions.py
new file mode 100644
index 0000000..5ee3cab
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/library/functions.py
@@ -0,0 +1,1836 @@
+from ctypes import *
+
+from gnutls.library.types import gnutls_ia_client_credentials_t
+_libraries = {}
+_libraries['libgnutls-extra.so.26'] = CDLL('libgnutls-extra.so.26')
+from gnutls.library.types import gnutls_ia_server_credentials_t
+from gnutls.library.types import gnutls_ia_avp_func
+from gnutls.library.types import gnutls_session_t
+from gnutls.library.types import size_t
+STRING = c_char_p
+from gnutls.library.types import ssize_t
+from gnutls.library.constants import gnutls_pk_algorithm_t
+_libraries['libgnutls.so.26'] = CDLL('libgnutls.so.26')
+from gnutls.library.constants import gnutls_sign_algorithm_t
+from gnutls.library.constants import gnutls_connection_end_t
+from gnutls.library.constants import gnutls_close_request_t
+from gnutls.library.constants import gnutls_alert_description_t
+from gnutls.library.constants import gnutls_alert_level_t
+from gnutls.library.constants import gnutls_cipher_algorithm_t
+from gnutls.library.constants import gnutls_kx_algorithm_t
+from gnutls.library.constants import gnutls_mac_algorithm_t
+from gnutls.library.constants import gnutls_compression_method_t
+from gnutls.library.constants import gnutls_certificate_type_t
+from gnutls.library.constants import gnutls_protocol_t
+from gnutls.library.constants import gnutls_handshake_description_t
+from gnutls.library.constants import gnutls_server_name_type_t
+from gnutls.library.constants import gnutls_supplemental_data_format_type_t
+from gnutls.library.types import gnutls_priority_t
+from gnutls.library.types import gnutls_datum_t
+from gnutls.library.types import gnutls_db_retr_func
+from gnutls.library.types import gnutls_db_remove_func
+from gnutls.library.types import gnutls_db_store_func
+from gnutls.library.types import gnutls_datum_t
+from gnutls.library.types import gnutls_handshake_post_client_hello_func
+from gnutls.library.constants import gnutls_credentials_type_t
+from gnutls.library.types import gnutls_anon_server_credentials_t
+from gnutls.library.types import gnutls_dh_params_t
+from gnutls.library.types import gnutls_params_function
+from gnutls.library.types import gnutls_anon_client_credentials_t
+from gnutls.library.types import gnutls_certificate_credentials_t
+from gnutls.library.types import gnutls_rsa_params_t
+from gnutls.library.constants import gnutls_x509_crt_fmt_t
+from gnutls.library.types import gnutls_x509_crt_t
+from gnutls.library.types import gnutls_x509_privkey_t
+from gnutls.library.types import gnutls_x509_crl_t
+from gnutls.library.types import gnutls_openpgp_keyring_t
+from gnutls.library.types import gnutls_alloc_function
+from gnutls.library.types import gnutls_is_secure_function
+from gnutls.library.types import gnutls_realloc_function
+from gnutls.library.types import gnutls_free_function
+from gnutls.library.types import gnutls_log_func
+from gnutls.library.types import gnutls_transport_ptr_t
+from gnutls.library.types import gnutls_push_func
+from gnutls.library.types import gnutls_pull_func
+from gnutls.library.constants import gnutls_openpgp_crt_status_t
+from gnutls.library.constants import gnutls_digest_algorithm_t
+from gnutls.library.types import gnutls_srp_client_credentials_t
+from gnutls.library.types import gnutls_srp_server_credentials_t
+from gnutls.library.types import gnutls_srp_server_credentials_function
+from gnutls.library.types import gnutls_srp_client_credentials_function
+from gnutls.library.types import gnutls_psk_client_credentials_t
+from gnutls.library.constants import gnutls_psk_key_flags
+from gnutls.library.types import gnutls_psk_server_credentials_t
+from gnutls.library.types import gnutls_psk_server_credentials_function
+from gnutls.library.types import gnutls_psk_client_credentials_function
+from gnutls.library.types import gnutls_sign_func
+from gnutls.library.types import gnutls_certificate_client_retrieve_function
+from gnutls.library.types import gnutls_certificate_server_retrieve_function
+from gnutls.library.constants import gnutls_certificate_request_t
+from gnutls.library.types import gnutls_openpgp_crt_t
+from gnutls.library.types import gnutls_openpgp_crt_fmt_t
+from gnutls.library.types import gnutls_certificate_print_formats_t
+from gnutls.library.types import gnutls_openpgp_privkey_t
+from gnutls.library.types import gnutls_openpgp_recv_key_func
+from gnutls.library.constants import gnutls_x509_subject_alt_name_t
+from gnutls.library.types import gnutls_x509_dn_t
+from gnutls.library.types import gnutls_x509_ava_st
+from gnutls.library.types import gnutls_pkcs7_t
+from gnutls.library.types import gnutls_x509_crq_t
+
+
+gnutls_ia_free_client_credentials = _libraries['libgnutls-extra.so.26'].gnutls_ia_free_client_credentials
+gnutls_ia_free_client_credentials.restype = None
+gnutls_ia_free_client_credentials.argtypes = [gnutls_ia_client_credentials_t]
+gnutls_ia_allocate_client_credentials = _libraries['libgnutls-extra.so.26'].gnutls_ia_allocate_client_credentials
+gnutls_ia_allocate_client_credentials.restype = c_int
+gnutls_ia_allocate_client_credentials.argtypes = [POINTER(gnutls_ia_client_credentials_t)]
+gnutls_ia_free_server_credentials = _libraries['libgnutls-extra.so.26'].gnutls_ia_free_server_credentials
+gnutls_ia_free_server_credentials.restype = None
+gnutls_ia_free_server_credentials.argtypes = [gnutls_ia_server_credentials_t]
+gnutls_ia_allocate_server_credentials = _libraries['libgnutls-extra.so.26'].gnutls_ia_allocate_server_credentials
+gnutls_ia_allocate_server_credentials.restype = c_int
+gnutls_ia_allocate_server_credentials.argtypes = [POINTER(gnutls_ia_server_credentials_t)]
+gnutls_ia_set_client_avp_function = _libraries['libgnutls-extra.so.26'].gnutls_ia_set_client_avp_function
+gnutls_ia_set_client_avp_function.restype = None
+gnutls_ia_set_client_avp_function.argtypes = [gnutls_ia_client_credentials_t, gnutls_ia_avp_func]
+gnutls_ia_set_client_avp_ptr = _libraries['libgnutls-extra.so.26'].gnutls_ia_set_client_avp_ptr
+gnutls_ia_set_client_avp_ptr.restype = None
+gnutls_ia_set_client_avp_ptr.argtypes = [gnutls_ia_client_credentials_t, c_void_p]
+gnutls_ia_get_client_avp_ptr = _libraries['libgnutls-extra.so.26'].gnutls_ia_get_client_avp_ptr
+gnutls_ia_get_client_avp_ptr.restype = c_void_p
+gnutls_ia_get_client_avp_ptr.argtypes = [gnutls_ia_client_credentials_t]
+gnutls_ia_set_server_avp_function = _libraries['libgnutls-extra.so.26'].gnutls_ia_set_server_avp_function
+gnutls_ia_set_server_avp_function.restype = None
+gnutls_ia_set_server_avp_function.argtypes = [gnutls_ia_server_credentials_t, gnutls_ia_avp_func]
+gnutls_ia_set_server_avp_ptr = _libraries['libgnutls-extra.so.26'].gnutls_ia_set_server_avp_ptr
+gnutls_ia_set_server_avp_ptr.restype = None
+gnutls_ia_set_server_avp_ptr.argtypes = [gnutls_ia_server_credentials_t, c_void_p]
+gnutls_ia_get_server_avp_ptr = _libraries['libgnutls-extra.so.26'].gnutls_ia_get_server_avp_ptr
+gnutls_ia_get_server_avp_ptr.restype = c_void_p
+gnutls_ia_get_server_avp_ptr.argtypes = [gnutls_ia_server_credentials_t]
+gnutls_ia_handshake_p = _libraries['libgnutls-extra.so.26'].gnutls_ia_handshake_p
+gnutls_ia_handshake_p.restype = c_int
+gnutls_ia_handshake_p.argtypes = [gnutls_session_t]
+gnutls_ia_handshake = _libraries['libgnutls-extra.so.26'].gnutls_ia_handshake
+gnutls_ia_handshake.restype = c_int
+gnutls_ia_handshake.argtypes = [gnutls_session_t]
+gnutls_ia_permute_inner_secret = _libraries['libgnutls-extra.so.26'].gnutls_ia_permute_inner_secret
+gnutls_ia_permute_inner_secret.restype = c_int
+gnutls_ia_permute_inner_secret.argtypes = [gnutls_session_t, size_t, STRING]
+gnutls_ia_endphase_send = _libraries['libgnutls-extra.so.26'].gnutls_ia_endphase_send
+gnutls_ia_endphase_send.restype = c_int
+gnutls_ia_endphase_send.argtypes = [gnutls_session_t, c_int]
+gnutls_ia_verify_endphase = _libraries['libgnutls-extra.so.26'].gnutls_ia_verify_endphase
+gnutls_ia_verify_endphase.restype = c_int
+gnutls_ia_verify_endphase.argtypes = [gnutls_session_t, STRING]
+gnutls_ia_send = _libraries['libgnutls-extra.so.26'].gnutls_ia_send
+gnutls_ia_send.restype = ssize_t
+gnutls_ia_send.argtypes = [gnutls_session_t, STRING, size_t]
+gnutls_ia_recv = _libraries['libgnutls-extra.so.26'].gnutls_ia_recv
+gnutls_ia_recv.restype = ssize_t
+gnutls_ia_recv.argtypes = [gnutls_session_t, STRING, size_t]
+gnutls_ia_generate_challenge = _libraries['libgnutls-extra.so.26'].gnutls_ia_generate_challenge
+gnutls_ia_generate_challenge.restype = c_int
+gnutls_ia_generate_challenge.argtypes = [gnutls_session_t, size_t, STRING]
+gnutls_ia_extract_inner_secret = _libraries['libgnutls-extra.so.26'].gnutls_ia_extract_inner_secret
+gnutls_ia_extract_inner_secret.restype = None
+gnutls_ia_extract_inner_secret.argtypes = [gnutls_session_t, STRING]
+gnutls_ia_enable = _libraries['libgnutls-extra.so.26'].gnutls_ia_enable
+gnutls_ia_enable.restype = None
+gnutls_ia_enable.argtypes = [gnutls_session_t, c_int]
+gnutls_global_init_extra = _libraries['libgnutls-extra.so.26'].gnutls_global_init_extra
+gnutls_global_init_extra.restype = c_int
+gnutls_global_init_extra.argtypes = []
+gnutls_extra_check_version = _libraries['libgnutls-extra.so.26'].gnutls_extra_check_version
+gnutls_extra_check_version.restype = STRING
+gnutls_extra_check_version.argtypes = [STRING]
+gnutls_pk_algorithm_get_name = _libraries['libgnutls.so.26'].gnutls_pk_algorithm_get_name
+gnutls_pk_algorithm_get_name.restype = STRING
+gnutls_pk_algorithm_get_name.argtypes = [gnutls_pk_algorithm_t]
+gnutls_sign_algorithm_get_name = _libraries['libgnutls.so.26'].gnutls_sign_algorithm_get_name
+gnutls_sign_algorithm_get_name.restype = STRING
+gnutls_sign_algorithm_get_name.argtypes = [gnutls_sign_algorithm_t]
+gnutls_init = _libraries['libgnutls.so.26'].gnutls_init
+gnutls_init.restype = c_int
+gnutls_init.argtypes = [POINTER(gnutls_session_t), gnutls_connection_end_t]
+gnutls_deinit = _libraries['libgnutls.so.26'].gnutls_deinit
+gnutls_deinit.restype = None
+gnutls_deinit.argtypes = [gnutls_session_t]
+gnutls_bye = _libraries['libgnutls.so.26'].gnutls_bye
+gnutls_bye.restype = c_int
+gnutls_bye.argtypes = [gnutls_session_t, gnutls_close_request_t]
+gnutls_handshake = _libraries['libgnutls.so.26'].gnutls_handshake
+gnutls_handshake.restype = c_int
+gnutls_handshake.argtypes = [gnutls_session_t]
+gnutls_rehandshake = _libraries['libgnutls.so.26'].gnutls_rehandshake
+gnutls_rehandshake.restype = c_int
+gnutls_rehandshake.argtypes = [gnutls_session_t]
+gnutls_alert_get = _libraries['libgnutls.so.26'].gnutls_alert_get
+gnutls_alert_get.restype = gnutls_alert_description_t
+gnutls_alert_get.argtypes = [gnutls_session_t]
+gnutls_alert_send = _libraries['libgnutls.so.26'].gnutls_alert_send
+gnutls_alert_send.restype = c_int
+gnutls_alert_send.argtypes = [gnutls_session_t, gnutls_alert_level_t, gnutls_alert_description_t]
+gnutls_alert_send_appropriate = _libraries['libgnutls.so.26'].gnutls_alert_send_appropriate
+gnutls_alert_send_appropriate.restype = c_int
+gnutls_alert_send_appropriate.argtypes = [gnutls_session_t, c_int]
+gnutls_alert_get_name = _libraries['libgnutls.so.26'].gnutls_alert_get_name
+gnutls_alert_get_name.restype = STRING
+gnutls_alert_get_name.argtypes = [gnutls_alert_description_t]
+gnutls_cipher_get = _libraries['libgnutls.so.26'].gnutls_cipher_get
+gnutls_cipher_get.restype = gnutls_cipher_algorithm_t
+gnutls_cipher_get.argtypes = [gnutls_session_t]
+gnutls_kx_get = _libraries['libgnutls.so.26'].gnutls_kx_get
+gnutls_kx_get.restype = gnutls_kx_algorithm_t
+gnutls_kx_get.argtypes = [gnutls_session_t]
+gnutls_mac_get = _libraries['libgnutls.so.26'].gnutls_mac_get
+gnutls_mac_get.restype = gnutls_mac_algorithm_t
+gnutls_mac_get.argtypes = [gnutls_session_t]
+gnutls_compression_get = _libraries['libgnutls.so.26'].gnutls_compression_get
+gnutls_compression_get.restype = gnutls_compression_method_t
+gnutls_compression_get.argtypes = [gnutls_session_t]
+gnutls_certificate_type_get = _libraries['libgnutls.so.26'].gnutls_certificate_type_get
+gnutls_certificate_type_get.restype = gnutls_certificate_type_t
+gnutls_certificate_type_get.argtypes = [gnutls_session_t]
+gnutls_cipher_get_key_size = _libraries['libgnutls.so.26'].gnutls_cipher_get_key_size
+gnutls_cipher_get_key_size.restype = size_t
+gnutls_cipher_get_key_size.argtypes = [gnutls_cipher_algorithm_t]
+gnutls_mac_get_key_size = _libraries['libgnutls.so.26'].gnutls_mac_get_key_size
+gnutls_mac_get_key_size.restype = size_t
+gnutls_mac_get_key_size.argtypes = [gnutls_mac_algorithm_t]
+gnutls_cipher_get_name = _libraries['libgnutls.so.26'].gnutls_cipher_get_name
+gnutls_cipher_get_name.restype = STRING
+gnutls_cipher_get_name.argtypes = [gnutls_cipher_algorithm_t]
+gnutls_mac_get_name = _libraries['libgnutls.so.26'].gnutls_mac_get_name
+gnutls_mac_get_name.restype = STRING
+gnutls_mac_get_name.argtypes = [gnutls_mac_algorithm_t]
+gnutls_compression_get_name = _libraries['libgnutls.so.26'].gnutls_compression_get_name
+gnutls_compression_get_name.restype = STRING
+gnutls_compression_get_name.argtypes = [gnutls_compression_method_t]
+gnutls_kx_get_name = _libraries['libgnutls.so.26'].gnutls_kx_get_name
+gnutls_kx_get_name.restype = STRING
+gnutls_kx_get_name.argtypes = [gnutls_kx_algorithm_t]
+gnutls_certificate_type_get_name = _libraries['libgnutls.so.26'].gnutls_certificate_type_get_name
+gnutls_certificate_type_get_name.restype = STRING
+gnutls_certificate_type_get_name.argtypes = [gnutls_certificate_type_t]
+gnutls_mac_get_id = _libraries['libgnutls.so.26'].gnutls_mac_get_id
+gnutls_mac_get_id.restype = gnutls_mac_algorithm_t
+gnutls_mac_get_id.argtypes = [STRING]
+gnutls_compression_get_id = _libraries['libgnutls.so.26'].gnutls_compression_get_id
+gnutls_compression_get_id.restype = gnutls_compression_method_t
+gnutls_compression_get_id.argtypes = [STRING]
+gnutls_cipher_get_id = _libraries['libgnutls.so.26'].gnutls_cipher_get_id
+gnutls_cipher_get_id.restype = gnutls_cipher_algorithm_t
+gnutls_cipher_get_id.argtypes = [STRING]
+gnutls_kx_get_id = _libraries['libgnutls.so.26'].gnutls_kx_get_id
+gnutls_kx_get_id.restype = gnutls_kx_algorithm_t
+gnutls_kx_get_id.argtypes = [STRING]
+gnutls_protocol_get_id = _libraries['libgnutls.so.26'].gnutls_protocol_get_id
+gnutls_protocol_get_id.restype = gnutls_protocol_t
+gnutls_protocol_get_id.argtypes = [STRING]
+gnutls_certificate_type_get_id = _libraries['libgnutls.so.26'].gnutls_certificate_type_get_id
+gnutls_certificate_type_get_id.restype = gnutls_certificate_type_t
+gnutls_certificate_type_get_id.argtypes = [STRING]
+gnutls_cipher_list = _libraries['libgnutls.so.26'].gnutls_cipher_list
+gnutls_cipher_list.restype = POINTER(gnutls_cipher_algorithm_t)
+gnutls_cipher_list.argtypes = []
+gnutls_mac_list = _libraries['libgnutls.so.26'].gnutls_mac_list
+gnutls_mac_list.restype = POINTER(gnutls_mac_algorithm_t)
+gnutls_mac_list.argtypes = []
+gnutls_compression_list = _libraries['libgnutls.so.26'].gnutls_compression_list
+gnutls_compression_list.restype = POINTER(gnutls_compression_method_t)
+gnutls_compression_list.argtypes = []
+gnutls_protocol_list = _libraries['libgnutls.so.26'].gnutls_protocol_list
+gnutls_protocol_list.restype = POINTER(gnutls_protocol_t)
+gnutls_protocol_list.argtypes = []
+gnutls_certificate_type_list = _libraries['libgnutls.so.26'].gnutls_certificate_type_list
+gnutls_certificate_type_list.restype = POINTER(gnutls_certificate_type_t)
+gnutls_certificate_type_list.argtypes = []
+gnutls_kx_list = _libraries['libgnutls.so.26'].gnutls_kx_list
+gnutls_kx_list.restype = POINTER(gnutls_kx_algorithm_t)
+gnutls_kx_list.argtypes = []
+gnutls_cipher_suite_info = _libraries['libgnutls.so.26'].gnutls_cipher_suite_info
+gnutls_cipher_suite_info.restype = STRING
+gnutls_cipher_suite_info.argtypes = [size_t, STRING, POINTER(gnutls_kx_algorithm_t), POINTER(gnutls_cipher_algorithm_t), POINTER(gnutls_mac_algorithm_t), POINTER(gnutls_protocol_t)]
+gnutls_error_is_fatal = _libraries['libgnutls.so.26'].gnutls_error_is_fatal
+gnutls_error_is_fatal.restype = c_int
+gnutls_error_is_fatal.argtypes = [c_int]
+gnutls_error_to_alert = _libraries['libgnutls.so.26'].gnutls_error_to_alert
+gnutls_error_to_alert.restype = c_int
+gnutls_error_to_alert.argtypes = [c_int, POINTER(c_int)]
+gnutls_perror = _libraries['libgnutls.so.26'].gnutls_perror
+gnutls_perror.restype = None
+gnutls_perror.argtypes = [c_int]
+gnutls_strerror = _libraries['libgnutls.so.26'].gnutls_strerror
+gnutls_strerror.restype = STRING
+gnutls_strerror.argtypes = [c_int]
+gnutls_handshake_set_private_extensions = _libraries['libgnutls.so.26'].gnutls_handshake_set_private_extensions
+gnutls_handshake_set_private_extensions.restype = None
+gnutls_handshake_set_private_extensions.argtypes = [gnutls_session_t, c_int]
+gnutls_handshake_get_last_out = _libraries['libgnutls.so.26'].gnutls_handshake_get_last_out
+gnutls_handshake_get_last_out.restype = gnutls_handshake_description_t
+gnutls_handshake_get_last_out.argtypes = [gnutls_session_t]
+gnutls_handshake_get_last_in = _libraries['libgnutls.so.26'].gnutls_handshake_get_last_in
+gnutls_handshake_get_last_in.restype = gnutls_handshake_description_t
+gnutls_handshake_get_last_in.argtypes = [gnutls_session_t]
+gnutls_record_send = _libraries['libgnutls.so.26'].gnutls_record_send
+gnutls_record_send.restype = ssize_t
+gnutls_record_send.argtypes = [gnutls_session_t, c_void_p, size_t]
+gnutls_record_recv = _libraries['libgnutls.so.26'].gnutls_record_recv
+gnutls_record_recv.restype = ssize_t
+gnutls_record_recv.argtypes = [gnutls_session_t, c_void_p, size_t]
+gnutls_session_enable_compatibility_mode = _libraries['libgnutls.so.26'].gnutls_session_enable_compatibility_mode
+gnutls_session_enable_compatibility_mode.restype = None
+gnutls_session_enable_compatibility_mode.argtypes = [gnutls_session_t]
+gnutls_record_disable_padding = _libraries['libgnutls.so.26'].gnutls_record_disable_padding
+gnutls_record_disable_padding.restype = None
+gnutls_record_disable_padding.argtypes = [gnutls_session_t]
+gnutls_record_get_direction = _libraries['libgnutls.so.26'].gnutls_record_get_direction
+gnutls_record_get_direction.restype = c_int
+gnutls_record_get_direction.argtypes = [gnutls_session_t]
+gnutls_record_get_max_size = _libraries['libgnutls.so.26'].gnutls_record_get_max_size
+gnutls_record_get_max_size.restype = size_t
+gnutls_record_get_max_size.argtypes = [gnutls_session_t]
+gnutls_record_set_max_size = _libraries['libgnutls.so.26'].gnutls_record_set_max_size
+gnutls_record_set_max_size.restype = ssize_t
+gnutls_record_set_max_size.argtypes = [gnutls_session_t, size_t]
+gnutls_record_check_pending = _libraries['libgnutls.so.26'].gnutls_record_check_pending
+gnutls_record_check_pending.restype = size_t
+gnutls_record_check_pending.argtypes = [gnutls_session_t]
+gnutls_prf = _libraries['libgnutls.so.26'].gnutls_prf
+gnutls_prf.restype = c_int
+gnutls_prf.argtypes = [gnutls_session_t, size_t, STRING, c_int, size_t, STRING, size_t, STRING]
+gnutls_prf_raw = _libraries['libgnutls.so.26'].gnutls_prf_raw
+gnutls_prf_raw.restype = c_int
+gnutls_prf_raw.argtypes = [gnutls_session_t, size_t, STRING, size_t, STRING, size_t, STRING]
+gnutls_server_name_set = _libraries['libgnutls.so.26'].gnutls_server_name_set
+gnutls_server_name_set.restype = c_int
+gnutls_server_name_set.argtypes = [gnutls_session_t, gnutls_server_name_type_t, c_void_p, size_t]
+gnutls_server_name_get = _libraries['libgnutls.so.26'].gnutls_server_name_get
+gnutls_server_name_get.restype = c_int
+gnutls_server_name_get.argtypes = [gnutls_session_t, c_void_p, POINTER(size_t), POINTER(c_uint), c_uint]
+gnutls_supplemental_get_name = _libraries['libgnutls.so.26'].gnutls_supplemental_get_name
+gnutls_supplemental_get_name.restype = STRING
+gnutls_supplemental_get_name.argtypes = [gnutls_supplemental_data_format_type_t]
+gnutls_cipher_set_priority = _libraries['libgnutls.so.26'].gnutls_cipher_set_priority
+gnutls_cipher_set_priority.restype = c_int
+gnutls_cipher_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)]
+gnutls_mac_set_priority = _libraries['libgnutls.so.26'].gnutls_mac_set_priority
+gnutls_mac_set_priority.restype = c_int
+gnutls_mac_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)]
+gnutls_compression_set_priority = _libraries['libgnutls.so.26'].gnutls_compression_set_priority
+gnutls_compression_set_priority.restype = c_int
+gnutls_compression_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)]
+gnutls_kx_set_priority = _libraries['libgnutls.so.26'].gnutls_kx_set_priority
+gnutls_kx_set_priority.restype = c_int
+gnutls_kx_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)]
+gnutls_protocol_set_priority = _libraries['libgnutls.so.26'].gnutls_protocol_set_priority
+gnutls_protocol_set_priority.restype = c_int
+gnutls_protocol_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)]
+gnutls_certificate_type_set_priority = _libraries['libgnutls.so.26'].gnutls_certificate_type_set_priority
+gnutls_certificate_type_set_priority.restype = c_int
+gnutls_certificate_type_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)]
+gnutls_priority_init = _libraries['libgnutls.so.26'].gnutls_priority_init
+gnutls_priority_init.restype = c_int
+gnutls_priority_init.argtypes = [POINTER(gnutls_priority_t), STRING, POINTER(STRING)]
+gnutls_priority_deinit = _libraries['libgnutls.so.26'].gnutls_priority_deinit
+gnutls_priority_deinit.restype = None
+gnutls_priority_deinit.argtypes = [gnutls_priority_t]
+gnutls_priority_set = _libraries['libgnutls.so.26'].gnutls_priority_set
+gnutls_priority_set.restype = c_int
+gnutls_priority_set.argtypes = [gnutls_session_t, gnutls_priority_t]
+gnutls_priority_set_direct = _libraries['libgnutls.so.26'].gnutls_priority_set_direct
+gnutls_priority_set_direct.restype = c_int
+gnutls_priority_set_direct.argtypes = [gnutls_session_t, STRING, POINTER(STRING)]
+gnutls_set_default_priority = _libraries['libgnutls.so.26'].gnutls_set_default_priority
+gnutls_set_default_priority.restype = c_int
+gnutls_set_default_priority.argtypes = [gnutls_session_t]
+gnutls_set_default_export_priority = _libraries['libgnutls.so.26'].gnutls_set_default_export_priority
+gnutls_set_default_export_priority.restype = c_int
+gnutls_set_default_export_priority.argtypes = [gnutls_session_t]
+gnutls_cipher_suite_get_name = _libraries['libgnutls.so.26'].gnutls_cipher_suite_get_name
+gnutls_cipher_suite_get_name.restype = STRING
+gnutls_cipher_suite_get_name.argtypes = [gnutls_kx_algorithm_t, gnutls_cipher_algorithm_t, gnutls_mac_algorithm_t]
+gnutls_protocol_get_version = _libraries['libgnutls.so.26'].gnutls_protocol_get_version
+gnutls_protocol_get_version.restype = gnutls_protocol_t
+gnutls_protocol_get_version.argtypes = [gnutls_session_t]
+gnutls_protocol_get_name = _libraries['libgnutls.so.26'].gnutls_protocol_get_name
+gnutls_protocol_get_name.restype = STRING
+gnutls_protocol_get_name.argtypes = [gnutls_protocol_t]
+gnutls_session_set_data = _libraries['libgnutls.so.26'].gnutls_session_set_data
+gnutls_session_set_data.restype = c_int
+gnutls_session_set_data.argtypes = [gnutls_session_t, c_void_p, size_t]
+gnutls_session_get_data = _libraries['libgnutls.so.26'].gnutls_session_get_data
+gnutls_session_get_data.restype = c_int
+gnutls_session_get_data.argtypes = [gnutls_session_t, c_void_p, POINTER(size_t)]
+gnutls_session_get_data2 = _libraries['libgnutls.so.26'].gnutls_session_get_data2
+gnutls_session_get_data2.restype = c_int
+gnutls_session_get_data2.argtypes = [gnutls_session_t, POINTER(gnutls_datum_t)]
+gnutls_session_get_id = _libraries['libgnutls.so.26'].gnutls_session_get_id
+gnutls_session_get_id.restype = c_int
+gnutls_session_get_id.argtypes = [gnutls_session_t, c_void_p, POINTER(size_t)]
+gnutls_session_get_server_random = _libraries['libgnutls.so.26'].gnutls_session_get_server_random
+gnutls_session_get_server_random.restype = c_void_p
+gnutls_session_get_server_random.argtypes = [gnutls_session_t]
+gnutls_session_get_client_random = _libraries['libgnutls.so.26'].gnutls_session_get_client_random
+gnutls_session_get_client_random.restype = c_void_p
+gnutls_session_get_client_random.argtypes = [gnutls_session_t]
+gnutls_session_get_master_secret = _libraries['libgnutls.so.26'].gnutls_session_get_master_secret
+gnutls_session_get_master_secret.restype = c_void_p
+gnutls_session_get_master_secret.argtypes = [gnutls_session_t]
+gnutls_session_is_resumed = _libraries['libgnutls.so.26'].gnutls_session_is_resumed
+gnutls_session_is_resumed.restype = c_int
+gnutls_session_is_resumed.argtypes = [gnutls_session_t]
+gnutls_db_set_cache_expiration = _libraries['libgnutls.so.26'].gnutls_db_set_cache_expiration
+gnutls_db_set_cache_expiration.restype = None
+gnutls_db_set_cache_expiration.argtypes = [gnutls_session_t, c_int]
+gnutls_db_remove_session = _libraries['libgnutls.so.26'].gnutls_db_remove_session
+gnutls_db_remove_session.restype = None
+gnutls_db_remove_session.argtypes = [gnutls_session_t]
+gnutls_db_set_retrieve_function = _libraries['libgnutls.so.26'].gnutls_db_set_retrieve_function
+gnutls_db_set_retrieve_function.restype = None
+gnutls_db_set_retrieve_function.argtypes = [gnutls_session_t, gnutls_db_retr_func]
+gnutls_db_set_remove_function = _libraries['libgnutls.so.26'].gnutls_db_set_remove_function
+gnutls_db_set_remove_function.restype = None
+gnutls_db_set_remove_function.argtypes = [gnutls_session_t, gnutls_db_remove_func]
+gnutls_db_set_store_function = _libraries['libgnutls.so.26'].gnutls_db_set_store_function
+gnutls_db_set_store_function.restype = None
+gnutls_db_set_store_function.argtypes = [gnutls_session_t, gnutls_db_store_func]
+gnutls_db_set_ptr = _libraries['libgnutls.so.26'].gnutls_db_set_ptr
+gnutls_db_set_ptr.restype = None
+gnutls_db_set_ptr.argtypes = [gnutls_session_t, c_void_p]
+gnutls_db_get_ptr = _libraries['libgnutls.so.26'].gnutls_db_get_ptr
+gnutls_db_get_ptr.restype = c_void_p
+gnutls_db_get_ptr.argtypes = [gnutls_session_t]
+gnutls_db_check_entry = _libraries['libgnutls.so.26'].gnutls_db_check_entry
+gnutls_db_check_entry.restype = c_int
+gnutls_db_check_entry.argtypes = [gnutls_session_t, gnutls_datum_t]
+gnutls_handshake_set_post_client_hello_function = _libraries['libgnutls.so.26'].gnutls_handshake_set_post_client_hello_function
+gnutls_handshake_set_post_client_hello_function.restype = None
+gnutls_handshake_set_post_client_hello_function.argtypes = [gnutls_session_t, gnutls_handshake_post_client_hello_func]
+gnutls_handshake_set_max_packet_length = _libraries['libgnutls.so.26'].gnutls_handshake_set_max_packet_length
+gnutls_handshake_set_max_packet_length.restype = None
+gnutls_handshake_set_max_packet_length.argtypes = [gnutls_session_t, size_t]
+gnutls_check_version = _libraries['libgnutls.so.26'].gnutls_check_version
+gnutls_check_version.restype = STRING
+gnutls_check_version.argtypes = [STRING]
+gnutls_credentials_clear = _libraries['libgnutls.so.26'].gnutls_credentials_clear
+gnutls_credentials_clear.restype = None
+gnutls_credentials_clear.argtypes = [gnutls_session_t]
+gnutls_credentials_set = _libraries['libgnutls.so.26'].gnutls_credentials_set
+gnutls_credentials_set.restype = c_int
+gnutls_credentials_set.argtypes = [gnutls_session_t, gnutls_credentials_type_t, c_void_p]
+gnutls_anon_free_server_credentials = _libraries['libgnutls.so.26'].gnutls_anon_free_server_credentials
+gnutls_anon_free_server_credentials.restype = None
+gnutls_anon_free_server_credentials.argtypes = [gnutls_anon_server_credentials_t]
+gnutls_anon_allocate_server_credentials = _libraries['libgnutls.so.26'].gnutls_anon_allocate_server_credentials
+gnutls_anon_allocate_server_credentials.restype = c_int
+gnutls_anon_allocate_server_credentials.argtypes = [POINTER(gnutls_anon_server_credentials_t)]
+gnutls_anon_set_server_dh_params = _libraries['libgnutls.so.26'].gnutls_anon_set_server_dh_params
+gnutls_anon_set_server_dh_params.restype = None
+gnutls_anon_set_server_dh_params.argtypes = [gnutls_anon_server_credentials_t, gnutls_dh_params_t]
+gnutls_anon_set_server_params_function = _libraries['libgnutls.so.26'].gnutls_anon_set_server_params_function
+gnutls_anon_set_server_params_function.restype = None
+gnutls_anon_set_server_params_function.argtypes = [gnutls_anon_server_credentials_t, gnutls_params_function]
+gnutls_anon_free_client_credentials = _libraries['libgnutls.so.26'].gnutls_anon_free_client_credentials
+gnutls_anon_free_client_credentials.restype = None
+gnutls_anon_free_client_credentials.argtypes = [gnutls_anon_client_credentials_t]
+gnutls_anon_allocate_client_credentials = _libraries['libgnutls.so.26'].gnutls_anon_allocate_client_credentials
+gnutls_anon_allocate_client_credentials.restype = c_int
+gnutls_anon_allocate_client_credentials.argtypes = [POINTER(gnutls_anon_client_credentials_t)]
+gnutls_certificate_free_credentials = _libraries['libgnutls.so.26'].gnutls_certificate_free_credentials
+gnutls_certificate_free_credentials.restype = None
+gnutls_certificate_free_credentials.argtypes = [gnutls_certificate_credentials_t]
+gnutls_certificate_allocate_credentials = _libraries['libgnutls.so.26'].gnutls_certificate_allocate_credentials
+gnutls_certificate_allocate_credentials.restype = c_int
+gnutls_certificate_allocate_credentials.argtypes = [POINTER(gnutls_certificate_credentials_t)]
+gnutls_certificate_free_keys = _libraries['libgnutls.so.26'].gnutls_certificate_free_keys
+gnutls_certificate_free_keys.restype = None
+gnutls_certificate_free_keys.argtypes = [gnutls_certificate_credentials_t]
+gnutls_certificate_free_cas = _libraries['libgnutls.so.26'].gnutls_certificate_free_cas
+gnutls_certificate_free_cas.restype = None
+gnutls_certificate_free_cas.argtypes = [gnutls_certificate_credentials_t]
+gnutls_certificate_free_ca_names = _libraries['libgnutls.so.26'].gnutls_certificate_free_ca_names
+gnutls_certificate_free_ca_names.restype = None
+gnutls_certificate_free_ca_names.argtypes = [gnutls_certificate_credentials_t]
+gnutls_certificate_free_crls = _libraries['libgnutls.so.26'].gnutls_certificate_free_crls
+gnutls_certificate_free_crls.restype = None
+gnutls_certificate_free_crls.argtypes = [gnutls_certificate_credentials_t]
+gnutls_certificate_set_dh_params = _libraries['libgnutls.so.26'].gnutls_certificate_set_dh_params
+gnutls_certificate_set_dh_params.restype = None
+gnutls_certificate_set_dh_params.argtypes = [gnutls_certificate_credentials_t, gnutls_dh_params_t]
+gnutls_certificate_set_rsa_export_params = _libraries['libgnutls.so.26'].gnutls_certificate_set_rsa_export_params
+gnutls_certificate_set_rsa_export_params.restype = None
+gnutls_certificate_set_rsa_export_params.argtypes = [gnutls_certificate_credentials_t, gnutls_rsa_params_t]
+gnutls_certificate_set_verify_flags = _libraries['libgnutls.so.26'].gnutls_certificate_set_verify_flags
+gnutls_certificate_set_verify_flags.restype = None
+gnutls_certificate_set_verify_flags.argtypes = [gnutls_certificate_credentials_t, c_uint]
+gnutls_certificate_set_verify_limits = _libraries['libgnutls.so.26'].gnutls_certificate_set_verify_limits
+gnutls_certificate_set_verify_limits.restype = None
+gnutls_certificate_set_verify_limits.argtypes = [gnutls_certificate_credentials_t, c_uint, c_uint]
+gnutls_certificate_set_x509_trust_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_trust_file
+gnutls_certificate_set_x509_trust_file.restype = c_int
+gnutls_certificate_set_x509_trust_file.argtypes = [gnutls_certificate_credentials_t, STRING, gnutls_x509_crt_fmt_t]
+gnutls_certificate_set_x509_trust_mem = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_trust_mem
+gnutls_certificate_set_x509_trust_mem.restype = c_int
+gnutls_certificate_set_x509_trust_mem.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_certificate_set_x509_crl_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_crl_file
+gnutls_certificate_set_x509_crl_file.restype = c_int
+gnutls_certificate_set_x509_crl_file.argtypes = [gnutls_certificate_credentials_t, STRING, gnutls_x509_crt_fmt_t]
+gnutls_certificate_set_x509_crl_mem = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_crl_mem
+gnutls_certificate_set_x509_crl_mem.restype = c_int
+gnutls_certificate_set_x509_crl_mem.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_certificate_set_x509_key_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_key_file
+gnutls_certificate_set_x509_key_file.restype = c_int
+gnutls_certificate_set_x509_key_file.argtypes = [gnutls_certificate_credentials_t, STRING, STRING, gnutls_x509_crt_fmt_t]
+gnutls_certificate_set_x509_key_mem = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_key_mem
+gnutls_certificate_set_x509_key_mem.restype = c_int
+gnutls_certificate_set_x509_key_mem.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_certificate_send_x509_rdn_sequence = _libraries['libgnutls.so.26'].gnutls_certificate_send_x509_rdn_sequence
+gnutls_certificate_send_x509_rdn_sequence.restype = None
+gnutls_certificate_send_x509_rdn_sequence.argtypes = [gnutls_session_t, c_int]
+gnutls_certificate_set_x509_simple_pkcs12_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_simple_pkcs12_file
+gnutls_certificate_set_x509_simple_pkcs12_file.restype = c_int
+gnutls_certificate_set_x509_simple_pkcs12_file.argtypes = [gnutls_certificate_credentials_t, STRING, gnutls_x509_crt_fmt_t, STRING]
+gnutls_certificate_set_x509_key = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_key
+gnutls_certificate_set_x509_key.restype = c_int
+gnutls_certificate_set_x509_key.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_x509_crt_t), c_int, gnutls_x509_privkey_t]
+gnutls_certificate_set_x509_trust = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_trust
+gnutls_certificate_set_x509_trust.restype = c_int
+gnutls_certificate_set_x509_trust.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_x509_crt_t), c_int]
+gnutls_certificate_set_x509_crl = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_crl
+gnutls_certificate_set_x509_crl.restype = c_int
+gnutls_certificate_set_x509_crl.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_x509_crl_t), c_int]
+gnutls_certificate_get_x509_cas = _libraries['libgnutls.so.26'].gnutls_certificate_get_x509_cas
+gnutls_certificate_get_x509_cas.restype = None
+gnutls_certificate_get_x509_cas.argtypes = [gnutls_certificate_credentials_t, POINTER(POINTER(gnutls_x509_crt_t)), POINTER(c_uint)]
+gnutls_certificate_get_x509_crls = _libraries['libgnutls.so.26'].gnutls_certificate_get_x509_crls
+gnutls_certificate_get_x509_crls.restype = None
+gnutls_certificate_get_x509_crls.argtypes = [gnutls_certificate_credentials_t, POINTER(POINTER(gnutls_x509_crl_t)), POINTER(c_uint)]
+gnutls_certificate_get_openpgp_keyring = _libraries['libgnutls.so.26'].gnutls_certificate_get_openpgp_keyring
+gnutls_certificate_get_openpgp_keyring.restype = None
+gnutls_certificate_get_openpgp_keyring.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_openpgp_keyring_t)]
+gnutls_global_init = _libraries['libgnutls.so.26'].gnutls_global_init
+gnutls_global_init.restype = c_int
+gnutls_global_init.argtypes = []
+gnutls_global_deinit = _libraries['libgnutls.so.26'].gnutls_global_deinit
+gnutls_global_deinit.restype = None
+gnutls_global_deinit.argtypes = []
+gnutls_global_set_mem_functions = _libraries['libgnutls.so.26'].gnutls_global_set_mem_functions
+gnutls_global_set_mem_functions.restype = None
+gnutls_global_set_mem_functions.argtypes = [gnutls_alloc_function, gnutls_alloc_function, gnutls_is_secure_function, gnutls_realloc_function, gnutls_free_function]
+gnutls_global_set_log_function = _libraries['libgnutls.so.26'].gnutls_global_set_log_function
+gnutls_global_set_log_function.restype = None
+gnutls_global_set_log_function.argtypes = [gnutls_log_func]
+gnutls_global_set_log_level = _libraries['libgnutls.so.26'].gnutls_global_set_log_level
+gnutls_global_set_log_level.restype = None
+gnutls_global_set_log_level.argtypes = [c_int]
+gnutls_dh_params_init = _libraries['libgnutls.so.26'].gnutls_dh_params_init
+gnutls_dh_params_init.restype = c_int
+gnutls_dh_params_init.argtypes = [POINTER(gnutls_dh_params_t)]
+gnutls_dh_params_deinit = _libraries['libgnutls.so.26'].gnutls_dh_params_deinit
+gnutls_dh_params_deinit.restype = None
+gnutls_dh_params_deinit.argtypes = [gnutls_dh_params_t]
+gnutls_dh_params_import_raw = _libraries['libgnutls.so.26'].gnutls_dh_params_import_raw
+gnutls_dh_params_import_raw.restype = c_int
+gnutls_dh_params_import_raw.argtypes = [gnutls_dh_params_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_dh_params_import_pkcs3 = _libraries['libgnutls.so.26'].gnutls_dh_params_import_pkcs3
+gnutls_dh_params_import_pkcs3.restype = c_int
+gnutls_dh_params_import_pkcs3.argtypes = [gnutls_dh_params_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_dh_params_generate2 = _libraries['libgnutls.so.26'].gnutls_dh_params_generate2
+gnutls_dh_params_generate2.restype = c_int
+gnutls_dh_params_generate2.argtypes = [gnutls_dh_params_t, c_uint]
+gnutls_dh_params_export_pkcs3 = _libraries['libgnutls.so.26'].gnutls_dh_params_export_pkcs3
+gnutls_dh_params_export_pkcs3.restype = c_int
+gnutls_dh_params_export_pkcs3.argtypes = [gnutls_dh_params_t, gnutls_x509_crt_fmt_t, POINTER(c_ubyte), POINTER(size_t)]
+gnutls_dh_params_export_raw = _libraries['libgnutls.so.26'].gnutls_dh_params_export_raw
+gnutls_dh_params_export_raw.restype = c_int
+gnutls_dh_params_export_raw.argtypes = [gnutls_dh_params_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(c_uint)]
+gnutls_dh_params_cpy = _libraries['libgnutls.so.26'].gnutls_dh_params_cpy
+gnutls_dh_params_cpy.restype = c_int
+gnutls_dh_params_cpy.argtypes = [gnutls_dh_params_t, gnutls_dh_params_t]
+gnutls_rsa_params_init = _libraries['libgnutls.so.26'].gnutls_rsa_params_init
+gnutls_rsa_params_init.restype = c_int
+gnutls_rsa_params_init.argtypes = [POINTER(gnutls_rsa_params_t)]
+gnutls_rsa_params_deinit = _libraries['libgnutls.so.26'].gnutls_rsa_params_deinit
+gnutls_rsa_params_deinit.restype = None
+gnutls_rsa_params_deinit.argtypes = [gnutls_rsa_params_t]
+gnutls_rsa_params_cpy = _libraries['libgnutls.so.26'].gnutls_rsa_params_cpy
+gnutls_rsa_params_cpy.restype = c_int
+gnutls_rsa_params_cpy.argtypes = [gnutls_rsa_params_t, gnutls_rsa_params_t]
+gnutls_rsa_params_import_raw = _libraries['libgnutls.so.26'].gnutls_rsa_params_import_raw
+gnutls_rsa_params_import_raw.restype = c_int
+gnutls_rsa_params_import_raw.argtypes = [gnutls_rsa_params_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_rsa_params_generate2 = _libraries['libgnutls.so.26'].gnutls_rsa_params_generate2
+gnutls_rsa_params_generate2.restype = c_int
+gnutls_rsa_params_generate2.argtypes = [gnutls_rsa_params_t, c_uint]
+gnutls_rsa_params_export_raw = _libraries['libgnutls.so.26'].gnutls_rsa_params_export_raw
+gnutls_rsa_params_export_raw.restype = c_int
+gnutls_rsa_params_export_raw.argtypes = [gnutls_rsa_params_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(c_uint)]
+gnutls_rsa_params_export_pkcs1 = _libraries['libgnutls.so.26'].gnutls_rsa_params_export_pkcs1
+gnutls_rsa_params_export_pkcs1.restype = c_int
+gnutls_rsa_params_export_pkcs1.argtypes = [gnutls_rsa_params_t, gnutls_x509_crt_fmt_t, POINTER(c_ubyte), POINTER(size_t)]
+gnutls_rsa_params_import_pkcs1 = _libraries['libgnutls.so.26'].gnutls_rsa_params_import_pkcs1
+gnutls_rsa_params_import_pkcs1.restype = c_int
+gnutls_rsa_params_import_pkcs1.argtypes = [gnutls_rsa_params_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_transport_set_ptr = _libraries['libgnutls.so.26'].gnutls_transport_set_ptr
+gnutls_transport_set_ptr.restype = None
+gnutls_transport_set_ptr.argtypes = [gnutls_session_t, gnutls_transport_ptr_t]
+gnutls_transport_set_ptr2 = _libraries['libgnutls.so.26'].gnutls_transport_set_ptr2
+gnutls_transport_set_ptr2.restype = None
+gnutls_transport_set_ptr2.argtypes = [gnutls_session_t, gnutls_transport_ptr_t, gnutls_transport_ptr_t]
+gnutls_transport_get_ptr = _libraries['libgnutls.so.26'].gnutls_transport_get_ptr
+gnutls_transport_get_ptr.restype = gnutls_transport_ptr_t
+gnutls_transport_get_ptr.argtypes = [gnutls_session_t]
+gnutls_transport_get_ptr2 = _libraries['libgnutls.so.26'].gnutls_transport_get_ptr2
+gnutls_transport_get_ptr2.restype = None
+gnutls_transport_get_ptr2.argtypes = [gnutls_session_t, POINTER(gnutls_transport_ptr_t), POINTER(gnutls_transport_ptr_t)]
+gnutls_transport_set_lowat = _libraries['libgnutls.so.26'].gnutls_transport_set_lowat
+gnutls_transport_set_lowat.restype = None
+gnutls_transport_set_lowat.argtypes = [gnutls_session_t, c_int]
+gnutls_transport_set_push_function = _libraries['libgnutls.so.26'].gnutls_transport_set_push_function
+gnutls_transport_set_push_function.restype = None
+gnutls_transport_set_push_function.argtypes = [gnutls_session_t, gnutls_push_func]
+gnutls_transport_set_pull_function = _libraries['libgnutls.so.26'].gnutls_transport_set_pull_function
+gnutls_transport_set_pull_function.restype = None
+gnutls_transport_set_pull_function.argtypes = [gnutls_session_t, gnutls_pull_func]
+gnutls_transport_set_errno = _libraries['libgnutls.so.26'].gnutls_transport_set_errno
+gnutls_transport_set_errno.restype = None
+gnutls_transport_set_errno.argtypes = [gnutls_session_t, c_int]
+gnutls_transport_set_global_errno = _libraries['libgnutls.so.26'].gnutls_transport_set_global_errno
+gnutls_transport_set_global_errno.restype = None
+gnutls_transport_set_global_errno.argtypes = [c_int]
+gnutls_session_set_ptr = _libraries['libgnutls.so.26'].gnutls_session_set_ptr
+gnutls_session_set_ptr.restype = None
+gnutls_session_set_ptr.argtypes = [gnutls_session_t, c_void_p]
+gnutls_session_get_ptr = _libraries['libgnutls.so.26'].gnutls_session_get_ptr
+gnutls_session_get_ptr.restype = c_void_p
+gnutls_session_get_ptr.argtypes = [gnutls_session_t]
+gnutls_openpgp_send_cert = _libraries['libgnutls.so.26'].gnutls_openpgp_send_cert
+gnutls_openpgp_send_cert.restype = None
+gnutls_openpgp_send_cert.argtypes = [gnutls_session_t, gnutls_openpgp_crt_status_t]
+gnutls_fingerprint = _libraries['libgnutls.so.26'].gnutls_fingerprint
+gnutls_fingerprint.restype = c_int
+gnutls_fingerprint.argtypes = [gnutls_digest_algorithm_t, POINTER(gnutls_datum_t), c_void_p, POINTER(size_t)]
+gnutls_srp_free_client_credentials = _libraries['libgnutls.so.26'].gnutls_srp_free_client_credentials
+gnutls_srp_free_client_credentials.restype = None
+gnutls_srp_free_client_credentials.argtypes = [gnutls_srp_client_credentials_t]
+gnutls_srp_allocate_client_credentials = _libraries['libgnutls.so.26'].gnutls_srp_allocate_client_credentials
+gnutls_srp_allocate_client_credentials.restype = c_int
+gnutls_srp_allocate_client_credentials.argtypes = [POINTER(gnutls_srp_client_credentials_t)]
+gnutls_srp_set_client_credentials = _libraries['libgnutls.so.26'].gnutls_srp_set_client_credentials
+gnutls_srp_set_client_credentials.restype = c_int
+gnutls_srp_set_client_credentials.argtypes = [gnutls_srp_client_credentials_t, STRING, STRING]
+gnutls_srp_free_server_credentials = _libraries['libgnutls.so.26'].gnutls_srp_free_server_credentials
+gnutls_srp_free_server_credentials.restype = None
+gnutls_srp_free_server_credentials.argtypes = [gnutls_srp_server_credentials_t]
+gnutls_srp_allocate_server_credentials = _libraries['libgnutls.so.26'].gnutls_srp_allocate_server_credentials
+gnutls_srp_allocate_server_credentials.restype = c_int
+gnutls_srp_allocate_server_credentials.argtypes = [POINTER(gnutls_srp_server_credentials_t)]
+gnutls_srp_set_server_credentials_file = _libraries['libgnutls.so.26'].gnutls_srp_set_server_credentials_file
+gnutls_srp_set_server_credentials_file.restype = c_int
+gnutls_srp_set_server_credentials_file.argtypes = [gnutls_srp_server_credentials_t, STRING, STRING]
+gnutls_srp_server_get_username = _libraries['libgnutls.so.26'].gnutls_srp_server_get_username
+gnutls_srp_server_get_username.restype = STRING
+gnutls_srp_server_get_username.argtypes = [gnutls_session_t]
+gnutls_srp_verifier = _libraries['libgnutls.so.26'].gnutls_srp_verifier
+gnutls_srp_verifier.restype = c_int
+gnutls_srp_verifier.argtypes = [STRING, STRING, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_srp_set_server_credentials_function = _libraries['libgnutls.so.26'].gnutls_srp_set_server_credentials_function
+gnutls_srp_set_server_credentials_function.restype = None
+gnutls_srp_set_server_credentials_function.argtypes = [gnutls_srp_server_credentials_t, gnutls_srp_server_credentials_function]
+gnutls_srp_set_client_credentials_function = _libraries['libgnutls.so.26'].gnutls_srp_set_client_credentials_function
+gnutls_srp_set_client_credentials_function.restype = None
+gnutls_srp_set_client_credentials_function.argtypes = [gnutls_srp_client_credentials_t, gnutls_srp_client_credentials_function]
+gnutls_srp_base64_encode = _libraries['libgnutls.so.26'].gnutls_srp_base64_encode
+gnutls_srp_base64_encode.restype = c_int
+gnutls_srp_base64_encode.argtypes = [POINTER(gnutls_datum_t), STRING, POINTER(size_t)]
+gnutls_srp_base64_encode_alloc = _libraries['libgnutls.so.26'].gnutls_srp_base64_encode_alloc
+gnutls_srp_base64_encode_alloc.restype = c_int
+gnutls_srp_base64_encode_alloc.argtypes = [POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_srp_base64_decode = _libraries['libgnutls.so.26'].gnutls_srp_base64_decode
+gnutls_srp_base64_decode.restype = c_int
+gnutls_srp_base64_decode.argtypes = [POINTER(gnutls_datum_t), STRING, POINTER(size_t)]
+gnutls_srp_base64_decode_alloc = _libraries['libgnutls.so.26'].gnutls_srp_base64_decode_alloc
+gnutls_srp_base64_decode_alloc.restype = c_int
+gnutls_srp_base64_decode_alloc.argtypes = [POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_psk_free_client_credentials = _libraries['libgnutls.so.26'].gnutls_psk_free_client_credentials
+gnutls_psk_free_client_credentials.restype = None
+gnutls_psk_free_client_credentials.argtypes = [gnutls_psk_client_credentials_t]
+gnutls_psk_allocate_client_credentials = _libraries['libgnutls.so.26'].gnutls_psk_allocate_client_credentials
+gnutls_psk_allocate_client_credentials.restype = c_int
+gnutls_psk_allocate_client_credentials.argtypes = [POINTER(gnutls_psk_client_credentials_t)]
+gnutls_psk_set_client_credentials = _libraries['libgnutls.so.26'].gnutls_psk_set_client_credentials
+gnutls_psk_set_client_credentials.restype = c_int
+gnutls_psk_set_client_credentials.argtypes = [gnutls_psk_client_credentials_t, STRING, POINTER(gnutls_datum_t), gnutls_psk_key_flags]
+gnutls_psk_free_server_credentials = _libraries['libgnutls.so.26'].gnutls_psk_free_server_credentials
+gnutls_psk_free_server_credentials.restype = None
+gnutls_psk_free_server_credentials.argtypes = [gnutls_psk_server_credentials_t]
+gnutls_psk_allocate_server_credentials = _libraries['libgnutls.so.26'].gnutls_psk_allocate_server_credentials
+gnutls_psk_allocate_server_credentials.restype = c_int
+gnutls_psk_allocate_server_credentials.argtypes = [POINTER(gnutls_psk_server_credentials_t)]
+gnutls_psk_set_server_credentials_file = _libraries['libgnutls.so.26'].gnutls_psk_set_server_credentials_file
+gnutls_psk_set_server_credentials_file.restype = c_int
+gnutls_psk_set_server_credentials_file.argtypes = [gnutls_psk_server_credentials_t, STRING]
+gnutls_psk_set_server_credentials_hint = _libraries['libgnutls.so.26'].gnutls_psk_set_server_credentials_hint
+gnutls_psk_set_server_credentials_hint.restype = c_int
+gnutls_psk_set_server_credentials_hint.argtypes = [gnutls_psk_server_credentials_t, STRING]
+gnutls_psk_server_get_username = _libraries['libgnutls.so.26'].gnutls_psk_server_get_username
+gnutls_psk_server_get_username.restype = STRING
+gnutls_psk_server_get_username.argtypes = [gnutls_session_t]
+gnutls_psk_client_get_hint = _libraries['libgnutls.so.26'].gnutls_psk_client_get_hint
+gnutls_psk_client_get_hint.restype = STRING
+gnutls_psk_client_get_hint.argtypes = [gnutls_session_t]
+gnutls_psk_set_server_credentials_function = _libraries['libgnutls.so.26'].gnutls_psk_set_server_credentials_function
+gnutls_psk_set_server_credentials_function.restype = None
+gnutls_psk_set_server_credentials_function.argtypes = [gnutls_psk_server_credentials_t, gnutls_psk_server_credentials_function]
+gnutls_psk_set_client_credentials_function = _libraries['libgnutls.so.26'].gnutls_psk_set_client_credentials_function
+gnutls_psk_set_client_credentials_function.restype = None
+gnutls_psk_set_client_credentials_function.argtypes = [gnutls_psk_client_credentials_t, gnutls_psk_client_credentials_function]
+gnutls_hex_encode = _libraries['libgnutls.so.26'].gnutls_hex_encode
+gnutls_hex_encode.restype = c_int
+gnutls_hex_encode.argtypes = [POINTER(gnutls_datum_t), STRING, POINTER(size_t)]
+gnutls_hex_decode = _libraries['libgnutls.so.26'].gnutls_hex_decode
+gnutls_hex_decode.restype = c_int
+gnutls_hex_decode.argtypes = [POINTER(gnutls_datum_t), STRING, POINTER(size_t)]
+gnutls_psk_set_server_dh_params = _libraries['libgnutls.so.26'].gnutls_psk_set_server_dh_params
+gnutls_psk_set_server_dh_params.restype = None
+gnutls_psk_set_server_dh_params.argtypes = [gnutls_psk_server_credentials_t, gnutls_dh_params_t]
+gnutls_psk_set_server_params_function = _libraries['libgnutls.so.26'].gnutls_psk_set_server_params_function
+gnutls_psk_set_server_params_function.restype = None
+gnutls_psk_set_server_params_function.argtypes = [gnutls_psk_server_credentials_t, gnutls_params_function]
+gnutls_psk_netconf_derive_key = _libraries['libgnutls.so.26'].gnutls_psk_netconf_derive_key
+gnutls_psk_netconf_derive_key.restype = c_int
+gnutls_psk_netconf_derive_key.argtypes = [STRING, STRING, STRING, POINTER(gnutls_datum_t)]
+gnutls_auth_get_type = _libraries['libgnutls.so.26'].gnutls_auth_get_type
+gnutls_auth_get_type.restype = gnutls_credentials_type_t
+gnutls_auth_get_type.argtypes = [gnutls_session_t]
+gnutls_auth_server_get_type = _libraries['libgnutls.so.26'].gnutls_auth_server_get_type
+gnutls_auth_server_get_type.restype = gnutls_credentials_type_t
+gnutls_auth_server_get_type.argtypes = [gnutls_session_t]
+gnutls_auth_client_get_type = _libraries['libgnutls.so.26'].gnutls_auth_client_get_type
+gnutls_auth_client_get_type.restype = gnutls_credentials_type_t
+gnutls_auth_client_get_type.argtypes = [gnutls_session_t]
+gnutls_dh_set_prime_bits = _libraries['libgnutls.so.26'].gnutls_dh_set_prime_bits
+gnutls_dh_set_prime_bits.restype = None
+gnutls_dh_set_prime_bits.argtypes = [gnutls_session_t, c_uint]
+gnutls_dh_get_secret_bits = _libraries['libgnutls.so.26'].gnutls_dh_get_secret_bits
+gnutls_dh_get_secret_bits.restype = c_int
+gnutls_dh_get_secret_bits.argtypes = [gnutls_session_t]
+gnutls_dh_get_peers_public_bits = _libraries['libgnutls.so.26'].gnutls_dh_get_peers_public_bits
+gnutls_dh_get_peers_public_bits.restype = c_int
+gnutls_dh_get_peers_public_bits.argtypes = [gnutls_session_t]
+gnutls_dh_get_prime_bits = _libraries['libgnutls.so.26'].gnutls_dh_get_prime_bits
+gnutls_dh_get_prime_bits.restype = c_int
+gnutls_dh_get_prime_bits.argtypes = [gnutls_session_t]
+gnutls_dh_get_group = _libraries['libgnutls.so.26'].gnutls_dh_get_group
+gnutls_dh_get_group.restype = c_int
+gnutls_dh_get_group.argtypes = [gnutls_session_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_dh_get_pubkey = _libraries['libgnutls.so.26'].gnutls_dh_get_pubkey
+gnutls_dh_get_pubkey.restype = c_int
+gnutls_dh_get_pubkey.argtypes = [gnutls_session_t, POINTER(gnutls_datum_t)]
+gnutls_rsa_export_get_pubkey = _libraries['libgnutls.so.26'].gnutls_rsa_export_get_pubkey
+gnutls_rsa_export_get_pubkey.restype = c_int
+gnutls_rsa_export_get_pubkey.argtypes = [gnutls_session_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_rsa_export_get_modulus_bits = _libraries['libgnutls.so.26'].gnutls_rsa_export_get_modulus_bits
+gnutls_rsa_export_get_modulus_bits.restype = c_int
+gnutls_rsa_export_get_modulus_bits.argtypes = [gnutls_session_t]
+gnutls_sign_callback_set = _libraries['libgnutls.so.26'].gnutls_sign_callback_set
+gnutls_sign_callback_set.restype = None
+gnutls_sign_callback_set.argtypes = [gnutls_session_t, gnutls_sign_func, c_void_p]
+gnutls_sign_callback_get = _libraries['libgnutls.so.26'].gnutls_sign_callback_get
+gnutls_sign_callback_get.restype = gnutls_sign_func
+gnutls_sign_callback_get.argtypes = [gnutls_session_t, POINTER(c_void_p)]
+gnutls_certificate_client_set_retrieve_function = _libraries['libgnutls.so.26'].gnutls_certificate_client_set_retrieve_function
+gnutls_certificate_client_set_retrieve_function.restype = None
+gnutls_certificate_client_set_retrieve_function.argtypes = [gnutls_certificate_credentials_t, gnutls_certificate_client_retrieve_function]
+gnutls_certificate_server_set_retrieve_function = _libraries['libgnutls.so.26'].gnutls_certificate_server_set_retrieve_function
+gnutls_certificate_server_set_retrieve_function.restype = None
+gnutls_certificate_server_set_retrieve_function.argtypes = [gnutls_certificate_credentials_t, gnutls_certificate_server_retrieve_function]
+gnutls_certificate_server_set_request = _libraries['libgnutls.so.26'].gnutls_certificate_server_set_request
+gnutls_certificate_server_set_request.restype = None
+gnutls_certificate_server_set_request.argtypes = [gnutls_session_t, gnutls_certificate_request_t]
+gnutls_certificate_get_peers = _libraries['libgnutls.so.26'].gnutls_certificate_get_peers
+gnutls_certificate_get_peers.restype = POINTER(gnutls_datum_t)
+gnutls_certificate_get_peers.argtypes = [gnutls_session_t, POINTER(c_uint)]
+gnutls_certificate_get_ours = _libraries['libgnutls.so.26'].gnutls_certificate_get_ours
+gnutls_certificate_get_ours.restype = POINTER(gnutls_datum_t)
+gnutls_certificate_get_ours.argtypes = [gnutls_session_t]
+__time_t = c_long
+time_t = __time_t
+gnutls_certificate_activation_time_peers = _libraries['libgnutls.so.26'].gnutls_certificate_activation_time_peers
+gnutls_certificate_activation_time_peers.restype = time_t
+gnutls_certificate_activation_time_peers.argtypes = [gnutls_session_t]
+gnutls_certificate_expiration_time_peers = _libraries['libgnutls.so.26'].gnutls_certificate_expiration_time_peers
+gnutls_certificate_expiration_time_peers.restype = time_t
+gnutls_certificate_expiration_time_peers.argtypes = [gnutls_session_t]
+gnutls_certificate_client_get_request_status = _libraries['libgnutls.so.26'].gnutls_certificate_client_get_request_status
+gnutls_certificate_client_get_request_status.restype = c_int
+gnutls_certificate_client_get_request_status.argtypes = [gnutls_session_t]
+gnutls_certificate_verify_peers2 = _libraries['libgnutls.so.26'].gnutls_certificate_verify_peers2
+gnutls_certificate_verify_peers2.restype = c_int
+gnutls_certificate_verify_peers2.argtypes = [gnutls_session_t, POINTER(c_uint)]
+gnutls_certificate_verify_peers = _libraries['libgnutls.so.26'].gnutls_certificate_verify_peers
+gnutls_certificate_verify_peers.restype = c_int
+gnutls_certificate_verify_peers.argtypes = [gnutls_session_t]
+gnutls_pem_base64_encode = _libraries['libgnutls.so.26'].gnutls_pem_base64_encode
+gnutls_pem_base64_encode.restype = c_int
+gnutls_pem_base64_encode.argtypes = [STRING, POINTER(gnutls_datum_t), STRING, POINTER(size_t)]
+gnutls_pem_base64_decode = _libraries['libgnutls.so.26'].gnutls_pem_base64_decode
+gnutls_pem_base64_decode.restype = c_int
+gnutls_pem_base64_decode.argtypes = [STRING, POINTER(gnutls_datum_t), POINTER(c_ubyte), POINTER(size_t)]
+gnutls_pem_base64_encode_alloc = _libraries['libgnutls.so.26'].gnutls_pem_base64_encode_alloc
+gnutls_pem_base64_encode_alloc.restype = c_int
+gnutls_pem_base64_encode_alloc.argtypes = [STRING, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_pem_base64_decode_alloc = _libraries['libgnutls.so.26'].gnutls_pem_base64_decode_alloc
+gnutls_pem_base64_decode_alloc.restype = c_int
+gnutls_pem_base64_decode_alloc.argtypes = [STRING, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_certificate_set_params_function = _libraries['libgnutls.so.26'].gnutls_certificate_set_params_function
+gnutls_certificate_set_params_function.restype = None
+gnutls_certificate_set_params_function.argtypes = [gnutls_certificate_credentials_t, gnutls_params_function]
+gnutls_anon_set_params_function = _libraries['libgnutls.so.26'].gnutls_anon_set_params_function
+gnutls_anon_set_params_function.restype = None
+gnutls_anon_set_params_function.argtypes = [gnutls_anon_server_credentials_t, gnutls_params_function]
+gnutls_psk_set_params_function = _libraries['libgnutls.so.26'].gnutls_psk_set_params_function
+gnutls_psk_set_params_function.restype = None
+gnutls_psk_set_params_function.argtypes = [gnutls_psk_server_credentials_t, gnutls_params_function]
+gnutls_hex2bin = _libraries['libgnutls.so.26'].gnutls_hex2bin
+gnutls_hex2bin.restype = c_int
+gnutls_hex2bin.argtypes = [STRING, size_t, STRING, POINTER(size_t)]
+gnutls_openpgp_crt_init = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_init
+gnutls_openpgp_crt_init.restype = c_int
+gnutls_openpgp_crt_init.argtypes = [POINTER(gnutls_openpgp_crt_t)]
+gnutls_openpgp_crt_deinit = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_deinit
+gnutls_openpgp_crt_deinit.restype = None
+gnutls_openpgp_crt_deinit.argtypes = [gnutls_openpgp_crt_t]
+gnutls_openpgp_crt_import = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_import
+gnutls_openpgp_crt_import.restype = c_int
+gnutls_openpgp_crt_import.argtypes = [gnutls_openpgp_crt_t, POINTER(gnutls_datum_t), gnutls_openpgp_crt_fmt_t]
+gnutls_openpgp_crt_export = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_export
+gnutls_openpgp_crt_export.restype = c_int
+gnutls_openpgp_crt_export.argtypes = [gnutls_openpgp_crt_t, gnutls_openpgp_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_openpgp_crt_print = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_print
+gnutls_openpgp_crt_print.restype = c_int
+gnutls_openpgp_crt_print.argtypes = [gnutls_openpgp_crt_t, gnutls_certificate_print_formats_t, POINTER(gnutls_datum_t)]
+gnutls_openpgp_crt_get_key_usage = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_key_usage
+gnutls_openpgp_crt_get_key_usage.restype = c_int
+gnutls_openpgp_crt_get_key_usage.argtypes = [gnutls_openpgp_crt_t, POINTER(c_uint)]
+gnutls_openpgp_crt_get_fingerprint = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_fingerprint
+gnutls_openpgp_crt_get_fingerprint.restype = c_int
+gnutls_openpgp_crt_get_fingerprint.argtypes = [gnutls_openpgp_crt_t, c_void_p, POINTER(size_t)]
+gnutls_openpgp_crt_get_subkey_fingerprint = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_fingerprint
+gnutls_openpgp_crt_get_subkey_fingerprint.restype = c_int
+gnutls_openpgp_crt_get_subkey_fingerprint.argtypes = [gnutls_openpgp_crt_t, c_uint, c_void_p, POINTER(size_t)]
+gnutls_openpgp_crt_get_name = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_name
+gnutls_openpgp_crt_get_name.restype = c_int
+gnutls_openpgp_crt_get_name.argtypes = [gnutls_openpgp_crt_t, c_int, STRING, POINTER(size_t)]
+gnutls_openpgp_crt_get_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_pk_algorithm
+gnutls_openpgp_crt_get_pk_algorithm.restype = gnutls_pk_algorithm_t
+gnutls_openpgp_crt_get_pk_algorithm.argtypes = [gnutls_openpgp_crt_t, POINTER(c_uint)]
+gnutls_openpgp_crt_get_version = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_version
+gnutls_openpgp_crt_get_version.restype = c_int
+gnutls_openpgp_crt_get_version.argtypes = [gnutls_openpgp_crt_t]
+gnutls_openpgp_crt_get_creation_time = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_creation_time
+gnutls_openpgp_crt_get_creation_time.restype = time_t
+gnutls_openpgp_crt_get_creation_time.argtypes = [gnutls_openpgp_crt_t]
+gnutls_openpgp_crt_get_expiration_time = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_expiration_time
+gnutls_openpgp_crt_get_expiration_time.restype = time_t
+gnutls_openpgp_crt_get_expiration_time.argtypes = [gnutls_openpgp_crt_t]
+gnutls_openpgp_crt_get_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_key_id
+gnutls_openpgp_crt_get_key_id.restype = c_int
+gnutls_openpgp_crt_get_key_id.argtypes = [gnutls_openpgp_crt_t, POINTER(c_ubyte)]
+gnutls_openpgp_crt_check_hostname = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_check_hostname
+gnutls_openpgp_crt_check_hostname.restype = c_int
+gnutls_openpgp_crt_check_hostname.argtypes = [gnutls_openpgp_crt_t, STRING]
+gnutls_openpgp_crt_get_revoked_status = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_revoked_status
+gnutls_openpgp_crt_get_revoked_status.restype = c_int
+gnutls_openpgp_crt_get_revoked_status.argtypes = [gnutls_openpgp_crt_t]
+gnutls_openpgp_crt_get_subkey_count = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_count
+gnutls_openpgp_crt_get_subkey_count.restype = c_int
+gnutls_openpgp_crt_get_subkey_count.argtypes = [gnutls_openpgp_crt_t]
+gnutls_openpgp_crt_get_subkey_idx = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_idx
+gnutls_openpgp_crt_get_subkey_idx.restype = c_int
+gnutls_openpgp_crt_get_subkey_idx.argtypes = [gnutls_openpgp_crt_t, POINTER(c_ubyte)]
+gnutls_openpgp_crt_get_subkey_revoked_status = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_revoked_status
+gnutls_openpgp_crt_get_subkey_revoked_status.restype = c_int
+gnutls_openpgp_crt_get_subkey_revoked_status.argtypes = [gnutls_openpgp_crt_t, c_uint]
+gnutls_openpgp_crt_get_subkey_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_pk_algorithm
+gnutls_openpgp_crt_get_subkey_pk_algorithm.restype = gnutls_pk_algorithm_t
+gnutls_openpgp_crt_get_subkey_pk_algorithm.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(c_uint)]
+gnutls_openpgp_crt_get_subkey_creation_time = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_creation_time
+gnutls_openpgp_crt_get_subkey_creation_time.restype = time_t
+gnutls_openpgp_crt_get_subkey_creation_time.argtypes = [gnutls_openpgp_crt_t, c_uint]
+gnutls_openpgp_crt_get_subkey_expiration_time = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_expiration_time
+gnutls_openpgp_crt_get_subkey_expiration_time.restype = time_t
+gnutls_openpgp_crt_get_subkey_expiration_time.argtypes = [gnutls_openpgp_crt_t, c_uint]
+gnutls_openpgp_crt_get_subkey_id = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_id
+gnutls_openpgp_crt_get_subkey_id.restype = c_int
+gnutls_openpgp_crt_get_subkey_id.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(c_ubyte)]
+gnutls_openpgp_crt_get_subkey_usage = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_usage
+gnutls_openpgp_crt_get_subkey_usage.restype = c_int
+gnutls_openpgp_crt_get_subkey_usage.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(c_uint)]
+gnutls_openpgp_crt_get_subkey_pk_dsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_pk_dsa_raw
+gnutls_openpgp_crt_get_subkey_pk_dsa_raw.restype = c_int
+gnutls_openpgp_crt_get_subkey_pk_dsa_raw.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_crt_get_subkey_pk_rsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_pk_rsa_raw
+gnutls_openpgp_crt_get_subkey_pk_rsa_raw.restype = c_int
+gnutls_openpgp_crt_get_subkey_pk_rsa_raw.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_crt_get_pk_dsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_pk_dsa_raw
+gnutls_openpgp_crt_get_pk_dsa_raw.restype = c_int
+gnutls_openpgp_crt_get_pk_dsa_raw.argtypes = [gnutls_openpgp_crt_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_crt_get_pk_rsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_pk_rsa_raw
+gnutls_openpgp_crt_get_pk_rsa_raw.restype = c_int
+gnutls_openpgp_crt_get_pk_rsa_raw.argtypes = [gnutls_openpgp_crt_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_crt_get_preferred_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_preferred_key_id
+gnutls_openpgp_crt_get_preferred_key_id.restype = c_int
+gnutls_openpgp_crt_get_preferred_key_id.argtypes = [gnutls_openpgp_crt_t, POINTER(c_ubyte)]
+gnutls_openpgp_crt_set_preferred_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_set_preferred_key_id
+gnutls_openpgp_crt_set_preferred_key_id.restype = c_int
+gnutls_openpgp_crt_set_preferred_key_id.argtypes = [gnutls_openpgp_crt_t, POINTER(c_ubyte)]
+gnutls_openpgp_privkey_init = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_init
+gnutls_openpgp_privkey_init.restype = c_int
+gnutls_openpgp_privkey_init.argtypes = [POINTER(gnutls_openpgp_privkey_t)]
+gnutls_openpgp_privkey_deinit = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_deinit
+gnutls_openpgp_privkey_deinit.restype = None
+gnutls_openpgp_privkey_deinit.argtypes = [gnutls_openpgp_privkey_t]
+gnutls_openpgp_privkey_get_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_pk_algorithm
+gnutls_openpgp_privkey_get_pk_algorithm.restype = gnutls_pk_algorithm_t
+gnutls_openpgp_privkey_get_pk_algorithm.argtypes = [gnutls_openpgp_privkey_t, POINTER(c_uint)]
+gnutls_openpgp_privkey_import = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_import
+gnutls_openpgp_privkey_import.restype = c_int
+gnutls_openpgp_privkey_import.argtypes = [gnutls_openpgp_privkey_t, POINTER(gnutls_datum_t), gnutls_openpgp_crt_fmt_t, STRING, c_uint]
+gnutls_openpgp_privkey_sign_hash = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_sign_hash
+gnutls_openpgp_privkey_sign_hash.restype = c_int
+gnutls_openpgp_privkey_sign_hash.argtypes = [gnutls_openpgp_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_privkey_get_fingerprint = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_fingerprint
+gnutls_openpgp_privkey_get_fingerprint.restype = c_int
+gnutls_openpgp_privkey_get_fingerprint.argtypes = [gnutls_openpgp_privkey_t, c_void_p, POINTER(size_t)]
+gnutls_openpgp_privkey_get_subkey_fingerprint = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_fingerprint
+gnutls_openpgp_privkey_get_subkey_fingerprint.restype = c_int
+gnutls_openpgp_privkey_get_subkey_fingerprint.argtypes = [gnutls_openpgp_privkey_t, c_uint, c_void_p, POINTER(size_t)]
+gnutls_openpgp_privkey_get_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_key_id
+gnutls_openpgp_privkey_get_key_id.restype = c_int
+gnutls_openpgp_privkey_get_key_id.argtypes = [gnutls_openpgp_privkey_t, POINTER(c_ubyte)]
+gnutls_openpgp_privkey_get_subkey_count = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_count
+gnutls_openpgp_privkey_get_subkey_count.restype = c_int
+gnutls_openpgp_privkey_get_subkey_count.argtypes = [gnutls_openpgp_privkey_t]
+gnutls_openpgp_privkey_get_subkey_idx = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_idx
+gnutls_openpgp_privkey_get_subkey_idx.restype = c_int
+gnutls_openpgp_privkey_get_subkey_idx.argtypes = [gnutls_openpgp_privkey_t, POINTER(c_ubyte)]
+gnutls_openpgp_privkey_get_subkey_revoked_status = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_revoked_status
+gnutls_openpgp_privkey_get_subkey_revoked_status.restype = c_int
+gnutls_openpgp_privkey_get_subkey_revoked_status.argtypes = [gnutls_openpgp_privkey_t, c_uint]
+gnutls_openpgp_privkey_get_revoked_status = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_revoked_status
+gnutls_openpgp_privkey_get_revoked_status.restype = c_int
+gnutls_openpgp_privkey_get_revoked_status.argtypes = [gnutls_openpgp_privkey_t]
+gnutls_openpgp_privkey_get_subkey_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_pk_algorithm
+gnutls_openpgp_privkey_get_subkey_pk_algorithm.restype = gnutls_pk_algorithm_t
+gnutls_openpgp_privkey_get_subkey_pk_algorithm.argtypes = [gnutls_openpgp_privkey_t, c_uint, POINTER(c_uint)]
+gnutls_openpgp_privkey_get_subkey_expiration_time = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_expiration_time
+gnutls_openpgp_privkey_get_subkey_expiration_time.restype = time_t
+gnutls_openpgp_privkey_get_subkey_expiration_time.argtypes = [gnutls_openpgp_privkey_t, c_uint]
+gnutls_openpgp_privkey_get_subkey_id = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_id
+gnutls_openpgp_privkey_get_subkey_id.restype = c_int
+gnutls_openpgp_privkey_get_subkey_id.argtypes = [gnutls_openpgp_privkey_t, c_uint, POINTER(c_ubyte)]
+gnutls_openpgp_privkey_get_subkey_creation_time = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_creation_time
+gnutls_openpgp_privkey_get_subkey_creation_time.restype = time_t
+gnutls_openpgp_privkey_get_subkey_creation_time.argtypes = [gnutls_openpgp_privkey_t, c_uint]
+gnutls_openpgp_privkey_export_subkey_dsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_export_subkey_dsa_raw
+gnutls_openpgp_privkey_export_subkey_dsa_raw.restype = c_int
+gnutls_openpgp_privkey_export_subkey_dsa_raw.argtypes = [gnutls_openpgp_privkey_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_privkey_export_subkey_rsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_export_subkey_rsa_raw
+gnutls_openpgp_privkey_export_subkey_rsa_raw.restype = c_int
+gnutls_openpgp_privkey_export_subkey_rsa_raw.argtypes = [gnutls_openpgp_privkey_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_privkey_export_dsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_export_dsa_raw
+gnutls_openpgp_privkey_export_dsa_raw.restype = c_int
+gnutls_openpgp_privkey_export_dsa_raw.argtypes = [gnutls_openpgp_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_privkey_export_rsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_export_rsa_raw
+gnutls_openpgp_privkey_export_rsa_raw.restype = c_int
+gnutls_openpgp_privkey_export_rsa_raw.argtypes = [gnutls_openpgp_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_privkey_export = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_export
+gnutls_openpgp_privkey_export.restype = c_int
+gnutls_openpgp_privkey_export.argtypes = [gnutls_openpgp_privkey_t, gnutls_openpgp_crt_fmt_t, STRING, c_uint, c_void_p, POINTER(size_t)]
+gnutls_openpgp_privkey_set_preferred_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_set_preferred_key_id
+gnutls_openpgp_privkey_set_preferred_key_id.restype = c_int
+gnutls_openpgp_privkey_set_preferred_key_id.argtypes = [gnutls_openpgp_privkey_t, POINTER(c_ubyte)]
+gnutls_openpgp_privkey_get_preferred_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_preferred_key_id
+gnutls_openpgp_privkey_get_preferred_key_id.restype = c_int
+gnutls_openpgp_privkey_get_preferred_key_id.argtypes = [gnutls_openpgp_privkey_t, POINTER(c_ubyte)]
+gnutls_openpgp_crt_get_auth_subkey = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_auth_subkey
+gnutls_openpgp_crt_get_auth_subkey.restype = c_int
+gnutls_openpgp_crt_get_auth_subkey.argtypes = [gnutls_openpgp_crt_t, POINTER(c_ubyte), c_uint]
+gnutls_openpgp_keyring_init = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_init
+gnutls_openpgp_keyring_init.restype = c_int
+gnutls_openpgp_keyring_init.argtypes = [POINTER(gnutls_openpgp_keyring_t)]
+gnutls_openpgp_keyring_deinit = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_deinit
+gnutls_openpgp_keyring_deinit.restype = None
+gnutls_openpgp_keyring_deinit.argtypes = [gnutls_openpgp_keyring_t]
+gnutls_openpgp_keyring_import = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_import
+gnutls_openpgp_keyring_import.restype = c_int
+gnutls_openpgp_keyring_import.argtypes = [gnutls_openpgp_keyring_t, POINTER(gnutls_datum_t), gnutls_openpgp_crt_fmt_t]
+gnutls_openpgp_keyring_check_id = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_check_id
+gnutls_openpgp_keyring_check_id.restype = c_int
+gnutls_openpgp_keyring_check_id.argtypes = [gnutls_openpgp_keyring_t, POINTER(c_ubyte), c_uint]
+gnutls_openpgp_crt_verify_ring = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_verify_ring
+gnutls_openpgp_crt_verify_ring.restype = c_int
+gnutls_openpgp_crt_verify_ring.argtypes = [gnutls_openpgp_crt_t, gnutls_openpgp_keyring_t, c_uint, POINTER(c_uint)]
+gnutls_openpgp_crt_verify_self = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_verify_self
+gnutls_openpgp_crt_verify_self.restype = c_int
+gnutls_openpgp_crt_verify_self.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(c_uint)]
+gnutls_openpgp_keyring_get_crt = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_get_crt
+gnutls_openpgp_keyring_get_crt.restype = c_int
+gnutls_openpgp_keyring_get_crt.argtypes = [gnutls_openpgp_keyring_t, c_uint, POINTER(gnutls_openpgp_crt_t)]
+gnutls_openpgp_keyring_get_crt_count = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_get_crt_count
+gnutls_openpgp_keyring_get_crt_count.restype = c_int
+gnutls_openpgp_keyring_get_crt_count.argtypes = [gnutls_openpgp_keyring_t]
+gnutls_openpgp_set_recv_key_function = _libraries['libgnutls.so.26'].gnutls_openpgp_set_recv_key_function
+gnutls_openpgp_set_recv_key_function.restype = None
+gnutls_openpgp_set_recv_key_function.argtypes = [gnutls_session_t, gnutls_openpgp_recv_key_func]
+gnutls_certificate_set_openpgp_key = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_key
+gnutls_certificate_set_openpgp_key.restype = c_int
+gnutls_certificate_set_openpgp_key.argtypes = [gnutls_certificate_credentials_t, gnutls_openpgp_crt_t, gnutls_openpgp_privkey_t]
+gnutls_certificate_set_openpgp_key_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_key_file
+gnutls_certificate_set_openpgp_key_file.restype = c_int
+gnutls_certificate_set_openpgp_key_file.argtypes = [gnutls_certificate_credentials_t, STRING, STRING, gnutls_openpgp_crt_fmt_t]
+gnutls_certificate_set_openpgp_key_mem = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_key_mem
+gnutls_certificate_set_openpgp_key_mem.restype = c_int
+gnutls_certificate_set_openpgp_key_mem.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), gnutls_openpgp_crt_fmt_t]
+gnutls_certificate_set_openpgp_key_file2 = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_key_file2
+gnutls_certificate_set_openpgp_key_file2.restype = c_int
+gnutls_certificate_set_openpgp_key_file2.argtypes = [gnutls_certificate_credentials_t, STRING, STRING, STRING, gnutls_openpgp_crt_fmt_t]
+gnutls_certificate_set_openpgp_key_mem2 = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_key_mem2
+gnutls_certificate_set_openpgp_key_mem2.restype = c_int
+gnutls_certificate_set_openpgp_key_mem2.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), STRING, gnutls_openpgp_crt_fmt_t]
+gnutls_certificate_set_openpgp_keyring_mem = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_keyring_mem
+gnutls_certificate_set_openpgp_keyring_mem.restype = c_int
+gnutls_certificate_set_openpgp_keyring_mem.argtypes = [gnutls_certificate_credentials_t, POINTER(c_ubyte), size_t, gnutls_openpgp_crt_fmt_t]
+gnutls_certificate_set_openpgp_keyring_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_keyring_file
+gnutls_certificate_set_openpgp_keyring_file.restype = c_int
+gnutls_certificate_set_openpgp_keyring_file.argtypes = [gnutls_certificate_credentials_t, STRING, gnutls_openpgp_crt_fmt_t]
+gnutls_x509_crt_init = _libraries['libgnutls.so.26'].gnutls_x509_crt_init
+gnutls_x509_crt_init.restype = c_int
+gnutls_x509_crt_init.argtypes = [POINTER(gnutls_x509_crt_t)]
+gnutls_x509_crt_deinit = _libraries['libgnutls.so.26'].gnutls_x509_crt_deinit
+gnutls_x509_crt_deinit.restype = None
+gnutls_x509_crt_deinit.argtypes = [gnutls_x509_crt_t]
+gnutls_x509_crt_import = _libraries['libgnutls.so.26'].gnutls_x509_crt_import
+gnutls_x509_crt_import.restype = c_int
+gnutls_x509_crt_import.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_x509_crt_list_import = _libraries['libgnutls.so.26'].gnutls_x509_crt_list_import
+gnutls_x509_crt_list_import.restype = c_int
+gnutls_x509_crt_list_import.argtypes = [POINTER(gnutls_x509_crt_t), POINTER(c_uint), POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t, c_uint]
+gnutls_x509_crt_export = _libraries['libgnutls.so.26'].gnutls_x509_crt_export
+gnutls_x509_crt_export.restype = c_int
+gnutls_x509_crt_export.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_issuer_dn = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_issuer_dn
+gnutls_x509_crt_get_issuer_dn.restype = c_int
+gnutls_x509_crt_get_issuer_dn.argtypes = [gnutls_x509_crt_t, STRING, POINTER(size_t)]
+gnutls_x509_crt_get_issuer_dn_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_issuer_dn_oid
+gnutls_x509_crt_get_issuer_dn_oid.restype = c_int
+gnutls_x509_crt_get_issuer_dn_oid.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_issuer_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_issuer_dn_by_oid
+gnutls_x509_crt_get_issuer_dn_by_oid.restype = c_int
+gnutls_x509_crt_get_issuer_dn_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_int, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_dn = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_dn
+gnutls_x509_crt_get_dn.restype = c_int
+gnutls_x509_crt_get_dn.argtypes = [gnutls_x509_crt_t, STRING, POINTER(size_t)]
+gnutls_x509_crt_get_dn_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_dn_oid
+gnutls_x509_crt_get_dn_oid.restype = c_int
+gnutls_x509_crt_get_dn_oid.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_dn_by_oid
+gnutls_x509_crt_get_dn_by_oid.restype = c_int
+gnutls_x509_crt_get_dn_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_int, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_check_hostname = _libraries['libgnutls.so.26'].gnutls_x509_crt_check_hostname
+gnutls_x509_crt_check_hostname.restype = c_int
+gnutls_x509_crt_check_hostname.argtypes = [gnutls_x509_crt_t, STRING]
+gnutls_x509_crt_get_signature_algorithm = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_signature_algorithm
+gnutls_x509_crt_get_signature_algorithm.restype = c_int
+gnutls_x509_crt_get_signature_algorithm.argtypes = [gnutls_x509_crt_t]
+gnutls_x509_crt_get_signature = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_signature
+gnutls_x509_crt_get_signature.restype = c_int
+gnutls_x509_crt_get_signature.argtypes = [gnutls_x509_crt_t, STRING, POINTER(size_t)]
+gnutls_x509_crt_get_version = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_version
+gnutls_x509_crt_get_version.restype = c_int
+gnutls_x509_crt_get_version.argtypes = [gnutls_x509_crt_t]
+gnutls_x509_crt_get_key_id = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_key_id
+gnutls_x509_crt_get_key_id.restype = c_int
+gnutls_x509_crt_get_key_id.argtypes = [gnutls_x509_crt_t, c_uint, POINTER(c_ubyte), POINTER(size_t)]
+gnutls_x509_crt_set_authority_key_id = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_authority_key_id
+gnutls_x509_crt_set_authority_key_id.restype = c_int
+gnutls_x509_crt_set_authority_key_id.argtypes = [gnutls_x509_crt_t, c_void_p, size_t]
+gnutls_x509_crt_get_authority_key_id = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_authority_key_id
+gnutls_x509_crt_get_authority_key_id.restype = c_int
+gnutls_x509_crt_get_authority_key_id.argtypes = [gnutls_x509_crt_t, c_void_p, POINTER(size_t), POINTER(c_uint)]
+gnutls_x509_crt_get_subject_key_id = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_subject_key_id
+gnutls_x509_crt_get_subject_key_id.restype = c_int
+gnutls_x509_crt_get_subject_key_id.argtypes = [gnutls_x509_crt_t, c_void_p, POINTER(size_t), POINTER(c_uint)]
+gnutls_x509_crt_get_crl_dist_points = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_crl_dist_points
+gnutls_x509_crt_get_crl_dist_points.restype = c_int
+gnutls_x509_crt_get_crl_dist_points.argtypes = [gnutls_x509_crt_t, c_uint, c_void_p, POINTER(size_t), POINTER(c_uint), POINTER(c_uint)]
+gnutls_x509_crt_set_crl_dist_points = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_crl_dist_points
+gnutls_x509_crt_set_crl_dist_points.restype = c_int
+gnutls_x509_crt_set_crl_dist_points.argtypes = [gnutls_x509_crt_t, gnutls_x509_subject_alt_name_t, c_void_p, c_uint]
+gnutls_x509_crt_cpy_crl_dist_points = _libraries['libgnutls.so.26'].gnutls_x509_crt_cpy_crl_dist_points
+gnutls_x509_crt_cpy_crl_dist_points.restype = c_int
+gnutls_x509_crt_cpy_crl_dist_points.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_t]
+gnutls_x509_crt_get_activation_time = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_activation_time
+gnutls_x509_crt_get_activation_time.restype = time_t
+gnutls_x509_crt_get_activation_time.argtypes = [gnutls_x509_crt_t]
+gnutls_x509_crt_get_expiration_time = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_expiration_time
+gnutls_x509_crt_get_expiration_time.restype = time_t
+gnutls_x509_crt_get_expiration_time.argtypes = [gnutls_x509_crt_t]
+gnutls_x509_crt_get_serial = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_serial
+gnutls_x509_crt_get_serial.restype = c_int
+gnutls_x509_crt_get_serial.argtypes = [gnutls_x509_crt_t, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_pk_algorithm
+gnutls_x509_crt_get_pk_algorithm.restype = c_int
+gnutls_x509_crt_get_pk_algorithm.argtypes = [gnutls_x509_crt_t, POINTER(c_uint)]
+gnutls_x509_crt_get_pk_rsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_pk_rsa_raw
+gnutls_x509_crt_get_pk_rsa_raw.restype = c_int
+gnutls_x509_crt_get_pk_rsa_raw.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_crt_get_pk_dsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_pk_dsa_raw
+gnutls_x509_crt_get_pk_dsa_raw.restype = c_int
+gnutls_x509_crt_get_pk_dsa_raw.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_crt_get_subject_alt_name = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_subject_alt_name
+gnutls_x509_crt_get_subject_alt_name.restype = c_int
+gnutls_x509_crt_get_subject_alt_name.argtypes = [gnutls_x509_crt_t, c_uint, c_void_p, POINTER(size_t), POINTER(c_uint)]
+gnutls_x509_crt_get_subject_alt_name2 = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_subject_alt_name2
+gnutls_x509_crt_get_subject_alt_name2.restype = c_int
+gnutls_x509_crt_get_subject_alt_name2.argtypes = [gnutls_x509_crt_t, c_uint, c_void_p, POINTER(size_t), POINTER(c_uint), POINTER(c_uint)]
+gnutls_x509_crt_get_subject_alt_othername_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_subject_alt_othername_oid
+gnutls_x509_crt_get_subject_alt_othername_oid.restype = c_int
+gnutls_x509_crt_get_subject_alt_othername_oid.argtypes = [gnutls_x509_crt_t, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_ca_status = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_ca_status
+gnutls_x509_crt_get_ca_status.restype = c_int
+gnutls_x509_crt_get_ca_status.argtypes = [gnutls_x509_crt_t, POINTER(c_uint)]
+gnutls_x509_crt_get_basic_constraints = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_basic_constraints
+gnutls_x509_crt_get_basic_constraints.restype = c_int
+gnutls_x509_crt_get_basic_constraints.argtypes = [gnutls_x509_crt_t, POINTER(c_uint), POINTER(c_int), POINTER(c_int)]
+gnutls_x509_crt_get_key_usage = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_key_usage
+gnutls_x509_crt_get_key_usage.restype = c_int
+gnutls_x509_crt_get_key_usage.argtypes = [gnutls_x509_crt_t, POINTER(c_uint), POINTER(c_uint)]
+gnutls_x509_crt_set_key_usage = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_key_usage
+gnutls_x509_crt_set_key_usage.restype = c_int
+gnutls_x509_crt_set_key_usage.argtypes = [gnutls_x509_crt_t, c_uint]
+gnutls_x509_crt_get_proxy = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_proxy
+gnutls_x509_crt_get_proxy.restype = c_int
+gnutls_x509_crt_get_proxy.argtypes = [gnutls_x509_crt_t, POINTER(c_uint), POINTER(c_int), POINTER(STRING), POINTER(STRING), POINTER(size_t)]
+gnutls_x509_dn_oid_known = _libraries['libgnutls.so.26'].gnutls_x509_dn_oid_known
+gnutls_x509_dn_oid_known.restype = c_int
+gnutls_x509_dn_oid_known.argtypes = [STRING]
+gnutls_x509_crt_get_extension_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_extension_oid
+gnutls_x509_crt_get_extension_oid.restype = c_int
+gnutls_x509_crt_get_extension_oid.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_extension_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_extension_by_oid
+gnutls_x509_crt_get_extension_by_oid.restype = c_int
+gnutls_x509_crt_get_extension_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_int, c_void_p, POINTER(size_t), POINTER(c_uint)]
+gnutls_x509_crt_get_extension_info = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_extension_info
+gnutls_x509_crt_get_extension_info.restype = c_int
+gnutls_x509_crt_get_extension_info.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t), POINTER(c_int)]
+gnutls_x509_crt_get_extension_data = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_extension_data
+gnutls_x509_crt_get_extension_data.restype = c_int
+gnutls_x509_crt_get_extension_data.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_set_extension_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_extension_by_oid
+gnutls_x509_crt_set_extension_by_oid.restype = c_int
+gnutls_x509_crt_set_extension_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_void_p, size_t, c_uint]
+gnutls_x509_crt_set_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_dn_by_oid
+gnutls_x509_crt_set_dn_by_oid.restype = c_int
+gnutls_x509_crt_set_dn_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_uint, c_void_p, c_uint]
+gnutls_x509_crt_set_issuer_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_issuer_dn_by_oid
+gnutls_x509_crt_set_issuer_dn_by_oid.restype = c_int
+gnutls_x509_crt_set_issuer_dn_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_uint, c_void_p, c_uint]
+gnutls_x509_crt_set_version = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_version
+gnutls_x509_crt_set_version.restype = c_int
+gnutls_x509_crt_set_version.argtypes = [gnutls_x509_crt_t, c_uint]
+gnutls_x509_crt_set_key = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_key
+gnutls_x509_crt_set_key.restype = c_int
+gnutls_x509_crt_set_key.argtypes = [gnutls_x509_crt_t, gnutls_x509_privkey_t]
+gnutls_x509_crt_set_ca_status = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_ca_status
+gnutls_x509_crt_set_ca_status.restype = c_int
+gnutls_x509_crt_set_ca_status.argtypes = [gnutls_x509_crt_t, c_uint]
+gnutls_x509_crt_set_basic_constraints = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_basic_constraints
+gnutls_x509_crt_set_basic_constraints.restype = c_int
+gnutls_x509_crt_set_basic_constraints.argtypes = [gnutls_x509_crt_t, c_uint, c_int]
+gnutls_x509_crt_set_subject_alternative_name = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_subject_alternative_name
+gnutls_x509_crt_set_subject_alternative_name.restype = c_int
+gnutls_x509_crt_set_subject_alternative_name.argtypes = [gnutls_x509_crt_t, gnutls_x509_subject_alt_name_t, STRING]
+gnutls_x509_crt_sign = _libraries['libgnutls.so.26'].gnutls_x509_crt_sign
+gnutls_x509_crt_sign.restype = c_int
+gnutls_x509_crt_sign.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_t, gnutls_x509_privkey_t]
+gnutls_x509_crt_sign2 = _libraries['libgnutls.so.26'].gnutls_x509_crt_sign2
+gnutls_x509_crt_sign2.restype = c_int
+gnutls_x509_crt_sign2.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_t, gnutls_x509_privkey_t, gnutls_digest_algorithm_t, c_uint]
+gnutls_x509_crt_set_activation_time = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_activation_time
+gnutls_x509_crt_set_activation_time.restype = c_int
+gnutls_x509_crt_set_activation_time.argtypes = [gnutls_x509_crt_t, time_t]
+gnutls_x509_crt_set_expiration_time = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_expiration_time
+gnutls_x509_crt_set_expiration_time.restype = c_int
+gnutls_x509_crt_set_expiration_time.argtypes = [gnutls_x509_crt_t, time_t]
+gnutls_x509_crt_set_serial = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_serial
+gnutls_x509_crt_set_serial.restype = c_int
+gnutls_x509_crt_set_serial.argtypes = [gnutls_x509_crt_t, c_void_p, size_t]
+gnutls_x509_crt_set_subject_key_id = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_subject_key_id
+gnutls_x509_crt_set_subject_key_id.restype = c_int
+gnutls_x509_crt_set_subject_key_id.argtypes = [gnutls_x509_crt_t, c_void_p, size_t]
+gnutls_x509_crt_set_proxy_dn = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_proxy_dn
+gnutls_x509_crt_set_proxy_dn.restype = c_int
+gnutls_x509_crt_set_proxy_dn.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_t, c_uint, c_void_p, c_uint]
+gnutls_x509_crt_set_proxy = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_proxy
+gnutls_x509_crt_set_proxy.restype = c_int
+gnutls_x509_crt_set_proxy.argtypes = [gnutls_x509_crt_t, c_int, STRING, STRING, size_t]
+gnutls_x509_crt_print = _libraries['libgnutls.so.26'].gnutls_x509_crt_print
+gnutls_x509_crt_print.restype = c_int
+gnutls_x509_crt_print.argtypes = [gnutls_x509_crt_t, gnutls_certificate_print_formats_t, POINTER(gnutls_datum_t)]
+gnutls_x509_crl_print = _libraries['libgnutls.so.26'].gnutls_x509_crl_print
+gnutls_x509_crl_print.restype = c_int
+gnutls_x509_crl_print.argtypes = [gnutls_x509_crl_t, gnutls_certificate_print_formats_t, POINTER(gnutls_datum_t)]
+gnutls_x509_crt_get_raw_issuer_dn = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_raw_issuer_dn
+gnutls_x509_crt_get_raw_issuer_dn.restype = c_int
+gnutls_x509_crt_get_raw_issuer_dn.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_datum_t)]
+gnutls_x509_crt_get_raw_dn = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_raw_dn
+gnutls_x509_crt_get_raw_dn.restype = c_int
+gnutls_x509_crt_get_raw_dn.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_datum_t)]
+gnutls_x509_rdn_get = _libraries['libgnutls.so.26'].gnutls_x509_rdn_get
+gnutls_x509_rdn_get.restype = c_int
+gnutls_x509_rdn_get.argtypes = [POINTER(gnutls_datum_t), STRING, POINTER(size_t)]
+gnutls_x509_rdn_get_oid = _libraries['libgnutls.so.26'].gnutls_x509_rdn_get_oid
+gnutls_x509_rdn_get_oid.restype = c_int
+gnutls_x509_rdn_get_oid.argtypes = [POINTER(gnutls_datum_t), c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_rdn_get_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_rdn_get_by_oid
+gnutls_x509_rdn_get_by_oid.restype = c_int
+gnutls_x509_rdn_get_by_oid.argtypes = [POINTER(gnutls_datum_t), STRING, c_int, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_subject = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_subject
+gnutls_x509_crt_get_subject.restype = c_int
+gnutls_x509_crt_get_subject.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_x509_dn_t)]
+gnutls_x509_crt_get_issuer = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_issuer
+gnutls_x509_crt_get_issuer.restype = c_int
+gnutls_x509_crt_get_issuer.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_x509_dn_t)]
+gnutls_x509_dn_get_rdn_ava = _libraries['libgnutls.so.26'].gnutls_x509_dn_get_rdn_ava
+gnutls_x509_dn_get_rdn_ava.restype = c_int
+gnutls_x509_dn_get_rdn_ava.argtypes = [gnutls_x509_dn_t, c_int, c_int, POINTER(gnutls_x509_ava_st)]
+gnutls_x509_dn_init = _libraries['libgnutls.so.26'].gnutls_x509_dn_init
+gnutls_x509_dn_init.restype = c_int
+gnutls_x509_dn_init.argtypes = [POINTER(gnutls_x509_dn_t)]
+gnutls_x509_dn_import = _libraries['libgnutls.so.26'].gnutls_x509_dn_import
+gnutls_x509_dn_import.restype = c_int
+gnutls_x509_dn_import.argtypes = [gnutls_x509_dn_t, POINTER(gnutls_datum_t)]
+gnutls_x509_dn_export = _libraries['libgnutls.so.26'].gnutls_x509_dn_export
+gnutls_x509_dn_export.restype = c_int
+gnutls_x509_dn_export.argtypes = [gnutls_x509_dn_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_x509_dn_deinit = _libraries['libgnutls.so.26'].gnutls_x509_dn_deinit
+gnutls_x509_dn_deinit.restype = None
+gnutls_x509_dn_deinit.argtypes = [gnutls_x509_dn_t]
+gnutls_x509_crl_init = _libraries['libgnutls.so.26'].gnutls_x509_crl_init
+gnutls_x509_crl_init.restype = c_int
+gnutls_x509_crl_init.argtypes = [POINTER(gnutls_x509_crl_t)]
+gnutls_x509_crl_deinit = _libraries['libgnutls.so.26'].gnutls_x509_crl_deinit
+gnutls_x509_crl_deinit.restype = None
+gnutls_x509_crl_deinit.argtypes = [gnutls_x509_crl_t]
+gnutls_x509_crl_import = _libraries['libgnutls.so.26'].gnutls_x509_crl_import
+gnutls_x509_crl_import.restype = c_int
+gnutls_x509_crl_import.argtypes = [gnutls_x509_crl_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_x509_crl_export = _libraries['libgnutls.so.26'].gnutls_x509_crl_export
+gnutls_x509_crl_export.restype = c_int
+gnutls_x509_crl_export.argtypes = [gnutls_x509_crl_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_x509_crl_get_issuer_dn = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_issuer_dn
+gnutls_x509_crl_get_issuer_dn.restype = c_int
+gnutls_x509_crl_get_issuer_dn.argtypes = [gnutls_x509_crl_t, STRING, POINTER(size_t)]
+gnutls_x509_crl_get_issuer_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_issuer_dn_by_oid
+gnutls_x509_crl_get_issuer_dn_by_oid.restype = c_int
+gnutls_x509_crl_get_issuer_dn_by_oid.argtypes = [gnutls_x509_crl_t, STRING, c_int, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_crl_get_dn_oid = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_dn_oid
+gnutls_x509_crl_get_dn_oid.restype = c_int
+gnutls_x509_crl_get_dn_oid.argtypes = [gnutls_x509_crl_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crl_get_signature_algorithm = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_signature_algorithm
+gnutls_x509_crl_get_signature_algorithm.restype = c_int
+gnutls_x509_crl_get_signature_algorithm.argtypes = [gnutls_x509_crl_t]
+gnutls_x509_crl_get_signature = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_signature
+gnutls_x509_crl_get_signature.restype = c_int
+gnutls_x509_crl_get_signature.argtypes = [gnutls_x509_crl_t, STRING, POINTER(size_t)]
+gnutls_x509_crl_get_version = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_version
+gnutls_x509_crl_get_version.restype = c_int
+gnutls_x509_crl_get_version.argtypes = [gnutls_x509_crl_t]
+gnutls_x509_crl_get_this_update = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_this_update
+gnutls_x509_crl_get_this_update.restype = time_t
+gnutls_x509_crl_get_this_update.argtypes = [gnutls_x509_crl_t]
+gnutls_x509_crl_get_next_update = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_next_update
+gnutls_x509_crl_get_next_update.restype = time_t
+gnutls_x509_crl_get_next_update.argtypes = [gnutls_x509_crl_t]
+gnutls_x509_crl_get_crt_count = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_crt_count
+gnutls_x509_crl_get_crt_count.restype = c_int
+gnutls_x509_crl_get_crt_count.argtypes = [gnutls_x509_crl_t]
+gnutls_x509_crl_get_crt_serial = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_crt_serial
+gnutls_x509_crl_get_crt_serial.restype = c_int
+gnutls_x509_crl_get_crt_serial.argtypes = [gnutls_x509_crl_t, c_int, POINTER(c_ubyte), POINTER(size_t), POINTER(time_t)]
+gnutls_x509_crl_check_issuer = _libraries['libgnutls.so.26'].gnutls_x509_crl_check_issuer
+gnutls_x509_crl_check_issuer.restype = c_int
+gnutls_x509_crl_check_issuer.argtypes = [gnutls_x509_crl_t, gnutls_x509_crt_t]
+gnutls_x509_crl_set_version = _libraries['libgnutls.so.26'].gnutls_x509_crl_set_version
+gnutls_x509_crl_set_version.restype = c_int
+gnutls_x509_crl_set_version.argtypes = [gnutls_x509_crl_t, c_uint]
+gnutls_x509_crl_sign = _libraries['libgnutls.so.26'].gnutls_x509_crl_sign
+gnutls_x509_crl_sign.restype = c_int
+gnutls_x509_crl_sign.argtypes = [gnutls_x509_crl_t, gnutls_x509_crt_t, gnutls_x509_privkey_t]
+gnutls_x509_crl_sign2 = _libraries['libgnutls.so.26'].gnutls_x509_crl_sign2
+gnutls_x509_crl_sign2.restype = c_int
+gnutls_x509_crl_sign2.argtypes = [gnutls_x509_crl_t, gnutls_x509_crt_t, gnutls_x509_privkey_t, gnutls_digest_algorithm_t, c_uint]
+gnutls_x509_crl_set_this_update = _libraries['libgnutls.so.26'].gnutls_x509_crl_set_this_update
+gnutls_x509_crl_set_this_update.restype = c_int
+gnutls_x509_crl_set_this_update.argtypes = [gnutls_x509_crl_t, time_t]
+gnutls_x509_crl_set_next_update = _libraries['libgnutls.so.26'].gnutls_x509_crl_set_next_update
+gnutls_x509_crl_set_next_update.restype = c_int
+gnutls_x509_crl_set_next_update.argtypes = [gnutls_x509_crl_t, time_t]
+gnutls_x509_crl_set_crt_serial = _libraries['libgnutls.so.26'].gnutls_x509_crl_set_crt_serial
+gnutls_x509_crl_set_crt_serial.restype = c_int
+gnutls_x509_crl_set_crt_serial.argtypes = [gnutls_x509_crl_t, c_void_p, size_t, time_t]
+gnutls_x509_crl_set_crt = _libraries['libgnutls.so.26'].gnutls_x509_crl_set_crt
+gnutls_x509_crl_set_crt.restype = c_int
+gnutls_x509_crl_set_crt.argtypes = [gnutls_x509_crl_t, gnutls_x509_crt_t, time_t]
+gnutls_pkcs7_init = _libraries['libgnutls.so.26'].gnutls_pkcs7_init
+gnutls_pkcs7_init.restype = c_int
+gnutls_pkcs7_init.argtypes = [POINTER(gnutls_pkcs7_t)]
+gnutls_pkcs7_deinit = _libraries['libgnutls.so.26'].gnutls_pkcs7_deinit
+gnutls_pkcs7_deinit.restype = None
+gnutls_pkcs7_deinit.argtypes = [gnutls_pkcs7_t]
+gnutls_pkcs7_import = _libraries['libgnutls.so.26'].gnutls_pkcs7_import
+gnutls_pkcs7_import.restype = c_int
+gnutls_pkcs7_import.argtypes = [gnutls_pkcs7_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_pkcs7_export = _libraries['libgnutls.so.26'].gnutls_pkcs7_export
+gnutls_pkcs7_export.restype = c_int
+gnutls_pkcs7_export.argtypes = [gnutls_pkcs7_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_pkcs7_get_crt_count = _libraries['libgnutls.so.26'].gnutls_pkcs7_get_crt_count
+gnutls_pkcs7_get_crt_count.restype = c_int
+gnutls_pkcs7_get_crt_count.argtypes = [gnutls_pkcs7_t]
+gnutls_pkcs7_get_crt_raw = _libraries['libgnutls.so.26'].gnutls_pkcs7_get_crt_raw
+gnutls_pkcs7_get_crt_raw.restype = c_int
+gnutls_pkcs7_get_crt_raw.argtypes = [gnutls_pkcs7_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_pkcs7_set_crt_raw = _libraries['libgnutls.so.26'].gnutls_pkcs7_set_crt_raw
+gnutls_pkcs7_set_crt_raw.restype = c_int
+gnutls_pkcs7_set_crt_raw.argtypes = [gnutls_pkcs7_t, POINTER(gnutls_datum_t)]
+gnutls_pkcs7_set_crt = _libraries['libgnutls.so.26'].gnutls_pkcs7_set_crt
+gnutls_pkcs7_set_crt.restype = c_int
+gnutls_pkcs7_set_crt.argtypes = [gnutls_pkcs7_t, gnutls_x509_crt_t]
+gnutls_pkcs7_delete_crt = _libraries['libgnutls.so.26'].gnutls_pkcs7_delete_crt
+gnutls_pkcs7_delete_crt.restype = c_int
+gnutls_pkcs7_delete_crt.argtypes = [gnutls_pkcs7_t, c_int]
+gnutls_pkcs7_get_crl_raw = _libraries['libgnutls.so.26'].gnutls_pkcs7_get_crl_raw
+gnutls_pkcs7_get_crl_raw.restype = c_int
+gnutls_pkcs7_get_crl_raw.argtypes = [gnutls_pkcs7_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_pkcs7_get_crl_count = _libraries['libgnutls.so.26'].gnutls_pkcs7_get_crl_count
+gnutls_pkcs7_get_crl_count.restype = c_int
+gnutls_pkcs7_get_crl_count.argtypes = [gnutls_pkcs7_t]
+gnutls_pkcs7_set_crl_raw = _libraries['libgnutls.so.26'].gnutls_pkcs7_set_crl_raw
+gnutls_pkcs7_set_crl_raw.restype = c_int
+gnutls_pkcs7_set_crl_raw.argtypes = [gnutls_pkcs7_t, POINTER(gnutls_datum_t)]
+gnutls_pkcs7_set_crl = _libraries['libgnutls.so.26'].gnutls_pkcs7_set_crl
+gnutls_pkcs7_set_crl.restype = c_int
+gnutls_pkcs7_set_crl.argtypes = [gnutls_pkcs7_t, gnutls_x509_crl_t]
+gnutls_pkcs7_delete_crl = _libraries['libgnutls.so.26'].gnutls_pkcs7_delete_crl
+gnutls_pkcs7_delete_crl.restype = c_int
+gnutls_pkcs7_delete_crl.argtypes = [gnutls_pkcs7_t, c_int]
+gnutls_x509_crt_check_issuer = _libraries['libgnutls.so.26'].gnutls_x509_crt_check_issuer
+gnutls_x509_crt_check_issuer.restype = c_int
+gnutls_x509_crt_check_issuer.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_t]
+gnutls_x509_crt_list_verify = _libraries['libgnutls.so.26'].gnutls_x509_crt_list_verify
+gnutls_x509_crt_list_verify.restype = c_int
+gnutls_x509_crt_list_verify.argtypes = [POINTER(gnutls_x509_crt_t), c_int, POINTER(gnutls_x509_crt_t), c_int, POINTER(gnutls_x509_crl_t), c_int, c_uint, POINTER(c_uint)]
+gnutls_x509_crt_verify = _libraries['libgnutls.so.26'].gnutls_x509_crt_verify
+gnutls_x509_crt_verify.restype = c_int
+gnutls_x509_crt_verify.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_x509_crt_t), c_int, c_uint, POINTER(c_uint)]
+gnutls_x509_crl_verify = _libraries['libgnutls.so.26'].gnutls_x509_crl_verify
+gnutls_x509_crl_verify.restype = c_int
+gnutls_x509_crl_verify.argtypes = [gnutls_x509_crl_t, POINTER(gnutls_x509_crt_t), c_int, c_uint, POINTER(c_uint)]
+gnutls_x509_crt_check_revocation = _libraries['libgnutls.so.26'].gnutls_x509_crt_check_revocation
+gnutls_x509_crt_check_revocation.restype = c_int
+gnutls_x509_crt_check_revocation.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_x509_crl_t), c_int]
+gnutls_x509_crt_get_fingerprint = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_fingerprint
+gnutls_x509_crt_get_fingerprint.restype = c_int
+gnutls_x509_crt_get_fingerprint.argtypes = [gnutls_x509_crt_t, gnutls_digest_algorithm_t, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_key_purpose_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_key_purpose_oid
+gnutls_x509_crt_get_key_purpose_oid.restype = c_int
+gnutls_x509_crt_get_key_purpose_oid.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t), POINTER(c_uint)]
+gnutls_x509_crt_set_key_purpose_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_key_purpose_oid
+gnutls_x509_crt_set_key_purpose_oid.restype = c_int
+gnutls_x509_crt_set_key_purpose_oid.argtypes = [gnutls_x509_crt_t, c_void_p, c_uint]
+gnutls_x509_privkey_init = _libraries['libgnutls.so.26'].gnutls_x509_privkey_init
+gnutls_x509_privkey_init.restype = c_int
+gnutls_x509_privkey_init.argtypes = [POINTER(gnutls_x509_privkey_t)]
+gnutls_x509_privkey_deinit = _libraries['libgnutls.so.26'].gnutls_x509_privkey_deinit
+gnutls_x509_privkey_deinit.restype = None
+gnutls_x509_privkey_deinit.argtypes = [gnutls_x509_privkey_t]
+gnutls_x509_privkey_cpy = _libraries['libgnutls.so.26'].gnutls_x509_privkey_cpy
+gnutls_x509_privkey_cpy.restype = c_int
+gnutls_x509_privkey_cpy.argtypes = [gnutls_x509_privkey_t, gnutls_x509_privkey_t]
+gnutls_x509_privkey_import = _libraries['libgnutls.so.26'].gnutls_x509_privkey_import
+gnutls_x509_privkey_import.restype = c_int
+gnutls_x509_privkey_import.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_x509_privkey_import_pkcs8 = _libraries['libgnutls.so.26'].gnutls_x509_privkey_import_pkcs8
+gnutls_x509_privkey_import_pkcs8.restype = c_int
+gnutls_x509_privkey_import_pkcs8.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t, STRING, c_uint]
+gnutls_x509_privkey_import_rsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_privkey_import_rsa_raw
+gnutls_x509_privkey_import_rsa_raw.restype = c_int
+gnutls_x509_privkey_import_rsa_raw.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_privkey_fix = _libraries['libgnutls.so.26'].gnutls_x509_privkey_fix
+gnutls_x509_privkey_fix.restype = c_int
+gnutls_x509_privkey_fix.argtypes = [gnutls_x509_privkey_t]
+gnutls_x509_privkey_export_dsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_privkey_export_dsa_raw
+gnutls_x509_privkey_export_dsa_raw.restype = c_int
+gnutls_x509_privkey_export_dsa_raw.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_privkey_import_dsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_privkey_import_dsa_raw
+gnutls_x509_privkey_import_dsa_raw.restype = c_int
+gnutls_x509_privkey_import_dsa_raw.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_privkey_get_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_x509_privkey_get_pk_algorithm
+gnutls_x509_privkey_get_pk_algorithm.restype = c_int
+gnutls_x509_privkey_get_pk_algorithm.argtypes = [gnutls_x509_privkey_t]
+gnutls_x509_privkey_get_key_id = _libraries['libgnutls.so.26'].gnutls_x509_privkey_get_key_id
+gnutls_x509_privkey_get_key_id.restype = c_int
+gnutls_x509_privkey_get_key_id.argtypes = [gnutls_x509_privkey_t, c_uint, POINTER(c_ubyte), POINTER(size_t)]
+gnutls_x509_privkey_generate = _libraries['libgnutls.so.26'].gnutls_x509_privkey_generate
+gnutls_x509_privkey_generate.restype = c_int
+gnutls_x509_privkey_generate.argtypes = [gnutls_x509_privkey_t, gnutls_pk_algorithm_t, c_uint, c_uint]
+gnutls_x509_privkey_export = _libraries['libgnutls.so.26'].gnutls_x509_privkey_export
+gnutls_x509_privkey_export.restype = c_int
+gnutls_x509_privkey_export.argtypes = [gnutls_x509_privkey_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_x509_privkey_export_pkcs8 = _libraries['libgnutls.so.26'].gnutls_x509_privkey_export_pkcs8
+gnutls_x509_privkey_export_pkcs8.restype = c_int
+gnutls_x509_privkey_export_pkcs8.argtypes = [gnutls_x509_privkey_t, gnutls_x509_crt_fmt_t, STRING, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_privkey_export_rsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_privkey_export_rsa_raw
+gnutls_x509_privkey_export_rsa_raw.restype = c_int
+gnutls_x509_privkey_export_rsa_raw.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_privkey_sign_data = _libraries['libgnutls.so.26'].gnutls_x509_privkey_sign_data
+gnutls_x509_privkey_sign_data.restype = c_int
+gnutls_x509_privkey_sign_data.argtypes = [gnutls_x509_privkey_t, gnutls_digest_algorithm_t, c_uint, POINTER(gnutls_datum_t), c_void_p, POINTER(size_t)]
+gnutls_x509_privkey_verify_data = _libraries['libgnutls.so.26'].gnutls_x509_privkey_verify_data
+gnutls_x509_privkey_verify_data.restype = c_int
+gnutls_x509_privkey_verify_data.argtypes = [gnutls_x509_privkey_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_crt_verify_data = _libraries['libgnutls.so.26'].gnutls_x509_crt_verify_data
+gnutls_x509_crt_verify_data.restype = c_int
+gnutls_x509_crt_verify_data.argtypes = [gnutls_x509_crt_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_privkey_sign_hash = _libraries['libgnutls.so.26'].gnutls_x509_privkey_sign_hash
+gnutls_x509_privkey_sign_hash.restype = c_int
+gnutls_x509_privkey_sign_hash.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_crq_init = _libraries['libgnutls.so.26'].gnutls_x509_crq_init
+gnutls_x509_crq_init.restype = c_int
+gnutls_x509_crq_init.argtypes = [POINTER(gnutls_x509_crq_t)]
+gnutls_x509_crq_deinit = _libraries['libgnutls.so.26'].gnutls_x509_crq_deinit
+gnutls_x509_crq_deinit.restype = None
+gnutls_x509_crq_deinit.argtypes = [gnutls_x509_crq_t]
+gnutls_x509_crq_import = _libraries['libgnutls.so.26'].gnutls_x509_crq_import
+gnutls_x509_crq_import.restype = c_int
+gnutls_x509_crq_import.argtypes = [gnutls_x509_crq_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_x509_crq_get_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_pk_algorithm
+gnutls_x509_crq_get_pk_algorithm.restype = c_int
+gnutls_x509_crq_get_pk_algorithm.argtypes = [gnutls_x509_crq_t, POINTER(c_uint)]
+gnutls_x509_crq_get_dn = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_dn
+gnutls_x509_crq_get_dn.restype = c_int
+gnutls_x509_crq_get_dn.argtypes = [gnutls_x509_crq_t, STRING, POINTER(size_t)]
+gnutls_x509_crq_get_dn_oid = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_dn_oid
+gnutls_x509_crq_get_dn_oid.restype = c_int
+gnutls_x509_crq_get_dn_oid.argtypes = [gnutls_x509_crq_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crq_get_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_dn_by_oid
+gnutls_x509_crq_get_dn_by_oid.restype = c_int
+gnutls_x509_crq_get_dn_by_oid.argtypes = [gnutls_x509_crq_t, STRING, c_int, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_crq_set_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crq_set_dn_by_oid
+gnutls_x509_crq_set_dn_by_oid.restype = c_int
+gnutls_x509_crq_set_dn_by_oid.argtypes = [gnutls_x509_crq_t, STRING, c_uint, c_void_p, c_uint]
+gnutls_x509_crq_set_version = _libraries['libgnutls.so.26'].gnutls_x509_crq_set_version
+gnutls_x509_crq_set_version.restype = c_int
+gnutls_x509_crq_set_version.argtypes = [gnutls_x509_crq_t, c_uint]
+gnutls_x509_crq_set_key = _libraries['libgnutls.so.26'].gnutls_x509_crq_set_key
+gnutls_x509_crq_set_key.restype = c_int
+gnutls_x509_crq_set_key.argtypes = [gnutls_x509_crq_t, gnutls_x509_privkey_t]
+gnutls_x509_crq_sign2 = _libraries['libgnutls.so.26'].gnutls_x509_crq_sign2
+gnutls_x509_crq_sign2.restype = c_int
+gnutls_x509_crq_sign2.argtypes = [gnutls_x509_crq_t, gnutls_x509_privkey_t, gnutls_digest_algorithm_t, c_uint]
+gnutls_x509_crq_sign = _libraries['libgnutls.so.26'].gnutls_x509_crq_sign
+gnutls_x509_crq_sign.restype = c_int
+gnutls_x509_crq_sign.argtypes = [gnutls_x509_crq_t, gnutls_x509_privkey_t]
+gnutls_x509_crq_set_challenge_password = _libraries['libgnutls.so.26'].gnutls_x509_crq_set_challenge_password
+gnutls_x509_crq_set_challenge_password.restype = c_int
+gnutls_x509_crq_set_challenge_password.argtypes = [gnutls_x509_crq_t, STRING]
+gnutls_x509_crq_get_challenge_password = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_challenge_password
+gnutls_x509_crq_get_challenge_password.restype = c_int
+gnutls_x509_crq_get_challenge_password.argtypes = [gnutls_x509_crq_t, STRING, POINTER(size_t)]
+gnutls_x509_crq_set_attribute_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crq_set_attribute_by_oid
+gnutls_x509_crq_set_attribute_by_oid.restype = c_int
+gnutls_x509_crq_set_attribute_by_oid.argtypes = [gnutls_x509_crq_t, STRING, c_void_p, size_t]
+gnutls_x509_crq_get_attribute_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_attribute_by_oid
+gnutls_x509_crq_get_attribute_by_oid.restype = c_int
+gnutls_x509_crq_get_attribute_by_oid.argtypes = [gnutls_x509_crq_t, STRING, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crq_export = _libraries['libgnutls.so.26'].gnutls_x509_crq_export
+gnutls_x509_crq_export.restype = c_int
+gnutls_x509_crq_export.argtypes = [gnutls_x509_crq_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_set_crq = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_crq
+gnutls_x509_crt_set_crq.restype = c_int
+gnutls_x509_crt_set_crq.argtypes = [gnutls_x509_crt_t, gnutls_x509_crq_t]
+__all__ = ['gnutls_ia_set_server_avp_ptr',
+           'gnutls_openpgp_privkey_init',
+           'gnutls_certificate_activation_time_peers',
+           'gnutls_x509_crt_set_proxy_dn',
+           'gnutls_db_set_remove_function',
+           'gnutls_x509_crt_set_dn_by_oid',
+           'gnutls_x509_crt_check_hostname',
+           'gnutls_openpgp_keyring_get_crt',
+           'gnutls_global_init_extra',
+           'gnutls_srp_set_client_credentials_function',
+           'gnutls_x509_crl_import',
+           'gnutls_certificate_set_x509_trust_file',
+           'gnutls_x509_crt_get_pk_rsa_raw',
+           'gnutls_x509_privkey_export_rsa_raw',
+           'gnutls_priority_set', 'gnutls_cipher_get',
+           'gnutls_certificate_set_openpgp_keyring_mem',
+           'gnutls_x509_crt_get_ca_status',
+           'gnutls_cipher_get_key_size',
+           'gnutls_certificate_set_x509_crl_file',
+           'gnutls_x509_privkey_import_dsa_raw',
+           'gnutls_x509_crq_init', 'gnutls_session_get_master_secret',
+           'gnutls_x509_crq_get_challenge_password', '__time_t',
+           'gnutls_x509_crt_get_pk_algorithm',
+           'gnutls_x509_crt_set_crq',
+           'gnutls_certificate_set_openpgp_key_mem2',
+           'gnutls_certificate_free_keys', 'gnutls_srp_verifier',
+           'gnutls_x509_crl_deinit',
+           'gnutls_openpgp_crt_get_pk_dsa_raw',
+           'gnutls_certificate_free_ca_names', 'gnutls_cipher_list',
+           'gnutls_x509_crq_export',
+           'gnutls_certificate_client_set_retrieve_function',
+           'gnutls_x509_crl_get_crt_serial',
+           'gnutls_pkcs7_get_crt_count',
+           'gnutls_certificate_set_x509_trust',
+           'gnutls_openpgp_crt_get_subkey_fingerprint',
+           'gnutls_ia_handshake_p',
+           'gnutls_openpgp_privkey_get_subkey_fingerprint',
+           'gnutls_openpgp_keyring_import', 'gnutls_pkcs7_set_crl',
+           'gnutls_x509_crq_get_pk_algorithm',
+           'gnutls_pkcs7_set_crl_raw',
+           'gnutls_certificate_set_verify_limits',
+           'gnutls_x509_crt_get_authority_key_id',
+           'gnutls_x509_crt_set_activation_time', 'gnutls_db_set_ptr',
+           'gnutls_openpgp_crt_get_version',
+           'gnutls_x509_crt_get_subject_key_id',
+           'gnutls_credentials_clear', 'gnutls_x509_crt_get_key_id',
+           'gnutls_x509_crt_init', 'gnutls_dh_params_generate2',
+           'gnutls_pkcs7_delete_crt',
+           'gnutls_x509_crt_get_subject_alt_name2',
+           'gnutls_alert_get_name',
+           'gnutls_x509_crt_set_authority_key_id',
+           'gnutls_openpgp_crt_get_subkey_pk_rsa_raw',
+           'gnutls_x509_crt_list_verify', 'gnutls_priority_init',
+           'gnutls_openpgp_crt_get_expiration_time',
+           'gnutls_x509_crl_set_version',
+           'gnutls_certificate_set_openpgp_keyring_file',
+           'gnutls_pem_base64_encode',
+           'gnutls_handshake_set_max_packet_length',
+           'gnutls_openpgp_privkey_get_subkey_expiration_time',
+           'gnutls_x509_crq_set_dn_by_oid', 'gnutls_session_get_id',
+           'gnutls_cipher_set_priority',
+           'gnutls_openpgp_keyring_check_id',
+           'gnutls_openpgp_keyring_deinit',
+           'gnutls_srp_base64_encode_alloc',
+           'gnutls_db_set_store_function',
+           'gnutls_supplemental_get_name',
+           'gnutls_handshake_get_last_out',
+           'gnutls_x509_privkey_export_pkcs8',
+           'gnutls_x509_privkey_deinit', 'gnutls_compression_get_id',
+           'gnutls_openpgp_crt_get_subkey_idx',
+           'gnutls_x509_privkey_import_rsa_raw',
+           'gnutls_transport_set_errno',
+           'gnutls_openpgp_privkey_get_subkey_revoked_status',
+           'gnutls_x509_crt_get_issuer_dn',
+           'gnutls_ia_get_server_avp_ptr',
+           'gnutls_openpgp_keyring_get_crt_count', 'gnutls_ia_recv',
+           'gnutls_x509_crt_get_pk_dsa_raw', 'gnutls_x509_crt_sign',
+           'gnutls_certificate_verify_peers',
+           'gnutls_srp_free_server_credentials',
+           'gnutls_x509_crt_print',
+           'gnutls_openpgp_privkey_export_subkey_dsa_raw',
+           'gnutls_server_name_set', 'gnutls_kx_set_priority',
+           'gnutls_transport_set_push_function',
+           'gnutls_x509_crt_sign2',
+           'gnutls_x509_crt_cpy_crl_dist_points',
+           'gnutls_pem_base64_decode', 'gnutls_srp_base64_decode',
+           'gnutls_openpgp_privkey_get_subkey_count',
+           'gnutls_global_init', 'gnutls_x509_rdn_get_by_oid',
+           'gnutls_dh_params_import_raw',
+           'gnutls_global_set_mem_functions',
+           'gnutls_x509_crt_set_key_usage', 'time_t',
+           'gnutls_anon_set_server_params_function',
+           'gnutls_mac_get_key_size',
+           'gnutls_rsa_params_export_pkcs1',
+           'gnutls_certificate_type_set_priority',
+           'gnutls_x509_crt_get_issuer_dn_oid',
+           'gnutls_dh_params_init',
+           'gnutls_x509_crq_set_attribute_by_oid',
+           'gnutls_certificate_expiration_time_peers',
+           'gnutls_ia_endphase_send',
+           'gnutls_psk_allocate_server_credentials',
+           'gnutls_certificate_set_dh_params', 'gnutls_init',
+           'gnutls_openpgp_privkey_get_subkey_pk_algorithm',
+           'gnutls_x509_rdn_get_oid', 'gnutls_x509_crl_get_crt_count',
+           'gnutls_perror', 'gnutls_x509_crl_get_dn_oid',
+           'gnutls_certificate_get_peers',
+           'gnutls_ia_set_server_avp_function',
+           'gnutls_x509_crl_sign2',
+           'gnutls_x509_crt_get_extension_oid',
+           'gnutls_x509_crl_sign', 'gnutls_dh_get_pubkey',
+           'gnutls_record_get_max_size', 'gnutls_x509_crt_get_dn_oid',
+           'gnutls_x509_crt_get_extension_info',
+           'gnutls_transport_get_ptr', 'gnutls_db_check_entry',
+           'gnutls_ia_generate_challenge',
+           'gnutls_certificate_server_set_retrieve_function',
+           'gnutls_certificate_set_openpgp_key',
+           'gnutls_srp_base64_encode', 'gnutls_db_get_ptr',
+           'gnutls_pkcs7_export', 'gnutls_mac_set_priority',
+           'gnutls_x509_crt_get_basic_constraints',
+           'gnutls_x509_crt_get_subject_alt_othername_oid',
+           'gnutls_cipher_get_id', 'gnutls_x509_crl_get_this_update',
+           'gnutls_x509_dn_init', 'gnutls_openpgp_crt_import',
+           'gnutls_certificate_set_x509_crl',
+           'gnutls_rsa_export_get_modulus_bits',
+           'gnutls_x509_crl_get_version',
+           'gnutls_pkcs7_get_crl_count', 'gnutls_handshake',
+           'gnutls_dh_get_group', 'gnutls_x509_crq_get_dn',
+           'gnutls_pkcs7_deinit', 'gnutls_record_check_pending',
+           'gnutls_protocol_get_name',
+           'gnutls_openpgp_privkey_sign_hash',
+           'gnutls_srp_set_server_credentials_file',
+           'gnutls_pkcs7_delete_crl', 'gnutls_rsa_params_init',
+           'gnutls_x509_crt_set_key_purpose_oid', 'gnutls_mac_get',
+           'gnutls_record_get_direction',
+           'gnutls_certificate_type_list', 'gnutls_session_get_ptr',
+           'gnutls_psk_set_server_dh_params',
+           'gnutls_x509_crt_get_raw_issuer_dn',
+           'gnutls_x509_crt_get_raw_dn', 'gnutls_record_send',
+           'gnutls_psk_allocate_client_credentials',
+           'gnutls_certificate_set_x509_key',
+           'gnutls_certificate_type_get_id',
+           'gnutls_x509_privkey_export_dsa_raw',
+           'gnutls_pk_algorithm_get_name',
+           'gnutls_openpgp_crt_get_pk_algorithm',
+           'gnutls_psk_free_client_credentials',
+           'gnutls_openpgp_crt_check_hostname',
+           'gnutls_handshake_set_post_client_hello_function',
+           'gnutls_record_set_max_size',
+           'gnutls_openpgp_crt_verify_ring',
+           'gnutls_transport_set_ptr', 'gnutls_ia_set_client_avp_ptr',
+           'gnutls_x509_privkey_generate', 'gnutls_db_remove_session',
+           'gnutls_certificate_type_get_name',
+           'gnutls_openpgp_crt_verify_self',
+           'gnutls_x509_crq_get_dn_oid', 'gnutls_x509_dn_oid_known',
+           'gnutls_openpgp_crt_print', 'gnutls_alert_send',
+           'gnutls_x509_privkey_sign_data',
+           'gnutls_x509_crt_get_extension_data',
+           'gnutls_x509_crl_set_crt_serial',
+           'gnutls_x509_crt_set_basic_constraints',
+           'gnutls_credentials_set', 'gnutls_transport_set_ptr2',
+           'gnutls_x509_crt_set_issuer_dn_by_oid',
+           'gnutls_record_disable_padding', 'gnutls_prf_raw',
+           'gnutls_anon_allocate_server_credentials',
+           'gnutls_x509_crl_get_signature',
+           'gnutls_x509_crl_check_issuer', 'gnutls_cipher_suite_info',
+           'gnutls_x509_crt_get_issuer',
+           'gnutls_certificate_set_params_function',
+           'gnutls_openpgp_crt_get_subkey_id',
+           'gnutls_psk_set_server_credentials_hint',
+           'gnutls_sign_callback_set',
+           'gnutls_x509_crt_check_revocation',
+           'gnutls_openpgp_privkey_export',
+           'gnutls_x509_crt_get_activation_time', 'gnutls_kx_list',
+           'gnutls_x509_crt_get_subject_alt_name',
+           'gnutls_openpgp_privkey_get_subkey_creation_time',
+           'gnutls_x509_crt_get_dn_by_oid', 'gnutls_rsa_params_cpy',
+           'gnutls_x509_crt_set_subject_key_id',
+           'gnutls_check_version',
+           'gnutls_certificate_client_get_request_status',
+           'gnutls_prf', 'gnutls_srp_server_get_username',
+           'gnutls_pem_base64_encode_alloc',
+           'gnutls_certificate_set_openpgp_key_file2',
+           'gnutls_openpgp_privkey_export_rsa_raw',
+           'gnutls_certificate_set_openpgp_key_mem',
+           'gnutls_openpgp_privkey_get_key_id',
+           'gnutls_anon_free_client_credentials',
+           'gnutls_transport_get_ptr2',
+           'gnutls_ia_get_client_avp_ptr', 'gnutls_pkcs7_import',
+           'gnutls_compression_get',
+           'gnutls_x509_crl_get_signature_algorithm',
+           'gnutls_openpgp_keyring_init',
+           'gnutls_certificate_free_crls',
+           'gnutls_transport_set_global_errno', 'gnutls_record_recv',
+           'gnutls_certificate_type_get',
+           'gnutls_auth_server_get_type',
+           'gnutls_anon_set_params_function',
+           'gnutls_openpgp_crt_deinit', 'gnutls_pkcs7_set_crt',
+           'gnutls_rsa_params_export_raw',
+           'gnutls_x509_dn_get_rdn_ava', 'gnutls_x509_crt_deinit',
+           'gnutls_session_get_client_random',
+           'gnutls_openpgp_set_recv_key_function',
+           'gnutls_x509_crl_set_this_update',
+           'gnutls_ia_free_client_credentials',
+           'gnutls_protocol_get_version', 'gnutls_x509_crl_set_crt',
+           'gnutls_fingerprint', 'gnutls_x509_dn_export',
+           'gnutls_openpgp_privkey_import', 'gnutls_error_to_alert',
+           'gnutls_x509_privkey_get_key_id',
+           'gnutls_x509_crt_get_subject', 'gnutls_rsa_params_deinit',
+           'gnutls_cipher_get_name', 'gnutls_ia_send',
+           'gnutls_x509_crt_set_extension_by_oid',
+           'gnutls_x509_privkey_get_pk_algorithm',
+           'gnutls_hex_encode', 'gnutls_rsa_params_import_raw',
+           'gnutls_mac_get_name', 'gnutls_psk_server_get_username',
+           'gnutls_session_get_data2', 'gnutls_kx_get',
+           'gnutls_openpgp_crt_get_preferred_key_id',
+           'gnutls_certificate_get_x509_crls',
+           'gnutls_x509_crq_set_version', 'gnutls_x509_privkey_cpy',
+           'gnutls_openpgp_crt_get_subkey_revoked_status',
+           'gnutls_priority_set_direct', 'gnutls_dh_get_secret_bits',
+           'gnutls_x509_crt_get_expiration_time', 'gnutls_pkcs7_init',
+           'gnutls_transport_set_pull_function',
+           'gnutls_protocol_list',
+           'gnutls_srp_set_client_credentials',
+           'gnutls_x509_crt_get_key_purpose_oid',
+           'gnutls_certificate_verify_peers2',
+           'gnutls_srp_base64_decode_alloc', 'gnutls_x509_crq_sign',
+           'gnutls_x509_privkey_init', 'gnutls_global_set_log_level',
+           'gnutls_sign_callback_get', 'gnutls_x509_rdn_get',
+           'gnutls_openpgp_privkey_set_preferred_key_id',
+           'gnutls_certificate_free_credentials',
+           'gnutls_x509_dn_deinit',
+           'gnutls_certificate_set_rsa_export_params',
+           'gnutls_x509_crt_get_serial', 'gnutls_x509_crq_import',
+           'gnutls_x509_privkey_export',
+           'gnutls_cipher_suite_get_name',
+           'gnutls_ia_extract_inner_secret',
+           'gnutls_x509_crt_get_version', 'gnutls_ia_enable',
+           'gnutls_x509_crt_set_key',
+           'gnutls_srp_free_client_credentials', 'gnutls_mac_list',
+           'gnutls_dh_get_prime_bits', 'gnutls_certificate_free_cas',
+           'gnutls_alert_get', 'gnutls_ia_permute_inner_secret',
+           'gnutls_rehandshake',
+           'gnutls_x509_crt_set_subject_alternative_name',
+           'gnutls_psk_set_server_credentials_file',
+           'gnutls_dh_set_prime_bits', 'gnutls_priority_deinit',
+           'gnutls_x509_crt_set_version',
+           'gnutls_dh_params_export_pkcs3', 'gnutls_x509_crq_deinit',
+           'gnutls_x509_crt_get_fingerprint',
+           'gnutls_extra_check_version',
+           'gnutls_srp_allocate_client_credentials',
+           'gnutls_x509_crl_get_issuer_dn_by_oid',
+           'gnutls_pkcs7_get_crl_raw',
+           'gnutls_x509_crt_set_expiration_time',
+           'gnutls_compression_set_priority',
+           'gnutls_openpgp_crt_get_subkey_count',
+           'gnutls_openpgp_crt_get_key_usage',
+           'gnutls_ia_allocate_server_credentials',
+           'gnutls_ia_free_server_credentials',
+           'gnutls_transport_set_lowat',
+           'gnutls_x509_crt_set_crl_dist_points',
+           'gnutls_compression_list',
+           'gnutls_x509_privkey_import_pkcs8',
+           'gnutls_session_enable_compatibility_mode',
+           'gnutls_x509_crq_set_challenge_password',
+           'gnutls_strerror', 'gnutls_x509_crt_get_dn',
+           'gnutls_x509_crl_init',
+           'gnutls_certificate_set_verify_flags',
+           'gnutls_psk_free_server_credentials',
+           'gnutls_openpgp_privkey_get_subkey_idx',
+           'gnutls_ia_set_client_avp_function',
+           'gnutls_openpgp_crt_get_subkey_creation_time',
+           'gnutls_compression_get_name', 'gnutls_openpgp_crt_init',
+           'gnutls_x509_crq_get_dn_by_oid',
+           'gnutls_openpgp_privkey_get_pk_algorithm',
+           'gnutls_certificate_set_x509_key_file',
+           'gnutls_openpgp_crt_get_key_id',
+           'gnutls_set_default_export_priority',
+           'gnutls_x509_crl_print', 'gnutls_rsa_export_get_pubkey',
+           'gnutls_x509_crq_set_key',
+           'gnutls_x509_crt_get_signature_algorithm',
+           'gnutls_openpgp_crt_get_name',
+           'gnutls_openpgp_crt_get_subkey_pk_dsa_raw',
+           'gnutls_x509_crl_get_issuer_dn',
+           'gnutls_rsa_params_generate2',
+           'gnutls_handshake_set_private_extensions',
+           'gnutls_psk_set_client_credentials',
+           'gnutls_server_name_get',
+           'gnutls_openpgp_crt_get_subkey_usage',
+           'gnutls_rsa_params_import_pkcs1', 'gnutls_session_set_ptr',
+           'gnutls_bye', 'gnutls_auth_client_get_type',
+           'gnutls_openpgp_privkey_export_subkey_rsa_raw',
+           'gnutls_x509_crt_get_proxy', 'gnutls_kx_get_id',
+           'gnutls_session_get_data', 'gnutls_x509_crt_list_import',
+           'gnutls_pkcs7_get_crt_raw',
+           'gnutls_openpgp_privkey_get_subkey_id',
+           'gnutls_psk_set_server_credentials_function',
+           'gnutls_srp_set_server_credentials_function',
+           'gnutls_ia_verify_endphase', 'gnutls_error_is_fatal',
+           'gnutls_x509_crt_verify_data',
+           'gnutls_psk_netconf_derive_key',
+           'gnutls_certificate_server_set_request',
+           'gnutls_openpgp_privkey_get_fingerprint',
+           'gnutls_dh_params_export_raw',
+           'gnutls_protocol_set_priority',
+           'gnutls_psk_set_client_credentials_function',
+           'gnutls_set_default_priority', 'gnutls_hex2bin',
+           'gnutls_dh_params_cpy', 'gnutls_ia_handshake',
+           'gnutls_handshake_get_last_in', 'gnutls_protocol_get_id',
+           'gnutls_x509_crq_get_attribute_by_oid',
+           'gnutls_certificate_get_ours',
+           'gnutls_anon_free_server_credentials',
+           'gnutls_x509_crt_verify', 'gnutls_session_set_data',
+           'gnutls_certificate_allocate_credentials',
+           'gnutls_x509_crt_set_serial', 'gnutls_openpgp_send_cert',
+           'gnutls_certificate_set_x509_key_mem',
+           'gnutls_x509_crt_get_extension_by_oid',
+           'gnutls_session_get_server_random',
+           'gnutls_openpgp_privkey_get_revoked_status',
+           'gnutls_dh_params_deinit', 'gnutls_mac_get_id',
+           'gnutls_x509_crt_get_signature', 'gnutls_x509_crq_sign2',
+           'gnutls_global_deinit', 'gnutls_sign_algorithm_get_name',
+           'gnutls_anon_allocate_client_credentials',
+           'gnutls_x509_crt_export',
+           'gnutls_certificate_get_x509_cas',
+           'gnutls_dh_params_import_pkcs3', 'gnutls_hex_decode',
+           'gnutls_openpgp_crt_export',
+           'gnutls_psk_set_params_function',
+           'gnutls_x509_crt_check_issuer',
+           'gnutls_x509_crl_set_next_update',
+           'gnutls_ia_allocate_client_credentials',
+           'gnutls_psk_client_get_hint',
+           'gnutls_certificate_send_x509_rdn_sequence',
+           'gnutls_alert_send_appropriate',
+           'gnutls_anon_set_server_dh_params',
+           'gnutls_openpgp_crt_get_revoked_status',
+           'gnutls_openpgp_crt_get_subkey_pk_algorithm',
+           'gnutls_openpgp_privkey_get_preferred_key_id',
+           'gnutls_x509_privkey_sign_hash', 'gnutls_x509_crl_export',
+           'gnutls_openpgp_privkey_deinit',
+           'gnutls_pkcs7_set_crt_raw', 'gnutls_auth_get_type',
+           'gnutls_certificate_get_openpgp_keyring',
+           'gnutls_openpgp_privkey_export_dsa_raw',
+           'gnutls_openpgp_crt_set_preferred_key_id',
+           'gnutls_srp_allocate_server_credentials',
+           'gnutls_dh_get_peers_public_bits',
+           'gnutls_certificate_set_x509_crl_mem',
+           'gnutls_x509_privkey_fix', 'gnutls_kx_get_name',
+           'gnutls_psk_set_server_params_function',
+           'gnutls_openpgp_crt_get_fingerprint',
+           'gnutls_openpgp_crt_get_subkey_expiration_time',
+           'gnutls_x509_dn_import',
+           'gnutls_x509_crt_get_issuer_dn_by_oid',
+           'gnutls_openpgp_crt_get_creation_time',
+           'gnutls_openpgp_crt_get_pk_rsa_raw',
+           'gnutls_session_is_resumed', 'gnutls_x509_crt_set_proxy',
+           'gnutls_certificate_set_openpgp_key_file',
+           'gnutls_certificate_set_x509_trust_mem',
+           'gnutls_openpgp_crt_get_auth_subkey',
+           'gnutls_x509_privkey_verify_data', 'gnutls_deinit',
+           'gnutls_x509_crt_import',
+           'gnutls_db_set_retrieve_function',
+           'gnutls_x509_privkey_import',
+           'gnutls_certificate_set_x509_simple_pkcs12_file',
+           'gnutls_global_set_log_function',
+           'gnutls_db_set_cache_expiration',
+           'gnutls_x509_crt_set_ca_status',
+           'gnutls_x509_crl_get_next_update',
+           'gnutls_x509_crl_verify', 'gnutls_pem_base64_decode_alloc',
+           'gnutls_x509_crt_get_key_usage',
+           'gnutls_x509_crt_get_crl_dist_points']
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/library/types.py b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/library/types.py
new file mode 100644
index 0000000..0d878bb
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/library/types.py
@@ -0,0 +1,248 @@
+from ctypes import *
+
+STRING = c_char_p
+from gnutls.library.constants import gnutls_cipher_algorithm_t
+from gnutls.library.constants import gnutls_certificate_print_formats
+from gnutls.library.constants import gnutls_params_type_t
+from gnutls.library.constants import gnutls_psk_key_flags
+from gnutls.library.constants import gnutls_x509_subject_alt_name_t
+from gnutls.library.constants import gnutls_certificate_type_t
+from gnutls.library.constants import gnutls_pk_algorithm_t
+from gnutls.library.constants import gnutls_openpgp_crt_fmt
+from gnutls.library.constants import gnutls_certificate_import_flags
+from gnutls.library.constants import gnutls_certificate_verify_flags
+from gnutls.library.constants import gnutls_pkcs_encrypt_flags_t
+
+
+class gnutls_session_int(Structure):
+    pass
+gnutls_session_t = POINTER(gnutls_session_int)
+size_t = c_size_t
+gnutls_ia_avp_func = CFUNCTYPE(c_int, gnutls_session_t, c_void_p, STRING, size_t, POINTER(STRING), POINTER(size_t))
+class gnutls_ia_server_credentials_st(Structure):
+    pass
+gnutls_ia_server_credentials_st._fields_ = [
+]
+gnutls_ia_server_credentials_t = POINTER(gnutls_ia_server_credentials_st)
+class gnutls_ia_client_credentials_st(Structure):
+    pass
+gnutls_ia_client_credentials_st._fields_ = [
+]
+gnutls_ia_client_credentials_t = POINTER(gnutls_ia_client_credentials_st)
+gnutls_certificate_print_formats_t = gnutls_certificate_print_formats
+gnutls_transport_ptr_t = c_void_p
+gnutls_session_int._fields_ = [
+]
+class gnutls_dh_params_int(Structure):
+    pass
+gnutls_dh_params_int._fields_ = [
+]
+gnutls_dh_params_t = POINTER(gnutls_dh_params_int)
+class gnutls_x509_privkey_int(Structure):
+    pass
+gnutls_x509_privkey_int._fields_ = [
+]
+gnutls_rsa_params_t = POINTER(gnutls_x509_privkey_int)
+class gnutls_priority_st(Structure):
+    pass
+gnutls_priority_st._fields_ = [
+]
+gnutls_priority_t = POINTER(gnutls_priority_st)
+class gnutls_datum_t(Structure):
+    pass
+gnutls_datum_t._fields_ = [
+    ('data', POINTER(c_ubyte)),
+    ('size', c_uint),
+]
+class gnutls_params_st(Structure):
+    pass
+class params(Union):
+    pass
+params._fields_ = [
+    ('dh', gnutls_dh_params_t),
+    ('rsa_export', gnutls_rsa_params_t),
+]
+gnutls_params_st._fields_ = [
+    ('type', gnutls_params_type_t),
+    ('params', params),
+    ('deinit', c_int),
+]
+gnutls_params_function = CFUNCTYPE(c_int, gnutls_session_t, gnutls_params_type_t, POINTER(gnutls_params_st))
+gnutls_oprfi_callback_func = CFUNCTYPE(c_int, gnutls_session_t, c_void_p, size_t, POINTER(c_ubyte), POINTER(c_ubyte))
+gnutls_db_store_func = CFUNCTYPE(c_int, c_void_p, gnutls_datum_t, gnutls_datum_t)
+gnutls_db_remove_func = CFUNCTYPE(c_int, c_void_p, gnutls_datum_t)
+gnutls_db_retr_func = CFUNCTYPE(gnutls_datum_t, c_void_p, gnutls_datum_t)
+gnutls_handshake_post_client_hello_func = CFUNCTYPE(c_int, gnutls_session_t)
+class gnutls_certificate_credentials_st(Structure):
+    pass
+gnutls_certificate_credentials_st._fields_ = [
+]
+gnutls_certificate_credentials_t = POINTER(gnutls_certificate_credentials_st)
+gnutls_certificate_server_credentials = gnutls_certificate_credentials_t
+gnutls_certificate_client_credentials = gnutls_certificate_credentials_t
+class gnutls_anon_server_credentials_st(Structure):
+    pass
+gnutls_anon_server_credentials_st._fields_ = [
+]
+gnutls_anon_server_credentials_t = POINTER(gnutls_anon_server_credentials_st)
+class gnutls_anon_client_credentials_st(Structure):
+    pass
+gnutls_anon_client_credentials_st._fields_ = [
+]
+gnutls_anon_client_credentials_t = POINTER(gnutls_anon_client_credentials_st)
+gnutls_x509_privkey_t = POINTER(gnutls_x509_privkey_int)
+class gnutls_x509_crl_int(Structure):
+    pass
+gnutls_x509_crl_int._fields_ = [
+]
+gnutls_x509_crl_t = POINTER(gnutls_x509_crl_int)
+class gnutls_x509_crt_int(Structure):
+    pass
+gnutls_x509_crt_int._fields_ = [
+]
+gnutls_x509_crt_t = POINTER(gnutls_x509_crt_int)
+class gnutls_openpgp_keyring_int(Structure):
+    pass
+gnutls_openpgp_keyring_int._fields_ = [
+]
+gnutls_openpgp_keyring_t = POINTER(gnutls_openpgp_keyring_int)
+gnutls_alloc_function = CFUNCTYPE(c_void_p, size_t)
+gnutls_calloc_function = CFUNCTYPE(c_void_p, size_t, size_t)
+gnutls_is_secure_function = CFUNCTYPE(c_int, c_void_p)
+gnutls_free_function = CFUNCTYPE(None, c_void_p)
+gnutls_realloc_function = CFUNCTYPE(c_void_p, c_void_p, size_t)
+gnutls_log_func = CFUNCTYPE(None, c_int, STRING)
+__ssize_t = c_long
+ssize_t = __ssize_t
+gnutls_pull_func = CFUNCTYPE(ssize_t, gnutls_transport_ptr_t, c_void_p, size_t)
+gnutls_push_func = CFUNCTYPE(ssize_t, gnutls_transport_ptr_t, c_void_p, size_t)
+class gnutls_srp_server_credentials_st(Structure):
+    pass
+gnutls_srp_server_credentials_st._fields_ = [
+]
+gnutls_srp_server_credentials_t = POINTER(gnutls_srp_server_credentials_st)
+class gnutls_srp_client_credentials_st(Structure):
+    pass
+gnutls_srp_client_credentials_st._fields_ = [
+]
+gnutls_srp_client_credentials_t = POINTER(gnutls_srp_client_credentials_st)
+gnutls_srp_server_credentials_function = CFUNCTYPE(c_int, gnutls_session_t, STRING, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t))
+gnutls_srp_client_credentials_function = CFUNCTYPE(c_int, gnutls_session_t, POINTER(STRING), POINTER(STRING))
+class gnutls_psk_server_credentials_st(Structure):
+    pass
+gnutls_psk_server_credentials_st._fields_ = [
+]
+gnutls_psk_server_credentials_t = POINTER(gnutls_psk_server_credentials_st)
+class gnutls_psk_client_credentials_st(Structure):
+    pass
+gnutls_psk_client_credentials_st._fields_ = [
+]
+gnutls_psk_client_credentials_t = POINTER(gnutls_psk_client_credentials_st)
+gnutls_psk_server_credentials_function = CFUNCTYPE(c_int, gnutls_session_t, STRING, POINTER(gnutls_datum_t))
+gnutls_psk_client_credentials_function = CFUNCTYPE(c_int, gnutls_session_t, POINTER(STRING), POINTER(gnutls_datum_t))
+class gnutls_openpgp_crt_int(Structure):
+    pass
+gnutls_openpgp_crt_int._fields_ = [
+]
+gnutls_openpgp_crt_t = POINTER(gnutls_openpgp_crt_int)
+class gnutls_openpgp_privkey_int(Structure):
+    pass
+gnutls_openpgp_privkey_int._fields_ = [
+]
+gnutls_openpgp_privkey_t = POINTER(gnutls_openpgp_privkey_int)
+class gnutls_retr_st(Structure):
+    pass
+class cert(Union):
+    pass
+cert._fields_ = [
+    ('x509', POINTER(gnutls_x509_crt_t)),
+    ('pgp', gnutls_openpgp_crt_t),
+]
+class key(Union):
+    pass
+key._fields_ = [
+    ('x509', gnutls_x509_privkey_t),
+    ('pgp', gnutls_openpgp_privkey_t),
+]
+gnutls_retr_st._fields_ = [
+    ('type', gnutls_certificate_type_t),
+    ('cert', cert),
+    ('ncerts', c_uint),
+    ('key', key),
+    ('deinit_all', c_uint),
+]
+gnutls_certificate_client_retrieve_function = CFUNCTYPE(c_int, gnutls_session_t, POINTER(gnutls_datum_t), c_int, POINTER(gnutls_pk_algorithm_t), c_int, POINTER(gnutls_retr_st))
+gnutls_certificate_server_retrieve_function = CFUNCTYPE(c_int, gnutls_session_t, POINTER(gnutls_retr_st))
+gnutls_sign_func = CFUNCTYPE(c_int, gnutls_session_t, c_void_p, gnutls_certificate_type_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t))
+gnutls_openpgp_crt_fmt_t = gnutls_openpgp_crt_fmt
+gnutls_openpgp_keyid_t = c_ubyte * 8
+gnutls_openpgp_recv_key_func = CFUNCTYPE(c_int, gnutls_session_t, POINTER(c_ubyte), c_uint, POINTER(gnutls_datum_t))
+gnutls_x509_dn_t = c_void_p
+class gnutls_x509_ava_st(Structure):
+    pass
+gnutls_x509_ava_st._fields_ = [
+    ('oid', gnutls_datum_t),
+    ('value', gnutls_datum_t),
+    ('value_tag', c_ulong),
+]
+class gnutls_pkcs7_int(Structure):
+    pass
+gnutls_pkcs7_int._fields_ = [
+]
+gnutls_pkcs7_t = POINTER(gnutls_pkcs7_int)
+class gnutls_x509_crq_int(Structure):
+    pass
+gnutls_x509_crq_int._fields_ = [
+]
+gnutls_x509_crq_t = POINTER(gnutls_x509_crq_int)
+__all__ = ['key', 'gnutls_certificate_print_formats_t',
+           'gnutls_session_int', 'gnutls_srp_server_credentials_st',
+           'gnutls_oprfi_callback_func', '__ssize_t',
+           'gnutls_transport_ptr_t', 'gnutls_pkcs7_int',
+           'gnutls_psk_client_credentials_st', 'gnutls_priority_t',
+           'gnutls_certificate_credentials_st',
+           'gnutls_psk_server_credentials_t', 'gnutls_x509_crt_t',
+           'gnutls_x509_privkey_t', 'gnutls_openpgp_keyring_t',
+           'gnutls_x509_privkey_int', 'gnutls_push_func',
+           'gnutls_x509_crq_int', 'gnutls_psk_server_credentials_st',
+           'gnutls_openpgp_crt_t',
+           'gnutls_certificate_client_credentials', 'size_t',
+           'gnutls_ia_avp_func', 'gnutls_params_st',
+           'gnutls_anon_client_credentials_t', 'gnutls_dh_params_t',
+           'gnutls_anon_client_credentials_st', 'gnutls_sign_func',
+           'gnutls_srp_server_credentials_function', 'cert',
+           'gnutls_x509_crt_int', 'gnutls_realloc_function',
+           'gnutls_srp_client_credentials_function',
+           'gnutls_ia_server_credentials_st',
+           'gnutls_srp_client_credentials_st',
+           'gnutls_calloc_function', 'gnutls_priority_st',
+           'gnutls_x509_crl_int', 'params',
+           'gnutls_certificate_server_credentials',
+           'gnutls_handshake_post_client_hello_func',
+           'gnutls_session_t',
+           'gnutls_psk_client_credentials_function',
+           'gnutls_openpgp_privkey_int', 'gnutls_retr_st',
+           'gnutls_is_secure_function', 'gnutls_db_retr_func',
+           'gnutls_openpgp_keyring_int',
+           'gnutls_srp_client_credentials_t',
+           'gnutls_psk_client_credentials_t',
+           'gnutls_anon_server_credentials_t', 'gnutls_dh_params_int',
+           'gnutls_datum_t', 'gnutls_openpgp_crt_fmt_t',
+           'gnutls_ia_server_credentials_t', 'gnutls_x509_ava_st',
+           'gnutls_alloc_function',
+           'gnutls_psk_server_credentials_function',
+           'gnutls_anon_server_credentials_st',
+           'gnutls_params_function',
+           'gnutls_srp_server_credentials_t',
+           'gnutls_openpgp_crt_int', 'gnutls_log_func',
+           'gnutls_rsa_params_t',
+           'gnutls_certificate_server_retrieve_function',
+           'gnutls_x509_dn_t', 'gnutls_x509_crq_t',
+           'gnutls_pull_func', 'gnutls_db_remove_func',
+           'gnutls_ia_client_credentials_t',
+           'gnutls_certificate_credentials_t', 'gnutls_pkcs7_t',
+           'gnutls_ia_client_credentials_st', 'gnutls_db_store_func',
+           'ssize_t', 'gnutls_openpgp_recv_key_func',
+           'gnutls_openpgp_privkey_t', 'gnutls_openpgp_keyid_t',
+           'gnutls_free_function', 'gnutls_x509_crl_t',
+           'gnutls_certificate_client_retrieve_function']
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/validators.py b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/validators.py
new file mode 100644
index 0000000..11c29c3
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/validators.py
@@ -0,0 +1,286 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS data validators"""
+
+__all__ = ['function_args', 'method_args', 'none', 'ignore', 'list_of', 'one_of', 'ProtocolListValidator', 
+           'KeyExchangeListValidator', 'CipherListValidator', 'MACListValidator', 'CompressionListValidator']
+
+from gnutls.constants import *
+
+#
+# Priority list validators. They take a tuple or list on input and output a
+# tuple with the same elements if they check valid, else raise an exception.
+#
+
+class ProtocolListValidator(tuple):
+    _protocols = set((PROTO_TLS1_1, PROTO_TLS1_0, PROTO_SSL3))
+
+    def __new__(cls, arg):
+        if not isinstance(arg, (tuple, list)):
+            raise TypeError("Argument must be a tuple or list")
+        if not arg:
+            raise ValueError("Protocol list cannot be empty")
+        if not cls._protocols.issuperset(set(arg)):
+            raise ValueError("Got invalid protocol")
+        return tuple.__new__(cls, arg)
+
+
+class KeyExchangeListValidator(tuple):
+    _algorithms = set((KX_RSA, KX_DHE_DSS, KX_DHE_RSA, KX_RSA_EXPORT, KX_ANON_DH))
+
+    def __new__(cls, arg):
+        if not isinstance(arg, (tuple, list)):
+            raise TypeError("Argument must be a tuple or list")
+        if not arg:
+            raise ValueError("Key exchange algorithm list cannot be empty")
+        if not cls._algorithms.issuperset(set(arg)):
+            raise ValueError("Got invalid key exchange algorithm")
+        return tuple.__new__(cls, arg)
+
+
+class CipherListValidator(tuple):
+    _ciphers = set((CIPHER_AES_128_CBC, CIPHER_3DES_CBC, CIPHER_ARCFOUR_128, CIPHER_AES_256_CBC, CIPHER_DES_CBC))
+
+    def __new__(cls, arg):
+        if not isinstance(arg, (tuple, list)):
+            raise TypeError("Argument must be a tuple or list")
+        if not arg:
+            raise ValueError("Cipher list cannot be empty")
+        if not cls._ciphers.issuperset(set(arg)):
+            raise ValueError("Got invalid cipher")
+        return tuple.__new__(cls, arg)
+
+
+class MACListValidator(tuple):
+    _algorithms = set((MAC_SHA1, MAC_MD5, MAC_RMD160))
+
+    def __new__(cls, arg):
+        if not isinstance(arg, (tuple, list)):
+            raise TypeError("Argument must be a tuple or list")
+        if not arg:
+            raise ValueError("MAC algorithm list cannot be empty")
+        if not cls._algorithms.issuperset(set(arg)):
+            raise ValueError("Got invalid MAC algorithm")
+        return tuple.__new__(cls, arg)
+
+
+class CompressionListValidator(tuple):
+    _compressions = set((COMP_DEFLATE, COMP_LZO, COMP_NULL))
+
+    def __new__(cls, arg):
+        if not isinstance(arg, (tuple, list)):
+            raise TypeError("Argument must be a tuple or list")
+        if not arg:
+            raise ValueError("Compression list cannot be empty")
+        if not cls._compressions.issuperset(set(arg)):
+            raise ValueError("Got invalid compression")
+        return tuple.__new__(cls, arg)
+
+#
+# Argument validating
+#
+
+# Helper functions (internal use)
+#
+
+def isclass(obj):
+    return hasattr(obj, '__bases__') or isinstance(obj, type)
+
+# Internal validator classes
+#
+
+class Validator(object):
+    _registered = []
+    def __init__(self, typ):
+        self.type = typ
+    def check(self, value):
+        return False
+    @staticmethod
+    def can_validate(typ):
+        return False
+    @classmethod
+    def register(cls, validator):
+        cls._registered.append(validator)
+    @classmethod
+    def get(cls, typ):
+        for validator in cls._registered:
+            if validator.can_validate(typ):
+                return validator(typ)
+        else:
+            return None
+    @staticmethod
+    def join_names(names):
+        if type(names) in (tuple, list):
+            if len(names) <= 2:
+                return ' or '.join(names)
+            else:
+                return ' or '.join((', '.join(names[:-1]), names[-1]))
+        else:
+            return names
+    def _type_names(self):
+        if isinstance(self.type, tuple):
+            return self.join_names([t.__name__.replace('NoneType', 'None') for t in self.type])
+        else:
+            return self.type.__name__.replace('NoneType', 'None')
+    @property
+    def name(self):
+        name = self._type_names()
+        if name.startswith('None'):
+            prefix = ''
+        elif name[0] in ('a', 'e', 'i', 'o', 'u'):
+            prefix = 'an '
+        else:
+            prefix = 'a '
+        return prefix + name
+
+class IgnoringValidator(Validator):
+    def __init__(self, typ):
+        self.type = none
+    def check(self, value):
+        return True
+    @staticmethod
+    def can_validate(obj):
+        return obj is ignore
+
+class TypeValidator(Validator):
+    def check(self, value):
+        return isinstance(value, self.type)
+    @staticmethod
+    def can_validate(obj):
+        return isclass(obj)
+
+class MultiTypeValidator(TypeValidator):
+    @staticmethod
+    def can_validate(obj):
+        return isinstance(obj, tuple) and not filter(lambda x: not isclass(x), obj)
+
+class OneOfValidator(Validator):
+    def __init__(self, typ):
+        self.type = typ.type
+    def check(self, value):
+        return value in self.type
+    @staticmethod
+    def can_validate(obj):
+        return isinstance(obj, one_of)
+    @property
+    def name(self):
+        return 'one of %s' % self.join_names(["`%r'" % e for e in self.type])
+
+class ListOfValidator(Validator):
+    def __init__(self, typ):
+        self.type = typ.type
+    def check(self, value):
+        return isinstance(value, (tuple, list)) and not filter(lambda x: not isinstance(x, self.type), value)
+    @staticmethod
+    def can_validate(obj):
+        return isinstance(obj, list_of)
+    @property
+    def name(self):
+        return 'a list of %s' % self._type_names()
+
+class ComplexValidator(Validator):
+    def __init__(self, typ):
+        self.type = [Validator.get(x) for x in typ]
+    def check(self, value):
+        return bool(sum(t.check(value) for t in self.type))
+    @staticmethod
+    def can_validate(obj):
+        return isinstance(obj, tuple) and not filter(lambda x: Validator.get(x) is None, obj)
+    @property
+    def name(self):
+        return self.join_names([x.name for x in self.type])
+
+Validator.register(IgnoringValidator)
+Validator.register(TypeValidator)
+Validator.register(MultiTypeValidator)
+Validator.register(OneOfValidator)
+Validator.register(ListOfValidator)
+Validator.register(ComplexValidator)
+
+
+# Extra types to be used with argument validating decorators
+#
+
+none = type(None)
+
+class one_of(object):
+    def __init__(self, *args):
+        if len(args) < 2:
+            raise ValueError("one_of must have at least 2 arguments")
+        self.type = args
+
+class list_of(object):
+    def __init__(self, *args):
+        if filter(lambda x: not isclass(x), args):
+            raise TypeError("list_of arguments must be types")
+        if len(args) == 1:
+            self.type = args[0]
+        else:
+            self.type = args
+
+ignore = type('ignore', (), {})()
+
+
+# Helpers for writing well behaved decorators
+#
+
+def decorator(func):
+    """A syntactic marker with no other effect than improving readability."""
+    return func
+
+def preserve_signature(func):
+    """Preserve the original function signature and attributes in decorator wrappers."""
+    from inspect import getargspec, formatargspec
+    from gnutls.constants import GNUTLSConstant
+    constants  = [c for c in (getargspec(func)[3] or []) if isinstance(c, GNUTLSConstant)]
+    signature  = formatargspec(*getargspec(func))[1:-1]
+    parameters = formatargspec(*getargspec(func), **{'formatvalue': lambda value: ""})[1:-1]
+    def fix_signature(wrapper):
+        if constants:
+            ## import the required GNUTLSConstants used as function default arguments
+            code = "from gnutls.constants import %s\n" % ', '.join(c.name for c in constants)
+            exec code in locals(), locals()
+        code = "def %s(%s): return wrapper(%s)\nnew_wrapper = %s\n" % (func.__name__, signature, parameters, func.__name__)
+        exec code in locals(), locals()
+        new_wrapper.__name__ = func.__name__
+        new_wrapper.__doc__ = func.__doc__
+        new_wrapper.__module__ = func.__module__
+        new_wrapper.__dict__.update(func.__dict__)
+        return new_wrapper
+    return fix_signature
+
+# Argument validating decorators
+#
+
+def _callable_args(*args, **kwargs):
+    """Internal function used by argument checking decorators"""
+    start = kwargs.get('_start', 0)
+    validators = []
+    for i, arg in enumerate(args):
+        validator = Validator.get(arg)
+        if validator is None:
+            raise TypeError("unsupported type `%r' at position %d for argument checking decorator" % (arg, i+1))
+        validators.append(validator)
+    def check_args_decorator(func):
+        @preserve_signature(func)
+        def check_args(*func_args):
+            pos = start
+            for validator in validators:
+                if not validator.check(func_args[pos]):
+                    raise TypeError("argument %d must be %s" % (pos+1-start, validator.name))
+                pos += 1
+            return func(*func_args)
+        return check_args
+    return check_args_decorator
+
+@decorator
+def method_args(*args):
+    """Check class or instance method arguments"""
+    return _callable_args(*args, **{'_start': 1})
+
+@decorator
+def function_args(*args):
+    """Check functions or staticmethod arguments"""
+    return _callable_args(*args)
+
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/__init__.py b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/__init__.py
new file mode 100644
index 0000000..c72f309
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/__init__.py
@@ -0,0 +1,5 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+__version__ = '1.1.9'
+
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/connection.py b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/connection.py
new file mode 100644
index 0000000..5990bd4
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/connection.py
@@ -0,0 +1,500 @@
+# Copyright (C) 2007-2008 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS connection support"""
+
+__all__ = ['X509Credentials', 'ClientSession', 'ServerSession', 'ServerSessionFactory']
+
+from time import time
+from socket import SHUT_RDWR as SOCKET_SHUT_RDWR
+
+from _ctypes import PyObj_FromPtr
+from ctypes import *
+
+from gnutls.validators import *
+from gnutls.constants import *
+from gnutls.crypto import *
+from gnutls.errors import *
+
+from gnutls.library.constants import GNUTLS_SERVER, GNUTLS_CLIENT, GNUTLS_CRT_X509
+from gnutls.library.constants import GNUTLS_CERT_INVALID, GNUTLS_CERT_REVOKED, GNUTLS_CERT_INSECURE_ALGORITHM
+from gnutls.library.constants import GNUTLS_CERT_SIGNER_NOT_FOUND, GNUTLS_CERT_SIGNER_NOT_CA
+from gnutls.library.constants import GNUTLS_AL_FATAL, GNUTLS_A_BAD_CERTIFICATE
+from gnutls.library.constants import GNUTLS_A_UNKNOWN_CA, GNUTLS_A_INSUFFICIENT_SECURITY
+from gnutls.library.constants import GNUTLS_A_CERTIFICATE_EXPIRED, GNUTLS_A_CERTIFICATE_REVOKED
+from gnutls.library.constants import GNUTLS_NAME_DNS
+from gnutls.library.types     import gnutls_certificate_credentials_t, gnutls_session_t, gnutls_x509_crt_t
+from gnutls.library.types     import gnutls_certificate_server_retrieve_function
+from gnutls.library.functions import *
+
+
+@gnutls_certificate_server_retrieve_function
+def _retrieve_server_certificate(c_session, retr_st):
+    session = PyObj_FromPtr(gnutls_session_get_ptr(c_session))
+    identity = session.credentials.select_server_identity(session)
+    retr_st.contents.type = GNUTLS_CRT_X509
+    retr_st.contents.deinit_all = 0
+    if identity is None:
+        retr_st.contents.ncerts = 0
+    else:
+        retr_st.contents.ncerts = 1
+        retr_st.contents.cert.x509.contents = identity.cert._c_object
+        retr_st.contents.key.x509 = identity.key._c_object
+    return 0
+
+
+class _ServerNameIdentities(dict):
+    """Used internally by X509Credentials to map server names to X509 identities for the server name extension"""
+    def __init__(self, identities):
+        dict.__init__(self)
+        for identity in identities:
+            self.add(identity)
+    def add(self, identity):
+        for name in identity.cert.alternative_names.dns:
+            self[name.lower()] = identity
+        for ip in identity.cert.alternative_names.ip:
+            self[ip] = identity
+        subject = identity.cert.subject
+        if subject.CN is not None:
+            self[subject.CN.lower()] = identity
+    def get(self, server_name, default=None):
+        server_name = server_name.lower()
+        if server_name in self:
+            return self[server_name]
+        for name in (n for n in self if n.startswith('*.')):
+            suffix = name[1:]
+            if server_name.endswith(suffix) and '.' not in server_name[:-len(suffix)]:
+                return self[name]
+        return default
+
+
+class X509Credentials(object):
+    DH_BITS  = 1024
+    RSA_BITS = 1024
+
+    dh_params  = None
+    rsa_params = None
+
+    def __new__(cls, *args, **kwargs):
+        c_object = gnutls_certificate_credentials_t()
+        gnutls_certificate_allocate_credentials(byref(c_object))
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_certificate_free_credentials
+        instance._c_object = c_object
+        return instance
+
+    @method_args((X509Certificate, none), (X509PrivateKey, none), list_of(X509Certificate), list_of(X509CRL), list_of(X509Identity))
+    def __init__(self, cert=None, key=None, trusted=[], crl_list=[], identities=[]):
+        """Credentials contain a X509 certificate, a private key, a list of trusted CAs and a list of CRLs (all optional).
+        An optional list of additional X509 identities can be specified for applications that need more that one identity"""
+        if cert and key:
+            gnutls_certificate_set_x509_key(self._c_object, byref(cert._c_object), 1, key._c_object)
+        elif (cert, key) != (None, None):
+            raise ValueError("Specify neither or both the certificate and private key")
+        gnutls_certificate_server_set_retrieve_function(self._c_object, _retrieve_server_certificate)
+        self._max_depth = 5
+        self._max_bits  = 8200
+        self._type = CRED_CERTIFICATE
+        self._cert = cert
+        self._key = key
+        self._identities = tuple(identities)
+        self._trusted = ()
+        self.add_trusted(trusted)
+        self.crl_list = crl_list
+        self.server_name_identities = _ServerNameIdentities(identities)
+        if cert and key:
+            self.server_name_identities.add(X509Identity(cert, key))
+        self.session_params = SessionParams(self._type)
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
+    # Methods to alter the credentials at runtime
+
+    @method_args(list_of(X509Certificate))
+    def add_trusted(self, trusted):
+        size = len(trusted)
+        if size > 0:
+            ca_list = (gnutls_x509_crt_t * size)(*[cert._c_object for cert in trusted])
+            gnutls_certificate_set_x509_trust(self._c_object, cast(byref(ca_list), POINTER(gnutls_x509_crt_t)), size)
+            self._trusted = self._trusted + tuple(trusted)
+
+    def generate_dh_params(self, bits=DH_BITS):
+        reference = self.dh_params ## keep a reference to preserve it until replaced
+        X509Credentials.dh_params  = DHParams(bits)
+        del reference
+
+    def generate_rsa_params(self, bits=RSA_BITS):
+        reference = self.rsa_params ## keep a reference to preserve it until replaced
+        X509Credentials.rsa_params = RSAParams(bits)
+        del reference
+
+    # Properties
+
+    @property
+    def cert(self):
+        return self._cert
+
+    @property
+    def key(self):
+        return self._key
+
+    @property
+    def identities(self):
+        return self._identities
+
+    @property
+    def trusted(self):
+        return self._trusted
+
+    def _get_crl_list(self):
+        return self._crl_list
+    @method_args(list_of(X509CRL)) 
+    def _set_crl_list(self, crl_list):
+        self._crl_list = tuple(crl_list)
+    crl_list = property(_get_crl_list, _set_crl_list)
+    del _get_crl_list, _set_crl_list
+
+    def _get_max_verify_length(self):
+        return self._max_depth
+    @method_args(int) 
+    def _set_max_verify_length(self, max_depth):
+        gnutls_certificate_set_verify_limits(self._c_object, self._max_bits, max_depth)
+        self._max_depth = max_depth
+    max_verify_length = property(_get_max_verify_length, _set_max_verify_length)
+    del _get_max_verify_length, _set_max_verify_length
+
+    def _get_max_verify_bits(self):
+        return self._max_bits
+    @method_args(int) 
+    def _set_max_verify_bits(self, max_bits):
+        gnutls_certificate_set_verify_limits(self._c_object, max_bits, self._max_depth)
+        self._max_bits = max_bits
+    max_verify_bits = property(_get_max_verify_bits, _set_max_verify_bits)
+    del _get_max_verify_bits, _set_max_verify_bits
+
+    # Methods to select and validate certificates
+
+    def check_certificate(self, cert, cert_name='certificate'):
+        """Verify activation, expiration and revocation for the given certificate"""
+        now = time()
+        if cert.activation_time > now:
+            raise CertificateExpiredError("%s is not yet activated" % cert_name)
+        if cert.expiration_time < now:
+            raise CertificateExpiredError("%s has expired" % cert_name)
+        for crl in self.crl_list:
+            crl.check_revocation(cert, cert_name=cert_name)
+
+    def select_server_identity(self, session):
+        """Select which identity the server will use for a given session. The default selection algorithm uses
+        the server name extension. A subclass can overwrite it if a different selection algorithm is desired."""
+        server_name = session.server_name
+        if server_name is not None:
+            return self.server_name_identities.get(server_name)
+        elif self.cert and self.key:
+            return self ## since we have the cert and key attributes we can behave like a X509Identity
+        else:
+            return None
+
+
+class SessionParams(object):
+    _default_kx_algorithms = {
+        CRED_CERTIFICATE: (KX_RSA, KX_DHE_DSS, KX_DHE_RSA),
+        CRED_ANON: (KX_ANON_DH,)}
+    _all_kx_algorithms = {
+        CRED_CERTIFICATE: set((KX_RSA, KX_DHE_DSS, KX_DHE_RSA, KX_RSA_EXPORT)),
+        CRED_ANON: set((KX_ANON_DH,))}
+
+    def __new__(cls, credentials_type):
+        if credentials_type not in cls._default_kx_algorithms:
+            raise TypeError("Unknown credentials type: %r" % credentials_type)
+        return object.__new__(cls)
+
+    def __init__(self, credentials_type):
+        self._credentials_type = credentials_type
+        self._protocols = (PROTO_TLS1_1, PROTO_TLS1_0, PROTO_SSL3)
+        self._kx_algorithms = self._default_kx_algorithms[credentials_type]
+        self._ciphers = (CIPHER_AES_128_CBC, CIPHER_3DES_CBC, CIPHER_ARCFOUR_128)
+        self._mac_algorithms = (MAC_SHA1, MAC_MD5, MAC_RMD160)
+        self._compressions = (COMP_NULL,)
+
+    def _get_protocols(self):
+        return self._protocols
+    def _set_protocols(self, protocols):
+        self._protocols = ProtocolListValidator(protocols)
+    protocols = property(_get_protocols, _set_protocols)
+    del _get_protocols, _set_protocols
+
+    def _get_kx_algorithms(self):
+        return self._kx_algorithms
+    def _set_kx_algorithms(self, algorithms):
+        cred_type = self._credentials_type
+        algorithms = KeyExchangeListValidator(algorithms)
+        invalid = set(algorithms) - self._all_kx_algorithms[cred_type]
+        if invalid:
+            raise ValueError("Cannot specify %r with %r credentials" % (list(invalid), cred_type))
+        self._kx_algorithms = algorithms
+    kx_algorithms = property(_get_kx_algorithms, _set_kx_algorithms)
+    del _get_kx_algorithms, _set_kx_algorithms
+
+    def _get_ciphers(self):
+        return self._ciphers
+    def _set_ciphers(self, ciphers):
+        self._ciphers = CipherListValidator(ciphers)
+    ciphers = property(_get_ciphers, _set_ciphers)
+    del _get_ciphers, _set_ciphers
+
+    def _get_mac_algorithms(self):
+        return self._mac_algorithms
+    def _set_mac_algorithms(self, algorithms):
+        self._mac_algorithms = MACListValidator(algorithms)
+    mac_algorithms = property(_get_mac_algorithms, _set_mac_algorithms)
+    del _get_mac_algorithms, _set_mac_algorithms
+
+    def _get_compressions(self):
+        return self._compressions
+    def _set_compressions(self, compressions):
+        self._compressions = CompressionListValidator(compressions)
+    compressions = property(_get_compressions, _set_compressions)
+    del _get_compressions, _set_compressions
+
+
+class Session(object):
+    """Abstract class representing a TLS session created from a TCP socket
+       and a Credentials object."""
+
+    session_type = None ## placeholder for GNUTLS_SERVER or GNUTLS_CLIENT as defined by subclass
+
+    def __new__(cls, *args, **kwargs):
+        if cls is Session:
+            raise RuntimeError("Session cannot be instantiated directly")
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_deinit
+        instance._c_object = gnutls_session_t()
+        return instance
+
+    def __init__(self, socket, credentials):
+        gnutls_init(byref(self._c_object), self.session_type)
+        ## Store a pointer to self on the C session
+        gnutls_session_set_ptr(self._c_object, id(self))
+        # gnutls_dh_set_prime_bits(session, DH_BITS)?
+        gnutls_transport_set_ptr(self._c_object, socket.fileno())
+        gnutls_handshake_set_private_extensions(self._c_object, 1)
+        self.socket = socket
+        self.credentials = credentials
+        self._update_params()
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
+    def __getattr__(self, name):
+        ## Generic wrapper for the underlying socket methods and attributes.
+        return getattr(self.socket, name)
+
+    # Session properties
+
+    def _get_credentials(self):
+        return self._credentials
+    @method_args(X509Credentials)
+    def _set_credentials(self, credentials):
+        ## Release all credentials, otherwise gnutls will only release an existing credential of
+        ## the same type as the one being set and we can end up with multiple credentials in C.
+        gnutls_credentials_clear(self._c_object)
+        gnutls_credentials_set(self._c_object, credentials._type, cast(credentials._c_object, c_void_p))
+        self._credentials = credentials
+    credentials = property(_get_credentials, _set_credentials)
+    del _get_credentials, _set_credentials
+
+    @property
+    def protocol(self):
+        return gnutls_protocol_get_name(gnutls_protocol_get_version(self._c_object))
+
+    @property
+    def kx_algorithm(self):
+        return gnutls_kx_get_name(gnutls_kx_get(self._c_object))
+
+    @property
+    def cipher(self):
+        return gnutls_cipher_get_name(gnutls_cipher_get(self._c_object))
+
+    @property
+    def mac_algorithm(self):
+        return gnutls_mac_get_name(gnutls_mac_get(self._c_object))
+
+    @property
+    def compression(self):
+        return gnutls_compression_get_name(gnutls_compression_get(self._c_object))
+
+    @property
+    def peer_certificate(self):
+        if gnutls_certificate_type_get(self._c_object) != GNUTLS_CRT_X509:
+            return None
+        list_size = c_uint()
+        cert_list = gnutls_certificate_get_peers(self._c_object, byref(list_size))
+        if list_size.value == 0:
+            return None
+        cert = cert_list[0]
+        return X509Certificate(string_at(cert.data, cert.size), X509_FMT_DER)
+
+    # Status checking after an operation was interrupted (these properties are
+    # only useful to check after an operation was interrupted, otherwise their
+    # value is meaningless).
+
+    @property
+    def interrupted_while_writing(self):
+        """True if an operation was interrupted while writing"""
+        return gnutls_record_get_direction(self._c_object)==1
+
+    @property
+    def interrupted_while_reading(self):
+        """True if an operation was interrupted while reading"""
+        return gnutls_record_get_direction(self._c_object)==0
+
+    # Session methods
+
+    def _update_params(self):
+        """Update the priorities of the session params using the credentials."""
+        def c_priority_list(priorities):
+            size = len(priorities) + 1
+            return (c_int * size)(*priorities)
+        session_params = self.credentials.session_params
+        # protocol order in the priority list is irrelevant (it always uses newer protocols first)
+        # the protocol list only specifies what protocols are to be enabled.
+        gnutls_protocol_set_priority(self._c_object, c_priority_list(session_params.protocols))
+        gnutls_kx_set_priority(self._c_object, c_priority_list(session_params.kx_algorithms))
+        gnutls_cipher_set_priority(self._c_object, c_priority_list(session_params.ciphers))
+        gnutls_mac_set_priority(self._c_object, c_priority_list(session_params.mac_algorithms))
+        gnutls_compression_set_priority(self._c_object, c_priority_list(session_params.compressions))
+
+    def handshake(self):
+        gnutls_handshake(self._c_object)
+
+    #@method_args((basestring, buffer))
+    def send(self, data):
+        data = str(data)
+        return gnutls_record_send(self._c_object, data, len(data))
+
+    def sendall(self, data):
+        size = len(data)
+        while size > 0:
+            sent = self.send(data[-size:])
+            size -= sent
+
+    def recv(self, limit):
+        data = create_string_buffer(limit)
+        size = gnutls_record_recv(self._c_object, data, limit)
+        return data[:size]
+
+    def send_alert(self, exception):
+        alertdict = {
+            CertificateError: GNUTLS_A_BAD_CERTIFICATE,
+            CertificateAuthorityError: GNUTLS_A_UNKNOWN_CA,
+            CertificateSecurityError: GNUTLS_A_INSUFFICIENT_SECURITY,
+            CertificateExpiredError: GNUTLS_A_CERTIFICATE_EXPIRED,
+            CertificateRevokedError: GNUTLS_A_CERTIFICATE_REVOKED}
+        alert = alertdict.get(exception.__class__)
+        if alert:
+            gnutls_alert_send(self._c_object, GNUTLS_AL_FATAL, alert)
+
+    @method_args(one_of(SHUT_RDWR, SHUT_WR))
+    def bye(self, how=SHUT_RDWR):
+        gnutls_bye(self._c_object, how)
+
+    def shutdown(self, how=SOCKET_SHUT_RDWR):
+        self.socket.shutdown(how)
+
+    def close(self):
+        self.socket.close()
+
+    def verify_peer(self):
+        status = c_uint()
+        gnutls_certificate_verify_peers2(self._c_object, byref(status))
+        status = status.value
+        if status & GNUTLS_CERT_INVALID:
+            raise CertificateError("peer certificate is invalid")
+        elif status & GNUTLS_CERT_SIGNER_NOT_FOUND:
+            raise CertificateAuthorityError("peer certificate signer not found")
+        elif status & GNUTLS_CERT_SIGNER_NOT_CA:
+            raise CertificateAuthorityError("peer certificate signer is not a CA")
+        elif status & GNUTLS_CERT_INSECURE_ALGORITHM:
+            raise CertificateSecurityError("peer certificate uses an insecure algorithm")
+        elif status & GNUTLS_CERT_REVOKED:
+            raise CertificateRevokedError("peer certificate was revoked")
+
+
+class ClientSession(Session):
+    session_type = GNUTLS_CLIENT
+
+    def __init__(self, socket, credentials, server_name=None):
+        Session.__init__(self, socket, credentials)
+        self._server_name = None
+        if server_name is not None:
+            self.server_name = server_name
+
+    def _get_server_name(self):
+        return self._server_name
+    @method_args(str)
+    def _set_server_name(self, server_name):
+        gnutls_server_name_set(self._c_object, GNUTLS_NAME_DNS, c_char_p(server_name), len(server_name))
+        self._server_name = server_name
+    server_name = property(_get_server_name, _set_server_name)
+    del _get_server_name, _set_server_name
+
+
+class ServerSession(Session):
+    session_type = GNUTLS_SERVER
+
+    def __init__(self, socket, credentials):
+        Session.__init__(self, socket, credentials)
+        gnutls_certificate_server_set_request(self._c_object, CERT_REQUEST)
+
+    @property
+    def server_name(self):
+        data_length = c_size_t(256)
+        data = create_string_buffer(data_length.value)
+        hostname_type = c_uint()
+        for i in xrange(2**16):
+            try:
+                gnutls_server_name_get(self._c_object, data, byref(data_length), byref(hostname_type), i)
+            except RequestedDataNotAvailable:
+                break
+            except MemoryError:
+                data_length.value += 1 ## one extra byte for the terminating 0
+                data = create_string_buffer(data_length.value)
+                gnutls_server_name_get(self._c_object, data, byref(data_length), byref(hostname_type), i)
+            if hostname_type.value != GNUTLS_NAME_DNS:
+                continue
+            return data.value
+        return None
+
+
+class ServerSessionFactory(object):
+
+    def __init__(self, socket, credentials, session_class=ServerSession):
+        if not issubclass(session_class, ServerSession):
+            raise TypeError, "session_class must be a subclass of ServerSession"
+        self.socket = socket
+        self.credentials = credentials
+        self.session_class = session_class
+
+    def __getattr__(self, name):
+        ## Generic wrapper for the underlying socket methods and attributes
+        return getattr(self.socket, name)
+
+    def bind(self, address):
+        self.socket.bind(address)
+
+    def listen(self, backlog):
+        self.socket.listen(backlog)
+
+    def accept(self):
+        new_sock, address = self.socket.accept()
+        session = self.session_class(new_sock, self.credentials)
+        return (session, address)
+
+    def shutdown(self, how=SOCKET_SHUT_RDWR):
+        self.socket.shutdown(how)
+
+    def close(self):
+        self.socket.close()
+
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/constants.py b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/constants.py
new file mode 100644
index 0000000..4637a16
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/constants.py
@@ -0,0 +1,54 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS constants"""
+
+__all__ = [
+    ## GNUTLS session protocols
+    'PROTO_TLS1_1', 'PROTO_TLS1_0', 'PROTO_SSL3',
+    
+    ## Key exchange algorithms
+    'KX_RSA', 'KX_DHE_DSS', 'KX_DHE_RSA', 'KX_RSA_EXPORT', 'KX_ANON_DH',
+    
+    ## Ciphers
+    'CIPHER_AES_128_CBC', 'CIPHER_3DES_CBC', 'CIPHER_ARCFOUR_128', 'CIPHER_AES_256_CBC', 'CIPHER_DES_CBC',
+    
+    ## MAC algorithms
+    'MAC_SHA1', 'MAC_MD5', 'MAC_RMD160',
+    
+    ## Compressions
+    'COMP_DEFLATE', 'COMP_LZO', 'COMP_NULL',
+
+    ## Credential types
+    'CRED_CERTIFICATE', 'CRED_ANON',
+
+    ## X509 certificate/private key formats
+    'X509_FMT_DER', 'X509_FMT_PEM',
+
+    ## Miscellaneous
+    'CERT_REQUEST', 'CERT_REQUIRE', 'SHUT_RDWR', 'SHUT_WR'
+]
+
+__name_map__ = {
+    'PROTO_TLS1_1': 'TLS1_1', 'PROTO_TLS1_0': 'TLS1_0', 'PROTO_SSL3': 'SSL3',
+    'CRED_CERTIFICATE': 'CRD_CERTIFICATE', 'CRED_ANON': 'CRD_ANON'
+}
+
+
+from gnutls.library import constants
+
+class GNUTLSConstant(int):
+    def __new__(cls, name):
+        gnutls_name = 'GNUTLS_' + __name_map__.get(name, name)
+        instance = int.__new__(cls, getattr(constants, gnutls_name))
+        instance.name = name
+        return instance
+    def __repr__(self):
+        return self.name
+
+## Generate all exported constants
+code = '\n'.join(["%s = GNUTLSConstant('%s')" % (name, name) for name in __all__])
+exec code in locals(), globals()
+del code, name
+
+del constants
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/crypto.py b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/crypto.py
new file mode 100644
index 0000000..d330144
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/crypto.py
@@ -0,0 +1,317 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS crypto support"""
+
+__all__ = ['X509Name', 'X509Certificate', 'X509PrivateKey', 'X509Identity', 'X509CRL', 'DHParams', 'RSAParams']
+
+import re
+from ctypes import *
+
+from gnutls.validators import method_args, one_of
+from gnutls.constants import X509_FMT_DER, X509_FMT_PEM
+from gnutls.errors import *
+
+from gnutls.library.constants import GNUTLS_SAN_DNSNAME, GNUTLS_SAN_RFC822NAME, GNUTLS_SAN_URI
+from gnutls.library.constants import GNUTLS_SAN_IPADDRESS, GNUTLS_SAN_OTHERNAME, GNUTLS_SAN_DN
+from gnutls.library.constants import GNUTLS_E_SHORT_MEMORY_BUFFER
+from gnutls.library.types     import *
+from gnutls.library.functions import *
+
+
+class X509NameMeta(type):
+    long_names = {'country': 'C',
+                  'state': 'ST',
+                  'locality': 'L',
+                  'common_name': 'CN',
+                  'organization': 'O',
+                  'organization_unit': 'OU',
+                  'email': 'EMAIL'}
+    def __new__(cls, name, bases, dic):
+        instance = type.__new__(cls, name, bases, dic)
+        instance.ids = X509NameMeta.long_names.values()
+        for long_name, short_name in X509NameMeta.long_names.items():
+            ## Map a long_name property to the short_name attribute
+            cls.add_property(instance, long_name, short_name)
+        return instance
+    def add_property(instance, name, short_name):
+        setattr(instance, name, property(lambda self: getattr(self, short_name, None)))
+
+
+class X509Name(str):
+    __metaclass__ = X509NameMeta
+
+    def __init__(self, dname):
+        str.__init__(self)
+        pairs = [x.replace('\,', ',') for x in re.split(r'(?<!\\),\s*', dname)]
+        for pair in pairs:
+            try:
+                name, value = pair.split('=', 1)
+            except ValueError:
+                raise ValueError("Invalid X509 distinguished name: %s" % dname)
+            str.__setattr__(self, name, value)
+        for name in X509Name.ids:
+            if not hasattr(self, name):
+                str.__setattr__(self, name, None)
+    def __setattr__(self, name, value):
+        if name in X509Name.ids:
+            raise AttributeError("can't set attribute")
+        str.__setattr__(self, name, value)
+
+
+class AlternativeNames(object):
+    __slots__ = {'dns': GNUTLS_SAN_DNSNAME, 'email': GNUTLS_SAN_RFC822NAME, 'uri': GNUTLS_SAN_URI,
+                 'ip': GNUTLS_SAN_IPADDRESS, 'other': GNUTLS_SAN_OTHERNAME, 'dn': GNUTLS_SAN_DN}
+    def __init__(self, names):
+        object.__init__(self)
+        for name, key in self.__slots__.iteritems():
+            setattr(self, name, tuple(names.get(key, ())))
+
+
+class X509Certificate(object):
+
+    def __new__(cls, *args, **kwargs):
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_x509_crt_deinit
+        instance._c_object = gnutls_x509_crt_t()
+        instance._alternative_names = None
+        return instance
+
+    @method_args(str, one_of(X509_FMT_PEM, X509_FMT_DER))
+    def __init__(self, buf, format=X509_FMT_PEM):
+        gnutls_x509_crt_init(byref(self._c_object))
+        data = gnutls_datum_t(cast(c_char_p(buf), POINTER(c_ubyte)), c_uint(len(buf)))
+        gnutls_x509_crt_import(self._c_object, byref(data), format)
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
+    @property
+    def subject(self):
+        size = c_size_t(256)
+        dname = create_string_buffer(size.value)
+        try:
+            gnutls_x509_crt_get_dn(self._c_object, dname, byref(size))
+        except MemoryError:
+            dname = create_string_buffer(size.value)
+            gnutls_x509_crt_get_dn(self._c_object, dname, byref(size))
+        return X509Name(dname.value)
+
+    @property
+    def issuer(self):
+        size = c_size_t(256)
+        dname = create_string_buffer(size.value)
+        try:
+            gnutls_x509_crt_get_issuer_dn(self._c_object, dname, byref(size))
+        except MemoryError:
+            dname = create_string_buffer(size.value)
+            gnutls_x509_crt_get_issuer_dn(self._c_object, dname, byref(size))
+        return X509Name(dname.value)
+
+    @property
+    def alternative_names(self):
+        if self._alternative_names is not None:
+            return self._alternative_names
+        names = {}
+        size = c_size_t(256)
+        alt_name = create_string_buffer(size.value)
+        for i in xrange(65536):
+            try:
+                name_type = gnutls_x509_crt_get_subject_alt_name(self._c_object, i, alt_name, byref(size), None)
+            except RequestedDataNotAvailable:
+                break
+            except MemoryError:
+                alt_name = create_string_buffer(size.value)
+                name_type = gnutls_x509_crt_get_subject_alt_name(self._c_object, i, alt_name, byref(size), None)
+            names.setdefault(name_type, []).append(alt_name.value)
+        self._alternative_names = AlternativeNames(names)
+        return self._alternative_names
+
+    @property
+    def serial_number(self):
+        size = c_size_t(1)
+        serial = c_ulong()
+        try:
+            gnutls_x509_crt_get_serial(self._c_object, cast(byref(serial), c_void_p), byref(size))
+        except MemoryError:
+            import struct, sys
+            serial = create_string_buffer(size.value * sizeof(c_void_p))
+            gnutls_x509_crt_get_serial(self._c_object, cast(serial, c_void_p), byref(size))
+            pad = size.value * sizeof(c_void_p) - len(serial.value)
+            format = '@%dL' % size.value
+            numbers = list(struct.unpack(format, serial.value + pad*'\x00'))
+            if sys.byteorder == 'little':
+                numbers.reverse()
+            number = 0
+            offset = sizeof(c_void_p) * 8
+            for n in numbers:
+                number = (number<<offset) + n
+            return number
+        else:
+            return serial.value
+
+    @property
+    def activation_time(self):
+        return gnutls_x509_crt_get_activation_time(self._c_object)
+
+    @property
+    def expiration_time(self):
+        return gnutls_x509_crt_get_expiration_time(self._c_object)
+
+    @property
+    def version(self):
+        return gnutls_x509_crt_get_version(self._c_object)
+
+    #@method_args(X509Certificate)
+    def has_issuer(self, issuer):
+        """Return True if the certificate was issued by the given issuer, False otherwise."""
+        if not isinstance(issuer, X509Certificate):
+            raise TypeError("issuer must be an X509Certificate object")
+        return bool(gnutls_x509_crt_check_issuer(self._c_object, issuer._c_object))
+
+    @method_args(str)
+    def has_hostname(self, hostname):
+        """Return True if the hostname matches the DNSName/IPAddress subject alternative name extension
+           of this certificate, False otherwise."""
+        ## For details see http://www.ietf.org/rfc/rfc2459.txt, section 4.2.1.7 Subject Alternative Name
+        return bool(gnutls_x509_crt_check_hostname(self._c_object, hostname))
+
+    def check_issuer(self, issuer):
+        """Raise CertificateError if certificate was not issued by the given issuer"""
+        if not self.has_issuer(issuer):
+            raise CertificateError("certificate issuer doesn't match")
+
+    def check_hostname(self, hostname):
+        """Raise CertificateError if the certificate DNSName/IPAddress subject alternative name extension
+           doesn't match the given hostname"""
+        if not self.has_hostname(hostname):
+            raise CertificateError("certificate doesn't match hostname")
+
+
+class X509PrivateKey(object):
+    def __new__(cls, *args, **kwargs):
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_x509_privkey_deinit
+        instance._c_object = gnutls_x509_privkey_t()
+        return instance
+
+    @method_args(str, one_of(X509_FMT_PEM, X509_FMT_DER))
+    def __init__(self, buf, format=X509_FMT_PEM):
+        gnutls_x509_privkey_init(byref(self._c_object))
+        data = gnutls_datum_t(cast(c_char_p(buf), POINTER(c_ubyte)), c_uint(len(buf)))
+        gnutls_x509_privkey_import(self._c_object, byref(data), format)
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
+
+class X509Identity(object):
+    """A X509 identity represents a X509 certificate and private key pair"""
+    
+    __slots__ = ('cert', 'key')
+    
+    @method_args(X509Certificate, X509PrivateKey)
+    def __init__(self, cert, key):
+        self.cert = cert
+        self.key = key
+    
+    def __setattr__(self, name, value):
+        if name in self.__slots__ and hasattr(self, name):
+            raise AttributeError("can't set attribute")
+        object.__setattr__(self, name, value)
+
+    def __delattr__(self, name):
+        if name in self.__slots__:
+            raise AttributeError("can't delete attribute")
+        object.__delattr__(self, name)
+
+
+class X509CRL(object):
+    def __new__(cls, *args, **kwargs):
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_x509_crl_deinit
+        instance._c_object = gnutls_x509_crl_t()
+        return instance
+
+    @method_args(str, one_of(X509_FMT_PEM, X509_FMT_DER))
+    def __init__(self, buf, format=X509_FMT_PEM):
+        gnutls_x509_crl_init(byref(self._c_object))
+        data = gnutls_datum_t(cast(c_char_p(buf), POINTER(c_ubyte)), c_uint(len(buf)))
+        gnutls_x509_crl_import(self._c_object, byref(data), format)
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
+    @property
+    def count(self):
+        return gnutls_x509_crl_get_crt_count(self._c_object)
+
+    @property
+    def version(self):
+        return gnutls_x509_crl_get_version(self._c_object)
+
+    @property
+    def issuer(self):
+        size = c_size_t(256)
+        dname = create_string_buffer(size.value)
+        try:
+            gnutls_x509_crl_get_issuer_dn(self._c_object, dname, byref(size))
+        except MemoryError:
+            dname = create_string_buffer(size.value)
+            gnutls_x509_crl_get_issuer_dn(self._c_object, dname, byref(size))
+        return X509Name(dname.value)
+
+    @method_args(X509Certificate)
+    def is_revoked(self, cert):
+        """Return True if certificate is revoked, False otherwise"""
+        return bool(gnutls_x509_crt_check_revocation(cert._c_object, byref(self._c_object), 1))
+
+    def check_revocation(self, cert, cert_name='certificate'):
+        """Raise CertificateRevokedError if the given certificate is revoked"""
+        if self.is_revoked(cert):
+            raise CertificateRevokedError("%s was revoked" % cert_name)
+
+
+class DHParams(object):
+    def __new__(cls, *args, **kwargs):
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_dh_params_deinit
+        instance._c_object = gnutls_dh_params_t()
+        return instance
+
+    @method_args(int)
+    def __init__(self, bits=1024):
+        gnutls_dh_params_init(byref(self._c_object))
+        gnutls_dh_params_generate2(self._c_object, bits)
+
+    def __get__(self, obj, type_=None):
+        return self._c_object
+
+    def __set__(self, obj, value):
+        raise AttributeError("Read-only attribute")
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
+
+class RSAParams(object):
+    def __new__(cls, *args, **kwargs):
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_rsa_params_deinit
+        instance._c_object = gnutls_rsa_params_t()
+        return instance
+
+    @method_args(int)
+    def __init__(self, bits=1024):
+        gnutls_rsa_params_init(byref(self._c_object))
+        gnutls_rsa_params_generate2(self._c_object, bits)
+
+    def __get__(self, obj, type_=None):
+        return self._c_object
+
+    def __set__(self, obj, value):
+        raise AttributeError("Read-only attribute")
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/errors.py b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/errors.py
new file mode 100644
index 0000000..592ba1d
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/errors.py
@@ -0,0 +1,22 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS errors"""
+
+__all__ = ['Error', 'GNUTLSError', 'OperationWouldBlock', 'OperationInterrupted',
+           'CertificateError', 'CertificateAuthorityError', 'CertificateSecurityError',
+           'CertificateExpiredError', 'CertificateRevokedError', 'RequestedDataNotAvailable']
+
+class Error(Exception): pass
+
+class GNUTLSError(Error): pass
+class OperationWouldBlock(GNUTLSError): pass
+class OperationInterrupted(GNUTLSError): pass
+
+class CertificateError(GNUTLSError): pass
+class CertificateAuthorityError(CertificateError): pass
+class CertificateSecurityError(CertificateError): pass
+class CertificateExpiredError(CertificateError): pass
+class CertificateRevokedError(CertificateError): pass
+
+class RequestedDataNotAvailable(GNUTLSError): pass
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/interfaces/__init__.py b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/interfaces/__init__.py
new file mode 100644
index 0000000..dc64199
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/interfaces/__init__.py
@@ -0,0 +1,2 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/interfaces/twisted/__init__.py b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/interfaces/twisted/__init__.py
new file mode 100644
index 0000000..cee60bf
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/interfaces/twisted/__init__.py
@@ -0,0 +1,372 @@
+# Copyright (C) 2007-2008 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS Twisted interface"""
+
+__all__ = ['X509Credentials', 'connectTLS', 'listenTLS']
+
+import socket
+from time import time
+from errno import EWOULDBLOCK, EINTR
+
+from twisted.python import failure
+from twisted.internet import main, base, interfaces, address, tcp, error
+from twisted.internet.protocol import BaseProtocol
+
+from zope.interface import implements, implementsOnly, implementedBy
+
+from gnutls.connection import ClientSession, ServerSession, ServerSessionFactory
+from gnutls.connection import X509Credentials as _X509Credentials
+from gnutls.constants import SHUT_RDWR, SHUT_WR
+from gnutls.errors import *
+
+
+class KeepRunning:
+    """Return this class from a recurrent function to indicate that it should keep running"""
+    pass
+
+class RecurrentCall(object):
+    """Execute a function repeatedly at the given interval, until signaled to stop"""
+    def __init__(self, period, func, *args, **kwargs):
+        from twisted.internet import reactor
+        self.func = func
+        self.args = args
+        self.kwargs = kwargs
+        self.period = period
+        self.now = None
+        self.next = None
+        self.callid = reactor.callLater(period, self)
+    def __call__(self):
+        from twisted.internet import reactor
+        self.callid = None
+        if self.now is None:
+            self.now = time()
+            self.next = self.now + self.period
+        else:
+            self.now, self.next = self.next, self.next + self.period
+        result = self.func(*self.args, **self.kwargs)
+        if result is KeepRunning:
+            delay = max(self.next-time(), 0)
+            self.callid = reactor.callLater(delay, self)
+    def cancel(self):
+        if self.callid is not None:
+            try:
+                self.callid.cancel()
+            except ValueError:
+                pass
+            self.callid = None
+
+
+class CertificateOK: pass
+
+class X509Credentials(_X509Credentials):
+    """A Twisted enhanced X509Credentials"""
+    verify_peer = False
+    verify_period = None
+
+    def verify_callback(self, peer_cert, preverify_status=None):
+        """Verifies the peer certificate and raises an exception if it cannot be accepted"""
+        if isinstance(preverify_status, Exception):
+            raise preverify_status
+        self.check_certificate(peer_cert, cert_name='peer certificate')
+
+
+class TLSMixin:
+    """TLS specific functionality common to both clients and servers"""
+
+    def getPeerCertificate(self):
+        return self.socket.peer_certificate
+
+    def doRead(self):
+        try:
+            return tcp.Connection.doRead(self)
+        except (OperationWouldBlock, OperationInterrupted):
+            return
+        except GNUTLSError, e:
+            return e
+
+    def writeSomeData(self, data):
+        try:
+            return tcp.Connection.writeSomeData(self, data)
+        except OperationInterrupted:
+            return self.writeSomeData(data)
+        except OperationWouldBlock:
+            return 0
+        except GNUTLSError, e:
+            return e
+
+    def _sendCloseReason(self, reason):
+        try:
+            self.socket.send_alert(reason)
+        except OperationInterrupted:
+            self._sendCloseReason(reason)
+
+    def _sendCloseAlert(self, how=SHUT_RDWR):
+        try:
+            self.socket.bye(how)
+        except OperationInterrupted:
+            self._sendCloseAlert(how)
+
+    def closeTLSSession(self, reason):
+        try:
+            self._sendCloseReason(reason)
+            self._sendCloseAlert(SHUT_RDWR)
+        except Exception, e:
+            pass
+
+    def _postLoseConnection(self):
+        self.closeTLSSession(self._close_reason)
+        return self._close_reason
+
+    def endTLSWrite(self):
+        self.stopWriting()
+        try:
+            self._sendCloseAlert(SHUT_WR)
+        except OperationWouldBlock, e:
+            if self.socket.interrupted_while_writing:
+                self.startWriting()
+                return
+        except Exception, e:
+            return e
+        del self.doWrite
+
+    def _closeWriteConnection(self):
+        self.doWrite = self.endTLSWrite
+        result = self.endTLSWrite()
+        if isinstance(result, Exception):
+            return result
+        return tcp.Connection._closeWriteConnection(self)
+
+
+class TLSClient(TLSMixin, tcp.Client):
+    """Add TLS capabilities to a TCP client"""
+    
+    implementsOnly(interfaces.ISSLTransport, *[i for i in implementedBy(tcp.Client) if i != interfaces.ITLSTransport])
+    
+    def __init__(self, host, port, bindAddress, credentials, connector, reactor=None, server_name=None):
+        self.credentials = credentials
+        self.server_name = server_name
+        self.__watchdog = None
+        tcp.Client.__init__(self, host, port, bindAddress, connector, reactor)
+
+    def createInternetSocket(self):
+        sock = tcp.Client.createInternetSocket(self)
+        return ClientSession(sock, self.credentials, self.server_name)
+
+    def _recurrentVerify(self):
+        if not self.connected or self.disconnecting:
+            return
+        try:
+            self.credentials.verify_callback(self.socket.peer_certificate)
+        except Exception, e:
+            self.loseConnection(e)
+            return
+        else:
+            return KeepRunning
+
+    def _verifyPeer(self):
+        session = self.socket
+        credentials = self.credentials
+        if not credentials.verify_peer:
+            return
+        try:
+            session.verify_peer()
+        except Exception, e:
+            preverify_status = e
+        else:
+            preverify_status = CertificateOK
+        
+        credentials.verify_callback(session.peer_certificate, preverify_status)
+        
+        if credentials.verify_period > 0:
+            self.__watchdog = RecurrentCall(credentials.verify_period, self._recurrentVerify)
+
+    def doHandshake(self):
+        self.stopWriting()
+        try:
+            self.socket.handshake()
+        except (OperationWouldBlock, OperationInterrupted):
+            if self.socket.interrupted_while_writing:
+                self.startWriting()
+            return
+        except GNUTLSError, e:
+            del self.doRead
+            self.failIfNotConnected(err = e)
+            return
+        
+        ## reset any references to the old doRead
+        del self.doRead
+        self.stopReading()
+        
+        try:
+            self._verifyPeer()
+        except GNUTLSError, e:
+            self.closeTLSSession(e)
+            self.failIfNotConnected(err = e)
+            return
+        except Exception, e:
+            self.closeTLSSession(e)
+            self.failIfNotConnected(err = error.getConnectError(str(e)))
+            return
+        
+        ## TLS handshake (including certificate verification) finished succesfully
+        tcp.Client._connectDone(self)
+        
+    def startTLS(self):
+        self.doRead = self.doHandshake
+        self.startReading()
+        self.doHandshake()
+
+    def _connectDone(self):
+        self.startTLS()
+
+    def loseConnection(self, reason=failure.Failure(main.CONNECTION_DONE)):
+        reason = failure.Failure(reason) # accept python exceptions too
+        self._close_reason = reason.value
+        tcp.Client.loseConnection(self, reason)
+
+    def connectionLost(self, reason):
+        if self.__watchdog is not None:
+            self.__watchdog.cancel()
+            self.__watchdog = None
+        tcp.Client.connectionLost(self, reason)
+
+
+class TLSConnector(base.BaseConnector):
+    def __init__(self, host, port, factory, credentials, timeout, bindAddress, reactor=None, server_name=None):
+        self.host = host
+        self.port = port
+        self.bindAddress = bindAddress
+        self.credentials = credentials
+        self.server_name = server_name
+        base.BaseConnector.__init__(self, factory, timeout, reactor)
+
+    def _makeTransport(self):
+        return TLSClient(self.host, self.port, self.bindAddress, self.credentials, self, self.reactor, self.server_name)
+
+
+class TLSServer(TLSMixin, tcp.Server):
+    """Add TLS capabilities to a TCP server"""
+    
+    #implements(interfaces.ISSLTransport)
+    implementsOnly(interfaces.ISSLTransport, *[i for i in implementedBy(tcp.Server) if i != interfaces.ITLSTransport])
+    
+    def __init__(self, sock, protocol, client, server, sessionno, *args, **kw):
+        self.__watchdog = None
+        self.credentials = server.credentials
+        tcp.Server.__init__(self, sock, protocol, client, server, sessionno, *args, **kw)
+
+    def _recurrentVerify(self):
+        if not self.connected or self.disconnecting:
+            return
+        try:
+            self.credentials.verify_callback(self.socket.peer_certificate)
+        except Exception, e:
+            self.loseConnection(e)
+            return
+        else:
+            return KeepRunning
+
+    def _verifyPeer(self):
+        session = self.socket
+        credentials = self.credentials
+        if not credentials.verify_peer:
+            return
+        try:
+            session.verify_peer()
+        except Exception, e:
+            preverify_status = e
+        else:
+            preverify_status = CertificateOK
+        
+        credentials.verify_callback(session.peer_certificate, preverify_status)
+        
+        if credentials.verify_period > 0:
+            self.__watchdog = RecurrentCall(credentials.verify_period, self._recurrentVerify)
+
+    def doHandshake(self):
+        self.stopWriting()
+        try:
+            self.socket.handshake()
+        except (OperationWouldBlock, OperationInterrupted):
+            if self.socket.interrupted_while_writing:
+                self.startWriting()
+            return
+        except GNUTLSError, e:
+            del self.doRead
+            return e
+        
+        ## reset any references to the old doRead
+        del self.doRead
+        self.stopReading()
+        self.startReading()
+        
+        try:
+            self._verifyPeer()
+        except Exception, e:
+            self.loseConnection(e)
+            return
+        
+        ## TLS handshake (including certificate verification) finished succesfully
+        
+        del self.protocol.makeConnection
+        self.protocol.makeConnection(self)
+
+    def startTLS(self):
+        self.doRead = self.doHandshake
+        self.startReading()
+
+    def loseConnection(self, reason=failure.Failure(main.CONNECTION_DONE)):
+        reason = failure.Failure(reason) # accept python exceptions too
+        self._close_reason = reason.value
+        tcp.Server.loseConnection(self, reason)
+
+    def connectionLost(self, reason):
+        if self.__watchdog is not None:
+            self.__watchdog.cancel()
+            self.__watchdog = None
+        tcp.Server.connectionLost(self, reason)
+
+
+class TLSPort(tcp.Port):
+    """Add TLS capabilities to a TCP port"""
+
+    transport = TLSServer
+
+    def __init__(self, port, factory, credentials, backlog=50, interface='', reactor=None):
+        tcp.Port.__init__(self, port, factory, backlog, interface, reactor)
+        self.credentials = credentials
+
+    def createInternetSocket(self):
+        sock = tcp.Port.createInternetSocket(self)
+        return ServerSessionFactory(sock, self.credentials, ServerSession)
+
+    def _preMakeConnection(self, transport):
+        transport.protocol.makeConnection = lambda *args: None
+        transport.protocol.transport = transport ## because we may call connectionLost without connectionMade
+        transport.startTLS()
+        return tcp.Port._preMakeConnection(self, transport)
+
+
+def connectTLS(reactor, host, port, factory, credentials, timeout=30, bindAddress=None, server_name=None):
+    c = TLSConnector(host, port, factory, credentials, timeout, bindAddress, reactor, server_name)
+    c.connect()
+    return c
+
+
+def listenTLS(reactor, port, factory, credentials, backlog=50, interface=''):
+    p = TLSPort(port, factory, credentials, backlog, interface, reactor)
+    p.startListening()
+    return p
+
+## Add the connectTLS and listenTLS methods to the reactor
+
+import new
+from twisted.internet.posixbase import PosixReactorBase
+
+method = new.instancemethod(connectTLS, None, PosixReactorBase)
+setattr(PosixReactorBase, 'connectTLS', method)
+
+method = new.instancemethod(listenTLS, None, PosixReactorBase)
+setattr(PosixReactorBase, 'listenTLS', method)
+
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/library/__init__.py b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/library/__init__.py
new file mode 100644
index 0000000..494460f
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/library/__init__.py
@@ -0,0 +1,17 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+from gnutls.library import _gnutls_init
+from gnutls.library import constants
+from gnutls.library import types
+from gnutls.library import errors
+from gnutls.library import functions
+
+__need_version__ = '2.4.1'
+
+if functions.gnutls_check_version(__need_version__) is None:
+    version = functions.gnutls_check_version(None)
+    raise RuntimeError("Found GNUTLS library version %s, but at least version %s is required" % (version, __need_version__))
+if functions.gnutls_extra_check_version(__need_version__) is None:
+    version = functions.gnutls_extra_check_version(None)
+    raise RuntimeError("Found GNUTLS extra library version %s, but at least version %s is required" % (version, __need_version__))
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/library/_gnutls_init.so b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/library/_gnutls_init.so
new file mode 100755
index 0000000..48b119c
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/library/_gnutls_init.so
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/library/constants.py b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/library/constants.py
new file mode 100644
index 0000000..43c82d3
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/library/constants.py
@@ -0,0 +1,648 @@
+from ctypes import *
+
+STRING = c_char_p
+
+
+GNUTLS_CRD_IA = 5
+GNUTLS_CERT_REQUIRE = 2
+GNUTLS_PKCS_USE_PKCS12_3DES = 2
+GNUTLS_CRD_CERTIFICATE = 1
+GNUTLS_HANDSHAKE_SERVER_HELLO_DONE = 14
+GNUTLS_SIGN_RSA_RMD160 = 5
+GNUTLS_PKCS_PLAIN = 1
+GNUTLS_A_UNKNOWN_CA = 48
+GNUTLS_CRT_PRINT_ONELINE = 1
+GNUTLS_PKCS_USE_PKCS12_ARCFOUR = 4
+GNUTLS_A_UNKNOWN_PSK_IDENTITY = 115
+GNUTLS_CRT_X509 = 1
+GNUTLS_KX_DHE_PSK = 10
+GNUTLS_PARAMS_RSA_EXPORT = 1
+GNUTLS_DIG_NULL = 1
+GNUTLS_KX_PSK = 9
+GNUTLS_CIPHER_RC2_40_CBC = 90
+GNUTLS_AL_WARNING = 1
+GNUTLS_DIG_SHA256 = 6
+GNUTLS_CERT_INSECURE_ALGORITHM = 256
+GNUTLS_SIGN_RSA_MD2 = 4
+GNUTLS_CRT_PRINT_UNSIGNED_FULL = 2
+GNUTLS_PK_DSA = 2
+GNUTLS_A_UNRECOGNIZED_NAME = 112
+GNUTLS_A_INNER_APPLICATION_FAILURE = 208
+GNUTLS_VERIFY_DO_NOT_ALLOW_SAME = 4
+GNUTLS_CIPHER_AES_128_CBC = 4
+GNUTLS_CRT_PRINT_FULL = 0
+GNUTLS_PKCS_USE_PBES2_3DES = 16
+GNUTLS_SSL3 = 1
+GNUTLS_SAN_OTHERNAME_XMPP = 1000
+GNUTLS_DIG_SHA384 = 7
+GNUTLS_MAC_UNKNOWN = 0
+GNUTLS_A_CERTIFICATE_UNOBTAINABLE = 111
+GNUTLS_OPENPGP_CERT_FINGERPRINT = 1
+GNUTLS_SIGN_RSA_SHA512 = 8
+GNUTLS_A_DECRYPT_ERROR = 51
+GNUTLS_SAN_DN = 6
+GNUTLS_SAN_DNSNAME = 1
+GNUTLS_CRT_UNKNOWN = 0
+GNUTLS_SERVER = 1
+GNUTLS_CIPHER_NULL = 1
+GNUTLS_CIPHER_DES_CBC = 91
+GNUTLS_A_USER_CANCELED = 90
+GNUTLS_TLS1_1 = 3
+GNUTLS_CRT_OPENPGP = 2
+GNUTLS_SHUT_WR = 1
+GNUTLS_KX_ANON_DH = 4
+GNUTLS_A_EXPORT_RESTRICTION = 60
+GNUTLS_HANDSHAKE_FINISHED = 20
+GNUTLS_KX_UNKNOWN = 0
+GNUTLS_MAC_NULL = 1
+GNUTLS_SAN_IPADDRESS = 4
+GNUTLS_HANDSHAKE_CLIENT_HELLO = 1
+GNUTLS_CRD_ANON = 2
+GNUTLS_SHUT_RDWR = 0
+GNUTLS_A_SSL3_NO_CERTIFICATE = 41
+GNUTLS_COMP_NULL = 1
+GNUTLS_TLS1_2 = 4
+GNUTLS_IA_APPLICATION_PAYLOAD = 0
+GNUTLS_SIGN_RSA_SHA224 = 9
+GNUTLS_HANDSHAKE_CERTIFICATE_PKT = 11
+GNUTLS_DIG_MD2 = 5
+GNUTLS_PK_RSA = 1
+GNUTLS_CIPHER_CAMELLIA_256_CBC = 8
+GNUTLS_HANDSHAKE_SUPPLEMENTAL = 23
+GNUTLS_SIGN_UNKNOWN = 0
+GNUTLS_PARAMS_DH = 2
+GNUTLS_PK_UNKNOWN = 0
+GNUTLS_A_INSUFFICIENT_SECURITY = 71
+GNUTLS_DIG_SHA512 = 8
+GNUTLS_SUPPLEMENTAL_USER_MAPPING_DATA = 0
+GNUTLS_KX_RSA = 1
+GNUTLS_SIGN_RSA_SHA384 = 7
+GNUTLS_A_RECORD_OVERFLOW = 22
+GNUTLS_KX_DHE_RSA = 3
+GNUTLS_COMP_LZO = 3
+GNUTLS_CERT_IGNORE = 0
+GNUTLS_SIGN_RSA_SHA1 = 1
+GNUTLS_A_ILLEGAL_PARAMETER = 47
+GNUTLS_A_NO_RENEGOTIATION = 100
+GNUTLS_A_PROTOCOL_VERSION = 70
+GNUTLS_A_DECOMPRESSION_FAILURE = 30
+GNUTLS_A_CERTIFICATE_REVOKED = 44
+GNUTLS_CIPHER_AES_256_CBC = 5
+GNUTLS_A_INTERNAL_ERROR = 80
+GNUTLS_HANDSHAKE_HELLO_REQUEST = 0
+GNUTLS_X509_FMT_DER = 0
+GNUTLS_HANDSHAKE_CERTIFICATE_REQUEST = 13
+GNUTLS_HANDSHAKE_SERVER_HELLO = 2
+GNUTLS_A_HANDSHAKE_FAILURE = 40
+GNUTLS_DIG_MD5 = 2
+GNUTLS_SIGN_RSA_MD5 = 3
+GNUTLS_MAC_SHA256 = 6
+GNUTLS_OPENPGP_CERT = 0
+GNUTLS_CERT_SIGNER_NOT_CA = 128
+GNUTLS_AL_FATAL = 2
+GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD2 = 16
+GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT = 2
+GNUTLS_CIPHER_3DES_CBC = 3
+GNUTLS_A_DECRYPTION_FAILED = 21
+GNUTLS_HANDSHAKE_CLIENT_KEY_EXCHANGE = 16
+GNUTLS_SAN_RFC822NAME = 2
+GNUTLS_CRD_PSK = 4
+GNUTLS_OPENPGP_FMT_RAW = 0
+GNUTLS_CERT_SIGNER_NOT_FOUND = 64
+GNUTLS_A_UNSUPPORTED_EXTENSION = 110
+GNUTLS_DIG_SHA1 = 3
+GNUTLS_DIG_RMD160 = 4
+GNUTLS_A_CLOSE_NOTIFY = 0
+GNUTLS_KX_SRP_RSA = 7
+GNUTLS_MAC_MD5 = 2
+GNUTLS_IA_FINAL_PHASE_FINISHED = 2
+GNUTLS_A_UNSUPPORTED_CERTIFICATE = 43
+GNUTLS_COMP_UNKNOWN = 0
+GNUTLS_PKCS_USE_PKCS12_RC2_40 = 8
+GNUTLS_CIPHER_UNKNOWN = 0
+GNUTLS_PSK_KEY_HEX = 1
+GNUTLS_KX_SRP_DSS = 8
+GNUTLS_MAC_SHA384 = 7
+GNUTLS_SAN_URI = 3
+GNUTLS_X509_FMT_PEM = 1
+GNUTLS_X509_CRT_LIST_IMPORT_FAIL_IF_EXCEED = 1
+GNUTLS_HANDSHAKE_CERTIFICATE_VERIFY = 15
+GNUTLS_A_DECODE_ERROR = 50
+GNUTLS_MAC_SHA1 = 3
+GNUTLS_HANDSHAKE_SERVER_KEY_EXCHANGE = 12
+GNUTLS_IA_INTERMEDIATE_PHASE_FINISHED = 1
+GNUTLS_A_CERTIFICATE_UNKNOWN = 46
+GNUTLS_OPENPGP_FMT_BASE64 = 1
+GNUTLS_CLIENT = 2
+GNUTLS_PSK_KEY_RAW = 0
+GNUTLS_A_UNEXPECTED_MESSAGE = 10
+GNUTLS_CERT_INVALID = 2
+GNUTLS_CRD_SRP = 3
+GNUTLS_A_BAD_RECORD_MAC = 20
+GNUTLS_MAC_RMD160 = 4
+GNUTLS_DIG_SHA224 = 9
+GNUTLS_TLS1_0 = 2
+GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD5 = 32
+GNUTLS_KX_SRP = 5
+GNUTLS_A_CERTIFICATE_EXPIRED = 45
+GNUTLS_MAC_MD2 = 5
+GNUTLS_VERIFY_ALLOW_ANY_X509_V1_CA_CRT = 8
+GNUTLS_A_ACCESS_DENIED = 49
+GNUTLS_VERIFY_DISABLE_CA_SIGN = 1
+GNUTLS_CIPHER_ARCFOUR_40 = 6
+GNUTLS_A_BAD_CERTIFICATE = 42
+GNUTLS_CERT_REVOKED = 32
+GNUTLS_CERT_REQUEST = 1
+GNUTLS_MAC_SHA512 = 8
+GNUTLS_SAN_OTHERNAME = 5
+GNUTLS_VERSION_UNKNOWN = 255
+GNUTLS_KX_RSA_EXPORT = 6
+GNUTLS_CIPHER_CAMELLIA_128_CBC = 7
+GNUTLS_COMP_DEFLATE = 2
+GNUTLS_NAME_DNS = 1
+GNUTLS_SIGN_DSA_SHA1 = 2
+GNUTLS_A_INNER_APPLICATION_VERIFICATION = 209
+GNUTLS_CIPHER_ARCFOUR_128 = 2
+GNUTLS_KX_DHE_DSS = 2
+GNUTLS_SIGN_RSA_SHA256 = 6
+GNUTLS_E_UNKNOWN_PK_ALGORITHM = -80 # Variable c_int
+TLS_MASTER_SIZE = 48 # Variable c_int
+LIBGNUTLS_VERSION_NUMBER = 132097 # Variable c_int
+GNUTLS_E_FATAL_ALERT_RECEIVED = -12 # Variable c_int
+GNUTLS_E_LARGE_PACKET = -7 # Variable c_int
+GNUTLS_E_ASN1_DER_OVERFLOW = -77 # Variable c_int
+GNUTLS_E_INCOMPATIBLE_LIBTASN1_LIBRARY = -203 # Variable c_int
+GNUTLS_E_SHORT_MEMORY_BUFFER = -51 # Variable c_int
+GNUTLS_E_UNKNOWN_ALGORITHM = -105 # Variable c_int
+GNUTLS_MAX_SESSION_ID = 32 # Variable c_int
+GNUTLS_E_OPENPGP_GETKEY_FAILED = -88 # Variable c_int
+GNUTLS_E_REHANDSHAKE = -37 # Variable c_int
+GNUTLS_E_ASN1_VALUE_NOT_FOUND = -70 # Variable c_int
+GNUTLS_E_SUCCESS = 0 # Variable c_int
+GNUTLS_E_ASN1_SYNTAX_ERROR = -76 # Variable c_int
+GNUTLS_OID_PKIX_COUNTRY_OF_RESIDENCE = '1.3.6.1.5.5.7.9.5' # Variable STRING
+GNUTLS_E_RECORD_LIMIT_REACHED = -39 # Variable c_int
+GNUTLS_E_WARNING_IA_FPHF_RECEIVED = -103 # Variable c_int
+GNUTLS_OID_X520_DN_QUALIFIER = '2.5.4.46' # Variable STRING
+GNUTLS_OID_X520_GIVEN_NAME = '2.5.4.42' # Variable STRING
+LIBGNUTLS_VERSION_MINOR = 4 # Variable c_int
+GNUTLS_E_ASN1_ELEMENT_NOT_FOUND = -67 # Variable c_int
+GNUTLS_E_CRYPTO_ALREADY_REGISTERED = -209 # Variable c_int
+GNUTLS_E_KEY_USAGE_VIOLATION = -48 # Variable c_int
+GNUTLS_E_WARNING_IA_IPHF_RECEIVED = -102 # Variable c_int
+GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM = -3 # Variable c_int
+GNUTLS_E_PK_DECRYPTION_FAILED = -45 # Variable c_int
+GNUTLS_CRL_REASON_CA_COMPROMISE = 32 # Variable c_int
+GNUTLS_E_UNKNOWN_PKCS_BAG_TYPE = -98 # Variable c_int
+GNUTLS_E_DECRYPTION_FAILED = -24 # Variable c_int
+GNUTLS_E_UNKNOWN_PKCS_CONTENT_TYPE = -97 # Variable c_int
+GNUTLS_KP_OCSP_SIGNING = '1.3.6.1.5.5.7.3.9' # Variable STRING
+GNUTLS_E_PK_SIGN_FAILED = -46 # Variable c_int
+GNUTLS_E_ASN1_TAG_IMPLICIT = -74 # Variable c_int
+GNUTLS_E_INIT_LIBEXTRA = -82 # Variable c_int
+GNUTLS_KP_TLS_WWW_SERVER = '1.3.6.1.5.5.7.3.1' # Variable STRING
+GNUTLS_E_OPENPGP_KEYRING_ERROR = -204 # Variable c_int
+GNUTLS_E_MEMORY_ERROR = -25 # Variable c_int
+GNUTLS_E_MAC_VERIFY_FAILED = -100 # Variable c_int
+GNUTLS_E_NO_TEMPORARY_DH_PARAMS = -93 # Variable c_int
+GNUTLS_KEY_NON_REPUDIATION = 64 # Variable c_int
+GNUTLS_MAX_ALGORITHM_NUM = 16 # Variable c_int
+GNUTLS_OID_X520_COUNTRY_NAME = '2.5.4.6' # Variable STRING
+GNUTLS_E_WARNING_ALERT_RECEIVED = -16 # Variable c_int
+GNUTLS_E_OPENPGP_UID_REVOKED = -79 # Variable c_int
+GNUTLS_E_PUSH_ERROR = -53 # Variable c_int
+GNUTLS_KEY_KEY_CERT_SIGN = 4 # Variable c_int
+GNUTLS_E_GOT_APPLICATION_DATA = -38 # Variable c_int
+GNUTLS_E_BASE64_DECODING_ERROR = -34 # Variable c_int
+GNUTLS_E_PULL_ERROR = -54 # Variable c_int
+GNUTLS_E_COMPRESSION_FAILED = -27 # Variable c_int
+GNUTLS_E_ASN1_DER_ERROR = -69 # Variable c_int
+GNUTLS_KEY_DECIPHER_ONLY = 32768 # Variable c_int
+GNUTLS_E_DECOMPRESSION_FAILED = -26 # Variable c_int
+LIBGNUTLS_VERSION_MAJOR = 2 # Variable c_int
+GNUTLS_E_NO_CIPHER_SUITES = -87 # Variable c_int
+GNUTLS_KEY_KEY_ENCIPHERMENT = 32 # Variable c_int
+GNUTLS_E_BASE64_UNEXPECTED_HEADER_ERROR = -207 # Variable c_int
+GNUTLS_E_ASN1_TYPE_ANY_ERROR = -75 # Variable c_int
+GNUTLS_OID_LDAP_UID = '0.9.2342.19200300.100.1.1' # Variable STRING
+GNUTLS_KEY_DATA_ENCIPHERMENT = 16 # Variable c_int
+GNUTLS_E_X509_UNSUPPORTED_OID = -205 # Variable c_int
+GNUTLS_E_NO_CERTIFICATE_FOUND = -49 # Variable c_int
+GNUTLS_E_UNIMPLEMENTED_FEATURE = -1250 # Variable c_int
+GNUTLS_E_UNSUPPORTED_VERSION_PACKET = -8 # Variable c_int
+GNUTLS_E_FILE_ERROR = -64 # Variable c_int
+GNUTLS_CRL_REASON_PRIVILEGE_WITHDRAWN = 1 # Variable c_int
+LIBGNUTLS_VERSION = '2.4.1' # Variable STRING
+GNUTLS_CRL_REASON_AFFILIATION_CHANGED = 16 # Variable c_int
+GNUTLS_OID_X520_ORGANIZATIONAL_UNIT_NAME = '2.5.4.11' # Variable STRING
+GNUTLS_OID_X520_COMMON_NAME = '2.5.4.3' # Variable STRING
+GNUTLS_E_HASH_FAILED = -33 # Variable c_int
+GNUTLS_E_PKCS1_WRONG_PAD = -57 # Variable c_int
+GNUTLS_OID_X520_GENERATION_QUALIFIER = '2.5.4.44' # Variable STRING
+GNUTLS_E_INCOMPATIBLE_CRYPTO_LIBRARY = -202 # Variable c_int
+GNUTLS_E_X509_UNSUPPORTED_CRITICAL_EXTENSION = -47 # Variable c_int
+GNUTLS_OID_X520_PSEUDONYM = '2.5.4.65' # Variable STRING
+GNUTLS_E_NO_COMPRESSION_ALGORITHMS = -86 # Variable c_int
+GNUTLS_E_UNEXPECTED_PACKET_LENGTH = -9 # Variable c_int
+GNUTLS_E_INCOMPATIBLE_GCRYPT_LIBRARY = -202 # Variable c_int
+GNUTLS_E_MPI_PRINT_FAILED = -35 # Variable c_int
+GNUTLS_E_INVALID_PASSWORD = -99 # Variable c_int
+GNUTLS_E_CERTIFICATE_KEY_MISMATCH = -60 # Variable c_int
+GNUTLS_OID_X520_STATE_OR_PROVINCE_NAME = '2.5.4.8' # Variable STRING
+GNUTLS_E_INSUFFICIENT_CREDENTIALS = -32 # Variable c_int
+GNUTLS_OID_X520_SURNAME = '2.5.4.4' # Variable STRING
+GNUTLS_E_X509_UNKNOWN_SAN = -62 # Variable c_int
+GNUTLS_KEY_CRL_SIGN = 2 # Variable c_int
+GNUTLS_E_PK_SIG_VERIFY_FAILED = -89 # Variable c_int
+GNUTLS_E_BASE64_ENCODING_ERROR = -201 # Variable c_int
+GNUTLS_E_ASN1_VALUE_NOT_VALID = -72 # Variable c_int
+GNUTLS_OID_X520_TITLE = '2.5.4.12' # Variable STRING
+GNUTLS_E_ENCRYPTION_FAILED = -40 # Variable c_int
+GNUTLS_OID_PKCS9_EMAIL = '1.2.840.113549.1.9.1' # Variable STRING
+GNUTLS_KP_ANY = '2.5.29.37.0' # Variable STRING
+GNUTLS_CRL_REASON_UNUSED = 128 # Variable c_int
+GNUTLS_E_OPENPGP_SUBKEY_ERROR = -208 # Variable c_int
+GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER = -55 # Variable c_int
+GNUTLS_E_EXPIRED = -29 # Variable c_int
+GNUTLS_E_DB_ERROR = -30 # Variable c_int
+GNUTLS_E_UNWANTED_ALGORITHM = -22 # Variable c_int
+GNUTLS_OID_PKIX_COUNTRY_OF_CITIZENSHIP = '1.3.6.1.5.5.7.9.4' # Variable STRING
+GNUTLS_E_APPLICATION_ERROR_MIN = -65500 # Variable c_int
+GNUTLS_E_INVALID_REQUEST = -50 # Variable c_int
+GNUTLS_E_ASN1_IDENTIFIER_NOT_FOUND = -68 # Variable c_int
+GNUTLS_OID_X520_INITIALS = '2.5.4.43' # Variable STRING
+GNUTLS_E_ASN1_TAG_ERROR = -73 # Variable c_int
+GNUTLS_E_X509_UNSUPPORTED_ATTRIBUTE = -95 # Variable c_int
+GNUTLS_KP_EMAIL_PROTECTION = '1.3.6.1.5.5.7.3.4' # Variable STRING
+GNUTLS_CRL_REASON_CESSATION_OF_OPERATION = 4 # Variable c_int
+GNUTLS_E_IA_VERIFY_FAILED = -104 # Variable c_int
+GNUTLS_KP_TIME_STAMPING = '1.3.6.1.5.5.7.3.8' # Variable STRING
+GNUTLS_E_INTERNAL_ERROR = -59 # Variable c_int
+GNUTLS_E_LZO_INIT_FAILED = -85 # Variable c_int
+GNUTLS_CRL_REASON_CERTIFICATE_HOLD = 2 # Variable c_int
+GNUTLS_OID_X520_ORGANIZATION_NAME = '2.5.4.10' # Variable STRING
+GNUTLS_CRL_REASON_KEY_COMPROMISE = 64 # Variable c_int
+GNUTLS_OID_PKIX_GENDER = '1.3.6.1.5.5.7.9.3' # Variable STRING
+GNUTLS_E_APPLICATION_ERROR_MAX = -65000 # Variable c_int
+GNUTLS_E_SRP_PWD_PARSING_ERROR = -91 # Variable c_int
+GNUTLS_E_NO_TEMPORARY_RSA_PARAMS = -84 # Variable c_int
+GNUTLS_OID_PKIX_PLACE_OF_BIRTH = '1.3.6.1.5.5.7.9.2' # Variable STRING
+GNUTLS_E_LIBRARY_VERSION_MISMATCH = -83 # Variable c_int
+GNUTLS_KEY_DIGITAL_SIGNATURE = 128 # Variable c_int
+GNUTLS_E_UNEXPECTED_HANDSHAKE_PACKET = -19 # Variable c_int
+GNUTLS_E_ASN1_GENERIC_ERROR = -71 # Variable c_int
+GNUTLS_E_ILLEGAL_SRP_USERNAME = -90 # Variable c_int
+_GNUTLS_GCC_VERSION = 40301 # Variable c_int
+GNUTLS_E_AGAIN = -28 # Variable c_int
+GNUTLS_E_DH_PRIME_UNACCEPTABLE = -63 # Variable c_int
+GNUTLS_E_UNSUPPORTED_CERTIFICATE_TYPE = -61 # Variable c_int
+GNUTLS_E_UNKNOWN_CIPHER_SUITE = -21 # Variable c_int
+GNUTLS_E_CONSTRAINT_ERROR = -101 # Variable c_int
+GNUTLS_E_UNEXPECTED_PACKET = -15 # Variable c_int
+TLS_RANDOM_SIZE = 32 # Variable c_int
+LIBGNUTLS_VERSION_PATCH = 1 # Variable c_int
+GNUTLS_E_RECEIVED_ILLEGAL_EXTENSION = -58 # Variable c_int
+GNUTLS_E_INVALID_SESSION = -10 # Variable c_int
+GNUTLS_KEY_KEY_AGREEMENT = 8 # Variable c_int
+GNUTLS_E_ERROR_IN_FINISHED_PACKET = -18 # Variable c_int
+GNUTLS_KEY_ENCIPHER_ONLY = 1 # Variable c_int
+GNUTLS_E_UNKNOWN_CIPHER_TYPE = -6 # Variable c_int
+GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE = -56 # Variable c_int
+GNUTLS_CRL_REASON_AA_COMPROMISE = 32768 # Variable c_int
+GNUTLS_E_CERTIFICATE_ERROR = -43 # Variable c_int
+GNUTLS_E_TOO_MANY_EMPTY_PACKETS = -78 # Variable c_int
+GNUTLS_OID_PKIX_DATE_OF_BIRTH = '1.3.6.1.5.5.7.9.1' # Variable STRING
+GNUTLS_E_PK_ENCRYPTION_FAILED = -44 # Variable c_int
+GNUTLS_OID_LDAP_DC = '0.9.2342.19200300.100.1.25' # Variable STRING
+GNUTLS_KP_TLS_WWW_CLIENT = '1.3.6.1.5.5.7.3.2' # Variable STRING
+GNUTLS_E_MPI_SCAN_FAILED = -23 # Variable c_int
+GNUTLS_E_OPENPGP_FINGERPRINT_UNSUPPORTED = -94 # Variable c_int
+GNUTLS_E_SRP_PWD_ERROR = -31 # Variable c_int
+GNUTLS_CRL_REASON_SUPERSEEDED = 8 # Variable c_int
+GNUTLS_E_INTERRUPTED = -52 # Variable c_int
+GNUTLS_OID_X520_LOCALITY_NAME = '2.5.4.7' # Variable STRING
+GNUTLS_E_UNKNOWN_HASH_ALGORITHM = -96 # Variable c_int
+GNUTLS_E_RANDOM_FAILED = -206 # Variable c_int
+GNUTLS_E_HANDSHAKE_TOO_LARGE = -210 # Variable c_int
+GNUTLS_KP_CODE_SIGNING = '1.3.6.1.5.5.7.3.3' # Variable STRING
+
+# values for enumeration 'gnutls_ia_apptype_t'
+gnutls_ia_apptype_t = c_int # enum
+
+# values for enumeration 'gnutls_cipher_algorithm_t'
+gnutls_cipher_algorithm_t = c_int # enum
+
+# values for enumeration 'gnutls_kx_algorithm_t'
+gnutls_kx_algorithm_t = c_int # enum
+
+# values for enumeration 'gnutls_params_type_t'
+gnutls_params_type_t = c_int # enum
+
+# values for enumeration 'gnutls_credentials_type_t'
+gnutls_credentials_type_t = c_int # enum
+
+# values for enumeration 'gnutls_mac_algorithm_t'
+gnutls_mac_algorithm_t = c_int # enum
+
+# values for enumeration 'gnutls_digest_algorithm_t'
+gnutls_digest_algorithm_t = c_int # enum
+
+# values for enumeration 'gnutls_compression_method_t'
+gnutls_compression_method_t = c_int # enum
+
+# values for enumeration 'gnutls_connection_end_t'
+gnutls_connection_end_t = c_int # enum
+
+# values for enumeration 'gnutls_alert_level_t'
+gnutls_alert_level_t = c_int # enum
+
+# values for enumeration 'gnutls_alert_description_t'
+gnutls_alert_description_t = c_int # enum
+
+# values for enumeration 'gnutls_handshake_description_t'
+gnutls_handshake_description_t = c_int # enum
+
+# values for enumeration 'gnutls_certificate_status_t'
+gnutls_certificate_status_t = c_int # enum
+
+# values for enumeration 'gnutls_certificate_request_t'
+gnutls_certificate_request_t = c_int # enum
+
+# values for enumeration 'gnutls_openpgp_crt_status_t'
+gnutls_openpgp_crt_status_t = c_int # enum
+
+# values for enumeration 'gnutls_close_request_t'
+gnutls_close_request_t = c_int # enum
+
+# values for enumeration 'gnutls_protocol_t'
+gnutls_protocol_t = c_int # enum
+
+# values for enumeration 'gnutls_certificate_type_t'
+gnutls_certificate_type_t = c_int # enum
+
+# values for enumeration 'gnutls_x509_crt_fmt_t'
+gnutls_x509_crt_fmt_t = c_int # enum
+
+# values for enumeration 'gnutls_certificate_print_formats'
+gnutls_certificate_print_formats = c_int # enum
+
+# values for enumeration 'gnutls_pk_algorithm_t'
+gnutls_pk_algorithm_t = c_int # enum
+
+# values for enumeration 'gnutls_sign_algorithm_t'
+gnutls_sign_algorithm_t = c_int # enum
+
+# values for enumeration 'gnutls_server_name_type_t'
+gnutls_server_name_type_t = c_int # enum
+
+# values for enumeration 'gnutls_supplemental_data_format_type_t'
+gnutls_supplemental_data_format_type_t = c_int # enum
+
+# values for enumeration 'gnutls_psk_key_flags'
+gnutls_psk_key_flags = c_int # enum
+
+# values for enumeration 'gnutls_x509_subject_alt_name_t'
+gnutls_x509_subject_alt_name_t = c_int # enum
+
+# values for enumeration 'gnutls_openpgp_crt_fmt'
+gnutls_openpgp_crt_fmt = c_int # enum
+
+# values for enumeration 'gnutls_certificate_import_flags'
+gnutls_certificate_import_flags = c_int # enum
+
+# values for enumeration 'gnutls_certificate_verify_flags'
+gnutls_certificate_verify_flags = c_int # enum
+
+# values for enumeration 'gnutls_pkcs_encrypt_flags_t'
+gnutls_pkcs_encrypt_flags_t = c_int # enum
+__all__ = ['GNUTLS_PKCS_USE_PKCS12_ARCFOUR',
+           'GNUTLS_HANDSHAKE_CLIENT_HELLO',
+           'GNUTLS_E_ASN1_DER_OVERFLOW',
+           'GNUTLS_CERT_INSECURE_ALGORITHM',
+           'GNUTLS_E_WARNING_ALERT_RECEIVED',
+           'GNUTLS_E_OPENPGP_GETKEY_FAILED', 'GNUTLS_KX_UNKNOWN',
+           'GNUTLS_E_SUCCESS', 'GNUTLS_CRT_PRINT_UNSIGNED_FULL',
+           'GNUTLS_DIG_NULL', 'GNUTLS_E_ASN1_IDENTIFIER_NOT_FOUND',
+           'GNUTLS_CIPHER_UNKNOWN', 'GNUTLS_KX_SRP_DSS',
+           'GNUTLS_A_UNSUPPORTED_EXTENSION',
+           'GNUTLS_E_WARNING_IA_IPHF_RECEIVED',
+           'GNUTLS_CRL_REASON_CA_COMPROMISE',
+           'GNUTLS_E_LZO_INIT_FAILED', 'gnutls_pkcs_encrypt_flags_t',
+           'GNUTLS_PKCS_USE_PKCS12_RC2_40',
+           'GNUTLS_A_CERTIFICATE_UNKNOWN',
+           'GNUTLS_E_MAC_VERIFY_FAILED', 'GNUTLS_OPENPGP_CERT',
+           'GNUTLS_E_NO_TEMPORARY_DH_PARAMS',
+           'GNUTLS_E_OPENPGP_UID_REVOKED', 'GNUTLS_KX_DHE_RSA',
+           'GNUTLS_E_PUSH_ERROR', 'GNUTLS_CRT_OPENPGP',
+           'GNUTLS_E_PULL_ERROR', 'GNUTLS_E_CONSTRAINT_ERROR',
+           'GNUTLS_KEY_DECIPHER_ONLY',
+           'GNUTLS_HANDSHAKE_HELLO_REQUEST',
+           'gnutls_certificate_verify_flags', 'GNUTLS_E_FILE_ERROR',
+           'GNUTLS_E_ASN1_TYPE_ANY_ERROR', 'GNUTLS_CERT_REVOKED',
+           'GNUTLS_E_NO_CERTIFICATE_FOUND', 'GNUTLS_SIGN_RSA_MD5',
+           'GNUTLS_E_DECOMPRESSION_FAILED', 'GNUTLS_DIG_MD5',
+           'GNUTLS_DIG_MD2', 'GNUTLS_A_HANDSHAKE_FAILURE',
+           'GNUTLS_E_ASN1_VALUE_NOT_FOUND',
+           'GNUTLS_VERIFY_ALLOW_ANY_X509_V1_CA_CRT',
+           'GNUTLS_E_PKCS1_WRONG_PAD', 'gnutls_params_type_t',
+           'GNUTLS_E_BASE64_DECODING_ERROR',
+           'GNUTLS_CIPHER_ARCFOUR_128', 'GNUTLS_X509_FMT_PEM',
+           'GNUTLS_E_CERTIFICATE_KEY_MISMATCH',
+           'GNUTLS_SIGN_RSA_SHA1', 'GNUTLS_DIG_SHA256',
+           'GNUTLS_HANDSHAKE_CERTIFICATE_REQUEST',
+           'LIBGNUTLS_VERSION', 'GNUTLS_OID_X520_TITLE',
+           'GNUTLS_MAC_SHA256', 'GNUTLS_E_DB_ERROR',
+           'GNUTLS_OID_PKIX_COUNTRY_OF_CITIZENSHIP',
+           'GNUTLS_SIGN_UNKNOWN', 'GNUTLS_DIG_SHA512',
+           'gnutls_x509_subject_alt_name_t', 'GNUTLS_AL_FATAL',
+           'GNUTLS_E_IA_VERIFY_FAILED', 'gnutls_certificate_type_t',
+           'GNUTLS_MAC_RMD160', 'GNUTLS_SIGN_RSA_SHA256',
+           'GNUTLS_CRT_PRINT_FULL',
+           'GNUTLS_E_LIBRARY_VERSION_MISMATCH',
+           'gnutls_pk_algorithm_t', 'GNUTLS_HANDSHAKE_SUPPLEMENTAL',
+           'GNUTLS_A_UNEXPECTED_MESSAGE',
+           'GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD5',
+           'GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD2',
+           'GNUTLS_E_UNEXPECTED_PACKET', 'GNUTLS_A_UNKNOWN_CA',
+           'gnutls_certificate_import_flags',
+           'LIBGNUTLS_VERSION_PATCH',
+           'GNUTLS_E_RECEIVED_ILLEGAL_EXTENSION',
+           'GNUTLS_SIGN_RSA_SHA512', 'GNUTLS_PKCS_USE_PBES2_3DES',
+           'GNUTLS_KEY_KEY_AGREEMENT',
+           'GNUTLS_E_DH_PRIME_UNACCEPTABLE',
+           'GNUTLS_E_INCOMPATIBLE_GCRYPT_LIBRARY',
+           'gnutls_cipher_algorithm_t',
+           'GNUTLS_IA_FINAL_PHASE_FINISHED', 'GNUTLS_SAN_DNSNAME',
+           'GNUTLS_E_PK_ENCRYPTION_FAILED',
+           'GNUTLS_E_MPI_SCAN_FAILED',
+           'GNUTLS_X509_CRT_LIST_IMPORT_FAIL_IF_EXCEED',
+           'GNUTLS_E_SRP_PWD_ERROR', 'gnutls_mac_algorithm_t',
+           'GNUTLS_PARAMS_RSA_EXPORT', 'GNUTLS_PSK_KEY_RAW',
+           'GNUTLS_E_UNKNOWN_HASH_ALGORITHM',
+           'GNUTLS_E_RANDOM_FAILED', 'GNUTLS_E_HANDSHAKE_TOO_LARGE',
+           'GNUTLS_A_NO_RENEGOTIATION', 'TLS_MASTER_SIZE',
+           'GNUTLS_E_FATAL_ALERT_RECEIVED', 'GNUTLS_E_LARGE_PACKET',
+           'GNUTLS_MAX_SESSION_ID',
+           'GNUTLS_A_INNER_APPLICATION_FAILURE',
+           'GNUTLS_E_RECORD_LIMIT_REACHED',
+           'GNUTLS_E_ASN1_ELEMENT_NOT_FOUND',
+           'GNUTLS_HANDSHAKE_CERTIFICATE_PKT',
+           'GNUTLS_A_INSUFFICIENT_SECURITY',
+           'GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM',
+           'GNUTLS_A_DECODE_ERROR',
+           'GNUTLS_A_INNER_APPLICATION_VERIFICATION',
+           'GNUTLS_E_UNKNOWN_PKCS_CONTENT_TYPE', 'GNUTLS_PK_RSA',
+           'GNUTLS_CRD_CERTIFICATE', 'GNUTLS_MAC_MD5',
+           'GNUTLS_MAC_MD2', 'GNUTLS_E_ASN1_TAG_IMPLICIT',
+           'GNUTLS_E_OPENPGP_KEYRING_ERROR', 'GNUTLS_SAN_OTHERNAME',
+           'GNUTLS_SAN_IPADDRESS', 'gnutls_compression_method_t',
+           'GNUTLS_SAN_DN', 'GNUTLS_COMP_NULL',
+           'GNUTLS_A_CERTIFICATE_EXPIRED',
+           'GNUTLS_OPENPGP_CERT_FINGERPRINT',
+           'GNUTLS_KEY_DATA_ENCIPHERMENT', 'GNUTLS_X509_FMT_DER',
+           'GNUTLS_CIPHER_AES_256_CBC', 'gnutls_sign_algorithm_t',
+           'GNUTLS_CRL_REASON_PRIVILEGE_WITHDRAWN', 'GNUTLS_SHUT_WR',
+           'GNUTLS_KX_DHE_PSK', 'GNUTLS_CLIENT', 'GNUTLS_DIG_SHA384',
+           'GNUTLS_E_X509_UNSUPPORTED_CRITICAL_EXTENSION',
+           'GNUTLS_E_UNKNOWN_CIPHER_TYPE',
+           'GNUTLS_E_MPI_PRINT_FAILED', 'GNUTLS_E_INVALID_PASSWORD',
+           'GNUTLS_CIPHER_3DES_CBC', 'gnutls_credentials_type_t',
+           'GNUTLS_SIGN_DSA_SHA1', 'GNUTLS_KEY_CRL_SIGN',
+           'GNUTLS_E_BASE64_ENCODING_ERROR', 'GNUTLS_A_CLOSE_NOTIFY',
+           'GNUTLS_OID_PKCS9_EMAIL', 'GNUTLS_CRL_REASON_UNUSED',
+           'GNUTLS_E_UNKNOWN_PK_ALGORITHM', 'GNUTLS_CERT_INVALID',
+           'GNUTLS_E_APPLICATION_ERROR_MIN',
+           'GNUTLS_HANDSHAKE_SERVER_HELLO_DONE',
+           'GNUTLS_E_OPENPGP_FINGERPRINT_UNSUPPORTED',
+           'GNUTLS_SAN_URI', 'GNUTLS_A_UNSUPPORTED_CERTIFICATE',
+           'GNUTLS_E_ASN1_TAG_ERROR', 'GNUTLS_E_INTERNAL_ERROR',
+           'GNUTLS_CRL_REASON_CERTIFICATE_HOLD',
+           'gnutls_certificate_status_t', 'GNUTLS_OID_PKIX_GENDER',
+           'GNUTLS_E_SRP_PWD_PARSING_ERROR', 'GNUTLS_MAC_SHA384',
+           'GNUTLS_COMP_DEFLATE', 'GNUTLS_E_ASN1_VALUE_NOT_VALID',
+           'GNUTLS_IA_INTERMEDIATE_PHASE_FINISHED',
+           'GNUTLS_COMP_UNKNOWN',
+           'GNUTLS_E_UNEXPECTED_HANDSHAKE_PACKET',
+           'GNUTLS_CIPHER_CAMELLIA_256_CBC',
+           'GNUTLS_CERT_SIGNER_NOT_FOUND',
+           'GNUTLS_A_PROTOCOL_VERSION', 'GNUTLS_E_AGAIN',
+           'GNUTLS_CIPHER_NULL', 'GNUTLS_KEY_ENCIPHER_ONLY',
+           'GNUTLS_NAME_DNS', 'GNUTLS_E_UNKNOWN_CIPHER_SUITE',
+           'gnutls_certificate_request_t',
+           'GNUTLS_CERT_SIGNER_NOT_CA', 'GNUTLS_A_USER_CANCELED',
+           'GNUTLS_E_PK_SIGN_FAILED',
+           'GNUTLS_E_ERROR_IN_FINISHED_PACKET',
+           'GNUTLS_CRL_REASON_AA_COMPROMISE', 'GNUTLS_MAC_SHA1',
+           'GNUTLS_CRD_ANON', 'GNUTLS_HANDSHAKE_SERVER_HELLO',
+           'GNUTLS_E_X509_UNSUPPORTED_ATTRIBUTE',
+           'GNUTLS_HANDSHAKE_CERTIFICATE_VERIFY',
+           'gnutls_ia_apptype_t', '_GNUTLS_GCC_VERSION',
+           'GNUTLS_CRL_REASON_SUPERSEEDED',
+           'gnutls_digest_algorithm_t', 'GNUTLS_A_DECRYPTION_FAILED',
+           'GNUTLS_MAC_NULL', 'GNUTLS_OID_PKIX_COUNTRY_OF_RESIDENCE',
+           'GNUTLS_E_ASN1_DER_ERROR', 'GNUTLS_PSK_KEY_HEX',
+           'GNUTLS_E_UNKNOWN_ALGORITHM', 'GNUTLS_DIG_SHA1',
+           'GNUTLS_E_INCOMPATIBLE_CRYPTO_LIBRARY',
+           'GNUTLS_E_ASN1_SYNTAX_ERROR',
+           'GNUTLS_E_WARNING_IA_FPHF_RECEIVED',
+           'GNUTLS_OID_X520_DN_QUALIFIER',
+           'GNUTLS_E_NO_CIPHER_SUITES', 'GNUTLS_KX_SRP',
+           'GNUTLS_E_CRYPTO_ALREADY_REGISTERED',
+           'GNUTLS_HANDSHAKE_FINISHED', 'GNUTLS_DIG_RMD160',
+           'gnutls_openpgp_crt_status_t', 'GNUTLS_KEY_KEY_CERT_SIGN',
+           'GNUTLS_CRD_SRP', 'GNUTLS_E_DECRYPTION_FAILED',
+           'GNUTLS_KX_SRP_RSA', 'gnutls_protocol_t',
+           'gnutls_openpgp_crt_fmt', 'GNUTLS_IA_APPLICATION_PAYLOAD',
+           'GNUTLS_SIGN_RSA_MD2', 'GNUTLS_A_CERTIFICATE_UNOBTAINABLE',
+           'GNUTLS_CIPHER_DES_CBC', 'GNUTLS_A_RECORD_OVERFLOW',
+           'GNUTLS_KX_DHE_DSS', 'GNUTLS_KEY_KEY_ENCIPHERMENT',
+           'GNUTLS_OID_LDAP_UID', 'GNUTLS_E_X509_UNSUPPORTED_OID',
+           'GNUTLS_VERIFY_DO_NOT_ALLOW_SAME',
+           'GNUTLS_E_UNIMPLEMENTED_FEATURE', 'GNUTLS_A_DECRYPT_ERROR',
+           'GNUTLS_TLS1_2', 'GNUTLS_TLS1_0', 'GNUTLS_TLS1_1',
+           'GNUTLS_CRL_REASON_AFFILIATION_CHANGED',
+           'GNUTLS_OPENPGP_FMT_RAW',
+           'GNUTLS_OID_X520_GENERATION_QUALIFIER',
+           'GNUTLS_OID_X520_PSEUDONYM',
+           'GNUTLS_A_DECOMPRESSION_FAILURE',
+           'GNUTLS_E_NO_COMPRESSION_ALGORITHMS',
+           'GNUTLS_E_UNEXPECTED_PACKET_LENGTH', 'GNUTLS_PK_UNKNOWN',
+           'GNUTLS_E_COMPRESSION_FAILED',
+           'GNUTLS_KEY_NON_REPUDIATION', 'GNUTLS_A_ACCESS_DENIED',
+           'GNUTLS_E_INSUFFICIENT_CREDENTIALS',
+           'gnutls_kx_algorithm_t', 'GNUTLS_OID_X520_COMMON_NAME',
+           'GNUTLS_OID_PKIX_PLACE_OF_BIRTH',
+           'GNUTLS_OID_X520_STATE_OR_PROVINCE_NAME',
+           'GNUTLS_VERIFY_DISABLE_CA_SIGN',
+           'GNUTLS_SAN_OTHERNAME_XMPP', 'GNUTLS_E_INVALID_REQUEST',
+           'GNUTLS_SSL3', 'GNUTLS_KP_TIME_STAMPING',
+           'GNUTLS_A_SSL3_NO_CERTIFICATE',
+           'GNUTLS_CRL_REASON_KEY_COMPROMISE',
+           'GNUTLS_E_APPLICATION_ERROR_MAX',
+           'GNUTLS_KEY_DIGITAL_SIGNATURE',
+           'gnutls_supplemental_data_format_type_t',
+           'gnutls_alert_description_t',
+           'GNUTLS_A_CERTIFICATE_REVOKED', 'gnutls_alert_level_t',
+           'gnutls_psk_key_flags', 'GNUTLS_A_BAD_CERTIFICATE',
+           'GNUTLS_MAC_UNKNOWN', 'GNUTLS_A_UNRECOGNIZED_NAME',
+           'TLS_RANDOM_SIZE', 'GNUTLS_E_INVALID_SESSION',
+           'GNUTLS_PARAMS_DH', 'GNUTLS_HANDSHAKE_CLIENT_KEY_EXCHANGE',
+           'gnutls_x509_crt_fmt_t', 'GNUTLS_KP_ANY',
+           'GNUTLS_E_TOO_MANY_EMPTY_PACKETS',
+           'GNUTLS_OID_PKIX_DATE_OF_BIRTH',
+           'GNUTLS_OPENPGP_FMT_BASE64',
+           'GNUTLS_E_NO_TEMPORARY_RSA_PARAMS',
+           'GNUTLS_VERSION_UNKNOWN', 'GNUTLS_E_INTERRUPTED',
+           'GNUTLS_COMP_LZO', 'GNUTLS_SERVER', 'GNUTLS_CRD_IA',
+           'GNUTLS_DIG_SHA224', 'GNUTLS_KX_RSA',
+           'LIBGNUTLS_VERSION_NUMBER', 'GNUTLS_CERT_IGNORE',
+           'GNUTLS_CERT_REQUEST', 'GNUTLS_MAC_SHA512',
+           'GNUTLS_E_SHORT_MEMORY_BUFFER', 'GNUTLS_SIGN_RSA_SHA224',
+           'GNUTLS_E_REHANDSHAKE', 'gnutls_close_request_t',
+           'GNUTLS_OID_X520_GIVEN_NAME', 'LIBGNUTLS_VERSION_MINOR',
+           'gnutls_handshake_description_t',
+           'GNUTLS_E_KEY_USAGE_VIOLATION',
+           'GNUTLS_E_PK_DECRYPTION_FAILED',
+           'GNUTLS_E_UNKNOWN_PKCS_BAG_TYPE', 'GNUTLS_KX_PSK',
+           'GNUTLS_SUPPLEMENTAL_USER_MAPPING_DATA',
+           'GNUTLS_KP_OCSP_SIGNING', 'GNUTLS_A_UNKNOWN_PSK_IDENTITY',
+           'GNUTLS_OID_X520_SURNAME', 'GNUTLS_E_MEMORY_ERROR',
+           'GNUTLS_CERT_REQUIRE', 'GNUTLS_KX_ANON_DH',
+           'GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT',
+           'GNUTLS_MAX_ALGORITHM_NUM', 'GNUTLS_A_EXPORT_RESTRICTION',
+           'GNUTLS_OID_X520_COUNTRY_NAME', 'GNUTLS_SHUT_RDWR',
+           'GNUTLS_AL_WARNING', 'GNUTLS_E_GOT_APPLICATION_DATA',
+           'LIBGNUTLS_VERSION_MAJOR', 'GNUTLS_CRT_UNKNOWN',
+           'GNUTLS_E_UNSUPPORTED_VERSION_PACKET',
+           'GNUTLS_KP_TLS_WWW_SERVER',
+           'GNUTLS_OID_X520_ORGANIZATIONAL_UNIT_NAME',
+           'GNUTLS_E_HASH_FAILED',
+           'GNUTLS_OID_X520_ORGANIZATION_NAME',
+           'gnutls_server_name_type_t', 'GNUTLS_E_ENCRYPTION_FAILED',
+           'GNUTLS_E_X509_UNKNOWN_SAN', 'GNUTLS_CRD_PSK',
+           'GNUTLS_E_PK_SIG_VERIFY_FAILED', 'GNUTLS_A_BAD_RECORD_MAC',
+           'GNUTLS_KX_RSA_EXPORT', 'GNUTLS_E_OPENPGP_SUBKEY_ERROR',
+           'GNUTLS_SIGN_RSA_SHA384', 'GNUTLS_CRT_X509',
+           'GNUTLS_E_EXPIRED', 'GNUTLS_E_UNWANTED_ALGORITHM',
+           'GNUTLS_SIGN_RSA_RMD160', 'GNUTLS_OID_X520_INITIALS',
+           'GNUTLS_KP_EMAIL_PROTECTION', 'gnutls_connection_end_t',
+           'GNUTLS_E_INIT_LIBEXTRA', 'GNUTLS_PKCS_PLAIN',
+           'GNUTLS_HANDSHAKE_SERVER_KEY_EXCHANGE',
+           'GNUTLS_CRL_REASON_CESSATION_OF_OPERATION',
+           'GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER',
+           'GNUTLS_CIPHER_CAMELLIA_128_CBC',
+           'GNUTLS_E_ASN1_GENERIC_ERROR',
+           'GNUTLS_E_ILLEGAL_SRP_USERNAME',
+           'GNUTLS_E_UNSUPPORTED_CERTIFICATE_TYPE', 'GNUTLS_PK_DSA',
+           'GNUTLS_E_INCOMPATIBLE_LIBTASN1_LIBRARY',
+           'GNUTLS_SAN_RFC822NAME',
+           'GNUTLS_E_BASE64_UNEXPECTED_HEADER_ERROR',
+           'GNUTLS_PKCS_USE_PKCS12_3DES', 'GNUTLS_CIPHER_ARCFOUR_40',
+           'GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE',
+           'GNUTLS_CIPHER_RC2_40_CBC', 'GNUTLS_CIPHER_AES_128_CBC',
+           'GNUTLS_OID_LDAP_DC', 'GNUTLS_KP_TLS_WWW_CLIENT',
+           'GNUTLS_A_INTERNAL_ERROR', 'GNUTLS_A_ILLEGAL_PARAMETER',
+           'gnutls_certificate_print_formats',
+           'GNUTLS_OID_X520_LOCALITY_NAME',
+           'GNUTLS_E_CERTIFICATE_ERROR', 'GNUTLS_CRT_PRINT_ONELINE',
+           'GNUTLS_KP_CODE_SIGNING']
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/library/errors.py b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/library/errors.py
new file mode 100644
index 0000000..1e4dea7
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/library/errors.py
@@ -0,0 +1,78 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS library errors"""
+
+from gnutls.errors import *
+from gnutls.errors import __all__
+
+from gnutls.library.constants import GNUTLS_E_AGAIN, GNUTLS_E_INTERRUPTED, GNUTLS_E_NO_CERTIFICATE_FOUND
+from gnutls.library.constants import GNUTLS_E_MEMORY_ERROR, GNUTLS_E_SHORT_MEMORY_BUFFER
+from gnutls.library.constants import GNUTLS_E_FATAL_ALERT_RECEIVED, GNUTLS_A_BAD_CERTIFICATE
+from gnutls.library.constants import GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE
+from gnutls.library.constants import GNUTLS_A_UNKNOWN_CA, GNUTLS_A_INSUFFICIENT_SECURITY
+from gnutls.library.constants import GNUTLS_A_CERTIFICATE_EXPIRED, GNUTLS_A_CERTIFICATE_REVOKED
+from gnutls.library.functions import gnutls_strerror, gnutls_alert_get
+
+class ErrorMessage(str):
+    def __new__(cls, code):
+        obj = str.__new__(cls, gnutls_strerror(code))
+        obj.code = code
+        return obj
+
+# Check functions which return an integer status code (negative codes being errors)
+#
+def _check_status(retcode, function, args):
+    if retcode >= 0:
+        return retcode
+    elif retcode == -1:
+        from gnutls.library import functions
+        if function in (functions.gnutls_certificate_activation_time_peers,
+                        functions.gnutls_x509_crt_get_activation_time,
+                        functions.gnutls_openpgp_key_get_creation_time):
+            raise GNUTLSError("cannot retrieve activation time")
+        elif function in (functions.gnutls_certificate_expiration_time_peers,
+                          functions.gnutls_x509_crt_get_expiration_time,
+                          functions.gnutls_openpgp_key_get_expiration_time):
+            raise GNUTLSError("cannot retrieve expiration time")
+        elif function in (functions.gnutls_x509_crl_get_this_update,
+                          functions.gnutls_x509_crl_get_next_update):
+            raise GNUTLSError("cannot retrieve CRL update time")
+        else:
+            raise GNUTLSError(ErrorMessage(retcode))
+    elif retcode == GNUTLS_E_AGAIN:
+        raise OperationWouldBlock(gnutls_strerror(retcode))
+    elif retcode == GNUTLS_E_INTERRUPTED:
+        raise OperationInterrupted(gnutls_strerror(retcode))
+    elif retcode in (GNUTLS_E_MEMORY_ERROR, GNUTLS_E_SHORT_MEMORY_BUFFER):
+        raise MemoryError(ErrorMessage(retcode))
+    elif retcode == GNUTLS_E_NO_CERTIFICATE_FOUND:
+        raise CertificateSecurityError(gnutls_strerror(retcode))
+    elif retcode == GNUTLS_E_FATAL_ALERT_RECEIVED:
+        alertdict = {
+            GNUTLS_A_BAD_CERTIFICATE: (CertificateError, "peer rejected our certificate as invalid"),
+            GNUTLS_A_UNKNOWN_CA: (CertificateAuthorityError, "peer does not trust our certificate authority"),
+            GNUTLS_A_INSUFFICIENT_SECURITY: (CertificateSecurityError, "peer rejected us on insufficient security"),
+            GNUTLS_A_CERTIFICATE_EXPIRED: (CertificateExpiredError, "peer rejected our certificate as expired"),
+            GNUTLS_A_CERTIFICATE_REVOKED: (CertificateRevokedError, "peer rejected our certificate as revoked")}
+        alert = gnutls_alert_get(args[0])
+        exception, reason = alertdict.get(alert, (GNUTLSError, ErrorMessage(retcode)))
+        raise exception(reason)
+    elif retcode == GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE:
+        raise RequestedDataNotAvailable(gnutls_strerror(retcode))
+    else:
+        raise GNUTLSError(ErrorMessage(retcode))
+
+# Attach the error checking function to all functions returning integers
+#
+from gnutls.library import functions
+from ctypes import c_int, c_long
+
+for func in functions.__dict__.values():
+    if not hasattr(func, 'errcheck'):
+        continue ## not a function
+    if func.restype in (c_int, c_long):
+        func.errcheck = _check_status
+
+del c_int, c_long, func, functions
+
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/library/functions.py b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/library/functions.py
new file mode 100644
index 0000000..5ee3cab
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/library/functions.py
@@ -0,0 +1,1836 @@
+from ctypes import *
+
+from gnutls.library.types import gnutls_ia_client_credentials_t
+_libraries = {}
+_libraries['libgnutls-extra.so.26'] = CDLL('libgnutls-extra.so.26')
+from gnutls.library.types import gnutls_ia_server_credentials_t
+from gnutls.library.types import gnutls_ia_avp_func
+from gnutls.library.types import gnutls_session_t
+from gnutls.library.types import size_t
+STRING = c_char_p
+from gnutls.library.types import ssize_t
+from gnutls.library.constants import gnutls_pk_algorithm_t
+_libraries['libgnutls.so.26'] = CDLL('libgnutls.so.26')
+from gnutls.library.constants import gnutls_sign_algorithm_t
+from gnutls.library.constants import gnutls_connection_end_t
+from gnutls.library.constants import gnutls_close_request_t
+from gnutls.library.constants import gnutls_alert_description_t
+from gnutls.library.constants import gnutls_alert_level_t
+from gnutls.library.constants import gnutls_cipher_algorithm_t
+from gnutls.library.constants import gnutls_kx_algorithm_t
+from gnutls.library.constants import gnutls_mac_algorithm_t
+from gnutls.library.constants import gnutls_compression_method_t
+from gnutls.library.constants import gnutls_certificate_type_t
+from gnutls.library.constants import gnutls_protocol_t
+from gnutls.library.constants import gnutls_handshake_description_t
+from gnutls.library.constants import gnutls_server_name_type_t
+from gnutls.library.constants import gnutls_supplemental_data_format_type_t
+from gnutls.library.types import gnutls_priority_t
+from gnutls.library.types import gnutls_datum_t
+from gnutls.library.types import gnutls_db_retr_func
+from gnutls.library.types import gnutls_db_remove_func
+from gnutls.library.types import gnutls_db_store_func
+from gnutls.library.types import gnutls_datum_t
+from gnutls.library.types import gnutls_handshake_post_client_hello_func
+from gnutls.library.constants import gnutls_credentials_type_t
+from gnutls.library.types import gnutls_anon_server_credentials_t
+from gnutls.library.types import gnutls_dh_params_t
+from gnutls.library.types import gnutls_params_function
+from gnutls.library.types import gnutls_anon_client_credentials_t
+from gnutls.library.types import gnutls_certificate_credentials_t
+from gnutls.library.types import gnutls_rsa_params_t
+from gnutls.library.constants import gnutls_x509_crt_fmt_t
+from gnutls.library.types import gnutls_x509_crt_t
+from gnutls.library.types import gnutls_x509_privkey_t
+from gnutls.library.types import gnutls_x509_crl_t
+from gnutls.library.types import gnutls_openpgp_keyring_t
+from gnutls.library.types import gnutls_alloc_function
+from gnutls.library.types import gnutls_is_secure_function
+from gnutls.library.types import gnutls_realloc_function
+from gnutls.library.types import gnutls_free_function
+from gnutls.library.types import gnutls_log_func
+from gnutls.library.types import gnutls_transport_ptr_t
+from gnutls.library.types import gnutls_push_func
+from gnutls.library.types import gnutls_pull_func
+from gnutls.library.constants import gnutls_openpgp_crt_status_t
+from gnutls.library.constants import gnutls_digest_algorithm_t
+from gnutls.library.types import gnutls_srp_client_credentials_t
+from gnutls.library.types import gnutls_srp_server_credentials_t
+from gnutls.library.types import gnutls_srp_server_credentials_function
+from gnutls.library.types import gnutls_srp_client_credentials_function
+from gnutls.library.types import gnutls_psk_client_credentials_t
+from gnutls.library.constants import gnutls_psk_key_flags
+from gnutls.library.types import gnutls_psk_server_credentials_t
+from gnutls.library.types import gnutls_psk_server_credentials_function
+from gnutls.library.types import gnutls_psk_client_credentials_function
+from gnutls.library.types import gnutls_sign_func
+from gnutls.library.types import gnutls_certificate_client_retrieve_function
+from gnutls.library.types import gnutls_certificate_server_retrieve_function
+from gnutls.library.constants import gnutls_certificate_request_t
+from gnutls.library.types import gnutls_openpgp_crt_t
+from gnutls.library.types import gnutls_openpgp_crt_fmt_t
+from gnutls.library.types import gnutls_certificate_print_formats_t
+from gnutls.library.types import gnutls_openpgp_privkey_t
+from gnutls.library.types import gnutls_openpgp_recv_key_func
+from gnutls.library.constants import gnutls_x509_subject_alt_name_t
+from gnutls.library.types import gnutls_x509_dn_t
+from gnutls.library.types import gnutls_x509_ava_st
+from gnutls.library.types import gnutls_pkcs7_t
+from gnutls.library.types import gnutls_x509_crq_t
+
+
+gnutls_ia_free_client_credentials = _libraries['libgnutls-extra.so.26'].gnutls_ia_free_client_credentials
+gnutls_ia_free_client_credentials.restype = None
+gnutls_ia_free_client_credentials.argtypes = [gnutls_ia_client_credentials_t]
+gnutls_ia_allocate_client_credentials = _libraries['libgnutls-extra.so.26'].gnutls_ia_allocate_client_credentials
+gnutls_ia_allocate_client_credentials.restype = c_int
+gnutls_ia_allocate_client_credentials.argtypes = [POINTER(gnutls_ia_client_credentials_t)]
+gnutls_ia_free_server_credentials = _libraries['libgnutls-extra.so.26'].gnutls_ia_free_server_credentials
+gnutls_ia_free_server_credentials.restype = None
+gnutls_ia_free_server_credentials.argtypes = [gnutls_ia_server_credentials_t]
+gnutls_ia_allocate_server_credentials = _libraries['libgnutls-extra.so.26'].gnutls_ia_allocate_server_credentials
+gnutls_ia_allocate_server_credentials.restype = c_int
+gnutls_ia_allocate_server_credentials.argtypes = [POINTER(gnutls_ia_server_credentials_t)]
+gnutls_ia_set_client_avp_function = _libraries['libgnutls-extra.so.26'].gnutls_ia_set_client_avp_function
+gnutls_ia_set_client_avp_function.restype = None
+gnutls_ia_set_client_avp_function.argtypes = [gnutls_ia_client_credentials_t, gnutls_ia_avp_func]
+gnutls_ia_set_client_avp_ptr = _libraries['libgnutls-extra.so.26'].gnutls_ia_set_client_avp_ptr
+gnutls_ia_set_client_avp_ptr.restype = None
+gnutls_ia_set_client_avp_ptr.argtypes = [gnutls_ia_client_credentials_t, c_void_p]
+gnutls_ia_get_client_avp_ptr = _libraries['libgnutls-extra.so.26'].gnutls_ia_get_client_avp_ptr
+gnutls_ia_get_client_avp_ptr.restype = c_void_p
+gnutls_ia_get_client_avp_ptr.argtypes = [gnutls_ia_client_credentials_t]
+gnutls_ia_set_server_avp_function = _libraries['libgnutls-extra.so.26'].gnutls_ia_set_server_avp_function
+gnutls_ia_set_server_avp_function.restype = None
+gnutls_ia_set_server_avp_function.argtypes = [gnutls_ia_server_credentials_t, gnutls_ia_avp_func]
+gnutls_ia_set_server_avp_ptr = _libraries['libgnutls-extra.so.26'].gnutls_ia_set_server_avp_ptr
+gnutls_ia_set_server_avp_ptr.restype = None
+gnutls_ia_set_server_avp_ptr.argtypes = [gnutls_ia_server_credentials_t, c_void_p]
+gnutls_ia_get_server_avp_ptr = _libraries['libgnutls-extra.so.26'].gnutls_ia_get_server_avp_ptr
+gnutls_ia_get_server_avp_ptr.restype = c_void_p
+gnutls_ia_get_server_avp_ptr.argtypes = [gnutls_ia_server_credentials_t]
+gnutls_ia_handshake_p = _libraries['libgnutls-extra.so.26'].gnutls_ia_handshake_p
+gnutls_ia_handshake_p.restype = c_int
+gnutls_ia_handshake_p.argtypes = [gnutls_session_t]
+gnutls_ia_handshake = _libraries['libgnutls-extra.so.26'].gnutls_ia_handshake
+gnutls_ia_handshake.restype = c_int
+gnutls_ia_handshake.argtypes = [gnutls_session_t]
+gnutls_ia_permute_inner_secret = _libraries['libgnutls-extra.so.26'].gnutls_ia_permute_inner_secret
+gnutls_ia_permute_inner_secret.restype = c_int
+gnutls_ia_permute_inner_secret.argtypes = [gnutls_session_t, size_t, STRING]
+gnutls_ia_endphase_send = _libraries['libgnutls-extra.so.26'].gnutls_ia_endphase_send
+gnutls_ia_endphase_send.restype = c_int
+gnutls_ia_endphase_send.argtypes = [gnutls_session_t, c_int]
+gnutls_ia_verify_endphase = _libraries['libgnutls-extra.so.26'].gnutls_ia_verify_endphase
+gnutls_ia_verify_endphase.restype = c_int
+gnutls_ia_verify_endphase.argtypes = [gnutls_session_t, STRING]
+gnutls_ia_send = _libraries['libgnutls-extra.so.26'].gnutls_ia_send
+gnutls_ia_send.restype = ssize_t
+gnutls_ia_send.argtypes = [gnutls_session_t, STRING, size_t]
+gnutls_ia_recv = _libraries['libgnutls-extra.so.26'].gnutls_ia_recv
+gnutls_ia_recv.restype = ssize_t
+gnutls_ia_recv.argtypes = [gnutls_session_t, STRING, size_t]
+gnutls_ia_generate_challenge = _libraries['libgnutls-extra.so.26'].gnutls_ia_generate_challenge
+gnutls_ia_generate_challenge.restype = c_int
+gnutls_ia_generate_challenge.argtypes = [gnutls_session_t, size_t, STRING]
+gnutls_ia_extract_inner_secret = _libraries['libgnutls-extra.so.26'].gnutls_ia_extract_inner_secret
+gnutls_ia_extract_inner_secret.restype = None
+gnutls_ia_extract_inner_secret.argtypes = [gnutls_session_t, STRING]
+gnutls_ia_enable = _libraries['libgnutls-extra.so.26'].gnutls_ia_enable
+gnutls_ia_enable.restype = None
+gnutls_ia_enable.argtypes = [gnutls_session_t, c_int]
+gnutls_global_init_extra = _libraries['libgnutls-extra.so.26'].gnutls_global_init_extra
+gnutls_global_init_extra.restype = c_int
+gnutls_global_init_extra.argtypes = []
+gnutls_extra_check_version = _libraries['libgnutls-extra.so.26'].gnutls_extra_check_version
+gnutls_extra_check_version.restype = STRING
+gnutls_extra_check_version.argtypes = [STRING]
+gnutls_pk_algorithm_get_name = _libraries['libgnutls.so.26'].gnutls_pk_algorithm_get_name
+gnutls_pk_algorithm_get_name.restype = STRING
+gnutls_pk_algorithm_get_name.argtypes = [gnutls_pk_algorithm_t]
+gnutls_sign_algorithm_get_name = _libraries['libgnutls.so.26'].gnutls_sign_algorithm_get_name
+gnutls_sign_algorithm_get_name.restype = STRING
+gnutls_sign_algorithm_get_name.argtypes = [gnutls_sign_algorithm_t]
+gnutls_init = _libraries['libgnutls.so.26'].gnutls_init
+gnutls_init.restype = c_int
+gnutls_init.argtypes = [POINTER(gnutls_session_t), gnutls_connection_end_t]
+gnutls_deinit = _libraries['libgnutls.so.26'].gnutls_deinit
+gnutls_deinit.restype = None
+gnutls_deinit.argtypes = [gnutls_session_t]
+gnutls_bye = _libraries['libgnutls.so.26'].gnutls_bye
+gnutls_bye.restype = c_int
+gnutls_bye.argtypes = [gnutls_session_t, gnutls_close_request_t]
+gnutls_handshake = _libraries['libgnutls.so.26'].gnutls_handshake
+gnutls_handshake.restype = c_int
+gnutls_handshake.argtypes = [gnutls_session_t]
+gnutls_rehandshake = _libraries['libgnutls.so.26'].gnutls_rehandshake
+gnutls_rehandshake.restype = c_int
+gnutls_rehandshake.argtypes = [gnutls_session_t]
+gnutls_alert_get = _libraries['libgnutls.so.26'].gnutls_alert_get
+gnutls_alert_get.restype = gnutls_alert_description_t
+gnutls_alert_get.argtypes = [gnutls_session_t]
+gnutls_alert_send = _libraries['libgnutls.so.26'].gnutls_alert_send
+gnutls_alert_send.restype = c_int
+gnutls_alert_send.argtypes = [gnutls_session_t, gnutls_alert_level_t, gnutls_alert_description_t]
+gnutls_alert_send_appropriate = _libraries['libgnutls.so.26'].gnutls_alert_send_appropriate
+gnutls_alert_send_appropriate.restype = c_int
+gnutls_alert_send_appropriate.argtypes = [gnutls_session_t, c_int]
+gnutls_alert_get_name = _libraries['libgnutls.so.26'].gnutls_alert_get_name
+gnutls_alert_get_name.restype = STRING
+gnutls_alert_get_name.argtypes = [gnutls_alert_description_t]
+gnutls_cipher_get = _libraries['libgnutls.so.26'].gnutls_cipher_get
+gnutls_cipher_get.restype = gnutls_cipher_algorithm_t
+gnutls_cipher_get.argtypes = [gnutls_session_t]
+gnutls_kx_get = _libraries['libgnutls.so.26'].gnutls_kx_get
+gnutls_kx_get.restype = gnutls_kx_algorithm_t
+gnutls_kx_get.argtypes = [gnutls_session_t]
+gnutls_mac_get = _libraries['libgnutls.so.26'].gnutls_mac_get
+gnutls_mac_get.restype = gnutls_mac_algorithm_t
+gnutls_mac_get.argtypes = [gnutls_session_t]
+gnutls_compression_get = _libraries['libgnutls.so.26'].gnutls_compression_get
+gnutls_compression_get.restype = gnutls_compression_method_t
+gnutls_compression_get.argtypes = [gnutls_session_t]
+gnutls_certificate_type_get = _libraries['libgnutls.so.26'].gnutls_certificate_type_get
+gnutls_certificate_type_get.restype = gnutls_certificate_type_t
+gnutls_certificate_type_get.argtypes = [gnutls_session_t]
+gnutls_cipher_get_key_size = _libraries['libgnutls.so.26'].gnutls_cipher_get_key_size
+gnutls_cipher_get_key_size.restype = size_t
+gnutls_cipher_get_key_size.argtypes = [gnutls_cipher_algorithm_t]
+gnutls_mac_get_key_size = _libraries['libgnutls.so.26'].gnutls_mac_get_key_size
+gnutls_mac_get_key_size.restype = size_t
+gnutls_mac_get_key_size.argtypes = [gnutls_mac_algorithm_t]
+gnutls_cipher_get_name = _libraries['libgnutls.so.26'].gnutls_cipher_get_name
+gnutls_cipher_get_name.restype = STRING
+gnutls_cipher_get_name.argtypes = [gnutls_cipher_algorithm_t]
+gnutls_mac_get_name = _libraries['libgnutls.so.26'].gnutls_mac_get_name
+gnutls_mac_get_name.restype = STRING
+gnutls_mac_get_name.argtypes = [gnutls_mac_algorithm_t]
+gnutls_compression_get_name = _libraries['libgnutls.so.26'].gnutls_compression_get_name
+gnutls_compression_get_name.restype = STRING
+gnutls_compression_get_name.argtypes = [gnutls_compression_method_t]
+gnutls_kx_get_name = _libraries['libgnutls.so.26'].gnutls_kx_get_name
+gnutls_kx_get_name.restype = STRING
+gnutls_kx_get_name.argtypes = [gnutls_kx_algorithm_t]
+gnutls_certificate_type_get_name = _libraries['libgnutls.so.26'].gnutls_certificate_type_get_name
+gnutls_certificate_type_get_name.restype = STRING
+gnutls_certificate_type_get_name.argtypes = [gnutls_certificate_type_t]
+gnutls_mac_get_id = _libraries['libgnutls.so.26'].gnutls_mac_get_id
+gnutls_mac_get_id.restype = gnutls_mac_algorithm_t
+gnutls_mac_get_id.argtypes = [STRING]
+gnutls_compression_get_id = _libraries['libgnutls.so.26'].gnutls_compression_get_id
+gnutls_compression_get_id.restype = gnutls_compression_method_t
+gnutls_compression_get_id.argtypes = [STRING]
+gnutls_cipher_get_id = _libraries['libgnutls.so.26'].gnutls_cipher_get_id
+gnutls_cipher_get_id.restype = gnutls_cipher_algorithm_t
+gnutls_cipher_get_id.argtypes = [STRING]
+gnutls_kx_get_id = _libraries['libgnutls.so.26'].gnutls_kx_get_id
+gnutls_kx_get_id.restype = gnutls_kx_algorithm_t
+gnutls_kx_get_id.argtypes = [STRING]
+gnutls_protocol_get_id = _libraries['libgnutls.so.26'].gnutls_protocol_get_id
+gnutls_protocol_get_id.restype = gnutls_protocol_t
+gnutls_protocol_get_id.argtypes = [STRING]
+gnutls_certificate_type_get_id = _libraries['libgnutls.so.26'].gnutls_certificate_type_get_id
+gnutls_certificate_type_get_id.restype = gnutls_certificate_type_t
+gnutls_certificate_type_get_id.argtypes = [STRING]
+gnutls_cipher_list = _libraries['libgnutls.so.26'].gnutls_cipher_list
+gnutls_cipher_list.restype = POINTER(gnutls_cipher_algorithm_t)
+gnutls_cipher_list.argtypes = []
+gnutls_mac_list = _libraries['libgnutls.so.26'].gnutls_mac_list
+gnutls_mac_list.restype = POINTER(gnutls_mac_algorithm_t)
+gnutls_mac_list.argtypes = []
+gnutls_compression_list = _libraries['libgnutls.so.26'].gnutls_compression_list
+gnutls_compression_list.restype = POINTER(gnutls_compression_method_t)
+gnutls_compression_list.argtypes = []
+gnutls_protocol_list = _libraries['libgnutls.so.26'].gnutls_protocol_list
+gnutls_protocol_list.restype = POINTER(gnutls_protocol_t)
+gnutls_protocol_list.argtypes = []
+gnutls_certificate_type_list = _libraries['libgnutls.so.26'].gnutls_certificate_type_list
+gnutls_certificate_type_list.restype = POINTER(gnutls_certificate_type_t)
+gnutls_certificate_type_list.argtypes = []
+gnutls_kx_list = _libraries['libgnutls.so.26'].gnutls_kx_list
+gnutls_kx_list.restype = POINTER(gnutls_kx_algorithm_t)
+gnutls_kx_list.argtypes = []
+gnutls_cipher_suite_info = _libraries['libgnutls.so.26'].gnutls_cipher_suite_info
+gnutls_cipher_suite_info.restype = STRING
+gnutls_cipher_suite_info.argtypes = [size_t, STRING, POINTER(gnutls_kx_algorithm_t), POINTER(gnutls_cipher_algorithm_t), POINTER(gnutls_mac_algorithm_t), POINTER(gnutls_protocol_t)]
+gnutls_error_is_fatal = _libraries['libgnutls.so.26'].gnutls_error_is_fatal
+gnutls_error_is_fatal.restype = c_int
+gnutls_error_is_fatal.argtypes = [c_int]
+gnutls_error_to_alert = _libraries['libgnutls.so.26'].gnutls_error_to_alert
+gnutls_error_to_alert.restype = c_int
+gnutls_error_to_alert.argtypes = [c_int, POINTER(c_int)]
+gnutls_perror = _libraries['libgnutls.so.26'].gnutls_perror
+gnutls_perror.restype = None
+gnutls_perror.argtypes = [c_int]
+gnutls_strerror = _libraries['libgnutls.so.26'].gnutls_strerror
+gnutls_strerror.restype = STRING
+gnutls_strerror.argtypes = [c_int]
+gnutls_handshake_set_private_extensions = _libraries['libgnutls.so.26'].gnutls_handshake_set_private_extensions
+gnutls_handshake_set_private_extensions.restype = None
+gnutls_handshake_set_private_extensions.argtypes = [gnutls_session_t, c_int]
+gnutls_handshake_get_last_out = _libraries['libgnutls.so.26'].gnutls_handshake_get_last_out
+gnutls_handshake_get_last_out.restype = gnutls_handshake_description_t
+gnutls_handshake_get_last_out.argtypes = [gnutls_session_t]
+gnutls_handshake_get_last_in = _libraries['libgnutls.so.26'].gnutls_handshake_get_last_in
+gnutls_handshake_get_last_in.restype = gnutls_handshake_description_t
+gnutls_handshake_get_last_in.argtypes = [gnutls_session_t]
+gnutls_record_send = _libraries['libgnutls.so.26'].gnutls_record_send
+gnutls_record_send.restype = ssize_t
+gnutls_record_send.argtypes = [gnutls_session_t, c_void_p, size_t]
+gnutls_record_recv = _libraries['libgnutls.so.26'].gnutls_record_recv
+gnutls_record_recv.restype = ssize_t
+gnutls_record_recv.argtypes = [gnutls_session_t, c_void_p, size_t]
+gnutls_session_enable_compatibility_mode = _libraries['libgnutls.so.26'].gnutls_session_enable_compatibility_mode
+gnutls_session_enable_compatibility_mode.restype = None
+gnutls_session_enable_compatibility_mode.argtypes = [gnutls_session_t]
+gnutls_record_disable_padding = _libraries['libgnutls.so.26'].gnutls_record_disable_padding
+gnutls_record_disable_padding.restype = None
+gnutls_record_disable_padding.argtypes = [gnutls_session_t]
+gnutls_record_get_direction = _libraries['libgnutls.so.26'].gnutls_record_get_direction
+gnutls_record_get_direction.restype = c_int
+gnutls_record_get_direction.argtypes = [gnutls_session_t]
+gnutls_record_get_max_size = _libraries['libgnutls.so.26'].gnutls_record_get_max_size
+gnutls_record_get_max_size.restype = size_t
+gnutls_record_get_max_size.argtypes = [gnutls_session_t]
+gnutls_record_set_max_size = _libraries['libgnutls.so.26'].gnutls_record_set_max_size
+gnutls_record_set_max_size.restype = ssize_t
+gnutls_record_set_max_size.argtypes = [gnutls_session_t, size_t]
+gnutls_record_check_pending = _libraries['libgnutls.so.26'].gnutls_record_check_pending
+gnutls_record_check_pending.restype = size_t
+gnutls_record_check_pending.argtypes = [gnutls_session_t]
+gnutls_prf = _libraries['libgnutls.so.26'].gnutls_prf
+gnutls_prf.restype = c_int
+gnutls_prf.argtypes = [gnutls_session_t, size_t, STRING, c_int, size_t, STRING, size_t, STRING]
+gnutls_prf_raw = _libraries['libgnutls.so.26'].gnutls_prf_raw
+gnutls_prf_raw.restype = c_int
+gnutls_prf_raw.argtypes = [gnutls_session_t, size_t, STRING, size_t, STRING, size_t, STRING]
+gnutls_server_name_set = _libraries['libgnutls.so.26'].gnutls_server_name_set
+gnutls_server_name_set.restype = c_int
+gnutls_server_name_set.argtypes = [gnutls_session_t, gnutls_server_name_type_t, c_void_p, size_t]
+gnutls_server_name_get = _libraries['libgnutls.so.26'].gnutls_server_name_get
+gnutls_server_name_get.restype = c_int
+gnutls_server_name_get.argtypes = [gnutls_session_t, c_void_p, POINTER(size_t), POINTER(c_uint), c_uint]
+gnutls_supplemental_get_name = _libraries['libgnutls.so.26'].gnutls_supplemental_get_name
+gnutls_supplemental_get_name.restype = STRING
+gnutls_supplemental_get_name.argtypes = [gnutls_supplemental_data_format_type_t]
+gnutls_cipher_set_priority = _libraries['libgnutls.so.26'].gnutls_cipher_set_priority
+gnutls_cipher_set_priority.restype = c_int
+gnutls_cipher_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)]
+gnutls_mac_set_priority = _libraries['libgnutls.so.26'].gnutls_mac_set_priority
+gnutls_mac_set_priority.restype = c_int
+gnutls_mac_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)]
+gnutls_compression_set_priority = _libraries['libgnutls.so.26'].gnutls_compression_set_priority
+gnutls_compression_set_priority.restype = c_int
+gnutls_compression_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)]
+gnutls_kx_set_priority = _libraries['libgnutls.so.26'].gnutls_kx_set_priority
+gnutls_kx_set_priority.restype = c_int
+gnutls_kx_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)]
+gnutls_protocol_set_priority = _libraries['libgnutls.so.26'].gnutls_protocol_set_priority
+gnutls_protocol_set_priority.restype = c_int
+gnutls_protocol_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)]
+gnutls_certificate_type_set_priority = _libraries['libgnutls.so.26'].gnutls_certificate_type_set_priority
+gnutls_certificate_type_set_priority.restype = c_int
+gnutls_certificate_type_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)]
+gnutls_priority_init = _libraries['libgnutls.so.26'].gnutls_priority_init
+gnutls_priority_init.restype = c_int
+gnutls_priority_init.argtypes = [POINTER(gnutls_priority_t), STRING, POINTER(STRING)]
+gnutls_priority_deinit = _libraries['libgnutls.so.26'].gnutls_priority_deinit
+gnutls_priority_deinit.restype = None
+gnutls_priority_deinit.argtypes = [gnutls_priority_t]
+gnutls_priority_set = _libraries['libgnutls.so.26'].gnutls_priority_set
+gnutls_priority_set.restype = c_int
+gnutls_priority_set.argtypes = [gnutls_session_t, gnutls_priority_t]
+gnutls_priority_set_direct = _libraries['libgnutls.so.26'].gnutls_priority_set_direct
+gnutls_priority_set_direct.restype = c_int
+gnutls_priority_set_direct.argtypes = [gnutls_session_t, STRING, POINTER(STRING)]
+gnutls_set_default_priority = _libraries['libgnutls.so.26'].gnutls_set_default_priority
+gnutls_set_default_priority.restype = c_int
+gnutls_set_default_priority.argtypes = [gnutls_session_t]
+gnutls_set_default_export_priority = _libraries['libgnutls.so.26'].gnutls_set_default_export_priority
+gnutls_set_default_export_priority.restype = c_int
+gnutls_set_default_export_priority.argtypes = [gnutls_session_t]
+gnutls_cipher_suite_get_name = _libraries['libgnutls.so.26'].gnutls_cipher_suite_get_name
+gnutls_cipher_suite_get_name.restype = STRING
+gnutls_cipher_suite_get_name.argtypes = [gnutls_kx_algorithm_t, gnutls_cipher_algorithm_t, gnutls_mac_algorithm_t]
+gnutls_protocol_get_version = _libraries['libgnutls.so.26'].gnutls_protocol_get_version
+gnutls_protocol_get_version.restype = gnutls_protocol_t
+gnutls_protocol_get_version.argtypes = [gnutls_session_t]
+gnutls_protocol_get_name = _libraries['libgnutls.so.26'].gnutls_protocol_get_name
+gnutls_protocol_get_name.restype = STRING
+gnutls_protocol_get_name.argtypes = [gnutls_protocol_t]
+gnutls_session_set_data = _libraries['libgnutls.so.26'].gnutls_session_set_data
+gnutls_session_set_data.restype = c_int
+gnutls_session_set_data.argtypes = [gnutls_session_t, c_void_p, size_t]
+gnutls_session_get_data = _libraries['libgnutls.so.26'].gnutls_session_get_data
+gnutls_session_get_data.restype = c_int
+gnutls_session_get_data.argtypes = [gnutls_session_t, c_void_p, POINTER(size_t)]
+gnutls_session_get_data2 = _libraries['libgnutls.so.26'].gnutls_session_get_data2
+gnutls_session_get_data2.restype = c_int
+gnutls_session_get_data2.argtypes = [gnutls_session_t, POINTER(gnutls_datum_t)]
+gnutls_session_get_id = _libraries['libgnutls.so.26'].gnutls_session_get_id
+gnutls_session_get_id.restype = c_int
+gnutls_session_get_id.argtypes = [gnutls_session_t, c_void_p, POINTER(size_t)]
+gnutls_session_get_server_random = _libraries['libgnutls.so.26'].gnutls_session_get_server_random
+gnutls_session_get_server_random.restype = c_void_p
+gnutls_session_get_server_random.argtypes = [gnutls_session_t]
+gnutls_session_get_client_random = _libraries['libgnutls.so.26'].gnutls_session_get_client_random
+gnutls_session_get_client_random.restype = c_void_p
+gnutls_session_get_client_random.argtypes = [gnutls_session_t]
+gnutls_session_get_master_secret = _libraries['libgnutls.so.26'].gnutls_session_get_master_secret
+gnutls_session_get_master_secret.restype = c_void_p
+gnutls_session_get_master_secret.argtypes = [gnutls_session_t]
+gnutls_session_is_resumed = _libraries['libgnutls.so.26'].gnutls_session_is_resumed
+gnutls_session_is_resumed.restype = c_int
+gnutls_session_is_resumed.argtypes = [gnutls_session_t]
+gnutls_db_set_cache_expiration = _libraries['libgnutls.so.26'].gnutls_db_set_cache_expiration
+gnutls_db_set_cache_expiration.restype = None
+gnutls_db_set_cache_expiration.argtypes = [gnutls_session_t, c_int]
+gnutls_db_remove_session = _libraries['libgnutls.so.26'].gnutls_db_remove_session
+gnutls_db_remove_session.restype = None
+gnutls_db_remove_session.argtypes = [gnutls_session_t]
+gnutls_db_set_retrieve_function = _libraries['libgnutls.so.26'].gnutls_db_set_retrieve_function
+gnutls_db_set_retrieve_function.restype = None
+gnutls_db_set_retrieve_function.argtypes = [gnutls_session_t, gnutls_db_retr_func]
+gnutls_db_set_remove_function = _libraries['libgnutls.so.26'].gnutls_db_set_remove_function
+gnutls_db_set_remove_function.restype = None
+gnutls_db_set_remove_function.argtypes = [gnutls_session_t, gnutls_db_remove_func]
+gnutls_db_set_store_function = _libraries['libgnutls.so.26'].gnutls_db_set_store_function
+gnutls_db_set_store_function.restype = None
+gnutls_db_set_store_function.argtypes = [gnutls_session_t, gnutls_db_store_func]
+gnutls_db_set_ptr = _libraries['libgnutls.so.26'].gnutls_db_set_ptr
+gnutls_db_set_ptr.restype = None
+gnutls_db_set_ptr.argtypes = [gnutls_session_t, c_void_p]
+gnutls_db_get_ptr = _libraries['libgnutls.so.26'].gnutls_db_get_ptr
+gnutls_db_get_ptr.restype = c_void_p
+gnutls_db_get_ptr.argtypes = [gnutls_session_t]
+gnutls_db_check_entry = _libraries['libgnutls.so.26'].gnutls_db_check_entry
+gnutls_db_check_entry.restype = c_int
+gnutls_db_check_entry.argtypes = [gnutls_session_t, gnutls_datum_t]
+gnutls_handshake_set_post_client_hello_function = _libraries['libgnutls.so.26'].gnutls_handshake_set_post_client_hello_function
+gnutls_handshake_set_post_client_hello_function.restype = None
+gnutls_handshake_set_post_client_hello_function.argtypes = [gnutls_session_t, gnutls_handshake_post_client_hello_func]
+gnutls_handshake_set_max_packet_length = _libraries['libgnutls.so.26'].gnutls_handshake_set_max_packet_length
+gnutls_handshake_set_max_packet_length.restype = None
+gnutls_handshake_set_max_packet_length.argtypes = [gnutls_session_t, size_t]
+gnutls_check_version = _libraries['libgnutls.so.26'].gnutls_check_version
+gnutls_check_version.restype = STRING
+gnutls_check_version.argtypes = [STRING]
+gnutls_credentials_clear = _libraries['libgnutls.so.26'].gnutls_credentials_clear
+gnutls_credentials_clear.restype = None
+gnutls_credentials_clear.argtypes = [gnutls_session_t]
+gnutls_credentials_set = _libraries['libgnutls.so.26'].gnutls_credentials_set
+gnutls_credentials_set.restype = c_int
+gnutls_credentials_set.argtypes = [gnutls_session_t, gnutls_credentials_type_t, c_void_p]
+gnutls_anon_free_server_credentials = _libraries['libgnutls.so.26'].gnutls_anon_free_server_credentials
+gnutls_anon_free_server_credentials.restype = None
+gnutls_anon_free_server_credentials.argtypes = [gnutls_anon_server_credentials_t]
+gnutls_anon_allocate_server_credentials = _libraries['libgnutls.so.26'].gnutls_anon_allocate_server_credentials
+gnutls_anon_allocate_server_credentials.restype = c_int
+gnutls_anon_allocate_server_credentials.argtypes = [POINTER(gnutls_anon_server_credentials_t)]
+gnutls_anon_set_server_dh_params = _libraries['libgnutls.so.26'].gnutls_anon_set_server_dh_params
+gnutls_anon_set_server_dh_params.restype = None
+gnutls_anon_set_server_dh_params.argtypes = [gnutls_anon_server_credentials_t, gnutls_dh_params_t]
+gnutls_anon_set_server_params_function = _libraries['libgnutls.so.26'].gnutls_anon_set_server_params_function
+gnutls_anon_set_server_params_function.restype = None
+gnutls_anon_set_server_params_function.argtypes = [gnutls_anon_server_credentials_t, gnutls_params_function]
+gnutls_anon_free_client_credentials = _libraries['libgnutls.so.26'].gnutls_anon_free_client_credentials
+gnutls_anon_free_client_credentials.restype = None
+gnutls_anon_free_client_credentials.argtypes = [gnutls_anon_client_credentials_t]
+gnutls_anon_allocate_client_credentials = _libraries['libgnutls.so.26'].gnutls_anon_allocate_client_credentials
+gnutls_anon_allocate_client_credentials.restype = c_int
+gnutls_anon_allocate_client_credentials.argtypes = [POINTER(gnutls_anon_client_credentials_t)]
+gnutls_certificate_free_credentials = _libraries['libgnutls.so.26'].gnutls_certificate_free_credentials
+gnutls_certificate_free_credentials.restype = None
+gnutls_certificate_free_credentials.argtypes = [gnutls_certificate_credentials_t]
+gnutls_certificate_allocate_credentials = _libraries['libgnutls.so.26'].gnutls_certificate_allocate_credentials
+gnutls_certificate_allocate_credentials.restype = c_int
+gnutls_certificate_allocate_credentials.argtypes = [POINTER(gnutls_certificate_credentials_t)]
+gnutls_certificate_free_keys = _libraries['libgnutls.so.26'].gnutls_certificate_free_keys
+gnutls_certificate_free_keys.restype = None
+gnutls_certificate_free_keys.argtypes = [gnutls_certificate_credentials_t]
+gnutls_certificate_free_cas = _libraries['libgnutls.so.26'].gnutls_certificate_free_cas
+gnutls_certificate_free_cas.restype = None
+gnutls_certificate_free_cas.argtypes = [gnutls_certificate_credentials_t]
+gnutls_certificate_free_ca_names = _libraries['libgnutls.so.26'].gnutls_certificate_free_ca_names
+gnutls_certificate_free_ca_names.restype = None
+gnutls_certificate_free_ca_names.argtypes = [gnutls_certificate_credentials_t]
+gnutls_certificate_free_crls = _libraries['libgnutls.so.26'].gnutls_certificate_free_crls
+gnutls_certificate_free_crls.restype = None
+gnutls_certificate_free_crls.argtypes = [gnutls_certificate_credentials_t]
+gnutls_certificate_set_dh_params = _libraries['libgnutls.so.26'].gnutls_certificate_set_dh_params
+gnutls_certificate_set_dh_params.restype = None
+gnutls_certificate_set_dh_params.argtypes = [gnutls_certificate_credentials_t, gnutls_dh_params_t]
+gnutls_certificate_set_rsa_export_params = _libraries['libgnutls.so.26'].gnutls_certificate_set_rsa_export_params
+gnutls_certificate_set_rsa_export_params.restype = None
+gnutls_certificate_set_rsa_export_params.argtypes = [gnutls_certificate_credentials_t, gnutls_rsa_params_t]
+gnutls_certificate_set_verify_flags = _libraries['libgnutls.so.26'].gnutls_certificate_set_verify_flags
+gnutls_certificate_set_verify_flags.restype = None
+gnutls_certificate_set_verify_flags.argtypes = [gnutls_certificate_credentials_t, c_uint]
+gnutls_certificate_set_verify_limits = _libraries['libgnutls.so.26'].gnutls_certificate_set_verify_limits
+gnutls_certificate_set_verify_limits.restype = None
+gnutls_certificate_set_verify_limits.argtypes = [gnutls_certificate_credentials_t, c_uint, c_uint]
+gnutls_certificate_set_x509_trust_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_trust_file
+gnutls_certificate_set_x509_trust_file.restype = c_int
+gnutls_certificate_set_x509_trust_file.argtypes = [gnutls_certificate_credentials_t, STRING, gnutls_x509_crt_fmt_t]
+gnutls_certificate_set_x509_trust_mem = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_trust_mem
+gnutls_certificate_set_x509_trust_mem.restype = c_int
+gnutls_certificate_set_x509_trust_mem.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_certificate_set_x509_crl_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_crl_file
+gnutls_certificate_set_x509_crl_file.restype = c_int
+gnutls_certificate_set_x509_crl_file.argtypes = [gnutls_certificate_credentials_t, STRING, gnutls_x509_crt_fmt_t]
+gnutls_certificate_set_x509_crl_mem = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_crl_mem
+gnutls_certificate_set_x509_crl_mem.restype = c_int
+gnutls_certificate_set_x509_crl_mem.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_certificate_set_x509_key_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_key_file
+gnutls_certificate_set_x509_key_file.restype = c_int
+gnutls_certificate_set_x509_key_file.argtypes = [gnutls_certificate_credentials_t, STRING, STRING, gnutls_x509_crt_fmt_t]
+gnutls_certificate_set_x509_key_mem = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_key_mem
+gnutls_certificate_set_x509_key_mem.restype = c_int
+gnutls_certificate_set_x509_key_mem.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_certificate_send_x509_rdn_sequence = _libraries['libgnutls.so.26'].gnutls_certificate_send_x509_rdn_sequence
+gnutls_certificate_send_x509_rdn_sequence.restype = None
+gnutls_certificate_send_x509_rdn_sequence.argtypes = [gnutls_session_t, c_int]
+gnutls_certificate_set_x509_simple_pkcs12_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_simple_pkcs12_file
+gnutls_certificate_set_x509_simple_pkcs12_file.restype = c_int
+gnutls_certificate_set_x509_simple_pkcs12_file.argtypes = [gnutls_certificate_credentials_t, STRING, gnutls_x509_crt_fmt_t, STRING]
+gnutls_certificate_set_x509_key = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_key
+gnutls_certificate_set_x509_key.restype = c_int
+gnutls_certificate_set_x509_key.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_x509_crt_t), c_int, gnutls_x509_privkey_t]
+gnutls_certificate_set_x509_trust = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_trust
+gnutls_certificate_set_x509_trust.restype = c_int
+gnutls_certificate_set_x509_trust.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_x509_crt_t), c_int]
+gnutls_certificate_set_x509_crl = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_crl
+gnutls_certificate_set_x509_crl.restype = c_int
+gnutls_certificate_set_x509_crl.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_x509_crl_t), c_int]
+gnutls_certificate_get_x509_cas = _libraries['libgnutls.so.26'].gnutls_certificate_get_x509_cas
+gnutls_certificate_get_x509_cas.restype = None
+gnutls_certificate_get_x509_cas.argtypes = [gnutls_certificate_credentials_t, POINTER(POINTER(gnutls_x509_crt_t)), POINTER(c_uint)]
+gnutls_certificate_get_x509_crls = _libraries['libgnutls.so.26'].gnutls_certificate_get_x509_crls
+gnutls_certificate_get_x509_crls.restype = None
+gnutls_certificate_get_x509_crls.argtypes = [gnutls_certificate_credentials_t, POINTER(POINTER(gnutls_x509_crl_t)), POINTER(c_uint)]
+gnutls_certificate_get_openpgp_keyring = _libraries['libgnutls.so.26'].gnutls_certificate_get_openpgp_keyring
+gnutls_certificate_get_openpgp_keyring.restype = None
+gnutls_certificate_get_openpgp_keyring.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_openpgp_keyring_t)]
+gnutls_global_init = _libraries['libgnutls.so.26'].gnutls_global_init
+gnutls_global_init.restype = c_int
+gnutls_global_init.argtypes = []
+gnutls_global_deinit = _libraries['libgnutls.so.26'].gnutls_global_deinit
+gnutls_global_deinit.restype = None
+gnutls_global_deinit.argtypes = []
+gnutls_global_set_mem_functions = _libraries['libgnutls.so.26'].gnutls_global_set_mem_functions
+gnutls_global_set_mem_functions.restype = None
+gnutls_global_set_mem_functions.argtypes = [gnutls_alloc_function, gnutls_alloc_function, gnutls_is_secure_function, gnutls_realloc_function, gnutls_free_function]
+gnutls_global_set_log_function = _libraries['libgnutls.so.26'].gnutls_global_set_log_function
+gnutls_global_set_log_function.restype = None
+gnutls_global_set_log_function.argtypes = [gnutls_log_func]
+gnutls_global_set_log_level = _libraries['libgnutls.so.26'].gnutls_global_set_log_level
+gnutls_global_set_log_level.restype = None
+gnutls_global_set_log_level.argtypes = [c_int]
+gnutls_dh_params_init = _libraries['libgnutls.so.26'].gnutls_dh_params_init
+gnutls_dh_params_init.restype = c_int
+gnutls_dh_params_init.argtypes = [POINTER(gnutls_dh_params_t)]
+gnutls_dh_params_deinit = _libraries['libgnutls.so.26'].gnutls_dh_params_deinit
+gnutls_dh_params_deinit.restype = None
+gnutls_dh_params_deinit.argtypes = [gnutls_dh_params_t]
+gnutls_dh_params_import_raw = _libraries['libgnutls.so.26'].gnutls_dh_params_import_raw
+gnutls_dh_params_import_raw.restype = c_int
+gnutls_dh_params_import_raw.argtypes = [gnutls_dh_params_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_dh_params_import_pkcs3 = _libraries['libgnutls.so.26'].gnutls_dh_params_import_pkcs3
+gnutls_dh_params_import_pkcs3.restype = c_int
+gnutls_dh_params_import_pkcs3.argtypes = [gnutls_dh_params_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_dh_params_generate2 = _libraries['libgnutls.so.26'].gnutls_dh_params_generate2
+gnutls_dh_params_generate2.restype = c_int
+gnutls_dh_params_generate2.argtypes = [gnutls_dh_params_t, c_uint]
+gnutls_dh_params_export_pkcs3 = _libraries['libgnutls.so.26'].gnutls_dh_params_export_pkcs3
+gnutls_dh_params_export_pkcs3.restype = c_int
+gnutls_dh_params_export_pkcs3.argtypes = [gnutls_dh_params_t, gnutls_x509_crt_fmt_t, POINTER(c_ubyte), POINTER(size_t)]
+gnutls_dh_params_export_raw = _libraries['libgnutls.so.26'].gnutls_dh_params_export_raw
+gnutls_dh_params_export_raw.restype = c_int
+gnutls_dh_params_export_raw.argtypes = [gnutls_dh_params_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(c_uint)]
+gnutls_dh_params_cpy = _libraries['libgnutls.so.26'].gnutls_dh_params_cpy
+gnutls_dh_params_cpy.restype = c_int
+gnutls_dh_params_cpy.argtypes = [gnutls_dh_params_t, gnutls_dh_params_t]
+gnutls_rsa_params_init = _libraries['libgnutls.so.26'].gnutls_rsa_params_init
+gnutls_rsa_params_init.restype = c_int
+gnutls_rsa_params_init.argtypes = [POINTER(gnutls_rsa_params_t)]
+gnutls_rsa_params_deinit = _libraries['libgnutls.so.26'].gnutls_rsa_params_deinit
+gnutls_rsa_params_deinit.restype = None
+gnutls_rsa_params_deinit.argtypes = [gnutls_rsa_params_t]
+gnutls_rsa_params_cpy = _libraries['libgnutls.so.26'].gnutls_rsa_params_cpy
+gnutls_rsa_params_cpy.restype = c_int
+gnutls_rsa_params_cpy.argtypes = [gnutls_rsa_params_t, gnutls_rsa_params_t]
+gnutls_rsa_params_import_raw = _libraries['libgnutls.so.26'].gnutls_rsa_params_import_raw
+gnutls_rsa_params_import_raw.restype = c_int
+gnutls_rsa_params_import_raw.argtypes = [gnutls_rsa_params_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_rsa_params_generate2 = _libraries['libgnutls.so.26'].gnutls_rsa_params_generate2
+gnutls_rsa_params_generate2.restype = c_int
+gnutls_rsa_params_generate2.argtypes = [gnutls_rsa_params_t, c_uint]
+gnutls_rsa_params_export_raw = _libraries['libgnutls.so.26'].gnutls_rsa_params_export_raw
+gnutls_rsa_params_export_raw.restype = c_int
+gnutls_rsa_params_export_raw.argtypes = [gnutls_rsa_params_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(c_uint)]
+gnutls_rsa_params_export_pkcs1 = _libraries['libgnutls.so.26'].gnutls_rsa_params_export_pkcs1
+gnutls_rsa_params_export_pkcs1.restype = c_int
+gnutls_rsa_params_export_pkcs1.argtypes = [gnutls_rsa_params_t, gnutls_x509_crt_fmt_t, POINTER(c_ubyte), POINTER(size_t)]
+gnutls_rsa_params_import_pkcs1 = _libraries['libgnutls.so.26'].gnutls_rsa_params_import_pkcs1
+gnutls_rsa_params_import_pkcs1.restype = c_int
+gnutls_rsa_params_import_pkcs1.argtypes = [gnutls_rsa_params_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_transport_set_ptr = _libraries['libgnutls.so.26'].gnutls_transport_set_ptr
+gnutls_transport_set_ptr.restype = None
+gnutls_transport_set_ptr.argtypes = [gnutls_session_t, gnutls_transport_ptr_t]
+gnutls_transport_set_ptr2 = _libraries['libgnutls.so.26'].gnutls_transport_set_ptr2
+gnutls_transport_set_ptr2.restype = None
+gnutls_transport_set_ptr2.argtypes = [gnutls_session_t, gnutls_transport_ptr_t, gnutls_transport_ptr_t]
+gnutls_transport_get_ptr = _libraries['libgnutls.so.26'].gnutls_transport_get_ptr
+gnutls_transport_get_ptr.restype = gnutls_transport_ptr_t
+gnutls_transport_get_ptr.argtypes = [gnutls_session_t]
+gnutls_transport_get_ptr2 = _libraries['libgnutls.so.26'].gnutls_transport_get_ptr2
+gnutls_transport_get_ptr2.restype = None
+gnutls_transport_get_ptr2.argtypes = [gnutls_session_t, POINTER(gnutls_transport_ptr_t), POINTER(gnutls_transport_ptr_t)]
+gnutls_transport_set_lowat = _libraries['libgnutls.so.26'].gnutls_transport_set_lowat
+gnutls_transport_set_lowat.restype = None
+gnutls_transport_set_lowat.argtypes = [gnutls_session_t, c_int]
+gnutls_transport_set_push_function = _libraries['libgnutls.so.26'].gnutls_transport_set_push_function
+gnutls_transport_set_push_function.restype = None
+gnutls_transport_set_push_function.argtypes = [gnutls_session_t, gnutls_push_func]
+gnutls_transport_set_pull_function = _libraries['libgnutls.so.26'].gnutls_transport_set_pull_function
+gnutls_transport_set_pull_function.restype = None
+gnutls_transport_set_pull_function.argtypes = [gnutls_session_t, gnutls_pull_func]
+gnutls_transport_set_errno = _libraries['libgnutls.so.26'].gnutls_transport_set_errno
+gnutls_transport_set_errno.restype = None
+gnutls_transport_set_errno.argtypes = [gnutls_session_t, c_int]
+gnutls_transport_set_global_errno = _libraries['libgnutls.so.26'].gnutls_transport_set_global_errno
+gnutls_transport_set_global_errno.restype = None
+gnutls_transport_set_global_errno.argtypes = [c_int]
+gnutls_session_set_ptr = _libraries['libgnutls.so.26'].gnutls_session_set_ptr
+gnutls_session_set_ptr.restype = None
+gnutls_session_set_ptr.argtypes = [gnutls_session_t, c_void_p]
+gnutls_session_get_ptr = _libraries['libgnutls.so.26'].gnutls_session_get_ptr
+gnutls_session_get_ptr.restype = c_void_p
+gnutls_session_get_ptr.argtypes = [gnutls_session_t]
+gnutls_openpgp_send_cert = _libraries['libgnutls.so.26'].gnutls_openpgp_send_cert
+gnutls_openpgp_send_cert.restype = None
+gnutls_openpgp_send_cert.argtypes = [gnutls_session_t, gnutls_openpgp_crt_status_t]
+gnutls_fingerprint = _libraries['libgnutls.so.26'].gnutls_fingerprint
+gnutls_fingerprint.restype = c_int
+gnutls_fingerprint.argtypes = [gnutls_digest_algorithm_t, POINTER(gnutls_datum_t), c_void_p, POINTER(size_t)]
+gnutls_srp_free_client_credentials = _libraries['libgnutls.so.26'].gnutls_srp_free_client_credentials
+gnutls_srp_free_client_credentials.restype = None
+gnutls_srp_free_client_credentials.argtypes = [gnutls_srp_client_credentials_t]
+gnutls_srp_allocate_client_credentials = _libraries['libgnutls.so.26'].gnutls_srp_allocate_client_credentials
+gnutls_srp_allocate_client_credentials.restype = c_int
+gnutls_srp_allocate_client_credentials.argtypes = [POINTER(gnutls_srp_client_credentials_t)]
+gnutls_srp_set_client_credentials = _libraries['libgnutls.so.26'].gnutls_srp_set_client_credentials
+gnutls_srp_set_client_credentials.restype = c_int
+gnutls_srp_set_client_credentials.argtypes = [gnutls_srp_client_credentials_t, STRING, STRING]
+gnutls_srp_free_server_credentials = _libraries['libgnutls.so.26'].gnutls_srp_free_server_credentials
+gnutls_srp_free_server_credentials.restype = None
+gnutls_srp_free_server_credentials.argtypes = [gnutls_srp_server_credentials_t]
+gnutls_srp_allocate_server_credentials = _libraries['libgnutls.so.26'].gnutls_srp_allocate_server_credentials
+gnutls_srp_allocate_server_credentials.restype = c_int
+gnutls_srp_allocate_server_credentials.argtypes = [POINTER(gnutls_srp_server_credentials_t)]
+gnutls_srp_set_server_credentials_file = _libraries['libgnutls.so.26'].gnutls_srp_set_server_credentials_file
+gnutls_srp_set_server_credentials_file.restype = c_int
+gnutls_srp_set_server_credentials_file.argtypes = [gnutls_srp_server_credentials_t, STRING, STRING]
+gnutls_srp_server_get_username = _libraries['libgnutls.so.26'].gnutls_srp_server_get_username
+gnutls_srp_server_get_username.restype = STRING
+gnutls_srp_server_get_username.argtypes = [gnutls_session_t]
+gnutls_srp_verifier = _libraries['libgnutls.so.26'].gnutls_srp_verifier
+gnutls_srp_verifier.restype = c_int
+gnutls_srp_verifier.argtypes = [STRING, STRING, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_srp_set_server_credentials_function = _libraries['libgnutls.so.26'].gnutls_srp_set_server_credentials_function
+gnutls_srp_set_server_credentials_function.restype = None
+gnutls_srp_set_server_credentials_function.argtypes = [gnutls_srp_server_credentials_t, gnutls_srp_server_credentials_function]
+gnutls_srp_set_client_credentials_function = _libraries['libgnutls.so.26'].gnutls_srp_set_client_credentials_function
+gnutls_srp_set_client_credentials_function.restype = None
+gnutls_srp_set_client_credentials_function.argtypes = [gnutls_srp_client_credentials_t, gnutls_srp_client_credentials_function]
+gnutls_srp_base64_encode = _libraries['libgnutls.so.26'].gnutls_srp_base64_encode
+gnutls_srp_base64_encode.restype = c_int
+gnutls_srp_base64_encode.argtypes = [POINTER(gnutls_datum_t), STRING, POINTER(size_t)]
+gnutls_srp_base64_encode_alloc = _libraries['libgnutls.so.26'].gnutls_srp_base64_encode_alloc
+gnutls_srp_base64_encode_alloc.restype = c_int
+gnutls_srp_base64_encode_alloc.argtypes = [POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_srp_base64_decode = _libraries['libgnutls.so.26'].gnutls_srp_base64_decode
+gnutls_srp_base64_decode.restype = c_int
+gnutls_srp_base64_decode.argtypes = [POINTER(gnutls_datum_t), STRING, POINTER(size_t)]
+gnutls_srp_base64_decode_alloc = _libraries['libgnutls.so.26'].gnutls_srp_base64_decode_alloc
+gnutls_srp_base64_decode_alloc.restype = c_int
+gnutls_srp_base64_decode_alloc.argtypes = [POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_psk_free_client_credentials = _libraries['libgnutls.so.26'].gnutls_psk_free_client_credentials
+gnutls_psk_free_client_credentials.restype = None
+gnutls_psk_free_client_credentials.argtypes = [gnutls_psk_client_credentials_t]
+gnutls_psk_allocate_client_credentials = _libraries['libgnutls.so.26'].gnutls_psk_allocate_client_credentials
+gnutls_psk_allocate_client_credentials.restype = c_int
+gnutls_psk_allocate_client_credentials.argtypes = [POINTER(gnutls_psk_client_credentials_t)]
+gnutls_psk_set_client_credentials = _libraries['libgnutls.so.26'].gnutls_psk_set_client_credentials
+gnutls_psk_set_client_credentials.restype = c_int
+gnutls_psk_set_client_credentials.argtypes = [gnutls_psk_client_credentials_t, STRING, POINTER(gnutls_datum_t), gnutls_psk_key_flags]
+gnutls_psk_free_server_credentials = _libraries['libgnutls.so.26'].gnutls_psk_free_server_credentials
+gnutls_psk_free_server_credentials.restype = None
+gnutls_psk_free_server_credentials.argtypes = [gnutls_psk_server_credentials_t]
+gnutls_psk_allocate_server_credentials = _libraries['libgnutls.so.26'].gnutls_psk_allocate_server_credentials
+gnutls_psk_allocate_server_credentials.restype = c_int
+gnutls_psk_allocate_server_credentials.argtypes = [POINTER(gnutls_psk_server_credentials_t)]
+gnutls_psk_set_server_credentials_file = _libraries['libgnutls.so.26'].gnutls_psk_set_server_credentials_file
+gnutls_psk_set_server_credentials_file.restype = c_int
+gnutls_psk_set_server_credentials_file.argtypes = [gnutls_psk_server_credentials_t, STRING]
+gnutls_psk_set_server_credentials_hint = _libraries['libgnutls.so.26'].gnutls_psk_set_server_credentials_hint
+gnutls_psk_set_server_credentials_hint.restype = c_int
+gnutls_psk_set_server_credentials_hint.argtypes = [gnutls_psk_server_credentials_t, STRING]
+gnutls_psk_server_get_username = _libraries['libgnutls.so.26'].gnutls_psk_server_get_username
+gnutls_psk_server_get_username.restype = STRING
+gnutls_psk_server_get_username.argtypes = [gnutls_session_t]
+gnutls_psk_client_get_hint = _libraries['libgnutls.so.26'].gnutls_psk_client_get_hint
+gnutls_psk_client_get_hint.restype = STRING
+gnutls_psk_client_get_hint.argtypes = [gnutls_session_t]
+gnutls_psk_set_server_credentials_function = _libraries['libgnutls.so.26'].gnutls_psk_set_server_credentials_function
+gnutls_psk_set_server_credentials_function.restype = None
+gnutls_psk_set_server_credentials_function.argtypes = [gnutls_psk_server_credentials_t, gnutls_psk_server_credentials_function]
+gnutls_psk_set_client_credentials_function = _libraries['libgnutls.so.26'].gnutls_psk_set_client_credentials_function
+gnutls_psk_set_client_credentials_function.restype = None
+gnutls_psk_set_client_credentials_function.argtypes = [gnutls_psk_client_credentials_t, gnutls_psk_client_credentials_function]
+gnutls_hex_encode = _libraries['libgnutls.so.26'].gnutls_hex_encode
+gnutls_hex_encode.restype = c_int
+gnutls_hex_encode.argtypes = [POINTER(gnutls_datum_t), STRING, POINTER(size_t)]
+gnutls_hex_decode = _libraries['libgnutls.so.26'].gnutls_hex_decode
+gnutls_hex_decode.restype = c_int
+gnutls_hex_decode.argtypes = [POINTER(gnutls_datum_t), STRING, POINTER(size_t)]
+gnutls_psk_set_server_dh_params = _libraries['libgnutls.so.26'].gnutls_psk_set_server_dh_params
+gnutls_psk_set_server_dh_params.restype = None
+gnutls_psk_set_server_dh_params.argtypes = [gnutls_psk_server_credentials_t, gnutls_dh_params_t]
+gnutls_psk_set_server_params_function = _libraries['libgnutls.so.26'].gnutls_psk_set_server_params_function
+gnutls_psk_set_server_params_function.restype = None
+gnutls_psk_set_server_params_function.argtypes = [gnutls_psk_server_credentials_t, gnutls_params_function]
+gnutls_psk_netconf_derive_key = _libraries['libgnutls.so.26'].gnutls_psk_netconf_derive_key
+gnutls_psk_netconf_derive_key.restype = c_int
+gnutls_psk_netconf_derive_key.argtypes = [STRING, STRING, STRING, POINTER(gnutls_datum_t)]
+gnutls_auth_get_type = _libraries['libgnutls.so.26'].gnutls_auth_get_type
+gnutls_auth_get_type.restype = gnutls_credentials_type_t
+gnutls_auth_get_type.argtypes = [gnutls_session_t]
+gnutls_auth_server_get_type = _libraries['libgnutls.so.26'].gnutls_auth_server_get_type
+gnutls_auth_server_get_type.restype = gnutls_credentials_type_t
+gnutls_auth_server_get_type.argtypes = [gnutls_session_t]
+gnutls_auth_client_get_type = _libraries['libgnutls.so.26'].gnutls_auth_client_get_type
+gnutls_auth_client_get_type.restype = gnutls_credentials_type_t
+gnutls_auth_client_get_type.argtypes = [gnutls_session_t]
+gnutls_dh_set_prime_bits = _libraries['libgnutls.so.26'].gnutls_dh_set_prime_bits
+gnutls_dh_set_prime_bits.restype = None
+gnutls_dh_set_prime_bits.argtypes = [gnutls_session_t, c_uint]
+gnutls_dh_get_secret_bits = _libraries['libgnutls.so.26'].gnutls_dh_get_secret_bits
+gnutls_dh_get_secret_bits.restype = c_int
+gnutls_dh_get_secret_bits.argtypes = [gnutls_session_t]
+gnutls_dh_get_peers_public_bits = _libraries['libgnutls.so.26'].gnutls_dh_get_peers_public_bits
+gnutls_dh_get_peers_public_bits.restype = c_int
+gnutls_dh_get_peers_public_bits.argtypes = [gnutls_session_t]
+gnutls_dh_get_prime_bits = _libraries['libgnutls.so.26'].gnutls_dh_get_prime_bits
+gnutls_dh_get_prime_bits.restype = c_int
+gnutls_dh_get_prime_bits.argtypes = [gnutls_session_t]
+gnutls_dh_get_group = _libraries['libgnutls.so.26'].gnutls_dh_get_group
+gnutls_dh_get_group.restype = c_int
+gnutls_dh_get_group.argtypes = [gnutls_session_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_dh_get_pubkey = _libraries['libgnutls.so.26'].gnutls_dh_get_pubkey
+gnutls_dh_get_pubkey.restype = c_int
+gnutls_dh_get_pubkey.argtypes = [gnutls_session_t, POINTER(gnutls_datum_t)]
+gnutls_rsa_export_get_pubkey = _libraries['libgnutls.so.26'].gnutls_rsa_export_get_pubkey
+gnutls_rsa_export_get_pubkey.restype = c_int
+gnutls_rsa_export_get_pubkey.argtypes = [gnutls_session_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_rsa_export_get_modulus_bits = _libraries['libgnutls.so.26'].gnutls_rsa_export_get_modulus_bits
+gnutls_rsa_export_get_modulus_bits.restype = c_int
+gnutls_rsa_export_get_modulus_bits.argtypes = [gnutls_session_t]
+gnutls_sign_callback_set = _libraries['libgnutls.so.26'].gnutls_sign_callback_set
+gnutls_sign_callback_set.restype = None
+gnutls_sign_callback_set.argtypes = [gnutls_session_t, gnutls_sign_func, c_void_p]
+gnutls_sign_callback_get = _libraries['libgnutls.so.26'].gnutls_sign_callback_get
+gnutls_sign_callback_get.restype = gnutls_sign_func
+gnutls_sign_callback_get.argtypes = [gnutls_session_t, POINTER(c_void_p)]
+gnutls_certificate_client_set_retrieve_function = _libraries['libgnutls.so.26'].gnutls_certificate_client_set_retrieve_function
+gnutls_certificate_client_set_retrieve_function.restype = None
+gnutls_certificate_client_set_retrieve_function.argtypes = [gnutls_certificate_credentials_t, gnutls_certificate_client_retrieve_function]
+gnutls_certificate_server_set_retrieve_function = _libraries['libgnutls.so.26'].gnutls_certificate_server_set_retrieve_function
+gnutls_certificate_server_set_retrieve_function.restype = None
+gnutls_certificate_server_set_retrieve_function.argtypes = [gnutls_certificate_credentials_t, gnutls_certificate_server_retrieve_function]
+gnutls_certificate_server_set_request = _libraries['libgnutls.so.26'].gnutls_certificate_server_set_request
+gnutls_certificate_server_set_request.restype = None
+gnutls_certificate_server_set_request.argtypes = [gnutls_session_t, gnutls_certificate_request_t]
+gnutls_certificate_get_peers = _libraries['libgnutls.so.26'].gnutls_certificate_get_peers
+gnutls_certificate_get_peers.restype = POINTER(gnutls_datum_t)
+gnutls_certificate_get_peers.argtypes = [gnutls_session_t, POINTER(c_uint)]
+gnutls_certificate_get_ours = _libraries['libgnutls.so.26'].gnutls_certificate_get_ours
+gnutls_certificate_get_ours.restype = POINTER(gnutls_datum_t)
+gnutls_certificate_get_ours.argtypes = [gnutls_session_t]
+__time_t = c_long
+time_t = __time_t
+gnutls_certificate_activation_time_peers = _libraries['libgnutls.so.26'].gnutls_certificate_activation_time_peers
+gnutls_certificate_activation_time_peers.restype = time_t
+gnutls_certificate_activation_time_peers.argtypes = [gnutls_session_t]
+gnutls_certificate_expiration_time_peers = _libraries['libgnutls.so.26'].gnutls_certificate_expiration_time_peers
+gnutls_certificate_expiration_time_peers.restype = time_t
+gnutls_certificate_expiration_time_peers.argtypes = [gnutls_session_t]
+gnutls_certificate_client_get_request_status = _libraries['libgnutls.so.26'].gnutls_certificate_client_get_request_status
+gnutls_certificate_client_get_request_status.restype = c_int
+gnutls_certificate_client_get_request_status.argtypes = [gnutls_session_t]
+gnutls_certificate_verify_peers2 = _libraries['libgnutls.so.26'].gnutls_certificate_verify_peers2
+gnutls_certificate_verify_peers2.restype = c_int
+gnutls_certificate_verify_peers2.argtypes = [gnutls_session_t, POINTER(c_uint)]
+gnutls_certificate_verify_peers = _libraries['libgnutls.so.26'].gnutls_certificate_verify_peers
+gnutls_certificate_verify_peers.restype = c_int
+gnutls_certificate_verify_peers.argtypes = [gnutls_session_t]
+gnutls_pem_base64_encode = _libraries['libgnutls.so.26'].gnutls_pem_base64_encode
+gnutls_pem_base64_encode.restype = c_int
+gnutls_pem_base64_encode.argtypes = [STRING, POINTER(gnutls_datum_t), STRING, POINTER(size_t)]
+gnutls_pem_base64_decode = _libraries['libgnutls.so.26'].gnutls_pem_base64_decode
+gnutls_pem_base64_decode.restype = c_int
+gnutls_pem_base64_decode.argtypes = [STRING, POINTER(gnutls_datum_t), POINTER(c_ubyte), POINTER(size_t)]
+gnutls_pem_base64_encode_alloc = _libraries['libgnutls.so.26'].gnutls_pem_base64_encode_alloc
+gnutls_pem_base64_encode_alloc.restype = c_int
+gnutls_pem_base64_encode_alloc.argtypes = [STRING, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_pem_base64_decode_alloc = _libraries['libgnutls.so.26'].gnutls_pem_base64_decode_alloc
+gnutls_pem_base64_decode_alloc.restype = c_int
+gnutls_pem_base64_decode_alloc.argtypes = [STRING, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_certificate_set_params_function = _libraries['libgnutls.so.26'].gnutls_certificate_set_params_function
+gnutls_certificate_set_params_function.restype = None
+gnutls_certificate_set_params_function.argtypes = [gnutls_certificate_credentials_t, gnutls_params_function]
+gnutls_anon_set_params_function = _libraries['libgnutls.so.26'].gnutls_anon_set_params_function
+gnutls_anon_set_params_function.restype = None
+gnutls_anon_set_params_function.argtypes = [gnutls_anon_server_credentials_t, gnutls_params_function]
+gnutls_psk_set_params_function = _libraries['libgnutls.so.26'].gnutls_psk_set_params_function
+gnutls_psk_set_params_function.restype = None
+gnutls_psk_set_params_function.argtypes = [gnutls_psk_server_credentials_t, gnutls_params_function]
+gnutls_hex2bin = _libraries['libgnutls.so.26'].gnutls_hex2bin
+gnutls_hex2bin.restype = c_int
+gnutls_hex2bin.argtypes = [STRING, size_t, STRING, POINTER(size_t)]
+gnutls_openpgp_crt_init = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_init
+gnutls_openpgp_crt_init.restype = c_int
+gnutls_openpgp_crt_init.argtypes = [POINTER(gnutls_openpgp_crt_t)]
+gnutls_openpgp_crt_deinit = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_deinit
+gnutls_openpgp_crt_deinit.restype = None
+gnutls_openpgp_crt_deinit.argtypes = [gnutls_openpgp_crt_t]
+gnutls_openpgp_crt_import = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_import
+gnutls_openpgp_crt_import.restype = c_int
+gnutls_openpgp_crt_import.argtypes = [gnutls_openpgp_crt_t, POINTER(gnutls_datum_t), gnutls_openpgp_crt_fmt_t]
+gnutls_openpgp_crt_export = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_export
+gnutls_openpgp_crt_export.restype = c_int
+gnutls_openpgp_crt_export.argtypes = [gnutls_openpgp_crt_t, gnutls_openpgp_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_openpgp_crt_print = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_print
+gnutls_openpgp_crt_print.restype = c_int
+gnutls_openpgp_crt_print.argtypes = [gnutls_openpgp_crt_t, gnutls_certificate_print_formats_t, POINTER(gnutls_datum_t)]
+gnutls_openpgp_crt_get_key_usage = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_key_usage
+gnutls_openpgp_crt_get_key_usage.restype = c_int
+gnutls_openpgp_crt_get_key_usage.argtypes = [gnutls_openpgp_crt_t, POINTER(c_uint)]
+gnutls_openpgp_crt_get_fingerprint = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_fingerprint
+gnutls_openpgp_crt_get_fingerprint.restype = c_int
+gnutls_openpgp_crt_get_fingerprint.argtypes = [gnutls_openpgp_crt_t, c_void_p, POINTER(size_t)]
+gnutls_openpgp_crt_get_subkey_fingerprint = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_fingerprint
+gnutls_openpgp_crt_get_subkey_fingerprint.restype = c_int
+gnutls_openpgp_crt_get_subkey_fingerprint.argtypes = [gnutls_openpgp_crt_t, c_uint, c_void_p, POINTER(size_t)]
+gnutls_openpgp_crt_get_name = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_name
+gnutls_openpgp_crt_get_name.restype = c_int
+gnutls_openpgp_crt_get_name.argtypes = [gnutls_openpgp_crt_t, c_int, STRING, POINTER(size_t)]
+gnutls_openpgp_crt_get_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_pk_algorithm
+gnutls_openpgp_crt_get_pk_algorithm.restype = gnutls_pk_algorithm_t
+gnutls_openpgp_crt_get_pk_algorithm.argtypes = [gnutls_openpgp_crt_t, POINTER(c_uint)]
+gnutls_openpgp_crt_get_version = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_version
+gnutls_openpgp_crt_get_version.restype = c_int
+gnutls_openpgp_crt_get_version.argtypes = [gnutls_openpgp_crt_t]
+gnutls_openpgp_crt_get_creation_time = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_creation_time
+gnutls_openpgp_crt_get_creation_time.restype = time_t
+gnutls_openpgp_crt_get_creation_time.argtypes = [gnutls_openpgp_crt_t]
+gnutls_openpgp_crt_get_expiration_time = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_expiration_time
+gnutls_openpgp_crt_get_expiration_time.restype = time_t
+gnutls_openpgp_crt_get_expiration_time.argtypes = [gnutls_openpgp_crt_t]
+gnutls_openpgp_crt_get_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_key_id
+gnutls_openpgp_crt_get_key_id.restype = c_int
+gnutls_openpgp_crt_get_key_id.argtypes = [gnutls_openpgp_crt_t, POINTER(c_ubyte)]
+gnutls_openpgp_crt_check_hostname = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_check_hostname
+gnutls_openpgp_crt_check_hostname.restype = c_int
+gnutls_openpgp_crt_check_hostname.argtypes = [gnutls_openpgp_crt_t, STRING]
+gnutls_openpgp_crt_get_revoked_status = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_revoked_status
+gnutls_openpgp_crt_get_revoked_status.restype = c_int
+gnutls_openpgp_crt_get_revoked_status.argtypes = [gnutls_openpgp_crt_t]
+gnutls_openpgp_crt_get_subkey_count = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_count
+gnutls_openpgp_crt_get_subkey_count.restype = c_int
+gnutls_openpgp_crt_get_subkey_count.argtypes = [gnutls_openpgp_crt_t]
+gnutls_openpgp_crt_get_subkey_idx = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_idx
+gnutls_openpgp_crt_get_subkey_idx.restype = c_int
+gnutls_openpgp_crt_get_subkey_idx.argtypes = [gnutls_openpgp_crt_t, POINTER(c_ubyte)]
+gnutls_openpgp_crt_get_subkey_revoked_status = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_revoked_status
+gnutls_openpgp_crt_get_subkey_revoked_status.restype = c_int
+gnutls_openpgp_crt_get_subkey_revoked_status.argtypes = [gnutls_openpgp_crt_t, c_uint]
+gnutls_openpgp_crt_get_subkey_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_pk_algorithm
+gnutls_openpgp_crt_get_subkey_pk_algorithm.restype = gnutls_pk_algorithm_t
+gnutls_openpgp_crt_get_subkey_pk_algorithm.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(c_uint)]
+gnutls_openpgp_crt_get_subkey_creation_time = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_creation_time
+gnutls_openpgp_crt_get_subkey_creation_time.restype = time_t
+gnutls_openpgp_crt_get_subkey_creation_time.argtypes = [gnutls_openpgp_crt_t, c_uint]
+gnutls_openpgp_crt_get_subkey_expiration_time = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_expiration_time
+gnutls_openpgp_crt_get_subkey_expiration_time.restype = time_t
+gnutls_openpgp_crt_get_subkey_expiration_time.argtypes = [gnutls_openpgp_crt_t, c_uint]
+gnutls_openpgp_crt_get_subkey_id = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_id
+gnutls_openpgp_crt_get_subkey_id.restype = c_int
+gnutls_openpgp_crt_get_subkey_id.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(c_ubyte)]
+gnutls_openpgp_crt_get_subkey_usage = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_usage
+gnutls_openpgp_crt_get_subkey_usage.restype = c_int
+gnutls_openpgp_crt_get_subkey_usage.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(c_uint)]
+gnutls_openpgp_crt_get_subkey_pk_dsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_pk_dsa_raw
+gnutls_openpgp_crt_get_subkey_pk_dsa_raw.restype = c_int
+gnutls_openpgp_crt_get_subkey_pk_dsa_raw.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_crt_get_subkey_pk_rsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_pk_rsa_raw
+gnutls_openpgp_crt_get_subkey_pk_rsa_raw.restype = c_int
+gnutls_openpgp_crt_get_subkey_pk_rsa_raw.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_crt_get_pk_dsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_pk_dsa_raw
+gnutls_openpgp_crt_get_pk_dsa_raw.restype = c_int
+gnutls_openpgp_crt_get_pk_dsa_raw.argtypes = [gnutls_openpgp_crt_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_crt_get_pk_rsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_pk_rsa_raw
+gnutls_openpgp_crt_get_pk_rsa_raw.restype = c_int
+gnutls_openpgp_crt_get_pk_rsa_raw.argtypes = [gnutls_openpgp_crt_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_crt_get_preferred_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_preferred_key_id
+gnutls_openpgp_crt_get_preferred_key_id.restype = c_int
+gnutls_openpgp_crt_get_preferred_key_id.argtypes = [gnutls_openpgp_crt_t, POINTER(c_ubyte)]
+gnutls_openpgp_crt_set_preferred_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_set_preferred_key_id
+gnutls_openpgp_crt_set_preferred_key_id.restype = c_int
+gnutls_openpgp_crt_set_preferred_key_id.argtypes = [gnutls_openpgp_crt_t, POINTER(c_ubyte)]
+gnutls_openpgp_privkey_init = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_init
+gnutls_openpgp_privkey_init.restype = c_int
+gnutls_openpgp_privkey_init.argtypes = [POINTER(gnutls_openpgp_privkey_t)]
+gnutls_openpgp_privkey_deinit = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_deinit
+gnutls_openpgp_privkey_deinit.restype = None
+gnutls_openpgp_privkey_deinit.argtypes = [gnutls_openpgp_privkey_t]
+gnutls_openpgp_privkey_get_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_pk_algorithm
+gnutls_openpgp_privkey_get_pk_algorithm.restype = gnutls_pk_algorithm_t
+gnutls_openpgp_privkey_get_pk_algorithm.argtypes = [gnutls_openpgp_privkey_t, POINTER(c_uint)]
+gnutls_openpgp_privkey_import = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_import
+gnutls_openpgp_privkey_import.restype = c_int
+gnutls_openpgp_privkey_import.argtypes = [gnutls_openpgp_privkey_t, POINTER(gnutls_datum_t), gnutls_openpgp_crt_fmt_t, STRING, c_uint]
+gnutls_openpgp_privkey_sign_hash = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_sign_hash
+gnutls_openpgp_privkey_sign_hash.restype = c_int
+gnutls_openpgp_privkey_sign_hash.argtypes = [gnutls_openpgp_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_privkey_get_fingerprint = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_fingerprint
+gnutls_openpgp_privkey_get_fingerprint.restype = c_int
+gnutls_openpgp_privkey_get_fingerprint.argtypes = [gnutls_openpgp_privkey_t, c_void_p, POINTER(size_t)]
+gnutls_openpgp_privkey_get_subkey_fingerprint = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_fingerprint
+gnutls_openpgp_privkey_get_subkey_fingerprint.restype = c_int
+gnutls_openpgp_privkey_get_subkey_fingerprint.argtypes = [gnutls_openpgp_privkey_t, c_uint, c_void_p, POINTER(size_t)]
+gnutls_openpgp_privkey_get_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_key_id
+gnutls_openpgp_privkey_get_key_id.restype = c_int
+gnutls_openpgp_privkey_get_key_id.argtypes = [gnutls_openpgp_privkey_t, POINTER(c_ubyte)]
+gnutls_openpgp_privkey_get_subkey_count = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_count
+gnutls_openpgp_privkey_get_subkey_count.restype = c_int
+gnutls_openpgp_privkey_get_subkey_count.argtypes = [gnutls_openpgp_privkey_t]
+gnutls_openpgp_privkey_get_subkey_idx = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_idx
+gnutls_openpgp_privkey_get_subkey_idx.restype = c_int
+gnutls_openpgp_privkey_get_subkey_idx.argtypes = [gnutls_openpgp_privkey_t, POINTER(c_ubyte)]
+gnutls_openpgp_privkey_get_subkey_revoked_status = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_revoked_status
+gnutls_openpgp_privkey_get_subkey_revoked_status.restype = c_int
+gnutls_openpgp_privkey_get_subkey_revoked_status.argtypes = [gnutls_openpgp_privkey_t, c_uint]
+gnutls_openpgp_privkey_get_revoked_status = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_revoked_status
+gnutls_openpgp_privkey_get_revoked_status.restype = c_int
+gnutls_openpgp_privkey_get_revoked_status.argtypes = [gnutls_openpgp_privkey_t]
+gnutls_openpgp_privkey_get_subkey_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_pk_algorithm
+gnutls_openpgp_privkey_get_subkey_pk_algorithm.restype = gnutls_pk_algorithm_t
+gnutls_openpgp_privkey_get_subkey_pk_algorithm.argtypes = [gnutls_openpgp_privkey_t, c_uint, POINTER(c_uint)]
+gnutls_openpgp_privkey_get_subkey_expiration_time = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_expiration_time
+gnutls_openpgp_privkey_get_subkey_expiration_time.restype = time_t
+gnutls_openpgp_privkey_get_subkey_expiration_time.argtypes = [gnutls_openpgp_privkey_t, c_uint]
+gnutls_openpgp_privkey_get_subkey_id = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_id
+gnutls_openpgp_privkey_get_subkey_id.restype = c_int
+gnutls_openpgp_privkey_get_subkey_id.argtypes = [gnutls_openpgp_privkey_t, c_uint, POINTER(c_ubyte)]
+gnutls_openpgp_privkey_get_subkey_creation_time = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_creation_time
+gnutls_openpgp_privkey_get_subkey_creation_time.restype = time_t
+gnutls_openpgp_privkey_get_subkey_creation_time.argtypes = [gnutls_openpgp_privkey_t, c_uint]
+gnutls_openpgp_privkey_export_subkey_dsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_export_subkey_dsa_raw
+gnutls_openpgp_privkey_export_subkey_dsa_raw.restype = c_int
+gnutls_openpgp_privkey_export_subkey_dsa_raw.argtypes = [gnutls_openpgp_privkey_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_privkey_export_subkey_rsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_export_subkey_rsa_raw
+gnutls_openpgp_privkey_export_subkey_rsa_raw.restype = c_int
+gnutls_openpgp_privkey_export_subkey_rsa_raw.argtypes = [gnutls_openpgp_privkey_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_privkey_export_dsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_export_dsa_raw
+gnutls_openpgp_privkey_export_dsa_raw.restype = c_int
+gnutls_openpgp_privkey_export_dsa_raw.argtypes = [gnutls_openpgp_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_privkey_export_rsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_export_rsa_raw
+gnutls_openpgp_privkey_export_rsa_raw.restype = c_int
+gnutls_openpgp_privkey_export_rsa_raw.argtypes = [gnutls_openpgp_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_privkey_export = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_export
+gnutls_openpgp_privkey_export.restype = c_int
+gnutls_openpgp_privkey_export.argtypes = [gnutls_openpgp_privkey_t, gnutls_openpgp_crt_fmt_t, STRING, c_uint, c_void_p, POINTER(size_t)]
+gnutls_openpgp_privkey_set_preferred_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_set_preferred_key_id
+gnutls_openpgp_privkey_set_preferred_key_id.restype = c_int
+gnutls_openpgp_privkey_set_preferred_key_id.argtypes = [gnutls_openpgp_privkey_t, POINTER(c_ubyte)]
+gnutls_openpgp_privkey_get_preferred_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_preferred_key_id
+gnutls_openpgp_privkey_get_preferred_key_id.restype = c_int
+gnutls_openpgp_privkey_get_preferred_key_id.argtypes = [gnutls_openpgp_privkey_t, POINTER(c_ubyte)]
+gnutls_openpgp_crt_get_auth_subkey = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_auth_subkey
+gnutls_openpgp_crt_get_auth_subkey.restype = c_int
+gnutls_openpgp_crt_get_auth_subkey.argtypes = [gnutls_openpgp_crt_t, POINTER(c_ubyte), c_uint]
+gnutls_openpgp_keyring_init = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_init
+gnutls_openpgp_keyring_init.restype = c_int
+gnutls_openpgp_keyring_init.argtypes = [POINTER(gnutls_openpgp_keyring_t)]
+gnutls_openpgp_keyring_deinit = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_deinit
+gnutls_openpgp_keyring_deinit.restype = None
+gnutls_openpgp_keyring_deinit.argtypes = [gnutls_openpgp_keyring_t]
+gnutls_openpgp_keyring_import = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_import
+gnutls_openpgp_keyring_import.restype = c_int
+gnutls_openpgp_keyring_import.argtypes = [gnutls_openpgp_keyring_t, POINTER(gnutls_datum_t), gnutls_openpgp_crt_fmt_t]
+gnutls_openpgp_keyring_check_id = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_check_id
+gnutls_openpgp_keyring_check_id.restype = c_int
+gnutls_openpgp_keyring_check_id.argtypes = [gnutls_openpgp_keyring_t, POINTER(c_ubyte), c_uint]
+gnutls_openpgp_crt_verify_ring = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_verify_ring
+gnutls_openpgp_crt_verify_ring.restype = c_int
+gnutls_openpgp_crt_verify_ring.argtypes = [gnutls_openpgp_crt_t, gnutls_openpgp_keyring_t, c_uint, POINTER(c_uint)]
+gnutls_openpgp_crt_verify_self = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_verify_self
+gnutls_openpgp_crt_verify_self.restype = c_int
+gnutls_openpgp_crt_verify_self.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(c_uint)]
+gnutls_openpgp_keyring_get_crt = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_get_crt
+gnutls_openpgp_keyring_get_crt.restype = c_int
+gnutls_openpgp_keyring_get_crt.argtypes = [gnutls_openpgp_keyring_t, c_uint, POINTER(gnutls_openpgp_crt_t)]
+gnutls_openpgp_keyring_get_crt_count = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_get_crt_count
+gnutls_openpgp_keyring_get_crt_count.restype = c_int
+gnutls_openpgp_keyring_get_crt_count.argtypes = [gnutls_openpgp_keyring_t]
+gnutls_openpgp_set_recv_key_function = _libraries['libgnutls.so.26'].gnutls_openpgp_set_recv_key_function
+gnutls_openpgp_set_recv_key_function.restype = None
+gnutls_openpgp_set_recv_key_function.argtypes = [gnutls_session_t, gnutls_openpgp_recv_key_func]
+gnutls_certificate_set_openpgp_key = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_key
+gnutls_certificate_set_openpgp_key.restype = c_int
+gnutls_certificate_set_openpgp_key.argtypes = [gnutls_certificate_credentials_t, gnutls_openpgp_crt_t, gnutls_openpgp_privkey_t]
+gnutls_certificate_set_openpgp_key_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_key_file
+gnutls_certificate_set_openpgp_key_file.restype = c_int
+gnutls_certificate_set_openpgp_key_file.argtypes = [gnutls_certificate_credentials_t, STRING, STRING, gnutls_openpgp_crt_fmt_t]
+gnutls_certificate_set_openpgp_key_mem = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_key_mem
+gnutls_certificate_set_openpgp_key_mem.restype = c_int
+gnutls_certificate_set_openpgp_key_mem.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), gnutls_openpgp_crt_fmt_t]
+gnutls_certificate_set_openpgp_key_file2 = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_key_file2
+gnutls_certificate_set_openpgp_key_file2.restype = c_int
+gnutls_certificate_set_openpgp_key_file2.argtypes = [gnutls_certificate_credentials_t, STRING, STRING, STRING, gnutls_openpgp_crt_fmt_t]
+gnutls_certificate_set_openpgp_key_mem2 = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_key_mem2
+gnutls_certificate_set_openpgp_key_mem2.restype = c_int
+gnutls_certificate_set_openpgp_key_mem2.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), STRING, gnutls_openpgp_crt_fmt_t]
+gnutls_certificate_set_openpgp_keyring_mem = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_keyring_mem
+gnutls_certificate_set_openpgp_keyring_mem.restype = c_int
+gnutls_certificate_set_openpgp_keyring_mem.argtypes = [gnutls_certificate_credentials_t, POINTER(c_ubyte), size_t, gnutls_openpgp_crt_fmt_t]
+gnutls_certificate_set_openpgp_keyring_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_keyring_file
+gnutls_certificate_set_openpgp_keyring_file.restype = c_int
+gnutls_certificate_set_openpgp_keyring_file.argtypes = [gnutls_certificate_credentials_t, STRING, gnutls_openpgp_crt_fmt_t]
+gnutls_x509_crt_init = _libraries['libgnutls.so.26'].gnutls_x509_crt_init
+gnutls_x509_crt_init.restype = c_int
+gnutls_x509_crt_init.argtypes = [POINTER(gnutls_x509_crt_t)]
+gnutls_x509_crt_deinit = _libraries['libgnutls.so.26'].gnutls_x509_crt_deinit
+gnutls_x509_crt_deinit.restype = None
+gnutls_x509_crt_deinit.argtypes = [gnutls_x509_crt_t]
+gnutls_x509_crt_import = _libraries['libgnutls.so.26'].gnutls_x509_crt_import
+gnutls_x509_crt_import.restype = c_int
+gnutls_x509_crt_import.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_x509_crt_list_import = _libraries['libgnutls.so.26'].gnutls_x509_crt_list_import
+gnutls_x509_crt_list_import.restype = c_int
+gnutls_x509_crt_list_import.argtypes = [POINTER(gnutls_x509_crt_t), POINTER(c_uint), POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t, c_uint]
+gnutls_x509_crt_export = _libraries['libgnutls.so.26'].gnutls_x509_crt_export
+gnutls_x509_crt_export.restype = c_int
+gnutls_x509_crt_export.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_issuer_dn = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_issuer_dn
+gnutls_x509_crt_get_issuer_dn.restype = c_int
+gnutls_x509_crt_get_issuer_dn.argtypes = [gnutls_x509_crt_t, STRING, POINTER(size_t)]
+gnutls_x509_crt_get_issuer_dn_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_issuer_dn_oid
+gnutls_x509_crt_get_issuer_dn_oid.restype = c_int
+gnutls_x509_crt_get_issuer_dn_oid.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_issuer_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_issuer_dn_by_oid
+gnutls_x509_crt_get_issuer_dn_by_oid.restype = c_int
+gnutls_x509_crt_get_issuer_dn_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_int, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_dn = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_dn
+gnutls_x509_crt_get_dn.restype = c_int
+gnutls_x509_crt_get_dn.argtypes = [gnutls_x509_crt_t, STRING, POINTER(size_t)]
+gnutls_x509_crt_get_dn_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_dn_oid
+gnutls_x509_crt_get_dn_oid.restype = c_int
+gnutls_x509_crt_get_dn_oid.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_dn_by_oid
+gnutls_x509_crt_get_dn_by_oid.restype = c_int
+gnutls_x509_crt_get_dn_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_int, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_check_hostname = _libraries['libgnutls.so.26'].gnutls_x509_crt_check_hostname
+gnutls_x509_crt_check_hostname.restype = c_int
+gnutls_x509_crt_check_hostname.argtypes = [gnutls_x509_crt_t, STRING]
+gnutls_x509_crt_get_signature_algorithm = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_signature_algorithm
+gnutls_x509_crt_get_signature_algorithm.restype = c_int
+gnutls_x509_crt_get_signature_algorithm.argtypes = [gnutls_x509_crt_t]
+gnutls_x509_crt_get_signature = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_signature
+gnutls_x509_crt_get_signature.restype = c_int
+gnutls_x509_crt_get_signature.argtypes = [gnutls_x509_crt_t, STRING, POINTER(size_t)]
+gnutls_x509_crt_get_version = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_version
+gnutls_x509_crt_get_version.restype = c_int
+gnutls_x509_crt_get_version.argtypes = [gnutls_x509_crt_t]
+gnutls_x509_crt_get_key_id = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_key_id
+gnutls_x509_crt_get_key_id.restype = c_int
+gnutls_x509_crt_get_key_id.argtypes = [gnutls_x509_crt_t, c_uint, POINTER(c_ubyte), POINTER(size_t)]
+gnutls_x509_crt_set_authority_key_id = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_authority_key_id
+gnutls_x509_crt_set_authority_key_id.restype = c_int
+gnutls_x509_crt_set_authority_key_id.argtypes = [gnutls_x509_crt_t, c_void_p, size_t]
+gnutls_x509_crt_get_authority_key_id = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_authority_key_id
+gnutls_x509_crt_get_authority_key_id.restype = c_int
+gnutls_x509_crt_get_authority_key_id.argtypes = [gnutls_x509_crt_t, c_void_p, POINTER(size_t), POINTER(c_uint)]
+gnutls_x509_crt_get_subject_key_id = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_subject_key_id
+gnutls_x509_crt_get_subject_key_id.restype = c_int
+gnutls_x509_crt_get_subject_key_id.argtypes = [gnutls_x509_crt_t, c_void_p, POINTER(size_t), POINTER(c_uint)]
+gnutls_x509_crt_get_crl_dist_points = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_crl_dist_points
+gnutls_x509_crt_get_crl_dist_points.restype = c_int
+gnutls_x509_crt_get_crl_dist_points.argtypes = [gnutls_x509_crt_t, c_uint, c_void_p, POINTER(size_t), POINTER(c_uint), POINTER(c_uint)]
+gnutls_x509_crt_set_crl_dist_points = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_crl_dist_points
+gnutls_x509_crt_set_crl_dist_points.restype = c_int
+gnutls_x509_crt_set_crl_dist_points.argtypes = [gnutls_x509_crt_t, gnutls_x509_subject_alt_name_t, c_void_p, c_uint]
+gnutls_x509_crt_cpy_crl_dist_points = _libraries['libgnutls.so.26'].gnutls_x509_crt_cpy_crl_dist_points
+gnutls_x509_crt_cpy_crl_dist_points.restype = c_int
+gnutls_x509_crt_cpy_crl_dist_points.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_t]
+gnutls_x509_crt_get_activation_time = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_activation_time
+gnutls_x509_crt_get_activation_time.restype = time_t
+gnutls_x509_crt_get_activation_time.argtypes = [gnutls_x509_crt_t]
+gnutls_x509_crt_get_expiration_time = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_expiration_time
+gnutls_x509_crt_get_expiration_time.restype = time_t
+gnutls_x509_crt_get_expiration_time.argtypes = [gnutls_x509_crt_t]
+gnutls_x509_crt_get_serial = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_serial
+gnutls_x509_crt_get_serial.restype = c_int
+gnutls_x509_crt_get_serial.argtypes = [gnutls_x509_crt_t, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_pk_algorithm
+gnutls_x509_crt_get_pk_algorithm.restype = c_int
+gnutls_x509_crt_get_pk_algorithm.argtypes = [gnutls_x509_crt_t, POINTER(c_uint)]
+gnutls_x509_crt_get_pk_rsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_pk_rsa_raw
+gnutls_x509_crt_get_pk_rsa_raw.restype = c_int
+gnutls_x509_crt_get_pk_rsa_raw.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_crt_get_pk_dsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_pk_dsa_raw
+gnutls_x509_crt_get_pk_dsa_raw.restype = c_int
+gnutls_x509_crt_get_pk_dsa_raw.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_crt_get_subject_alt_name = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_subject_alt_name
+gnutls_x509_crt_get_subject_alt_name.restype = c_int
+gnutls_x509_crt_get_subject_alt_name.argtypes = [gnutls_x509_crt_t, c_uint, c_void_p, POINTER(size_t), POINTER(c_uint)]
+gnutls_x509_crt_get_subject_alt_name2 = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_subject_alt_name2
+gnutls_x509_crt_get_subject_alt_name2.restype = c_int
+gnutls_x509_crt_get_subject_alt_name2.argtypes = [gnutls_x509_crt_t, c_uint, c_void_p, POINTER(size_t), POINTER(c_uint), POINTER(c_uint)]
+gnutls_x509_crt_get_subject_alt_othername_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_subject_alt_othername_oid
+gnutls_x509_crt_get_subject_alt_othername_oid.restype = c_int
+gnutls_x509_crt_get_subject_alt_othername_oid.argtypes = [gnutls_x509_crt_t, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_ca_status = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_ca_status
+gnutls_x509_crt_get_ca_status.restype = c_int
+gnutls_x509_crt_get_ca_status.argtypes = [gnutls_x509_crt_t, POINTER(c_uint)]
+gnutls_x509_crt_get_basic_constraints = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_basic_constraints
+gnutls_x509_crt_get_basic_constraints.restype = c_int
+gnutls_x509_crt_get_basic_constraints.argtypes = [gnutls_x509_crt_t, POINTER(c_uint), POINTER(c_int), POINTER(c_int)]
+gnutls_x509_crt_get_key_usage = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_key_usage
+gnutls_x509_crt_get_key_usage.restype = c_int
+gnutls_x509_crt_get_key_usage.argtypes = [gnutls_x509_crt_t, POINTER(c_uint), POINTER(c_uint)]
+gnutls_x509_crt_set_key_usage = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_key_usage
+gnutls_x509_crt_set_key_usage.restype = c_int
+gnutls_x509_crt_set_key_usage.argtypes = [gnutls_x509_crt_t, c_uint]
+gnutls_x509_crt_get_proxy = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_proxy
+gnutls_x509_crt_get_proxy.restype = c_int
+gnutls_x509_crt_get_proxy.argtypes = [gnutls_x509_crt_t, POINTER(c_uint), POINTER(c_int), POINTER(STRING), POINTER(STRING), POINTER(size_t)]
+gnutls_x509_dn_oid_known = _libraries['libgnutls.so.26'].gnutls_x509_dn_oid_known
+gnutls_x509_dn_oid_known.restype = c_int
+gnutls_x509_dn_oid_known.argtypes = [STRING]
+gnutls_x509_crt_get_extension_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_extension_oid
+gnutls_x509_crt_get_extension_oid.restype = c_int
+gnutls_x509_crt_get_extension_oid.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_extension_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_extension_by_oid
+gnutls_x509_crt_get_extension_by_oid.restype = c_int
+gnutls_x509_crt_get_extension_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_int, c_void_p, POINTER(size_t), POINTER(c_uint)]
+gnutls_x509_crt_get_extension_info = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_extension_info
+gnutls_x509_crt_get_extension_info.restype = c_int
+gnutls_x509_crt_get_extension_info.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t), POINTER(c_int)]
+gnutls_x509_crt_get_extension_data = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_extension_data
+gnutls_x509_crt_get_extension_data.restype = c_int
+gnutls_x509_crt_get_extension_data.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_set_extension_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_extension_by_oid
+gnutls_x509_crt_set_extension_by_oid.restype = c_int
+gnutls_x509_crt_set_extension_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_void_p, size_t, c_uint]
+gnutls_x509_crt_set_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_dn_by_oid
+gnutls_x509_crt_set_dn_by_oid.restype = c_int
+gnutls_x509_crt_set_dn_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_uint, c_void_p, c_uint]
+gnutls_x509_crt_set_issuer_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_issuer_dn_by_oid
+gnutls_x509_crt_set_issuer_dn_by_oid.restype = c_int
+gnutls_x509_crt_set_issuer_dn_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_uint, c_void_p, c_uint]
+gnutls_x509_crt_set_version = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_version
+gnutls_x509_crt_set_version.restype = c_int
+gnutls_x509_crt_set_version.argtypes = [gnutls_x509_crt_t, c_uint]
+gnutls_x509_crt_set_key = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_key
+gnutls_x509_crt_set_key.restype = c_int
+gnutls_x509_crt_set_key.argtypes = [gnutls_x509_crt_t, gnutls_x509_privkey_t]
+gnutls_x509_crt_set_ca_status = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_ca_status
+gnutls_x509_crt_set_ca_status.restype = c_int
+gnutls_x509_crt_set_ca_status.argtypes = [gnutls_x509_crt_t, c_uint]
+gnutls_x509_crt_set_basic_constraints = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_basic_constraints
+gnutls_x509_crt_set_basic_constraints.restype = c_int
+gnutls_x509_crt_set_basic_constraints.argtypes = [gnutls_x509_crt_t, c_uint, c_int]
+gnutls_x509_crt_set_subject_alternative_name = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_subject_alternative_name
+gnutls_x509_crt_set_subject_alternative_name.restype = c_int
+gnutls_x509_crt_set_subject_alternative_name.argtypes = [gnutls_x509_crt_t, gnutls_x509_subject_alt_name_t, STRING]
+gnutls_x509_crt_sign = _libraries['libgnutls.so.26'].gnutls_x509_crt_sign
+gnutls_x509_crt_sign.restype = c_int
+gnutls_x509_crt_sign.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_t, gnutls_x509_privkey_t]
+gnutls_x509_crt_sign2 = _libraries['libgnutls.so.26'].gnutls_x509_crt_sign2
+gnutls_x509_crt_sign2.restype = c_int
+gnutls_x509_crt_sign2.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_t, gnutls_x509_privkey_t, gnutls_digest_algorithm_t, c_uint]
+gnutls_x509_crt_set_activation_time = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_activation_time
+gnutls_x509_crt_set_activation_time.restype = c_int
+gnutls_x509_crt_set_activation_time.argtypes = [gnutls_x509_crt_t, time_t]
+gnutls_x509_crt_set_expiration_time = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_expiration_time
+gnutls_x509_crt_set_expiration_time.restype = c_int
+gnutls_x509_crt_set_expiration_time.argtypes = [gnutls_x509_crt_t, time_t]
+gnutls_x509_crt_set_serial = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_serial
+gnutls_x509_crt_set_serial.restype = c_int
+gnutls_x509_crt_set_serial.argtypes = [gnutls_x509_crt_t, c_void_p, size_t]
+gnutls_x509_crt_set_subject_key_id = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_subject_key_id
+gnutls_x509_crt_set_subject_key_id.restype = c_int
+gnutls_x509_crt_set_subject_key_id.argtypes = [gnutls_x509_crt_t, c_void_p, size_t]
+gnutls_x509_crt_set_proxy_dn = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_proxy_dn
+gnutls_x509_crt_set_proxy_dn.restype = c_int
+gnutls_x509_crt_set_proxy_dn.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_t, c_uint, c_void_p, c_uint]
+gnutls_x509_crt_set_proxy = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_proxy
+gnutls_x509_crt_set_proxy.restype = c_int
+gnutls_x509_crt_set_proxy.argtypes = [gnutls_x509_crt_t, c_int, STRING, STRING, size_t]
+gnutls_x509_crt_print = _libraries['libgnutls.so.26'].gnutls_x509_crt_print
+gnutls_x509_crt_print.restype = c_int
+gnutls_x509_crt_print.argtypes = [gnutls_x509_crt_t, gnutls_certificate_print_formats_t, POINTER(gnutls_datum_t)]
+gnutls_x509_crl_print = _libraries['libgnutls.so.26'].gnutls_x509_crl_print
+gnutls_x509_crl_print.restype = c_int
+gnutls_x509_crl_print.argtypes = [gnutls_x509_crl_t, gnutls_certificate_print_formats_t, POINTER(gnutls_datum_t)]
+gnutls_x509_crt_get_raw_issuer_dn = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_raw_issuer_dn
+gnutls_x509_crt_get_raw_issuer_dn.restype = c_int
+gnutls_x509_crt_get_raw_issuer_dn.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_datum_t)]
+gnutls_x509_crt_get_raw_dn = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_raw_dn
+gnutls_x509_crt_get_raw_dn.restype = c_int
+gnutls_x509_crt_get_raw_dn.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_datum_t)]
+gnutls_x509_rdn_get = _libraries['libgnutls.so.26'].gnutls_x509_rdn_get
+gnutls_x509_rdn_get.restype = c_int
+gnutls_x509_rdn_get.argtypes = [POINTER(gnutls_datum_t), STRING, POINTER(size_t)]
+gnutls_x509_rdn_get_oid = _libraries['libgnutls.so.26'].gnutls_x509_rdn_get_oid
+gnutls_x509_rdn_get_oid.restype = c_int
+gnutls_x509_rdn_get_oid.argtypes = [POINTER(gnutls_datum_t), c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_rdn_get_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_rdn_get_by_oid
+gnutls_x509_rdn_get_by_oid.restype = c_int
+gnutls_x509_rdn_get_by_oid.argtypes = [POINTER(gnutls_datum_t), STRING, c_int, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_subject = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_subject
+gnutls_x509_crt_get_subject.restype = c_int
+gnutls_x509_crt_get_subject.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_x509_dn_t)]
+gnutls_x509_crt_get_issuer = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_issuer
+gnutls_x509_crt_get_issuer.restype = c_int
+gnutls_x509_crt_get_issuer.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_x509_dn_t)]
+gnutls_x509_dn_get_rdn_ava = _libraries['libgnutls.so.26'].gnutls_x509_dn_get_rdn_ava
+gnutls_x509_dn_get_rdn_ava.restype = c_int
+gnutls_x509_dn_get_rdn_ava.argtypes = [gnutls_x509_dn_t, c_int, c_int, POINTER(gnutls_x509_ava_st)]
+gnutls_x509_dn_init = _libraries['libgnutls.so.26'].gnutls_x509_dn_init
+gnutls_x509_dn_init.restype = c_int
+gnutls_x509_dn_init.argtypes = [POINTER(gnutls_x509_dn_t)]
+gnutls_x509_dn_import = _libraries['libgnutls.so.26'].gnutls_x509_dn_import
+gnutls_x509_dn_import.restype = c_int
+gnutls_x509_dn_import.argtypes = [gnutls_x509_dn_t, POINTER(gnutls_datum_t)]
+gnutls_x509_dn_export = _libraries['libgnutls.so.26'].gnutls_x509_dn_export
+gnutls_x509_dn_export.restype = c_int
+gnutls_x509_dn_export.argtypes = [gnutls_x509_dn_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_x509_dn_deinit = _libraries['libgnutls.so.26'].gnutls_x509_dn_deinit
+gnutls_x509_dn_deinit.restype = None
+gnutls_x509_dn_deinit.argtypes = [gnutls_x509_dn_t]
+gnutls_x509_crl_init = _libraries['libgnutls.so.26'].gnutls_x509_crl_init
+gnutls_x509_crl_init.restype = c_int
+gnutls_x509_crl_init.argtypes = [POINTER(gnutls_x509_crl_t)]
+gnutls_x509_crl_deinit = _libraries['libgnutls.so.26'].gnutls_x509_crl_deinit
+gnutls_x509_crl_deinit.restype = None
+gnutls_x509_crl_deinit.argtypes = [gnutls_x509_crl_t]
+gnutls_x509_crl_import = _libraries['libgnutls.so.26'].gnutls_x509_crl_import
+gnutls_x509_crl_import.restype = c_int
+gnutls_x509_crl_import.argtypes = [gnutls_x509_crl_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_x509_crl_export = _libraries['libgnutls.so.26'].gnutls_x509_crl_export
+gnutls_x509_crl_export.restype = c_int
+gnutls_x509_crl_export.argtypes = [gnutls_x509_crl_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_x509_crl_get_issuer_dn = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_issuer_dn
+gnutls_x509_crl_get_issuer_dn.restype = c_int
+gnutls_x509_crl_get_issuer_dn.argtypes = [gnutls_x509_crl_t, STRING, POINTER(size_t)]
+gnutls_x509_crl_get_issuer_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_issuer_dn_by_oid
+gnutls_x509_crl_get_issuer_dn_by_oid.restype = c_int
+gnutls_x509_crl_get_issuer_dn_by_oid.argtypes = [gnutls_x509_crl_t, STRING, c_int, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_crl_get_dn_oid = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_dn_oid
+gnutls_x509_crl_get_dn_oid.restype = c_int
+gnutls_x509_crl_get_dn_oid.argtypes = [gnutls_x509_crl_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crl_get_signature_algorithm = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_signature_algorithm
+gnutls_x509_crl_get_signature_algorithm.restype = c_int
+gnutls_x509_crl_get_signature_algorithm.argtypes = [gnutls_x509_crl_t]
+gnutls_x509_crl_get_signature = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_signature
+gnutls_x509_crl_get_signature.restype = c_int
+gnutls_x509_crl_get_signature.argtypes = [gnutls_x509_crl_t, STRING, POINTER(size_t)]
+gnutls_x509_crl_get_version = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_version
+gnutls_x509_crl_get_version.restype = c_int
+gnutls_x509_crl_get_version.argtypes = [gnutls_x509_crl_t]
+gnutls_x509_crl_get_this_update = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_this_update
+gnutls_x509_crl_get_this_update.restype = time_t
+gnutls_x509_crl_get_this_update.argtypes = [gnutls_x509_crl_t]
+gnutls_x509_crl_get_next_update = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_next_update
+gnutls_x509_crl_get_next_update.restype = time_t
+gnutls_x509_crl_get_next_update.argtypes = [gnutls_x509_crl_t]
+gnutls_x509_crl_get_crt_count = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_crt_count
+gnutls_x509_crl_get_crt_count.restype = c_int
+gnutls_x509_crl_get_crt_count.argtypes = [gnutls_x509_crl_t]
+gnutls_x509_crl_get_crt_serial = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_crt_serial
+gnutls_x509_crl_get_crt_serial.restype = c_int
+gnutls_x509_crl_get_crt_serial.argtypes = [gnutls_x509_crl_t, c_int, POINTER(c_ubyte), POINTER(size_t), POINTER(time_t)]
+gnutls_x509_crl_check_issuer = _libraries['libgnutls.so.26'].gnutls_x509_crl_check_issuer
+gnutls_x509_crl_check_issuer.restype = c_int
+gnutls_x509_crl_check_issuer.argtypes = [gnutls_x509_crl_t, gnutls_x509_crt_t]
+gnutls_x509_crl_set_version = _libraries['libgnutls.so.26'].gnutls_x509_crl_set_version
+gnutls_x509_crl_set_version.restype = c_int
+gnutls_x509_crl_set_version.argtypes = [gnutls_x509_crl_t, c_uint]
+gnutls_x509_crl_sign = _libraries['libgnutls.so.26'].gnutls_x509_crl_sign
+gnutls_x509_crl_sign.restype = c_int
+gnutls_x509_crl_sign.argtypes = [gnutls_x509_crl_t, gnutls_x509_crt_t, gnutls_x509_privkey_t]
+gnutls_x509_crl_sign2 = _libraries['libgnutls.so.26'].gnutls_x509_crl_sign2
+gnutls_x509_crl_sign2.restype = c_int
+gnutls_x509_crl_sign2.argtypes = [gnutls_x509_crl_t, gnutls_x509_crt_t, gnutls_x509_privkey_t, gnutls_digest_algorithm_t, c_uint]
+gnutls_x509_crl_set_this_update = _libraries['libgnutls.so.26'].gnutls_x509_crl_set_this_update
+gnutls_x509_crl_set_this_update.restype = c_int
+gnutls_x509_crl_set_this_update.argtypes = [gnutls_x509_crl_t, time_t]
+gnutls_x509_crl_set_next_update = _libraries['libgnutls.so.26'].gnutls_x509_crl_set_next_update
+gnutls_x509_crl_set_next_update.restype = c_int
+gnutls_x509_crl_set_next_update.argtypes = [gnutls_x509_crl_t, time_t]
+gnutls_x509_crl_set_crt_serial = _libraries['libgnutls.so.26'].gnutls_x509_crl_set_crt_serial
+gnutls_x509_crl_set_crt_serial.restype = c_int
+gnutls_x509_crl_set_crt_serial.argtypes = [gnutls_x509_crl_t, c_void_p, size_t, time_t]
+gnutls_x509_crl_set_crt = _libraries['libgnutls.so.26'].gnutls_x509_crl_set_crt
+gnutls_x509_crl_set_crt.restype = c_int
+gnutls_x509_crl_set_crt.argtypes = [gnutls_x509_crl_t, gnutls_x509_crt_t, time_t]
+gnutls_pkcs7_init = _libraries['libgnutls.so.26'].gnutls_pkcs7_init
+gnutls_pkcs7_init.restype = c_int
+gnutls_pkcs7_init.argtypes = [POINTER(gnutls_pkcs7_t)]
+gnutls_pkcs7_deinit = _libraries['libgnutls.so.26'].gnutls_pkcs7_deinit
+gnutls_pkcs7_deinit.restype = None
+gnutls_pkcs7_deinit.argtypes = [gnutls_pkcs7_t]
+gnutls_pkcs7_import = _libraries['libgnutls.so.26'].gnutls_pkcs7_import
+gnutls_pkcs7_import.restype = c_int
+gnutls_pkcs7_import.argtypes = [gnutls_pkcs7_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_pkcs7_export = _libraries['libgnutls.so.26'].gnutls_pkcs7_export
+gnutls_pkcs7_export.restype = c_int
+gnutls_pkcs7_export.argtypes = [gnutls_pkcs7_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_pkcs7_get_crt_count = _libraries['libgnutls.so.26'].gnutls_pkcs7_get_crt_count
+gnutls_pkcs7_get_crt_count.restype = c_int
+gnutls_pkcs7_get_crt_count.argtypes = [gnutls_pkcs7_t]
+gnutls_pkcs7_get_crt_raw = _libraries['libgnutls.so.26'].gnutls_pkcs7_get_crt_raw
+gnutls_pkcs7_get_crt_raw.restype = c_int
+gnutls_pkcs7_get_crt_raw.argtypes = [gnutls_pkcs7_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_pkcs7_set_crt_raw = _libraries['libgnutls.so.26'].gnutls_pkcs7_set_crt_raw
+gnutls_pkcs7_set_crt_raw.restype = c_int
+gnutls_pkcs7_set_crt_raw.argtypes = [gnutls_pkcs7_t, POINTER(gnutls_datum_t)]
+gnutls_pkcs7_set_crt = _libraries['libgnutls.so.26'].gnutls_pkcs7_set_crt
+gnutls_pkcs7_set_crt.restype = c_int
+gnutls_pkcs7_set_crt.argtypes = [gnutls_pkcs7_t, gnutls_x509_crt_t]
+gnutls_pkcs7_delete_crt = _libraries['libgnutls.so.26'].gnutls_pkcs7_delete_crt
+gnutls_pkcs7_delete_crt.restype = c_int
+gnutls_pkcs7_delete_crt.argtypes = [gnutls_pkcs7_t, c_int]
+gnutls_pkcs7_get_crl_raw = _libraries['libgnutls.so.26'].gnutls_pkcs7_get_crl_raw
+gnutls_pkcs7_get_crl_raw.restype = c_int
+gnutls_pkcs7_get_crl_raw.argtypes = [gnutls_pkcs7_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_pkcs7_get_crl_count = _libraries['libgnutls.so.26'].gnutls_pkcs7_get_crl_count
+gnutls_pkcs7_get_crl_count.restype = c_int
+gnutls_pkcs7_get_crl_count.argtypes = [gnutls_pkcs7_t]
+gnutls_pkcs7_set_crl_raw = _libraries['libgnutls.so.26'].gnutls_pkcs7_set_crl_raw
+gnutls_pkcs7_set_crl_raw.restype = c_int
+gnutls_pkcs7_set_crl_raw.argtypes = [gnutls_pkcs7_t, POINTER(gnutls_datum_t)]
+gnutls_pkcs7_set_crl = _libraries['libgnutls.so.26'].gnutls_pkcs7_set_crl
+gnutls_pkcs7_set_crl.restype = c_int
+gnutls_pkcs7_set_crl.argtypes = [gnutls_pkcs7_t, gnutls_x509_crl_t]
+gnutls_pkcs7_delete_crl = _libraries['libgnutls.so.26'].gnutls_pkcs7_delete_crl
+gnutls_pkcs7_delete_crl.restype = c_int
+gnutls_pkcs7_delete_crl.argtypes = [gnutls_pkcs7_t, c_int]
+gnutls_x509_crt_check_issuer = _libraries['libgnutls.so.26'].gnutls_x509_crt_check_issuer
+gnutls_x509_crt_check_issuer.restype = c_int
+gnutls_x509_crt_check_issuer.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_t]
+gnutls_x509_crt_list_verify = _libraries['libgnutls.so.26'].gnutls_x509_crt_list_verify
+gnutls_x509_crt_list_verify.restype = c_int
+gnutls_x509_crt_list_verify.argtypes = [POINTER(gnutls_x509_crt_t), c_int, POINTER(gnutls_x509_crt_t), c_int, POINTER(gnutls_x509_crl_t), c_int, c_uint, POINTER(c_uint)]
+gnutls_x509_crt_verify = _libraries['libgnutls.so.26'].gnutls_x509_crt_verify
+gnutls_x509_crt_verify.restype = c_int
+gnutls_x509_crt_verify.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_x509_crt_t), c_int, c_uint, POINTER(c_uint)]
+gnutls_x509_crl_verify = _libraries['libgnutls.so.26'].gnutls_x509_crl_verify
+gnutls_x509_crl_verify.restype = c_int
+gnutls_x509_crl_verify.argtypes = [gnutls_x509_crl_t, POINTER(gnutls_x509_crt_t), c_int, c_uint, POINTER(c_uint)]
+gnutls_x509_crt_check_revocation = _libraries['libgnutls.so.26'].gnutls_x509_crt_check_revocation
+gnutls_x509_crt_check_revocation.restype = c_int
+gnutls_x509_crt_check_revocation.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_x509_crl_t), c_int]
+gnutls_x509_crt_get_fingerprint = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_fingerprint
+gnutls_x509_crt_get_fingerprint.restype = c_int
+gnutls_x509_crt_get_fingerprint.argtypes = [gnutls_x509_crt_t, gnutls_digest_algorithm_t, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_key_purpose_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_key_purpose_oid
+gnutls_x509_crt_get_key_purpose_oid.restype = c_int
+gnutls_x509_crt_get_key_purpose_oid.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t), POINTER(c_uint)]
+gnutls_x509_crt_set_key_purpose_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_key_purpose_oid
+gnutls_x509_crt_set_key_purpose_oid.restype = c_int
+gnutls_x509_crt_set_key_purpose_oid.argtypes = [gnutls_x509_crt_t, c_void_p, c_uint]
+gnutls_x509_privkey_init = _libraries['libgnutls.so.26'].gnutls_x509_privkey_init
+gnutls_x509_privkey_init.restype = c_int
+gnutls_x509_privkey_init.argtypes = [POINTER(gnutls_x509_privkey_t)]
+gnutls_x509_privkey_deinit = _libraries['libgnutls.so.26'].gnutls_x509_privkey_deinit
+gnutls_x509_privkey_deinit.restype = None
+gnutls_x509_privkey_deinit.argtypes = [gnutls_x509_privkey_t]
+gnutls_x509_privkey_cpy = _libraries['libgnutls.so.26'].gnutls_x509_privkey_cpy
+gnutls_x509_privkey_cpy.restype = c_int
+gnutls_x509_privkey_cpy.argtypes = [gnutls_x509_privkey_t, gnutls_x509_privkey_t]
+gnutls_x509_privkey_import = _libraries['libgnutls.so.26'].gnutls_x509_privkey_import
+gnutls_x509_privkey_import.restype = c_int
+gnutls_x509_privkey_import.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_x509_privkey_import_pkcs8 = _libraries['libgnutls.so.26'].gnutls_x509_privkey_import_pkcs8
+gnutls_x509_privkey_import_pkcs8.restype = c_int
+gnutls_x509_privkey_import_pkcs8.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t, STRING, c_uint]
+gnutls_x509_privkey_import_rsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_privkey_import_rsa_raw
+gnutls_x509_privkey_import_rsa_raw.restype = c_int
+gnutls_x509_privkey_import_rsa_raw.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_privkey_fix = _libraries['libgnutls.so.26'].gnutls_x509_privkey_fix
+gnutls_x509_privkey_fix.restype = c_int
+gnutls_x509_privkey_fix.argtypes = [gnutls_x509_privkey_t]
+gnutls_x509_privkey_export_dsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_privkey_export_dsa_raw
+gnutls_x509_privkey_export_dsa_raw.restype = c_int
+gnutls_x509_privkey_export_dsa_raw.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_privkey_import_dsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_privkey_import_dsa_raw
+gnutls_x509_privkey_import_dsa_raw.restype = c_int
+gnutls_x509_privkey_import_dsa_raw.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_privkey_get_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_x509_privkey_get_pk_algorithm
+gnutls_x509_privkey_get_pk_algorithm.restype = c_int
+gnutls_x509_privkey_get_pk_algorithm.argtypes = [gnutls_x509_privkey_t]
+gnutls_x509_privkey_get_key_id = _libraries['libgnutls.so.26'].gnutls_x509_privkey_get_key_id
+gnutls_x509_privkey_get_key_id.restype = c_int
+gnutls_x509_privkey_get_key_id.argtypes = [gnutls_x509_privkey_t, c_uint, POINTER(c_ubyte), POINTER(size_t)]
+gnutls_x509_privkey_generate = _libraries['libgnutls.so.26'].gnutls_x509_privkey_generate
+gnutls_x509_privkey_generate.restype = c_int
+gnutls_x509_privkey_generate.argtypes = [gnutls_x509_privkey_t, gnutls_pk_algorithm_t, c_uint, c_uint]
+gnutls_x509_privkey_export = _libraries['libgnutls.so.26'].gnutls_x509_privkey_export
+gnutls_x509_privkey_export.restype = c_int
+gnutls_x509_privkey_export.argtypes = [gnutls_x509_privkey_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_x509_privkey_export_pkcs8 = _libraries['libgnutls.so.26'].gnutls_x509_privkey_export_pkcs8
+gnutls_x509_privkey_export_pkcs8.restype = c_int
+gnutls_x509_privkey_export_pkcs8.argtypes = [gnutls_x509_privkey_t, gnutls_x509_crt_fmt_t, STRING, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_privkey_export_rsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_privkey_export_rsa_raw
+gnutls_x509_privkey_export_rsa_raw.restype = c_int
+gnutls_x509_privkey_export_rsa_raw.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_privkey_sign_data = _libraries['libgnutls.so.26'].gnutls_x509_privkey_sign_data
+gnutls_x509_privkey_sign_data.restype = c_int
+gnutls_x509_privkey_sign_data.argtypes = [gnutls_x509_privkey_t, gnutls_digest_algorithm_t, c_uint, POINTER(gnutls_datum_t), c_void_p, POINTER(size_t)]
+gnutls_x509_privkey_verify_data = _libraries['libgnutls.so.26'].gnutls_x509_privkey_verify_data
+gnutls_x509_privkey_verify_data.restype = c_int
+gnutls_x509_privkey_verify_data.argtypes = [gnutls_x509_privkey_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_crt_verify_data = _libraries['libgnutls.so.26'].gnutls_x509_crt_verify_data
+gnutls_x509_crt_verify_data.restype = c_int
+gnutls_x509_crt_verify_data.argtypes = [gnutls_x509_crt_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_privkey_sign_hash = _libraries['libgnutls.so.26'].gnutls_x509_privkey_sign_hash
+gnutls_x509_privkey_sign_hash.restype = c_int
+gnutls_x509_privkey_sign_hash.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_crq_init = _libraries['libgnutls.so.26'].gnutls_x509_crq_init
+gnutls_x509_crq_init.restype = c_int
+gnutls_x509_crq_init.argtypes = [POINTER(gnutls_x509_crq_t)]
+gnutls_x509_crq_deinit = _libraries['libgnutls.so.26'].gnutls_x509_crq_deinit
+gnutls_x509_crq_deinit.restype = None
+gnutls_x509_crq_deinit.argtypes = [gnutls_x509_crq_t]
+gnutls_x509_crq_import = _libraries['libgnutls.so.26'].gnutls_x509_crq_import
+gnutls_x509_crq_import.restype = c_int
+gnutls_x509_crq_import.argtypes = [gnutls_x509_crq_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_x509_crq_get_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_pk_algorithm
+gnutls_x509_crq_get_pk_algorithm.restype = c_int
+gnutls_x509_crq_get_pk_algorithm.argtypes = [gnutls_x509_crq_t, POINTER(c_uint)]
+gnutls_x509_crq_get_dn = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_dn
+gnutls_x509_crq_get_dn.restype = c_int
+gnutls_x509_crq_get_dn.argtypes = [gnutls_x509_crq_t, STRING, POINTER(size_t)]
+gnutls_x509_crq_get_dn_oid = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_dn_oid
+gnutls_x509_crq_get_dn_oid.restype = c_int
+gnutls_x509_crq_get_dn_oid.argtypes = [gnutls_x509_crq_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crq_get_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_dn_by_oid
+gnutls_x509_crq_get_dn_by_oid.restype = c_int
+gnutls_x509_crq_get_dn_by_oid.argtypes = [gnutls_x509_crq_t, STRING, c_int, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_crq_set_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crq_set_dn_by_oid
+gnutls_x509_crq_set_dn_by_oid.restype = c_int
+gnutls_x509_crq_set_dn_by_oid.argtypes = [gnutls_x509_crq_t, STRING, c_uint, c_void_p, c_uint]
+gnutls_x509_crq_set_version = _libraries['libgnutls.so.26'].gnutls_x509_crq_set_version
+gnutls_x509_crq_set_version.restype = c_int
+gnutls_x509_crq_set_version.argtypes = [gnutls_x509_crq_t, c_uint]
+gnutls_x509_crq_set_key = _libraries['libgnutls.so.26'].gnutls_x509_crq_set_key
+gnutls_x509_crq_set_key.restype = c_int
+gnutls_x509_crq_set_key.argtypes = [gnutls_x509_crq_t, gnutls_x509_privkey_t]
+gnutls_x509_crq_sign2 = _libraries['libgnutls.so.26'].gnutls_x509_crq_sign2
+gnutls_x509_crq_sign2.restype = c_int
+gnutls_x509_crq_sign2.argtypes = [gnutls_x509_crq_t, gnutls_x509_privkey_t, gnutls_digest_algorithm_t, c_uint]
+gnutls_x509_crq_sign = _libraries['libgnutls.so.26'].gnutls_x509_crq_sign
+gnutls_x509_crq_sign.restype = c_int
+gnutls_x509_crq_sign.argtypes = [gnutls_x509_crq_t, gnutls_x509_privkey_t]
+gnutls_x509_crq_set_challenge_password = _libraries['libgnutls.so.26'].gnutls_x509_crq_set_challenge_password
+gnutls_x509_crq_set_challenge_password.restype = c_int
+gnutls_x509_crq_set_challenge_password.argtypes = [gnutls_x509_crq_t, STRING]
+gnutls_x509_crq_get_challenge_password = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_challenge_password
+gnutls_x509_crq_get_challenge_password.restype = c_int
+gnutls_x509_crq_get_challenge_password.argtypes = [gnutls_x509_crq_t, STRING, POINTER(size_t)]
+gnutls_x509_crq_set_attribute_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crq_set_attribute_by_oid
+gnutls_x509_crq_set_attribute_by_oid.restype = c_int
+gnutls_x509_crq_set_attribute_by_oid.argtypes = [gnutls_x509_crq_t, STRING, c_void_p, size_t]
+gnutls_x509_crq_get_attribute_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_attribute_by_oid
+gnutls_x509_crq_get_attribute_by_oid.restype = c_int
+gnutls_x509_crq_get_attribute_by_oid.argtypes = [gnutls_x509_crq_t, STRING, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crq_export = _libraries['libgnutls.so.26'].gnutls_x509_crq_export
+gnutls_x509_crq_export.restype = c_int
+gnutls_x509_crq_export.argtypes = [gnutls_x509_crq_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_set_crq = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_crq
+gnutls_x509_crt_set_crq.restype = c_int
+gnutls_x509_crt_set_crq.argtypes = [gnutls_x509_crt_t, gnutls_x509_crq_t]
+__all__ = ['gnutls_ia_set_server_avp_ptr',
+           'gnutls_openpgp_privkey_init',
+           'gnutls_certificate_activation_time_peers',
+           'gnutls_x509_crt_set_proxy_dn',
+           'gnutls_db_set_remove_function',
+           'gnutls_x509_crt_set_dn_by_oid',
+           'gnutls_x509_crt_check_hostname',
+           'gnutls_openpgp_keyring_get_crt',
+           'gnutls_global_init_extra',
+           'gnutls_srp_set_client_credentials_function',
+           'gnutls_x509_crl_import',
+           'gnutls_certificate_set_x509_trust_file',
+           'gnutls_x509_crt_get_pk_rsa_raw',
+           'gnutls_x509_privkey_export_rsa_raw',
+           'gnutls_priority_set', 'gnutls_cipher_get',
+           'gnutls_certificate_set_openpgp_keyring_mem',
+           'gnutls_x509_crt_get_ca_status',
+           'gnutls_cipher_get_key_size',
+           'gnutls_certificate_set_x509_crl_file',
+           'gnutls_x509_privkey_import_dsa_raw',
+           'gnutls_x509_crq_init', 'gnutls_session_get_master_secret',
+           'gnutls_x509_crq_get_challenge_password', '__time_t',
+           'gnutls_x509_crt_get_pk_algorithm',
+           'gnutls_x509_crt_set_crq',
+           'gnutls_certificate_set_openpgp_key_mem2',
+           'gnutls_certificate_free_keys', 'gnutls_srp_verifier',
+           'gnutls_x509_crl_deinit',
+           'gnutls_openpgp_crt_get_pk_dsa_raw',
+           'gnutls_certificate_free_ca_names', 'gnutls_cipher_list',
+           'gnutls_x509_crq_export',
+           'gnutls_certificate_client_set_retrieve_function',
+           'gnutls_x509_crl_get_crt_serial',
+           'gnutls_pkcs7_get_crt_count',
+           'gnutls_certificate_set_x509_trust',
+           'gnutls_openpgp_crt_get_subkey_fingerprint',
+           'gnutls_ia_handshake_p',
+           'gnutls_openpgp_privkey_get_subkey_fingerprint',
+           'gnutls_openpgp_keyring_import', 'gnutls_pkcs7_set_crl',
+           'gnutls_x509_crq_get_pk_algorithm',
+           'gnutls_pkcs7_set_crl_raw',
+           'gnutls_certificate_set_verify_limits',
+           'gnutls_x509_crt_get_authority_key_id',
+           'gnutls_x509_crt_set_activation_time', 'gnutls_db_set_ptr',
+           'gnutls_openpgp_crt_get_version',
+           'gnutls_x509_crt_get_subject_key_id',
+           'gnutls_credentials_clear', 'gnutls_x509_crt_get_key_id',
+           'gnutls_x509_crt_init', 'gnutls_dh_params_generate2',
+           'gnutls_pkcs7_delete_crt',
+           'gnutls_x509_crt_get_subject_alt_name2',
+           'gnutls_alert_get_name',
+           'gnutls_x509_crt_set_authority_key_id',
+           'gnutls_openpgp_crt_get_subkey_pk_rsa_raw',
+           'gnutls_x509_crt_list_verify', 'gnutls_priority_init',
+           'gnutls_openpgp_crt_get_expiration_time',
+           'gnutls_x509_crl_set_version',
+           'gnutls_certificate_set_openpgp_keyring_file',
+           'gnutls_pem_base64_encode',
+           'gnutls_handshake_set_max_packet_length',
+           'gnutls_openpgp_privkey_get_subkey_expiration_time',
+           'gnutls_x509_crq_set_dn_by_oid', 'gnutls_session_get_id',
+           'gnutls_cipher_set_priority',
+           'gnutls_openpgp_keyring_check_id',
+           'gnutls_openpgp_keyring_deinit',
+           'gnutls_srp_base64_encode_alloc',
+           'gnutls_db_set_store_function',
+           'gnutls_supplemental_get_name',
+           'gnutls_handshake_get_last_out',
+           'gnutls_x509_privkey_export_pkcs8',
+           'gnutls_x509_privkey_deinit', 'gnutls_compression_get_id',
+           'gnutls_openpgp_crt_get_subkey_idx',
+           'gnutls_x509_privkey_import_rsa_raw',
+           'gnutls_transport_set_errno',
+           'gnutls_openpgp_privkey_get_subkey_revoked_status',
+           'gnutls_x509_crt_get_issuer_dn',
+           'gnutls_ia_get_server_avp_ptr',
+           'gnutls_openpgp_keyring_get_crt_count', 'gnutls_ia_recv',
+           'gnutls_x509_crt_get_pk_dsa_raw', 'gnutls_x509_crt_sign',
+           'gnutls_certificate_verify_peers',
+           'gnutls_srp_free_server_credentials',
+           'gnutls_x509_crt_print',
+           'gnutls_openpgp_privkey_export_subkey_dsa_raw',
+           'gnutls_server_name_set', 'gnutls_kx_set_priority',
+           'gnutls_transport_set_push_function',
+           'gnutls_x509_crt_sign2',
+           'gnutls_x509_crt_cpy_crl_dist_points',
+           'gnutls_pem_base64_decode', 'gnutls_srp_base64_decode',
+           'gnutls_openpgp_privkey_get_subkey_count',
+           'gnutls_global_init', 'gnutls_x509_rdn_get_by_oid',
+           'gnutls_dh_params_import_raw',
+           'gnutls_global_set_mem_functions',
+           'gnutls_x509_crt_set_key_usage', 'time_t',
+           'gnutls_anon_set_server_params_function',
+           'gnutls_mac_get_key_size',
+           'gnutls_rsa_params_export_pkcs1',
+           'gnutls_certificate_type_set_priority',
+           'gnutls_x509_crt_get_issuer_dn_oid',
+           'gnutls_dh_params_init',
+           'gnutls_x509_crq_set_attribute_by_oid',
+           'gnutls_certificate_expiration_time_peers',
+           'gnutls_ia_endphase_send',
+           'gnutls_psk_allocate_server_credentials',
+           'gnutls_certificate_set_dh_params', 'gnutls_init',
+           'gnutls_openpgp_privkey_get_subkey_pk_algorithm',
+           'gnutls_x509_rdn_get_oid', 'gnutls_x509_crl_get_crt_count',
+           'gnutls_perror', 'gnutls_x509_crl_get_dn_oid',
+           'gnutls_certificate_get_peers',
+           'gnutls_ia_set_server_avp_function',
+           'gnutls_x509_crl_sign2',
+           'gnutls_x509_crt_get_extension_oid',
+           'gnutls_x509_crl_sign', 'gnutls_dh_get_pubkey',
+           'gnutls_record_get_max_size', 'gnutls_x509_crt_get_dn_oid',
+           'gnutls_x509_crt_get_extension_info',
+           'gnutls_transport_get_ptr', 'gnutls_db_check_entry',
+           'gnutls_ia_generate_challenge',
+           'gnutls_certificate_server_set_retrieve_function',
+           'gnutls_certificate_set_openpgp_key',
+           'gnutls_srp_base64_encode', 'gnutls_db_get_ptr',
+           'gnutls_pkcs7_export', 'gnutls_mac_set_priority',
+           'gnutls_x509_crt_get_basic_constraints',
+           'gnutls_x509_crt_get_subject_alt_othername_oid',
+           'gnutls_cipher_get_id', 'gnutls_x509_crl_get_this_update',
+           'gnutls_x509_dn_init', 'gnutls_openpgp_crt_import',
+           'gnutls_certificate_set_x509_crl',
+           'gnutls_rsa_export_get_modulus_bits',
+           'gnutls_x509_crl_get_version',
+           'gnutls_pkcs7_get_crl_count', 'gnutls_handshake',
+           'gnutls_dh_get_group', 'gnutls_x509_crq_get_dn',
+           'gnutls_pkcs7_deinit', 'gnutls_record_check_pending',
+           'gnutls_protocol_get_name',
+           'gnutls_openpgp_privkey_sign_hash',
+           'gnutls_srp_set_server_credentials_file',
+           'gnutls_pkcs7_delete_crl', 'gnutls_rsa_params_init',
+           'gnutls_x509_crt_set_key_purpose_oid', 'gnutls_mac_get',
+           'gnutls_record_get_direction',
+           'gnutls_certificate_type_list', 'gnutls_session_get_ptr',
+           'gnutls_psk_set_server_dh_params',
+           'gnutls_x509_crt_get_raw_issuer_dn',
+           'gnutls_x509_crt_get_raw_dn', 'gnutls_record_send',
+           'gnutls_psk_allocate_client_credentials',
+           'gnutls_certificate_set_x509_key',
+           'gnutls_certificate_type_get_id',
+           'gnutls_x509_privkey_export_dsa_raw',
+           'gnutls_pk_algorithm_get_name',
+           'gnutls_openpgp_crt_get_pk_algorithm',
+           'gnutls_psk_free_client_credentials',
+           'gnutls_openpgp_crt_check_hostname',
+           'gnutls_handshake_set_post_client_hello_function',
+           'gnutls_record_set_max_size',
+           'gnutls_openpgp_crt_verify_ring',
+           'gnutls_transport_set_ptr', 'gnutls_ia_set_client_avp_ptr',
+           'gnutls_x509_privkey_generate', 'gnutls_db_remove_session',
+           'gnutls_certificate_type_get_name',
+           'gnutls_openpgp_crt_verify_self',
+           'gnutls_x509_crq_get_dn_oid', 'gnutls_x509_dn_oid_known',
+           'gnutls_openpgp_crt_print', 'gnutls_alert_send',
+           'gnutls_x509_privkey_sign_data',
+           'gnutls_x509_crt_get_extension_data',
+           'gnutls_x509_crl_set_crt_serial',
+           'gnutls_x509_crt_set_basic_constraints',
+           'gnutls_credentials_set', 'gnutls_transport_set_ptr2',
+           'gnutls_x509_crt_set_issuer_dn_by_oid',
+           'gnutls_record_disable_padding', 'gnutls_prf_raw',
+           'gnutls_anon_allocate_server_credentials',
+           'gnutls_x509_crl_get_signature',
+           'gnutls_x509_crl_check_issuer', 'gnutls_cipher_suite_info',
+           'gnutls_x509_crt_get_issuer',
+           'gnutls_certificate_set_params_function',
+           'gnutls_openpgp_crt_get_subkey_id',
+           'gnutls_psk_set_server_credentials_hint',
+           'gnutls_sign_callback_set',
+           'gnutls_x509_crt_check_revocation',
+           'gnutls_openpgp_privkey_export',
+           'gnutls_x509_crt_get_activation_time', 'gnutls_kx_list',
+           'gnutls_x509_crt_get_subject_alt_name',
+           'gnutls_openpgp_privkey_get_subkey_creation_time',
+           'gnutls_x509_crt_get_dn_by_oid', 'gnutls_rsa_params_cpy',
+           'gnutls_x509_crt_set_subject_key_id',
+           'gnutls_check_version',
+           'gnutls_certificate_client_get_request_status',
+           'gnutls_prf', 'gnutls_srp_server_get_username',
+           'gnutls_pem_base64_encode_alloc',
+           'gnutls_certificate_set_openpgp_key_file2',
+           'gnutls_openpgp_privkey_export_rsa_raw',
+           'gnutls_certificate_set_openpgp_key_mem',
+           'gnutls_openpgp_privkey_get_key_id',
+           'gnutls_anon_free_client_credentials',
+           'gnutls_transport_get_ptr2',
+           'gnutls_ia_get_client_avp_ptr', 'gnutls_pkcs7_import',
+           'gnutls_compression_get',
+           'gnutls_x509_crl_get_signature_algorithm',
+           'gnutls_openpgp_keyring_init',
+           'gnutls_certificate_free_crls',
+           'gnutls_transport_set_global_errno', 'gnutls_record_recv',
+           'gnutls_certificate_type_get',
+           'gnutls_auth_server_get_type',
+           'gnutls_anon_set_params_function',
+           'gnutls_openpgp_crt_deinit', 'gnutls_pkcs7_set_crt',
+           'gnutls_rsa_params_export_raw',
+           'gnutls_x509_dn_get_rdn_ava', 'gnutls_x509_crt_deinit',
+           'gnutls_session_get_client_random',
+           'gnutls_openpgp_set_recv_key_function',
+           'gnutls_x509_crl_set_this_update',
+           'gnutls_ia_free_client_credentials',
+           'gnutls_protocol_get_version', 'gnutls_x509_crl_set_crt',
+           'gnutls_fingerprint', 'gnutls_x509_dn_export',
+           'gnutls_openpgp_privkey_import', 'gnutls_error_to_alert',
+           'gnutls_x509_privkey_get_key_id',
+           'gnutls_x509_crt_get_subject', 'gnutls_rsa_params_deinit',
+           'gnutls_cipher_get_name', 'gnutls_ia_send',
+           'gnutls_x509_crt_set_extension_by_oid',
+           'gnutls_x509_privkey_get_pk_algorithm',
+           'gnutls_hex_encode', 'gnutls_rsa_params_import_raw',
+           'gnutls_mac_get_name', 'gnutls_psk_server_get_username',
+           'gnutls_session_get_data2', 'gnutls_kx_get',
+           'gnutls_openpgp_crt_get_preferred_key_id',
+           'gnutls_certificate_get_x509_crls',
+           'gnutls_x509_crq_set_version', 'gnutls_x509_privkey_cpy',
+           'gnutls_openpgp_crt_get_subkey_revoked_status',
+           'gnutls_priority_set_direct', 'gnutls_dh_get_secret_bits',
+           'gnutls_x509_crt_get_expiration_time', 'gnutls_pkcs7_init',
+           'gnutls_transport_set_pull_function',
+           'gnutls_protocol_list',
+           'gnutls_srp_set_client_credentials',
+           'gnutls_x509_crt_get_key_purpose_oid',
+           'gnutls_certificate_verify_peers2',
+           'gnutls_srp_base64_decode_alloc', 'gnutls_x509_crq_sign',
+           'gnutls_x509_privkey_init', 'gnutls_global_set_log_level',
+           'gnutls_sign_callback_get', 'gnutls_x509_rdn_get',
+           'gnutls_openpgp_privkey_set_preferred_key_id',
+           'gnutls_certificate_free_credentials',
+           'gnutls_x509_dn_deinit',
+           'gnutls_certificate_set_rsa_export_params',
+           'gnutls_x509_crt_get_serial', 'gnutls_x509_crq_import',
+           'gnutls_x509_privkey_export',
+           'gnutls_cipher_suite_get_name',
+           'gnutls_ia_extract_inner_secret',
+           'gnutls_x509_crt_get_version', 'gnutls_ia_enable',
+           'gnutls_x509_crt_set_key',
+           'gnutls_srp_free_client_credentials', 'gnutls_mac_list',
+           'gnutls_dh_get_prime_bits', 'gnutls_certificate_free_cas',
+           'gnutls_alert_get', 'gnutls_ia_permute_inner_secret',
+           'gnutls_rehandshake',
+           'gnutls_x509_crt_set_subject_alternative_name',
+           'gnutls_psk_set_server_credentials_file',
+           'gnutls_dh_set_prime_bits', 'gnutls_priority_deinit',
+           'gnutls_x509_crt_set_version',
+           'gnutls_dh_params_export_pkcs3', 'gnutls_x509_crq_deinit',
+           'gnutls_x509_crt_get_fingerprint',
+           'gnutls_extra_check_version',
+           'gnutls_srp_allocate_client_credentials',
+           'gnutls_x509_crl_get_issuer_dn_by_oid',
+           'gnutls_pkcs7_get_crl_raw',
+           'gnutls_x509_crt_set_expiration_time',
+           'gnutls_compression_set_priority',
+           'gnutls_openpgp_crt_get_subkey_count',
+           'gnutls_openpgp_crt_get_key_usage',
+           'gnutls_ia_allocate_server_credentials',
+           'gnutls_ia_free_server_credentials',
+           'gnutls_transport_set_lowat',
+           'gnutls_x509_crt_set_crl_dist_points',
+           'gnutls_compression_list',
+           'gnutls_x509_privkey_import_pkcs8',
+           'gnutls_session_enable_compatibility_mode',
+           'gnutls_x509_crq_set_challenge_password',
+           'gnutls_strerror', 'gnutls_x509_crt_get_dn',
+           'gnutls_x509_crl_init',
+           'gnutls_certificate_set_verify_flags',
+           'gnutls_psk_free_server_credentials',
+           'gnutls_openpgp_privkey_get_subkey_idx',
+           'gnutls_ia_set_client_avp_function',
+           'gnutls_openpgp_crt_get_subkey_creation_time',
+           'gnutls_compression_get_name', 'gnutls_openpgp_crt_init',
+           'gnutls_x509_crq_get_dn_by_oid',
+           'gnutls_openpgp_privkey_get_pk_algorithm',
+           'gnutls_certificate_set_x509_key_file',
+           'gnutls_openpgp_crt_get_key_id',
+           'gnutls_set_default_export_priority',
+           'gnutls_x509_crl_print', 'gnutls_rsa_export_get_pubkey',
+           'gnutls_x509_crq_set_key',
+           'gnutls_x509_crt_get_signature_algorithm',
+           'gnutls_openpgp_crt_get_name',
+           'gnutls_openpgp_crt_get_subkey_pk_dsa_raw',
+           'gnutls_x509_crl_get_issuer_dn',
+           'gnutls_rsa_params_generate2',
+           'gnutls_handshake_set_private_extensions',
+           'gnutls_psk_set_client_credentials',
+           'gnutls_server_name_get',
+           'gnutls_openpgp_crt_get_subkey_usage',
+           'gnutls_rsa_params_import_pkcs1', 'gnutls_session_set_ptr',
+           'gnutls_bye', 'gnutls_auth_client_get_type',
+           'gnutls_openpgp_privkey_export_subkey_rsa_raw',
+           'gnutls_x509_crt_get_proxy', 'gnutls_kx_get_id',
+           'gnutls_session_get_data', 'gnutls_x509_crt_list_import',
+           'gnutls_pkcs7_get_crt_raw',
+           'gnutls_openpgp_privkey_get_subkey_id',
+           'gnutls_psk_set_server_credentials_function',
+           'gnutls_srp_set_server_credentials_function',
+           'gnutls_ia_verify_endphase', 'gnutls_error_is_fatal',
+           'gnutls_x509_crt_verify_data',
+           'gnutls_psk_netconf_derive_key',
+           'gnutls_certificate_server_set_request',
+           'gnutls_openpgp_privkey_get_fingerprint',
+           'gnutls_dh_params_export_raw',
+           'gnutls_protocol_set_priority',
+           'gnutls_psk_set_client_credentials_function',
+           'gnutls_set_default_priority', 'gnutls_hex2bin',
+           'gnutls_dh_params_cpy', 'gnutls_ia_handshake',
+           'gnutls_handshake_get_last_in', 'gnutls_protocol_get_id',
+           'gnutls_x509_crq_get_attribute_by_oid',
+           'gnutls_certificate_get_ours',
+           'gnutls_anon_free_server_credentials',
+           'gnutls_x509_crt_verify', 'gnutls_session_set_data',
+           'gnutls_certificate_allocate_credentials',
+           'gnutls_x509_crt_set_serial', 'gnutls_openpgp_send_cert',
+           'gnutls_certificate_set_x509_key_mem',
+           'gnutls_x509_crt_get_extension_by_oid',
+           'gnutls_session_get_server_random',
+           'gnutls_openpgp_privkey_get_revoked_status',
+           'gnutls_dh_params_deinit', 'gnutls_mac_get_id',
+           'gnutls_x509_crt_get_signature', 'gnutls_x509_crq_sign2',
+           'gnutls_global_deinit', 'gnutls_sign_algorithm_get_name',
+           'gnutls_anon_allocate_client_credentials',
+           'gnutls_x509_crt_export',
+           'gnutls_certificate_get_x509_cas',
+           'gnutls_dh_params_import_pkcs3', 'gnutls_hex_decode',
+           'gnutls_openpgp_crt_export',
+           'gnutls_psk_set_params_function',
+           'gnutls_x509_crt_check_issuer',
+           'gnutls_x509_crl_set_next_update',
+           'gnutls_ia_allocate_client_credentials',
+           'gnutls_psk_client_get_hint',
+           'gnutls_certificate_send_x509_rdn_sequence',
+           'gnutls_alert_send_appropriate',
+           'gnutls_anon_set_server_dh_params',
+           'gnutls_openpgp_crt_get_revoked_status',
+           'gnutls_openpgp_crt_get_subkey_pk_algorithm',
+           'gnutls_openpgp_privkey_get_preferred_key_id',
+           'gnutls_x509_privkey_sign_hash', 'gnutls_x509_crl_export',
+           'gnutls_openpgp_privkey_deinit',
+           'gnutls_pkcs7_set_crt_raw', 'gnutls_auth_get_type',
+           'gnutls_certificate_get_openpgp_keyring',
+           'gnutls_openpgp_privkey_export_dsa_raw',
+           'gnutls_openpgp_crt_set_preferred_key_id',
+           'gnutls_srp_allocate_server_credentials',
+           'gnutls_dh_get_peers_public_bits',
+           'gnutls_certificate_set_x509_crl_mem',
+           'gnutls_x509_privkey_fix', 'gnutls_kx_get_name',
+           'gnutls_psk_set_server_params_function',
+           'gnutls_openpgp_crt_get_fingerprint',
+           'gnutls_openpgp_crt_get_subkey_expiration_time',
+           'gnutls_x509_dn_import',
+           'gnutls_x509_crt_get_issuer_dn_by_oid',
+           'gnutls_openpgp_crt_get_creation_time',
+           'gnutls_openpgp_crt_get_pk_rsa_raw',
+           'gnutls_session_is_resumed', 'gnutls_x509_crt_set_proxy',
+           'gnutls_certificate_set_openpgp_key_file',
+           'gnutls_certificate_set_x509_trust_mem',
+           'gnutls_openpgp_crt_get_auth_subkey',
+           'gnutls_x509_privkey_verify_data', 'gnutls_deinit',
+           'gnutls_x509_crt_import',
+           'gnutls_db_set_retrieve_function',
+           'gnutls_x509_privkey_import',
+           'gnutls_certificate_set_x509_simple_pkcs12_file',
+           'gnutls_global_set_log_function',
+           'gnutls_db_set_cache_expiration',
+           'gnutls_x509_crt_set_ca_status',
+           'gnutls_x509_crl_get_next_update',
+           'gnutls_x509_crl_verify', 'gnutls_pem_base64_decode_alloc',
+           'gnutls_x509_crt_get_key_usage',
+           'gnutls_x509_crt_get_crl_dist_points']
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/library/types.py b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/library/types.py
new file mode 100644
index 0000000..0d878bb
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/library/types.py
@@ -0,0 +1,248 @@
+from ctypes import *
+
+STRING = c_char_p
+from gnutls.library.constants import gnutls_cipher_algorithm_t
+from gnutls.library.constants import gnutls_certificate_print_formats
+from gnutls.library.constants import gnutls_params_type_t
+from gnutls.library.constants import gnutls_psk_key_flags
+from gnutls.library.constants import gnutls_x509_subject_alt_name_t
+from gnutls.library.constants import gnutls_certificate_type_t
+from gnutls.library.constants import gnutls_pk_algorithm_t
+from gnutls.library.constants import gnutls_openpgp_crt_fmt
+from gnutls.library.constants import gnutls_certificate_import_flags
+from gnutls.library.constants import gnutls_certificate_verify_flags
+from gnutls.library.constants import gnutls_pkcs_encrypt_flags_t
+
+
+class gnutls_session_int(Structure):
+    pass
+gnutls_session_t = POINTER(gnutls_session_int)
+size_t = c_size_t
+gnutls_ia_avp_func = CFUNCTYPE(c_int, gnutls_session_t, c_void_p, STRING, size_t, POINTER(STRING), POINTER(size_t))
+class gnutls_ia_server_credentials_st(Structure):
+    pass
+gnutls_ia_server_credentials_st._fields_ = [
+]
+gnutls_ia_server_credentials_t = POINTER(gnutls_ia_server_credentials_st)
+class gnutls_ia_client_credentials_st(Structure):
+    pass
+gnutls_ia_client_credentials_st._fields_ = [
+]
+gnutls_ia_client_credentials_t = POINTER(gnutls_ia_client_credentials_st)
+gnutls_certificate_print_formats_t = gnutls_certificate_print_formats
+gnutls_transport_ptr_t = c_void_p
+gnutls_session_int._fields_ = [
+]
+class gnutls_dh_params_int(Structure):
+    pass
+gnutls_dh_params_int._fields_ = [
+]
+gnutls_dh_params_t = POINTER(gnutls_dh_params_int)
+class gnutls_x509_privkey_int(Structure):
+    pass
+gnutls_x509_privkey_int._fields_ = [
+]
+gnutls_rsa_params_t = POINTER(gnutls_x509_privkey_int)
+class gnutls_priority_st(Structure):
+    pass
+gnutls_priority_st._fields_ = [
+]
+gnutls_priority_t = POINTER(gnutls_priority_st)
+class gnutls_datum_t(Structure):
+    pass
+gnutls_datum_t._fields_ = [
+    ('data', POINTER(c_ubyte)),
+    ('size', c_uint),
+]
+class gnutls_params_st(Structure):
+    pass
+class params(Union):
+    pass
+params._fields_ = [
+    ('dh', gnutls_dh_params_t),
+    ('rsa_export', gnutls_rsa_params_t),
+]
+gnutls_params_st._fields_ = [
+    ('type', gnutls_params_type_t),
+    ('params', params),
+    ('deinit', c_int),
+]
+gnutls_params_function = CFUNCTYPE(c_int, gnutls_session_t, gnutls_params_type_t, POINTER(gnutls_params_st))
+gnutls_oprfi_callback_func = CFUNCTYPE(c_int, gnutls_session_t, c_void_p, size_t, POINTER(c_ubyte), POINTER(c_ubyte))
+gnutls_db_store_func = CFUNCTYPE(c_int, c_void_p, gnutls_datum_t, gnutls_datum_t)
+gnutls_db_remove_func = CFUNCTYPE(c_int, c_void_p, gnutls_datum_t)
+gnutls_db_retr_func = CFUNCTYPE(gnutls_datum_t, c_void_p, gnutls_datum_t)
+gnutls_handshake_post_client_hello_func = CFUNCTYPE(c_int, gnutls_session_t)
+class gnutls_certificate_credentials_st(Structure):
+    pass
+gnutls_certificate_credentials_st._fields_ = [
+]
+gnutls_certificate_credentials_t = POINTER(gnutls_certificate_credentials_st)
+gnutls_certificate_server_credentials = gnutls_certificate_credentials_t
+gnutls_certificate_client_credentials = gnutls_certificate_credentials_t
+class gnutls_anon_server_credentials_st(Structure):
+    pass
+gnutls_anon_server_credentials_st._fields_ = [
+]
+gnutls_anon_server_credentials_t = POINTER(gnutls_anon_server_credentials_st)
+class gnutls_anon_client_credentials_st(Structure):
+    pass
+gnutls_anon_client_credentials_st._fields_ = [
+]
+gnutls_anon_client_credentials_t = POINTER(gnutls_anon_client_credentials_st)
+gnutls_x509_privkey_t = POINTER(gnutls_x509_privkey_int)
+class gnutls_x509_crl_int(Structure):
+    pass
+gnutls_x509_crl_int._fields_ = [
+]
+gnutls_x509_crl_t = POINTER(gnutls_x509_crl_int)
+class gnutls_x509_crt_int(Structure):
+    pass
+gnutls_x509_crt_int._fields_ = [
+]
+gnutls_x509_crt_t = POINTER(gnutls_x509_crt_int)
+class gnutls_openpgp_keyring_int(Structure):
+    pass
+gnutls_openpgp_keyring_int._fields_ = [
+]
+gnutls_openpgp_keyring_t = POINTER(gnutls_openpgp_keyring_int)
+gnutls_alloc_function = CFUNCTYPE(c_void_p, size_t)
+gnutls_calloc_function = CFUNCTYPE(c_void_p, size_t, size_t)
+gnutls_is_secure_function = CFUNCTYPE(c_int, c_void_p)
+gnutls_free_function = CFUNCTYPE(None, c_void_p)
+gnutls_realloc_function = CFUNCTYPE(c_void_p, c_void_p, size_t)
+gnutls_log_func = CFUNCTYPE(None, c_int, STRING)
+__ssize_t = c_long
+ssize_t = __ssize_t
+gnutls_pull_func = CFUNCTYPE(ssize_t, gnutls_transport_ptr_t, c_void_p, size_t)
+gnutls_push_func = CFUNCTYPE(ssize_t, gnutls_transport_ptr_t, c_void_p, size_t)
+class gnutls_srp_server_credentials_st(Structure):
+    pass
+gnutls_srp_server_credentials_st._fields_ = [
+]
+gnutls_srp_server_credentials_t = POINTER(gnutls_srp_server_credentials_st)
+class gnutls_srp_client_credentials_st(Structure):
+    pass
+gnutls_srp_client_credentials_st._fields_ = [
+]
+gnutls_srp_client_credentials_t = POINTER(gnutls_srp_client_credentials_st)
+gnutls_srp_server_credentials_function = CFUNCTYPE(c_int, gnutls_session_t, STRING, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t))
+gnutls_srp_client_credentials_function = CFUNCTYPE(c_int, gnutls_session_t, POINTER(STRING), POINTER(STRING))
+class gnutls_psk_server_credentials_st(Structure):
+    pass
+gnutls_psk_server_credentials_st._fields_ = [
+]
+gnutls_psk_server_credentials_t = POINTER(gnutls_psk_server_credentials_st)
+class gnutls_psk_client_credentials_st(Structure):
+    pass
+gnutls_psk_client_credentials_st._fields_ = [
+]
+gnutls_psk_client_credentials_t = POINTER(gnutls_psk_client_credentials_st)
+gnutls_psk_server_credentials_function = CFUNCTYPE(c_int, gnutls_session_t, STRING, POINTER(gnutls_datum_t))
+gnutls_psk_client_credentials_function = CFUNCTYPE(c_int, gnutls_session_t, POINTER(STRING), POINTER(gnutls_datum_t))
+class gnutls_openpgp_crt_int(Structure):
+    pass
+gnutls_openpgp_crt_int._fields_ = [
+]
+gnutls_openpgp_crt_t = POINTER(gnutls_openpgp_crt_int)
+class gnutls_openpgp_privkey_int(Structure):
+    pass
+gnutls_openpgp_privkey_int._fields_ = [
+]
+gnutls_openpgp_privkey_t = POINTER(gnutls_openpgp_privkey_int)
+class gnutls_retr_st(Structure):
+    pass
+class cert(Union):
+    pass
+cert._fields_ = [
+    ('x509', POINTER(gnutls_x509_crt_t)),
+    ('pgp', gnutls_openpgp_crt_t),
+]
+class key(Union):
+    pass
+key._fields_ = [
+    ('x509', gnutls_x509_privkey_t),
+    ('pgp', gnutls_openpgp_privkey_t),
+]
+gnutls_retr_st._fields_ = [
+    ('type', gnutls_certificate_type_t),
+    ('cert', cert),
+    ('ncerts', c_uint),
+    ('key', key),
+    ('deinit_all', c_uint),
+]
+gnutls_certificate_client_retrieve_function = CFUNCTYPE(c_int, gnutls_session_t, POINTER(gnutls_datum_t), c_int, POINTER(gnutls_pk_algorithm_t), c_int, POINTER(gnutls_retr_st))
+gnutls_certificate_server_retrieve_function = CFUNCTYPE(c_int, gnutls_session_t, POINTER(gnutls_retr_st))
+gnutls_sign_func = CFUNCTYPE(c_int, gnutls_session_t, c_void_p, gnutls_certificate_type_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t))
+gnutls_openpgp_crt_fmt_t = gnutls_openpgp_crt_fmt
+gnutls_openpgp_keyid_t = c_ubyte * 8
+gnutls_openpgp_recv_key_func = CFUNCTYPE(c_int, gnutls_session_t, POINTER(c_ubyte), c_uint, POINTER(gnutls_datum_t))
+gnutls_x509_dn_t = c_void_p
+class gnutls_x509_ava_st(Structure):
+    pass
+gnutls_x509_ava_st._fields_ = [
+    ('oid', gnutls_datum_t),
+    ('value', gnutls_datum_t),
+    ('value_tag', c_ulong),
+]
+class gnutls_pkcs7_int(Structure):
+    pass
+gnutls_pkcs7_int._fields_ = [
+]
+gnutls_pkcs7_t = POINTER(gnutls_pkcs7_int)
+class gnutls_x509_crq_int(Structure):
+    pass
+gnutls_x509_crq_int._fields_ = [
+]
+gnutls_x509_crq_t = POINTER(gnutls_x509_crq_int)
+__all__ = ['key', 'gnutls_certificate_print_formats_t',
+           'gnutls_session_int', 'gnutls_srp_server_credentials_st',
+           'gnutls_oprfi_callback_func', '__ssize_t',
+           'gnutls_transport_ptr_t', 'gnutls_pkcs7_int',
+           'gnutls_psk_client_credentials_st', 'gnutls_priority_t',
+           'gnutls_certificate_credentials_st',
+           'gnutls_psk_server_credentials_t', 'gnutls_x509_crt_t',
+           'gnutls_x509_privkey_t', 'gnutls_openpgp_keyring_t',
+           'gnutls_x509_privkey_int', 'gnutls_push_func',
+           'gnutls_x509_crq_int', 'gnutls_psk_server_credentials_st',
+           'gnutls_openpgp_crt_t',
+           'gnutls_certificate_client_credentials', 'size_t',
+           'gnutls_ia_avp_func', 'gnutls_params_st',
+           'gnutls_anon_client_credentials_t', 'gnutls_dh_params_t',
+           'gnutls_anon_client_credentials_st', 'gnutls_sign_func',
+           'gnutls_srp_server_credentials_function', 'cert',
+           'gnutls_x509_crt_int', 'gnutls_realloc_function',
+           'gnutls_srp_client_credentials_function',
+           'gnutls_ia_server_credentials_st',
+           'gnutls_srp_client_credentials_st',
+           'gnutls_calloc_function', 'gnutls_priority_st',
+           'gnutls_x509_crl_int', 'params',
+           'gnutls_certificate_server_credentials',
+           'gnutls_handshake_post_client_hello_func',
+           'gnutls_session_t',
+           'gnutls_psk_client_credentials_function',
+           'gnutls_openpgp_privkey_int', 'gnutls_retr_st',
+           'gnutls_is_secure_function', 'gnutls_db_retr_func',
+           'gnutls_openpgp_keyring_int',
+           'gnutls_srp_client_credentials_t',
+           'gnutls_psk_client_credentials_t',
+           'gnutls_anon_server_credentials_t', 'gnutls_dh_params_int',
+           'gnutls_datum_t', 'gnutls_openpgp_crt_fmt_t',
+           'gnutls_ia_server_credentials_t', 'gnutls_x509_ava_st',
+           'gnutls_alloc_function',
+           'gnutls_psk_server_credentials_function',
+           'gnutls_anon_server_credentials_st',
+           'gnutls_params_function',
+           'gnutls_srp_server_credentials_t',
+           'gnutls_openpgp_crt_int', 'gnutls_log_func',
+           'gnutls_rsa_params_t',
+           'gnutls_certificate_server_retrieve_function',
+           'gnutls_x509_dn_t', 'gnutls_x509_crq_t',
+           'gnutls_pull_func', 'gnutls_db_remove_func',
+           'gnutls_ia_client_credentials_t',
+           'gnutls_certificate_credentials_t', 'gnutls_pkcs7_t',
+           'gnutls_ia_client_credentials_st', 'gnutls_db_store_func',
+           'ssize_t', 'gnutls_openpgp_recv_key_func',
+           'gnutls_openpgp_privkey_t', 'gnutls_openpgp_keyid_t',
+           'gnutls_free_function', 'gnutls_x509_crl_t',
+           'gnutls_certificate_client_retrieve_function']
diff --git a/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/validators.py b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/validators.py
new file mode 100644
index 0000000..11c29c3
--- /dev/null
+++ b/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/validators.py
@@ -0,0 +1,286 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS data validators"""
+
+__all__ = ['function_args', 'method_args', 'none', 'ignore', 'list_of', 'one_of', 'ProtocolListValidator', 
+           'KeyExchangeListValidator', 'CipherListValidator', 'MACListValidator', 'CompressionListValidator']
+
+from gnutls.constants import *
+
+#
+# Priority list validators. They take a tuple or list on input and output a
+# tuple with the same elements if they check valid, else raise an exception.
+#
+
+class ProtocolListValidator(tuple):
+    _protocols = set((PROTO_TLS1_1, PROTO_TLS1_0, PROTO_SSL3))
+
+    def __new__(cls, arg):
+        if not isinstance(arg, (tuple, list)):
+            raise TypeError("Argument must be a tuple or list")
+        if not arg:
+            raise ValueError("Protocol list cannot be empty")
+        if not cls._protocols.issuperset(set(arg)):
+            raise ValueError("Got invalid protocol")
+        return tuple.__new__(cls, arg)
+
+
+class KeyExchangeListValidator(tuple):
+    _algorithms = set((KX_RSA, KX_DHE_DSS, KX_DHE_RSA, KX_RSA_EXPORT, KX_ANON_DH))
+
+    def __new__(cls, arg):
+        if not isinstance(arg, (tuple, list)):
+            raise TypeError("Argument must be a tuple or list")
+        if not arg:
+            raise ValueError("Key exchange algorithm list cannot be empty")
+        if not cls._algorithms.issuperset(set(arg)):
+            raise ValueError("Got invalid key exchange algorithm")
+        return tuple.__new__(cls, arg)
+
+
+class CipherListValidator(tuple):
+    _ciphers = set((CIPHER_AES_128_CBC, CIPHER_3DES_CBC, CIPHER_ARCFOUR_128, CIPHER_AES_256_CBC, CIPHER_DES_CBC))
+
+    def __new__(cls, arg):
+        if not isinstance(arg, (tuple, list)):
+            raise TypeError("Argument must be a tuple or list")
+        if not arg:
+            raise ValueError("Cipher list cannot be empty")
+        if not cls._ciphers.issuperset(set(arg)):
+            raise ValueError("Got invalid cipher")
+        return tuple.__new__(cls, arg)
+
+
+class MACListValidator(tuple):
+    _algorithms = set((MAC_SHA1, MAC_MD5, MAC_RMD160))
+
+    def __new__(cls, arg):
+        if not isinstance(arg, (tuple, list)):
+            raise TypeError("Argument must be a tuple or list")
+        if not arg:
+            raise ValueError("MAC algorithm list cannot be empty")
+        if not cls._algorithms.issuperset(set(arg)):
+            raise ValueError("Got invalid MAC algorithm")
+        return tuple.__new__(cls, arg)
+
+
+class CompressionListValidator(tuple):
+    _compressions = set((COMP_DEFLATE, COMP_LZO, COMP_NULL))
+
+    def __new__(cls, arg):
+        if not isinstance(arg, (tuple, list)):
+            raise TypeError("Argument must be a tuple or list")
+        if not arg:
+            raise ValueError("Compression list cannot be empty")
+        if not cls._compressions.issuperset(set(arg)):
+            raise ValueError("Got invalid compression")
+        return tuple.__new__(cls, arg)
+
+#
+# Argument validating
+#
+
+# Helper functions (internal use)
+#
+
+def isclass(obj):
+    return hasattr(obj, '__bases__') or isinstance(obj, type)
+
+# Internal validator classes
+#
+
+class Validator(object):
+    _registered = []
+    def __init__(self, typ):
+        self.type = typ
+    def check(self, value):
+        return False
+    @staticmethod
+    def can_validate(typ):
+        return False
+    @classmethod
+    def register(cls, validator):
+        cls._registered.append(validator)
+    @classmethod
+    def get(cls, typ):
+        for validator in cls._registered:
+            if validator.can_validate(typ):
+                return validator(typ)
+        else:
+            return None
+    @staticmethod
+    def join_names(names):
+        if type(names) in (tuple, list):
+            if len(names) <= 2:
+                return ' or '.join(names)
+            else:
+                return ' or '.join((', '.join(names[:-1]), names[-1]))
+        else:
+            return names
+    def _type_names(self):
+        if isinstance(self.type, tuple):
+            return self.join_names([t.__name__.replace('NoneType', 'None') for t in self.type])
+        else:
+            return self.type.__name__.replace('NoneType', 'None')
+    @property
+    def name(self):
+        name = self._type_names()
+        if name.startswith('None'):
+            prefix = ''
+        elif name[0] in ('a', 'e', 'i', 'o', 'u'):
+            prefix = 'an '
+        else:
+            prefix = 'a '
+        return prefix + name
+
+class IgnoringValidator(Validator):
+    def __init__(self, typ):
+        self.type = none
+    def check(self, value):
+        return True
+    @staticmethod
+    def can_validate(obj):
+        return obj is ignore
+
+class TypeValidator(Validator):
+    def check(self, value):
+        return isinstance(value, self.type)
+    @staticmethod
+    def can_validate(obj):
+        return isclass(obj)
+
+class MultiTypeValidator(TypeValidator):
+    @staticmethod
+    def can_validate(obj):
+        return isinstance(obj, tuple) and not filter(lambda x: not isclass(x), obj)
+
+class OneOfValidator(Validator):
+    def __init__(self, typ):
+        self.type = typ.type
+    def check(self, value):
+        return value in self.type
+    @staticmethod
+    def can_validate(obj):
+        return isinstance(obj, one_of)
+    @property
+    def name(self):
+        return 'one of %s' % self.join_names(["`%r'" % e for e in self.type])
+
+class ListOfValidator(Validator):
+    def __init__(self, typ):
+        self.type = typ.type
+    def check(self, value):
+        return isinstance(value, (tuple, list)) and not filter(lambda x: not isinstance(x, self.type), value)
+    @staticmethod
+    def can_validate(obj):
+        return isinstance(obj, list_of)
+    @property
+    def name(self):
+        return 'a list of %s' % self._type_names()
+
+class ComplexValidator(Validator):
+    def __init__(self, typ):
+        self.type = [Validator.get(x) for x in typ]
+    def check(self, value):
+        return bool(sum(t.check(value) for t in self.type))
+    @staticmethod
+    def can_validate(obj):
+        return isinstance(obj, tuple) and not filter(lambda x: Validator.get(x) is None, obj)
+    @property
+    def name(self):
+        return self.join_names([x.name for x in self.type])
+
+Validator.register(IgnoringValidator)
+Validator.register(TypeValidator)
+Validator.register(MultiTypeValidator)
+Validator.register(OneOfValidator)
+Validator.register(ListOfValidator)
+Validator.register(ComplexValidator)
+
+
+# Extra types to be used with argument validating decorators
+#
+
+none = type(None)
+
+class one_of(object):
+    def __init__(self, *args):
+        if len(args) < 2:
+            raise ValueError("one_of must have at least 2 arguments")
+        self.type = args
+
+class list_of(object):
+    def __init__(self, *args):
+        if filter(lambda x: not isclass(x), args):
+            raise TypeError("list_of arguments must be types")
+        if len(args) == 1:
+            self.type = args[0]
+        else:
+            self.type = args
+
+ignore = type('ignore', (), {})()
+
+
+# Helpers for writing well behaved decorators
+#
+
+def decorator(func):
+    """A syntactic marker with no other effect than improving readability."""
+    return func
+
+def preserve_signature(func):
+    """Preserve the original function signature and attributes in decorator wrappers."""
+    from inspect import getargspec, formatargspec
+    from gnutls.constants import GNUTLSConstant
+    constants  = [c for c in (getargspec(func)[3] or []) if isinstance(c, GNUTLSConstant)]
+    signature  = formatargspec(*getargspec(func))[1:-1]
+    parameters = formatargspec(*getargspec(func), **{'formatvalue': lambda value: ""})[1:-1]
+    def fix_signature(wrapper):
+        if constants:
+            ## import the required GNUTLSConstants used as function default arguments
+            code = "from gnutls.constants import %s\n" % ', '.join(c.name for c in constants)
+            exec code in locals(), locals()
+        code = "def %s(%s): return wrapper(%s)\nnew_wrapper = %s\n" % (func.__name__, signature, parameters, func.__name__)
+        exec code in locals(), locals()
+        new_wrapper.__name__ = func.__name__
+        new_wrapper.__doc__ = func.__doc__
+        new_wrapper.__module__ = func.__module__
+        new_wrapper.__dict__.update(func.__dict__)
+        return new_wrapper
+    return fix_signature
+
+# Argument validating decorators
+#
+
+def _callable_args(*args, **kwargs):
+    """Internal function used by argument checking decorators"""
+    start = kwargs.get('_start', 0)
+    validators = []
+    for i, arg in enumerate(args):
+        validator = Validator.get(arg)
+        if validator is None:
+            raise TypeError("unsupported type `%r' at position %d for argument checking decorator" % (arg, i+1))
+        validators.append(validator)
+    def check_args_decorator(func):
+        @preserve_signature(func)
+        def check_args(*func_args):
+            pos = start
+            for validator in validators:
+                if not validator.check(func_args[pos]):
+                    raise TypeError("argument %d must be %s" % (pos+1-start, validator.name))
+                pos += 1
+            return func(*func_args)
+        return check_args
+    return check_args_decorator
+
+@decorator
+def method_args(*args):
+    """Check class or instance method arguments"""
+    return _callable_args(*args, **{'_start': 1})
+
+@decorator
+def function_args(*args):
+    """Check functions or staticmethod arguments"""
+    return _callable_args(*args)
+
diff --git a/gnutls-1.1.9/build/temp.linux-x86_64-2.5/gnutls/library/_gnutls_init.o b/gnutls-1.1.9/build/temp.linux-x86_64-2.5/gnutls/library/_gnutls_init.o
new file mode 100644
index 0000000..f304de0
--- /dev/null
+++ b/gnutls-1.1.9/build/temp.linux-x86_64-2.5/gnutls/library/_gnutls_init.o
diff --git a/gnutls-1.1.9/build/temp.linux-x86_64-2.6/gnutls/library/_gnutls_init.o b/gnutls-1.1.9/build/temp.linux-x86_64-2.6/gnutls/library/_gnutls_init.o
new file mode 100644
index 0000000..b60f55f
--- /dev/null
+++ b/gnutls-1.1.9/build/temp.linux-x86_64-2.6/gnutls/library/_gnutls_init.o
diff --git a/gnutls-1.1.9/build_inplace b/gnutls-1.1.9/build_inplace
new file mode 100755
index 0000000..06748a0
--- /dev/null
+++ b/gnutls-1.1.9/build_inplace
@@ -0,0 +1,5 @@
+#!/bin/sh
+
+python setup.py build_ext --inplace
+python setup.py clean
+
diff --git a/gnutls-1.1.9/debian/README.Debian b/gnutls-1.1.9/debian/README.Debian
new file mode 100644
index 0000000..184ec24
--- /dev/null
+++ b/gnutls-1.1.9/debian/README.Debian
@@ -0,0 +1,6 @@
+python-gnutls for Debian
+------------------------
+
+<possible notes regarding this package - if none, delete this file>
+
+ -- Kristina Clair <kclair@leap.se>  Wed, 03 Oct 2012 11:29:13 -0700
diff --git a/gnutls-1.1.9/debian/README.source b/gnutls-1.1.9/debian/README.source
new file mode 100644
index 0000000..fc78539
--- /dev/null
+++ b/gnutls-1.1.9/debian/README.source
@@ -0,0 +1,9 @@
+python-gnutls for Debian
+------------------------
+
+<this file describes information about the source package, see Debian policy
+manual section 4.14. You WILL either need to modify or delete this file>
+
+
+
+
diff --git a/gnutls-1.1.9/debian/changelog b/gnutls-1.1.9/debian/changelog
new file mode 100644
index 0000000..50a4d11
--- /dev/null
+++ b/gnutls-1.1.9/debian/changelog
@@ -0,0 +1,5 @@
+python-gnutls (1.1.9-1) unstable; urgency=low
+
+  * Initial release (Closes: #nnnn)  <nnnn is the bug number of your ITP>
+
+ -- Kristina Clair <kclair@leap.se>  Wed, 03 Oct 2012 11:29:13 -0700
diff --git a/gnutls-1.1.9/debian/compat b/gnutls-1.1.9/debian/compat
new file mode 100644
index 0000000..7f8f011
--- /dev/null
+++ b/gnutls-1.1.9/debian/compat
@@ -0,0 +1 @@
+7
diff --git a/gnutls-1.1.9/debian/control b/gnutls-1.1.9/debian/control
new file mode 100644
index 0000000..0153e6b
--- /dev/null
+++ b/gnutls-1.1.9/debian/control
@@ -0,0 +1,25 @@
+Source: python-gnutls
+Section: python 
+Priority: optional 
+Maintainer: Kristina Clair <kclair@leap.se>
+Build-Depends: cdbs (>= 0.4.47), debhelper (>= 5.0.42), python-all-dev (>= 2.5), python-support, libgnutls-dev (>= 2.4.1) 
+Standards-Version: 3.8.4
+Homepage: http://pypi.python.org/pypi/python-gnutls/1.1.9 
+
+Package: python-gnutls
+Architecture: any
+Depends: ${python:Depends}, ${misc:Depends}, ${shlibs:Depends}, libgnutls26 (>= 2.4.1)
+Provides: ${python:Provides}
+Description: Python wrapper for the GNUTLS library
+ This package provides a high level object oriented wrapper around
+ libgnutls, as well as low level bindings to the GNUTLS types and
+ functions via ctypes. The high level wrapper hides the details of
+ accessing the GNUTLS library via ctypes behind a set of classes
+ that encapsulate GNUTLS sessions, certificates and credentials and
+ expose them to Python applications using a simple API.
+ .
+ The package also includes a Twisted interface that has seamless
+ intergration with Twisted, providing connectTLS and listenTLS
+ methods on the Twisted reactor once imported (the methods are
+ automatically attached to the reactor by simply importing the
+ GNUTLS Twisted interface module).
diff --git a/gnutls-1.1.9/debian/copyright b/gnutls-1.1.9/debian/copyright
new file mode 100644
index 0000000..f9150bb
--- /dev/null
+++ b/gnutls-1.1.9/debian/copyright
@@ -0,0 +1,43 @@
+This work was packaged for Debian by:
+
+    k clair <kclair@leap.se> on Wed, 03 Oct 2012 11:04:26 -0700
+
+It was downloaded from:
+
+    http://pypi.python.org/pypi/python-gnutls/1.1.9 
+
+Upstream Author(s):
+
+    AG Projects
+    Dan Pascu
+    Mircea Amarascu
+
+Copyright:
+
+    Copyright (C) 2006-2007 AG Projects
+    Dan Pascu
+    Mircea Amarascu
+
+License:
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This package is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+On Debian systems, the complete text of the GNU General
+Public License version 3 can be found in "/usr/share/common-licenses/GPL-3".
+
+The Debian packaging is:
+
+    Copyright (C) 2012 k clair <kclair@leap.se>
+
+    and is licensed under the GPL version 3, see above.
diff --git a/gnutls-1.1.9/debian/docs b/gnutls-1.1.9/debian/docs
new file mode 100644
index 0000000..e845566
--- /dev/null
+++ b/gnutls-1.1.9/debian/docs
@@ -0,0 +1 @@
+README
diff --git a/gnutls-1.1.9/debian/emacsen-install.ex b/gnutls-1.1.9/debian/emacsen-install.ex
new file mode 100644
index 0000000..11c7a42
--- /dev/null
+++ b/gnutls-1.1.9/debian/emacsen-install.ex
@@ -0,0 +1,45 @@
+#! /bin/sh -e
+# /usr/lib/emacsen-common/packages/install/python-gnutls
+
+# Written by Jim Van Zandt <jrv@debian.org>, borrowing heavily
+# from the install scripts for gettext by Santiago Vila
+# <sanvila@ctv.es> and octave by Dirk Eddelbuettel <edd@debian.org>.
+
+FLAVOR=$1
+PACKAGE=python-gnutls
+
+if [ ${FLAVOR} = emacs ]; then exit 0; fi
+
+echo install/${PACKAGE}: Handling install for emacsen flavor ${FLAVOR}
+
+#FLAVORTEST=`echo $FLAVOR | cut -c-6`
+#if [ ${FLAVORTEST} = xemacs ] ; then
+#    SITEFLAG="-no-site-file"
+#else
+#    SITEFLAG="--no-site-file"
+#fi
+FLAGS="${SITEFLAG} -q -batch -l path.el -f batch-byte-compile"
+
+ELDIR=/usr/share/emacs/site-lisp/${PACKAGE}
+ELCDIR=/usr/share/${FLAVOR}/site-lisp/${PACKAGE}
+
+# Install-info-altdir does not actually exist.
+# Maybe somebody will write it.
+if test -x /usr/sbin/install-info-altdir; then
+    echo install/${PACKAGE}: install Info links for ${FLAVOR}
+    install-info-altdir --quiet --section "" "" --dirname=${FLAVOR} /usr/share/info/${PACKAGE}.info.gz
+fi
+
+install -m 755 -d ${ELCDIR}
+cd ${ELDIR}
+FILES=`echo *.el`
+cp ${FILES} ${ELCDIR}
+cd ${ELCDIR}
+
+cat << EOF > path.el
+(setq load-path (cons "." load-path) byte-compile-warnings nil)
+EOF
+${FLAVOR} ${FLAGS} ${FILES}
+rm -f *.el path.el
+
+exit 0
diff --git a/gnutls-1.1.9/debian/emacsen-remove.ex b/gnutls-1.1.9/debian/emacsen-remove.ex
new file mode 100644
index 0000000..2599e78
--- /dev/null
+++ b/gnutls-1.1.9/debian/emacsen-remove.ex
@@ -0,0 +1,15 @@
+#!/bin/sh -e
+# /usr/lib/emacsen-common/packages/remove/python-gnutls
+
+FLAVOR=$1
+PACKAGE=python-gnutls
+
+if [ ${FLAVOR} != emacs ]; then
+    if test -x /usr/sbin/install-info-altdir; then
+        echo remove/${PACKAGE}: removing Info links for ${FLAVOR}
+        install-info-altdir --quiet --remove --dirname=${FLAVOR} /usr/share/info/python-gnutls.info.gz
+    fi
+
+    echo remove/${PACKAGE}: purging byte-compiled files for ${FLAVOR}
+    rm -rf /usr/share/${FLAVOR}/site-lisp/${PACKAGE}
+fi
diff --git a/gnutls-1.1.9/debian/emacsen-startup.ex b/gnutls-1.1.9/debian/emacsen-startup.ex
new file mode 100644
index 0000000..ab381f9
--- /dev/null
+++ b/gnutls-1.1.9/debian/emacsen-startup.ex
@@ -0,0 +1,25 @@
+;; -*-emacs-lisp-*-
+;;
+;; Emacs startup file, e.g.  /etc/emacs/site-start.d/50python-gnutls.el
+;; for the Debian python-gnutls package
+;;
+;; Originally contributed by Nils Naumann <naumann@unileoben.ac.at>
+;; Modified by Dirk Eddelbuettel <edd@debian.org>
+;; Adapted for dh-make by Jim Van Zandt <jrv@debian.org>
+
+;; The python-gnutls package follows the Debian/GNU Linux 'emacsen' policy and
+;; byte-compiles its elisp files for each 'emacs flavor' (emacs19,
+;; xemacs19, emacs20, xemacs20...).  The compiled code is then
+;; installed in a subdirectory of the respective site-lisp directory.
+;; We have to add this to the load-path:
+(let ((package-dir (concat "/usr/share/"
+                           (symbol-name flavor)
+                           "/site-lisp/python-gnutls")))
+;; If package-dir does not exist, the python-gnutls package must have
+;; removed but not purged, and we should skip the setup.
+  (when (file-directory-p package-dir)
+    (setq load-path (cons package-dir load-path))
+    (autoload 'python-gnutls-mode "python-gnutls-mode"
+      "Major mode for editing python-gnutls files." t)
+    (add-to-list 'auto-mode-alist '("\\.python-gnutls$" . python-gnutls-mode))))
+
diff --git a/gnutls-1.1.9/debian/files b/gnutls-1.1.9/debian/files
new file mode 100644
index 0000000..b48ceaa
--- /dev/null
+++ b/gnutls-1.1.9/debian/files
@@ -0,0 +1 @@
+python-gnutls_1.1.9-1_amd64.deb python optional
diff --git a/gnutls-1.1.9/debian/init.d.ex b/gnutls-1.1.9/debian/init.d.ex
new file mode 100644
index 0000000..188583f
--- /dev/null
+++ b/gnutls-1.1.9/debian/init.d.ex
@@ -0,0 +1,154 @@
+#!/bin/sh
+### BEGIN INIT INFO
+# Provides:          python-gnutls
+# Required-Start:    $network $local_fs
+# Required-Stop:
+# Default-Start:     2 3 4 5
+# Default-Stop:      0 1 6
+# Short-Description: <Enter a short description of the sortware>
+# Description:       <Enter a long description of the software>
+#                    <...>
+#                    <...>
+### END INIT INFO
+
+# Author: Kristina Clair <kclair@leap.se>
+
+# PATH should only include /usr/* if it runs after the mountnfs.sh script
+PATH=/sbin:/usr/sbin:/bin:/usr/bin
+DESC=python-gnutls             # Introduce a short description here
+NAME=python-gnutls             # Introduce the short server's name here
+DAEMON=/usr/sbin/python-gnutls # Introduce the server's location here
+DAEMON_ARGS=""             # Arguments to run the daemon with
+PIDFILE=/var/run/$NAME.pid
+SCRIPTNAME=/etc/init.d/$NAME
+
+# Exit if the package is not installed
+[ -x $DAEMON ] || exit 0
+
+# Read configuration variable file if it is present
+[ -r /etc/default/$NAME ] && . /etc/default/$NAME
+
+# Load the VERBOSE setting and other rcS variables
+. /lib/init/vars.sh
+
+# Define LSB log_* functions.
+# Depend on lsb-base (>= 3.0-6) to ensure that this file is present.
+. /lib/lsb/init-functions
+
+#
+# Function that starts the daemon/service
+#
+do_start()
+{
+	# Return
+	#   0 if daemon has been started
+	#   1 if daemon was already running
+	#   2 if daemon could not be started
+	start-stop-daemon --start --quiet --pidfile $PIDFILE --exec $DAEMON --test > /dev/null \
+		|| return 1
+	start-stop-daemon --start --quiet --pidfile $PIDFILE --exec $DAEMON -- \
+		$DAEMON_ARGS \
+		|| return 2
+	# Add code here, if necessary, that waits for the process to be ready
+	# to handle requests from services started subsequently which depend
+	# on this one.  As a last resort, sleep for some time.
+}
+
+#
+# Function that stops the daemon/service
+#
+do_stop()
+{
+	# Return
+	#   0 if daemon has been stopped
+	#   1 if daemon was already stopped
+	#   2 if daemon could not be stopped
+	#   other if a failure occurred
+	start-stop-daemon --stop --quiet --retry=TERM/30/KILL/5 --pidfile $PIDFILE --name $NAME
+	RETVAL="$?"
+	[ "$RETVAL" = 2 ] && return 2
+	# Wait for children to finish too if this is a daemon that forks
+	# and if the daemon is only ever run from this initscript.
+	# If the above conditions are not satisfied then add some other code
+	# that waits for the process to drop all resources that could be
+	# needed by services started subsequently.  A last resort is to
+	# sleep for some time.
+	start-stop-daemon --stop --quiet --oknodo --retry=0/30/KILL/5 --exec $DAEMON
+	[ "$?" = 2 ] && return 2
+	# Many daemons don't delete their pidfiles when they exit.
+	rm -f $PIDFILE
+	return "$RETVAL"
+}
+
+#
+# Function that sends a SIGHUP to the daemon/service
+#
+do_reload() {
+	#
+	# If the daemon can reload its configuration without
+	# restarting (for example, when it is sent a SIGHUP),
+	# then implement that here.
+	#
+	start-stop-daemon --stop --signal 1 --quiet --pidfile $PIDFILE --name $NAME
+	return 0
+}
+
+case "$1" in
+  start)
+    [ "$VERBOSE" != no ] && log_daemon_msg "Starting $DESC " "$NAME"
+    do_start
+    case "$?" in
+		0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
+		2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
+	esac
+  ;;
+  stop)
+	[ "$VERBOSE" != no ] && log_daemon_msg "Stopping $DESC" "$NAME"
+	do_stop
+	case "$?" in
+		0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
+		2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
+	esac
+	;;
+  status)
+       status_of_proc "$DAEMON" "$NAME" && exit 0 || exit $?
+       ;;
+  #reload|force-reload)
+	#
+	# If do_reload() is not implemented then leave this commented out
+	# and leave 'force-reload' as an alias for 'restart'.
+	#
+	#log_daemon_msg "Reloading $DESC" "$NAME"
+	#do_reload
+	#log_end_msg $?
+	#;;
+  restart|force-reload)
+	#
+	# If the "reload" option is implemented then remove the
+	# 'force-reload' alias
+	#
+	log_daemon_msg "Restarting $DESC" "$NAME"
+	do_stop
+	case "$?" in
+	  0|1)
+		do_start
+		case "$?" in
+			0) log_end_msg 0 ;;
+			1) log_end_msg 1 ;; # Old process is still running
+			*) log_end_msg 1 ;; # Failed to start
+		esac
+		;;
+	  *)
+	  	# Failed to stop
+		log_end_msg 1
+		;;
+	esac
+	;;
+  *)
+	#echo "Usage: $SCRIPTNAME {start|stop|restart|reload|force-reload}" >&2
+	echo "Usage: $SCRIPTNAME {start|stop|status|restart|force-reload}" >&2
+	exit 3
+	;;
+esac
+
+:
diff --git a/gnutls-1.1.9/debian/manpage.1.ex b/gnutls-1.1.9/debian/manpage.1.ex
new file mode 100644
index 0000000..6d190a5
--- /dev/null
+++ b/gnutls-1.1.9/debian/manpage.1.ex
@@ -0,0 +1,59 @@
+.\"                                      Hey, EMACS: -*- nroff -*-
+.\" First parameter, NAME, should be all caps
+.\" Second parameter, SECTION, should be 1-8, maybe w/ subsection
+.\" other parameters are allowed: see man(7), man(1)
+.TH PYTHON-GNUTLS SECTION "October  3, 2012"
+.\" Please adjust this date whenever revising the manpage.
+.\"
+.\" Some roff macros, for reference:
+.\" .nh        disable hyphenation
+.\" .hy        enable hyphenation
+.\" .ad l      left justify
+.\" .ad b      justify to both left and right margins
+.\" .nf        disable filling
+.\" .fi        enable filling
+.\" .br        insert line break
+.\" .sp <n>    insert n+1 empty lines
+.\" for manpage-specific macros, see man(7)
+.SH NAME
+python-gnutls \- program to do something
+.SH SYNOPSIS
+.B python-gnutls
+.RI [ options ] " files" ...
+.br
+.B bar
+.RI [ options ] " files" ...
+.SH DESCRIPTION
+This manual page documents briefly the
+.B python-gnutls
+and
+.B bar
+commands.
+.PP
+.\" TeX users may be more comfortable with the \fB<whatever>\fP and
+.\" \fI<whatever>\fP escape sequences to invode bold face and italics,
+.\" respectively.
+\fBpython-gnutls\fP is a program that...
+.SH OPTIONS
+These programs follow the usual GNU command line syntax, with long
+options starting with two dashes (`-').
+A summary of options is included below.
+For a complete description, see the Info files.
+.TP
+.B \-h, \-\-help
+Show summary of options.
+.TP
+.B \-v, \-\-version
+Show version of program.
+.SH SEE ALSO
+.BR bar (1),
+.BR baz (1).
+.br
+The programs are documented fully by
+.IR "The Rise and Fall of a Fooish Bar" ,
+available via the Info system.
+.SH AUTHOR
+python-gnutls was written by <upstream author>.
+.PP
+This manual page was written by Kristina Clair <kclair@leap.se>,
+for the Debian project (and may be used by others).
diff --git a/gnutls-1.1.9/debian/manpage.sgml.ex b/gnutls-1.1.9/debian/manpage.sgml.ex
new file mode 100644
index 0000000..5abe851
--- /dev/null
+++ b/gnutls-1.1.9/debian/manpage.sgml.ex
@@ -0,0 +1,154 @@
+<!doctype refentry PUBLIC "-//OASIS//DTD DocBook V4.1//EN" [
+
+<!-- Process this file with docbook-to-man to generate an nroff manual
+     page: `docbook-to-man manpage.sgml > manpage.1'.  You may view
+     the manual page with: `docbook-to-man manpage.sgml | nroff -man |
+     less'.  A typical entry in a Makefile or Makefile.am is:
+
+manpage.1: manpage.sgml
+	docbook-to-man $< > $@
+
+
+	The docbook-to-man binary is found in the docbook-to-man package.
+	Please remember that if you create the nroff version in one of the
+	debian/rules file targets (such as build), you will need to include
+	docbook-to-man in your Build-Depends control field.
+
+  -->
+
+  <!-- Fill in your name for FIRSTNAME and SURNAME. -->
+  <!ENTITY dhfirstname "<firstname>FIRSTNAME</firstname>">
+  <!ENTITY dhsurname   "<surname>SURNAME</surname>">
+  <!-- Please adjust the date whenever revising the manpage. -->
+  <!ENTITY dhdate      "<date>October  3, 2012</date>">
+  <!-- SECTION should be 1-8, maybe w/ subsection other parameters are
+       allowed: see man(7), man(1). -->
+  <!ENTITY dhsection   "<manvolnum>SECTION</manvolnum>">
+  <!ENTITY dhemail     "<email>kclair@leap.se</email>">
+  <!ENTITY dhusername  "Kristina Clair">
+  <!ENTITY dhucpackage "<refentrytitle>PYTHON-GNUTLS</refentrytitle>">
+  <!ENTITY dhpackage   "python-gnutls">
+
+  <!ENTITY debian      "<productname>Debian</productname>">
+  <!ENTITY gnu         "<acronym>GNU</acronym>">
+  <!ENTITY gpl         "&gnu; <acronym>GPL</acronym>">
+]>
+
+<refentry>
+  <refentryinfo>
+    <address>
+      &dhemail;
+    </address>
+    <author>
+      &dhfirstname;
+      &dhsurname;
+    </author>
+    <copyright>
+      <year>2003</year>
+      <holder>&dhusername;</holder>
+    </copyright>
+    &dhdate;
+  </refentryinfo>
+  <refmeta>
+    &dhucpackage;
+
+    &dhsection;
+  </refmeta>
+  <refnamediv>
+    <refname>&dhpackage;</refname>
+
+    <refpurpose>program to do something</refpurpose>
+  </refnamediv>
+  <refsynopsisdiv>
+    <cmdsynopsis>
+      <command>&dhpackage;</command>
+
+      <arg><option>-e <replaceable>this</replaceable></option></arg>
+
+      <arg><option>--example <replaceable>that</replaceable></option></arg>
+    </cmdsynopsis>
+  </refsynopsisdiv>
+  <refsect1>
+    <title>DESCRIPTION</title>
+
+    <para>This manual page documents briefly the
+      <command>&dhpackage;</command> and <command>bar</command>
+      commands.</para>
+
+    <para>This manual page was written for the &debian; distribution
+      because the original program does not have a manual page.
+      Instead, it has documentation in the &gnu;
+      <application>Info</application> format; see below.</para>
+
+    <para><command>&dhpackage;</command> is a program that...</para>
+
+  </refsect1>
+  <refsect1>
+    <title>OPTIONS</title>
+
+    <para>These programs follow the usual &gnu; command line syntax,
+      with long options starting with two dashes (`-').  A summary of
+      options is included below.  For a complete description, see the
+      <application>Info</application> files.</para>
+
+    <variablelist>
+      <varlistentry>
+        <term><option>-h</option>
+          <option>--help</option>
+        </term>
+        <listitem>
+          <para>Show summary of options.</para>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term><option>-v</option>
+          <option>--version</option>
+        </term>
+        <listitem>
+          <para>Show version of program.</para>
+        </listitem>
+      </varlistentry>
+    </variablelist>
+  </refsect1>
+  <refsect1>
+    <title>SEE ALSO</title>
+
+    <para>bar (1), baz (1).</para>
+
+    <para>The programs are documented fully by <citetitle>The Rise and
+      Fall of a Fooish Bar</citetitle> available via the
+      <application>Info</application> system.</para>
+  </refsect1>
+  <refsect1>
+    <title>AUTHOR</title>
+
+    <para>This manual page was written by &dhusername; &dhemail; for
+      the &debian; system (and may be used by others).  Permission is
+      granted to copy, distribute and/or modify this document under
+      the terms of the &gnu; General Public License, Version 2 any
+      later version published by the Free Software Foundation.
+    </para>
+    <para>
+      On Debian systems, the complete text of the GNU General Public
+      License can be found in /usr/share/common-licenses/GPL.
+    </para>
+
+  </refsect1>
+</refentry>
+
+<!-- Keep this comment at the end of the file
+Local variables:
+mode: sgml
+sgml-omittag:t
+sgml-shorttag:t
+sgml-minimize-attributes:nil
+sgml-always-quote-attributes:t
+sgml-indent-step:2
+sgml-indent-data:t
+sgml-parent-document:nil
+sgml-default-dtd-file:nil
+sgml-exposed-tags:nil
+sgml-local-catalogs:nil
+sgml-local-ecat-files:nil
+End:
+-->
diff --git a/gnutls-1.1.9/debian/manpage.xml.ex b/gnutls-1.1.9/debian/manpage.xml.ex
new file mode 100644
index 0000000..95b52f9
--- /dev/null
+++ b/gnutls-1.1.9/debian/manpage.xml.ex
@@ -0,0 +1,291 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN"
+"http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd" [
+
+<!--
+
+`xsltproc -''-nonet \
+          -''-param man.charmap.use.subset "0" \
+          -''-param make.year.ranges "1" \
+          -''-param make.single.year.ranges "1" \
+          /usr/share/xml/docbook/stylesheet/docbook-xsl/manpages/docbook.xsl \
+          manpage.xml'
+
+A manual page <package>.<section> will be generated. You may view the
+manual page with: nroff -man <package>.<section> | less'. A typical entry
+in a Makefile or Makefile.am is:
+
+DB2MAN = /usr/share/sgml/docbook/stylesheet/xsl/docbook-xsl/manpages/docbook.xsl
+XP     = xsltproc -''-nonet -''-param man.charmap.use.subset "0"
+
+manpage.1: manpage.xml
+        $(XP) $(DB2MAN) $<
+
+The xsltproc binary is found in the xsltproc package. The XSL files are in
+docbook-xsl. A description of the parameters you can use can be found in the
+docbook-xsl-doc-* packages. Please remember that if you create the nroff
+version in one of the debian/rules file targets (such as build), you will need
+to include xsltproc and docbook-xsl in your Build-Depends control field.
+Alternatively use the xmlto command/package. That will also automatically
+pull in xsltproc and docbook-xsl.
+
+Notes for using docbook2x: docbook2x-man does not automatically create the
+AUTHOR(S) and COPYRIGHT sections. In this case, please add them manually as
+<refsect1> ... </refsect1>.
+
+To disable the automatic creation of the AUTHOR(S) and COPYRIGHT sections
+read /usr/share/doc/docbook-xsl/doc/manpages/authors.html. This file can be
+found in the docbook-xsl-doc-html package.
+
+Validation can be done using: `xmllint -''-noout -''-valid manpage.xml`
+
+General documentation about man-pages and man-page-formatting:
+man(1), man(7), http://www.tldp.org/HOWTO/Man-Page/
+
+-->
+
+  <!-- Fill in your name for FIRSTNAME and SURNAME. -->
+  <!ENTITY dhfirstname "FIRSTNAME">
+  <!ENTITY dhsurname   "SURNAME">
+  <!-- dhusername could also be set to "&dhfirstname; &dhsurname;". -->
+  <!ENTITY dhusername  "Kristina Clair">
+  <!ENTITY dhemail     "kclair@leap.se">
+  <!-- SECTION should be 1-8, maybe w/ subsection other parameters are
+       allowed: see man(7), man(1) and
+       http://www.tldp.org/HOWTO/Man-Page/q2.html. -->
+  <!ENTITY dhsection   "SECTION">
+  <!-- TITLE should be something like "User commands" or similar (see
+       http://www.tldp.org/HOWTO/Man-Page/q2.html). -->
+  <!ENTITY dhtitle     "python-gnutls User Manual">
+  <!ENTITY dhucpackage "PYTHON-GNUTLS">
+  <!ENTITY dhpackage   "python-gnutls">
+]>
+
+<refentry>
+  <refentryinfo>
+    <title>&dhtitle;</title>
+    <productname>&dhpackage;</productname>
+    <authorgroup>
+      <author>
+       <firstname>&dhfirstname;</firstname>
+        <surname>&dhsurname;</surname>
+        <contrib>Wrote this manpage for the Debian system.</contrib>
+        <address>
+          <email>&dhemail;</email>
+        </address>
+      </author>
+    </authorgroup>
+    <copyright>
+      <year>2007</year>
+      <holder>&dhusername;</holder>
+    </copyright>
+    <legalnotice>
+      <para>This manual page was written for the Debian system
+        (and may be used by others).</para>
+      <para>Permission is granted to copy, distribute and/or modify this
+        document under the terms of the GNU General Public License,
+        Version 2 or (at your option) any later version published by
+        the Free Software Foundation.</para>
+      <para>On Debian systems, the complete text of the GNU General Public
+        License can be found in
+        <filename>/usr/share/common-licenses/GPL</filename>.</para>
+    </legalnotice>
+  </refentryinfo>
+  <refmeta>
+    <refentrytitle>&dhucpackage;</refentrytitle>
+    <manvolnum>&dhsection;</manvolnum>
+  </refmeta>
+  <refnamediv>
+    <refname>&dhpackage;</refname>
+    <refpurpose>program to do something</refpurpose>
+  </refnamediv>
+  <refsynopsisdiv>
+    <cmdsynopsis>
+      <command>&dhpackage;</command>
+      <!-- These are several examples, how syntaxes could look -->
+      <arg choice="plain"><option>-e <replaceable>this</replaceable></option></arg>
+      <arg choice="opt"><option>--example=<parameter>that</parameter></option></arg>
+      <arg choice="opt">
+        <group choice="req">
+          <arg choice="plain"><option>-e</option></arg>
+          <arg choice="plain"><option>--example</option></arg>
+        </group>
+        <replaceable class="option">this</replaceable>
+      </arg>
+      <arg choice="opt">
+        <group choice="req">
+          <arg choice="plain"><option>-e</option></arg>
+          <arg choice="plain"><option>--example</option></arg>
+        </group>
+        <group choice="req">
+          <arg choice="plain"><replaceable>this</replaceable></arg>
+          <arg choice="plain"><replaceable>that</replaceable></arg>
+        </group>
+      </arg>
+    </cmdsynopsis>
+    <cmdsynopsis>
+      <command>&dhpackage;</command>
+      <!-- Normally the help and version options make the programs stop
+           right after outputting the requested information. -->
+      <group choice="opt">
+        <arg choice="plain">
+          <group choice="req">
+            <arg choice="plain"><option>-h</option></arg>
+            <arg choice="plain"><option>--help</option></arg>
+          </group>
+        </arg>
+        <arg choice="plain">
+          <group choice="req">
+            <arg choice="plain"><option>-v</option></arg>
+            <arg choice="plain"><option>--version</option></arg>
+          </group>
+        </arg>
+      </group>
+    </cmdsynopsis>
+  </refsynopsisdiv>
+  <refsect1 id="description">
+    <title>DESCRIPTION</title>
+    <para>This manual page documents briefly the
+      <command>&dhpackage;</command> and <command>bar</command>
+      commands.</para>
+    <para>This manual page was written for the Debian distribution
+      because the original program does not have a manual page.
+      Instead, it has documentation in the GNU <citerefentry>
+        <refentrytitle>info</refentrytitle>
+        <manvolnum>1</manvolnum>
+      </citerefentry> format; see below.</para>
+    <para><command>&dhpackage;</command> is a program that...</para>
+  </refsect1>
+  <refsect1 id="options">
+    <title>OPTIONS</title>
+    <para>The program follows the usual GNU command line syntax,
+      with long options starting with two dashes (`-').  A summary of
+      options is included below.  For a complete description, see the
+      <citerefentry>
+        <refentrytitle>info</refentrytitle>
+        <manvolnum>1</manvolnum>
+      </citerefentry> files.</para>
+    <variablelist>
+      <!-- Use the variablelist.term.separator and the
+           variablelist.term.break.after parameters to
+           control the term elements. -->
+      <varlistentry>
+        <term><option>-e <replaceable>this</replaceable></option></term>
+        <term><option>--example=<replaceable>that</replaceable></option></term>
+        <listitem>
+          <para>Does this and that.</para>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term><option>-h</option></term>
+        <term><option>--help</option></term>
+        <listitem>
+          <para>Show summary of options.</para>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term><option>-v</option></term>
+        <term><option>--version</option></term>
+        <listitem>
+          <para>Show version of program.</para>
+        </listitem>
+      </varlistentry>
+    </variablelist>
+  </refsect1>
+  <refsect1 id="files">
+    <title>FILES</title>
+    <variablelist>
+      <varlistentry>
+        <term><filename>/etc/foo.conf</filename></term>
+        <listitem>
+          <para>The system-wide configuration file to control the
+            behaviour of <application>&dhpackage;</application>. See
+            <citerefentry>
+              <refentrytitle>foo.conf</refentrytitle>
+              <manvolnum>5</manvolnum>
+            </citerefentry> for further details.</para>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term><filename>${HOME}/.foo.conf</filename></term>
+        <listitem>
+          <para>The per-user configuration file to control the
+             behaviour of <application>&dhpackage;</application>. See
+             <citerefentry>
+               <refentrytitle>foo.conf</refentrytitle>
+               <manvolnum>5</manvolnum>
+             </citerefentry> for further details.</para>
+        </listitem>
+      </varlistentry>
+    </variablelist>
+  </refsect1>
+  <refsect1 id="environment">
+    <title>ENVIONMENT</title>
+    <variablelist>
+      <varlistentry>
+        <term><envar>FOO_CONF</envar></term>
+        <listitem>
+          <para>If used, the defined file is used as configuration
+            file (see also <xref linkend="files"/>).</para>
+        </listitem>
+      </varlistentry>
+    </variablelist>
+  </refsect1>
+  <refsect1 id="diagnostics">
+    <title>DIAGNOSTICS</title>
+    <para>The following diagnostics may be issued
+      on <filename class="devicefile">stderr</filename>:</para>
+    <variablelist>
+      <varlistentry>
+        <term><errortext>Bad configuration file. Exiting.</errortext></term>
+        <listitem>
+          <para>The configuration file seems to contain a broken configuration
+            line. Use the <option>--verbose</option> option, to get more info.
+          </para>
+        </listitem>
+      </varlistentry>
+    </variablelist>
+    <para><command>&dhpackage;</command> provides some return codes, that can
+      be used in scripts:</para>
+    <segmentedlist>
+      <segtitle>Code</segtitle>
+      <segtitle>Diagnostic</segtitle>
+      <seglistitem>
+        <seg><errorcode>0</errorcode></seg>
+        <seg>Program exited successfully.</seg>
+      </seglistitem>
+      <seglistitem>
+        <seg><errorcode>1</errorcode></seg>
+        <seg>The configuration file seems to be broken.</seg>
+      </seglistitem>
+    </segmentedlist>
+  </refsect1>
+  <refsect1 id="bugs">
+    <!-- Or use this section to tell about upstream BTS. -->
+    <title>BUGS</title>
+    <para>The program is currently limited to only work
+      with the <package>foobar</package> library.</para>
+    <para>The upstreams <acronym>BTS</acronym> can be found
+      at <ulink url="http://bugzilla.foo.tld"/>.</para>
+  </refsect1>
+  <refsect1 id="see_also">
+    <title>SEE ALSO</title>
+    <!-- In alpabetical order. -->
+    <para><citerefentry>
+        <refentrytitle>bar</refentrytitle>
+        <manvolnum>1</manvolnum>
+      </citerefentry>, <citerefentry>
+        <refentrytitle>baz</refentrytitle>
+        <manvolnum>1</manvolnum>
+      </citerefentry>, <citerefentry>
+        <refentrytitle>foo.conf</refentrytitle>
+        <manvolnum>5</manvolnum>
+      </citerefentry></para>
+    <para>The programs are documented fully by <citetitle>The Rise and
+      Fall of a Fooish Bar</citetitle> available via the <citerefentry>
+        <refentrytitle>info</refentrytitle>
+        <manvolnum>1</manvolnum>
+      </citerefentry> system.</para>
+  </refsect1>
+</refentry>
+
diff --git a/gnutls-1.1.9/debian/menu.ex b/gnutls-1.1.9/debian/menu.ex
new file mode 100644
index 0000000..bcb64f4
--- /dev/null
+++ b/gnutls-1.1.9/debian/menu.ex
@@ -0,0 +1,2 @@
+?package(python-gnutls):needs="X11|text|vc|wm" section="Applications/see-menu-manual"\
+  title="python-gnutls" command="/usr/bin/python-gnutls"
diff --git a/gnutls-1.1.9/debian/postinst.ex b/gnutls-1.1.9/debian/postinst.ex
new file mode 100644
index 0000000..a38fdc0
--- /dev/null
+++ b/gnutls-1.1.9/debian/postinst.ex
@@ -0,0 +1,39 @@
+#!/bin/sh
+# postinst script for python-gnutls
+#
+# see: dh_installdeb(1)
+
+set -e
+
+# summary of how this script can be called:
+#        * <postinst> `configure' <most-recently-configured-version>
+#        * <old-postinst> `abort-upgrade' <new version>
+#        * <conflictor's-postinst> `abort-remove' `in-favour' <package>
+#          <new-version>
+#        * <postinst> `abort-remove'
+#        * <deconfigured's-postinst> `abort-deconfigure' `in-favour'
+#          <failed-install-package> <version> `removing'
+#          <conflicting-package> <version>
+# for details, see http://www.debian.org/doc/debian-policy/ or
+# the debian-policy package
+
+
+case "$1" in
+    configure)
+    ;;
+
+    abort-upgrade|abort-remove|abort-deconfigure)
+    ;;
+
+    *)
+        echo "postinst called with unknown argument \`$1'" >&2
+        exit 1
+    ;;
+esac
+
+# dh_installdeb will replace this with shell code automatically
+# generated by other debhelper scripts.
+
+#DEBHELPER#
+
+exit 0
diff --git a/gnutls-1.1.9/debian/postrm.ex b/gnutls-1.1.9/debian/postrm.ex
new file mode 100644
index 0000000..cf70528
--- /dev/null
+++ b/gnutls-1.1.9/debian/postrm.ex
@@ -0,0 +1,37 @@
+#!/bin/sh
+# postrm script for python-gnutls
+#
+# see: dh_installdeb(1)
+
+set -e
+
+# summary of how this script can be called:
+#        * <postrm> `remove'
+#        * <postrm> `purge'
+#        * <old-postrm> `upgrade' <new-version>
+#        * <new-postrm> `failed-upgrade' <old-version>
+#        * <new-postrm> `abort-install'
+#        * <new-postrm> `abort-install' <old-version>
+#        * <new-postrm> `abort-upgrade' <old-version>
+#        * <disappearer's-postrm> `disappear' <overwriter>
+#          <overwriter-version>
+# for details, see http://www.debian.org/doc/debian-policy/ or
+# the debian-policy package
+
+
+case "$1" in
+    purge|remove|upgrade|failed-upgrade|abort-install|abort-upgrade|disappear)
+    ;;
+
+    *)
+        echo "postrm called with unknown argument \`$1'" >&2
+        exit 1
+    ;;
+esac
+
+# dh_installdeb will replace this with shell code automatically
+# generated by other debhelper scripts.
+
+#DEBHELPER#
+
+exit 0
diff --git a/gnutls-1.1.9/debian/preinst.ex b/gnutls-1.1.9/debian/preinst.ex
new file mode 100644
index 0000000..01483a2
--- /dev/null
+++ b/gnutls-1.1.9/debian/preinst.ex
@@ -0,0 +1,35 @@
+#!/bin/sh
+# preinst script for python-gnutls
+#
+# see: dh_installdeb(1)
+
+set -e
+
+# summary of how this script can be called:
+#        * <new-preinst> `install'
+#        * <new-preinst> `install' <old-version>
+#        * <new-preinst> `upgrade' <old-version>
+#        * <old-preinst> `abort-upgrade' <new-version>
+# for details, see http://www.debian.org/doc/debian-policy/ or
+# the debian-policy package
+
+
+case "$1" in
+    install|upgrade)
+    ;;
+
+    abort-upgrade)
+    ;;
+
+    *)
+        echo "preinst called with unknown argument \`$1'" >&2
+        exit 1
+    ;;
+esac
+
+# dh_installdeb will replace this with shell code automatically
+# generated by other debhelper scripts.
+
+#DEBHELPER#
+
+exit 0
diff --git a/gnutls-1.1.9/debian/prerm.ex b/gnutls-1.1.9/debian/prerm.ex
new file mode 100644
index 0000000..8a17723
--- /dev/null
+++ b/gnutls-1.1.9/debian/prerm.ex
@@ -0,0 +1,38 @@
+#!/bin/sh
+# prerm script for python-gnutls
+#
+# see: dh_installdeb(1)
+
+set -e
+
+# summary of how this script can be called:
+#        * <prerm> `remove'
+#        * <old-prerm> `upgrade' <new-version>
+#        * <new-prerm> `failed-upgrade' <old-version>
+#        * <conflictor's-prerm> `remove' `in-favour' <package> <new-version>
+#        * <deconfigured's-prerm> `deconfigure' `in-favour'
+#          <package-being-installed> <version> `removing'
+#          <conflicting-package> <version>
+# for details, see http://www.debian.org/doc/debian-policy/ or
+# the debian-policy package
+
+
+case "$1" in
+    remove|upgrade|deconfigure)
+    ;;
+
+    failed-upgrade)
+    ;;
+
+    *)
+        echo "prerm called with unknown argument \`$1'" >&2
+        exit 1
+    ;;
+esac
+
+# dh_installdeb will replace this with shell code automatically
+# generated by other debhelper scripts.
+
+#DEBHELPER#
+
+exit 0
diff --git a/gnutls-1.1.9/debian/pycompat b/gnutls-1.1.9/debian/pycompat
new file mode 100644
index 0000000..0cfbf08
--- /dev/null
+++ b/gnutls-1.1.9/debian/pycompat
@@ -0,0 +1 @@
+2
diff --git a/gnutls-1.1.9/debian/python-gnutls.cron.d.ex b/gnutls-1.1.9/debian/python-gnutls.cron.d.ex
new file mode 100644
index 0000000..811a4da
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls.cron.d.ex
@@ -0,0 +1,4 @@
+#
+# Regular cron jobs for the python-gnutls package
+#
+0 4	* * *	root	[ -x /usr/bin/python-gnutls_maintenance ] && /usr/bin/python-gnutls_maintenance
diff --git a/gnutls-1.1.9/debian/python-gnutls.debhelper.log b/gnutls-1.1.9/debian/python-gnutls.debhelper.log
new file mode 100644
index 0000000..3b6dd09
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls.debhelper.log
@@ -0,0 +1,33 @@
+dh_prep
+dh_installdirs
+dh_installdirs
+dh_installdocs
+dh_installexamples
+dh_installman
+dh_installinfo
+dh_installmenu
+dh_installcron
+dh_installinit
+dh_installdebconf
+dh_installemacsen
+dh_installcatalogs
+dh_installpam
+dh_installlogrotate
+dh_installlogcheck
+dh_installchangelogs
+dh_installudev
+dh_lintian
+dh_install
+dh_link
+dh_installmime
+dh_pysupport
+dh_strip
+dh_compress
+dh_fixperms
+dh_makeshlibs
+dh_installdeb
+dh_perl
+dh_shlibdeps
+dh_gencontrol
+dh_md5sums
+dh_builddeb
diff --git a/gnutls-1.1.9/debian/python-gnutls.default.ex b/gnutls-1.1.9/debian/python-gnutls.default.ex
new file mode 100644
index 0000000..7506cd0
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls.default.ex
@@ -0,0 +1,10 @@
+# Defaults for python-gnutls initscript
+# sourced by /etc/init.d/python-gnutls
+# installed at /etc/default/python-gnutls by the maintainer scripts
+
+#
+# This is a POSIX shell fragment
+#
+
+# Additional options that are passed to the Daemon.
+DAEMON_OPTS=""
diff --git a/gnutls-1.1.9/debian/python-gnutls.doc-base.EX b/gnutls-1.1.9/debian/python-gnutls.doc-base.EX
new file mode 100644
index 0000000..5487b85
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls.doc-base.EX
@@ -0,0 +1,20 @@
+Document: python-gnutls
+Title: Debian python-gnutls Manual
+Author: <insert document author here>
+Abstract: This manual describes what python-gnutls is
+ and how it can be used to
+ manage online manuals on Debian systems.
+Section: unknown
+
+Format: debiandoc-sgml
+Files: /usr/share/doc/python-gnutls/python-gnutls.sgml.gz
+
+Format: postscript
+Files: /usr/share/doc/python-gnutls/python-gnutls.ps.gz
+
+Format: text
+Files: /usr/share/doc/python-gnutls/python-gnutls.text.gz
+
+Format: HTML
+Index: /usr/share/doc/python-gnutls/html/index.html
+Files: /usr/share/doc/python-gnutls/html/*.html
diff --git a/gnutls-1.1.9/debian/python-gnutls.postinst.debhelper b/gnutls-1.1.9/debian/python-gnutls.postinst.debhelper
new file mode 100644
index 0000000..f95dafe
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls.postinst.debhelper
@@ -0,0 +1,5 @@
+# Automatically added by dh_pysupport
+if which update-python-modules >/dev/null 2>&1; then
+	update-python-modules  python-gnutls.public
+fi
+# End automatically added section
diff --git a/gnutls-1.1.9/debian/python-gnutls.prerm.debhelper b/gnutls-1.1.9/debian/python-gnutls.prerm.debhelper
new file mode 100644
index 0000000..cd6a4b8
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls.prerm.debhelper
@@ -0,0 +1,5 @@
+# Automatically added by dh_pysupport
+if which update-python-modules >/dev/null 2>&1; then
+	update-python-modules -c  python-gnutls.public
+fi
+# End automatically added section
diff --git a/gnutls-1.1.9/debian/python-gnutls.substvars b/gnutls-1.1.9/debian/python-gnutls.substvars
new file mode 100644
index 0000000..d9fbd55
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls.substvars
@@ -0,0 +1,5 @@
+python:Versions=2.5, 2.6
+python:Provides=python2.5-gnutls, python2.6-gnutls
+python:Depends=python (<< 2.7), python (>= 2.5), python-support (>= 0.90.0)
+shlibs:Depends=libc6 (>= 2.2.5), libgcrypt11 (>= 1.4.2), libgnutls26 (>= 2.7.14-0)
+misc:Depends=
diff --git a/gnutls-1.1.9/debian/python-gnutls/DEBIAN/control b/gnutls-1.1.9/debian/python-gnutls/DEBIAN/control
new file mode 100644
index 0000000..b682699
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls/DEBIAN/control
@@ -0,0 +1,23 @@
+Package: python-gnutls
+Version: 1.1.9-1
+Architecture: amd64
+Maintainer: Kristina Clair <kclair@leap.se>
+Installed-Size: 384
+Depends: python (<< 2.7), python (>= 2.5), python-support (>= 0.90.0), libc6 (>= 2.2.5), libgcrypt11 (>= 1.4.2), libgnutls26 (>= 2.7.14-0)
+Provides: python2.5-gnutls, python2.6-gnutls
+Section: python
+Priority: optional
+Homepage: http://pypi.python.org/pypi/python-gnutls/1.1.9
+Description: Python wrapper for the GNUTLS library
+ This package provides a high level object oriented wrapper around
+ libgnutls, as well as low level bindings to the GNUTLS types and
+ functions via ctypes. The high level wrapper hides the details of
+ accessing the GNUTLS library via ctypes behind a set of classes
+ that encapsulate GNUTLS sessions, certificates and credentials and
+ expose them to Python applications using a simple API.
+ .
+ The package also includes a Twisted interface that has seamless
+ intergration with Twisted, providing connectTLS and listenTLS
+ methods on the Twisted reactor once imported (the methods are
+ automatically attached to the reactor by simply importing the
+ GNUTLS Twisted interface module).
diff --git a/gnutls-1.1.9/debian/python-gnutls/DEBIAN/md5sums b/gnutls-1.1.9/debian/python-gnutls/DEBIAN/md5sums
new file mode 100644
index 0000000..2382143
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls/DEBIAN/md5sums
@@ -0,0 +1,22 @@
+e2fda9ac98c37b6ee3bcde708158ec5f  usr/lib/pyshared/python2.5/gnutls/library/_gnutls_init.so
+4df141ee145ba70bcff331c30e684970  usr/lib/pyshared/python2.6/gnutls/library/_gnutls_init.so
+d9394eb9362a7142eba88799f798040e  usr/share/doc/python-gnutls/README
+6697fe77b6f7274495d2b1bc8203c3ca  usr/share/doc/python-gnutls/README.Debian
+950c66db7ec6a47faf3391a6a85ba7b8  usr/share/doc/python-gnutls/changelog.Debian.gz
+646bad4dab8ebd62f5b4e94444dba184  usr/share/doc/python-gnutls/changelog.gz
+193feaea73d0afef725c19e7cfb6b0f2  usr/share/doc/python-gnutls/copyright
+5381f2a59419a8b6f446e1b5278f1c0a  usr/share/pyshared/gnutls/__init__.py
+2788c637b67d61652b34e99a742c071c  usr/share/pyshared/gnutls/connection.py
+0623f736a384003c2b968aa33bd7bfce  usr/share/pyshared/gnutls/constants.py
+399209afd686dbde597cda5fc8d85b5e  usr/share/pyshared/gnutls/crypto.py
+783bdf857659a208094eab4fca90702b  usr/share/pyshared/gnutls/errors.py
+75ae33a6542527f186a27e43bcb1f3d0  usr/share/pyshared/gnutls/interfaces/__init__.py
+e001e00896dcc0be201deb3e5df946b4  usr/share/pyshared/gnutls/interfaces/twisted/__init__.py
+a1c2591684c72bc0007f1f286e0ed441  usr/share/pyshared/gnutls/library/__init__.py
+c8296954f1e2c7ca000304278fb12086  usr/share/pyshared/gnutls/library/constants.py
+44ad85247067f96a66703b9d3e193db2  usr/share/pyshared/gnutls/library/errors.py
+7e42329b298a4cc7fdd9923da9bc5102  usr/share/pyshared/gnutls/library/functions.py
+a2c13c22a95e264f9f8962c0cd941a8a  usr/share/pyshared/gnutls/library/types.py
+b3748b63be993c6b85ecac409026620c  usr/share/pyshared/gnutls/validators.py
+6022acbfb8337f4308b7a57fdd8c74ef  usr/share/pyshared/python_gnutls-1.1.9.egg-info
+05cc8ee1313d573768910bec62c9311e  usr/share/python-support/python-gnutls.public
diff --git a/gnutls-1.1.9/debian/python-gnutls/DEBIAN/postinst b/gnutls-1.1.9/debian/python-gnutls/DEBIAN/postinst
new file mode 100755
index 0000000..1b965f9
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls/DEBIAN/postinst
@@ -0,0 +1,7 @@
+#!/bin/sh
+set -e
+# Automatically added by dh_pysupport
+if which update-python-modules >/dev/null 2>&1; then
+	update-python-modules  python-gnutls.public
+fi
+# End automatically added section
diff --git a/gnutls-1.1.9/debian/python-gnutls/DEBIAN/prerm b/gnutls-1.1.9/debian/python-gnutls/DEBIAN/prerm
new file mode 100755
index 0000000..b79f34e
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls/DEBIAN/prerm
@@ -0,0 +1,7 @@
+#!/bin/sh
+set -e
+# Automatically added by dh_pysupport
+if which update-python-modules >/dev/null 2>&1; then
+	update-python-modules -c  python-gnutls.public
+fi
+# End automatically added section
diff --git a/gnutls-1.1.9/debian/python-gnutls/usr/lib/pyshared/python2.5/gnutls/library/_gnutls_init.so b/gnutls-1.1.9/debian/python-gnutls/usr/lib/pyshared/python2.5/gnutls/library/_gnutls_init.so
new file mode 100644
index 0000000..36aba17
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls/usr/lib/pyshared/python2.5/gnutls/library/_gnutls_init.so
diff --git a/gnutls-1.1.9/debian/python-gnutls/usr/lib/pyshared/python2.6/gnutls/library/_gnutls_init.so b/gnutls-1.1.9/debian/python-gnutls/usr/lib/pyshared/python2.6/gnutls/library/_gnutls_init.so
new file mode 100644
index 0000000..503e46f
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls/usr/lib/pyshared/python2.6/gnutls/library/_gnutls_init.so
diff --git a/gnutls-1.1.9/debian/python-gnutls/usr/share/doc/python-gnutls/README b/gnutls-1.1.9/debian/python-gnutls/usr/share/doc/python-gnutls/README
new file mode 100644
index 0000000..ef1052a
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls/usr/share/doc/python-gnutls/README
@@ -0,0 +1,19 @@
+
+Python wrapper for the GNUTLS library
+
+This package provides a high level object oriented wrapper around libgnutls,
+as well as low level bindings to the GNUTLS types and functions via ctypes.
+The high level wrapper hides the details of accessing the GNUTLS library via
+ctypes behind a set of classes that encapsulate GNUTLS sessions, certificates
+and credentials and expose them to python applications using a simple API.
+
+The package also includes a Twisted interface that has seamless intergration
+with Twisted, providing connectTLS and listenTLS methods on the Twisted
+reactor once imported (the methods are automatically attached to the reactor
+by simply importing the GNUTLS Twisted interface module).
+
+The high level wrapper is written using the GNUTLS library bindings that are
+made available via ctypes. This makes the wrapper very powerful and flexible
+as it has direct access to all the GNUTLS internals and is also very easy to
+extend without any need to write C code or recompile anything.
+
diff --git a/gnutls-1.1.9/debian/python-gnutls/usr/share/doc/python-gnutls/README.Debian b/gnutls-1.1.9/debian/python-gnutls/usr/share/doc/python-gnutls/README.Debian
new file mode 100644
index 0000000..184ec24
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls/usr/share/doc/python-gnutls/README.Debian
@@ -0,0 +1,6 @@
+python-gnutls for Debian
+------------------------
+
+<possible notes regarding this package - if none, delete this file>
+
+ -- Kristina Clair <kclair@leap.se>  Wed, 03 Oct 2012 11:29:13 -0700
diff --git a/gnutls-1.1.9/debian/python-gnutls/usr/share/doc/python-gnutls/changelog.Debian.gz b/gnutls-1.1.9/debian/python-gnutls/usr/share/doc/python-gnutls/changelog.Debian.gz
new file mode 100644
index 0000000..a148fd0
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls/usr/share/doc/python-gnutls/changelog.Debian.gz
diff --git a/gnutls-1.1.9/debian/python-gnutls/usr/share/doc/python-gnutls/changelog.gz b/gnutls-1.1.9/debian/python-gnutls/usr/share/doc/python-gnutls/changelog.gz
new file mode 100644
index 0000000..aa90b7b
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls/usr/share/doc/python-gnutls/changelog.gz
diff --git a/gnutls-1.1.9/debian/python-gnutls/usr/share/doc/python-gnutls/copyright b/gnutls-1.1.9/debian/python-gnutls/usr/share/doc/python-gnutls/copyright
new file mode 100644
index 0000000..f9150bb
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls/usr/share/doc/python-gnutls/copyright
@@ -0,0 +1,43 @@
+This work was packaged for Debian by:
+
+    k clair <kclair@leap.se> on Wed, 03 Oct 2012 11:04:26 -0700
+
+It was downloaded from:
+
+    http://pypi.python.org/pypi/python-gnutls/1.1.9 
+
+Upstream Author(s):
+
+    AG Projects
+    Dan Pascu
+    Mircea Amarascu
+
+Copyright:
+
+    Copyright (C) 2006-2007 AG Projects
+    Dan Pascu
+    Mircea Amarascu
+
+License:
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This package is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+On Debian systems, the complete text of the GNU General
+Public License version 3 can be found in "/usr/share/common-licenses/GPL-3".
+
+The Debian packaging is:
+
+    Copyright (C) 2012 k clair <kclair@leap.se>
+
+    and is licensed under the GPL version 3, see above.
diff --git a/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/__init__.py b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/__init__.py
new file mode 100644
index 0000000..c72f309
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/__init__.py
@@ -0,0 +1,5 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+__version__ = '1.1.9'
+
diff --git a/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/connection.py b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/connection.py
new file mode 100644
index 0000000..5990bd4
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/connection.py
@@ -0,0 +1,500 @@
+# Copyright (C) 2007-2008 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS connection support"""
+
+__all__ = ['X509Credentials', 'ClientSession', 'ServerSession', 'ServerSessionFactory']
+
+from time import time
+from socket import SHUT_RDWR as SOCKET_SHUT_RDWR
+
+from _ctypes import PyObj_FromPtr
+from ctypes import *
+
+from gnutls.validators import *
+from gnutls.constants import *
+from gnutls.crypto import *
+from gnutls.errors import *
+
+from gnutls.library.constants import GNUTLS_SERVER, GNUTLS_CLIENT, GNUTLS_CRT_X509
+from gnutls.library.constants import GNUTLS_CERT_INVALID, GNUTLS_CERT_REVOKED, GNUTLS_CERT_INSECURE_ALGORITHM
+from gnutls.library.constants import GNUTLS_CERT_SIGNER_NOT_FOUND, GNUTLS_CERT_SIGNER_NOT_CA
+from gnutls.library.constants import GNUTLS_AL_FATAL, GNUTLS_A_BAD_CERTIFICATE
+from gnutls.library.constants import GNUTLS_A_UNKNOWN_CA, GNUTLS_A_INSUFFICIENT_SECURITY
+from gnutls.library.constants import GNUTLS_A_CERTIFICATE_EXPIRED, GNUTLS_A_CERTIFICATE_REVOKED
+from gnutls.library.constants import GNUTLS_NAME_DNS
+from gnutls.library.types     import gnutls_certificate_credentials_t, gnutls_session_t, gnutls_x509_crt_t
+from gnutls.library.types     import gnutls_certificate_server_retrieve_function
+from gnutls.library.functions import *
+
+
+@gnutls_certificate_server_retrieve_function
+def _retrieve_server_certificate(c_session, retr_st):
+    session = PyObj_FromPtr(gnutls_session_get_ptr(c_session))
+    identity = session.credentials.select_server_identity(session)
+    retr_st.contents.type = GNUTLS_CRT_X509
+    retr_st.contents.deinit_all = 0
+    if identity is None:
+        retr_st.contents.ncerts = 0
+    else:
+        retr_st.contents.ncerts = 1
+        retr_st.contents.cert.x509.contents = identity.cert._c_object
+        retr_st.contents.key.x509 = identity.key._c_object
+    return 0
+
+
+class _ServerNameIdentities(dict):
+    """Used internally by X509Credentials to map server names to X509 identities for the server name extension"""
+    def __init__(self, identities):
+        dict.__init__(self)
+        for identity in identities:
+            self.add(identity)
+    def add(self, identity):
+        for name in identity.cert.alternative_names.dns:
+            self[name.lower()] = identity
+        for ip in identity.cert.alternative_names.ip:
+            self[ip] = identity
+        subject = identity.cert.subject
+        if subject.CN is not None:
+            self[subject.CN.lower()] = identity
+    def get(self, server_name, default=None):
+        server_name = server_name.lower()
+        if server_name in self:
+            return self[server_name]
+        for name in (n for n in self if n.startswith('*.')):
+            suffix = name[1:]
+            if server_name.endswith(suffix) and '.' not in server_name[:-len(suffix)]:
+                return self[name]
+        return default
+
+
+class X509Credentials(object):
+    DH_BITS  = 1024
+    RSA_BITS = 1024
+
+    dh_params  = None
+    rsa_params = None
+
+    def __new__(cls, *args, **kwargs):
+        c_object = gnutls_certificate_credentials_t()
+        gnutls_certificate_allocate_credentials(byref(c_object))
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_certificate_free_credentials
+        instance._c_object = c_object
+        return instance
+
+    @method_args((X509Certificate, none), (X509PrivateKey, none), list_of(X509Certificate), list_of(X509CRL), list_of(X509Identity))
+    def __init__(self, cert=None, key=None, trusted=[], crl_list=[], identities=[]):
+        """Credentials contain a X509 certificate, a private key, a list of trusted CAs and a list of CRLs (all optional).
+        An optional list of additional X509 identities can be specified for applications that need more that one identity"""
+        if cert and key:
+            gnutls_certificate_set_x509_key(self._c_object, byref(cert._c_object), 1, key._c_object)
+        elif (cert, key) != (None, None):
+            raise ValueError("Specify neither or both the certificate and private key")
+        gnutls_certificate_server_set_retrieve_function(self._c_object, _retrieve_server_certificate)
+        self._max_depth = 5
+        self._max_bits  = 8200
+        self._type = CRED_CERTIFICATE
+        self._cert = cert
+        self._key = key
+        self._identities = tuple(identities)
+        self._trusted = ()
+        self.add_trusted(trusted)
+        self.crl_list = crl_list
+        self.server_name_identities = _ServerNameIdentities(identities)
+        if cert and key:
+            self.server_name_identities.add(X509Identity(cert, key))
+        self.session_params = SessionParams(self._type)
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
+    # Methods to alter the credentials at runtime
+
+    @method_args(list_of(X509Certificate))
+    def add_trusted(self, trusted):
+        size = len(trusted)
+        if size > 0:
+            ca_list = (gnutls_x509_crt_t * size)(*[cert._c_object for cert in trusted])
+            gnutls_certificate_set_x509_trust(self._c_object, cast(byref(ca_list), POINTER(gnutls_x509_crt_t)), size)
+            self._trusted = self._trusted + tuple(trusted)
+
+    def generate_dh_params(self, bits=DH_BITS):
+        reference = self.dh_params ## keep a reference to preserve it until replaced
+        X509Credentials.dh_params  = DHParams(bits)
+        del reference
+
+    def generate_rsa_params(self, bits=RSA_BITS):
+        reference = self.rsa_params ## keep a reference to preserve it until replaced
+        X509Credentials.rsa_params = RSAParams(bits)
+        del reference
+
+    # Properties
+
+    @property
+    def cert(self):
+        return self._cert
+
+    @property
+    def key(self):
+        return self._key
+
+    @property
+    def identities(self):
+        return self._identities
+
+    @property
+    def trusted(self):
+        return self._trusted
+
+    def _get_crl_list(self):
+        return self._crl_list
+    @method_args(list_of(X509CRL)) 
+    def _set_crl_list(self, crl_list):
+        self._crl_list = tuple(crl_list)
+    crl_list = property(_get_crl_list, _set_crl_list)
+    del _get_crl_list, _set_crl_list
+
+    def _get_max_verify_length(self):
+        return self._max_depth
+    @method_args(int) 
+    def _set_max_verify_length(self, max_depth):
+        gnutls_certificate_set_verify_limits(self._c_object, self._max_bits, max_depth)
+        self._max_depth = max_depth
+    max_verify_length = property(_get_max_verify_length, _set_max_verify_length)
+    del _get_max_verify_length, _set_max_verify_length
+
+    def _get_max_verify_bits(self):
+        return self._max_bits
+    @method_args(int) 
+    def _set_max_verify_bits(self, max_bits):
+        gnutls_certificate_set_verify_limits(self._c_object, max_bits, self._max_depth)
+        self._max_bits = max_bits
+    max_verify_bits = property(_get_max_verify_bits, _set_max_verify_bits)
+    del _get_max_verify_bits, _set_max_verify_bits
+
+    # Methods to select and validate certificates
+
+    def check_certificate(self, cert, cert_name='certificate'):
+        """Verify activation, expiration and revocation for the given certificate"""
+        now = time()
+        if cert.activation_time > now:
+            raise CertificateExpiredError("%s is not yet activated" % cert_name)
+        if cert.expiration_time < now:
+            raise CertificateExpiredError("%s has expired" % cert_name)
+        for crl in self.crl_list:
+            crl.check_revocation(cert, cert_name=cert_name)
+
+    def select_server_identity(self, session):
+        """Select which identity the server will use for a given session. The default selection algorithm uses
+        the server name extension. A subclass can overwrite it if a different selection algorithm is desired."""
+        server_name = session.server_name
+        if server_name is not None:
+            return self.server_name_identities.get(server_name)
+        elif self.cert and self.key:
+            return self ## since we have the cert and key attributes we can behave like a X509Identity
+        else:
+            return None
+
+
+class SessionParams(object):
+    _default_kx_algorithms = {
+        CRED_CERTIFICATE: (KX_RSA, KX_DHE_DSS, KX_DHE_RSA),
+        CRED_ANON: (KX_ANON_DH,)}
+    _all_kx_algorithms = {
+        CRED_CERTIFICATE: set((KX_RSA, KX_DHE_DSS, KX_DHE_RSA, KX_RSA_EXPORT)),
+        CRED_ANON: set((KX_ANON_DH,))}
+
+    def __new__(cls, credentials_type):
+        if credentials_type not in cls._default_kx_algorithms:
+            raise TypeError("Unknown credentials type: %r" % credentials_type)
+        return object.__new__(cls)
+
+    def __init__(self, credentials_type):
+        self._credentials_type = credentials_type
+        self._protocols = (PROTO_TLS1_1, PROTO_TLS1_0, PROTO_SSL3)
+        self._kx_algorithms = self._default_kx_algorithms[credentials_type]
+        self._ciphers = (CIPHER_AES_128_CBC, CIPHER_3DES_CBC, CIPHER_ARCFOUR_128)
+        self._mac_algorithms = (MAC_SHA1, MAC_MD5, MAC_RMD160)
+        self._compressions = (COMP_NULL,)
+
+    def _get_protocols(self):
+        return self._protocols
+    def _set_protocols(self, protocols):
+        self._protocols = ProtocolListValidator(protocols)
+    protocols = property(_get_protocols, _set_protocols)
+    del _get_protocols, _set_protocols
+
+    def _get_kx_algorithms(self):
+        return self._kx_algorithms
+    def _set_kx_algorithms(self, algorithms):
+        cred_type = self._credentials_type
+        algorithms = KeyExchangeListValidator(algorithms)
+        invalid = set(algorithms) - self._all_kx_algorithms[cred_type]
+        if invalid:
+            raise ValueError("Cannot specify %r with %r credentials" % (list(invalid), cred_type))
+        self._kx_algorithms = algorithms
+    kx_algorithms = property(_get_kx_algorithms, _set_kx_algorithms)
+    del _get_kx_algorithms, _set_kx_algorithms
+
+    def _get_ciphers(self):
+        return self._ciphers
+    def _set_ciphers(self, ciphers):
+        self._ciphers = CipherListValidator(ciphers)
+    ciphers = property(_get_ciphers, _set_ciphers)
+    del _get_ciphers, _set_ciphers
+
+    def _get_mac_algorithms(self):
+        return self._mac_algorithms
+    def _set_mac_algorithms(self, algorithms):
+        self._mac_algorithms = MACListValidator(algorithms)
+    mac_algorithms = property(_get_mac_algorithms, _set_mac_algorithms)
+    del _get_mac_algorithms, _set_mac_algorithms
+
+    def _get_compressions(self):
+        return self._compressions
+    def _set_compressions(self, compressions):
+        self._compressions = CompressionListValidator(compressions)
+    compressions = property(_get_compressions, _set_compressions)
+    del _get_compressions, _set_compressions
+
+
+class Session(object):
+    """Abstract class representing a TLS session created from a TCP socket
+       and a Credentials object."""
+
+    session_type = None ## placeholder for GNUTLS_SERVER or GNUTLS_CLIENT as defined by subclass
+
+    def __new__(cls, *args, **kwargs):
+        if cls is Session:
+            raise RuntimeError("Session cannot be instantiated directly")
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_deinit
+        instance._c_object = gnutls_session_t()
+        return instance
+
+    def __init__(self, socket, credentials):
+        gnutls_init(byref(self._c_object), self.session_type)
+        ## Store a pointer to self on the C session
+        gnutls_session_set_ptr(self._c_object, id(self))
+        # gnutls_dh_set_prime_bits(session, DH_BITS)?
+        gnutls_transport_set_ptr(self._c_object, socket.fileno())
+        gnutls_handshake_set_private_extensions(self._c_object, 1)
+        self.socket = socket
+        self.credentials = credentials
+        self._update_params()
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
+    def __getattr__(self, name):
+        ## Generic wrapper for the underlying socket methods and attributes.
+        return getattr(self.socket, name)
+
+    # Session properties
+
+    def _get_credentials(self):
+        return self._credentials
+    @method_args(X509Credentials)
+    def _set_credentials(self, credentials):
+        ## Release all credentials, otherwise gnutls will only release an existing credential of
+        ## the same type as the one being set and we can end up with multiple credentials in C.
+        gnutls_credentials_clear(self._c_object)
+        gnutls_credentials_set(self._c_object, credentials._type, cast(credentials._c_object, c_void_p))
+        self._credentials = credentials
+    credentials = property(_get_credentials, _set_credentials)
+    del _get_credentials, _set_credentials
+
+    @property
+    def protocol(self):
+        return gnutls_protocol_get_name(gnutls_protocol_get_version(self._c_object))
+
+    @property
+    def kx_algorithm(self):
+        return gnutls_kx_get_name(gnutls_kx_get(self._c_object))
+
+    @property
+    def cipher(self):
+        return gnutls_cipher_get_name(gnutls_cipher_get(self._c_object))
+
+    @property
+    def mac_algorithm(self):
+        return gnutls_mac_get_name(gnutls_mac_get(self._c_object))
+
+    @property
+    def compression(self):
+        return gnutls_compression_get_name(gnutls_compression_get(self._c_object))
+
+    @property
+    def peer_certificate(self):
+        if gnutls_certificate_type_get(self._c_object) != GNUTLS_CRT_X509:
+            return None
+        list_size = c_uint()
+        cert_list = gnutls_certificate_get_peers(self._c_object, byref(list_size))
+        if list_size.value == 0:
+            return None
+        cert = cert_list[0]
+        return X509Certificate(string_at(cert.data, cert.size), X509_FMT_DER)
+
+    # Status checking after an operation was interrupted (these properties are
+    # only useful to check after an operation was interrupted, otherwise their
+    # value is meaningless).
+
+    @property
+    def interrupted_while_writing(self):
+        """True if an operation was interrupted while writing"""
+        return gnutls_record_get_direction(self._c_object)==1
+
+    @property
+    def interrupted_while_reading(self):
+        """True if an operation was interrupted while reading"""
+        return gnutls_record_get_direction(self._c_object)==0
+
+    # Session methods
+
+    def _update_params(self):
+        """Update the priorities of the session params using the credentials."""
+        def c_priority_list(priorities):
+            size = len(priorities) + 1
+            return (c_int * size)(*priorities)
+        session_params = self.credentials.session_params
+        # protocol order in the priority list is irrelevant (it always uses newer protocols first)
+        # the protocol list only specifies what protocols are to be enabled.
+        gnutls_protocol_set_priority(self._c_object, c_priority_list(session_params.protocols))
+        gnutls_kx_set_priority(self._c_object, c_priority_list(session_params.kx_algorithms))
+        gnutls_cipher_set_priority(self._c_object, c_priority_list(session_params.ciphers))
+        gnutls_mac_set_priority(self._c_object, c_priority_list(session_params.mac_algorithms))
+        gnutls_compression_set_priority(self._c_object, c_priority_list(session_params.compressions))
+
+    def handshake(self):
+        gnutls_handshake(self._c_object)
+
+    #@method_args((basestring, buffer))
+    def send(self, data):
+        data = str(data)
+        return gnutls_record_send(self._c_object, data, len(data))
+
+    def sendall(self, data):
+        size = len(data)
+        while size > 0:
+            sent = self.send(data[-size:])
+            size -= sent
+
+    def recv(self, limit):
+        data = create_string_buffer(limit)
+        size = gnutls_record_recv(self._c_object, data, limit)
+        return data[:size]
+
+    def send_alert(self, exception):
+        alertdict = {
+            CertificateError: GNUTLS_A_BAD_CERTIFICATE,
+            CertificateAuthorityError: GNUTLS_A_UNKNOWN_CA,
+            CertificateSecurityError: GNUTLS_A_INSUFFICIENT_SECURITY,
+            CertificateExpiredError: GNUTLS_A_CERTIFICATE_EXPIRED,
+            CertificateRevokedError: GNUTLS_A_CERTIFICATE_REVOKED}
+        alert = alertdict.get(exception.__class__)
+        if alert:
+            gnutls_alert_send(self._c_object, GNUTLS_AL_FATAL, alert)
+
+    @method_args(one_of(SHUT_RDWR, SHUT_WR))
+    def bye(self, how=SHUT_RDWR):
+        gnutls_bye(self._c_object, how)
+
+    def shutdown(self, how=SOCKET_SHUT_RDWR):
+        self.socket.shutdown(how)
+
+    def close(self):
+        self.socket.close()
+
+    def verify_peer(self):
+        status = c_uint()
+        gnutls_certificate_verify_peers2(self._c_object, byref(status))
+        status = status.value
+        if status & GNUTLS_CERT_INVALID:
+            raise CertificateError("peer certificate is invalid")
+        elif status & GNUTLS_CERT_SIGNER_NOT_FOUND:
+            raise CertificateAuthorityError("peer certificate signer not found")
+        elif status & GNUTLS_CERT_SIGNER_NOT_CA:
+            raise CertificateAuthorityError("peer certificate signer is not a CA")
+        elif status & GNUTLS_CERT_INSECURE_ALGORITHM:
+            raise CertificateSecurityError("peer certificate uses an insecure algorithm")
+        elif status & GNUTLS_CERT_REVOKED:
+            raise CertificateRevokedError("peer certificate was revoked")
+
+
+class ClientSession(Session):
+    session_type = GNUTLS_CLIENT
+
+    def __init__(self, socket, credentials, server_name=None):
+        Session.__init__(self, socket, credentials)
+        self._server_name = None
+        if server_name is not None:
+            self.server_name = server_name
+
+    def _get_server_name(self):
+        return self._server_name
+    @method_args(str)
+    def _set_server_name(self, server_name):
+        gnutls_server_name_set(self._c_object, GNUTLS_NAME_DNS, c_char_p(server_name), len(server_name))
+        self._server_name = server_name
+    server_name = property(_get_server_name, _set_server_name)
+    del _get_server_name, _set_server_name
+
+
+class ServerSession(Session):
+    session_type = GNUTLS_SERVER
+
+    def __init__(self, socket, credentials):
+        Session.__init__(self, socket, credentials)
+        gnutls_certificate_server_set_request(self._c_object, CERT_REQUEST)
+
+    @property
+    def server_name(self):
+        data_length = c_size_t(256)
+        data = create_string_buffer(data_length.value)
+        hostname_type = c_uint()
+        for i in xrange(2**16):
+            try:
+                gnutls_server_name_get(self._c_object, data, byref(data_length), byref(hostname_type), i)
+            except RequestedDataNotAvailable:
+                break
+            except MemoryError:
+                data_length.value += 1 ## one extra byte for the terminating 0
+                data = create_string_buffer(data_length.value)
+                gnutls_server_name_get(self._c_object, data, byref(data_length), byref(hostname_type), i)
+            if hostname_type.value != GNUTLS_NAME_DNS:
+                continue
+            return data.value
+        return None
+
+
+class ServerSessionFactory(object):
+
+    def __init__(self, socket, credentials, session_class=ServerSession):
+        if not issubclass(session_class, ServerSession):
+            raise TypeError, "session_class must be a subclass of ServerSession"
+        self.socket = socket
+        self.credentials = credentials
+        self.session_class = session_class
+
+    def __getattr__(self, name):
+        ## Generic wrapper for the underlying socket methods and attributes
+        return getattr(self.socket, name)
+
+    def bind(self, address):
+        self.socket.bind(address)
+
+    def listen(self, backlog):
+        self.socket.listen(backlog)
+
+    def accept(self):
+        new_sock, address = self.socket.accept()
+        session = self.session_class(new_sock, self.credentials)
+        return (session, address)
+
+    def shutdown(self, how=SOCKET_SHUT_RDWR):
+        self.socket.shutdown(how)
+
+    def close(self):
+        self.socket.close()
+
diff --git a/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/constants.py b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/constants.py
new file mode 100644
index 0000000..4637a16
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/constants.py
@@ -0,0 +1,54 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS constants"""
+
+__all__ = [
+    ## GNUTLS session protocols
+    'PROTO_TLS1_1', 'PROTO_TLS1_0', 'PROTO_SSL3',
+    
+    ## Key exchange algorithms
+    'KX_RSA', 'KX_DHE_DSS', 'KX_DHE_RSA', 'KX_RSA_EXPORT', 'KX_ANON_DH',
+    
+    ## Ciphers
+    'CIPHER_AES_128_CBC', 'CIPHER_3DES_CBC', 'CIPHER_ARCFOUR_128', 'CIPHER_AES_256_CBC', 'CIPHER_DES_CBC',
+    
+    ## MAC algorithms
+    'MAC_SHA1', 'MAC_MD5', 'MAC_RMD160',
+    
+    ## Compressions
+    'COMP_DEFLATE', 'COMP_LZO', 'COMP_NULL',
+
+    ## Credential types
+    'CRED_CERTIFICATE', 'CRED_ANON',
+
+    ## X509 certificate/private key formats
+    'X509_FMT_DER', 'X509_FMT_PEM',
+
+    ## Miscellaneous
+    'CERT_REQUEST', 'CERT_REQUIRE', 'SHUT_RDWR', 'SHUT_WR'
+]
+
+__name_map__ = {
+    'PROTO_TLS1_1': 'TLS1_1', 'PROTO_TLS1_0': 'TLS1_0', 'PROTO_SSL3': 'SSL3',
+    'CRED_CERTIFICATE': 'CRD_CERTIFICATE', 'CRED_ANON': 'CRD_ANON'
+}
+
+
+from gnutls.library import constants
+
+class GNUTLSConstant(int):
+    def __new__(cls, name):
+        gnutls_name = 'GNUTLS_' + __name_map__.get(name, name)
+        instance = int.__new__(cls, getattr(constants, gnutls_name))
+        instance.name = name
+        return instance
+    def __repr__(self):
+        return self.name
+
+## Generate all exported constants
+code = '\n'.join(["%s = GNUTLSConstant('%s')" % (name, name) for name in __all__])
+exec code in locals(), globals()
+del code, name
+
+del constants
diff --git a/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/crypto.py b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/crypto.py
new file mode 100644
index 0000000..d330144
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/crypto.py
@@ -0,0 +1,317 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS crypto support"""
+
+__all__ = ['X509Name', 'X509Certificate', 'X509PrivateKey', 'X509Identity', 'X509CRL', 'DHParams', 'RSAParams']
+
+import re
+from ctypes import *
+
+from gnutls.validators import method_args, one_of
+from gnutls.constants import X509_FMT_DER, X509_FMT_PEM
+from gnutls.errors import *
+
+from gnutls.library.constants import GNUTLS_SAN_DNSNAME, GNUTLS_SAN_RFC822NAME, GNUTLS_SAN_URI
+from gnutls.library.constants import GNUTLS_SAN_IPADDRESS, GNUTLS_SAN_OTHERNAME, GNUTLS_SAN_DN
+from gnutls.library.constants import GNUTLS_E_SHORT_MEMORY_BUFFER
+from gnutls.library.types     import *
+from gnutls.library.functions import *
+
+
+class X509NameMeta(type):
+    long_names = {'country': 'C',
+                  'state': 'ST',
+                  'locality': 'L',
+                  'common_name': 'CN',
+                  'organization': 'O',
+                  'organization_unit': 'OU',
+                  'email': 'EMAIL'}
+    def __new__(cls, name, bases, dic):
+        instance = type.__new__(cls, name, bases, dic)
+        instance.ids = X509NameMeta.long_names.values()
+        for long_name, short_name in X509NameMeta.long_names.items():
+            ## Map a long_name property to the short_name attribute
+            cls.add_property(instance, long_name, short_name)
+        return instance
+    def add_property(instance, name, short_name):
+        setattr(instance, name, property(lambda self: getattr(self, short_name, None)))
+
+
+class X509Name(str):
+    __metaclass__ = X509NameMeta
+
+    def __init__(self, dname):
+        str.__init__(self)
+        pairs = [x.replace('\,', ',') for x in re.split(r'(?<!\\),\s*', dname)]
+        for pair in pairs:
+            try:
+                name, value = pair.split('=', 1)
+            except ValueError:
+                raise ValueError("Invalid X509 distinguished name: %s" % dname)
+            str.__setattr__(self, name, value)
+        for name in X509Name.ids:
+            if not hasattr(self, name):
+                str.__setattr__(self, name, None)
+    def __setattr__(self, name, value):
+        if name in X509Name.ids:
+            raise AttributeError("can't set attribute")
+        str.__setattr__(self, name, value)
+
+
+class AlternativeNames(object):
+    __slots__ = {'dns': GNUTLS_SAN_DNSNAME, 'email': GNUTLS_SAN_RFC822NAME, 'uri': GNUTLS_SAN_URI,
+                 'ip': GNUTLS_SAN_IPADDRESS, 'other': GNUTLS_SAN_OTHERNAME, 'dn': GNUTLS_SAN_DN}
+    def __init__(self, names):
+        object.__init__(self)
+        for name, key in self.__slots__.iteritems():
+            setattr(self, name, tuple(names.get(key, ())))
+
+
+class X509Certificate(object):
+
+    def __new__(cls, *args, **kwargs):
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_x509_crt_deinit
+        instance._c_object = gnutls_x509_crt_t()
+        instance._alternative_names = None
+        return instance
+
+    @method_args(str, one_of(X509_FMT_PEM, X509_FMT_DER))
+    def __init__(self, buf, format=X509_FMT_PEM):
+        gnutls_x509_crt_init(byref(self._c_object))
+        data = gnutls_datum_t(cast(c_char_p(buf), POINTER(c_ubyte)), c_uint(len(buf)))
+        gnutls_x509_crt_import(self._c_object, byref(data), format)
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
+    @property
+    def subject(self):
+        size = c_size_t(256)
+        dname = create_string_buffer(size.value)
+        try:
+            gnutls_x509_crt_get_dn(self._c_object, dname, byref(size))
+        except MemoryError:
+            dname = create_string_buffer(size.value)
+            gnutls_x509_crt_get_dn(self._c_object, dname, byref(size))
+        return X509Name(dname.value)
+
+    @property
+    def issuer(self):
+        size = c_size_t(256)
+        dname = create_string_buffer(size.value)
+        try:
+            gnutls_x509_crt_get_issuer_dn(self._c_object, dname, byref(size))
+        except MemoryError:
+            dname = create_string_buffer(size.value)
+            gnutls_x509_crt_get_issuer_dn(self._c_object, dname, byref(size))
+        return X509Name(dname.value)
+
+    @property
+    def alternative_names(self):
+        if self._alternative_names is not None:
+            return self._alternative_names
+        names = {}
+        size = c_size_t(256)
+        alt_name = create_string_buffer(size.value)
+        for i in xrange(65536):
+            try:
+                name_type = gnutls_x509_crt_get_subject_alt_name(self._c_object, i, alt_name, byref(size), None)
+            except RequestedDataNotAvailable:
+                break
+            except MemoryError:
+                alt_name = create_string_buffer(size.value)
+                name_type = gnutls_x509_crt_get_subject_alt_name(self._c_object, i, alt_name, byref(size), None)
+            names.setdefault(name_type, []).append(alt_name.value)
+        self._alternative_names = AlternativeNames(names)
+        return self._alternative_names
+
+    @property
+    def serial_number(self):
+        size = c_size_t(1)
+        serial = c_ulong()
+        try:
+            gnutls_x509_crt_get_serial(self._c_object, cast(byref(serial), c_void_p), byref(size))
+        except MemoryError:
+            import struct, sys
+            serial = create_string_buffer(size.value * sizeof(c_void_p))
+            gnutls_x509_crt_get_serial(self._c_object, cast(serial, c_void_p), byref(size))
+            pad = size.value * sizeof(c_void_p) - len(serial.value)
+            format = '@%dL' % size.value
+            numbers = list(struct.unpack(format, serial.value + pad*'\x00'))
+            if sys.byteorder == 'little':
+                numbers.reverse()
+            number = 0
+            offset = sizeof(c_void_p) * 8
+            for n in numbers:
+                number = (number<<offset) + n
+            return number
+        else:
+            return serial.value
+
+    @property
+    def activation_time(self):
+        return gnutls_x509_crt_get_activation_time(self._c_object)
+
+    @property
+    def expiration_time(self):
+        return gnutls_x509_crt_get_expiration_time(self._c_object)
+
+    @property
+    def version(self):
+        return gnutls_x509_crt_get_version(self._c_object)
+
+    #@method_args(X509Certificate)
+    def has_issuer(self, issuer):
+        """Return True if the certificate was issued by the given issuer, False otherwise."""
+        if not isinstance(issuer, X509Certificate):
+            raise TypeError("issuer must be an X509Certificate object")
+        return bool(gnutls_x509_crt_check_issuer(self._c_object, issuer._c_object))
+
+    @method_args(str)
+    def has_hostname(self, hostname):
+        """Return True if the hostname matches the DNSName/IPAddress subject alternative name extension
+           of this certificate, False otherwise."""
+        ## For details see http://www.ietf.org/rfc/rfc2459.txt, section 4.2.1.7 Subject Alternative Name
+        return bool(gnutls_x509_crt_check_hostname(self._c_object, hostname))
+
+    def check_issuer(self, issuer):
+        """Raise CertificateError if certificate was not issued by the given issuer"""
+        if not self.has_issuer(issuer):
+            raise CertificateError("certificate issuer doesn't match")
+
+    def check_hostname(self, hostname):
+        """Raise CertificateError if the certificate DNSName/IPAddress subject alternative name extension
+           doesn't match the given hostname"""
+        if not self.has_hostname(hostname):
+            raise CertificateError("certificate doesn't match hostname")
+
+
+class X509PrivateKey(object):
+    def __new__(cls, *args, **kwargs):
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_x509_privkey_deinit
+        instance._c_object = gnutls_x509_privkey_t()
+        return instance
+
+    @method_args(str, one_of(X509_FMT_PEM, X509_FMT_DER))
+    def __init__(self, buf, format=X509_FMT_PEM):
+        gnutls_x509_privkey_init(byref(self._c_object))
+        data = gnutls_datum_t(cast(c_char_p(buf), POINTER(c_ubyte)), c_uint(len(buf)))
+        gnutls_x509_privkey_import(self._c_object, byref(data), format)
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
+
+class X509Identity(object):
+    """A X509 identity represents a X509 certificate and private key pair"""
+    
+    __slots__ = ('cert', 'key')
+    
+    @method_args(X509Certificate, X509PrivateKey)
+    def __init__(self, cert, key):
+        self.cert = cert
+        self.key = key
+    
+    def __setattr__(self, name, value):
+        if name in self.__slots__ and hasattr(self, name):
+            raise AttributeError("can't set attribute")
+        object.__setattr__(self, name, value)
+
+    def __delattr__(self, name):
+        if name in self.__slots__:
+            raise AttributeError("can't delete attribute")
+        object.__delattr__(self, name)
+
+
+class X509CRL(object):
+    def __new__(cls, *args, **kwargs):
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_x509_crl_deinit
+        instance._c_object = gnutls_x509_crl_t()
+        return instance
+
+    @method_args(str, one_of(X509_FMT_PEM, X509_FMT_DER))
+    def __init__(self, buf, format=X509_FMT_PEM):
+        gnutls_x509_crl_init(byref(self._c_object))
+        data = gnutls_datum_t(cast(c_char_p(buf), POINTER(c_ubyte)), c_uint(len(buf)))
+        gnutls_x509_crl_import(self._c_object, byref(data), format)
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
+    @property
+    def count(self):
+        return gnutls_x509_crl_get_crt_count(self._c_object)
+
+    @property
+    def version(self):
+        return gnutls_x509_crl_get_version(self._c_object)
+
+    @property
+    def issuer(self):
+        size = c_size_t(256)
+        dname = create_string_buffer(size.value)
+        try:
+            gnutls_x509_crl_get_issuer_dn(self._c_object, dname, byref(size))
+        except MemoryError:
+            dname = create_string_buffer(size.value)
+            gnutls_x509_crl_get_issuer_dn(self._c_object, dname, byref(size))
+        return X509Name(dname.value)
+
+    @method_args(X509Certificate)
+    def is_revoked(self, cert):
+        """Return True if certificate is revoked, False otherwise"""
+        return bool(gnutls_x509_crt_check_revocation(cert._c_object, byref(self._c_object), 1))
+
+    def check_revocation(self, cert, cert_name='certificate'):
+        """Raise CertificateRevokedError if the given certificate is revoked"""
+        if self.is_revoked(cert):
+            raise CertificateRevokedError("%s was revoked" % cert_name)
+
+
+class DHParams(object):
+    def __new__(cls, *args, **kwargs):
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_dh_params_deinit
+        instance._c_object = gnutls_dh_params_t()
+        return instance
+
+    @method_args(int)
+    def __init__(self, bits=1024):
+        gnutls_dh_params_init(byref(self._c_object))
+        gnutls_dh_params_generate2(self._c_object, bits)
+
+    def __get__(self, obj, type_=None):
+        return self._c_object
+
+    def __set__(self, obj, value):
+        raise AttributeError("Read-only attribute")
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
+
+class RSAParams(object):
+    def __new__(cls, *args, **kwargs):
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_rsa_params_deinit
+        instance._c_object = gnutls_rsa_params_t()
+        return instance
+
+    @method_args(int)
+    def __init__(self, bits=1024):
+        gnutls_rsa_params_init(byref(self._c_object))
+        gnutls_rsa_params_generate2(self._c_object, bits)
+
+    def __get__(self, obj, type_=None):
+        return self._c_object
+
+    def __set__(self, obj, value):
+        raise AttributeError("Read-only attribute")
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
diff --git a/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/errors.py b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/errors.py
new file mode 100644
index 0000000..592ba1d
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/errors.py
@@ -0,0 +1,22 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS errors"""
+
+__all__ = ['Error', 'GNUTLSError', 'OperationWouldBlock', 'OperationInterrupted',
+           'CertificateError', 'CertificateAuthorityError', 'CertificateSecurityError',
+           'CertificateExpiredError', 'CertificateRevokedError', 'RequestedDataNotAvailable']
+
+class Error(Exception): pass
+
+class GNUTLSError(Error): pass
+class OperationWouldBlock(GNUTLSError): pass
+class OperationInterrupted(GNUTLSError): pass
+
+class CertificateError(GNUTLSError): pass
+class CertificateAuthorityError(CertificateError): pass
+class CertificateSecurityError(CertificateError): pass
+class CertificateExpiredError(CertificateError): pass
+class CertificateRevokedError(CertificateError): pass
+
+class RequestedDataNotAvailable(GNUTLSError): pass
diff --git a/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/interfaces/__init__.py b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/interfaces/__init__.py
new file mode 100644
index 0000000..dc64199
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/interfaces/__init__.py
@@ -0,0 +1,2 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
diff --git a/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/interfaces/twisted/__init__.py b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/interfaces/twisted/__init__.py
new file mode 100644
index 0000000..cee60bf
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/interfaces/twisted/__init__.py
@@ -0,0 +1,372 @@
+# Copyright (C) 2007-2008 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS Twisted interface"""
+
+__all__ = ['X509Credentials', 'connectTLS', 'listenTLS']
+
+import socket
+from time import time
+from errno import EWOULDBLOCK, EINTR
+
+from twisted.python import failure
+from twisted.internet import main, base, interfaces, address, tcp, error
+from twisted.internet.protocol import BaseProtocol
+
+from zope.interface import implements, implementsOnly, implementedBy
+
+from gnutls.connection import ClientSession, ServerSession, ServerSessionFactory
+from gnutls.connection import X509Credentials as _X509Credentials
+from gnutls.constants import SHUT_RDWR, SHUT_WR
+from gnutls.errors import *
+
+
+class KeepRunning:
+    """Return this class from a recurrent function to indicate that it should keep running"""
+    pass
+
+class RecurrentCall(object):
+    """Execute a function repeatedly at the given interval, until signaled to stop"""
+    def __init__(self, period, func, *args, **kwargs):
+        from twisted.internet import reactor
+        self.func = func
+        self.args = args
+        self.kwargs = kwargs
+        self.period = period
+        self.now = None
+        self.next = None
+        self.callid = reactor.callLater(period, self)
+    def __call__(self):
+        from twisted.internet import reactor
+        self.callid = None
+        if self.now is None:
+            self.now = time()
+            self.next = self.now + self.period
+        else:
+            self.now, self.next = self.next, self.next + self.period
+        result = self.func(*self.args, **self.kwargs)
+        if result is KeepRunning:
+            delay = max(self.next-time(), 0)
+            self.callid = reactor.callLater(delay, self)
+    def cancel(self):
+        if self.callid is not None:
+            try:
+                self.callid.cancel()
+            except ValueError:
+                pass
+            self.callid = None
+
+
+class CertificateOK: pass
+
+class X509Credentials(_X509Credentials):
+    """A Twisted enhanced X509Credentials"""
+    verify_peer = False
+    verify_period = None
+
+    def verify_callback(self, peer_cert, preverify_status=None):
+        """Verifies the peer certificate and raises an exception if it cannot be accepted"""
+        if isinstance(preverify_status, Exception):
+            raise preverify_status
+        self.check_certificate(peer_cert, cert_name='peer certificate')
+
+
+class TLSMixin:
+    """TLS specific functionality common to both clients and servers"""
+
+    def getPeerCertificate(self):
+        return self.socket.peer_certificate
+
+    def doRead(self):
+        try:
+            return tcp.Connection.doRead(self)
+        except (OperationWouldBlock, OperationInterrupted):
+            return
+        except GNUTLSError, e:
+            return e
+
+    def writeSomeData(self, data):
+        try:
+            return tcp.Connection.writeSomeData(self, data)
+        except OperationInterrupted:
+            return self.writeSomeData(data)
+        except OperationWouldBlock:
+            return 0
+        except GNUTLSError, e:
+            return e
+
+    def _sendCloseReason(self, reason):
+        try:
+            self.socket.send_alert(reason)
+        except OperationInterrupted:
+            self._sendCloseReason(reason)
+
+    def _sendCloseAlert(self, how=SHUT_RDWR):
+        try:
+            self.socket.bye(how)
+        except OperationInterrupted:
+            self._sendCloseAlert(how)
+
+    def closeTLSSession(self, reason):
+        try:
+            self._sendCloseReason(reason)
+            self._sendCloseAlert(SHUT_RDWR)
+        except Exception, e:
+            pass
+
+    def _postLoseConnection(self):
+        self.closeTLSSession(self._close_reason)
+        return self._close_reason
+
+    def endTLSWrite(self):
+        self.stopWriting()
+        try:
+            self._sendCloseAlert(SHUT_WR)
+        except OperationWouldBlock, e:
+            if self.socket.interrupted_while_writing:
+                self.startWriting()
+                return
+        except Exception, e:
+            return e
+        del self.doWrite
+
+    def _closeWriteConnection(self):
+        self.doWrite = self.endTLSWrite
+        result = self.endTLSWrite()
+        if isinstance(result, Exception):
+            return result
+        return tcp.Connection._closeWriteConnection(self)
+
+
+class TLSClient(TLSMixin, tcp.Client):
+    """Add TLS capabilities to a TCP client"""
+    
+    implementsOnly(interfaces.ISSLTransport, *[i for i in implementedBy(tcp.Client) if i != interfaces.ITLSTransport])
+    
+    def __init__(self, host, port, bindAddress, credentials, connector, reactor=None, server_name=None):
+        self.credentials = credentials
+        self.server_name = server_name
+        self.__watchdog = None
+        tcp.Client.__init__(self, host, port, bindAddress, connector, reactor)
+
+    def createInternetSocket(self):
+        sock = tcp.Client.createInternetSocket(self)
+        return ClientSession(sock, self.credentials, self.server_name)
+
+    def _recurrentVerify(self):
+        if not self.connected or self.disconnecting:
+            return
+        try:
+            self.credentials.verify_callback(self.socket.peer_certificate)
+        except Exception, e:
+            self.loseConnection(e)
+            return
+        else:
+            return KeepRunning
+
+    def _verifyPeer(self):
+        session = self.socket
+        credentials = self.credentials
+        if not credentials.verify_peer:
+            return
+        try:
+            session.verify_peer()
+        except Exception, e:
+            preverify_status = e
+        else:
+            preverify_status = CertificateOK
+        
+        credentials.verify_callback(session.peer_certificate, preverify_status)
+        
+        if credentials.verify_period > 0:
+            self.__watchdog = RecurrentCall(credentials.verify_period, self._recurrentVerify)
+
+    def doHandshake(self):
+        self.stopWriting()
+        try:
+            self.socket.handshake()
+        except (OperationWouldBlock, OperationInterrupted):
+            if self.socket.interrupted_while_writing:
+                self.startWriting()
+            return
+        except GNUTLSError, e:
+            del self.doRead
+            self.failIfNotConnected(err = e)
+            return
+        
+        ## reset any references to the old doRead
+        del self.doRead
+        self.stopReading()
+        
+        try:
+            self._verifyPeer()
+        except GNUTLSError, e:
+            self.closeTLSSession(e)
+            self.failIfNotConnected(err = e)
+            return
+        except Exception, e:
+            self.closeTLSSession(e)
+            self.failIfNotConnected(err = error.getConnectError(str(e)))
+            return
+        
+        ## TLS handshake (including certificate verification) finished succesfully
+        tcp.Client._connectDone(self)
+        
+    def startTLS(self):
+        self.doRead = self.doHandshake
+        self.startReading()
+        self.doHandshake()
+
+    def _connectDone(self):
+        self.startTLS()
+
+    def loseConnection(self, reason=failure.Failure(main.CONNECTION_DONE)):
+        reason = failure.Failure(reason) # accept python exceptions too
+        self._close_reason = reason.value
+        tcp.Client.loseConnection(self, reason)
+
+    def connectionLost(self, reason):
+        if self.__watchdog is not None:
+            self.__watchdog.cancel()
+            self.__watchdog = None
+        tcp.Client.connectionLost(self, reason)
+
+
+class TLSConnector(base.BaseConnector):
+    def __init__(self, host, port, factory, credentials, timeout, bindAddress, reactor=None, server_name=None):
+        self.host = host
+        self.port = port
+        self.bindAddress = bindAddress
+        self.credentials = credentials
+        self.server_name = server_name
+        base.BaseConnector.__init__(self, factory, timeout, reactor)
+
+    def _makeTransport(self):
+        return TLSClient(self.host, self.port, self.bindAddress, self.credentials, self, self.reactor, self.server_name)
+
+
+class TLSServer(TLSMixin, tcp.Server):
+    """Add TLS capabilities to a TCP server"""
+    
+    #implements(interfaces.ISSLTransport)
+    implementsOnly(interfaces.ISSLTransport, *[i for i in implementedBy(tcp.Server) if i != interfaces.ITLSTransport])
+    
+    def __init__(self, sock, protocol, client, server, sessionno, *args, **kw):
+        self.__watchdog = None
+        self.credentials = server.credentials
+        tcp.Server.__init__(self, sock, protocol, client, server, sessionno, *args, **kw)
+
+    def _recurrentVerify(self):
+        if not self.connected or self.disconnecting:
+            return
+        try:
+            self.credentials.verify_callback(self.socket.peer_certificate)
+        except Exception, e:
+            self.loseConnection(e)
+            return
+        else:
+            return KeepRunning
+
+    def _verifyPeer(self):
+        session = self.socket
+        credentials = self.credentials
+        if not credentials.verify_peer:
+            return
+        try:
+            session.verify_peer()
+        except Exception, e:
+            preverify_status = e
+        else:
+            preverify_status = CertificateOK
+        
+        credentials.verify_callback(session.peer_certificate, preverify_status)
+        
+        if credentials.verify_period > 0:
+            self.__watchdog = RecurrentCall(credentials.verify_period, self._recurrentVerify)
+
+    def doHandshake(self):
+        self.stopWriting()
+        try:
+            self.socket.handshake()
+        except (OperationWouldBlock, OperationInterrupted):
+            if self.socket.interrupted_while_writing:
+                self.startWriting()
+            return
+        except GNUTLSError, e:
+            del self.doRead
+            return e
+        
+        ## reset any references to the old doRead
+        del self.doRead
+        self.stopReading()
+        self.startReading()
+        
+        try:
+            self._verifyPeer()
+        except Exception, e:
+            self.loseConnection(e)
+            return
+        
+        ## TLS handshake (including certificate verification) finished succesfully
+        
+        del self.protocol.makeConnection
+        self.protocol.makeConnection(self)
+
+    def startTLS(self):
+        self.doRead = self.doHandshake
+        self.startReading()
+
+    def loseConnection(self, reason=failure.Failure(main.CONNECTION_DONE)):
+        reason = failure.Failure(reason) # accept python exceptions too
+        self._close_reason = reason.value
+        tcp.Server.loseConnection(self, reason)
+
+    def connectionLost(self, reason):
+        if self.__watchdog is not None:
+            self.__watchdog.cancel()
+            self.__watchdog = None
+        tcp.Server.connectionLost(self, reason)
+
+
+class TLSPort(tcp.Port):
+    """Add TLS capabilities to a TCP port"""
+
+    transport = TLSServer
+
+    def __init__(self, port, factory, credentials, backlog=50, interface='', reactor=None):
+        tcp.Port.__init__(self, port, factory, backlog, interface, reactor)
+        self.credentials = credentials
+
+    def createInternetSocket(self):
+        sock = tcp.Port.createInternetSocket(self)
+        return ServerSessionFactory(sock, self.credentials, ServerSession)
+
+    def _preMakeConnection(self, transport):
+        transport.protocol.makeConnection = lambda *args: None
+        transport.protocol.transport = transport ## because we may call connectionLost without connectionMade
+        transport.startTLS()
+        return tcp.Port._preMakeConnection(self, transport)
+
+
+def connectTLS(reactor, host, port, factory, credentials, timeout=30, bindAddress=None, server_name=None):
+    c = TLSConnector(host, port, factory, credentials, timeout, bindAddress, reactor, server_name)
+    c.connect()
+    return c
+
+
+def listenTLS(reactor, port, factory, credentials, backlog=50, interface=''):
+    p = TLSPort(port, factory, credentials, backlog, interface, reactor)
+    p.startListening()
+    return p
+
+## Add the connectTLS and listenTLS methods to the reactor
+
+import new
+from twisted.internet.posixbase import PosixReactorBase
+
+method = new.instancemethod(connectTLS, None, PosixReactorBase)
+setattr(PosixReactorBase, 'connectTLS', method)
+
+method = new.instancemethod(listenTLS, None, PosixReactorBase)
+setattr(PosixReactorBase, 'listenTLS', method)
+
diff --git a/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/library/__init__.py b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/library/__init__.py
new file mode 100644
index 0000000..494460f
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/library/__init__.py
@@ -0,0 +1,17 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+from gnutls.library import _gnutls_init
+from gnutls.library import constants
+from gnutls.library import types
+from gnutls.library import errors
+from gnutls.library import functions
+
+__need_version__ = '2.4.1'
+
+if functions.gnutls_check_version(__need_version__) is None:
+    version = functions.gnutls_check_version(None)
+    raise RuntimeError("Found GNUTLS library version %s, but at least version %s is required" % (version, __need_version__))
+if functions.gnutls_extra_check_version(__need_version__) is None:
+    version = functions.gnutls_extra_check_version(None)
+    raise RuntimeError("Found GNUTLS extra library version %s, but at least version %s is required" % (version, __need_version__))
diff --git a/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/library/constants.py b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/library/constants.py
new file mode 100644
index 0000000..43c82d3
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/library/constants.py
@@ -0,0 +1,648 @@
+from ctypes import *
+
+STRING = c_char_p
+
+
+GNUTLS_CRD_IA = 5
+GNUTLS_CERT_REQUIRE = 2
+GNUTLS_PKCS_USE_PKCS12_3DES = 2
+GNUTLS_CRD_CERTIFICATE = 1
+GNUTLS_HANDSHAKE_SERVER_HELLO_DONE = 14
+GNUTLS_SIGN_RSA_RMD160 = 5
+GNUTLS_PKCS_PLAIN = 1
+GNUTLS_A_UNKNOWN_CA = 48
+GNUTLS_CRT_PRINT_ONELINE = 1
+GNUTLS_PKCS_USE_PKCS12_ARCFOUR = 4
+GNUTLS_A_UNKNOWN_PSK_IDENTITY = 115
+GNUTLS_CRT_X509 = 1
+GNUTLS_KX_DHE_PSK = 10
+GNUTLS_PARAMS_RSA_EXPORT = 1
+GNUTLS_DIG_NULL = 1
+GNUTLS_KX_PSK = 9
+GNUTLS_CIPHER_RC2_40_CBC = 90
+GNUTLS_AL_WARNING = 1
+GNUTLS_DIG_SHA256 = 6
+GNUTLS_CERT_INSECURE_ALGORITHM = 256
+GNUTLS_SIGN_RSA_MD2 = 4
+GNUTLS_CRT_PRINT_UNSIGNED_FULL = 2
+GNUTLS_PK_DSA = 2
+GNUTLS_A_UNRECOGNIZED_NAME = 112
+GNUTLS_A_INNER_APPLICATION_FAILURE = 208
+GNUTLS_VERIFY_DO_NOT_ALLOW_SAME = 4
+GNUTLS_CIPHER_AES_128_CBC = 4
+GNUTLS_CRT_PRINT_FULL = 0
+GNUTLS_PKCS_USE_PBES2_3DES = 16
+GNUTLS_SSL3 = 1
+GNUTLS_SAN_OTHERNAME_XMPP = 1000
+GNUTLS_DIG_SHA384 = 7
+GNUTLS_MAC_UNKNOWN = 0
+GNUTLS_A_CERTIFICATE_UNOBTAINABLE = 111
+GNUTLS_OPENPGP_CERT_FINGERPRINT = 1
+GNUTLS_SIGN_RSA_SHA512 = 8
+GNUTLS_A_DECRYPT_ERROR = 51
+GNUTLS_SAN_DN = 6
+GNUTLS_SAN_DNSNAME = 1
+GNUTLS_CRT_UNKNOWN = 0
+GNUTLS_SERVER = 1
+GNUTLS_CIPHER_NULL = 1
+GNUTLS_CIPHER_DES_CBC = 91
+GNUTLS_A_USER_CANCELED = 90
+GNUTLS_TLS1_1 = 3
+GNUTLS_CRT_OPENPGP = 2
+GNUTLS_SHUT_WR = 1
+GNUTLS_KX_ANON_DH = 4
+GNUTLS_A_EXPORT_RESTRICTION = 60
+GNUTLS_HANDSHAKE_FINISHED = 20
+GNUTLS_KX_UNKNOWN = 0
+GNUTLS_MAC_NULL = 1
+GNUTLS_SAN_IPADDRESS = 4
+GNUTLS_HANDSHAKE_CLIENT_HELLO = 1
+GNUTLS_CRD_ANON = 2
+GNUTLS_SHUT_RDWR = 0
+GNUTLS_A_SSL3_NO_CERTIFICATE = 41
+GNUTLS_COMP_NULL = 1
+GNUTLS_TLS1_2 = 4
+GNUTLS_IA_APPLICATION_PAYLOAD = 0
+GNUTLS_SIGN_RSA_SHA224 = 9
+GNUTLS_HANDSHAKE_CERTIFICATE_PKT = 11
+GNUTLS_DIG_MD2 = 5
+GNUTLS_PK_RSA = 1
+GNUTLS_CIPHER_CAMELLIA_256_CBC = 8
+GNUTLS_HANDSHAKE_SUPPLEMENTAL = 23
+GNUTLS_SIGN_UNKNOWN = 0
+GNUTLS_PARAMS_DH = 2
+GNUTLS_PK_UNKNOWN = 0
+GNUTLS_A_INSUFFICIENT_SECURITY = 71
+GNUTLS_DIG_SHA512 = 8
+GNUTLS_SUPPLEMENTAL_USER_MAPPING_DATA = 0
+GNUTLS_KX_RSA = 1
+GNUTLS_SIGN_RSA_SHA384 = 7
+GNUTLS_A_RECORD_OVERFLOW = 22
+GNUTLS_KX_DHE_RSA = 3
+GNUTLS_COMP_LZO = 3
+GNUTLS_CERT_IGNORE = 0
+GNUTLS_SIGN_RSA_SHA1 = 1
+GNUTLS_A_ILLEGAL_PARAMETER = 47
+GNUTLS_A_NO_RENEGOTIATION = 100
+GNUTLS_A_PROTOCOL_VERSION = 70
+GNUTLS_A_DECOMPRESSION_FAILURE = 30
+GNUTLS_A_CERTIFICATE_REVOKED = 44
+GNUTLS_CIPHER_AES_256_CBC = 5
+GNUTLS_A_INTERNAL_ERROR = 80
+GNUTLS_HANDSHAKE_HELLO_REQUEST = 0
+GNUTLS_X509_FMT_DER = 0
+GNUTLS_HANDSHAKE_CERTIFICATE_REQUEST = 13
+GNUTLS_HANDSHAKE_SERVER_HELLO = 2
+GNUTLS_A_HANDSHAKE_FAILURE = 40
+GNUTLS_DIG_MD5 = 2
+GNUTLS_SIGN_RSA_MD5 = 3
+GNUTLS_MAC_SHA256 = 6
+GNUTLS_OPENPGP_CERT = 0
+GNUTLS_CERT_SIGNER_NOT_CA = 128
+GNUTLS_AL_FATAL = 2
+GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD2 = 16
+GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT = 2
+GNUTLS_CIPHER_3DES_CBC = 3
+GNUTLS_A_DECRYPTION_FAILED = 21
+GNUTLS_HANDSHAKE_CLIENT_KEY_EXCHANGE = 16
+GNUTLS_SAN_RFC822NAME = 2
+GNUTLS_CRD_PSK = 4
+GNUTLS_OPENPGP_FMT_RAW = 0
+GNUTLS_CERT_SIGNER_NOT_FOUND = 64
+GNUTLS_A_UNSUPPORTED_EXTENSION = 110
+GNUTLS_DIG_SHA1 = 3
+GNUTLS_DIG_RMD160 = 4
+GNUTLS_A_CLOSE_NOTIFY = 0
+GNUTLS_KX_SRP_RSA = 7
+GNUTLS_MAC_MD5 = 2
+GNUTLS_IA_FINAL_PHASE_FINISHED = 2
+GNUTLS_A_UNSUPPORTED_CERTIFICATE = 43
+GNUTLS_COMP_UNKNOWN = 0
+GNUTLS_PKCS_USE_PKCS12_RC2_40 = 8
+GNUTLS_CIPHER_UNKNOWN = 0
+GNUTLS_PSK_KEY_HEX = 1
+GNUTLS_KX_SRP_DSS = 8
+GNUTLS_MAC_SHA384 = 7
+GNUTLS_SAN_URI = 3
+GNUTLS_X509_FMT_PEM = 1
+GNUTLS_X509_CRT_LIST_IMPORT_FAIL_IF_EXCEED = 1
+GNUTLS_HANDSHAKE_CERTIFICATE_VERIFY = 15
+GNUTLS_A_DECODE_ERROR = 50
+GNUTLS_MAC_SHA1 = 3
+GNUTLS_HANDSHAKE_SERVER_KEY_EXCHANGE = 12
+GNUTLS_IA_INTERMEDIATE_PHASE_FINISHED = 1
+GNUTLS_A_CERTIFICATE_UNKNOWN = 46
+GNUTLS_OPENPGP_FMT_BASE64 = 1
+GNUTLS_CLIENT = 2
+GNUTLS_PSK_KEY_RAW = 0
+GNUTLS_A_UNEXPECTED_MESSAGE = 10
+GNUTLS_CERT_INVALID = 2
+GNUTLS_CRD_SRP = 3
+GNUTLS_A_BAD_RECORD_MAC = 20
+GNUTLS_MAC_RMD160 = 4
+GNUTLS_DIG_SHA224 = 9
+GNUTLS_TLS1_0 = 2
+GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD5 = 32
+GNUTLS_KX_SRP = 5
+GNUTLS_A_CERTIFICATE_EXPIRED = 45
+GNUTLS_MAC_MD2 = 5
+GNUTLS_VERIFY_ALLOW_ANY_X509_V1_CA_CRT = 8
+GNUTLS_A_ACCESS_DENIED = 49
+GNUTLS_VERIFY_DISABLE_CA_SIGN = 1
+GNUTLS_CIPHER_ARCFOUR_40 = 6
+GNUTLS_A_BAD_CERTIFICATE = 42
+GNUTLS_CERT_REVOKED = 32
+GNUTLS_CERT_REQUEST = 1
+GNUTLS_MAC_SHA512 = 8
+GNUTLS_SAN_OTHERNAME = 5
+GNUTLS_VERSION_UNKNOWN = 255
+GNUTLS_KX_RSA_EXPORT = 6
+GNUTLS_CIPHER_CAMELLIA_128_CBC = 7
+GNUTLS_COMP_DEFLATE = 2
+GNUTLS_NAME_DNS = 1
+GNUTLS_SIGN_DSA_SHA1 = 2
+GNUTLS_A_INNER_APPLICATION_VERIFICATION = 209
+GNUTLS_CIPHER_ARCFOUR_128 = 2
+GNUTLS_KX_DHE_DSS = 2
+GNUTLS_SIGN_RSA_SHA256 = 6
+GNUTLS_E_UNKNOWN_PK_ALGORITHM = -80 # Variable c_int
+TLS_MASTER_SIZE = 48 # Variable c_int
+LIBGNUTLS_VERSION_NUMBER = 132097 # Variable c_int
+GNUTLS_E_FATAL_ALERT_RECEIVED = -12 # Variable c_int
+GNUTLS_E_LARGE_PACKET = -7 # Variable c_int
+GNUTLS_E_ASN1_DER_OVERFLOW = -77 # Variable c_int
+GNUTLS_E_INCOMPATIBLE_LIBTASN1_LIBRARY = -203 # Variable c_int
+GNUTLS_E_SHORT_MEMORY_BUFFER = -51 # Variable c_int
+GNUTLS_E_UNKNOWN_ALGORITHM = -105 # Variable c_int
+GNUTLS_MAX_SESSION_ID = 32 # Variable c_int
+GNUTLS_E_OPENPGP_GETKEY_FAILED = -88 # Variable c_int
+GNUTLS_E_REHANDSHAKE = -37 # Variable c_int
+GNUTLS_E_ASN1_VALUE_NOT_FOUND = -70 # Variable c_int
+GNUTLS_E_SUCCESS = 0 # Variable c_int
+GNUTLS_E_ASN1_SYNTAX_ERROR = -76 # Variable c_int
+GNUTLS_OID_PKIX_COUNTRY_OF_RESIDENCE = '1.3.6.1.5.5.7.9.5' # Variable STRING
+GNUTLS_E_RECORD_LIMIT_REACHED = -39 # Variable c_int
+GNUTLS_E_WARNING_IA_FPHF_RECEIVED = -103 # Variable c_int
+GNUTLS_OID_X520_DN_QUALIFIER = '2.5.4.46' # Variable STRING
+GNUTLS_OID_X520_GIVEN_NAME = '2.5.4.42' # Variable STRING
+LIBGNUTLS_VERSION_MINOR = 4 # Variable c_int
+GNUTLS_E_ASN1_ELEMENT_NOT_FOUND = -67 # Variable c_int
+GNUTLS_E_CRYPTO_ALREADY_REGISTERED = -209 # Variable c_int
+GNUTLS_E_KEY_USAGE_VIOLATION = -48 # Variable c_int
+GNUTLS_E_WARNING_IA_IPHF_RECEIVED = -102 # Variable c_int
+GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM = -3 # Variable c_int
+GNUTLS_E_PK_DECRYPTION_FAILED = -45 # Variable c_int
+GNUTLS_CRL_REASON_CA_COMPROMISE = 32 # Variable c_int
+GNUTLS_E_UNKNOWN_PKCS_BAG_TYPE = -98 # Variable c_int
+GNUTLS_E_DECRYPTION_FAILED = -24 # Variable c_int
+GNUTLS_E_UNKNOWN_PKCS_CONTENT_TYPE = -97 # Variable c_int
+GNUTLS_KP_OCSP_SIGNING = '1.3.6.1.5.5.7.3.9' # Variable STRING
+GNUTLS_E_PK_SIGN_FAILED = -46 # Variable c_int
+GNUTLS_E_ASN1_TAG_IMPLICIT = -74 # Variable c_int
+GNUTLS_E_INIT_LIBEXTRA = -82 # Variable c_int
+GNUTLS_KP_TLS_WWW_SERVER = '1.3.6.1.5.5.7.3.1' # Variable STRING
+GNUTLS_E_OPENPGP_KEYRING_ERROR = -204 # Variable c_int
+GNUTLS_E_MEMORY_ERROR = -25 # Variable c_int
+GNUTLS_E_MAC_VERIFY_FAILED = -100 # Variable c_int
+GNUTLS_E_NO_TEMPORARY_DH_PARAMS = -93 # Variable c_int
+GNUTLS_KEY_NON_REPUDIATION = 64 # Variable c_int
+GNUTLS_MAX_ALGORITHM_NUM = 16 # Variable c_int
+GNUTLS_OID_X520_COUNTRY_NAME = '2.5.4.6' # Variable STRING
+GNUTLS_E_WARNING_ALERT_RECEIVED = -16 # Variable c_int
+GNUTLS_E_OPENPGP_UID_REVOKED = -79 # Variable c_int
+GNUTLS_E_PUSH_ERROR = -53 # Variable c_int
+GNUTLS_KEY_KEY_CERT_SIGN = 4 # Variable c_int
+GNUTLS_E_GOT_APPLICATION_DATA = -38 # Variable c_int
+GNUTLS_E_BASE64_DECODING_ERROR = -34 # Variable c_int
+GNUTLS_E_PULL_ERROR = -54 # Variable c_int
+GNUTLS_E_COMPRESSION_FAILED = -27 # Variable c_int
+GNUTLS_E_ASN1_DER_ERROR = -69 # Variable c_int
+GNUTLS_KEY_DECIPHER_ONLY = 32768 # Variable c_int
+GNUTLS_E_DECOMPRESSION_FAILED = -26 # Variable c_int
+LIBGNUTLS_VERSION_MAJOR = 2 # Variable c_int
+GNUTLS_E_NO_CIPHER_SUITES = -87 # Variable c_int
+GNUTLS_KEY_KEY_ENCIPHERMENT = 32 # Variable c_int
+GNUTLS_E_BASE64_UNEXPECTED_HEADER_ERROR = -207 # Variable c_int
+GNUTLS_E_ASN1_TYPE_ANY_ERROR = -75 # Variable c_int
+GNUTLS_OID_LDAP_UID = '0.9.2342.19200300.100.1.1' # Variable STRING
+GNUTLS_KEY_DATA_ENCIPHERMENT = 16 # Variable c_int
+GNUTLS_E_X509_UNSUPPORTED_OID = -205 # Variable c_int
+GNUTLS_E_NO_CERTIFICATE_FOUND = -49 # Variable c_int
+GNUTLS_E_UNIMPLEMENTED_FEATURE = -1250 # Variable c_int
+GNUTLS_E_UNSUPPORTED_VERSION_PACKET = -8 # Variable c_int
+GNUTLS_E_FILE_ERROR = -64 # Variable c_int
+GNUTLS_CRL_REASON_PRIVILEGE_WITHDRAWN = 1 # Variable c_int
+LIBGNUTLS_VERSION = '2.4.1' # Variable STRING
+GNUTLS_CRL_REASON_AFFILIATION_CHANGED = 16 # Variable c_int
+GNUTLS_OID_X520_ORGANIZATIONAL_UNIT_NAME = '2.5.4.11' # Variable STRING
+GNUTLS_OID_X520_COMMON_NAME = '2.5.4.3' # Variable STRING
+GNUTLS_E_HASH_FAILED = -33 # Variable c_int
+GNUTLS_E_PKCS1_WRONG_PAD = -57 # Variable c_int
+GNUTLS_OID_X520_GENERATION_QUALIFIER = '2.5.4.44' # Variable STRING
+GNUTLS_E_INCOMPATIBLE_CRYPTO_LIBRARY = -202 # Variable c_int
+GNUTLS_E_X509_UNSUPPORTED_CRITICAL_EXTENSION = -47 # Variable c_int
+GNUTLS_OID_X520_PSEUDONYM = '2.5.4.65' # Variable STRING
+GNUTLS_E_NO_COMPRESSION_ALGORITHMS = -86 # Variable c_int
+GNUTLS_E_UNEXPECTED_PACKET_LENGTH = -9 # Variable c_int
+GNUTLS_E_INCOMPATIBLE_GCRYPT_LIBRARY = -202 # Variable c_int
+GNUTLS_E_MPI_PRINT_FAILED = -35 # Variable c_int
+GNUTLS_E_INVALID_PASSWORD = -99 # Variable c_int
+GNUTLS_E_CERTIFICATE_KEY_MISMATCH = -60 # Variable c_int
+GNUTLS_OID_X520_STATE_OR_PROVINCE_NAME = '2.5.4.8' # Variable STRING
+GNUTLS_E_INSUFFICIENT_CREDENTIALS = -32 # Variable c_int
+GNUTLS_OID_X520_SURNAME = '2.5.4.4' # Variable STRING
+GNUTLS_E_X509_UNKNOWN_SAN = -62 # Variable c_int
+GNUTLS_KEY_CRL_SIGN = 2 # Variable c_int
+GNUTLS_E_PK_SIG_VERIFY_FAILED = -89 # Variable c_int
+GNUTLS_E_BASE64_ENCODING_ERROR = -201 # Variable c_int
+GNUTLS_E_ASN1_VALUE_NOT_VALID = -72 # Variable c_int
+GNUTLS_OID_X520_TITLE = '2.5.4.12' # Variable STRING
+GNUTLS_E_ENCRYPTION_FAILED = -40 # Variable c_int
+GNUTLS_OID_PKCS9_EMAIL = '1.2.840.113549.1.9.1' # Variable STRING
+GNUTLS_KP_ANY = '2.5.29.37.0' # Variable STRING
+GNUTLS_CRL_REASON_UNUSED = 128 # Variable c_int
+GNUTLS_E_OPENPGP_SUBKEY_ERROR = -208 # Variable c_int
+GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER = -55 # Variable c_int
+GNUTLS_E_EXPIRED = -29 # Variable c_int
+GNUTLS_E_DB_ERROR = -30 # Variable c_int
+GNUTLS_E_UNWANTED_ALGORITHM = -22 # Variable c_int
+GNUTLS_OID_PKIX_COUNTRY_OF_CITIZENSHIP = '1.3.6.1.5.5.7.9.4' # Variable STRING
+GNUTLS_E_APPLICATION_ERROR_MIN = -65500 # Variable c_int
+GNUTLS_E_INVALID_REQUEST = -50 # Variable c_int
+GNUTLS_E_ASN1_IDENTIFIER_NOT_FOUND = -68 # Variable c_int
+GNUTLS_OID_X520_INITIALS = '2.5.4.43' # Variable STRING
+GNUTLS_E_ASN1_TAG_ERROR = -73 # Variable c_int
+GNUTLS_E_X509_UNSUPPORTED_ATTRIBUTE = -95 # Variable c_int
+GNUTLS_KP_EMAIL_PROTECTION = '1.3.6.1.5.5.7.3.4' # Variable STRING
+GNUTLS_CRL_REASON_CESSATION_OF_OPERATION = 4 # Variable c_int
+GNUTLS_E_IA_VERIFY_FAILED = -104 # Variable c_int
+GNUTLS_KP_TIME_STAMPING = '1.3.6.1.5.5.7.3.8' # Variable STRING
+GNUTLS_E_INTERNAL_ERROR = -59 # Variable c_int
+GNUTLS_E_LZO_INIT_FAILED = -85 # Variable c_int
+GNUTLS_CRL_REASON_CERTIFICATE_HOLD = 2 # Variable c_int
+GNUTLS_OID_X520_ORGANIZATION_NAME = '2.5.4.10' # Variable STRING
+GNUTLS_CRL_REASON_KEY_COMPROMISE = 64 # Variable c_int
+GNUTLS_OID_PKIX_GENDER = '1.3.6.1.5.5.7.9.3' # Variable STRING
+GNUTLS_E_APPLICATION_ERROR_MAX = -65000 # Variable c_int
+GNUTLS_E_SRP_PWD_PARSING_ERROR = -91 # Variable c_int
+GNUTLS_E_NO_TEMPORARY_RSA_PARAMS = -84 # Variable c_int
+GNUTLS_OID_PKIX_PLACE_OF_BIRTH = '1.3.6.1.5.5.7.9.2' # Variable STRING
+GNUTLS_E_LIBRARY_VERSION_MISMATCH = -83 # Variable c_int
+GNUTLS_KEY_DIGITAL_SIGNATURE = 128 # Variable c_int
+GNUTLS_E_UNEXPECTED_HANDSHAKE_PACKET = -19 # Variable c_int
+GNUTLS_E_ASN1_GENERIC_ERROR = -71 # Variable c_int
+GNUTLS_E_ILLEGAL_SRP_USERNAME = -90 # Variable c_int
+_GNUTLS_GCC_VERSION = 40301 # Variable c_int
+GNUTLS_E_AGAIN = -28 # Variable c_int
+GNUTLS_E_DH_PRIME_UNACCEPTABLE = -63 # Variable c_int
+GNUTLS_E_UNSUPPORTED_CERTIFICATE_TYPE = -61 # Variable c_int
+GNUTLS_E_UNKNOWN_CIPHER_SUITE = -21 # Variable c_int
+GNUTLS_E_CONSTRAINT_ERROR = -101 # Variable c_int
+GNUTLS_E_UNEXPECTED_PACKET = -15 # Variable c_int
+TLS_RANDOM_SIZE = 32 # Variable c_int
+LIBGNUTLS_VERSION_PATCH = 1 # Variable c_int
+GNUTLS_E_RECEIVED_ILLEGAL_EXTENSION = -58 # Variable c_int
+GNUTLS_E_INVALID_SESSION = -10 # Variable c_int
+GNUTLS_KEY_KEY_AGREEMENT = 8 # Variable c_int
+GNUTLS_E_ERROR_IN_FINISHED_PACKET = -18 # Variable c_int
+GNUTLS_KEY_ENCIPHER_ONLY = 1 # Variable c_int
+GNUTLS_E_UNKNOWN_CIPHER_TYPE = -6 # Variable c_int
+GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE = -56 # Variable c_int
+GNUTLS_CRL_REASON_AA_COMPROMISE = 32768 # Variable c_int
+GNUTLS_E_CERTIFICATE_ERROR = -43 # Variable c_int
+GNUTLS_E_TOO_MANY_EMPTY_PACKETS = -78 # Variable c_int
+GNUTLS_OID_PKIX_DATE_OF_BIRTH = '1.3.6.1.5.5.7.9.1' # Variable STRING
+GNUTLS_E_PK_ENCRYPTION_FAILED = -44 # Variable c_int
+GNUTLS_OID_LDAP_DC = '0.9.2342.19200300.100.1.25' # Variable STRING
+GNUTLS_KP_TLS_WWW_CLIENT = '1.3.6.1.5.5.7.3.2' # Variable STRING
+GNUTLS_E_MPI_SCAN_FAILED = -23 # Variable c_int
+GNUTLS_E_OPENPGP_FINGERPRINT_UNSUPPORTED = -94 # Variable c_int
+GNUTLS_E_SRP_PWD_ERROR = -31 # Variable c_int
+GNUTLS_CRL_REASON_SUPERSEEDED = 8 # Variable c_int
+GNUTLS_E_INTERRUPTED = -52 # Variable c_int
+GNUTLS_OID_X520_LOCALITY_NAME = '2.5.4.7' # Variable STRING
+GNUTLS_E_UNKNOWN_HASH_ALGORITHM = -96 # Variable c_int
+GNUTLS_E_RANDOM_FAILED = -206 # Variable c_int
+GNUTLS_E_HANDSHAKE_TOO_LARGE = -210 # Variable c_int
+GNUTLS_KP_CODE_SIGNING = '1.3.6.1.5.5.7.3.3' # Variable STRING
+
+# values for enumeration 'gnutls_ia_apptype_t'
+gnutls_ia_apptype_t = c_int # enum
+
+# values for enumeration 'gnutls_cipher_algorithm_t'
+gnutls_cipher_algorithm_t = c_int # enum
+
+# values for enumeration 'gnutls_kx_algorithm_t'
+gnutls_kx_algorithm_t = c_int # enum
+
+# values for enumeration 'gnutls_params_type_t'
+gnutls_params_type_t = c_int # enum
+
+# values for enumeration 'gnutls_credentials_type_t'
+gnutls_credentials_type_t = c_int # enum
+
+# values for enumeration 'gnutls_mac_algorithm_t'
+gnutls_mac_algorithm_t = c_int # enum
+
+# values for enumeration 'gnutls_digest_algorithm_t'
+gnutls_digest_algorithm_t = c_int # enum
+
+# values for enumeration 'gnutls_compression_method_t'
+gnutls_compression_method_t = c_int # enum
+
+# values for enumeration 'gnutls_connection_end_t'
+gnutls_connection_end_t = c_int # enum
+
+# values for enumeration 'gnutls_alert_level_t'
+gnutls_alert_level_t = c_int # enum
+
+# values for enumeration 'gnutls_alert_description_t'
+gnutls_alert_description_t = c_int # enum
+
+# values for enumeration 'gnutls_handshake_description_t'
+gnutls_handshake_description_t = c_int # enum
+
+# values for enumeration 'gnutls_certificate_status_t'
+gnutls_certificate_status_t = c_int # enum
+
+# values for enumeration 'gnutls_certificate_request_t'
+gnutls_certificate_request_t = c_int # enum
+
+# values for enumeration 'gnutls_openpgp_crt_status_t'
+gnutls_openpgp_crt_status_t = c_int # enum
+
+# values for enumeration 'gnutls_close_request_t'
+gnutls_close_request_t = c_int # enum
+
+# values for enumeration 'gnutls_protocol_t'
+gnutls_protocol_t = c_int # enum
+
+# values for enumeration 'gnutls_certificate_type_t'
+gnutls_certificate_type_t = c_int # enum
+
+# values for enumeration 'gnutls_x509_crt_fmt_t'
+gnutls_x509_crt_fmt_t = c_int # enum
+
+# values for enumeration 'gnutls_certificate_print_formats'
+gnutls_certificate_print_formats = c_int # enum
+
+# values for enumeration 'gnutls_pk_algorithm_t'
+gnutls_pk_algorithm_t = c_int # enum
+
+# values for enumeration 'gnutls_sign_algorithm_t'
+gnutls_sign_algorithm_t = c_int # enum
+
+# values for enumeration 'gnutls_server_name_type_t'
+gnutls_server_name_type_t = c_int # enum
+
+# values for enumeration 'gnutls_supplemental_data_format_type_t'
+gnutls_supplemental_data_format_type_t = c_int # enum
+
+# values for enumeration 'gnutls_psk_key_flags'
+gnutls_psk_key_flags = c_int # enum
+
+# values for enumeration 'gnutls_x509_subject_alt_name_t'
+gnutls_x509_subject_alt_name_t = c_int # enum
+
+# values for enumeration 'gnutls_openpgp_crt_fmt'
+gnutls_openpgp_crt_fmt = c_int # enum
+
+# values for enumeration 'gnutls_certificate_import_flags'
+gnutls_certificate_import_flags = c_int # enum
+
+# values for enumeration 'gnutls_certificate_verify_flags'
+gnutls_certificate_verify_flags = c_int # enum
+
+# values for enumeration 'gnutls_pkcs_encrypt_flags_t'
+gnutls_pkcs_encrypt_flags_t = c_int # enum
+__all__ = ['GNUTLS_PKCS_USE_PKCS12_ARCFOUR',
+           'GNUTLS_HANDSHAKE_CLIENT_HELLO',
+           'GNUTLS_E_ASN1_DER_OVERFLOW',
+           'GNUTLS_CERT_INSECURE_ALGORITHM',
+           'GNUTLS_E_WARNING_ALERT_RECEIVED',
+           'GNUTLS_E_OPENPGP_GETKEY_FAILED', 'GNUTLS_KX_UNKNOWN',
+           'GNUTLS_E_SUCCESS', 'GNUTLS_CRT_PRINT_UNSIGNED_FULL',
+           'GNUTLS_DIG_NULL', 'GNUTLS_E_ASN1_IDENTIFIER_NOT_FOUND',
+           'GNUTLS_CIPHER_UNKNOWN', 'GNUTLS_KX_SRP_DSS',
+           'GNUTLS_A_UNSUPPORTED_EXTENSION',
+           'GNUTLS_E_WARNING_IA_IPHF_RECEIVED',
+           'GNUTLS_CRL_REASON_CA_COMPROMISE',
+           'GNUTLS_E_LZO_INIT_FAILED', 'gnutls_pkcs_encrypt_flags_t',
+           'GNUTLS_PKCS_USE_PKCS12_RC2_40',
+           'GNUTLS_A_CERTIFICATE_UNKNOWN',
+           'GNUTLS_E_MAC_VERIFY_FAILED', 'GNUTLS_OPENPGP_CERT',
+           'GNUTLS_E_NO_TEMPORARY_DH_PARAMS',
+           'GNUTLS_E_OPENPGP_UID_REVOKED', 'GNUTLS_KX_DHE_RSA',
+           'GNUTLS_E_PUSH_ERROR', 'GNUTLS_CRT_OPENPGP',
+           'GNUTLS_E_PULL_ERROR', 'GNUTLS_E_CONSTRAINT_ERROR',
+           'GNUTLS_KEY_DECIPHER_ONLY',
+           'GNUTLS_HANDSHAKE_HELLO_REQUEST',
+           'gnutls_certificate_verify_flags', 'GNUTLS_E_FILE_ERROR',
+           'GNUTLS_E_ASN1_TYPE_ANY_ERROR', 'GNUTLS_CERT_REVOKED',
+           'GNUTLS_E_NO_CERTIFICATE_FOUND', 'GNUTLS_SIGN_RSA_MD5',
+           'GNUTLS_E_DECOMPRESSION_FAILED', 'GNUTLS_DIG_MD5',
+           'GNUTLS_DIG_MD2', 'GNUTLS_A_HANDSHAKE_FAILURE',
+           'GNUTLS_E_ASN1_VALUE_NOT_FOUND',
+           'GNUTLS_VERIFY_ALLOW_ANY_X509_V1_CA_CRT',
+           'GNUTLS_E_PKCS1_WRONG_PAD', 'gnutls_params_type_t',
+           'GNUTLS_E_BASE64_DECODING_ERROR',
+           'GNUTLS_CIPHER_ARCFOUR_128', 'GNUTLS_X509_FMT_PEM',
+           'GNUTLS_E_CERTIFICATE_KEY_MISMATCH',
+           'GNUTLS_SIGN_RSA_SHA1', 'GNUTLS_DIG_SHA256',
+           'GNUTLS_HANDSHAKE_CERTIFICATE_REQUEST',
+           'LIBGNUTLS_VERSION', 'GNUTLS_OID_X520_TITLE',
+           'GNUTLS_MAC_SHA256', 'GNUTLS_E_DB_ERROR',
+           'GNUTLS_OID_PKIX_COUNTRY_OF_CITIZENSHIP',
+           'GNUTLS_SIGN_UNKNOWN', 'GNUTLS_DIG_SHA512',
+           'gnutls_x509_subject_alt_name_t', 'GNUTLS_AL_FATAL',
+           'GNUTLS_E_IA_VERIFY_FAILED', 'gnutls_certificate_type_t',
+           'GNUTLS_MAC_RMD160', 'GNUTLS_SIGN_RSA_SHA256',
+           'GNUTLS_CRT_PRINT_FULL',
+           'GNUTLS_E_LIBRARY_VERSION_MISMATCH',
+           'gnutls_pk_algorithm_t', 'GNUTLS_HANDSHAKE_SUPPLEMENTAL',
+           'GNUTLS_A_UNEXPECTED_MESSAGE',
+           'GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD5',
+           'GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD2',
+           'GNUTLS_E_UNEXPECTED_PACKET', 'GNUTLS_A_UNKNOWN_CA',
+           'gnutls_certificate_import_flags',
+           'LIBGNUTLS_VERSION_PATCH',
+           'GNUTLS_E_RECEIVED_ILLEGAL_EXTENSION',
+           'GNUTLS_SIGN_RSA_SHA512', 'GNUTLS_PKCS_USE_PBES2_3DES',
+           'GNUTLS_KEY_KEY_AGREEMENT',
+           'GNUTLS_E_DH_PRIME_UNACCEPTABLE',
+           'GNUTLS_E_INCOMPATIBLE_GCRYPT_LIBRARY',
+           'gnutls_cipher_algorithm_t',
+           'GNUTLS_IA_FINAL_PHASE_FINISHED', 'GNUTLS_SAN_DNSNAME',
+           'GNUTLS_E_PK_ENCRYPTION_FAILED',
+           'GNUTLS_E_MPI_SCAN_FAILED',
+           'GNUTLS_X509_CRT_LIST_IMPORT_FAIL_IF_EXCEED',
+           'GNUTLS_E_SRP_PWD_ERROR', 'gnutls_mac_algorithm_t',
+           'GNUTLS_PARAMS_RSA_EXPORT', 'GNUTLS_PSK_KEY_RAW',
+           'GNUTLS_E_UNKNOWN_HASH_ALGORITHM',
+           'GNUTLS_E_RANDOM_FAILED', 'GNUTLS_E_HANDSHAKE_TOO_LARGE',
+           'GNUTLS_A_NO_RENEGOTIATION', 'TLS_MASTER_SIZE',
+           'GNUTLS_E_FATAL_ALERT_RECEIVED', 'GNUTLS_E_LARGE_PACKET',
+           'GNUTLS_MAX_SESSION_ID',
+           'GNUTLS_A_INNER_APPLICATION_FAILURE',
+           'GNUTLS_E_RECORD_LIMIT_REACHED',
+           'GNUTLS_E_ASN1_ELEMENT_NOT_FOUND',
+           'GNUTLS_HANDSHAKE_CERTIFICATE_PKT',
+           'GNUTLS_A_INSUFFICIENT_SECURITY',
+           'GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM',
+           'GNUTLS_A_DECODE_ERROR',
+           'GNUTLS_A_INNER_APPLICATION_VERIFICATION',
+           'GNUTLS_E_UNKNOWN_PKCS_CONTENT_TYPE', 'GNUTLS_PK_RSA',
+           'GNUTLS_CRD_CERTIFICATE', 'GNUTLS_MAC_MD5',
+           'GNUTLS_MAC_MD2', 'GNUTLS_E_ASN1_TAG_IMPLICIT',
+           'GNUTLS_E_OPENPGP_KEYRING_ERROR', 'GNUTLS_SAN_OTHERNAME',
+           'GNUTLS_SAN_IPADDRESS', 'gnutls_compression_method_t',
+           'GNUTLS_SAN_DN', 'GNUTLS_COMP_NULL',
+           'GNUTLS_A_CERTIFICATE_EXPIRED',
+           'GNUTLS_OPENPGP_CERT_FINGERPRINT',
+           'GNUTLS_KEY_DATA_ENCIPHERMENT', 'GNUTLS_X509_FMT_DER',
+           'GNUTLS_CIPHER_AES_256_CBC', 'gnutls_sign_algorithm_t',
+           'GNUTLS_CRL_REASON_PRIVILEGE_WITHDRAWN', 'GNUTLS_SHUT_WR',
+           'GNUTLS_KX_DHE_PSK', 'GNUTLS_CLIENT', 'GNUTLS_DIG_SHA384',
+           'GNUTLS_E_X509_UNSUPPORTED_CRITICAL_EXTENSION',
+           'GNUTLS_E_UNKNOWN_CIPHER_TYPE',
+           'GNUTLS_E_MPI_PRINT_FAILED', 'GNUTLS_E_INVALID_PASSWORD',
+           'GNUTLS_CIPHER_3DES_CBC', 'gnutls_credentials_type_t',
+           'GNUTLS_SIGN_DSA_SHA1', 'GNUTLS_KEY_CRL_SIGN',
+           'GNUTLS_E_BASE64_ENCODING_ERROR', 'GNUTLS_A_CLOSE_NOTIFY',
+           'GNUTLS_OID_PKCS9_EMAIL', 'GNUTLS_CRL_REASON_UNUSED',
+           'GNUTLS_E_UNKNOWN_PK_ALGORITHM', 'GNUTLS_CERT_INVALID',
+           'GNUTLS_E_APPLICATION_ERROR_MIN',
+           'GNUTLS_HANDSHAKE_SERVER_HELLO_DONE',
+           'GNUTLS_E_OPENPGP_FINGERPRINT_UNSUPPORTED',
+           'GNUTLS_SAN_URI', 'GNUTLS_A_UNSUPPORTED_CERTIFICATE',
+           'GNUTLS_E_ASN1_TAG_ERROR', 'GNUTLS_E_INTERNAL_ERROR',
+           'GNUTLS_CRL_REASON_CERTIFICATE_HOLD',
+           'gnutls_certificate_status_t', 'GNUTLS_OID_PKIX_GENDER',
+           'GNUTLS_E_SRP_PWD_PARSING_ERROR', 'GNUTLS_MAC_SHA384',
+           'GNUTLS_COMP_DEFLATE', 'GNUTLS_E_ASN1_VALUE_NOT_VALID',
+           'GNUTLS_IA_INTERMEDIATE_PHASE_FINISHED',
+           'GNUTLS_COMP_UNKNOWN',
+           'GNUTLS_E_UNEXPECTED_HANDSHAKE_PACKET',
+           'GNUTLS_CIPHER_CAMELLIA_256_CBC',
+           'GNUTLS_CERT_SIGNER_NOT_FOUND',
+           'GNUTLS_A_PROTOCOL_VERSION', 'GNUTLS_E_AGAIN',
+           'GNUTLS_CIPHER_NULL', 'GNUTLS_KEY_ENCIPHER_ONLY',
+           'GNUTLS_NAME_DNS', 'GNUTLS_E_UNKNOWN_CIPHER_SUITE',
+           'gnutls_certificate_request_t',
+           'GNUTLS_CERT_SIGNER_NOT_CA', 'GNUTLS_A_USER_CANCELED',
+           'GNUTLS_E_PK_SIGN_FAILED',
+           'GNUTLS_E_ERROR_IN_FINISHED_PACKET',
+           'GNUTLS_CRL_REASON_AA_COMPROMISE', 'GNUTLS_MAC_SHA1',
+           'GNUTLS_CRD_ANON', 'GNUTLS_HANDSHAKE_SERVER_HELLO',
+           'GNUTLS_E_X509_UNSUPPORTED_ATTRIBUTE',
+           'GNUTLS_HANDSHAKE_CERTIFICATE_VERIFY',
+           'gnutls_ia_apptype_t', '_GNUTLS_GCC_VERSION',
+           'GNUTLS_CRL_REASON_SUPERSEEDED',
+           'gnutls_digest_algorithm_t', 'GNUTLS_A_DECRYPTION_FAILED',
+           'GNUTLS_MAC_NULL', 'GNUTLS_OID_PKIX_COUNTRY_OF_RESIDENCE',
+           'GNUTLS_E_ASN1_DER_ERROR', 'GNUTLS_PSK_KEY_HEX',
+           'GNUTLS_E_UNKNOWN_ALGORITHM', 'GNUTLS_DIG_SHA1',
+           'GNUTLS_E_INCOMPATIBLE_CRYPTO_LIBRARY',
+           'GNUTLS_E_ASN1_SYNTAX_ERROR',
+           'GNUTLS_E_WARNING_IA_FPHF_RECEIVED',
+           'GNUTLS_OID_X520_DN_QUALIFIER',
+           'GNUTLS_E_NO_CIPHER_SUITES', 'GNUTLS_KX_SRP',
+           'GNUTLS_E_CRYPTO_ALREADY_REGISTERED',
+           'GNUTLS_HANDSHAKE_FINISHED', 'GNUTLS_DIG_RMD160',
+           'gnutls_openpgp_crt_status_t', 'GNUTLS_KEY_KEY_CERT_SIGN',
+           'GNUTLS_CRD_SRP', 'GNUTLS_E_DECRYPTION_FAILED',
+           'GNUTLS_KX_SRP_RSA', 'gnutls_protocol_t',
+           'gnutls_openpgp_crt_fmt', 'GNUTLS_IA_APPLICATION_PAYLOAD',
+           'GNUTLS_SIGN_RSA_MD2', 'GNUTLS_A_CERTIFICATE_UNOBTAINABLE',
+           'GNUTLS_CIPHER_DES_CBC', 'GNUTLS_A_RECORD_OVERFLOW',
+           'GNUTLS_KX_DHE_DSS', 'GNUTLS_KEY_KEY_ENCIPHERMENT',
+           'GNUTLS_OID_LDAP_UID', 'GNUTLS_E_X509_UNSUPPORTED_OID',
+           'GNUTLS_VERIFY_DO_NOT_ALLOW_SAME',
+           'GNUTLS_E_UNIMPLEMENTED_FEATURE', 'GNUTLS_A_DECRYPT_ERROR',
+           'GNUTLS_TLS1_2', 'GNUTLS_TLS1_0', 'GNUTLS_TLS1_1',
+           'GNUTLS_CRL_REASON_AFFILIATION_CHANGED',
+           'GNUTLS_OPENPGP_FMT_RAW',
+           'GNUTLS_OID_X520_GENERATION_QUALIFIER',
+           'GNUTLS_OID_X520_PSEUDONYM',
+           'GNUTLS_A_DECOMPRESSION_FAILURE',
+           'GNUTLS_E_NO_COMPRESSION_ALGORITHMS',
+           'GNUTLS_E_UNEXPECTED_PACKET_LENGTH', 'GNUTLS_PK_UNKNOWN',
+           'GNUTLS_E_COMPRESSION_FAILED',
+           'GNUTLS_KEY_NON_REPUDIATION', 'GNUTLS_A_ACCESS_DENIED',
+           'GNUTLS_E_INSUFFICIENT_CREDENTIALS',
+           'gnutls_kx_algorithm_t', 'GNUTLS_OID_X520_COMMON_NAME',
+           'GNUTLS_OID_PKIX_PLACE_OF_BIRTH',
+           'GNUTLS_OID_X520_STATE_OR_PROVINCE_NAME',
+           'GNUTLS_VERIFY_DISABLE_CA_SIGN',
+           'GNUTLS_SAN_OTHERNAME_XMPP', 'GNUTLS_E_INVALID_REQUEST',
+           'GNUTLS_SSL3', 'GNUTLS_KP_TIME_STAMPING',
+           'GNUTLS_A_SSL3_NO_CERTIFICATE',
+           'GNUTLS_CRL_REASON_KEY_COMPROMISE',
+           'GNUTLS_E_APPLICATION_ERROR_MAX',
+           'GNUTLS_KEY_DIGITAL_SIGNATURE',
+           'gnutls_supplemental_data_format_type_t',
+           'gnutls_alert_description_t',
+           'GNUTLS_A_CERTIFICATE_REVOKED', 'gnutls_alert_level_t',
+           'gnutls_psk_key_flags', 'GNUTLS_A_BAD_CERTIFICATE',
+           'GNUTLS_MAC_UNKNOWN', 'GNUTLS_A_UNRECOGNIZED_NAME',
+           'TLS_RANDOM_SIZE', 'GNUTLS_E_INVALID_SESSION',
+           'GNUTLS_PARAMS_DH', 'GNUTLS_HANDSHAKE_CLIENT_KEY_EXCHANGE',
+           'gnutls_x509_crt_fmt_t', 'GNUTLS_KP_ANY',
+           'GNUTLS_E_TOO_MANY_EMPTY_PACKETS',
+           'GNUTLS_OID_PKIX_DATE_OF_BIRTH',
+           'GNUTLS_OPENPGP_FMT_BASE64',
+           'GNUTLS_E_NO_TEMPORARY_RSA_PARAMS',
+           'GNUTLS_VERSION_UNKNOWN', 'GNUTLS_E_INTERRUPTED',
+           'GNUTLS_COMP_LZO', 'GNUTLS_SERVER', 'GNUTLS_CRD_IA',
+           'GNUTLS_DIG_SHA224', 'GNUTLS_KX_RSA',
+           'LIBGNUTLS_VERSION_NUMBER', 'GNUTLS_CERT_IGNORE',
+           'GNUTLS_CERT_REQUEST', 'GNUTLS_MAC_SHA512',
+           'GNUTLS_E_SHORT_MEMORY_BUFFER', 'GNUTLS_SIGN_RSA_SHA224',
+           'GNUTLS_E_REHANDSHAKE', 'gnutls_close_request_t',
+           'GNUTLS_OID_X520_GIVEN_NAME', 'LIBGNUTLS_VERSION_MINOR',
+           'gnutls_handshake_description_t',
+           'GNUTLS_E_KEY_USAGE_VIOLATION',
+           'GNUTLS_E_PK_DECRYPTION_FAILED',
+           'GNUTLS_E_UNKNOWN_PKCS_BAG_TYPE', 'GNUTLS_KX_PSK',
+           'GNUTLS_SUPPLEMENTAL_USER_MAPPING_DATA',
+           'GNUTLS_KP_OCSP_SIGNING', 'GNUTLS_A_UNKNOWN_PSK_IDENTITY',
+           'GNUTLS_OID_X520_SURNAME', 'GNUTLS_E_MEMORY_ERROR',
+           'GNUTLS_CERT_REQUIRE', 'GNUTLS_KX_ANON_DH',
+           'GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT',
+           'GNUTLS_MAX_ALGORITHM_NUM', 'GNUTLS_A_EXPORT_RESTRICTION',
+           'GNUTLS_OID_X520_COUNTRY_NAME', 'GNUTLS_SHUT_RDWR',
+           'GNUTLS_AL_WARNING', 'GNUTLS_E_GOT_APPLICATION_DATA',
+           'LIBGNUTLS_VERSION_MAJOR', 'GNUTLS_CRT_UNKNOWN',
+           'GNUTLS_E_UNSUPPORTED_VERSION_PACKET',
+           'GNUTLS_KP_TLS_WWW_SERVER',
+           'GNUTLS_OID_X520_ORGANIZATIONAL_UNIT_NAME',
+           'GNUTLS_E_HASH_FAILED',
+           'GNUTLS_OID_X520_ORGANIZATION_NAME',
+           'gnutls_server_name_type_t', 'GNUTLS_E_ENCRYPTION_FAILED',
+           'GNUTLS_E_X509_UNKNOWN_SAN', 'GNUTLS_CRD_PSK',
+           'GNUTLS_E_PK_SIG_VERIFY_FAILED', 'GNUTLS_A_BAD_RECORD_MAC',
+           'GNUTLS_KX_RSA_EXPORT', 'GNUTLS_E_OPENPGP_SUBKEY_ERROR',
+           'GNUTLS_SIGN_RSA_SHA384', 'GNUTLS_CRT_X509',
+           'GNUTLS_E_EXPIRED', 'GNUTLS_E_UNWANTED_ALGORITHM',
+           'GNUTLS_SIGN_RSA_RMD160', 'GNUTLS_OID_X520_INITIALS',
+           'GNUTLS_KP_EMAIL_PROTECTION', 'gnutls_connection_end_t',
+           'GNUTLS_E_INIT_LIBEXTRA', 'GNUTLS_PKCS_PLAIN',
+           'GNUTLS_HANDSHAKE_SERVER_KEY_EXCHANGE',
+           'GNUTLS_CRL_REASON_CESSATION_OF_OPERATION',
+           'GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER',
+           'GNUTLS_CIPHER_CAMELLIA_128_CBC',
+           'GNUTLS_E_ASN1_GENERIC_ERROR',
+           'GNUTLS_E_ILLEGAL_SRP_USERNAME',
+           'GNUTLS_E_UNSUPPORTED_CERTIFICATE_TYPE', 'GNUTLS_PK_DSA',
+           'GNUTLS_E_INCOMPATIBLE_LIBTASN1_LIBRARY',
+           'GNUTLS_SAN_RFC822NAME',
+           'GNUTLS_E_BASE64_UNEXPECTED_HEADER_ERROR',
+           'GNUTLS_PKCS_USE_PKCS12_3DES', 'GNUTLS_CIPHER_ARCFOUR_40',
+           'GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE',
+           'GNUTLS_CIPHER_RC2_40_CBC', 'GNUTLS_CIPHER_AES_128_CBC',
+           'GNUTLS_OID_LDAP_DC', 'GNUTLS_KP_TLS_WWW_CLIENT',
+           'GNUTLS_A_INTERNAL_ERROR', 'GNUTLS_A_ILLEGAL_PARAMETER',
+           'gnutls_certificate_print_formats',
+           'GNUTLS_OID_X520_LOCALITY_NAME',
+           'GNUTLS_E_CERTIFICATE_ERROR', 'GNUTLS_CRT_PRINT_ONELINE',
+           'GNUTLS_KP_CODE_SIGNING']
diff --git a/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/library/errors.py b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/library/errors.py
new file mode 100644
index 0000000..1e4dea7
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/library/errors.py
@@ -0,0 +1,78 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS library errors"""
+
+from gnutls.errors import *
+from gnutls.errors import __all__
+
+from gnutls.library.constants import GNUTLS_E_AGAIN, GNUTLS_E_INTERRUPTED, GNUTLS_E_NO_CERTIFICATE_FOUND
+from gnutls.library.constants import GNUTLS_E_MEMORY_ERROR, GNUTLS_E_SHORT_MEMORY_BUFFER
+from gnutls.library.constants import GNUTLS_E_FATAL_ALERT_RECEIVED, GNUTLS_A_BAD_CERTIFICATE
+from gnutls.library.constants import GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE
+from gnutls.library.constants import GNUTLS_A_UNKNOWN_CA, GNUTLS_A_INSUFFICIENT_SECURITY
+from gnutls.library.constants import GNUTLS_A_CERTIFICATE_EXPIRED, GNUTLS_A_CERTIFICATE_REVOKED
+from gnutls.library.functions import gnutls_strerror, gnutls_alert_get
+
+class ErrorMessage(str):
+    def __new__(cls, code):
+        obj = str.__new__(cls, gnutls_strerror(code))
+        obj.code = code
+        return obj
+
+# Check functions which return an integer status code (negative codes being errors)
+#
+def _check_status(retcode, function, args):
+    if retcode >= 0:
+        return retcode
+    elif retcode == -1:
+        from gnutls.library import functions
+        if function in (functions.gnutls_certificate_activation_time_peers,
+                        functions.gnutls_x509_crt_get_activation_time,
+                        functions.gnutls_openpgp_key_get_creation_time):
+            raise GNUTLSError("cannot retrieve activation time")
+        elif function in (functions.gnutls_certificate_expiration_time_peers,
+                          functions.gnutls_x509_crt_get_expiration_time,
+                          functions.gnutls_openpgp_key_get_expiration_time):
+            raise GNUTLSError("cannot retrieve expiration time")
+        elif function in (functions.gnutls_x509_crl_get_this_update,
+                          functions.gnutls_x509_crl_get_next_update):
+            raise GNUTLSError("cannot retrieve CRL update time")
+        else:
+            raise GNUTLSError(ErrorMessage(retcode))
+    elif retcode == GNUTLS_E_AGAIN:
+        raise OperationWouldBlock(gnutls_strerror(retcode))
+    elif retcode == GNUTLS_E_INTERRUPTED:
+        raise OperationInterrupted(gnutls_strerror(retcode))
+    elif retcode in (GNUTLS_E_MEMORY_ERROR, GNUTLS_E_SHORT_MEMORY_BUFFER):
+        raise MemoryError(ErrorMessage(retcode))
+    elif retcode == GNUTLS_E_NO_CERTIFICATE_FOUND:
+        raise CertificateSecurityError(gnutls_strerror(retcode))
+    elif retcode == GNUTLS_E_FATAL_ALERT_RECEIVED:
+        alertdict = {
+            GNUTLS_A_BAD_CERTIFICATE: (CertificateError, "peer rejected our certificate as invalid"),
+            GNUTLS_A_UNKNOWN_CA: (CertificateAuthorityError, "peer does not trust our certificate authority"),
+            GNUTLS_A_INSUFFICIENT_SECURITY: (CertificateSecurityError, "peer rejected us on insufficient security"),
+            GNUTLS_A_CERTIFICATE_EXPIRED: (CertificateExpiredError, "peer rejected our certificate as expired"),
+            GNUTLS_A_CERTIFICATE_REVOKED: (CertificateRevokedError, "peer rejected our certificate as revoked")}
+        alert = gnutls_alert_get(args[0])
+        exception, reason = alertdict.get(alert, (GNUTLSError, ErrorMessage(retcode)))
+        raise exception(reason)
+    elif retcode == GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE:
+        raise RequestedDataNotAvailable(gnutls_strerror(retcode))
+    else:
+        raise GNUTLSError(ErrorMessage(retcode))
+
+# Attach the error checking function to all functions returning integers
+#
+from gnutls.library import functions
+from ctypes import c_int, c_long
+
+for func in functions.__dict__.values():
+    if not hasattr(func, 'errcheck'):
+        continue ## not a function
+    if func.restype in (c_int, c_long):
+        func.errcheck = _check_status
+
+del c_int, c_long, func, functions
+
diff --git a/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/library/functions.py b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/library/functions.py
new file mode 100644
index 0000000..5ee3cab
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/library/functions.py
@@ -0,0 +1,1836 @@
+from ctypes import *
+
+from gnutls.library.types import gnutls_ia_client_credentials_t
+_libraries = {}
+_libraries['libgnutls-extra.so.26'] = CDLL('libgnutls-extra.so.26')
+from gnutls.library.types import gnutls_ia_server_credentials_t
+from gnutls.library.types import gnutls_ia_avp_func
+from gnutls.library.types import gnutls_session_t
+from gnutls.library.types import size_t
+STRING = c_char_p
+from gnutls.library.types import ssize_t
+from gnutls.library.constants import gnutls_pk_algorithm_t
+_libraries['libgnutls.so.26'] = CDLL('libgnutls.so.26')
+from gnutls.library.constants import gnutls_sign_algorithm_t
+from gnutls.library.constants import gnutls_connection_end_t
+from gnutls.library.constants import gnutls_close_request_t
+from gnutls.library.constants import gnutls_alert_description_t
+from gnutls.library.constants import gnutls_alert_level_t
+from gnutls.library.constants import gnutls_cipher_algorithm_t
+from gnutls.library.constants import gnutls_kx_algorithm_t
+from gnutls.library.constants import gnutls_mac_algorithm_t
+from gnutls.library.constants import gnutls_compression_method_t
+from gnutls.library.constants import gnutls_certificate_type_t
+from gnutls.library.constants import gnutls_protocol_t
+from gnutls.library.constants import gnutls_handshake_description_t
+from gnutls.library.constants import gnutls_server_name_type_t
+from gnutls.library.constants import gnutls_supplemental_data_format_type_t
+from gnutls.library.types import gnutls_priority_t
+from gnutls.library.types import gnutls_datum_t
+from gnutls.library.types import gnutls_db_retr_func
+from gnutls.library.types import gnutls_db_remove_func
+from gnutls.library.types import gnutls_db_store_func
+from gnutls.library.types import gnutls_datum_t
+from gnutls.library.types import gnutls_handshake_post_client_hello_func
+from gnutls.library.constants import gnutls_credentials_type_t
+from gnutls.library.types import gnutls_anon_server_credentials_t
+from gnutls.library.types import gnutls_dh_params_t
+from gnutls.library.types import gnutls_params_function
+from gnutls.library.types import gnutls_anon_client_credentials_t
+from gnutls.library.types import gnutls_certificate_credentials_t
+from gnutls.library.types import gnutls_rsa_params_t
+from gnutls.library.constants import gnutls_x509_crt_fmt_t
+from gnutls.library.types import gnutls_x509_crt_t
+from gnutls.library.types import gnutls_x509_privkey_t
+from gnutls.library.types import gnutls_x509_crl_t
+from gnutls.library.types import gnutls_openpgp_keyring_t
+from gnutls.library.types import gnutls_alloc_function
+from gnutls.library.types import gnutls_is_secure_function
+from gnutls.library.types import gnutls_realloc_function
+from gnutls.library.types import gnutls_free_function
+from gnutls.library.types import gnutls_log_func
+from gnutls.library.types import gnutls_transport_ptr_t
+from gnutls.library.types import gnutls_push_func
+from gnutls.library.types import gnutls_pull_func
+from gnutls.library.constants import gnutls_openpgp_crt_status_t
+from gnutls.library.constants import gnutls_digest_algorithm_t
+from gnutls.library.types import gnutls_srp_client_credentials_t
+from gnutls.library.types import gnutls_srp_server_credentials_t
+from gnutls.library.types import gnutls_srp_server_credentials_function
+from gnutls.library.types import gnutls_srp_client_credentials_function
+from gnutls.library.types import gnutls_psk_client_credentials_t
+from gnutls.library.constants import gnutls_psk_key_flags
+from gnutls.library.types import gnutls_psk_server_credentials_t
+from gnutls.library.types import gnutls_psk_server_credentials_function
+from gnutls.library.types import gnutls_psk_client_credentials_function
+from gnutls.library.types import gnutls_sign_func
+from gnutls.library.types import gnutls_certificate_client_retrieve_function
+from gnutls.library.types import gnutls_certificate_server_retrieve_function
+from gnutls.library.constants import gnutls_certificate_request_t
+from gnutls.library.types import gnutls_openpgp_crt_t
+from gnutls.library.types import gnutls_openpgp_crt_fmt_t
+from gnutls.library.types import gnutls_certificate_print_formats_t
+from gnutls.library.types import gnutls_openpgp_privkey_t
+from gnutls.library.types import gnutls_openpgp_recv_key_func
+from gnutls.library.constants import gnutls_x509_subject_alt_name_t
+from gnutls.library.types import gnutls_x509_dn_t
+from gnutls.library.types import gnutls_x509_ava_st
+from gnutls.library.types import gnutls_pkcs7_t
+from gnutls.library.types import gnutls_x509_crq_t
+
+
+gnutls_ia_free_client_credentials = _libraries['libgnutls-extra.so.26'].gnutls_ia_free_client_credentials
+gnutls_ia_free_client_credentials.restype = None
+gnutls_ia_free_client_credentials.argtypes = [gnutls_ia_client_credentials_t]
+gnutls_ia_allocate_client_credentials = _libraries['libgnutls-extra.so.26'].gnutls_ia_allocate_client_credentials
+gnutls_ia_allocate_client_credentials.restype = c_int
+gnutls_ia_allocate_client_credentials.argtypes = [POINTER(gnutls_ia_client_credentials_t)]
+gnutls_ia_free_server_credentials = _libraries['libgnutls-extra.so.26'].gnutls_ia_free_server_credentials
+gnutls_ia_free_server_credentials.restype = None
+gnutls_ia_free_server_credentials.argtypes = [gnutls_ia_server_credentials_t]
+gnutls_ia_allocate_server_credentials = _libraries['libgnutls-extra.so.26'].gnutls_ia_allocate_server_credentials
+gnutls_ia_allocate_server_credentials.restype = c_int
+gnutls_ia_allocate_server_credentials.argtypes = [POINTER(gnutls_ia_server_credentials_t)]
+gnutls_ia_set_client_avp_function = _libraries['libgnutls-extra.so.26'].gnutls_ia_set_client_avp_function
+gnutls_ia_set_client_avp_function.restype = None
+gnutls_ia_set_client_avp_function.argtypes = [gnutls_ia_client_credentials_t, gnutls_ia_avp_func]
+gnutls_ia_set_client_avp_ptr = _libraries['libgnutls-extra.so.26'].gnutls_ia_set_client_avp_ptr
+gnutls_ia_set_client_avp_ptr.restype = None
+gnutls_ia_set_client_avp_ptr.argtypes = [gnutls_ia_client_credentials_t, c_void_p]
+gnutls_ia_get_client_avp_ptr = _libraries['libgnutls-extra.so.26'].gnutls_ia_get_client_avp_ptr
+gnutls_ia_get_client_avp_ptr.restype = c_void_p
+gnutls_ia_get_client_avp_ptr.argtypes = [gnutls_ia_client_credentials_t]
+gnutls_ia_set_server_avp_function = _libraries['libgnutls-extra.so.26'].gnutls_ia_set_server_avp_function
+gnutls_ia_set_server_avp_function.restype = None
+gnutls_ia_set_server_avp_function.argtypes = [gnutls_ia_server_credentials_t, gnutls_ia_avp_func]
+gnutls_ia_set_server_avp_ptr = _libraries['libgnutls-extra.so.26'].gnutls_ia_set_server_avp_ptr
+gnutls_ia_set_server_avp_ptr.restype = None
+gnutls_ia_set_server_avp_ptr.argtypes = [gnutls_ia_server_credentials_t, c_void_p]
+gnutls_ia_get_server_avp_ptr = _libraries['libgnutls-extra.so.26'].gnutls_ia_get_server_avp_ptr
+gnutls_ia_get_server_avp_ptr.restype = c_void_p
+gnutls_ia_get_server_avp_ptr.argtypes = [gnutls_ia_server_credentials_t]
+gnutls_ia_handshake_p = _libraries['libgnutls-extra.so.26'].gnutls_ia_handshake_p
+gnutls_ia_handshake_p.restype = c_int
+gnutls_ia_handshake_p.argtypes = [gnutls_session_t]
+gnutls_ia_handshake = _libraries['libgnutls-extra.so.26'].gnutls_ia_handshake
+gnutls_ia_handshake.restype = c_int
+gnutls_ia_handshake.argtypes = [gnutls_session_t]
+gnutls_ia_permute_inner_secret = _libraries['libgnutls-extra.so.26'].gnutls_ia_permute_inner_secret
+gnutls_ia_permute_inner_secret.restype = c_int
+gnutls_ia_permute_inner_secret.argtypes = [gnutls_session_t, size_t, STRING]
+gnutls_ia_endphase_send = _libraries['libgnutls-extra.so.26'].gnutls_ia_endphase_send
+gnutls_ia_endphase_send.restype = c_int
+gnutls_ia_endphase_send.argtypes = [gnutls_session_t, c_int]
+gnutls_ia_verify_endphase = _libraries['libgnutls-extra.so.26'].gnutls_ia_verify_endphase
+gnutls_ia_verify_endphase.restype = c_int
+gnutls_ia_verify_endphase.argtypes = [gnutls_session_t, STRING]
+gnutls_ia_send = _libraries['libgnutls-extra.so.26'].gnutls_ia_send
+gnutls_ia_send.restype = ssize_t
+gnutls_ia_send.argtypes = [gnutls_session_t, STRING, size_t]
+gnutls_ia_recv = _libraries['libgnutls-extra.so.26'].gnutls_ia_recv
+gnutls_ia_recv.restype = ssize_t
+gnutls_ia_recv.argtypes = [gnutls_session_t, STRING, size_t]
+gnutls_ia_generate_challenge = _libraries['libgnutls-extra.so.26'].gnutls_ia_generate_challenge
+gnutls_ia_generate_challenge.restype = c_int
+gnutls_ia_generate_challenge.argtypes = [gnutls_session_t, size_t, STRING]
+gnutls_ia_extract_inner_secret = _libraries['libgnutls-extra.so.26'].gnutls_ia_extract_inner_secret
+gnutls_ia_extract_inner_secret.restype = None
+gnutls_ia_extract_inner_secret.argtypes = [gnutls_session_t, STRING]
+gnutls_ia_enable = _libraries['libgnutls-extra.so.26'].gnutls_ia_enable
+gnutls_ia_enable.restype = None
+gnutls_ia_enable.argtypes = [gnutls_session_t, c_int]
+gnutls_global_init_extra = _libraries['libgnutls-extra.so.26'].gnutls_global_init_extra
+gnutls_global_init_extra.restype = c_int
+gnutls_global_init_extra.argtypes = []
+gnutls_extra_check_version = _libraries['libgnutls-extra.so.26'].gnutls_extra_check_version
+gnutls_extra_check_version.restype = STRING
+gnutls_extra_check_version.argtypes = [STRING]
+gnutls_pk_algorithm_get_name = _libraries['libgnutls.so.26'].gnutls_pk_algorithm_get_name
+gnutls_pk_algorithm_get_name.restype = STRING
+gnutls_pk_algorithm_get_name.argtypes = [gnutls_pk_algorithm_t]
+gnutls_sign_algorithm_get_name = _libraries['libgnutls.so.26'].gnutls_sign_algorithm_get_name
+gnutls_sign_algorithm_get_name.restype = STRING
+gnutls_sign_algorithm_get_name.argtypes = [gnutls_sign_algorithm_t]
+gnutls_init = _libraries['libgnutls.so.26'].gnutls_init
+gnutls_init.restype = c_int
+gnutls_init.argtypes = [POINTER(gnutls_session_t), gnutls_connection_end_t]
+gnutls_deinit = _libraries['libgnutls.so.26'].gnutls_deinit
+gnutls_deinit.restype = None
+gnutls_deinit.argtypes = [gnutls_session_t]
+gnutls_bye = _libraries['libgnutls.so.26'].gnutls_bye
+gnutls_bye.restype = c_int
+gnutls_bye.argtypes = [gnutls_session_t, gnutls_close_request_t]
+gnutls_handshake = _libraries['libgnutls.so.26'].gnutls_handshake
+gnutls_handshake.restype = c_int
+gnutls_handshake.argtypes = [gnutls_session_t]
+gnutls_rehandshake = _libraries['libgnutls.so.26'].gnutls_rehandshake
+gnutls_rehandshake.restype = c_int
+gnutls_rehandshake.argtypes = [gnutls_session_t]
+gnutls_alert_get = _libraries['libgnutls.so.26'].gnutls_alert_get
+gnutls_alert_get.restype = gnutls_alert_description_t
+gnutls_alert_get.argtypes = [gnutls_session_t]
+gnutls_alert_send = _libraries['libgnutls.so.26'].gnutls_alert_send
+gnutls_alert_send.restype = c_int
+gnutls_alert_send.argtypes = [gnutls_session_t, gnutls_alert_level_t, gnutls_alert_description_t]
+gnutls_alert_send_appropriate = _libraries['libgnutls.so.26'].gnutls_alert_send_appropriate
+gnutls_alert_send_appropriate.restype = c_int
+gnutls_alert_send_appropriate.argtypes = [gnutls_session_t, c_int]
+gnutls_alert_get_name = _libraries['libgnutls.so.26'].gnutls_alert_get_name
+gnutls_alert_get_name.restype = STRING
+gnutls_alert_get_name.argtypes = [gnutls_alert_description_t]
+gnutls_cipher_get = _libraries['libgnutls.so.26'].gnutls_cipher_get
+gnutls_cipher_get.restype = gnutls_cipher_algorithm_t
+gnutls_cipher_get.argtypes = [gnutls_session_t]
+gnutls_kx_get = _libraries['libgnutls.so.26'].gnutls_kx_get
+gnutls_kx_get.restype = gnutls_kx_algorithm_t
+gnutls_kx_get.argtypes = [gnutls_session_t]
+gnutls_mac_get = _libraries['libgnutls.so.26'].gnutls_mac_get
+gnutls_mac_get.restype = gnutls_mac_algorithm_t
+gnutls_mac_get.argtypes = [gnutls_session_t]
+gnutls_compression_get = _libraries['libgnutls.so.26'].gnutls_compression_get
+gnutls_compression_get.restype = gnutls_compression_method_t
+gnutls_compression_get.argtypes = [gnutls_session_t]
+gnutls_certificate_type_get = _libraries['libgnutls.so.26'].gnutls_certificate_type_get
+gnutls_certificate_type_get.restype = gnutls_certificate_type_t
+gnutls_certificate_type_get.argtypes = [gnutls_session_t]
+gnutls_cipher_get_key_size = _libraries['libgnutls.so.26'].gnutls_cipher_get_key_size
+gnutls_cipher_get_key_size.restype = size_t
+gnutls_cipher_get_key_size.argtypes = [gnutls_cipher_algorithm_t]
+gnutls_mac_get_key_size = _libraries['libgnutls.so.26'].gnutls_mac_get_key_size
+gnutls_mac_get_key_size.restype = size_t
+gnutls_mac_get_key_size.argtypes = [gnutls_mac_algorithm_t]
+gnutls_cipher_get_name = _libraries['libgnutls.so.26'].gnutls_cipher_get_name
+gnutls_cipher_get_name.restype = STRING
+gnutls_cipher_get_name.argtypes = [gnutls_cipher_algorithm_t]
+gnutls_mac_get_name = _libraries['libgnutls.so.26'].gnutls_mac_get_name
+gnutls_mac_get_name.restype = STRING
+gnutls_mac_get_name.argtypes = [gnutls_mac_algorithm_t]
+gnutls_compression_get_name = _libraries['libgnutls.so.26'].gnutls_compression_get_name
+gnutls_compression_get_name.restype = STRING
+gnutls_compression_get_name.argtypes = [gnutls_compression_method_t]
+gnutls_kx_get_name = _libraries['libgnutls.so.26'].gnutls_kx_get_name
+gnutls_kx_get_name.restype = STRING
+gnutls_kx_get_name.argtypes = [gnutls_kx_algorithm_t]
+gnutls_certificate_type_get_name = _libraries['libgnutls.so.26'].gnutls_certificate_type_get_name
+gnutls_certificate_type_get_name.restype = STRING
+gnutls_certificate_type_get_name.argtypes = [gnutls_certificate_type_t]
+gnutls_mac_get_id = _libraries['libgnutls.so.26'].gnutls_mac_get_id
+gnutls_mac_get_id.restype = gnutls_mac_algorithm_t
+gnutls_mac_get_id.argtypes = [STRING]
+gnutls_compression_get_id = _libraries['libgnutls.so.26'].gnutls_compression_get_id
+gnutls_compression_get_id.restype = gnutls_compression_method_t
+gnutls_compression_get_id.argtypes = [STRING]
+gnutls_cipher_get_id = _libraries['libgnutls.so.26'].gnutls_cipher_get_id
+gnutls_cipher_get_id.restype = gnutls_cipher_algorithm_t
+gnutls_cipher_get_id.argtypes = [STRING]
+gnutls_kx_get_id = _libraries['libgnutls.so.26'].gnutls_kx_get_id
+gnutls_kx_get_id.restype = gnutls_kx_algorithm_t
+gnutls_kx_get_id.argtypes = [STRING]
+gnutls_protocol_get_id = _libraries['libgnutls.so.26'].gnutls_protocol_get_id
+gnutls_protocol_get_id.restype = gnutls_protocol_t
+gnutls_protocol_get_id.argtypes = [STRING]
+gnutls_certificate_type_get_id = _libraries['libgnutls.so.26'].gnutls_certificate_type_get_id
+gnutls_certificate_type_get_id.restype = gnutls_certificate_type_t
+gnutls_certificate_type_get_id.argtypes = [STRING]
+gnutls_cipher_list = _libraries['libgnutls.so.26'].gnutls_cipher_list
+gnutls_cipher_list.restype = POINTER(gnutls_cipher_algorithm_t)
+gnutls_cipher_list.argtypes = []
+gnutls_mac_list = _libraries['libgnutls.so.26'].gnutls_mac_list
+gnutls_mac_list.restype = POINTER(gnutls_mac_algorithm_t)
+gnutls_mac_list.argtypes = []
+gnutls_compression_list = _libraries['libgnutls.so.26'].gnutls_compression_list
+gnutls_compression_list.restype = POINTER(gnutls_compression_method_t)
+gnutls_compression_list.argtypes = []
+gnutls_protocol_list = _libraries['libgnutls.so.26'].gnutls_protocol_list
+gnutls_protocol_list.restype = POINTER(gnutls_protocol_t)
+gnutls_protocol_list.argtypes = []
+gnutls_certificate_type_list = _libraries['libgnutls.so.26'].gnutls_certificate_type_list
+gnutls_certificate_type_list.restype = POINTER(gnutls_certificate_type_t)
+gnutls_certificate_type_list.argtypes = []
+gnutls_kx_list = _libraries['libgnutls.so.26'].gnutls_kx_list
+gnutls_kx_list.restype = POINTER(gnutls_kx_algorithm_t)
+gnutls_kx_list.argtypes = []
+gnutls_cipher_suite_info = _libraries['libgnutls.so.26'].gnutls_cipher_suite_info
+gnutls_cipher_suite_info.restype = STRING
+gnutls_cipher_suite_info.argtypes = [size_t, STRING, POINTER(gnutls_kx_algorithm_t), POINTER(gnutls_cipher_algorithm_t), POINTER(gnutls_mac_algorithm_t), POINTER(gnutls_protocol_t)]
+gnutls_error_is_fatal = _libraries['libgnutls.so.26'].gnutls_error_is_fatal
+gnutls_error_is_fatal.restype = c_int
+gnutls_error_is_fatal.argtypes = [c_int]
+gnutls_error_to_alert = _libraries['libgnutls.so.26'].gnutls_error_to_alert
+gnutls_error_to_alert.restype = c_int
+gnutls_error_to_alert.argtypes = [c_int, POINTER(c_int)]
+gnutls_perror = _libraries['libgnutls.so.26'].gnutls_perror
+gnutls_perror.restype = None
+gnutls_perror.argtypes = [c_int]
+gnutls_strerror = _libraries['libgnutls.so.26'].gnutls_strerror
+gnutls_strerror.restype = STRING
+gnutls_strerror.argtypes = [c_int]
+gnutls_handshake_set_private_extensions = _libraries['libgnutls.so.26'].gnutls_handshake_set_private_extensions
+gnutls_handshake_set_private_extensions.restype = None
+gnutls_handshake_set_private_extensions.argtypes = [gnutls_session_t, c_int]
+gnutls_handshake_get_last_out = _libraries['libgnutls.so.26'].gnutls_handshake_get_last_out
+gnutls_handshake_get_last_out.restype = gnutls_handshake_description_t
+gnutls_handshake_get_last_out.argtypes = [gnutls_session_t]
+gnutls_handshake_get_last_in = _libraries['libgnutls.so.26'].gnutls_handshake_get_last_in
+gnutls_handshake_get_last_in.restype = gnutls_handshake_description_t
+gnutls_handshake_get_last_in.argtypes = [gnutls_session_t]
+gnutls_record_send = _libraries['libgnutls.so.26'].gnutls_record_send
+gnutls_record_send.restype = ssize_t
+gnutls_record_send.argtypes = [gnutls_session_t, c_void_p, size_t]
+gnutls_record_recv = _libraries['libgnutls.so.26'].gnutls_record_recv
+gnutls_record_recv.restype = ssize_t
+gnutls_record_recv.argtypes = [gnutls_session_t, c_void_p, size_t]
+gnutls_session_enable_compatibility_mode = _libraries['libgnutls.so.26'].gnutls_session_enable_compatibility_mode
+gnutls_session_enable_compatibility_mode.restype = None
+gnutls_session_enable_compatibility_mode.argtypes = [gnutls_session_t]
+gnutls_record_disable_padding = _libraries['libgnutls.so.26'].gnutls_record_disable_padding
+gnutls_record_disable_padding.restype = None
+gnutls_record_disable_padding.argtypes = [gnutls_session_t]
+gnutls_record_get_direction = _libraries['libgnutls.so.26'].gnutls_record_get_direction
+gnutls_record_get_direction.restype = c_int
+gnutls_record_get_direction.argtypes = [gnutls_session_t]
+gnutls_record_get_max_size = _libraries['libgnutls.so.26'].gnutls_record_get_max_size
+gnutls_record_get_max_size.restype = size_t
+gnutls_record_get_max_size.argtypes = [gnutls_session_t]
+gnutls_record_set_max_size = _libraries['libgnutls.so.26'].gnutls_record_set_max_size
+gnutls_record_set_max_size.restype = ssize_t
+gnutls_record_set_max_size.argtypes = [gnutls_session_t, size_t]
+gnutls_record_check_pending = _libraries['libgnutls.so.26'].gnutls_record_check_pending
+gnutls_record_check_pending.restype = size_t
+gnutls_record_check_pending.argtypes = [gnutls_session_t]
+gnutls_prf = _libraries['libgnutls.so.26'].gnutls_prf
+gnutls_prf.restype = c_int
+gnutls_prf.argtypes = [gnutls_session_t, size_t, STRING, c_int, size_t, STRING, size_t, STRING]
+gnutls_prf_raw = _libraries['libgnutls.so.26'].gnutls_prf_raw
+gnutls_prf_raw.restype = c_int
+gnutls_prf_raw.argtypes = [gnutls_session_t, size_t, STRING, size_t, STRING, size_t, STRING]
+gnutls_server_name_set = _libraries['libgnutls.so.26'].gnutls_server_name_set
+gnutls_server_name_set.restype = c_int
+gnutls_server_name_set.argtypes = [gnutls_session_t, gnutls_server_name_type_t, c_void_p, size_t]
+gnutls_server_name_get = _libraries['libgnutls.so.26'].gnutls_server_name_get
+gnutls_server_name_get.restype = c_int
+gnutls_server_name_get.argtypes = [gnutls_session_t, c_void_p, POINTER(size_t), POINTER(c_uint), c_uint]
+gnutls_supplemental_get_name = _libraries['libgnutls.so.26'].gnutls_supplemental_get_name
+gnutls_supplemental_get_name.restype = STRING
+gnutls_supplemental_get_name.argtypes = [gnutls_supplemental_data_format_type_t]
+gnutls_cipher_set_priority = _libraries['libgnutls.so.26'].gnutls_cipher_set_priority
+gnutls_cipher_set_priority.restype = c_int
+gnutls_cipher_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)]
+gnutls_mac_set_priority = _libraries['libgnutls.so.26'].gnutls_mac_set_priority
+gnutls_mac_set_priority.restype = c_int
+gnutls_mac_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)]
+gnutls_compression_set_priority = _libraries['libgnutls.so.26'].gnutls_compression_set_priority
+gnutls_compression_set_priority.restype = c_int
+gnutls_compression_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)]
+gnutls_kx_set_priority = _libraries['libgnutls.so.26'].gnutls_kx_set_priority
+gnutls_kx_set_priority.restype = c_int
+gnutls_kx_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)]
+gnutls_protocol_set_priority = _libraries['libgnutls.so.26'].gnutls_protocol_set_priority
+gnutls_protocol_set_priority.restype = c_int
+gnutls_protocol_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)]
+gnutls_certificate_type_set_priority = _libraries['libgnutls.so.26'].gnutls_certificate_type_set_priority
+gnutls_certificate_type_set_priority.restype = c_int
+gnutls_certificate_type_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)]
+gnutls_priority_init = _libraries['libgnutls.so.26'].gnutls_priority_init
+gnutls_priority_init.restype = c_int
+gnutls_priority_init.argtypes = [POINTER(gnutls_priority_t), STRING, POINTER(STRING)]
+gnutls_priority_deinit = _libraries['libgnutls.so.26'].gnutls_priority_deinit
+gnutls_priority_deinit.restype = None
+gnutls_priority_deinit.argtypes = [gnutls_priority_t]
+gnutls_priority_set = _libraries['libgnutls.so.26'].gnutls_priority_set
+gnutls_priority_set.restype = c_int
+gnutls_priority_set.argtypes = [gnutls_session_t, gnutls_priority_t]
+gnutls_priority_set_direct = _libraries['libgnutls.so.26'].gnutls_priority_set_direct
+gnutls_priority_set_direct.restype = c_int
+gnutls_priority_set_direct.argtypes = [gnutls_session_t, STRING, POINTER(STRING)]
+gnutls_set_default_priority = _libraries['libgnutls.so.26'].gnutls_set_default_priority
+gnutls_set_default_priority.restype = c_int
+gnutls_set_default_priority.argtypes = [gnutls_session_t]
+gnutls_set_default_export_priority = _libraries['libgnutls.so.26'].gnutls_set_default_export_priority
+gnutls_set_default_export_priority.restype = c_int
+gnutls_set_default_export_priority.argtypes = [gnutls_session_t]
+gnutls_cipher_suite_get_name = _libraries['libgnutls.so.26'].gnutls_cipher_suite_get_name
+gnutls_cipher_suite_get_name.restype = STRING
+gnutls_cipher_suite_get_name.argtypes = [gnutls_kx_algorithm_t, gnutls_cipher_algorithm_t, gnutls_mac_algorithm_t]
+gnutls_protocol_get_version = _libraries['libgnutls.so.26'].gnutls_protocol_get_version
+gnutls_protocol_get_version.restype = gnutls_protocol_t
+gnutls_protocol_get_version.argtypes = [gnutls_session_t]
+gnutls_protocol_get_name = _libraries['libgnutls.so.26'].gnutls_protocol_get_name
+gnutls_protocol_get_name.restype = STRING
+gnutls_protocol_get_name.argtypes = [gnutls_protocol_t]
+gnutls_session_set_data = _libraries['libgnutls.so.26'].gnutls_session_set_data
+gnutls_session_set_data.restype = c_int
+gnutls_session_set_data.argtypes = [gnutls_session_t, c_void_p, size_t]
+gnutls_session_get_data = _libraries['libgnutls.so.26'].gnutls_session_get_data
+gnutls_session_get_data.restype = c_int
+gnutls_session_get_data.argtypes = [gnutls_session_t, c_void_p, POINTER(size_t)]
+gnutls_session_get_data2 = _libraries['libgnutls.so.26'].gnutls_session_get_data2
+gnutls_session_get_data2.restype = c_int
+gnutls_session_get_data2.argtypes = [gnutls_session_t, POINTER(gnutls_datum_t)]
+gnutls_session_get_id = _libraries['libgnutls.so.26'].gnutls_session_get_id
+gnutls_session_get_id.restype = c_int
+gnutls_session_get_id.argtypes = [gnutls_session_t, c_void_p, POINTER(size_t)]
+gnutls_session_get_server_random = _libraries['libgnutls.so.26'].gnutls_session_get_server_random
+gnutls_session_get_server_random.restype = c_void_p
+gnutls_session_get_server_random.argtypes = [gnutls_session_t]
+gnutls_session_get_client_random = _libraries['libgnutls.so.26'].gnutls_session_get_client_random
+gnutls_session_get_client_random.restype = c_void_p
+gnutls_session_get_client_random.argtypes = [gnutls_session_t]
+gnutls_session_get_master_secret = _libraries['libgnutls.so.26'].gnutls_session_get_master_secret
+gnutls_session_get_master_secret.restype = c_void_p
+gnutls_session_get_master_secret.argtypes = [gnutls_session_t]
+gnutls_session_is_resumed = _libraries['libgnutls.so.26'].gnutls_session_is_resumed
+gnutls_session_is_resumed.restype = c_int
+gnutls_session_is_resumed.argtypes = [gnutls_session_t]
+gnutls_db_set_cache_expiration = _libraries['libgnutls.so.26'].gnutls_db_set_cache_expiration
+gnutls_db_set_cache_expiration.restype = None
+gnutls_db_set_cache_expiration.argtypes = [gnutls_session_t, c_int]
+gnutls_db_remove_session = _libraries['libgnutls.so.26'].gnutls_db_remove_session
+gnutls_db_remove_session.restype = None
+gnutls_db_remove_session.argtypes = [gnutls_session_t]
+gnutls_db_set_retrieve_function = _libraries['libgnutls.so.26'].gnutls_db_set_retrieve_function
+gnutls_db_set_retrieve_function.restype = None
+gnutls_db_set_retrieve_function.argtypes = [gnutls_session_t, gnutls_db_retr_func]
+gnutls_db_set_remove_function = _libraries['libgnutls.so.26'].gnutls_db_set_remove_function
+gnutls_db_set_remove_function.restype = None
+gnutls_db_set_remove_function.argtypes = [gnutls_session_t, gnutls_db_remove_func]
+gnutls_db_set_store_function = _libraries['libgnutls.so.26'].gnutls_db_set_store_function
+gnutls_db_set_store_function.restype = None
+gnutls_db_set_store_function.argtypes = [gnutls_session_t, gnutls_db_store_func]
+gnutls_db_set_ptr = _libraries['libgnutls.so.26'].gnutls_db_set_ptr
+gnutls_db_set_ptr.restype = None
+gnutls_db_set_ptr.argtypes = [gnutls_session_t, c_void_p]
+gnutls_db_get_ptr = _libraries['libgnutls.so.26'].gnutls_db_get_ptr
+gnutls_db_get_ptr.restype = c_void_p
+gnutls_db_get_ptr.argtypes = [gnutls_session_t]
+gnutls_db_check_entry = _libraries['libgnutls.so.26'].gnutls_db_check_entry
+gnutls_db_check_entry.restype = c_int
+gnutls_db_check_entry.argtypes = [gnutls_session_t, gnutls_datum_t]
+gnutls_handshake_set_post_client_hello_function = _libraries['libgnutls.so.26'].gnutls_handshake_set_post_client_hello_function
+gnutls_handshake_set_post_client_hello_function.restype = None
+gnutls_handshake_set_post_client_hello_function.argtypes = [gnutls_session_t, gnutls_handshake_post_client_hello_func]
+gnutls_handshake_set_max_packet_length = _libraries['libgnutls.so.26'].gnutls_handshake_set_max_packet_length
+gnutls_handshake_set_max_packet_length.restype = None
+gnutls_handshake_set_max_packet_length.argtypes = [gnutls_session_t, size_t]
+gnutls_check_version = _libraries['libgnutls.so.26'].gnutls_check_version
+gnutls_check_version.restype = STRING
+gnutls_check_version.argtypes = [STRING]
+gnutls_credentials_clear = _libraries['libgnutls.so.26'].gnutls_credentials_clear
+gnutls_credentials_clear.restype = None
+gnutls_credentials_clear.argtypes = [gnutls_session_t]
+gnutls_credentials_set = _libraries['libgnutls.so.26'].gnutls_credentials_set
+gnutls_credentials_set.restype = c_int
+gnutls_credentials_set.argtypes = [gnutls_session_t, gnutls_credentials_type_t, c_void_p]
+gnutls_anon_free_server_credentials = _libraries['libgnutls.so.26'].gnutls_anon_free_server_credentials
+gnutls_anon_free_server_credentials.restype = None
+gnutls_anon_free_server_credentials.argtypes = [gnutls_anon_server_credentials_t]
+gnutls_anon_allocate_server_credentials = _libraries['libgnutls.so.26'].gnutls_anon_allocate_server_credentials
+gnutls_anon_allocate_server_credentials.restype = c_int
+gnutls_anon_allocate_server_credentials.argtypes = [POINTER(gnutls_anon_server_credentials_t)]
+gnutls_anon_set_server_dh_params = _libraries['libgnutls.so.26'].gnutls_anon_set_server_dh_params
+gnutls_anon_set_server_dh_params.restype = None
+gnutls_anon_set_server_dh_params.argtypes = [gnutls_anon_server_credentials_t, gnutls_dh_params_t]
+gnutls_anon_set_server_params_function = _libraries['libgnutls.so.26'].gnutls_anon_set_server_params_function
+gnutls_anon_set_server_params_function.restype = None
+gnutls_anon_set_server_params_function.argtypes = [gnutls_anon_server_credentials_t, gnutls_params_function]
+gnutls_anon_free_client_credentials = _libraries['libgnutls.so.26'].gnutls_anon_free_client_credentials
+gnutls_anon_free_client_credentials.restype = None
+gnutls_anon_free_client_credentials.argtypes = [gnutls_anon_client_credentials_t]
+gnutls_anon_allocate_client_credentials = _libraries['libgnutls.so.26'].gnutls_anon_allocate_client_credentials
+gnutls_anon_allocate_client_credentials.restype = c_int
+gnutls_anon_allocate_client_credentials.argtypes = [POINTER(gnutls_anon_client_credentials_t)]
+gnutls_certificate_free_credentials = _libraries['libgnutls.so.26'].gnutls_certificate_free_credentials
+gnutls_certificate_free_credentials.restype = None
+gnutls_certificate_free_credentials.argtypes = [gnutls_certificate_credentials_t]
+gnutls_certificate_allocate_credentials = _libraries['libgnutls.so.26'].gnutls_certificate_allocate_credentials
+gnutls_certificate_allocate_credentials.restype = c_int
+gnutls_certificate_allocate_credentials.argtypes = [POINTER(gnutls_certificate_credentials_t)]
+gnutls_certificate_free_keys = _libraries['libgnutls.so.26'].gnutls_certificate_free_keys
+gnutls_certificate_free_keys.restype = None
+gnutls_certificate_free_keys.argtypes = [gnutls_certificate_credentials_t]
+gnutls_certificate_free_cas = _libraries['libgnutls.so.26'].gnutls_certificate_free_cas
+gnutls_certificate_free_cas.restype = None
+gnutls_certificate_free_cas.argtypes = [gnutls_certificate_credentials_t]
+gnutls_certificate_free_ca_names = _libraries['libgnutls.so.26'].gnutls_certificate_free_ca_names
+gnutls_certificate_free_ca_names.restype = None
+gnutls_certificate_free_ca_names.argtypes = [gnutls_certificate_credentials_t]
+gnutls_certificate_free_crls = _libraries['libgnutls.so.26'].gnutls_certificate_free_crls
+gnutls_certificate_free_crls.restype = None
+gnutls_certificate_free_crls.argtypes = [gnutls_certificate_credentials_t]
+gnutls_certificate_set_dh_params = _libraries['libgnutls.so.26'].gnutls_certificate_set_dh_params
+gnutls_certificate_set_dh_params.restype = None
+gnutls_certificate_set_dh_params.argtypes = [gnutls_certificate_credentials_t, gnutls_dh_params_t]
+gnutls_certificate_set_rsa_export_params = _libraries['libgnutls.so.26'].gnutls_certificate_set_rsa_export_params
+gnutls_certificate_set_rsa_export_params.restype = None
+gnutls_certificate_set_rsa_export_params.argtypes = [gnutls_certificate_credentials_t, gnutls_rsa_params_t]
+gnutls_certificate_set_verify_flags = _libraries['libgnutls.so.26'].gnutls_certificate_set_verify_flags
+gnutls_certificate_set_verify_flags.restype = None
+gnutls_certificate_set_verify_flags.argtypes = [gnutls_certificate_credentials_t, c_uint]
+gnutls_certificate_set_verify_limits = _libraries['libgnutls.so.26'].gnutls_certificate_set_verify_limits
+gnutls_certificate_set_verify_limits.restype = None
+gnutls_certificate_set_verify_limits.argtypes = [gnutls_certificate_credentials_t, c_uint, c_uint]
+gnutls_certificate_set_x509_trust_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_trust_file
+gnutls_certificate_set_x509_trust_file.restype = c_int
+gnutls_certificate_set_x509_trust_file.argtypes = [gnutls_certificate_credentials_t, STRING, gnutls_x509_crt_fmt_t]
+gnutls_certificate_set_x509_trust_mem = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_trust_mem
+gnutls_certificate_set_x509_trust_mem.restype = c_int
+gnutls_certificate_set_x509_trust_mem.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_certificate_set_x509_crl_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_crl_file
+gnutls_certificate_set_x509_crl_file.restype = c_int
+gnutls_certificate_set_x509_crl_file.argtypes = [gnutls_certificate_credentials_t, STRING, gnutls_x509_crt_fmt_t]
+gnutls_certificate_set_x509_crl_mem = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_crl_mem
+gnutls_certificate_set_x509_crl_mem.restype = c_int
+gnutls_certificate_set_x509_crl_mem.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_certificate_set_x509_key_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_key_file
+gnutls_certificate_set_x509_key_file.restype = c_int
+gnutls_certificate_set_x509_key_file.argtypes = [gnutls_certificate_credentials_t, STRING, STRING, gnutls_x509_crt_fmt_t]
+gnutls_certificate_set_x509_key_mem = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_key_mem
+gnutls_certificate_set_x509_key_mem.restype = c_int
+gnutls_certificate_set_x509_key_mem.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_certificate_send_x509_rdn_sequence = _libraries['libgnutls.so.26'].gnutls_certificate_send_x509_rdn_sequence
+gnutls_certificate_send_x509_rdn_sequence.restype = None
+gnutls_certificate_send_x509_rdn_sequence.argtypes = [gnutls_session_t, c_int]
+gnutls_certificate_set_x509_simple_pkcs12_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_simple_pkcs12_file
+gnutls_certificate_set_x509_simple_pkcs12_file.restype = c_int
+gnutls_certificate_set_x509_simple_pkcs12_file.argtypes = [gnutls_certificate_credentials_t, STRING, gnutls_x509_crt_fmt_t, STRING]
+gnutls_certificate_set_x509_key = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_key
+gnutls_certificate_set_x509_key.restype = c_int
+gnutls_certificate_set_x509_key.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_x509_crt_t), c_int, gnutls_x509_privkey_t]
+gnutls_certificate_set_x509_trust = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_trust
+gnutls_certificate_set_x509_trust.restype = c_int
+gnutls_certificate_set_x509_trust.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_x509_crt_t), c_int]
+gnutls_certificate_set_x509_crl = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_crl
+gnutls_certificate_set_x509_crl.restype = c_int
+gnutls_certificate_set_x509_crl.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_x509_crl_t), c_int]
+gnutls_certificate_get_x509_cas = _libraries['libgnutls.so.26'].gnutls_certificate_get_x509_cas
+gnutls_certificate_get_x509_cas.restype = None
+gnutls_certificate_get_x509_cas.argtypes = [gnutls_certificate_credentials_t, POINTER(POINTER(gnutls_x509_crt_t)), POINTER(c_uint)]
+gnutls_certificate_get_x509_crls = _libraries['libgnutls.so.26'].gnutls_certificate_get_x509_crls
+gnutls_certificate_get_x509_crls.restype = None
+gnutls_certificate_get_x509_crls.argtypes = [gnutls_certificate_credentials_t, POINTER(POINTER(gnutls_x509_crl_t)), POINTER(c_uint)]
+gnutls_certificate_get_openpgp_keyring = _libraries['libgnutls.so.26'].gnutls_certificate_get_openpgp_keyring
+gnutls_certificate_get_openpgp_keyring.restype = None
+gnutls_certificate_get_openpgp_keyring.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_openpgp_keyring_t)]
+gnutls_global_init = _libraries['libgnutls.so.26'].gnutls_global_init
+gnutls_global_init.restype = c_int
+gnutls_global_init.argtypes = []
+gnutls_global_deinit = _libraries['libgnutls.so.26'].gnutls_global_deinit
+gnutls_global_deinit.restype = None
+gnutls_global_deinit.argtypes = []
+gnutls_global_set_mem_functions = _libraries['libgnutls.so.26'].gnutls_global_set_mem_functions
+gnutls_global_set_mem_functions.restype = None
+gnutls_global_set_mem_functions.argtypes = [gnutls_alloc_function, gnutls_alloc_function, gnutls_is_secure_function, gnutls_realloc_function, gnutls_free_function]
+gnutls_global_set_log_function = _libraries['libgnutls.so.26'].gnutls_global_set_log_function
+gnutls_global_set_log_function.restype = None
+gnutls_global_set_log_function.argtypes = [gnutls_log_func]
+gnutls_global_set_log_level = _libraries['libgnutls.so.26'].gnutls_global_set_log_level
+gnutls_global_set_log_level.restype = None
+gnutls_global_set_log_level.argtypes = [c_int]
+gnutls_dh_params_init = _libraries['libgnutls.so.26'].gnutls_dh_params_init
+gnutls_dh_params_init.restype = c_int
+gnutls_dh_params_init.argtypes = [POINTER(gnutls_dh_params_t)]
+gnutls_dh_params_deinit = _libraries['libgnutls.so.26'].gnutls_dh_params_deinit
+gnutls_dh_params_deinit.restype = None
+gnutls_dh_params_deinit.argtypes = [gnutls_dh_params_t]
+gnutls_dh_params_import_raw = _libraries['libgnutls.so.26'].gnutls_dh_params_import_raw
+gnutls_dh_params_import_raw.restype = c_int
+gnutls_dh_params_import_raw.argtypes = [gnutls_dh_params_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_dh_params_import_pkcs3 = _libraries['libgnutls.so.26'].gnutls_dh_params_import_pkcs3
+gnutls_dh_params_import_pkcs3.restype = c_int
+gnutls_dh_params_import_pkcs3.argtypes = [gnutls_dh_params_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_dh_params_generate2 = _libraries['libgnutls.so.26'].gnutls_dh_params_generate2
+gnutls_dh_params_generate2.restype = c_int
+gnutls_dh_params_generate2.argtypes = [gnutls_dh_params_t, c_uint]
+gnutls_dh_params_export_pkcs3 = _libraries['libgnutls.so.26'].gnutls_dh_params_export_pkcs3
+gnutls_dh_params_export_pkcs3.restype = c_int
+gnutls_dh_params_export_pkcs3.argtypes = [gnutls_dh_params_t, gnutls_x509_crt_fmt_t, POINTER(c_ubyte), POINTER(size_t)]
+gnutls_dh_params_export_raw = _libraries['libgnutls.so.26'].gnutls_dh_params_export_raw
+gnutls_dh_params_export_raw.restype = c_int
+gnutls_dh_params_export_raw.argtypes = [gnutls_dh_params_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(c_uint)]
+gnutls_dh_params_cpy = _libraries['libgnutls.so.26'].gnutls_dh_params_cpy
+gnutls_dh_params_cpy.restype = c_int
+gnutls_dh_params_cpy.argtypes = [gnutls_dh_params_t, gnutls_dh_params_t]
+gnutls_rsa_params_init = _libraries['libgnutls.so.26'].gnutls_rsa_params_init
+gnutls_rsa_params_init.restype = c_int
+gnutls_rsa_params_init.argtypes = [POINTER(gnutls_rsa_params_t)]
+gnutls_rsa_params_deinit = _libraries['libgnutls.so.26'].gnutls_rsa_params_deinit
+gnutls_rsa_params_deinit.restype = None
+gnutls_rsa_params_deinit.argtypes = [gnutls_rsa_params_t]
+gnutls_rsa_params_cpy = _libraries['libgnutls.so.26'].gnutls_rsa_params_cpy
+gnutls_rsa_params_cpy.restype = c_int
+gnutls_rsa_params_cpy.argtypes = [gnutls_rsa_params_t, gnutls_rsa_params_t]
+gnutls_rsa_params_import_raw = _libraries['libgnutls.so.26'].gnutls_rsa_params_import_raw
+gnutls_rsa_params_import_raw.restype = c_int
+gnutls_rsa_params_import_raw.argtypes = [gnutls_rsa_params_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_rsa_params_generate2 = _libraries['libgnutls.so.26'].gnutls_rsa_params_generate2
+gnutls_rsa_params_generate2.restype = c_int
+gnutls_rsa_params_generate2.argtypes = [gnutls_rsa_params_t, c_uint]
+gnutls_rsa_params_export_raw = _libraries['libgnutls.so.26'].gnutls_rsa_params_export_raw
+gnutls_rsa_params_export_raw.restype = c_int
+gnutls_rsa_params_export_raw.argtypes = [gnutls_rsa_params_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(c_uint)]
+gnutls_rsa_params_export_pkcs1 = _libraries['libgnutls.so.26'].gnutls_rsa_params_export_pkcs1
+gnutls_rsa_params_export_pkcs1.restype = c_int
+gnutls_rsa_params_export_pkcs1.argtypes = [gnutls_rsa_params_t, gnutls_x509_crt_fmt_t, POINTER(c_ubyte), POINTER(size_t)]
+gnutls_rsa_params_import_pkcs1 = _libraries['libgnutls.so.26'].gnutls_rsa_params_import_pkcs1
+gnutls_rsa_params_import_pkcs1.restype = c_int
+gnutls_rsa_params_import_pkcs1.argtypes = [gnutls_rsa_params_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_transport_set_ptr = _libraries['libgnutls.so.26'].gnutls_transport_set_ptr
+gnutls_transport_set_ptr.restype = None
+gnutls_transport_set_ptr.argtypes = [gnutls_session_t, gnutls_transport_ptr_t]
+gnutls_transport_set_ptr2 = _libraries['libgnutls.so.26'].gnutls_transport_set_ptr2
+gnutls_transport_set_ptr2.restype = None
+gnutls_transport_set_ptr2.argtypes = [gnutls_session_t, gnutls_transport_ptr_t, gnutls_transport_ptr_t]
+gnutls_transport_get_ptr = _libraries['libgnutls.so.26'].gnutls_transport_get_ptr
+gnutls_transport_get_ptr.restype = gnutls_transport_ptr_t
+gnutls_transport_get_ptr.argtypes = [gnutls_session_t]
+gnutls_transport_get_ptr2 = _libraries['libgnutls.so.26'].gnutls_transport_get_ptr2
+gnutls_transport_get_ptr2.restype = None
+gnutls_transport_get_ptr2.argtypes = [gnutls_session_t, POINTER(gnutls_transport_ptr_t), POINTER(gnutls_transport_ptr_t)]
+gnutls_transport_set_lowat = _libraries['libgnutls.so.26'].gnutls_transport_set_lowat
+gnutls_transport_set_lowat.restype = None
+gnutls_transport_set_lowat.argtypes = [gnutls_session_t, c_int]
+gnutls_transport_set_push_function = _libraries['libgnutls.so.26'].gnutls_transport_set_push_function
+gnutls_transport_set_push_function.restype = None
+gnutls_transport_set_push_function.argtypes = [gnutls_session_t, gnutls_push_func]
+gnutls_transport_set_pull_function = _libraries['libgnutls.so.26'].gnutls_transport_set_pull_function
+gnutls_transport_set_pull_function.restype = None
+gnutls_transport_set_pull_function.argtypes = [gnutls_session_t, gnutls_pull_func]
+gnutls_transport_set_errno = _libraries['libgnutls.so.26'].gnutls_transport_set_errno
+gnutls_transport_set_errno.restype = None
+gnutls_transport_set_errno.argtypes = [gnutls_session_t, c_int]
+gnutls_transport_set_global_errno = _libraries['libgnutls.so.26'].gnutls_transport_set_global_errno
+gnutls_transport_set_global_errno.restype = None
+gnutls_transport_set_global_errno.argtypes = [c_int]
+gnutls_session_set_ptr = _libraries['libgnutls.so.26'].gnutls_session_set_ptr
+gnutls_session_set_ptr.restype = None
+gnutls_session_set_ptr.argtypes = [gnutls_session_t, c_void_p]
+gnutls_session_get_ptr = _libraries['libgnutls.so.26'].gnutls_session_get_ptr
+gnutls_session_get_ptr.restype = c_void_p
+gnutls_session_get_ptr.argtypes = [gnutls_session_t]
+gnutls_openpgp_send_cert = _libraries['libgnutls.so.26'].gnutls_openpgp_send_cert
+gnutls_openpgp_send_cert.restype = None
+gnutls_openpgp_send_cert.argtypes = [gnutls_session_t, gnutls_openpgp_crt_status_t]
+gnutls_fingerprint = _libraries['libgnutls.so.26'].gnutls_fingerprint
+gnutls_fingerprint.restype = c_int
+gnutls_fingerprint.argtypes = [gnutls_digest_algorithm_t, POINTER(gnutls_datum_t), c_void_p, POINTER(size_t)]
+gnutls_srp_free_client_credentials = _libraries['libgnutls.so.26'].gnutls_srp_free_client_credentials
+gnutls_srp_free_client_credentials.restype = None
+gnutls_srp_free_client_credentials.argtypes = [gnutls_srp_client_credentials_t]
+gnutls_srp_allocate_client_credentials = _libraries['libgnutls.so.26'].gnutls_srp_allocate_client_credentials
+gnutls_srp_allocate_client_credentials.restype = c_int
+gnutls_srp_allocate_client_credentials.argtypes = [POINTER(gnutls_srp_client_credentials_t)]
+gnutls_srp_set_client_credentials = _libraries['libgnutls.so.26'].gnutls_srp_set_client_credentials
+gnutls_srp_set_client_credentials.restype = c_int
+gnutls_srp_set_client_credentials.argtypes = [gnutls_srp_client_credentials_t, STRING, STRING]
+gnutls_srp_free_server_credentials = _libraries['libgnutls.so.26'].gnutls_srp_free_server_credentials
+gnutls_srp_free_server_credentials.restype = None
+gnutls_srp_free_server_credentials.argtypes = [gnutls_srp_server_credentials_t]
+gnutls_srp_allocate_server_credentials = _libraries['libgnutls.so.26'].gnutls_srp_allocate_server_credentials
+gnutls_srp_allocate_server_credentials.restype = c_int
+gnutls_srp_allocate_server_credentials.argtypes = [POINTER(gnutls_srp_server_credentials_t)]
+gnutls_srp_set_server_credentials_file = _libraries['libgnutls.so.26'].gnutls_srp_set_server_credentials_file
+gnutls_srp_set_server_credentials_file.restype = c_int
+gnutls_srp_set_server_credentials_file.argtypes = [gnutls_srp_server_credentials_t, STRING, STRING]
+gnutls_srp_server_get_username = _libraries['libgnutls.so.26'].gnutls_srp_server_get_username
+gnutls_srp_server_get_username.restype = STRING
+gnutls_srp_server_get_username.argtypes = [gnutls_session_t]
+gnutls_srp_verifier = _libraries['libgnutls.so.26'].gnutls_srp_verifier
+gnutls_srp_verifier.restype = c_int
+gnutls_srp_verifier.argtypes = [STRING, STRING, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_srp_set_server_credentials_function = _libraries['libgnutls.so.26'].gnutls_srp_set_server_credentials_function
+gnutls_srp_set_server_credentials_function.restype = None
+gnutls_srp_set_server_credentials_function.argtypes = [gnutls_srp_server_credentials_t, gnutls_srp_server_credentials_function]
+gnutls_srp_set_client_credentials_function = _libraries['libgnutls.so.26'].gnutls_srp_set_client_credentials_function
+gnutls_srp_set_client_credentials_function.restype = None
+gnutls_srp_set_client_credentials_function.argtypes = [gnutls_srp_client_credentials_t, gnutls_srp_client_credentials_function]
+gnutls_srp_base64_encode = _libraries['libgnutls.so.26'].gnutls_srp_base64_encode
+gnutls_srp_base64_encode.restype = c_int
+gnutls_srp_base64_encode.argtypes = [POINTER(gnutls_datum_t), STRING, POINTER(size_t)]
+gnutls_srp_base64_encode_alloc = _libraries['libgnutls.so.26'].gnutls_srp_base64_encode_alloc
+gnutls_srp_base64_encode_alloc.restype = c_int
+gnutls_srp_base64_encode_alloc.argtypes = [POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_srp_base64_decode = _libraries['libgnutls.so.26'].gnutls_srp_base64_decode
+gnutls_srp_base64_decode.restype = c_int
+gnutls_srp_base64_decode.argtypes = [POINTER(gnutls_datum_t), STRING, POINTER(size_t)]
+gnutls_srp_base64_decode_alloc = _libraries['libgnutls.so.26'].gnutls_srp_base64_decode_alloc
+gnutls_srp_base64_decode_alloc.restype = c_int
+gnutls_srp_base64_decode_alloc.argtypes = [POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_psk_free_client_credentials = _libraries['libgnutls.so.26'].gnutls_psk_free_client_credentials
+gnutls_psk_free_client_credentials.restype = None
+gnutls_psk_free_client_credentials.argtypes = [gnutls_psk_client_credentials_t]
+gnutls_psk_allocate_client_credentials = _libraries['libgnutls.so.26'].gnutls_psk_allocate_client_credentials
+gnutls_psk_allocate_client_credentials.restype = c_int
+gnutls_psk_allocate_client_credentials.argtypes = [POINTER(gnutls_psk_client_credentials_t)]
+gnutls_psk_set_client_credentials = _libraries['libgnutls.so.26'].gnutls_psk_set_client_credentials
+gnutls_psk_set_client_credentials.restype = c_int
+gnutls_psk_set_client_credentials.argtypes = [gnutls_psk_client_credentials_t, STRING, POINTER(gnutls_datum_t), gnutls_psk_key_flags]
+gnutls_psk_free_server_credentials = _libraries['libgnutls.so.26'].gnutls_psk_free_server_credentials
+gnutls_psk_free_server_credentials.restype = None
+gnutls_psk_free_server_credentials.argtypes = [gnutls_psk_server_credentials_t]
+gnutls_psk_allocate_server_credentials = _libraries['libgnutls.so.26'].gnutls_psk_allocate_server_credentials
+gnutls_psk_allocate_server_credentials.restype = c_int
+gnutls_psk_allocate_server_credentials.argtypes = [POINTER(gnutls_psk_server_credentials_t)]
+gnutls_psk_set_server_credentials_file = _libraries['libgnutls.so.26'].gnutls_psk_set_server_credentials_file
+gnutls_psk_set_server_credentials_file.restype = c_int
+gnutls_psk_set_server_credentials_file.argtypes = [gnutls_psk_server_credentials_t, STRING]
+gnutls_psk_set_server_credentials_hint = _libraries['libgnutls.so.26'].gnutls_psk_set_server_credentials_hint
+gnutls_psk_set_server_credentials_hint.restype = c_int
+gnutls_psk_set_server_credentials_hint.argtypes = [gnutls_psk_server_credentials_t, STRING]
+gnutls_psk_server_get_username = _libraries['libgnutls.so.26'].gnutls_psk_server_get_username
+gnutls_psk_server_get_username.restype = STRING
+gnutls_psk_server_get_username.argtypes = [gnutls_session_t]
+gnutls_psk_client_get_hint = _libraries['libgnutls.so.26'].gnutls_psk_client_get_hint
+gnutls_psk_client_get_hint.restype = STRING
+gnutls_psk_client_get_hint.argtypes = [gnutls_session_t]
+gnutls_psk_set_server_credentials_function = _libraries['libgnutls.so.26'].gnutls_psk_set_server_credentials_function
+gnutls_psk_set_server_credentials_function.restype = None
+gnutls_psk_set_server_credentials_function.argtypes = [gnutls_psk_server_credentials_t, gnutls_psk_server_credentials_function]
+gnutls_psk_set_client_credentials_function = _libraries['libgnutls.so.26'].gnutls_psk_set_client_credentials_function
+gnutls_psk_set_client_credentials_function.restype = None
+gnutls_psk_set_client_credentials_function.argtypes = [gnutls_psk_client_credentials_t, gnutls_psk_client_credentials_function]
+gnutls_hex_encode = _libraries['libgnutls.so.26'].gnutls_hex_encode
+gnutls_hex_encode.restype = c_int
+gnutls_hex_encode.argtypes = [POINTER(gnutls_datum_t), STRING, POINTER(size_t)]
+gnutls_hex_decode = _libraries['libgnutls.so.26'].gnutls_hex_decode
+gnutls_hex_decode.restype = c_int
+gnutls_hex_decode.argtypes = [POINTER(gnutls_datum_t), STRING, POINTER(size_t)]
+gnutls_psk_set_server_dh_params = _libraries['libgnutls.so.26'].gnutls_psk_set_server_dh_params
+gnutls_psk_set_server_dh_params.restype = None
+gnutls_psk_set_server_dh_params.argtypes = [gnutls_psk_server_credentials_t, gnutls_dh_params_t]
+gnutls_psk_set_server_params_function = _libraries['libgnutls.so.26'].gnutls_psk_set_server_params_function
+gnutls_psk_set_server_params_function.restype = None
+gnutls_psk_set_server_params_function.argtypes = [gnutls_psk_server_credentials_t, gnutls_params_function]
+gnutls_psk_netconf_derive_key = _libraries['libgnutls.so.26'].gnutls_psk_netconf_derive_key
+gnutls_psk_netconf_derive_key.restype = c_int
+gnutls_psk_netconf_derive_key.argtypes = [STRING, STRING, STRING, POINTER(gnutls_datum_t)]
+gnutls_auth_get_type = _libraries['libgnutls.so.26'].gnutls_auth_get_type
+gnutls_auth_get_type.restype = gnutls_credentials_type_t
+gnutls_auth_get_type.argtypes = [gnutls_session_t]
+gnutls_auth_server_get_type = _libraries['libgnutls.so.26'].gnutls_auth_server_get_type
+gnutls_auth_server_get_type.restype = gnutls_credentials_type_t
+gnutls_auth_server_get_type.argtypes = [gnutls_session_t]
+gnutls_auth_client_get_type = _libraries['libgnutls.so.26'].gnutls_auth_client_get_type
+gnutls_auth_client_get_type.restype = gnutls_credentials_type_t
+gnutls_auth_client_get_type.argtypes = [gnutls_session_t]
+gnutls_dh_set_prime_bits = _libraries['libgnutls.so.26'].gnutls_dh_set_prime_bits
+gnutls_dh_set_prime_bits.restype = None
+gnutls_dh_set_prime_bits.argtypes = [gnutls_session_t, c_uint]
+gnutls_dh_get_secret_bits = _libraries['libgnutls.so.26'].gnutls_dh_get_secret_bits
+gnutls_dh_get_secret_bits.restype = c_int
+gnutls_dh_get_secret_bits.argtypes = [gnutls_session_t]
+gnutls_dh_get_peers_public_bits = _libraries['libgnutls.so.26'].gnutls_dh_get_peers_public_bits
+gnutls_dh_get_peers_public_bits.restype = c_int
+gnutls_dh_get_peers_public_bits.argtypes = [gnutls_session_t]
+gnutls_dh_get_prime_bits = _libraries['libgnutls.so.26'].gnutls_dh_get_prime_bits
+gnutls_dh_get_prime_bits.restype = c_int
+gnutls_dh_get_prime_bits.argtypes = [gnutls_session_t]
+gnutls_dh_get_group = _libraries['libgnutls.so.26'].gnutls_dh_get_group
+gnutls_dh_get_group.restype = c_int
+gnutls_dh_get_group.argtypes = [gnutls_session_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_dh_get_pubkey = _libraries['libgnutls.so.26'].gnutls_dh_get_pubkey
+gnutls_dh_get_pubkey.restype = c_int
+gnutls_dh_get_pubkey.argtypes = [gnutls_session_t, POINTER(gnutls_datum_t)]
+gnutls_rsa_export_get_pubkey = _libraries['libgnutls.so.26'].gnutls_rsa_export_get_pubkey
+gnutls_rsa_export_get_pubkey.restype = c_int
+gnutls_rsa_export_get_pubkey.argtypes = [gnutls_session_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_rsa_export_get_modulus_bits = _libraries['libgnutls.so.26'].gnutls_rsa_export_get_modulus_bits
+gnutls_rsa_export_get_modulus_bits.restype = c_int
+gnutls_rsa_export_get_modulus_bits.argtypes = [gnutls_session_t]
+gnutls_sign_callback_set = _libraries['libgnutls.so.26'].gnutls_sign_callback_set
+gnutls_sign_callback_set.restype = None
+gnutls_sign_callback_set.argtypes = [gnutls_session_t, gnutls_sign_func, c_void_p]
+gnutls_sign_callback_get = _libraries['libgnutls.so.26'].gnutls_sign_callback_get
+gnutls_sign_callback_get.restype = gnutls_sign_func
+gnutls_sign_callback_get.argtypes = [gnutls_session_t, POINTER(c_void_p)]
+gnutls_certificate_client_set_retrieve_function = _libraries['libgnutls.so.26'].gnutls_certificate_client_set_retrieve_function
+gnutls_certificate_client_set_retrieve_function.restype = None
+gnutls_certificate_client_set_retrieve_function.argtypes = [gnutls_certificate_credentials_t, gnutls_certificate_client_retrieve_function]
+gnutls_certificate_server_set_retrieve_function = _libraries['libgnutls.so.26'].gnutls_certificate_server_set_retrieve_function
+gnutls_certificate_server_set_retrieve_function.restype = None
+gnutls_certificate_server_set_retrieve_function.argtypes = [gnutls_certificate_credentials_t, gnutls_certificate_server_retrieve_function]
+gnutls_certificate_server_set_request = _libraries['libgnutls.so.26'].gnutls_certificate_server_set_request
+gnutls_certificate_server_set_request.restype = None
+gnutls_certificate_server_set_request.argtypes = [gnutls_session_t, gnutls_certificate_request_t]
+gnutls_certificate_get_peers = _libraries['libgnutls.so.26'].gnutls_certificate_get_peers
+gnutls_certificate_get_peers.restype = POINTER(gnutls_datum_t)
+gnutls_certificate_get_peers.argtypes = [gnutls_session_t, POINTER(c_uint)]
+gnutls_certificate_get_ours = _libraries['libgnutls.so.26'].gnutls_certificate_get_ours
+gnutls_certificate_get_ours.restype = POINTER(gnutls_datum_t)
+gnutls_certificate_get_ours.argtypes = [gnutls_session_t]
+__time_t = c_long
+time_t = __time_t
+gnutls_certificate_activation_time_peers = _libraries['libgnutls.so.26'].gnutls_certificate_activation_time_peers
+gnutls_certificate_activation_time_peers.restype = time_t
+gnutls_certificate_activation_time_peers.argtypes = [gnutls_session_t]
+gnutls_certificate_expiration_time_peers = _libraries['libgnutls.so.26'].gnutls_certificate_expiration_time_peers
+gnutls_certificate_expiration_time_peers.restype = time_t
+gnutls_certificate_expiration_time_peers.argtypes = [gnutls_session_t]
+gnutls_certificate_client_get_request_status = _libraries['libgnutls.so.26'].gnutls_certificate_client_get_request_status
+gnutls_certificate_client_get_request_status.restype = c_int
+gnutls_certificate_client_get_request_status.argtypes = [gnutls_session_t]
+gnutls_certificate_verify_peers2 = _libraries['libgnutls.so.26'].gnutls_certificate_verify_peers2
+gnutls_certificate_verify_peers2.restype = c_int
+gnutls_certificate_verify_peers2.argtypes = [gnutls_session_t, POINTER(c_uint)]
+gnutls_certificate_verify_peers = _libraries['libgnutls.so.26'].gnutls_certificate_verify_peers
+gnutls_certificate_verify_peers.restype = c_int
+gnutls_certificate_verify_peers.argtypes = [gnutls_session_t]
+gnutls_pem_base64_encode = _libraries['libgnutls.so.26'].gnutls_pem_base64_encode
+gnutls_pem_base64_encode.restype = c_int
+gnutls_pem_base64_encode.argtypes = [STRING, POINTER(gnutls_datum_t), STRING, POINTER(size_t)]
+gnutls_pem_base64_decode = _libraries['libgnutls.so.26'].gnutls_pem_base64_decode
+gnutls_pem_base64_decode.restype = c_int
+gnutls_pem_base64_decode.argtypes = [STRING, POINTER(gnutls_datum_t), POINTER(c_ubyte), POINTER(size_t)]
+gnutls_pem_base64_encode_alloc = _libraries['libgnutls.so.26'].gnutls_pem_base64_encode_alloc
+gnutls_pem_base64_encode_alloc.restype = c_int
+gnutls_pem_base64_encode_alloc.argtypes = [STRING, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_pem_base64_decode_alloc = _libraries['libgnutls.so.26'].gnutls_pem_base64_decode_alloc
+gnutls_pem_base64_decode_alloc.restype = c_int
+gnutls_pem_base64_decode_alloc.argtypes = [STRING, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_certificate_set_params_function = _libraries['libgnutls.so.26'].gnutls_certificate_set_params_function
+gnutls_certificate_set_params_function.restype = None
+gnutls_certificate_set_params_function.argtypes = [gnutls_certificate_credentials_t, gnutls_params_function]
+gnutls_anon_set_params_function = _libraries['libgnutls.so.26'].gnutls_anon_set_params_function
+gnutls_anon_set_params_function.restype = None
+gnutls_anon_set_params_function.argtypes = [gnutls_anon_server_credentials_t, gnutls_params_function]
+gnutls_psk_set_params_function = _libraries['libgnutls.so.26'].gnutls_psk_set_params_function
+gnutls_psk_set_params_function.restype = None
+gnutls_psk_set_params_function.argtypes = [gnutls_psk_server_credentials_t, gnutls_params_function]
+gnutls_hex2bin = _libraries['libgnutls.so.26'].gnutls_hex2bin
+gnutls_hex2bin.restype = c_int
+gnutls_hex2bin.argtypes = [STRING, size_t, STRING, POINTER(size_t)]
+gnutls_openpgp_crt_init = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_init
+gnutls_openpgp_crt_init.restype = c_int
+gnutls_openpgp_crt_init.argtypes = [POINTER(gnutls_openpgp_crt_t)]
+gnutls_openpgp_crt_deinit = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_deinit
+gnutls_openpgp_crt_deinit.restype = None
+gnutls_openpgp_crt_deinit.argtypes = [gnutls_openpgp_crt_t]
+gnutls_openpgp_crt_import = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_import
+gnutls_openpgp_crt_import.restype = c_int
+gnutls_openpgp_crt_import.argtypes = [gnutls_openpgp_crt_t, POINTER(gnutls_datum_t), gnutls_openpgp_crt_fmt_t]
+gnutls_openpgp_crt_export = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_export
+gnutls_openpgp_crt_export.restype = c_int
+gnutls_openpgp_crt_export.argtypes = [gnutls_openpgp_crt_t, gnutls_openpgp_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_openpgp_crt_print = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_print
+gnutls_openpgp_crt_print.restype = c_int
+gnutls_openpgp_crt_print.argtypes = [gnutls_openpgp_crt_t, gnutls_certificate_print_formats_t, POINTER(gnutls_datum_t)]
+gnutls_openpgp_crt_get_key_usage = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_key_usage
+gnutls_openpgp_crt_get_key_usage.restype = c_int
+gnutls_openpgp_crt_get_key_usage.argtypes = [gnutls_openpgp_crt_t, POINTER(c_uint)]
+gnutls_openpgp_crt_get_fingerprint = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_fingerprint
+gnutls_openpgp_crt_get_fingerprint.restype = c_int
+gnutls_openpgp_crt_get_fingerprint.argtypes = [gnutls_openpgp_crt_t, c_void_p, POINTER(size_t)]
+gnutls_openpgp_crt_get_subkey_fingerprint = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_fingerprint
+gnutls_openpgp_crt_get_subkey_fingerprint.restype = c_int
+gnutls_openpgp_crt_get_subkey_fingerprint.argtypes = [gnutls_openpgp_crt_t, c_uint, c_void_p, POINTER(size_t)]
+gnutls_openpgp_crt_get_name = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_name
+gnutls_openpgp_crt_get_name.restype = c_int
+gnutls_openpgp_crt_get_name.argtypes = [gnutls_openpgp_crt_t, c_int, STRING, POINTER(size_t)]
+gnutls_openpgp_crt_get_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_pk_algorithm
+gnutls_openpgp_crt_get_pk_algorithm.restype = gnutls_pk_algorithm_t
+gnutls_openpgp_crt_get_pk_algorithm.argtypes = [gnutls_openpgp_crt_t, POINTER(c_uint)]
+gnutls_openpgp_crt_get_version = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_version
+gnutls_openpgp_crt_get_version.restype = c_int
+gnutls_openpgp_crt_get_version.argtypes = [gnutls_openpgp_crt_t]
+gnutls_openpgp_crt_get_creation_time = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_creation_time
+gnutls_openpgp_crt_get_creation_time.restype = time_t
+gnutls_openpgp_crt_get_creation_time.argtypes = [gnutls_openpgp_crt_t]
+gnutls_openpgp_crt_get_expiration_time = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_expiration_time
+gnutls_openpgp_crt_get_expiration_time.restype = time_t
+gnutls_openpgp_crt_get_expiration_time.argtypes = [gnutls_openpgp_crt_t]
+gnutls_openpgp_crt_get_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_key_id
+gnutls_openpgp_crt_get_key_id.restype = c_int
+gnutls_openpgp_crt_get_key_id.argtypes = [gnutls_openpgp_crt_t, POINTER(c_ubyte)]
+gnutls_openpgp_crt_check_hostname = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_check_hostname
+gnutls_openpgp_crt_check_hostname.restype = c_int
+gnutls_openpgp_crt_check_hostname.argtypes = [gnutls_openpgp_crt_t, STRING]
+gnutls_openpgp_crt_get_revoked_status = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_revoked_status
+gnutls_openpgp_crt_get_revoked_status.restype = c_int
+gnutls_openpgp_crt_get_revoked_status.argtypes = [gnutls_openpgp_crt_t]
+gnutls_openpgp_crt_get_subkey_count = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_count
+gnutls_openpgp_crt_get_subkey_count.restype = c_int
+gnutls_openpgp_crt_get_subkey_count.argtypes = [gnutls_openpgp_crt_t]
+gnutls_openpgp_crt_get_subkey_idx = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_idx
+gnutls_openpgp_crt_get_subkey_idx.restype = c_int
+gnutls_openpgp_crt_get_subkey_idx.argtypes = [gnutls_openpgp_crt_t, POINTER(c_ubyte)]
+gnutls_openpgp_crt_get_subkey_revoked_status = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_revoked_status
+gnutls_openpgp_crt_get_subkey_revoked_status.restype = c_int
+gnutls_openpgp_crt_get_subkey_revoked_status.argtypes = [gnutls_openpgp_crt_t, c_uint]
+gnutls_openpgp_crt_get_subkey_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_pk_algorithm
+gnutls_openpgp_crt_get_subkey_pk_algorithm.restype = gnutls_pk_algorithm_t
+gnutls_openpgp_crt_get_subkey_pk_algorithm.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(c_uint)]
+gnutls_openpgp_crt_get_subkey_creation_time = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_creation_time
+gnutls_openpgp_crt_get_subkey_creation_time.restype = time_t
+gnutls_openpgp_crt_get_subkey_creation_time.argtypes = [gnutls_openpgp_crt_t, c_uint]
+gnutls_openpgp_crt_get_subkey_expiration_time = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_expiration_time
+gnutls_openpgp_crt_get_subkey_expiration_time.restype = time_t
+gnutls_openpgp_crt_get_subkey_expiration_time.argtypes = [gnutls_openpgp_crt_t, c_uint]
+gnutls_openpgp_crt_get_subkey_id = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_id
+gnutls_openpgp_crt_get_subkey_id.restype = c_int
+gnutls_openpgp_crt_get_subkey_id.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(c_ubyte)]
+gnutls_openpgp_crt_get_subkey_usage = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_usage
+gnutls_openpgp_crt_get_subkey_usage.restype = c_int
+gnutls_openpgp_crt_get_subkey_usage.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(c_uint)]
+gnutls_openpgp_crt_get_subkey_pk_dsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_pk_dsa_raw
+gnutls_openpgp_crt_get_subkey_pk_dsa_raw.restype = c_int
+gnutls_openpgp_crt_get_subkey_pk_dsa_raw.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_crt_get_subkey_pk_rsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_pk_rsa_raw
+gnutls_openpgp_crt_get_subkey_pk_rsa_raw.restype = c_int
+gnutls_openpgp_crt_get_subkey_pk_rsa_raw.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_crt_get_pk_dsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_pk_dsa_raw
+gnutls_openpgp_crt_get_pk_dsa_raw.restype = c_int
+gnutls_openpgp_crt_get_pk_dsa_raw.argtypes = [gnutls_openpgp_crt_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_crt_get_pk_rsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_pk_rsa_raw
+gnutls_openpgp_crt_get_pk_rsa_raw.restype = c_int
+gnutls_openpgp_crt_get_pk_rsa_raw.argtypes = [gnutls_openpgp_crt_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_crt_get_preferred_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_preferred_key_id
+gnutls_openpgp_crt_get_preferred_key_id.restype = c_int
+gnutls_openpgp_crt_get_preferred_key_id.argtypes = [gnutls_openpgp_crt_t, POINTER(c_ubyte)]
+gnutls_openpgp_crt_set_preferred_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_set_preferred_key_id
+gnutls_openpgp_crt_set_preferred_key_id.restype = c_int
+gnutls_openpgp_crt_set_preferred_key_id.argtypes = [gnutls_openpgp_crt_t, POINTER(c_ubyte)]
+gnutls_openpgp_privkey_init = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_init
+gnutls_openpgp_privkey_init.restype = c_int
+gnutls_openpgp_privkey_init.argtypes = [POINTER(gnutls_openpgp_privkey_t)]
+gnutls_openpgp_privkey_deinit = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_deinit
+gnutls_openpgp_privkey_deinit.restype = None
+gnutls_openpgp_privkey_deinit.argtypes = [gnutls_openpgp_privkey_t]
+gnutls_openpgp_privkey_get_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_pk_algorithm
+gnutls_openpgp_privkey_get_pk_algorithm.restype = gnutls_pk_algorithm_t
+gnutls_openpgp_privkey_get_pk_algorithm.argtypes = [gnutls_openpgp_privkey_t, POINTER(c_uint)]
+gnutls_openpgp_privkey_import = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_import
+gnutls_openpgp_privkey_import.restype = c_int
+gnutls_openpgp_privkey_import.argtypes = [gnutls_openpgp_privkey_t, POINTER(gnutls_datum_t), gnutls_openpgp_crt_fmt_t, STRING, c_uint]
+gnutls_openpgp_privkey_sign_hash = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_sign_hash
+gnutls_openpgp_privkey_sign_hash.restype = c_int
+gnutls_openpgp_privkey_sign_hash.argtypes = [gnutls_openpgp_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_privkey_get_fingerprint = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_fingerprint
+gnutls_openpgp_privkey_get_fingerprint.restype = c_int
+gnutls_openpgp_privkey_get_fingerprint.argtypes = [gnutls_openpgp_privkey_t, c_void_p, POINTER(size_t)]
+gnutls_openpgp_privkey_get_subkey_fingerprint = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_fingerprint
+gnutls_openpgp_privkey_get_subkey_fingerprint.restype = c_int
+gnutls_openpgp_privkey_get_subkey_fingerprint.argtypes = [gnutls_openpgp_privkey_t, c_uint, c_void_p, POINTER(size_t)]
+gnutls_openpgp_privkey_get_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_key_id
+gnutls_openpgp_privkey_get_key_id.restype = c_int
+gnutls_openpgp_privkey_get_key_id.argtypes = [gnutls_openpgp_privkey_t, POINTER(c_ubyte)]
+gnutls_openpgp_privkey_get_subkey_count = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_count
+gnutls_openpgp_privkey_get_subkey_count.restype = c_int
+gnutls_openpgp_privkey_get_subkey_count.argtypes = [gnutls_openpgp_privkey_t]
+gnutls_openpgp_privkey_get_subkey_idx = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_idx
+gnutls_openpgp_privkey_get_subkey_idx.restype = c_int
+gnutls_openpgp_privkey_get_subkey_idx.argtypes = [gnutls_openpgp_privkey_t, POINTER(c_ubyte)]
+gnutls_openpgp_privkey_get_subkey_revoked_status = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_revoked_status
+gnutls_openpgp_privkey_get_subkey_revoked_status.restype = c_int
+gnutls_openpgp_privkey_get_subkey_revoked_status.argtypes = [gnutls_openpgp_privkey_t, c_uint]
+gnutls_openpgp_privkey_get_revoked_status = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_revoked_status
+gnutls_openpgp_privkey_get_revoked_status.restype = c_int
+gnutls_openpgp_privkey_get_revoked_status.argtypes = [gnutls_openpgp_privkey_t]
+gnutls_openpgp_privkey_get_subkey_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_pk_algorithm
+gnutls_openpgp_privkey_get_subkey_pk_algorithm.restype = gnutls_pk_algorithm_t
+gnutls_openpgp_privkey_get_subkey_pk_algorithm.argtypes = [gnutls_openpgp_privkey_t, c_uint, POINTER(c_uint)]
+gnutls_openpgp_privkey_get_subkey_expiration_time = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_expiration_time
+gnutls_openpgp_privkey_get_subkey_expiration_time.restype = time_t
+gnutls_openpgp_privkey_get_subkey_expiration_time.argtypes = [gnutls_openpgp_privkey_t, c_uint]
+gnutls_openpgp_privkey_get_subkey_id = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_id
+gnutls_openpgp_privkey_get_subkey_id.restype = c_int
+gnutls_openpgp_privkey_get_subkey_id.argtypes = [gnutls_openpgp_privkey_t, c_uint, POINTER(c_ubyte)]
+gnutls_openpgp_privkey_get_subkey_creation_time = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_creation_time
+gnutls_openpgp_privkey_get_subkey_creation_time.restype = time_t
+gnutls_openpgp_privkey_get_subkey_creation_time.argtypes = [gnutls_openpgp_privkey_t, c_uint]
+gnutls_openpgp_privkey_export_subkey_dsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_export_subkey_dsa_raw
+gnutls_openpgp_privkey_export_subkey_dsa_raw.restype = c_int
+gnutls_openpgp_privkey_export_subkey_dsa_raw.argtypes = [gnutls_openpgp_privkey_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_privkey_export_subkey_rsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_export_subkey_rsa_raw
+gnutls_openpgp_privkey_export_subkey_rsa_raw.restype = c_int
+gnutls_openpgp_privkey_export_subkey_rsa_raw.argtypes = [gnutls_openpgp_privkey_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_privkey_export_dsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_export_dsa_raw
+gnutls_openpgp_privkey_export_dsa_raw.restype = c_int
+gnutls_openpgp_privkey_export_dsa_raw.argtypes = [gnutls_openpgp_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_privkey_export_rsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_export_rsa_raw
+gnutls_openpgp_privkey_export_rsa_raw.restype = c_int
+gnutls_openpgp_privkey_export_rsa_raw.argtypes = [gnutls_openpgp_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_privkey_export = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_export
+gnutls_openpgp_privkey_export.restype = c_int
+gnutls_openpgp_privkey_export.argtypes = [gnutls_openpgp_privkey_t, gnutls_openpgp_crt_fmt_t, STRING, c_uint, c_void_p, POINTER(size_t)]
+gnutls_openpgp_privkey_set_preferred_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_set_preferred_key_id
+gnutls_openpgp_privkey_set_preferred_key_id.restype = c_int
+gnutls_openpgp_privkey_set_preferred_key_id.argtypes = [gnutls_openpgp_privkey_t, POINTER(c_ubyte)]
+gnutls_openpgp_privkey_get_preferred_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_preferred_key_id
+gnutls_openpgp_privkey_get_preferred_key_id.restype = c_int
+gnutls_openpgp_privkey_get_preferred_key_id.argtypes = [gnutls_openpgp_privkey_t, POINTER(c_ubyte)]
+gnutls_openpgp_crt_get_auth_subkey = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_auth_subkey
+gnutls_openpgp_crt_get_auth_subkey.restype = c_int
+gnutls_openpgp_crt_get_auth_subkey.argtypes = [gnutls_openpgp_crt_t, POINTER(c_ubyte), c_uint]
+gnutls_openpgp_keyring_init = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_init
+gnutls_openpgp_keyring_init.restype = c_int
+gnutls_openpgp_keyring_init.argtypes = [POINTER(gnutls_openpgp_keyring_t)]
+gnutls_openpgp_keyring_deinit = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_deinit
+gnutls_openpgp_keyring_deinit.restype = None
+gnutls_openpgp_keyring_deinit.argtypes = [gnutls_openpgp_keyring_t]
+gnutls_openpgp_keyring_import = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_import
+gnutls_openpgp_keyring_import.restype = c_int
+gnutls_openpgp_keyring_import.argtypes = [gnutls_openpgp_keyring_t, POINTER(gnutls_datum_t), gnutls_openpgp_crt_fmt_t]
+gnutls_openpgp_keyring_check_id = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_check_id
+gnutls_openpgp_keyring_check_id.restype = c_int
+gnutls_openpgp_keyring_check_id.argtypes = [gnutls_openpgp_keyring_t, POINTER(c_ubyte), c_uint]
+gnutls_openpgp_crt_verify_ring = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_verify_ring
+gnutls_openpgp_crt_verify_ring.restype = c_int
+gnutls_openpgp_crt_verify_ring.argtypes = [gnutls_openpgp_crt_t, gnutls_openpgp_keyring_t, c_uint, POINTER(c_uint)]
+gnutls_openpgp_crt_verify_self = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_verify_self
+gnutls_openpgp_crt_verify_self.restype = c_int
+gnutls_openpgp_crt_verify_self.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(c_uint)]
+gnutls_openpgp_keyring_get_crt = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_get_crt
+gnutls_openpgp_keyring_get_crt.restype = c_int
+gnutls_openpgp_keyring_get_crt.argtypes = [gnutls_openpgp_keyring_t, c_uint, POINTER(gnutls_openpgp_crt_t)]
+gnutls_openpgp_keyring_get_crt_count = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_get_crt_count
+gnutls_openpgp_keyring_get_crt_count.restype = c_int
+gnutls_openpgp_keyring_get_crt_count.argtypes = [gnutls_openpgp_keyring_t]
+gnutls_openpgp_set_recv_key_function = _libraries['libgnutls.so.26'].gnutls_openpgp_set_recv_key_function
+gnutls_openpgp_set_recv_key_function.restype = None
+gnutls_openpgp_set_recv_key_function.argtypes = [gnutls_session_t, gnutls_openpgp_recv_key_func]
+gnutls_certificate_set_openpgp_key = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_key
+gnutls_certificate_set_openpgp_key.restype = c_int
+gnutls_certificate_set_openpgp_key.argtypes = [gnutls_certificate_credentials_t, gnutls_openpgp_crt_t, gnutls_openpgp_privkey_t]
+gnutls_certificate_set_openpgp_key_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_key_file
+gnutls_certificate_set_openpgp_key_file.restype = c_int
+gnutls_certificate_set_openpgp_key_file.argtypes = [gnutls_certificate_credentials_t, STRING, STRING, gnutls_openpgp_crt_fmt_t]
+gnutls_certificate_set_openpgp_key_mem = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_key_mem
+gnutls_certificate_set_openpgp_key_mem.restype = c_int
+gnutls_certificate_set_openpgp_key_mem.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), gnutls_openpgp_crt_fmt_t]
+gnutls_certificate_set_openpgp_key_file2 = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_key_file2
+gnutls_certificate_set_openpgp_key_file2.restype = c_int
+gnutls_certificate_set_openpgp_key_file2.argtypes = [gnutls_certificate_credentials_t, STRING, STRING, STRING, gnutls_openpgp_crt_fmt_t]
+gnutls_certificate_set_openpgp_key_mem2 = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_key_mem2
+gnutls_certificate_set_openpgp_key_mem2.restype = c_int
+gnutls_certificate_set_openpgp_key_mem2.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), STRING, gnutls_openpgp_crt_fmt_t]
+gnutls_certificate_set_openpgp_keyring_mem = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_keyring_mem
+gnutls_certificate_set_openpgp_keyring_mem.restype = c_int
+gnutls_certificate_set_openpgp_keyring_mem.argtypes = [gnutls_certificate_credentials_t, POINTER(c_ubyte), size_t, gnutls_openpgp_crt_fmt_t]
+gnutls_certificate_set_openpgp_keyring_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_keyring_file
+gnutls_certificate_set_openpgp_keyring_file.restype = c_int
+gnutls_certificate_set_openpgp_keyring_file.argtypes = [gnutls_certificate_credentials_t, STRING, gnutls_openpgp_crt_fmt_t]
+gnutls_x509_crt_init = _libraries['libgnutls.so.26'].gnutls_x509_crt_init
+gnutls_x509_crt_init.restype = c_int
+gnutls_x509_crt_init.argtypes = [POINTER(gnutls_x509_crt_t)]
+gnutls_x509_crt_deinit = _libraries['libgnutls.so.26'].gnutls_x509_crt_deinit
+gnutls_x509_crt_deinit.restype = None
+gnutls_x509_crt_deinit.argtypes = [gnutls_x509_crt_t]
+gnutls_x509_crt_import = _libraries['libgnutls.so.26'].gnutls_x509_crt_import
+gnutls_x509_crt_import.restype = c_int
+gnutls_x509_crt_import.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_x509_crt_list_import = _libraries['libgnutls.so.26'].gnutls_x509_crt_list_import
+gnutls_x509_crt_list_import.restype = c_int
+gnutls_x509_crt_list_import.argtypes = [POINTER(gnutls_x509_crt_t), POINTER(c_uint), POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t, c_uint]
+gnutls_x509_crt_export = _libraries['libgnutls.so.26'].gnutls_x509_crt_export
+gnutls_x509_crt_export.restype = c_int
+gnutls_x509_crt_export.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_issuer_dn = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_issuer_dn
+gnutls_x509_crt_get_issuer_dn.restype = c_int
+gnutls_x509_crt_get_issuer_dn.argtypes = [gnutls_x509_crt_t, STRING, POINTER(size_t)]
+gnutls_x509_crt_get_issuer_dn_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_issuer_dn_oid
+gnutls_x509_crt_get_issuer_dn_oid.restype = c_int
+gnutls_x509_crt_get_issuer_dn_oid.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_issuer_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_issuer_dn_by_oid
+gnutls_x509_crt_get_issuer_dn_by_oid.restype = c_int
+gnutls_x509_crt_get_issuer_dn_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_int, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_dn = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_dn
+gnutls_x509_crt_get_dn.restype = c_int
+gnutls_x509_crt_get_dn.argtypes = [gnutls_x509_crt_t, STRING, POINTER(size_t)]
+gnutls_x509_crt_get_dn_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_dn_oid
+gnutls_x509_crt_get_dn_oid.restype = c_int
+gnutls_x509_crt_get_dn_oid.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_dn_by_oid
+gnutls_x509_crt_get_dn_by_oid.restype = c_int
+gnutls_x509_crt_get_dn_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_int, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_check_hostname = _libraries['libgnutls.so.26'].gnutls_x509_crt_check_hostname
+gnutls_x509_crt_check_hostname.restype = c_int
+gnutls_x509_crt_check_hostname.argtypes = [gnutls_x509_crt_t, STRING]
+gnutls_x509_crt_get_signature_algorithm = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_signature_algorithm
+gnutls_x509_crt_get_signature_algorithm.restype = c_int
+gnutls_x509_crt_get_signature_algorithm.argtypes = [gnutls_x509_crt_t]
+gnutls_x509_crt_get_signature = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_signature
+gnutls_x509_crt_get_signature.restype = c_int
+gnutls_x509_crt_get_signature.argtypes = [gnutls_x509_crt_t, STRING, POINTER(size_t)]
+gnutls_x509_crt_get_version = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_version
+gnutls_x509_crt_get_version.restype = c_int
+gnutls_x509_crt_get_version.argtypes = [gnutls_x509_crt_t]
+gnutls_x509_crt_get_key_id = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_key_id
+gnutls_x509_crt_get_key_id.restype = c_int
+gnutls_x509_crt_get_key_id.argtypes = [gnutls_x509_crt_t, c_uint, POINTER(c_ubyte), POINTER(size_t)]
+gnutls_x509_crt_set_authority_key_id = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_authority_key_id
+gnutls_x509_crt_set_authority_key_id.restype = c_int
+gnutls_x509_crt_set_authority_key_id.argtypes = [gnutls_x509_crt_t, c_void_p, size_t]
+gnutls_x509_crt_get_authority_key_id = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_authority_key_id
+gnutls_x509_crt_get_authority_key_id.restype = c_int
+gnutls_x509_crt_get_authority_key_id.argtypes = [gnutls_x509_crt_t, c_void_p, POINTER(size_t), POINTER(c_uint)]
+gnutls_x509_crt_get_subject_key_id = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_subject_key_id
+gnutls_x509_crt_get_subject_key_id.restype = c_int
+gnutls_x509_crt_get_subject_key_id.argtypes = [gnutls_x509_crt_t, c_void_p, POINTER(size_t), POINTER(c_uint)]
+gnutls_x509_crt_get_crl_dist_points = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_crl_dist_points
+gnutls_x509_crt_get_crl_dist_points.restype = c_int
+gnutls_x509_crt_get_crl_dist_points.argtypes = [gnutls_x509_crt_t, c_uint, c_void_p, POINTER(size_t), POINTER(c_uint), POINTER(c_uint)]
+gnutls_x509_crt_set_crl_dist_points = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_crl_dist_points
+gnutls_x509_crt_set_crl_dist_points.restype = c_int
+gnutls_x509_crt_set_crl_dist_points.argtypes = [gnutls_x509_crt_t, gnutls_x509_subject_alt_name_t, c_void_p, c_uint]
+gnutls_x509_crt_cpy_crl_dist_points = _libraries['libgnutls.so.26'].gnutls_x509_crt_cpy_crl_dist_points
+gnutls_x509_crt_cpy_crl_dist_points.restype = c_int
+gnutls_x509_crt_cpy_crl_dist_points.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_t]
+gnutls_x509_crt_get_activation_time = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_activation_time
+gnutls_x509_crt_get_activation_time.restype = time_t
+gnutls_x509_crt_get_activation_time.argtypes = [gnutls_x509_crt_t]
+gnutls_x509_crt_get_expiration_time = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_expiration_time
+gnutls_x509_crt_get_expiration_time.restype = time_t
+gnutls_x509_crt_get_expiration_time.argtypes = [gnutls_x509_crt_t]
+gnutls_x509_crt_get_serial = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_serial
+gnutls_x509_crt_get_serial.restype = c_int
+gnutls_x509_crt_get_serial.argtypes = [gnutls_x509_crt_t, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_pk_algorithm
+gnutls_x509_crt_get_pk_algorithm.restype = c_int
+gnutls_x509_crt_get_pk_algorithm.argtypes = [gnutls_x509_crt_t, POINTER(c_uint)]
+gnutls_x509_crt_get_pk_rsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_pk_rsa_raw
+gnutls_x509_crt_get_pk_rsa_raw.restype = c_int
+gnutls_x509_crt_get_pk_rsa_raw.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_crt_get_pk_dsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_pk_dsa_raw
+gnutls_x509_crt_get_pk_dsa_raw.restype = c_int
+gnutls_x509_crt_get_pk_dsa_raw.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_crt_get_subject_alt_name = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_subject_alt_name
+gnutls_x509_crt_get_subject_alt_name.restype = c_int
+gnutls_x509_crt_get_subject_alt_name.argtypes = [gnutls_x509_crt_t, c_uint, c_void_p, POINTER(size_t), POINTER(c_uint)]
+gnutls_x509_crt_get_subject_alt_name2 = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_subject_alt_name2
+gnutls_x509_crt_get_subject_alt_name2.restype = c_int
+gnutls_x509_crt_get_subject_alt_name2.argtypes = [gnutls_x509_crt_t, c_uint, c_void_p, POINTER(size_t), POINTER(c_uint), POINTER(c_uint)]
+gnutls_x509_crt_get_subject_alt_othername_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_subject_alt_othername_oid
+gnutls_x509_crt_get_subject_alt_othername_oid.restype = c_int
+gnutls_x509_crt_get_subject_alt_othername_oid.argtypes = [gnutls_x509_crt_t, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_ca_status = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_ca_status
+gnutls_x509_crt_get_ca_status.restype = c_int
+gnutls_x509_crt_get_ca_status.argtypes = [gnutls_x509_crt_t, POINTER(c_uint)]
+gnutls_x509_crt_get_basic_constraints = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_basic_constraints
+gnutls_x509_crt_get_basic_constraints.restype = c_int
+gnutls_x509_crt_get_basic_constraints.argtypes = [gnutls_x509_crt_t, POINTER(c_uint), POINTER(c_int), POINTER(c_int)]
+gnutls_x509_crt_get_key_usage = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_key_usage
+gnutls_x509_crt_get_key_usage.restype = c_int
+gnutls_x509_crt_get_key_usage.argtypes = [gnutls_x509_crt_t, POINTER(c_uint), POINTER(c_uint)]
+gnutls_x509_crt_set_key_usage = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_key_usage
+gnutls_x509_crt_set_key_usage.restype = c_int
+gnutls_x509_crt_set_key_usage.argtypes = [gnutls_x509_crt_t, c_uint]
+gnutls_x509_crt_get_proxy = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_proxy
+gnutls_x509_crt_get_proxy.restype = c_int
+gnutls_x509_crt_get_proxy.argtypes = [gnutls_x509_crt_t, POINTER(c_uint), POINTER(c_int), POINTER(STRING), POINTER(STRING), POINTER(size_t)]
+gnutls_x509_dn_oid_known = _libraries['libgnutls.so.26'].gnutls_x509_dn_oid_known
+gnutls_x509_dn_oid_known.restype = c_int
+gnutls_x509_dn_oid_known.argtypes = [STRING]
+gnutls_x509_crt_get_extension_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_extension_oid
+gnutls_x509_crt_get_extension_oid.restype = c_int
+gnutls_x509_crt_get_extension_oid.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_extension_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_extension_by_oid
+gnutls_x509_crt_get_extension_by_oid.restype = c_int
+gnutls_x509_crt_get_extension_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_int, c_void_p, POINTER(size_t), POINTER(c_uint)]
+gnutls_x509_crt_get_extension_info = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_extension_info
+gnutls_x509_crt_get_extension_info.restype = c_int
+gnutls_x509_crt_get_extension_info.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t), POINTER(c_int)]
+gnutls_x509_crt_get_extension_data = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_extension_data
+gnutls_x509_crt_get_extension_data.restype = c_int
+gnutls_x509_crt_get_extension_data.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_set_extension_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_extension_by_oid
+gnutls_x509_crt_set_extension_by_oid.restype = c_int
+gnutls_x509_crt_set_extension_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_void_p, size_t, c_uint]
+gnutls_x509_crt_set_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_dn_by_oid
+gnutls_x509_crt_set_dn_by_oid.restype = c_int
+gnutls_x509_crt_set_dn_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_uint, c_void_p, c_uint]
+gnutls_x509_crt_set_issuer_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_issuer_dn_by_oid
+gnutls_x509_crt_set_issuer_dn_by_oid.restype = c_int
+gnutls_x509_crt_set_issuer_dn_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_uint, c_void_p, c_uint]
+gnutls_x509_crt_set_version = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_version
+gnutls_x509_crt_set_version.restype = c_int
+gnutls_x509_crt_set_version.argtypes = [gnutls_x509_crt_t, c_uint]
+gnutls_x509_crt_set_key = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_key
+gnutls_x509_crt_set_key.restype = c_int
+gnutls_x509_crt_set_key.argtypes = [gnutls_x509_crt_t, gnutls_x509_privkey_t]
+gnutls_x509_crt_set_ca_status = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_ca_status
+gnutls_x509_crt_set_ca_status.restype = c_int
+gnutls_x509_crt_set_ca_status.argtypes = [gnutls_x509_crt_t, c_uint]
+gnutls_x509_crt_set_basic_constraints = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_basic_constraints
+gnutls_x509_crt_set_basic_constraints.restype = c_int
+gnutls_x509_crt_set_basic_constraints.argtypes = [gnutls_x509_crt_t, c_uint, c_int]
+gnutls_x509_crt_set_subject_alternative_name = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_subject_alternative_name
+gnutls_x509_crt_set_subject_alternative_name.restype = c_int
+gnutls_x509_crt_set_subject_alternative_name.argtypes = [gnutls_x509_crt_t, gnutls_x509_subject_alt_name_t, STRING]
+gnutls_x509_crt_sign = _libraries['libgnutls.so.26'].gnutls_x509_crt_sign
+gnutls_x509_crt_sign.restype = c_int
+gnutls_x509_crt_sign.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_t, gnutls_x509_privkey_t]
+gnutls_x509_crt_sign2 = _libraries['libgnutls.so.26'].gnutls_x509_crt_sign2
+gnutls_x509_crt_sign2.restype = c_int
+gnutls_x509_crt_sign2.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_t, gnutls_x509_privkey_t, gnutls_digest_algorithm_t, c_uint]
+gnutls_x509_crt_set_activation_time = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_activation_time
+gnutls_x509_crt_set_activation_time.restype = c_int
+gnutls_x509_crt_set_activation_time.argtypes = [gnutls_x509_crt_t, time_t]
+gnutls_x509_crt_set_expiration_time = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_expiration_time
+gnutls_x509_crt_set_expiration_time.restype = c_int
+gnutls_x509_crt_set_expiration_time.argtypes = [gnutls_x509_crt_t, time_t]
+gnutls_x509_crt_set_serial = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_serial
+gnutls_x509_crt_set_serial.restype = c_int
+gnutls_x509_crt_set_serial.argtypes = [gnutls_x509_crt_t, c_void_p, size_t]
+gnutls_x509_crt_set_subject_key_id = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_subject_key_id
+gnutls_x509_crt_set_subject_key_id.restype = c_int
+gnutls_x509_crt_set_subject_key_id.argtypes = [gnutls_x509_crt_t, c_void_p, size_t]
+gnutls_x509_crt_set_proxy_dn = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_proxy_dn
+gnutls_x509_crt_set_proxy_dn.restype = c_int
+gnutls_x509_crt_set_proxy_dn.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_t, c_uint, c_void_p, c_uint]
+gnutls_x509_crt_set_proxy = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_proxy
+gnutls_x509_crt_set_proxy.restype = c_int
+gnutls_x509_crt_set_proxy.argtypes = [gnutls_x509_crt_t, c_int, STRING, STRING, size_t]
+gnutls_x509_crt_print = _libraries['libgnutls.so.26'].gnutls_x509_crt_print
+gnutls_x509_crt_print.restype = c_int
+gnutls_x509_crt_print.argtypes = [gnutls_x509_crt_t, gnutls_certificate_print_formats_t, POINTER(gnutls_datum_t)]
+gnutls_x509_crl_print = _libraries['libgnutls.so.26'].gnutls_x509_crl_print
+gnutls_x509_crl_print.restype = c_int
+gnutls_x509_crl_print.argtypes = [gnutls_x509_crl_t, gnutls_certificate_print_formats_t, POINTER(gnutls_datum_t)]
+gnutls_x509_crt_get_raw_issuer_dn = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_raw_issuer_dn
+gnutls_x509_crt_get_raw_issuer_dn.restype = c_int
+gnutls_x509_crt_get_raw_issuer_dn.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_datum_t)]
+gnutls_x509_crt_get_raw_dn = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_raw_dn
+gnutls_x509_crt_get_raw_dn.restype = c_int
+gnutls_x509_crt_get_raw_dn.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_datum_t)]
+gnutls_x509_rdn_get = _libraries['libgnutls.so.26'].gnutls_x509_rdn_get
+gnutls_x509_rdn_get.restype = c_int
+gnutls_x509_rdn_get.argtypes = [POINTER(gnutls_datum_t), STRING, POINTER(size_t)]
+gnutls_x509_rdn_get_oid = _libraries['libgnutls.so.26'].gnutls_x509_rdn_get_oid
+gnutls_x509_rdn_get_oid.restype = c_int
+gnutls_x509_rdn_get_oid.argtypes = [POINTER(gnutls_datum_t), c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_rdn_get_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_rdn_get_by_oid
+gnutls_x509_rdn_get_by_oid.restype = c_int
+gnutls_x509_rdn_get_by_oid.argtypes = [POINTER(gnutls_datum_t), STRING, c_int, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_subject = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_subject
+gnutls_x509_crt_get_subject.restype = c_int
+gnutls_x509_crt_get_subject.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_x509_dn_t)]
+gnutls_x509_crt_get_issuer = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_issuer
+gnutls_x509_crt_get_issuer.restype = c_int
+gnutls_x509_crt_get_issuer.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_x509_dn_t)]
+gnutls_x509_dn_get_rdn_ava = _libraries['libgnutls.so.26'].gnutls_x509_dn_get_rdn_ava
+gnutls_x509_dn_get_rdn_ava.restype = c_int
+gnutls_x509_dn_get_rdn_ava.argtypes = [gnutls_x509_dn_t, c_int, c_int, POINTER(gnutls_x509_ava_st)]
+gnutls_x509_dn_init = _libraries['libgnutls.so.26'].gnutls_x509_dn_init
+gnutls_x509_dn_init.restype = c_int
+gnutls_x509_dn_init.argtypes = [POINTER(gnutls_x509_dn_t)]
+gnutls_x509_dn_import = _libraries['libgnutls.so.26'].gnutls_x509_dn_import
+gnutls_x509_dn_import.restype = c_int
+gnutls_x509_dn_import.argtypes = [gnutls_x509_dn_t, POINTER(gnutls_datum_t)]
+gnutls_x509_dn_export = _libraries['libgnutls.so.26'].gnutls_x509_dn_export
+gnutls_x509_dn_export.restype = c_int
+gnutls_x509_dn_export.argtypes = [gnutls_x509_dn_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_x509_dn_deinit = _libraries['libgnutls.so.26'].gnutls_x509_dn_deinit
+gnutls_x509_dn_deinit.restype = None
+gnutls_x509_dn_deinit.argtypes = [gnutls_x509_dn_t]
+gnutls_x509_crl_init = _libraries['libgnutls.so.26'].gnutls_x509_crl_init
+gnutls_x509_crl_init.restype = c_int
+gnutls_x509_crl_init.argtypes = [POINTER(gnutls_x509_crl_t)]
+gnutls_x509_crl_deinit = _libraries['libgnutls.so.26'].gnutls_x509_crl_deinit
+gnutls_x509_crl_deinit.restype = None
+gnutls_x509_crl_deinit.argtypes = [gnutls_x509_crl_t]
+gnutls_x509_crl_import = _libraries['libgnutls.so.26'].gnutls_x509_crl_import
+gnutls_x509_crl_import.restype = c_int
+gnutls_x509_crl_import.argtypes = [gnutls_x509_crl_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_x509_crl_export = _libraries['libgnutls.so.26'].gnutls_x509_crl_export
+gnutls_x509_crl_export.restype = c_int
+gnutls_x509_crl_export.argtypes = [gnutls_x509_crl_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_x509_crl_get_issuer_dn = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_issuer_dn
+gnutls_x509_crl_get_issuer_dn.restype = c_int
+gnutls_x509_crl_get_issuer_dn.argtypes = [gnutls_x509_crl_t, STRING, POINTER(size_t)]
+gnutls_x509_crl_get_issuer_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_issuer_dn_by_oid
+gnutls_x509_crl_get_issuer_dn_by_oid.restype = c_int
+gnutls_x509_crl_get_issuer_dn_by_oid.argtypes = [gnutls_x509_crl_t, STRING, c_int, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_crl_get_dn_oid = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_dn_oid
+gnutls_x509_crl_get_dn_oid.restype = c_int
+gnutls_x509_crl_get_dn_oid.argtypes = [gnutls_x509_crl_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crl_get_signature_algorithm = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_signature_algorithm
+gnutls_x509_crl_get_signature_algorithm.restype = c_int
+gnutls_x509_crl_get_signature_algorithm.argtypes = [gnutls_x509_crl_t]
+gnutls_x509_crl_get_signature = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_signature
+gnutls_x509_crl_get_signature.restype = c_int
+gnutls_x509_crl_get_signature.argtypes = [gnutls_x509_crl_t, STRING, POINTER(size_t)]
+gnutls_x509_crl_get_version = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_version
+gnutls_x509_crl_get_version.restype = c_int
+gnutls_x509_crl_get_version.argtypes = [gnutls_x509_crl_t]
+gnutls_x509_crl_get_this_update = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_this_update
+gnutls_x509_crl_get_this_update.restype = time_t
+gnutls_x509_crl_get_this_update.argtypes = [gnutls_x509_crl_t]
+gnutls_x509_crl_get_next_update = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_next_update
+gnutls_x509_crl_get_next_update.restype = time_t
+gnutls_x509_crl_get_next_update.argtypes = [gnutls_x509_crl_t]
+gnutls_x509_crl_get_crt_count = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_crt_count
+gnutls_x509_crl_get_crt_count.restype = c_int
+gnutls_x509_crl_get_crt_count.argtypes = [gnutls_x509_crl_t]
+gnutls_x509_crl_get_crt_serial = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_crt_serial
+gnutls_x509_crl_get_crt_serial.restype = c_int
+gnutls_x509_crl_get_crt_serial.argtypes = [gnutls_x509_crl_t, c_int, POINTER(c_ubyte), POINTER(size_t), POINTER(time_t)]
+gnutls_x509_crl_check_issuer = _libraries['libgnutls.so.26'].gnutls_x509_crl_check_issuer
+gnutls_x509_crl_check_issuer.restype = c_int
+gnutls_x509_crl_check_issuer.argtypes = [gnutls_x509_crl_t, gnutls_x509_crt_t]
+gnutls_x509_crl_set_version = _libraries['libgnutls.so.26'].gnutls_x509_crl_set_version
+gnutls_x509_crl_set_version.restype = c_int
+gnutls_x509_crl_set_version.argtypes = [gnutls_x509_crl_t, c_uint]
+gnutls_x509_crl_sign = _libraries['libgnutls.so.26'].gnutls_x509_crl_sign
+gnutls_x509_crl_sign.restype = c_int
+gnutls_x509_crl_sign.argtypes = [gnutls_x509_crl_t, gnutls_x509_crt_t, gnutls_x509_privkey_t]
+gnutls_x509_crl_sign2 = _libraries['libgnutls.so.26'].gnutls_x509_crl_sign2
+gnutls_x509_crl_sign2.restype = c_int
+gnutls_x509_crl_sign2.argtypes = [gnutls_x509_crl_t, gnutls_x509_crt_t, gnutls_x509_privkey_t, gnutls_digest_algorithm_t, c_uint]
+gnutls_x509_crl_set_this_update = _libraries['libgnutls.so.26'].gnutls_x509_crl_set_this_update
+gnutls_x509_crl_set_this_update.restype = c_int
+gnutls_x509_crl_set_this_update.argtypes = [gnutls_x509_crl_t, time_t]
+gnutls_x509_crl_set_next_update = _libraries['libgnutls.so.26'].gnutls_x509_crl_set_next_update
+gnutls_x509_crl_set_next_update.restype = c_int
+gnutls_x509_crl_set_next_update.argtypes = [gnutls_x509_crl_t, time_t]
+gnutls_x509_crl_set_crt_serial = _libraries['libgnutls.so.26'].gnutls_x509_crl_set_crt_serial
+gnutls_x509_crl_set_crt_serial.restype = c_int
+gnutls_x509_crl_set_crt_serial.argtypes = [gnutls_x509_crl_t, c_void_p, size_t, time_t]
+gnutls_x509_crl_set_crt = _libraries['libgnutls.so.26'].gnutls_x509_crl_set_crt
+gnutls_x509_crl_set_crt.restype = c_int
+gnutls_x509_crl_set_crt.argtypes = [gnutls_x509_crl_t, gnutls_x509_crt_t, time_t]
+gnutls_pkcs7_init = _libraries['libgnutls.so.26'].gnutls_pkcs7_init
+gnutls_pkcs7_init.restype = c_int
+gnutls_pkcs7_init.argtypes = [POINTER(gnutls_pkcs7_t)]
+gnutls_pkcs7_deinit = _libraries['libgnutls.so.26'].gnutls_pkcs7_deinit
+gnutls_pkcs7_deinit.restype = None
+gnutls_pkcs7_deinit.argtypes = [gnutls_pkcs7_t]
+gnutls_pkcs7_import = _libraries['libgnutls.so.26'].gnutls_pkcs7_import
+gnutls_pkcs7_import.restype = c_int
+gnutls_pkcs7_import.argtypes = [gnutls_pkcs7_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_pkcs7_export = _libraries['libgnutls.so.26'].gnutls_pkcs7_export
+gnutls_pkcs7_export.restype = c_int
+gnutls_pkcs7_export.argtypes = [gnutls_pkcs7_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_pkcs7_get_crt_count = _libraries['libgnutls.so.26'].gnutls_pkcs7_get_crt_count
+gnutls_pkcs7_get_crt_count.restype = c_int
+gnutls_pkcs7_get_crt_count.argtypes = [gnutls_pkcs7_t]
+gnutls_pkcs7_get_crt_raw = _libraries['libgnutls.so.26'].gnutls_pkcs7_get_crt_raw
+gnutls_pkcs7_get_crt_raw.restype = c_int
+gnutls_pkcs7_get_crt_raw.argtypes = [gnutls_pkcs7_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_pkcs7_set_crt_raw = _libraries['libgnutls.so.26'].gnutls_pkcs7_set_crt_raw
+gnutls_pkcs7_set_crt_raw.restype = c_int
+gnutls_pkcs7_set_crt_raw.argtypes = [gnutls_pkcs7_t, POINTER(gnutls_datum_t)]
+gnutls_pkcs7_set_crt = _libraries['libgnutls.so.26'].gnutls_pkcs7_set_crt
+gnutls_pkcs7_set_crt.restype = c_int
+gnutls_pkcs7_set_crt.argtypes = [gnutls_pkcs7_t, gnutls_x509_crt_t]
+gnutls_pkcs7_delete_crt = _libraries['libgnutls.so.26'].gnutls_pkcs7_delete_crt
+gnutls_pkcs7_delete_crt.restype = c_int
+gnutls_pkcs7_delete_crt.argtypes = [gnutls_pkcs7_t, c_int]
+gnutls_pkcs7_get_crl_raw = _libraries['libgnutls.so.26'].gnutls_pkcs7_get_crl_raw
+gnutls_pkcs7_get_crl_raw.restype = c_int
+gnutls_pkcs7_get_crl_raw.argtypes = [gnutls_pkcs7_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_pkcs7_get_crl_count = _libraries['libgnutls.so.26'].gnutls_pkcs7_get_crl_count
+gnutls_pkcs7_get_crl_count.restype = c_int
+gnutls_pkcs7_get_crl_count.argtypes = [gnutls_pkcs7_t]
+gnutls_pkcs7_set_crl_raw = _libraries['libgnutls.so.26'].gnutls_pkcs7_set_crl_raw
+gnutls_pkcs7_set_crl_raw.restype = c_int
+gnutls_pkcs7_set_crl_raw.argtypes = [gnutls_pkcs7_t, POINTER(gnutls_datum_t)]
+gnutls_pkcs7_set_crl = _libraries['libgnutls.so.26'].gnutls_pkcs7_set_crl
+gnutls_pkcs7_set_crl.restype = c_int
+gnutls_pkcs7_set_crl.argtypes = [gnutls_pkcs7_t, gnutls_x509_crl_t]
+gnutls_pkcs7_delete_crl = _libraries['libgnutls.so.26'].gnutls_pkcs7_delete_crl
+gnutls_pkcs7_delete_crl.restype = c_int
+gnutls_pkcs7_delete_crl.argtypes = [gnutls_pkcs7_t, c_int]
+gnutls_x509_crt_check_issuer = _libraries['libgnutls.so.26'].gnutls_x509_crt_check_issuer
+gnutls_x509_crt_check_issuer.restype = c_int
+gnutls_x509_crt_check_issuer.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_t]
+gnutls_x509_crt_list_verify = _libraries['libgnutls.so.26'].gnutls_x509_crt_list_verify
+gnutls_x509_crt_list_verify.restype = c_int
+gnutls_x509_crt_list_verify.argtypes = [POINTER(gnutls_x509_crt_t), c_int, POINTER(gnutls_x509_crt_t), c_int, POINTER(gnutls_x509_crl_t), c_int, c_uint, POINTER(c_uint)]
+gnutls_x509_crt_verify = _libraries['libgnutls.so.26'].gnutls_x509_crt_verify
+gnutls_x509_crt_verify.restype = c_int
+gnutls_x509_crt_verify.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_x509_crt_t), c_int, c_uint, POINTER(c_uint)]
+gnutls_x509_crl_verify = _libraries['libgnutls.so.26'].gnutls_x509_crl_verify
+gnutls_x509_crl_verify.restype = c_int
+gnutls_x509_crl_verify.argtypes = [gnutls_x509_crl_t, POINTER(gnutls_x509_crt_t), c_int, c_uint, POINTER(c_uint)]
+gnutls_x509_crt_check_revocation = _libraries['libgnutls.so.26'].gnutls_x509_crt_check_revocation
+gnutls_x509_crt_check_revocation.restype = c_int
+gnutls_x509_crt_check_revocation.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_x509_crl_t), c_int]
+gnutls_x509_crt_get_fingerprint = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_fingerprint
+gnutls_x509_crt_get_fingerprint.restype = c_int
+gnutls_x509_crt_get_fingerprint.argtypes = [gnutls_x509_crt_t, gnutls_digest_algorithm_t, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_key_purpose_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_key_purpose_oid
+gnutls_x509_crt_get_key_purpose_oid.restype = c_int
+gnutls_x509_crt_get_key_purpose_oid.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t), POINTER(c_uint)]
+gnutls_x509_crt_set_key_purpose_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_key_purpose_oid
+gnutls_x509_crt_set_key_purpose_oid.restype = c_int
+gnutls_x509_crt_set_key_purpose_oid.argtypes = [gnutls_x509_crt_t, c_void_p, c_uint]
+gnutls_x509_privkey_init = _libraries['libgnutls.so.26'].gnutls_x509_privkey_init
+gnutls_x509_privkey_init.restype = c_int
+gnutls_x509_privkey_init.argtypes = [POINTER(gnutls_x509_privkey_t)]
+gnutls_x509_privkey_deinit = _libraries['libgnutls.so.26'].gnutls_x509_privkey_deinit
+gnutls_x509_privkey_deinit.restype = None
+gnutls_x509_privkey_deinit.argtypes = [gnutls_x509_privkey_t]
+gnutls_x509_privkey_cpy = _libraries['libgnutls.so.26'].gnutls_x509_privkey_cpy
+gnutls_x509_privkey_cpy.restype = c_int
+gnutls_x509_privkey_cpy.argtypes = [gnutls_x509_privkey_t, gnutls_x509_privkey_t]
+gnutls_x509_privkey_import = _libraries['libgnutls.so.26'].gnutls_x509_privkey_import
+gnutls_x509_privkey_import.restype = c_int
+gnutls_x509_privkey_import.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_x509_privkey_import_pkcs8 = _libraries['libgnutls.so.26'].gnutls_x509_privkey_import_pkcs8
+gnutls_x509_privkey_import_pkcs8.restype = c_int
+gnutls_x509_privkey_import_pkcs8.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t, STRING, c_uint]
+gnutls_x509_privkey_import_rsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_privkey_import_rsa_raw
+gnutls_x509_privkey_import_rsa_raw.restype = c_int
+gnutls_x509_privkey_import_rsa_raw.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_privkey_fix = _libraries['libgnutls.so.26'].gnutls_x509_privkey_fix
+gnutls_x509_privkey_fix.restype = c_int
+gnutls_x509_privkey_fix.argtypes = [gnutls_x509_privkey_t]
+gnutls_x509_privkey_export_dsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_privkey_export_dsa_raw
+gnutls_x509_privkey_export_dsa_raw.restype = c_int
+gnutls_x509_privkey_export_dsa_raw.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_privkey_import_dsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_privkey_import_dsa_raw
+gnutls_x509_privkey_import_dsa_raw.restype = c_int
+gnutls_x509_privkey_import_dsa_raw.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_privkey_get_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_x509_privkey_get_pk_algorithm
+gnutls_x509_privkey_get_pk_algorithm.restype = c_int
+gnutls_x509_privkey_get_pk_algorithm.argtypes = [gnutls_x509_privkey_t]
+gnutls_x509_privkey_get_key_id = _libraries['libgnutls.so.26'].gnutls_x509_privkey_get_key_id
+gnutls_x509_privkey_get_key_id.restype = c_int
+gnutls_x509_privkey_get_key_id.argtypes = [gnutls_x509_privkey_t, c_uint, POINTER(c_ubyte), POINTER(size_t)]
+gnutls_x509_privkey_generate = _libraries['libgnutls.so.26'].gnutls_x509_privkey_generate
+gnutls_x509_privkey_generate.restype = c_int
+gnutls_x509_privkey_generate.argtypes = [gnutls_x509_privkey_t, gnutls_pk_algorithm_t, c_uint, c_uint]
+gnutls_x509_privkey_export = _libraries['libgnutls.so.26'].gnutls_x509_privkey_export
+gnutls_x509_privkey_export.restype = c_int
+gnutls_x509_privkey_export.argtypes = [gnutls_x509_privkey_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_x509_privkey_export_pkcs8 = _libraries['libgnutls.so.26'].gnutls_x509_privkey_export_pkcs8
+gnutls_x509_privkey_export_pkcs8.restype = c_int
+gnutls_x509_privkey_export_pkcs8.argtypes = [gnutls_x509_privkey_t, gnutls_x509_crt_fmt_t, STRING, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_privkey_export_rsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_privkey_export_rsa_raw
+gnutls_x509_privkey_export_rsa_raw.restype = c_int
+gnutls_x509_privkey_export_rsa_raw.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_privkey_sign_data = _libraries['libgnutls.so.26'].gnutls_x509_privkey_sign_data
+gnutls_x509_privkey_sign_data.restype = c_int
+gnutls_x509_privkey_sign_data.argtypes = [gnutls_x509_privkey_t, gnutls_digest_algorithm_t, c_uint, POINTER(gnutls_datum_t), c_void_p, POINTER(size_t)]
+gnutls_x509_privkey_verify_data = _libraries['libgnutls.so.26'].gnutls_x509_privkey_verify_data
+gnutls_x509_privkey_verify_data.restype = c_int
+gnutls_x509_privkey_verify_data.argtypes = [gnutls_x509_privkey_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_crt_verify_data = _libraries['libgnutls.so.26'].gnutls_x509_crt_verify_data
+gnutls_x509_crt_verify_data.restype = c_int
+gnutls_x509_crt_verify_data.argtypes = [gnutls_x509_crt_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_privkey_sign_hash = _libraries['libgnutls.so.26'].gnutls_x509_privkey_sign_hash
+gnutls_x509_privkey_sign_hash.restype = c_int
+gnutls_x509_privkey_sign_hash.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_crq_init = _libraries['libgnutls.so.26'].gnutls_x509_crq_init
+gnutls_x509_crq_init.restype = c_int
+gnutls_x509_crq_init.argtypes = [POINTER(gnutls_x509_crq_t)]
+gnutls_x509_crq_deinit = _libraries['libgnutls.so.26'].gnutls_x509_crq_deinit
+gnutls_x509_crq_deinit.restype = None
+gnutls_x509_crq_deinit.argtypes = [gnutls_x509_crq_t]
+gnutls_x509_crq_import = _libraries['libgnutls.so.26'].gnutls_x509_crq_import
+gnutls_x509_crq_import.restype = c_int
+gnutls_x509_crq_import.argtypes = [gnutls_x509_crq_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_x509_crq_get_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_pk_algorithm
+gnutls_x509_crq_get_pk_algorithm.restype = c_int
+gnutls_x509_crq_get_pk_algorithm.argtypes = [gnutls_x509_crq_t, POINTER(c_uint)]
+gnutls_x509_crq_get_dn = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_dn
+gnutls_x509_crq_get_dn.restype = c_int
+gnutls_x509_crq_get_dn.argtypes = [gnutls_x509_crq_t, STRING, POINTER(size_t)]
+gnutls_x509_crq_get_dn_oid = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_dn_oid
+gnutls_x509_crq_get_dn_oid.restype = c_int
+gnutls_x509_crq_get_dn_oid.argtypes = [gnutls_x509_crq_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crq_get_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_dn_by_oid
+gnutls_x509_crq_get_dn_by_oid.restype = c_int
+gnutls_x509_crq_get_dn_by_oid.argtypes = [gnutls_x509_crq_t, STRING, c_int, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_crq_set_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crq_set_dn_by_oid
+gnutls_x509_crq_set_dn_by_oid.restype = c_int
+gnutls_x509_crq_set_dn_by_oid.argtypes = [gnutls_x509_crq_t, STRING, c_uint, c_void_p, c_uint]
+gnutls_x509_crq_set_version = _libraries['libgnutls.so.26'].gnutls_x509_crq_set_version
+gnutls_x509_crq_set_version.restype = c_int
+gnutls_x509_crq_set_version.argtypes = [gnutls_x509_crq_t, c_uint]
+gnutls_x509_crq_set_key = _libraries['libgnutls.so.26'].gnutls_x509_crq_set_key
+gnutls_x509_crq_set_key.restype = c_int
+gnutls_x509_crq_set_key.argtypes = [gnutls_x509_crq_t, gnutls_x509_privkey_t]
+gnutls_x509_crq_sign2 = _libraries['libgnutls.so.26'].gnutls_x509_crq_sign2
+gnutls_x509_crq_sign2.restype = c_int
+gnutls_x509_crq_sign2.argtypes = [gnutls_x509_crq_t, gnutls_x509_privkey_t, gnutls_digest_algorithm_t, c_uint]
+gnutls_x509_crq_sign = _libraries['libgnutls.so.26'].gnutls_x509_crq_sign
+gnutls_x509_crq_sign.restype = c_int
+gnutls_x509_crq_sign.argtypes = [gnutls_x509_crq_t, gnutls_x509_privkey_t]
+gnutls_x509_crq_set_challenge_password = _libraries['libgnutls.so.26'].gnutls_x509_crq_set_challenge_password
+gnutls_x509_crq_set_challenge_password.restype = c_int
+gnutls_x509_crq_set_challenge_password.argtypes = [gnutls_x509_crq_t, STRING]
+gnutls_x509_crq_get_challenge_password = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_challenge_password
+gnutls_x509_crq_get_challenge_password.restype = c_int
+gnutls_x509_crq_get_challenge_password.argtypes = [gnutls_x509_crq_t, STRING, POINTER(size_t)]
+gnutls_x509_crq_set_attribute_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crq_set_attribute_by_oid
+gnutls_x509_crq_set_attribute_by_oid.restype = c_int
+gnutls_x509_crq_set_attribute_by_oid.argtypes = [gnutls_x509_crq_t, STRING, c_void_p, size_t]
+gnutls_x509_crq_get_attribute_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_attribute_by_oid
+gnutls_x509_crq_get_attribute_by_oid.restype = c_int
+gnutls_x509_crq_get_attribute_by_oid.argtypes = [gnutls_x509_crq_t, STRING, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crq_export = _libraries['libgnutls.so.26'].gnutls_x509_crq_export
+gnutls_x509_crq_export.restype = c_int
+gnutls_x509_crq_export.argtypes = [gnutls_x509_crq_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_set_crq = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_crq
+gnutls_x509_crt_set_crq.restype = c_int
+gnutls_x509_crt_set_crq.argtypes = [gnutls_x509_crt_t, gnutls_x509_crq_t]
+__all__ = ['gnutls_ia_set_server_avp_ptr',
+           'gnutls_openpgp_privkey_init',
+           'gnutls_certificate_activation_time_peers',
+           'gnutls_x509_crt_set_proxy_dn',
+           'gnutls_db_set_remove_function',
+           'gnutls_x509_crt_set_dn_by_oid',
+           'gnutls_x509_crt_check_hostname',
+           'gnutls_openpgp_keyring_get_crt',
+           'gnutls_global_init_extra',
+           'gnutls_srp_set_client_credentials_function',
+           'gnutls_x509_crl_import',
+           'gnutls_certificate_set_x509_trust_file',
+           'gnutls_x509_crt_get_pk_rsa_raw',
+           'gnutls_x509_privkey_export_rsa_raw',
+           'gnutls_priority_set', 'gnutls_cipher_get',
+           'gnutls_certificate_set_openpgp_keyring_mem',
+           'gnutls_x509_crt_get_ca_status',
+           'gnutls_cipher_get_key_size',
+           'gnutls_certificate_set_x509_crl_file',
+           'gnutls_x509_privkey_import_dsa_raw',
+           'gnutls_x509_crq_init', 'gnutls_session_get_master_secret',
+           'gnutls_x509_crq_get_challenge_password', '__time_t',
+           'gnutls_x509_crt_get_pk_algorithm',
+           'gnutls_x509_crt_set_crq',
+           'gnutls_certificate_set_openpgp_key_mem2',
+           'gnutls_certificate_free_keys', 'gnutls_srp_verifier',
+           'gnutls_x509_crl_deinit',
+           'gnutls_openpgp_crt_get_pk_dsa_raw',
+           'gnutls_certificate_free_ca_names', 'gnutls_cipher_list',
+           'gnutls_x509_crq_export',
+           'gnutls_certificate_client_set_retrieve_function',
+           'gnutls_x509_crl_get_crt_serial',
+           'gnutls_pkcs7_get_crt_count',
+           'gnutls_certificate_set_x509_trust',
+           'gnutls_openpgp_crt_get_subkey_fingerprint',
+           'gnutls_ia_handshake_p',
+           'gnutls_openpgp_privkey_get_subkey_fingerprint',
+           'gnutls_openpgp_keyring_import', 'gnutls_pkcs7_set_crl',
+           'gnutls_x509_crq_get_pk_algorithm',
+           'gnutls_pkcs7_set_crl_raw',
+           'gnutls_certificate_set_verify_limits',
+           'gnutls_x509_crt_get_authority_key_id',
+           'gnutls_x509_crt_set_activation_time', 'gnutls_db_set_ptr',
+           'gnutls_openpgp_crt_get_version',
+           'gnutls_x509_crt_get_subject_key_id',
+           'gnutls_credentials_clear', 'gnutls_x509_crt_get_key_id',
+           'gnutls_x509_crt_init', 'gnutls_dh_params_generate2',
+           'gnutls_pkcs7_delete_crt',
+           'gnutls_x509_crt_get_subject_alt_name2',
+           'gnutls_alert_get_name',
+           'gnutls_x509_crt_set_authority_key_id',
+           'gnutls_openpgp_crt_get_subkey_pk_rsa_raw',
+           'gnutls_x509_crt_list_verify', 'gnutls_priority_init',
+           'gnutls_openpgp_crt_get_expiration_time',
+           'gnutls_x509_crl_set_version',
+           'gnutls_certificate_set_openpgp_keyring_file',
+           'gnutls_pem_base64_encode',
+           'gnutls_handshake_set_max_packet_length',
+           'gnutls_openpgp_privkey_get_subkey_expiration_time',
+           'gnutls_x509_crq_set_dn_by_oid', 'gnutls_session_get_id',
+           'gnutls_cipher_set_priority',
+           'gnutls_openpgp_keyring_check_id',
+           'gnutls_openpgp_keyring_deinit',
+           'gnutls_srp_base64_encode_alloc',
+           'gnutls_db_set_store_function',
+           'gnutls_supplemental_get_name',
+           'gnutls_handshake_get_last_out',
+           'gnutls_x509_privkey_export_pkcs8',
+           'gnutls_x509_privkey_deinit', 'gnutls_compression_get_id',
+           'gnutls_openpgp_crt_get_subkey_idx',
+           'gnutls_x509_privkey_import_rsa_raw',
+           'gnutls_transport_set_errno',
+           'gnutls_openpgp_privkey_get_subkey_revoked_status',
+           'gnutls_x509_crt_get_issuer_dn',
+           'gnutls_ia_get_server_avp_ptr',
+           'gnutls_openpgp_keyring_get_crt_count', 'gnutls_ia_recv',
+           'gnutls_x509_crt_get_pk_dsa_raw', 'gnutls_x509_crt_sign',
+           'gnutls_certificate_verify_peers',
+           'gnutls_srp_free_server_credentials',
+           'gnutls_x509_crt_print',
+           'gnutls_openpgp_privkey_export_subkey_dsa_raw',
+           'gnutls_server_name_set', 'gnutls_kx_set_priority',
+           'gnutls_transport_set_push_function',
+           'gnutls_x509_crt_sign2',
+           'gnutls_x509_crt_cpy_crl_dist_points',
+           'gnutls_pem_base64_decode', 'gnutls_srp_base64_decode',
+           'gnutls_openpgp_privkey_get_subkey_count',
+           'gnutls_global_init', 'gnutls_x509_rdn_get_by_oid',
+           'gnutls_dh_params_import_raw',
+           'gnutls_global_set_mem_functions',
+           'gnutls_x509_crt_set_key_usage', 'time_t',
+           'gnutls_anon_set_server_params_function',
+           'gnutls_mac_get_key_size',
+           'gnutls_rsa_params_export_pkcs1',
+           'gnutls_certificate_type_set_priority',
+           'gnutls_x509_crt_get_issuer_dn_oid',
+           'gnutls_dh_params_init',
+           'gnutls_x509_crq_set_attribute_by_oid',
+           'gnutls_certificate_expiration_time_peers',
+           'gnutls_ia_endphase_send',
+           'gnutls_psk_allocate_server_credentials',
+           'gnutls_certificate_set_dh_params', 'gnutls_init',
+           'gnutls_openpgp_privkey_get_subkey_pk_algorithm',
+           'gnutls_x509_rdn_get_oid', 'gnutls_x509_crl_get_crt_count',
+           'gnutls_perror', 'gnutls_x509_crl_get_dn_oid',
+           'gnutls_certificate_get_peers',
+           'gnutls_ia_set_server_avp_function',
+           'gnutls_x509_crl_sign2',
+           'gnutls_x509_crt_get_extension_oid',
+           'gnutls_x509_crl_sign', 'gnutls_dh_get_pubkey',
+           'gnutls_record_get_max_size', 'gnutls_x509_crt_get_dn_oid',
+           'gnutls_x509_crt_get_extension_info',
+           'gnutls_transport_get_ptr', 'gnutls_db_check_entry',
+           'gnutls_ia_generate_challenge',
+           'gnutls_certificate_server_set_retrieve_function',
+           'gnutls_certificate_set_openpgp_key',
+           'gnutls_srp_base64_encode', 'gnutls_db_get_ptr',
+           'gnutls_pkcs7_export', 'gnutls_mac_set_priority',
+           'gnutls_x509_crt_get_basic_constraints',
+           'gnutls_x509_crt_get_subject_alt_othername_oid',
+           'gnutls_cipher_get_id', 'gnutls_x509_crl_get_this_update',
+           'gnutls_x509_dn_init', 'gnutls_openpgp_crt_import',
+           'gnutls_certificate_set_x509_crl',
+           'gnutls_rsa_export_get_modulus_bits',
+           'gnutls_x509_crl_get_version',
+           'gnutls_pkcs7_get_crl_count', 'gnutls_handshake',
+           'gnutls_dh_get_group', 'gnutls_x509_crq_get_dn',
+           'gnutls_pkcs7_deinit', 'gnutls_record_check_pending',
+           'gnutls_protocol_get_name',
+           'gnutls_openpgp_privkey_sign_hash',
+           'gnutls_srp_set_server_credentials_file',
+           'gnutls_pkcs7_delete_crl', 'gnutls_rsa_params_init',
+           'gnutls_x509_crt_set_key_purpose_oid', 'gnutls_mac_get',
+           'gnutls_record_get_direction',
+           'gnutls_certificate_type_list', 'gnutls_session_get_ptr',
+           'gnutls_psk_set_server_dh_params',
+           'gnutls_x509_crt_get_raw_issuer_dn',
+           'gnutls_x509_crt_get_raw_dn', 'gnutls_record_send',
+           'gnutls_psk_allocate_client_credentials',
+           'gnutls_certificate_set_x509_key',
+           'gnutls_certificate_type_get_id',
+           'gnutls_x509_privkey_export_dsa_raw',
+           'gnutls_pk_algorithm_get_name',
+           'gnutls_openpgp_crt_get_pk_algorithm',
+           'gnutls_psk_free_client_credentials',
+           'gnutls_openpgp_crt_check_hostname',
+           'gnutls_handshake_set_post_client_hello_function',
+           'gnutls_record_set_max_size',
+           'gnutls_openpgp_crt_verify_ring',
+           'gnutls_transport_set_ptr', 'gnutls_ia_set_client_avp_ptr',
+           'gnutls_x509_privkey_generate', 'gnutls_db_remove_session',
+           'gnutls_certificate_type_get_name',
+           'gnutls_openpgp_crt_verify_self',
+           'gnutls_x509_crq_get_dn_oid', 'gnutls_x509_dn_oid_known',
+           'gnutls_openpgp_crt_print', 'gnutls_alert_send',
+           'gnutls_x509_privkey_sign_data',
+           'gnutls_x509_crt_get_extension_data',
+           'gnutls_x509_crl_set_crt_serial',
+           'gnutls_x509_crt_set_basic_constraints',
+           'gnutls_credentials_set', 'gnutls_transport_set_ptr2',
+           'gnutls_x509_crt_set_issuer_dn_by_oid',
+           'gnutls_record_disable_padding', 'gnutls_prf_raw',
+           'gnutls_anon_allocate_server_credentials',
+           'gnutls_x509_crl_get_signature',
+           'gnutls_x509_crl_check_issuer', 'gnutls_cipher_suite_info',
+           'gnutls_x509_crt_get_issuer',
+           'gnutls_certificate_set_params_function',
+           'gnutls_openpgp_crt_get_subkey_id',
+           'gnutls_psk_set_server_credentials_hint',
+           'gnutls_sign_callback_set',
+           'gnutls_x509_crt_check_revocation',
+           'gnutls_openpgp_privkey_export',
+           'gnutls_x509_crt_get_activation_time', 'gnutls_kx_list',
+           'gnutls_x509_crt_get_subject_alt_name',
+           'gnutls_openpgp_privkey_get_subkey_creation_time',
+           'gnutls_x509_crt_get_dn_by_oid', 'gnutls_rsa_params_cpy',
+           'gnutls_x509_crt_set_subject_key_id',
+           'gnutls_check_version',
+           'gnutls_certificate_client_get_request_status',
+           'gnutls_prf', 'gnutls_srp_server_get_username',
+           'gnutls_pem_base64_encode_alloc',
+           'gnutls_certificate_set_openpgp_key_file2',
+           'gnutls_openpgp_privkey_export_rsa_raw',
+           'gnutls_certificate_set_openpgp_key_mem',
+           'gnutls_openpgp_privkey_get_key_id',
+           'gnutls_anon_free_client_credentials',
+           'gnutls_transport_get_ptr2',
+           'gnutls_ia_get_client_avp_ptr', 'gnutls_pkcs7_import',
+           'gnutls_compression_get',
+           'gnutls_x509_crl_get_signature_algorithm',
+           'gnutls_openpgp_keyring_init',
+           'gnutls_certificate_free_crls',
+           'gnutls_transport_set_global_errno', 'gnutls_record_recv',
+           'gnutls_certificate_type_get',
+           'gnutls_auth_server_get_type',
+           'gnutls_anon_set_params_function',
+           'gnutls_openpgp_crt_deinit', 'gnutls_pkcs7_set_crt',
+           'gnutls_rsa_params_export_raw',
+           'gnutls_x509_dn_get_rdn_ava', 'gnutls_x509_crt_deinit',
+           'gnutls_session_get_client_random',
+           'gnutls_openpgp_set_recv_key_function',
+           'gnutls_x509_crl_set_this_update',
+           'gnutls_ia_free_client_credentials',
+           'gnutls_protocol_get_version', 'gnutls_x509_crl_set_crt',
+           'gnutls_fingerprint', 'gnutls_x509_dn_export',
+           'gnutls_openpgp_privkey_import', 'gnutls_error_to_alert',
+           'gnutls_x509_privkey_get_key_id',
+           'gnutls_x509_crt_get_subject', 'gnutls_rsa_params_deinit',
+           'gnutls_cipher_get_name', 'gnutls_ia_send',
+           'gnutls_x509_crt_set_extension_by_oid',
+           'gnutls_x509_privkey_get_pk_algorithm',
+           'gnutls_hex_encode', 'gnutls_rsa_params_import_raw',
+           'gnutls_mac_get_name', 'gnutls_psk_server_get_username',
+           'gnutls_session_get_data2', 'gnutls_kx_get',
+           'gnutls_openpgp_crt_get_preferred_key_id',
+           'gnutls_certificate_get_x509_crls',
+           'gnutls_x509_crq_set_version', 'gnutls_x509_privkey_cpy',
+           'gnutls_openpgp_crt_get_subkey_revoked_status',
+           'gnutls_priority_set_direct', 'gnutls_dh_get_secret_bits',
+           'gnutls_x509_crt_get_expiration_time', 'gnutls_pkcs7_init',
+           'gnutls_transport_set_pull_function',
+           'gnutls_protocol_list',
+           'gnutls_srp_set_client_credentials',
+           'gnutls_x509_crt_get_key_purpose_oid',
+           'gnutls_certificate_verify_peers2',
+           'gnutls_srp_base64_decode_alloc', 'gnutls_x509_crq_sign',
+           'gnutls_x509_privkey_init', 'gnutls_global_set_log_level',
+           'gnutls_sign_callback_get', 'gnutls_x509_rdn_get',
+           'gnutls_openpgp_privkey_set_preferred_key_id',
+           'gnutls_certificate_free_credentials',
+           'gnutls_x509_dn_deinit',
+           'gnutls_certificate_set_rsa_export_params',
+           'gnutls_x509_crt_get_serial', 'gnutls_x509_crq_import',
+           'gnutls_x509_privkey_export',
+           'gnutls_cipher_suite_get_name',
+           'gnutls_ia_extract_inner_secret',
+           'gnutls_x509_crt_get_version', 'gnutls_ia_enable',
+           'gnutls_x509_crt_set_key',
+           'gnutls_srp_free_client_credentials', 'gnutls_mac_list',
+           'gnutls_dh_get_prime_bits', 'gnutls_certificate_free_cas',
+           'gnutls_alert_get', 'gnutls_ia_permute_inner_secret',
+           'gnutls_rehandshake',
+           'gnutls_x509_crt_set_subject_alternative_name',
+           'gnutls_psk_set_server_credentials_file',
+           'gnutls_dh_set_prime_bits', 'gnutls_priority_deinit',
+           'gnutls_x509_crt_set_version',
+           'gnutls_dh_params_export_pkcs3', 'gnutls_x509_crq_deinit',
+           'gnutls_x509_crt_get_fingerprint',
+           'gnutls_extra_check_version',
+           'gnutls_srp_allocate_client_credentials',
+           'gnutls_x509_crl_get_issuer_dn_by_oid',
+           'gnutls_pkcs7_get_crl_raw',
+           'gnutls_x509_crt_set_expiration_time',
+           'gnutls_compression_set_priority',
+           'gnutls_openpgp_crt_get_subkey_count',
+           'gnutls_openpgp_crt_get_key_usage',
+           'gnutls_ia_allocate_server_credentials',
+           'gnutls_ia_free_server_credentials',
+           'gnutls_transport_set_lowat',
+           'gnutls_x509_crt_set_crl_dist_points',
+           'gnutls_compression_list',
+           'gnutls_x509_privkey_import_pkcs8',
+           'gnutls_session_enable_compatibility_mode',
+           'gnutls_x509_crq_set_challenge_password',
+           'gnutls_strerror', 'gnutls_x509_crt_get_dn',
+           'gnutls_x509_crl_init',
+           'gnutls_certificate_set_verify_flags',
+           'gnutls_psk_free_server_credentials',
+           'gnutls_openpgp_privkey_get_subkey_idx',
+           'gnutls_ia_set_client_avp_function',
+           'gnutls_openpgp_crt_get_subkey_creation_time',
+           'gnutls_compression_get_name', 'gnutls_openpgp_crt_init',
+           'gnutls_x509_crq_get_dn_by_oid',
+           'gnutls_openpgp_privkey_get_pk_algorithm',
+           'gnutls_certificate_set_x509_key_file',
+           'gnutls_openpgp_crt_get_key_id',
+           'gnutls_set_default_export_priority',
+           'gnutls_x509_crl_print', 'gnutls_rsa_export_get_pubkey',
+           'gnutls_x509_crq_set_key',
+           'gnutls_x509_crt_get_signature_algorithm',
+           'gnutls_openpgp_crt_get_name',
+           'gnutls_openpgp_crt_get_subkey_pk_dsa_raw',
+           'gnutls_x509_crl_get_issuer_dn',
+           'gnutls_rsa_params_generate2',
+           'gnutls_handshake_set_private_extensions',
+           'gnutls_psk_set_client_credentials',
+           'gnutls_server_name_get',
+           'gnutls_openpgp_crt_get_subkey_usage',
+           'gnutls_rsa_params_import_pkcs1', 'gnutls_session_set_ptr',
+           'gnutls_bye', 'gnutls_auth_client_get_type',
+           'gnutls_openpgp_privkey_export_subkey_rsa_raw',
+           'gnutls_x509_crt_get_proxy', 'gnutls_kx_get_id',
+           'gnutls_session_get_data', 'gnutls_x509_crt_list_import',
+           'gnutls_pkcs7_get_crt_raw',
+           'gnutls_openpgp_privkey_get_subkey_id',
+           'gnutls_psk_set_server_credentials_function',
+           'gnutls_srp_set_server_credentials_function',
+           'gnutls_ia_verify_endphase', 'gnutls_error_is_fatal',
+           'gnutls_x509_crt_verify_data',
+           'gnutls_psk_netconf_derive_key',
+           'gnutls_certificate_server_set_request',
+           'gnutls_openpgp_privkey_get_fingerprint',
+           'gnutls_dh_params_export_raw',
+           'gnutls_protocol_set_priority',
+           'gnutls_psk_set_client_credentials_function',
+           'gnutls_set_default_priority', 'gnutls_hex2bin',
+           'gnutls_dh_params_cpy', 'gnutls_ia_handshake',
+           'gnutls_handshake_get_last_in', 'gnutls_protocol_get_id',
+           'gnutls_x509_crq_get_attribute_by_oid',
+           'gnutls_certificate_get_ours',
+           'gnutls_anon_free_server_credentials',
+           'gnutls_x509_crt_verify', 'gnutls_session_set_data',
+           'gnutls_certificate_allocate_credentials',
+           'gnutls_x509_crt_set_serial', 'gnutls_openpgp_send_cert',
+           'gnutls_certificate_set_x509_key_mem',
+           'gnutls_x509_crt_get_extension_by_oid',
+           'gnutls_session_get_server_random',
+           'gnutls_openpgp_privkey_get_revoked_status',
+           'gnutls_dh_params_deinit', 'gnutls_mac_get_id',
+           'gnutls_x509_crt_get_signature', 'gnutls_x509_crq_sign2',
+           'gnutls_global_deinit', 'gnutls_sign_algorithm_get_name',
+           'gnutls_anon_allocate_client_credentials',
+           'gnutls_x509_crt_export',
+           'gnutls_certificate_get_x509_cas',
+           'gnutls_dh_params_import_pkcs3', 'gnutls_hex_decode',
+           'gnutls_openpgp_crt_export',
+           'gnutls_psk_set_params_function',
+           'gnutls_x509_crt_check_issuer',
+           'gnutls_x509_crl_set_next_update',
+           'gnutls_ia_allocate_client_credentials',
+           'gnutls_psk_client_get_hint',
+           'gnutls_certificate_send_x509_rdn_sequence',
+           'gnutls_alert_send_appropriate',
+           'gnutls_anon_set_server_dh_params',
+           'gnutls_openpgp_crt_get_revoked_status',
+           'gnutls_openpgp_crt_get_subkey_pk_algorithm',
+           'gnutls_openpgp_privkey_get_preferred_key_id',
+           'gnutls_x509_privkey_sign_hash', 'gnutls_x509_crl_export',
+           'gnutls_openpgp_privkey_deinit',
+           'gnutls_pkcs7_set_crt_raw', 'gnutls_auth_get_type',
+           'gnutls_certificate_get_openpgp_keyring',
+           'gnutls_openpgp_privkey_export_dsa_raw',
+           'gnutls_openpgp_crt_set_preferred_key_id',
+           'gnutls_srp_allocate_server_credentials',
+           'gnutls_dh_get_peers_public_bits',
+           'gnutls_certificate_set_x509_crl_mem',
+           'gnutls_x509_privkey_fix', 'gnutls_kx_get_name',
+           'gnutls_psk_set_server_params_function',
+           'gnutls_openpgp_crt_get_fingerprint',
+           'gnutls_openpgp_crt_get_subkey_expiration_time',
+           'gnutls_x509_dn_import',
+           'gnutls_x509_crt_get_issuer_dn_by_oid',
+           'gnutls_openpgp_crt_get_creation_time',
+           'gnutls_openpgp_crt_get_pk_rsa_raw',
+           'gnutls_session_is_resumed', 'gnutls_x509_crt_set_proxy',
+           'gnutls_certificate_set_openpgp_key_file',
+           'gnutls_certificate_set_x509_trust_mem',
+           'gnutls_openpgp_crt_get_auth_subkey',
+           'gnutls_x509_privkey_verify_data', 'gnutls_deinit',
+           'gnutls_x509_crt_import',
+           'gnutls_db_set_retrieve_function',
+           'gnutls_x509_privkey_import',
+           'gnutls_certificate_set_x509_simple_pkcs12_file',
+           'gnutls_global_set_log_function',
+           'gnutls_db_set_cache_expiration',
+           'gnutls_x509_crt_set_ca_status',
+           'gnutls_x509_crl_get_next_update',
+           'gnutls_x509_crl_verify', 'gnutls_pem_base64_decode_alloc',
+           'gnutls_x509_crt_get_key_usage',
+           'gnutls_x509_crt_get_crl_dist_points']
diff --git a/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/library/types.py b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/library/types.py
new file mode 100644
index 0000000..0d878bb
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/library/types.py
@@ -0,0 +1,248 @@
+from ctypes import *
+
+STRING = c_char_p
+from gnutls.library.constants import gnutls_cipher_algorithm_t
+from gnutls.library.constants import gnutls_certificate_print_formats
+from gnutls.library.constants import gnutls_params_type_t
+from gnutls.library.constants import gnutls_psk_key_flags
+from gnutls.library.constants import gnutls_x509_subject_alt_name_t
+from gnutls.library.constants import gnutls_certificate_type_t
+from gnutls.library.constants import gnutls_pk_algorithm_t
+from gnutls.library.constants import gnutls_openpgp_crt_fmt
+from gnutls.library.constants import gnutls_certificate_import_flags
+from gnutls.library.constants import gnutls_certificate_verify_flags
+from gnutls.library.constants import gnutls_pkcs_encrypt_flags_t
+
+
+class gnutls_session_int(Structure):
+    pass
+gnutls_session_t = POINTER(gnutls_session_int)
+size_t = c_size_t
+gnutls_ia_avp_func = CFUNCTYPE(c_int, gnutls_session_t, c_void_p, STRING, size_t, POINTER(STRING), POINTER(size_t))
+class gnutls_ia_server_credentials_st(Structure):
+    pass
+gnutls_ia_server_credentials_st._fields_ = [
+]
+gnutls_ia_server_credentials_t = POINTER(gnutls_ia_server_credentials_st)
+class gnutls_ia_client_credentials_st(Structure):
+    pass
+gnutls_ia_client_credentials_st._fields_ = [
+]
+gnutls_ia_client_credentials_t = POINTER(gnutls_ia_client_credentials_st)
+gnutls_certificate_print_formats_t = gnutls_certificate_print_formats
+gnutls_transport_ptr_t = c_void_p
+gnutls_session_int._fields_ = [
+]
+class gnutls_dh_params_int(Structure):
+    pass
+gnutls_dh_params_int._fields_ = [
+]
+gnutls_dh_params_t = POINTER(gnutls_dh_params_int)
+class gnutls_x509_privkey_int(Structure):
+    pass
+gnutls_x509_privkey_int._fields_ = [
+]
+gnutls_rsa_params_t = POINTER(gnutls_x509_privkey_int)
+class gnutls_priority_st(Structure):
+    pass
+gnutls_priority_st._fields_ = [
+]
+gnutls_priority_t = POINTER(gnutls_priority_st)
+class gnutls_datum_t(Structure):
+    pass
+gnutls_datum_t._fields_ = [
+    ('data', POINTER(c_ubyte)),
+    ('size', c_uint),
+]
+class gnutls_params_st(Structure):
+    pass
+class params(Union):
+    pass
+params._fields_ = [
+    ('dh', gnutls_dh_params_t),
+    ('rsa_export', gnutls_rsa_params_t),
+]
+gnutls_params_st._fields_ = [
+    ('type', gnutls_params_type_t),
+    ('params', params),
+    ('deinit', c_int),
+]
+gnutls_params_function = CFUNCTYPE(c_int, gnutls_session_t, gnutls_params_type_t, POINTER(gnutls_params_st))
+gnutls_oprfi_callback_func = CFUNCTYPE(c_int, gnutls_session_t, c_void_p, size_t, POINTER(c_ubyte), POINTER(c_ubyte))
+gnutls_db_store_func = CFUNCTYPE(c_int, c_void_p, gnutls_datum_t, gnutls_datum_t)
+gnutls_db_remove_func = CFUNCTYPE(c_int, c_void_p, gnutls_datum_t)
+gnutls_db_retr_func = CFUNCTYPE(gnutls_datum_t, c_void_p, gnutls_datum_t)
+gnutls_handshake_post_client_hello_func = CFUNCTYPE(c_int, gnutls_session_t)
+class gnutls_certificate_credentials_st(Structure):
+    pass
+gnutls_certificate_credentials_st._fields_ = [
+]
+gnutls_certificate_credentials_t = POINTER(gnutls_certificate_credentials_st)
+gnutls_certificate_server_credentials = gnutls_certificate_credentials_t
+gnutls_certificate_client_credentials = gnutls_certificate_credentials_t
+class gnutls_anon_server_credentials_st(Structure):
+    pass
+gnutls_anon_server_credentials_st._fields_ = [
+]
+gnutls_anon_server_credentials_t = POINTER(gnutls_anon_server_credentials_st)
+class gnutls_anon_client_credentials_st(Structure):
+    pass
+gnutls_anon_client_credentials_st._fields_ = [
+]
+gnutls_anon_client_credentials_t = POINTER(gnutls_anon_client_credentials_st)
+gnutls_x509_privkey_t = POINTER(gnutls_x509_privkey_int)
+class gnutls_x509_crl_int(Structure):
+    pass
+gnutls_x509_crl_int._fields_ = [
+]
+gnutls_x509_crl_t = POINTER(gnutls_x509_crl_int)
+class gnutls_x509_crt_int(Structure):
+    pass
+gnutls_x509_crt_int._fields_ = [
+]
+gnutls_x509_crt_t = POINTER(gnutls_x509_crt_int)
+class gnutls_openpgp_keyring_int(Structure):
+    pass
+gnutls_openpgp_keyring_int._fields_ = [
+]
+gnutls_openpgp_keyring_t = POINTER(gnutls_openpgp_keyring_int)
+gnutls_alloc_function = CFUNCTYPE(c_void_p, size_t)
+gnutls_calloc_function = CFUNCTYPE(c_void_p, size_t, size_t)
+gnutls_is_secure_function = CFUNCTYPE(c_int, c_void_p)
+gnutls_free_function = CFUNCTYPE(None, c_void_p)
+gnutls_realloc_function = CFUNCTYPE(c_void_p, c_void_p, size_t)
+gnutls_log_func = CFUNCTYPE(None, c_int, STRING)
+__ssize_t = c_long
+ssize_t = __ssize_t
+gnutls_pull_func = CFUNCTYPE(ssize_t, gnutls_transport_ptr_t, c_void_p, size_t)
+gnutls_push_func = CFUNCTYPE(ssize_t, gnutls_transport_ptr_t, c_void_p, size_t)
+class gnutls_srp_server_credentials_st(Structure):
+    pass
+gnutls_srp_server_credentials_st._fields_ = [
+]
+gnutls_srp_server_credentials_t = POINTER(gnutls_srp_server_credentials_st)
+class gnutls_srp_client_credentials_st(Structure):
+    pass
+gnutls_srp_client_credentials_st._fields_ = [
+]
+gnutls_srp_client_credentials_t = POINTER(gnutls_srp_client_credentials_st)
+gnutls_srp_server_credentials_function = CFUNCTYPE(c_int, gnutls_session_t, STRING, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t))
+gnutls_srp_client_credentials_function = CFUNCTYPE(c_int, gnutls_session_t, POINTER(STRING), POINTER(STRING))
+class gnutls_psk_server_credentials_st(Structure):
+    pass
+gnutls_psk_server_credentials_st._fields_ = [
+]
+gnutls_psk_server_credentials_t = POINTER(gnutls_psk_server_credentials_st)
+class gnutls_psk_client_credentials_st(Structure):
+    pass
+gnutls_psk_client_credentials_st._fields_ = [
+]
+gnutls_psk_client_credentials_t = POINTER(gnutls_psk_client_credentials_st)
+gnutls_psk_server_credentials_function = CFUNCTYPE(c_int, gnutls_session_t, STRING, POINTER(gnutls_datum_t))
+gnutls_psk_client_credentials_function = CFUNCTYPE(c_int, gnutls_session_t, POINTER(STRING), POINTER(gnutls_datum_t))
+class gnutls_openpgp_crt_int(Structure):
+    pass
+gnutls_openpgp_crt_int._fields_ = [
+]
+gnutls_openpgp_crt_t = POINTER(gnutls_openpgp_crt_int)
+class gnutls_openpgp_privkey_int(Structure):
+    pass
+gnutls_openpgp_privkey_int._fields_ = [
+]
+gnutls_openpgp_privkey_t = POINTER(gnutls_openpgp_privkey_int)
+class gnutls_retr_st(Structure):
+    pass
+class cert(Union):
+    pass
+cert._fields_ = [
+    ('x509', POINTER(gnutls_x509_crt_t)),
+    ('pgp', gnutls_openpgp_crt_t),
+]
+class key(Union):
+    pass
+key._fields_ = [
+    ('x509', gnutls_x509_privkey_t),
+    ('pgp', gnutls_openpgp_privkey_t),
+]
+gnutls_retr_st._fields_ = [
+    ('type', gnutls_certificate_type_t),
+    ('cert', cert),
+    ('ncerts', c_uint),
+    ('key', key),
+    ('deinit_all', c_uint),
+]
+gnutls_certificate_client_retrieve_function = CFUNCTYPE(c_int, gnutls_session_t, POINTER(gnutls_datum_t), c_int, POINTER(gnutls_pk_algorithm_t), c_int, POINTER(gnutls_retr_st))
+gnutls_certificate_server_retrieve_function = CFUNCTYPE(c_int, gnutls_session_t, POINTER(gnutls_retr_st))
+gnutls_sign_func = CFUNCTYPE(c_int, gnutls_session_t, c_void_p, gnutls_certificate_type_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t))
+gnutls_openpgp_crt_fmt_t = gnutls_openpgp_crt_fmt
+gnutls_openpgp_keyid_t = c_ubyte * 8
+gnutls_openpgp_recv_key_func = CFUNCTYPE(c_int, gnutls_session_t, POINTER(c_ubyte), c_uint, POINTER(gnutls_datum_t))
+gnutls_x509_dn_t = c_void_p
+class gnutls_x509_ava_st(Structure):
+    pass
+gnutls_x509_ava_st._fields_ = [
+    ('oid', gnutls_datum_t),
+    ('value', gnutls_datum_t),
+    ('value_tag', c_ulong),
+]
+class gnutls_pkcs7_int(Structure):
+    pass
+gnutls_pkcs7_int._fields_ = [
+]
+gnutls_pkcs7_t = POINTER(gnutls_pkcs7_int)
+class gnutls_x509_crq_int(Structure):
+    pass
+gnutls_x509_crq_int._fields_ = [
+]
+gnutls_x509_crq_t = POINTER(gnutls_x509_crq_int)
+__all__ = ['key', 'gnutls_certificate_print_formats_t',
+           'gnutls_session_int', 'gnutls_srp_server_credentials_st',
+           'gnutls_oprfi_callback_func', '__ssize_t',
+           'gnutls_transport_ptr_t', 'gnutls_pkcs7_int',
+           'gnutls_psk_client_credentials_st', 'gnutls_priority_t',
+           'gnutls_certificate_credentials_st',
+           'gnutls_psk_server_credentials_t', 'gnutls_x509_crt_t',
+           'gnutls_x509_privkey_t', 'gnutls_openpgp_keyring_t',
+           'gnutls_x509_privkey_int', 'gnutls_push_func',
+           'gnutls_x509_crq_int', 'gnutls_psk_server_credentials_st',
+           'gnutls_openpgp_crt_t',
+           'gnutls_certificate_client_credentials', 'size_t',
+           'gnutls_ia_avp_func', 'gnutls_params_st',
+           'gnutls_anon_client_credentials_t', 'gnutls_dh_params_t',
+           'gnutls_anon_client_credentials_st', 'gnutls_sign_func',
+           'gnutls_srp_server_credentials_function', 'cert',
+           'gnutls_x509_crt_int', 'gnutls_realloc_function',
+           'gnutls_srp_client_credentials_function',
+           'gnutls_ia_server_credentials_st',
+           'gnutls_srp_client_credentials_st',
+           'gnutls_calloc_function', 'gnutls_priority_st',
+           'gnutls_x509_crl_int', 'params',
+           'gnutls_certificate_server_credentials',
+           'gnutls_handshake_post_client_hello_func',
+           'gnutls_session_t',
+           'gnutls_psk_client_credentials_function',
+           'gnutls_openpgp_privkey_int', 'gnutls_retr_st',
+           'gnutls_is_secure_function', 'gnutls_db_retr_func',
+           'gnutls_openpgp_keyring_int',
+           'gnutls_srp_client_credentials_t',
+           'gnutls_psk_client_credentials_t',
+           'gnutls_anon_server_credentials_t', 'gnutls_dh_params_int',
+           'gnutls_datum_t', 'gnutls_openpgp_crt_fmt_t',
+           'gnutls_ia_server_credentials_t', 'gnutls_x509_ava_st',
+           'gnutls_alloc_function',
+           'gnutls_psk_server_credentials_function',
+           'gnutls_anon_server_credentials_st',
+           'gnutls_params_function',
+           'gnutls_srp_server_credentials_t',
+           'gnutls_openpgp_crt_int', 'gnutls_log_func',
+           'gnutls_rsa_params_t',
+           'gnutls_certificate_server_retrieve_function',
+           'gnutls_x509_dn_t', 'gnutls_x509_crq_t',
+           'gnutls_pull_func', 'gnutls_db_remove_func',
+           'gnutls_ia_client_credentials_t',
+           'gnutls_certificate_credentials_t', 'gnutls_pkcs7_t',
+           'gnutls_ia_client_credentials_st', 'gnutls_db_store_func',
+           'ssize_t', 'gnutls_openpgp_recv_key_func',
+           'gnutls_openpgp_privkey_t', 'gnutls_openpgp_keyid_t',
+           'gnutls_free_function', 'gnutls_x509_crl_t',
+           'gnutls_certificate_client_retrieve_function']
diff --git a/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/validators.py b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/validators.py
new file mode 100644
index 0000000..11c29c3
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/gnutls/validators.py
@@ -0,0 +1,286 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS data validators"""
+
+__all__ = ['function_args', 'method_args', 'none', 'ignore', 'list_of', 'one_of', 'ProtocolListValidator', 
+           'KeyExchangeListValidator', 'CipherListValidator', 'MACListValidator', 'CompressionListValidator']
+
+from gnutls.constants import *
+
+#
+# Priority list validators. They take a tuple or list on input and output a
+# tuple with the same elements if they check valid, else raise an exception.
+#
+
+class ProtocolListValidator(tuple):
+    _protocols = set((PROTO_TLS1_1, PROTO_TLS1_0, PROTO_SSL3))
+
+    def __new__(cls, arg):
+        if not isinstance(arg, (tuple, list)):
+            raise TypeError("Argument must be a tuple or list")
+        if not arg:
+            raise ValueError("Protocol list cannot be empty")
+        if not cls._protocols.issuperset(set(arg)):
+            raise ValueError("Got invalid protocol")
+        return tuple.__new__(cls, arg)
+
+
+class KeyExchangeListValidator(tuple):
+    _algorithms = set((KX_RSA, KX_DHE_DSS, KX_DHE_RSA, KX_RSA_EXPORT, KX_ANON_DH))
+
+    def __new__(cls, arg):
+        if not isinstance(arg, (tuple, list)):
+            raise TypeError("Argument must be a tuple or list")
+        if not arg:
+            raise ValueError("Key exchange algorithm list cannot be empty")
+        if not cls._algorithms.issuperset(set(arg)):
+            raise ValueError("Got invalid key exchange algorithm")
+        return tuple.__new__(cls, arg)
+
+
+class CipherListValidator(tuple):
+    _ciphers = set((CIPHER_AES_128_CBC, CIPHER_3DES_CBC, CIPHER_ARCFOUR_128, CIPHER_AES_256_CBC, CIPHER_DES_CBC))
+
+    def __new__(cls, arg):
+        if not isinstance(arg, (tuple, list)):
+            raise TypeError("Argument must be a tuple or list")
+        if not arg:
+            raise ValueError("Cipher list cannot be empty")
+        if not cls._ciphers.issuperset(set(arg)):
+            raise ValueError("Got invalid cipher")
+        return tuple.__new__(cls, arg)
+
+
+class MACListValidator(tuple):
+    _algorithms = set((MAC_SHA1, MAC_MD5, MAC_RMD160))
+
+    def __new__(cls, arg):
+        if not isinstance(arg, (tuple, list)):
+            raise TypeError("Argument must be a tuple or list")
+        if not arg:
+            raise ValueError("MAC algorithm list cannot be empty")
+        if not cls._algorithms.issuperset(set(arg)):
+            raise ValueError("Got invalid MAC algorithm")
+        return tuple.__new__(cls, arg)
+
+
+class CompressionListValidator(tuple):
+    _compressions = set((COMP_DEFLATE, COMP_LZO, COMP_NULL))
+
+    def __new__(cls, arg):
+        if not isinstance(arg, (tuple, list)):
+            raise TypeError("Argument must be a tuple or list")
+        if not arg:
+            raise ValueError("Compression list cannot be empty")
+        if not cls._compressions.issuperset(set(arg)):
+            raise ValueError("Got invalid compression")
+        return tuple.__new__(cls, arg)
+
+#
+# Argument validating
+#
+
+# Helper functions (internal use)
+#
+
+def isclass(obj):
+    return hasattr(obj, '__bases__') or isinstance(obj, type)
+
+# Internal validator classes
+#
+
+class Validator(object):
+    _registered = []
+    def __init__(self, typ):
+        self.type = typ
+    def check(self, value):
+        return False
+    @staticmethod
+    def can_validate(typ):
+        return False
+    @classmethod
+    def register(cls, validator):
+        cls._registered.append(validator)
+    @classmethod
+    def get(cls, typ):
+        for validator in cls._registered:
+            if validator.can_validate(typ):
+                return validator(typ)
+        else:
+            return None
+    @staticmethod
+    def join_names(names):
+        if type(names) in (tuple, list):
+            if len(names) <= 2:
+                return ' or '.join(names)
+            else:
+                return ' or '.join((', '.join(names[:-1]), names[-1]))
+        else:
+            return names
+    def _type_names(self):
+        if isinstance(self.type, tuple):
+            return self.join_names([t.__name__.replace('NoneType', 'None') for t in self.type])
+        else:
+            return self.type.__name__.replace('NoneType', 'None')
+    @property
+    def name(self):
+        name = self._type_names()
+        if name.startswith('None'):
+            prefix = ''
+        elif name[0] in ('a', 'e', 'i', 'o', 'u'):
+            prefix = 'an '
+        else:
+            prefix = 'a '
+        return prefix + name
+
+class IgnoringValidator(Validator):
+    def __init__(self, typ):
+        self.type = none
+    def check(self, value):
+        return True
+    @staticmethod
+    def can_validate(obj):
+        return obj is ignore
+
+class TypeValidator(Validator):
+    def check(self, value):
+        return isinstance(value, self.type)
+    @staticmethod
+    def can_validate(obj):
+        return isclass(obj)
+
+class MultiTypeValidator(TypeValidator):
+    @staticmethod
+    def can_validate(obj):
+        return isinstance(obj, tuple) and not filter(lambda x: not isclass(x), obj)
+
+class OneOfValidator(Validator):
+    def __init__(self, typ):
+        self.type = typ.type
+    def check(self, value):
+        return value in self.type
+    @staticmethod
+    def can_validate(obj):
+        return isinstance(obj, one_of)
+    @property
+    def name(self):
+        return 'one of %s' % self.join_names(["`%r'" % e for e in self.type])
+
+class ListOfValidator(Validator):
+    def __init__(self, typ):
+        self.type = typ.type
+    def check(self, value):
+        return isinstance(value, (tuple, list)) and not filter(lambda x: not isinstance(x, self.type), value)
+    @staticmethod
+    def can_validate(obj):
+        return isinstance(obj, list_of)
+    @property
+    def name(self):
+        return 'a list of %s' % self._type_names()
+
+class ComplexValidator(Validator):
+    def __init__(self, typ):
+        self.type = [Validator.get(x) for x in typ]
+    def check(self, value):
+        return bool(sum(t.check(value) for t in self.type))
+    @staticmethod
+    def can_validate(obj):
+        return isinstance(obj, tuple) and not filter(lambda x: Validator.get(x) is None, obj)
+    @property
+    def name(self):
+        return self.join_names([x.name for x in self.type])
+
+Validator.register(IgnoringValidator)
+Validator.register(TypeValidator)
+Validator.register(MultiTypeValidator)
+Validator.register(OneOfValidator)
+Validator.register(ListOfValidator)
+Validator.register(ComplexValidator)
+
+
+# Extra types to be used with argument validating decorators
+#
+
+none = type(None)
+
+class one_of(object):
+    def __init__(self, *args):
+        if len(args) < 2:
+            raise ValueError("one_of must have at least 2 arguments")
+        self.type = args
+
+class list_of(object):
+    def __init__(self, *args):
+        if filter(lambda x: not isclass(x), args):
+            raise TypeError("list_of arguments must be types")
+        if len(args) == 1:
+            self.type = args[0]
+        else:
+            self.type = args
+
+ignore = type('ignore', (), {})()
+
+
+# Helpers for writing well behaved decorators
+#
+
+def decorator(func):
+    """A syntactic marker with no other effect than improving readability."""
+    return func
+
+def preserve_signature(func):
+    """Preserve the original function signature and attributes in decorator wrappers."""
+    from inspect import getargspec, formatargspec
+    from gnutls.constants import GNUTLSConstant
+    constants  = [c for c in (getargspec(func)[3] or []) if isinstance(c, GNUTLSConstant)]
+    signature  = formatargspec(*getargspec(func))[1:-1]
+    parameters = formatargspec(*getargspec(func), **{'formatvalue': lambda value: ""})[1:-1]
+    def fix_signature(wrapper):
+        if constants:
+            ## import the required GNUTLSConstants used as function default arguments
+            code = "from gnutls.constants import %s\n" % ', '.join(c.name for c in constants)
+            exec code in locals(), locals()
+        code = "def %s(%s): return wrapper(%s)\nnew_wrapper = %s\n" % (func.__name__, signature, parameters, func.__name__)
+        exec code in locals(), locals()
+        new_wrapper.__name__ = func.__name__
+        new_wrapper.__doc__ = func.__doc__
+        new_wrapper.__module__ = func.__module__
+        new_wrapper.__dict__.update(func.__dict__)
+        return new_wrapper
+    return fix_signature
+
+# Argument validating decorators
+#
+
+def _callable_args(*args, **kwargs):
+    """Internal function used by argument checking decorators"""
+    start = kwargs.get('_start', 0)
+    validators = []
+    for i, arg in enumerate(args):
+        validator = Validator.get(arg)
+        if validator is None:
+            raise TypeError("unsupported type `%r' at position %d for argument checking decorator" % (arg, i+1))
+        validators.append(validator)
+    def check_args_decorator(func):
+        @preserve_signature(func)
+        def check_args(*func_args):
+            pos = start
+            for validator in validators:
+                if not validator.check(func_args[pos]):
+                    raise TypeError("argument %d must be %s" % (pos+1-start, validator.name))
+                pos += 1
+            return func(*func_args)
+        return check_args
+    return check_args_decorator
+
+@decorator
+def method_args(*args):
+    """Check class or instance method arguments"""
+    return _callable_args(*args, **{'_start': 1})
+
+@decorator
+def function_args(*args):
+    """Check functions or staticmethod arguments"""
+    return _callable_args(*args)
+
diff --git a/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/python_gnutls-1.1.9.egg-info b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/python_gnutls-1.1.9.egg-info
new file mode 100644
index 0000000..39109f3
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls/usr/share/pyshared/python_gnutls-1.1.9.egg-info
@@ -0,0 +1,33 @@
+Metadata-Version: 1.0
+Name: python-gnutls
+Version: 1.1.9
+Summary: Python wrapper for the GNUTLS library
+Home-page: http://ag-projects.com/
+Author: Dan Pascu
+Author-email: dan@ag-projects.com
+License: LGPL
+Download-URL: http://cheeseshop.python.org/pypi/python-gnutls/1.1.9
+Description: This package provides a high level object oriented wrapper around libgnutls,
+        as well as low level bindings to the GNUTLS types and functions via ctypes.
+        The high level wrapper hides the details of accessing the GNUTLS library via
+        ctypes behind a set of classes that encapsulate GNUTLS sessions, certificates
+        and credentials and expose them to python applications using a simple API.
+        
+        The package also includes a Twisted interface that has seamless intergration
+        with Twisted, providing connectTLS and listenTLS methods on the Twisted
+        reactor once imported (the methods are automatically attached to the reactor
+        by simply importing the GNUTLS Twisted interface module).
+        
+        The high level wrapper is written using the GNUTLS library bindings that are
+        made available via ctypes. This makes the wrapper very powerful and flexible
+        as it has direct access to all the GNUTLS internals and is also very easy to
+        extend without any need to write C code or recompile anything.
+        
+        
+Platform: Platform Independent
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
diff --git a/gnutls-1.1.9/debian/python-gnutls/usr/share/python-support/python-gnutls.public b/gnutls-1.1.9/debian/python-gnutls/usr/share/python-support/python-gnutls.public
new file mode 100644
index 0000000..bf75f2a
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-gnutls/usr/share/python-support/python-gnutls.public
@@ -0,0 +1,18 @@
+pyversions=2.5,2.6
+
+/usr/lib/pyshared/python2.5/gnutls/library/_gnutls_init.so
+/usr/lib/pyshared/python2.6/gnutls/library/_gnutls_init.so
+/usr/share/pyshared/gnutls/__init__.py
+/usr/share/pyshared/gnutls/connection.py
+/usr/share/pyshared/gnutls/constants.py
+/usr/share/pyshared/gnutls/crypto.py
+/usr/share/pyshared/gnutls/errors.py
+/usr/share/pyshared/gnutls/interfaces/__init__.py
+/usr/share/pyshared/gnutls/interfaces/twisted/__init__.py
+/usr/share/pyshared/gnutls/library/__init__.py
+/usr/share/pyshared/gnutls/library/constants.py
+/usr/share/pyshared/gnutls/library/errors.py
+/usr/share/pyshared/gnutls/library/functions.py
+/usr/share/pyshared/gnutls/library/types.py
+/usr/share/pyshared/gnutls/validators.py
+/usr/share/pyshared/python_gnutls-1.1.9.egg-info
diff --git a/gnutls-1.1.9/debian/python-module-stampdir/python-gnutls b/gnutls-1.1.9/debian/python-module-stampdir/python-gnutls
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/gnutls-1.1.9/debian/python-module-stampdir/python-gnutls
diff --git a/gnutls-1.1.9/debian/rules b/gnutls-1.1.9/debian/rules
new file mode 100755
index 0000000..56ca1a0
--- /dev/null
+++ b/gnutls-1.1.9/debian/rules
@@ -0,0 +1,7 @@
+#!/usr/bin/make -f
+
+DEB_PYTHON_SYSTEM=pysupport
+DEB_COMPRESS_EXCLUDE := .py
+
+include /usr/share/cdbs/1/rules/debhelper.mk
+include /usr/share/cdbs/1/class/python-distutils.mk
diff --git a/gnutls-1.1.9/debian/source/format b/gnutls-1.1.9/debian/source/format
new file mode 100644
index 0000000..163aaf8
--- /dev/null
+++ b/gnutls-1.1.9/debian/source/format
@@ -0,0 +1 @@
+3.0 (quilt)
diff --git a/gnutls-1.1.9/debian/watch.ex b/gnutls-1.1.9/debian/watch.ex
new file mode 100644
index 0000000..09ab1ee
--- /dev/null
+++ b/gnutls-1.1.9/debian/watch.ex
@@ -0,0 +1,23 @@
+# Example watch control file for uscan
+# Rename this file to "watch" and then you can run the "uscan" command
+# to check for upstream updates and more.
+# See uscan(1) for format
+
+# Compulsory line, this is a version 3 file
+version=3
+
+# Uncomment to examine a Webpage
+# <Webpage URL> <string match>
+#http://www.example.com/downloads.php python-gnutls-(.*)\.tar\.gz
+
+# Uncomment to examine a Webserver directory
+#http://www.example.com/pub/python-gnutls-(.*)\.tar\.gz
+
+# Uncommment to examine a FTP server
+#ftp://ftp.example.com/pub/python-gnutls-(.*)\.tar\.gz debian uupdate
+
+# Uncomment to find new files on sourceforge, for devscripts >= 2.9
+# http://sf.net/python-gnutls/python-gnutls-(.*)\.tar\.gz
+
+# Uncomment to find new files on GooglePages
+# http://example.googlepages.com/foo.html python-gnutls-(.*)\.tar\.gz
diff --git a/gnutls-1.1.9/examples/README b/gnutls-1.1.9/examples/README
new file mode 100644
index 0000000..343359f
--- /dev/null
+++ b/gnutls-1.1.9/examples/README
@@ -0,0 +1,21 @@
+
+This directory holds some examples of using python-gnutls. 
+
+- An example of writing a synchronous client and server using the
+  ClientSession and ServerSession classes from python-gnutls is
+  given in client.py and server.py
+
+- An example of writing an asynchronous client and server using the
+  python-gnutls twisted interface is given in twisted-client.py and
+  twisted-server.py
+
+- An example of working with X509 certificates and their attributes
+  as well as using a CRL to check their revocation is in crypto.py
+
+
+
+To run the examples without installing python-gnutls, run the following
+command prior to trying the examples (after python-gnutls was built):
+
+export PYTHONPATH=/path/to/python-gnutls
+
diff --git a/gnutls-1.1.9/examples/certs/ca.pem b/gnutls-1.1.9/examples/certs/ca.pem
new file mode 100644
index 0000000..6b81c20
--- /dev/null
+++ b/gnutls-1.1.9/examples/certs/ca.pem
@@ -0,0 +1,42 @@
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
diff --git a/gnutls-1.1.9/examples/certs/crl.pem b/gnutls-1.1.9/examples/certs/crl.pem
new file mode 100644
index 0000000..d1eb221
--- /dev/null
+++ b/gnutls-1.1.9/examples/certs/crl.pem
@@ -0,0 +1,19 @@
+-----BEGIN X509 CRL-----
+MIIDGjCCAQICAQEwDQYJKoZIhvcNAQEFBQAwgasxCzAJBgNVBAYTAk5MMRYwFAYD
+VQQIEw1Ob29yZC1Ib29sYW5kMRAwDgYDVQQHEwdIYWFybGVtMRQwEgYDVQQKEwtB
+RyBQcm9qZWN0czEUMBIGA1UECxMLRGV2ZWxvcG1lbnQxIDAeBgNVBAMTF0FHIFBy
+b2plY3RzIERldmVsb3BtZW50MSQwIgYJKoZIhvcNAQkBFhVkZXZlbEBhZy1wcm9q
+ZWN0cy5jb20XDTA3MDQwMzEyMjMwNFoXDTE3MDMzMTEyMjMwNFowIjAgAgECFw0w
+NzA0MDMxMjIxNTlaMAwwCgYDVR0VBAMKAQEwDQYJKoZIhvcNAQEFBQADggIBAIoF
+8pCAPnWt1kpao/TXkR80/ZOyrdKRAyo+hYejUJw41lxsWey4NUEwbWp9pnCWsL3s
+DMrLt948PRzIqMhI/9zXhl4+ipuuWSTJAb4usMh3CG0vJsexzE1e8SMAnoJdE3Fu
+5M2xCmd8loCaq3/oA05Ovv8Kc1KwTBiJUNQNvVEMhw9Wsn3mrFk2mWNlLa0vnANI
+DlO9HFZJOrw0ipco03ACDxTGGQiNxw6Yjw+OCqMaV3AAE9GvE8VXy3PgeaDgvffM
+9e71+6TC5j6S0S5c8P83NQpAAbYatQh5/McPd8b8o9ailj/rGt1krYxiLSUb12NE
+yy6EmybdLJmat9nvMAlpbxtzdRQdX0E9aDQaK4J388OkMiT6P83ykEKT7qCloEk6
+vkAebqCexA/dqv+7+AsNe+h18iHB+aZxv0xU3NS1Te4X902AUj2n4UGtiOUELMgJ
+leEN8Nh5R9a8/OsXQVLqqeMg6QmTjP3Y1PYNv4GSnJNAYMhEUPz19tC0E5kR4cLQ
+Y7csgROnfo5EX7byeQK1PjSGTMOP5KMgdH1YpxSg43uuTk12ZJEqKYeIXa50KYCA
+6OurC+2fOWQQogRnRlx94lOInfKeTlN7F09sMjBzIA+m9sKahKsZ00rHxuvcjP/e
+ZN+qO9H56VmfcOefMRLRPSPwuwtQdR3udI/QyL4D
+-----END X509 CRL-----
diff --git a/gnutls-1.1.9/examples/certs/revoked.crt b/gnutls-1.1.9/examples/certs/revoked.crt
new file mode 100644
index 0000000..d41bd3a
--- /dev/null
+++ b/gnutls-1.1.9/examples/certs/revoked.crt
@@ -0,0 +1,34 @@
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
diff --git a/gnutls-1.1.9/examples/certs/revoked.key b/gnutls-1.1.9/examples/certs/revoked.key
new file mode 100644
index 0000000..f223826
--- /dev/null
+++ b/gnutls-1.1.9/examples/certs/revoked.key
@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICXgIBAAKBgQD7aTVlguaouWiCLFPBV9lTDha99aNZd9MfQwnHhbKcbs5zuItT
+D0o4IlrE5j660TZ619GVWPj9JDkmOCaRe4d+5oqldelbPv6dr5hmpNwyzVxqMZDy
+x93NBgpOUrC/IeMDEM8LEbse1e5uLCSqqKYAGkPiV6WhP9xA0F+Y0YIZTQIDAQAB
+AoGBANKqwjehjK5tTollo3krp8vUznG2134szhgwEI3EFnrGzvBg/z5GXabUAsNj
+O8VHciNVnSVMPLfCFrFT892MaWffkEYwkyrkX+VUZYlRoMeNE/xT4BzPFchHg1rw
+I8rwFRWZumHB0AhKzg7N015/cxNar2aIKtU5m833NrN9K3vxAkEA/7yFJLsAuPHT
+scqPMXQ0XW/7P74lSFYHtbLOihVr/4myzLqpwuUvL55q1Ixi4AF/UHZ29pLilbDQ
+jQIKfT6K9wJBAPurjBJ8E0unfg+UYhx7/ws718uiDqJ7E0nC37RTOO+qyqZF4687
+B0yOIt/MbwDRUQttArLoNIv+nSs7yvzCiNsCQQDEZWjyzlI9tinXTjItzoowf8E6
+MLK9HKSLG6iWTuFDu+H+bBPXQt67+TMdzDpawYuepXuy3Rb50nI2+CxKBu/9AkEA
+8/SOizyK18M8h42mrUXlLNaNkG8/EHGNeOrWPs6NWoWMezE0TCBEKwl89MQOthQx
+I4pAG3zLswjVAZusYOeSEQJAdHhBRhk8EHgo/rMITeL0sGRH3nT82oPOJIPLDoDQ
+1T8aRVTvTtSsBXSadBw+cwmfgl2Z5GCmAmFoRS6bZqZCHQ==
+-----END RSA PRIVATE KEY-----
diff --git a/gnutls-1.1.9/examples/certs/valid.crt b/gnutls-1.1.9/examples/certs/valid.crt
new file mode 100644
index 0000000..10a3066
--- /dev/null
+++ b/gnutls-1.1.9/examples/certs/valid.crt
@@ -0,0 +1,34 @@
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
diff --git a/gnutls-1.1.9/examples/certs/valid.key b/gnutls-1.1.9/examples/certs/valid.key
new file mode 100644
index 0000000..694caed
--- /dev/null
+++ b/gnutls-1.1.9/examples/certs/valid.key
@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICWwIBAAKBgQCmG/QS3GuCd8rM8kWjAvs7ySoXjrETmBTfcCHPhABTuUVBRBUU
+PwIX8NgJmPtW50uSu7TFfCeeHKByNETqIbJExFysdYhfuuyq3s397X1GNMxj4Uxm
+lydjpEXgJmUL42uCIVsQU0ARatW26Q6TsvwyduJwRICaD01C36hseSFaCQIDAQAB
+AoGAC6qs8uIuXuSBBvIBOBjOgn13il4IS+MDnEno5gVUbIz3s0TP4jMmt32//rSS
++qCWK0EpyjEVK0LBdiP7ryIcviC3EMU33SErqSPdpJN/UOYePn5CX45d30OyDL/J
+1ai4AsQbG9twe5cOJae8ZLa76O4Q82MTxN2agrSoV41lcu0CQQDZID9NbHioGBPE
+cgwzwgTAWXc+sdHKsEJERxCPGyqChuFwFjgTdl0MQms3mclAOUq/23j6XYHkjG7o
+YS3FcBaTAkEAw9lnMKN5kF3/9xxZxmr62qm6RlgvpdgW4zs9m7SVGSq7fio07i4z
+a/5RGC0Tr/WzfjHD1+SyUEXmT1DMl7eycwJAQUX2gdoYM8B5QNdgX7b2IrVCqfBf
+N2XhphEPI1ZxYygVYdLsLL2qn2LgRKjQ3aPbmu3p4qp1wDWPqgB8+BwITQJAP1nA
+fkQy21b8qCM8iukp8bc7MOvvpbarWJ9eA1K7c+OVuG7Qpka9jW47LxXNq3pPsD9K
+uTgZ0ct6fyeEtoLOLwJAM1Eeopu3wSkNbf2p4TbhePc5ASZRR2c1GZZQE4GIYamB
+yEk53aQ5MDpHLffWdWI7vZ449s/AHwrN6txlu/+VTQ==
+-----END RSA PRIVATE KEY-----
diff --git a/gnutls-1.1.9/examples/client.py b/gnutls-1.1.9/examples/client.py
new file mode 100755
index 0000000..c6e4208
--- /dev/null
+++ b/gnutls-1.1.9/examples/client.py
@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+
+"""Synchronous client using python-gnutls"""
+
+import sys
+import os
+import socket
+
+from gnutls.crypto import *
+from gnutls.connection import *
+
+script_path = os.path.realpath(os.path.dirname(sys.argv[0]))
+certs_path = os.path.join(script_path, 'certs')
+
+cert = X509Certificate(open(certs_path + '/valid.crt').read())
+key = X509PrivateKey(open(certs_path + '/valid.key').read())
+ca = X509Certificate(open(certs_path + '/ca.pem').read())
+crl = X509CRL(open(certs_path + '/crl.pem').read())
+cred = X509Credentials(cert, key)
+
+sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+session = ClientSession(sock, cred)
+
+session.connect(('localhost', 10000))
+session.handshake()
+session.send("test\r\n")
+buf = session.recv(1024)
+print 'Received: ', buf.rstrip()
+session.bye()
+session.shutdown()
+session.close()
+
diff --git a/gnutls-1.1.9/examples/crypto.py b/gnutls-1.1.9/examples/crypto.py
new file mode 100755
index 0000000..cbb29c9
--- /dev/null
+++ b/gnutls-1.1.9/examples/crypto.py
@@ -0,0 +1,84 @@
+#!/usr/bin/env python
+
+"""Cryptographic examples using python-gnutls"""
+
+import sys
+import os
+import time
+
+from gnutls.crypto import *
+
+script_path = os.path.realpath(os.path.dirname(sys.argv[0]))
+certs_path = os.path.join(script_path, 'certs')
+
+cert = X509Certificate(open(certs_path + '/valid.crt').read())
+crl = X509CRL(open(certs_path + '/crl.pem').read())
+
+print ''
+
+print 'CRL certs/crl.pem:'
+print '------------------'
+print 'CRL issuer:'
+print '  CN = %s' % crl.issuer.CN # or crl.issuer.common_name
+print '  O  = %s' % crl.issuer.O  # or crl.issuer.organization
+print '  OU = %s' % crl.issuer.OU # or crl.issuer.organization_unit
+print '  C  = %s' % crl.issuer.C  # or crl.issuer.country
+print '  ST = %s' % crl.issuer.ST # or crl.issuer.state
+print '  L  = %s' % crl.issuer.L  # or crl.issuer.locality
+print '  EMAIL = %s' % crl.issuer.EMAIL # or crl.issuer.email
+print 'CRL version:', crl.version
+print 'CRL count:  ', crl.count
+print ''
+
+print 'Certificate certs/valid.crt:'
+print '----------------------------'
+print 'Cert subject:'
+print '  CN = %s' % cert.subject.CN # or cert.subject.common_name
+print '  O  = %s' % cert.subject.O  # or cert.subject.organization
+print '  OU = %s' % cert.subject.OU # or cert.subject.organization_unit
+print '  C  = %s' % cert.subject.C  # or cert.subject.country
+print '  ST = %s' % cert.subject.ST # or cert.subject.state
+print '  L  = %s' % cert.subject.L  # or cert.subject.locality
+print '  EMAIL = %s' % cert.subject.EMAIL # or cert.subject.email
+print 'Cert issuer:'
+print '  CN = %s' % cert.issuer.CN # or cert.issuer.common_name
+print '  O  = %s' % cert.issuer.O  # or cert.issuer.organization
+print '  OU = %s' % cert.issuer.OU # or cert.issuer.organization_unit
+print '  C  = %s' % cert.issuer.C  # or cert.issuer.country
+print '  ST = %s' % cert.issuer.ST # or cert.issuer.state
+print '  L  = %s' % cert.issuer.L  # or cert.issuer.locality
+print '  EMAIL = %s' % cert.issuer.EMAIL # or cert.issuer.email
+print 'Cert serial:    ', cert.serial_number
+print 'Cert version:   ', cert.version
+print 'Cert activation:', time.ctime(cert.activation_time)
+print 'Cert expiration:', time.ctime(cert.expiration_time)
+print 'Cert is revoked:', crl.is_revoked(cert)
+print ''
+
+cert = X509Certificate(open(certs_path + '/revoked.crt').read())
+
+print 'Certificate certs/revoked.crt:'
+print '------------------------------'
+print 'Cert subject:'
+print '  CN = %s' % cert.subject.common_name       # here we use long names
+print '  O  = %s' % cert.subject.organization
+print '  OU = %s' % cert.subject.organization_unit
+print '  C  = %s' % cert.subject.country
+print '  ST = %s' % cert.subject.state
+print '  L  = %s' % cert.subject.locality
+print '  EMAIL = %s' % cert.subject.email
+print 'Cert issuer:'
+print '  CN = %s' % cert.issuer.common_name
+print '  O  = %s' % cert.issuer.organization
+print '  OU = %s' % cert.issuer.organization_unit
+print '  C  = %s' % cert.issuer.country
+print '  ST = %s' % cert.issuer.state
+print '  L  = %s' % cert.issuer.locality
+print '  EMAIL = %s' % cert.issuer.email
+print 'Cert serial:    ', cert.serial_number
+print 'Cert version:   ', cert.version
+print 'Cert activation:', time.ctime(cert.activation_time)
+print 'Cert expiration:', time.ctime(cert.expiration_time)
+print 'Cert is revoked:', crl.is_revoked(cert)
+print ''
+
diff --git a/gnutls-1.1.9/examples/server.py b/gnutls-1.1.9/examples/server.py
new file mode 100755
index 0000000..e7d744d
--- /dev/null
+++ b/gnutls-1.1.9/examples/server.py
@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+
+"""Synchronous server using python-gnutls"""
+
+import sys
+import os
+import socket
+
+from gnutls.crypto import *
+from gnutls.connection import *
+
+script_path = os.path.realpath(os.path.dirname(sys.argv[0]))
+certs_path = os.path.join(script_path, 'certs')
+
+cert = X509Certificate(open(certs_path + '/valid.crt').read())
+key = X509PrivateKey(open(certs_path + '/valid.key').read())
+ca = X509Certificate(open(certs_path + '/ca.pem').read())
+crl = X509CRL(open(certs_path + '/crl.pem').read())
+cred = X509Credentials(cert, key, [ca], [crl])
+
+sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+ssf = ServerSessionFactory(sock, cred)
+ssf.bind(('0.0.0.0', 10000))
+ssf.listen(100)
+
+while True:
+    session, address = ssf.accept()
+    try:
+        session.handshake()
+        peer_cert = session.peer_certificate
+        try:
+            peer_name = peer_cert.subject
+        except AttributeError:
+            peer_name = 'Unknown'
+        print '\nNew connection from:', peer_name
+        print 'Protocol:     ', session.protocol
+        print 'KX algorithm: ', session.kx_algorithm
+        print 'Cipher:       ', session.cipher
+        print 'MAC algorithm:', session.mac_algorithm
+        print 'Compression:  ', session.compression
+        session.verify_peer()
+        cred.check_certificate(peer_cert, cert_name='peer certificate')
+    except Exception, e:
+        print 'Handshake failed:', e
+        session.bye()
+    else:
+        while True:
+            try:
+                buf = session.recv(1024)
+                if buf == 0 or buf == '':
+                    print "Peer has closed the session"
+                    break
+                else:
+                    if buf.strip().lower() == 'quit':
+                        print "Got quit command, closing connection"
+                        session.bye()
+                        break
+                session.send(buf)
+            except Exception, e:
+                print "Error in reception: ", e
+                break
+    session.shutdown()
+    session.close()
diff --git a/gnutls-1.1.9/examples/twisted-client.py b/gnutls-1.1.9/examples/twisted-client.py
new file mode 100755
index 0000000..0bcb8ca
--- /dev/null
+++ b/gnutls-1.1.9/examples/twisted-client.py
@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+
+"""Asynchronous client using Twisted with GNUTLS"""
+
+import sys
+import os
+
+from twisted.internet.protocol import ClientFactory
+from twisted.protocols.basic import LineOnlyReceiver
+from twisted.internet import reactor
+
+from gnutls.constants import *
+from gnutls.crypto import *
+from gnutls.errors import *
+from gnutls.interfaces.twisted import X509Credentials
+
+class EchoProtocol(LineOnlyReceiver):
+
+    def connectionMade(self):
+        self.sendLine('echo')
+
+    def lineReceived(self, line):
+        print 'received: ', line
+        self.transport.loseConnection()
+
+    def connectionLost(self, reason):
+        reactor.stop()
+
+class EchoFactory(ClientFactory):
+    protocol = EchoProtocol
+
+    def clientConnectionFailed(self, connector, err):
+        print err.value
+        reactor.stop()
+
+
+script_path = os.path.realpath(os.path.dirname(sys.argv[0]))
+certs_path = os.path.join(script_path, 'certs')
+
+cert = X509Certificate(open(certs_path + '/valid.crt').read())
+key = X509PrivateKey(open(certs_path + '/valid.key').read())
+ca = X509Certificate(open(certs_path + '/ca.pem').read())
+crl = X509CRL(open(certs_path + '/crl.pem').read())
+cred = X509Credentials(cert, key, [ca])
+cred.verify_peer = True
+
+reactor.connectTLS('localhost', 10000, EchoFactory(), cred)
+reactor.run()
+
diff --git a/gnutls-1.1.9/examples/twisted-server.py b/gnutls-1.1.9/examples/twisted-server.py
new file mode 100755
index 0000000..67e14e6
--- /dev/null
+++ b/gnutls-1.1.9/examples/twisted-server.py
@@ -0,0 +1,59 @@
+#!/usr/bin/env python
+
+"""Asynchronous server using Twisted with GNUTLS"""
+
+import sys
+import os
+
+from twisted.internet.protocol import Factory
+from twisted.protocols.basic import LineOnlyReceiver
+from twisted.internet.error import CannotListenError, ConnectionDone
+from twisted.internet import reactor
+
+from gnutls.constants import *
+from gnutls.crypto import *
+from gnutls.errors import *
+from gnutls.interfaces.twisted import X509Credentials
+
+class EchoProtocol(LineOnlyReceiver):
+
+    def connectionMade(self):
+        session = self.transport.socket
+        try:
+            peer_name = session.peer_certificate.subject
+        except AttributeError:
+            peer_name = 'Unknown'
+        print '\nNew connection from:', peer_name
+        print 'Protocol:     ', session.protocol
+        print 'KX algorithm: ', session.kx_algorithm
+        print 'Cipher:       ', session.cipher
+        print 'MAC algorithm:', session.mac_algorithm
+        print 'Compression:  ', session.compression
+
+    def lineReceived(self, line):
+        if line == 'quit':
+            self.transport.loseConnection()
+            return
+        self.sendLine(line)
+
+    def connectionLost(self, reason):
+        if reason.type != ConnectionDone:
+            print "Connection was lost:", str(reason.value)
+
+class EchoFactory(Factory):
+    protocol = EchoProtocol
+
+script_path = os.path.realpath(os.path.dirname(sys.argv[0]))
+certs_path = os.path.join(script_path, 'certs')
+
+cert = X509Certificate(open(certs_path + '/valid.crt').read())
+key = X509PrivateKey(open(certs_path + '/valid.key').read())
+ca = X509Certificate(open(certs_path + '/ca.pem').read())
+crl = X509CRL(open(certs_path + '/crl.pem').read())
+cred = X509Credentials(cert, key, [ca], [crl])
+cred.verify_peer = True
+cred.session_params.compressions = (COMP_LZO, COMP_DEFLATE, COMP_NULL)
+
+reactor.listenTLS(10000, EchoFactory(), cred)
+reactor.run()
+
diff --git a/gnutls-1.1.9/gnutls/__init__.py b/gnutls-1.1.9/gnutls/__init__.py
new file mode 100644
index 0000000..c72f309
--- /dev/null
+++ b/gnutls-1.1.9/gnutls/__init__.py
@@ -0,0 +1,5 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+__version__ = '1.1.9'
+
diff --git a/gnutls-1.1.9/gnutls/__init__.pyc b/gnutls-1.1.9/gnutls/__init__.pyc
new file mode 100644
index 0000000..f675015
--- /dev/null
+++ b/gnutls-1.1.9/gnutls/__init__.pyc
diff --git a/gnutls-1.1.9/gnutls/connection.py b/gnutls-1.1.9/gnutls/connection.py
new file mode 100644
index 0000000..5990bd4
--- /dev/null
+++ b/gnutls-1.1.9/gnutls/connection.py
@@ -0,0 +1,500 @@
+# Copyright (C) 2007-2008 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS connection support"""
+
+__all__ = ['X509Credentials', 'ClientSession', 'ServerSession', 'ServerSessionFactory']
+
+from time import time
+from socket import SHUT_RDWR as SOCKET_SHUT_RDWR
+
+from _ctypes import PyObj_FromPtr
+from ctypes import *
+
+from gnutls.validators import *
+from gnutls.constants import *
+from gnutls.crypto import *
+from gnutls.errors import *
+
+from gnutls.library.constants import GNUTLS_SERVER, GNUTLS_CLIENT, GNUTLS_CRT_X509
+from gnutls.library.constants import GNUTLS_CERT_INVALID, GNUTLS_CERT_REVOKED, GNUTLS_CERT_INSECURE_ALGORITHM
+from gnutls.library.constants import GNUTLS_CERT_SIGNER_NOT_FOUND, GNUTLS_CERT_SIGNER_NOT_CA
+from gnutls.library.constants import GNUTLS_AL_FATAL, GNUTLS_A_BAD_CERTIFICATE
+from gnutls.library.constants import GNUTLS_A_UNKNOWN_CA, GNUTLS_A_INSUFFICIENT_SECURITY
+from gnutls.library.constants import GNUTLS_A_CERTIFICATE_EXPIRED, GNUTLS_A_CERTIFICATE_REVOKED
+from gnutls.library.constants import GNUTLS_NAME_DNS
+from gnutls.library.types     import gnutls_certificate_credentials_t, gnutls_session_t, gnutls_x509_crt_t
+from gnutls.library.types     import gnutls_certificate_server_retrieve_function
+from gnutls.library.functions import *
+
+
+@gnutls_certificate_server_retrieve_function
+def _retrieve_server_certificate(c_session, retr_st):
+    session = PyObj_FromPtr(gnutls_session_get_ptr(c_session))
+    identity = session.credentials.select_server_identity(session)
+    retr_st.contents.type = GNUTLS_CRT_X509
+    retr_st.contents.deinit_all = 0
+    if identity is None:
+        retr_st.contents.ncerts = 0
+    else:
+        retr_st.contents.ncerts = 1
+        retr_st.contents.cert.x509.contents = identity.cert._c_object
+        retr_st.contents.key.x509 = identity.key._c_object
+    return 0
+
+
+class _ServerNameIdentities(dict):
+    """Used internally by X509Credentials to map server names to X509 identities for the server name extension"""
+    def __init__(self, identities):
+        dict.__init__(self)
+        for identity in identities:
+            self.add(identity)
+    def add(self, identity):
+        for name in identity.cert.alternative_names.dns:
+            self[name.lower()] = identity
+        for ip in identity.cert.alternative_names.ip:
+            self[ip] = identity
+        subject = identity.cert.subject
+        if subject.CN is not None:
+            self[subject.CN.lower()] = identity
+    def get(self, server_name, default=None):
+        server_name = server_name.lower()
+        if server_name in self:
+            return self[server_name]
+        for name in (n for n in self if n.startswith('*.')):
+            suffix = name[1:]
+            if server_name.endswith(suffix) and '.' not in server_name[:-len(suffix)]:
+                return self[name]
+        return default
+
+
+class X509Credentials(object):
+    DH_BITS  = 1024
+    RSA_BITS = 1024
+
+    dh_params  = None
+    rsa_params = None
+
+    def __new__(cls, *args, **kwargs):
+        c_object = gnutls_certificate_credentials_t()
+        gnutls_certificate_allocate_credentials(byref(c_object))
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_certificate_free_credentials
+        instance._c_object = c_object
+        return instance
+
+    @method_args((X509Certificate, none), (X509PrivateKey, none), list_of(X509Certificate), list_of(X509CRL), list_of(X509Identity))
+    def __init__(self, cert=None, key=None, trusted=[], crl_list=[], identities=[]):
+        """Credentials contain a X509 certificate, a private key, a list of trusted CAs and a list of CRLs (all optional).
+        An optional list of additional X509 identities can be specified for applications that need more that one identity"""
+        if cert and key:
+            gnutls_certificate_set_x509_key(self._c_object, byref(cert._c_object), 1, key._c_object)
+        elif (cert, key) != (None, None):
+            raise ValueError("Specify neither or both the certificate and private key")
+        gnutls_certificate_server_set_retrieve_function(self._c_object, _retrieve_server_certificate)
+        self._max_depth = 5
+        self._max_bits  = 8200
+        self._type = CRED_CERTIFICATE
+        self._cert = cert
+        self._key = key
+        self._identities = tuple(identities)
+        self._trusted = ()
+        self.add_trusted(trusted)
+        self.crl_list = crl_list
+        self.server_name_identities = _ServerNameIdentities(identities)
+        if cert and key:
+            self.server_name_identities.add(X509Identity(cert, key))
+        self.session_params = SessionParams(self._type)
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
+    # Methods to alter the credentials at runtime
+
+    @method_args(list_of(X509Certificate))
+    def add_trusted(self, trusted):
+        size = len(trusted)
+        if size > 0:
+            ca_list = (gnutls_x509_crt_t * size)(*[cert._c_object for cert in trusted])
+            gnutls_certificate_set_x509_trust(self._c_object, cast(byref(ca_list), POINTER(gnutls_x509_crt_t)), size)
+            self._trusted = self._trusted + tuple(trusted)
+
+    def generate_dh_params(self, bits=DH_BITS):
+        reference = self.dh_params ## keep a reference to preserve it until replaced
+        X509Credentials.dh_params  = DHParams(bits)
+        del reference
+
+    def generate_rsa_params(self, bits=RSA_BITS):
+        reference = self.rsa_params ## keep a reference to preserve it until replaced
+        X509Credentials.rsa_params = RSAParams(bits)
+        del reference
+
+    # Properties
+
+    @property
+    def cert(self):
+        return self._cert
+
+    @property
+    def key(self):
+        return self._key
+
+    @property
+    def identities(self):
+        return self._identities
+
+    @property
+    def trusted(self):
+        return self._trusted
+
+    def _get_crl_list(self):
+        return self._crl_list
+    @method_args(list_of(X509CRL)) 
+    def _set_crl_list(self, crl_list):
+        self._crl_list = tuple(crl_list)
+    crl_list = property(_get_crl_list, _set_crl_list)
+    del _get_crl_list, _set_crl_list
+
+    def _get_max_verify_length(self):
+        return self._max_depth
+    @method_args(int) 
+    def _set_max_verify_length(self, max_depth):
+        gnutls_certificate_set_verify_limits(self._c_object, self._max_bits, max_depth)
+        self._max_depth = max_depth
+    max_verify_length = property(_get_max_verify_length, _set_max_verify_length)
+    del _get_max_verify_length, _set_max_verify_length
+
+    def _get_max_verify_bits(self):
+        return self._max_bits
+    @method_args(int) 
+    def _set_max_verify_bits(self, max_bits):
+        gnutls_certificate_set_verify_limits(self._c_object, max_bits, self._max_depth)
+        self._max_bits = max_bits
+    max_verify_bits = property(_get_max_verify_bits, _set_max_verify_bits)
+    del _get_max_verify_bits, _set_max_verify_bits
+
+    # Methods to select and validate certificates
+
+    def check_certificate(self, cert, cert_name='certificate'):
+        """Verify activation, expiration and revocation for the given certificate"""
+        now = time()
+        if cert.activation_time > now:
+            raise CertificateExpiredError("%s is not yet activated" % cert_name)
+        if cert.expiration_time < now:
+            raise CertificateExpiredError("%s has expired" % cert_name)
+        for crl in self.crl_list:
+            crl.check_revocation(cert, cert_name=cert_name)
+
+    def select_server_identity(self, session):
+        """Select which identity the server will use for a given session. The default selection algorithm uses
+        the server name extension. A subclass can overwrite it if a different selection algorithm is desired."""
+        server_name = session.server_name
+        if server_name is not None:
+            return self.server_name_identities.get(server_name)
+        elif self.cert and self.key:
+            return self ## since we have the cert and key attributes we can behave like a X509Identity
+        else:
+            return None
+
+
+class SessionParams(object):
+    _default_kx_algorithms = {
+        CRED_CERTIFICATE: (KX_RSA, KX_DHE_DSS, KX_DHE_RSA),
+        CRED_ANON: (KX_ANON_DH,)}
+    _all_kx_algorithms = {
+        CRED_CERTIFICATE: set((KX_RSA, KX_DHE_DSS, KX_DHE_RSA, KX_RSA_EXPORT)),
+        CRED_ANON: set((KX_ANON_DH,))}
+
+    def __new__(cls, credentials_type):
+        if credentials_type not in cls._default_kx_algorithms:
+            raise TypeError("Unknown credentials type: %r" % credentials_type)
+        return object.__new__(cls)
+
+    def __init__(self, credentials_type):
+        self._credentials_type = credentials_type
+        self._protocols = (PROTO_TLS1_1, PROTO_TLS1_0, PROTO_SSL3)
+        self._kx_algorithms = self._default_kx_algorithms[credentials_type]
+        self._ciphers = (CIPHER_AES_128_CBC, CIPHER_3DES_CBC, CIPHER_ARCFOUR_128)
+        self._mac_algorithms = (MAC_SHA1, MAC_MD5, MAC_RMD160)
+        self._compressions = (COMP_NULL,)
+
+    def _get_protocols(self):
+        return self._protocols
+    def _set_protocols(self, protocols):
+        self._protocols = ProtocolListValidator(protocols)
+    protocols = property(_get_protocols, _set_protocols)
+    del _get_protocols, _set_protocols
+
+    def _get_kx_algorithms(self):
+        return self._kx_algorithms
+    def _set_kx_algorithms(self, algorithms):
+        cred_type = self._credentials_type
+        algorithms = KeyExchangeListValidator(algorithms)
+        invalid = set(algorithms) - self._all_kx_algorithms[cred_type]
+        if invalid:
+            raise ValueError("Cannot specify %r with %r credentials" % (list(invalid), cred_type))
+        self._kx_algorithms = algorithms
+    kx_algorithms = property(_get_kx_algorithms, _set_kx_algorithms)
+    del _get_kx_algorithms, _set_kx_algorithms
+
+    def _get_ciphers(self):
+        return self._ciphers
+    def _set_ciphers(self, ciphers):
+        self._ciphers = CipherListValidator(ciphers)
+    ciphers = property(_get_ciphers, _set_ciphers)
+    del _get_ciphers, _set_ciphers
+
+    def _get_mac_algorithms(self):
+        return self._mac_algorithms
+    def _set_mac_algorithms(self, algorithms):
+        self._mac_algorithms = MACListValidator(algorithms)
+    mac_algorithms = property(_get_mac_algorithms, _set_mac_algorithms)
+    del _get_mac_algorithms, _set_mac_algorithms
+
+    def _get_compressions(self):
+        return self._compressions
+    def _set_compressions(self, compressions):
+        self._compressions = CompressionListValidator(compressions)
+    compressions = property(_get_compressions, _set_compressions)
+    del _get_compressions, _set_compressions
+
+
+class Session(object):
+    """Abstract class representing a TLS session created from a TCP socket
+       and a Credentials object."""
+
+    session_type = None ## placeholder for GNUTLS_SERVER or GNUTLS_CLIENT as defined by subclass
+
+    def __new__(cls, *args, **kwargs):
+        if cls is Session:
+            raise RuntimeError("Session cannot be instantiated directly")
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_deinit
+        instance._c_object = gnutls_session_t()
+        return instance
+
+    def __init__(self, socket, credentials):
+        gnutls_init(byref(self._c_object), self.session_type)
+        ## Store a pointer to self on the C session
+        gnutls_session_set_ptr(self._c_object, id(self))
+        # gnutls_dh_set_prime_bits(session, DH_BITS)?
+        gnutls_transport_set_ptr(self._c_object, socket.fileno())
+        gnutls_handshake_set_private_extensions(self._c_object, 1)
+        self.socket = socket
+        self.credentials = credentials
+        self._update_params()
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
+    def __getattr__(self, name):
+        ## Generic wrapper for the underlying socket methods and attributes.
+        return getattr(self.socket, name)
+
+    # Session properties
+
+    def _get_credentials(self):
+        return self._credentials
+    @method_args(X509Credentials)
+    def _set_credentials(self, credentials):
+        ## Release all credentials, otherwise gnutls will only release an existing credential of
+        ## the same type as the one being set and we can end up with multiple credentials in C.
+        gnutls_credentials_clear(self._c_object)
+        gnutls_credentials_set(self._c_object, credentials._type, cast(credentials._c_object, c_void_p))
+        self._credentials = credentials
+    credentials = property(_get_credentials, _set_credentials)
+    del _get_credentials, _set_credentials
+
+    @property
+    def protocol(self):
+        return gnutls_protocol_get_name(gnutls_protocol_get_version(self._c_object))
+
+    @property
+    def kx_algorithm(self):
+        return gnutls_kx_get_name(gnutls_kx_get(self._c_object))
+
+    @property
+    def cipher(self):
+        return gnutls_cipher_get_name(gnutls_cipher_get(self._c_object))
+
+    @property
+    def mac_algorithm(self):
+        return gnutls_mac_get_name(gnutls_mac_get(self._c_object))
+
+    @property
+    def compression(self):
+        return gnutls_compression_get_name(gnutls_compression_get(self._c_object))
+
+    @property
+    def peer_certificate(self):
+        if gnutls_certificate_type_get(self._c_object) != GNUTLS_CRT_X509:
+            return None
+        list_size = c_uint()
+        cert_list = gnutls_certificate_get_peers(self._c_object, byref(list_size))
+        if list_size.value == 0:
+            return None
+        cert = cert_list[0]
+        return X509Certificate(string_at(cert.data, cert.size), X509_FMT_DER)
+
+    # Status checking after an operation was interrupted (these properties are
+    # only useful to check after an operation was interrupted, otherwise their
+    # value is meaningless).
+
+    @property
+    def interrupted_while_writing(self):
+        """True if an operation was interrupted while writing"""
+        return gnutls_record_get_direction(self._c_object)==1
+
+    @property
+    def interrupted_while_reading(self):
+        """True if an operation was interrupted while reading"""
+        return gnutls_record_get_direction(self._c_object)==0
+
+    # Session methods
+
+    def _update_params(self):
+        """Update the priorities of the session params using the credentials."""
+        def c_priority_list(priorities):
+            size = len(priorities) + 1
+            return (c_int * size)(*priorities)
+        session_params = self.credentials.session_params
+        # protocol order in the priority list is irrelevant (it always uses newer protocols first)
+        # the protocol list only specifies what protocols are to be enabled.
+        gnutls_protocol_set_priority(self._c_object, c_priority_list(session_params.protocols))
+        gnutls_kx_set_priority(self._c_object, c_priority_list(session_params.kx_algorithms))
+        gnutls_cipher_set_priority(self._c_object, c_priority_list(session_params.ciphers))
+        gnutls_mac_set_priority(self._c_object, c_priority_list(session_params.mac_algorithms))
+        gnutls_compression_set_priority(self._c_object, c_priority_list(session_params.compressions))
+
+    def handshake(self):
+        gnutls_handshake(self._c_object)
+
+    #@method_args((basestring, buffer))
+    def send(self, data):
+        data = str(data)
+        return gnutls_record_send(self._c_object, data, len(data))
+
+    def sendall(self, data):
+        size = len(data)
+        while size > 0:
+            sent = self.send(data[-size:])
+            size -= sent
+
+    def recv(self, limit):
+        data = create_string_buffer(limit)
+        size = gnutls_record_recv(self._c_object, data, limit)
+        return data[:size]
+
+    def send_alert(self, exception):
+        alertdict = {
+            CertificateError: GNUTLS_A_BAD_CERTIFICATE,
+            CertificateAuthorityError: GNUTLS_A_UNKNOWN_CA,
+            CertificateSecurityError: GNUTLS_A_INSUFFICIENT_SECURITY,
+            CertificateExpiredError: GNUTLS_A_CERTIFICATE_EXPIRED,
+            CertificateRevokedError: GNUTLS_A_CERTIFICATE_REVOKED}
+        alert = alertdict.get(exception.__class__)
+        if alert:
+            gnutls_alert_send(self._c_object, GNUTLS_AL_FATAL, alert)
+
+    @method_args(one_of(SHUT_RDWR, SHUT_WR))
+    def bye(self, how=SHUT_RDWR):
+        gnutls_bye(self._c_object, how)
+
+    def shutdown(self, how=SOCKET_SHUT_RDWR):
+        self.socket.shutdown(how)
+
+    def close(self):
+        self.socket.close()
+
+    def verify_peer(self):
+        status = c_uint()
+        gnutls_certificate_verify_peers2(self._c_object, byref(status))
+        status = status.value
+        if status & GNUTLS_CERT_INVALID:
+            raise CertificateError("peer certificate is invalid")
+        elif status & GNUTLS_CERT_SIGNER_NOT_FOUND:
+            raise CertificateAuthorityError("peer certificate signer not found")
+        elif status & GNUTLS_CERT_SIGNER_NOT_CA:
+            raise CertificateAuthorityError("peer certificate signer is not a CA")
+        elif status & GNUTLS_CERT_INSECURE_ALGORITHM:
+            raise CertificateSecurityError("peer certificate uses an insecure algorithm")
+        elif status & GNUTLS_CERT_REVOKED:
+            raise CertificateRevokedError("peer certificate was revoked")
+
+
+class ClientSession(Session):
+    session_type = GNUTLS_CLIENT
+
+    def __init__(self, socket, credentials, server_name=None):
+        Session.__init__(self, socket, credentials)
+        self._server_name = None
+        if server_name is not None:
+            self.server_name = server_name
+
+    def _get_server_name(self):
+        return self._server_name
+    @method_args(str)
+    def _set_server_name(self, server_name):
+        gnutls_server_name_set(self._c_object, GNUTLS_NAME_DNS, c_char_p(server_name), len(server_name))
+        self._server_name = server_name
+    server_name = property(_get_server_name, _set_server_name)
+    del _get_server_name, _set_server_name
+
+
+class ServerSession(Session):
+    session_type = GNUTLS_SERVER
+
+    def __init__(self, socket, credentials):
+        Session.__init__(self, socket, credentials)
+        gnutls_certificate_server_set_request(self._c_object, CERT_REQUEST)
+
+    @property
+    def server_name(self):
+        data_length = c_size_t(256)
+        data = create_string_buffer(data_length.value)
+        hostname_type = c_uint()
+        for i in xrange(2**16):
+            try:
+                gnutls_server_name_get(self._c_object, data, byref(data_length), byref(hostname_type), i)
+            except RequestedDataNotAvailable:
+                break
+            except MemoryError:
+                data_length.value += 1 ## one extra byte for the terminating 0
+                data = create_string_buffer(data_length.value)
+                gnutls_server_name_get(self._c_object, data, byref(data_length), byref(hostname_type), i)
+            if hostname_type.value != GNUTLS_NAME_DNS:
+                continue
+            return data.value
+        return None
+
+
+class ServerSessionFactory(object):
+
+    def __init__(self, socket, credentials, session_class=ServerSession):
+        if not issubclass(session_class, ServerSession):
+            raise TypeError, "session_class must be a subclass of ServerSession"
+        self.socket = socket
+        self.credentials = credentials
+        self.session_class = session_class
+
+    def __getattr__(self, name):
+        ## Generic wrapper for the underlying socket methods and attributes
+        return getattr(self.socket, name)
+
+    def bind(self, address):
+        self.socket.bind(address)
+
+    def listen(self, backlog):
+        self.socket.listen(backlog)
+
+    def accept(self):
+        new_sock, address = self.socket.accept()
+        session = self.session_class(new_sock, self.credentials)
+        return (session, address)
+
+    def shutdown(self, how=SOCKET_SHUT_RDWR):
+        self.socket.shutdown(how)
+
+    def close(self):
+        self.socket.close()
+
diff --git a/gnutls-1.1.9/gnutls/constants.py b/gnutls-1.1.9/gnutls/constants.py
new file mode 100644
index 0000000..4637a16
--- /dev/null
+++ b/gnutls-1.1.9/gnutls/constants.py
@@ -0,0 +1,54 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS constants"""
+
+__all__ = [
+    ## GNUTLS session protocols
+    'PROTO_TLS1_1', 'PROTO_TLS1_0', 'PROTO_SSL3',
+    
+    ## Key exchange algorithms
+    'KX_RSA', 'KX_DHE_DSS', 'KX_DHE_RSA', 'KX_RSA_EXPORT', 'KX_ANON_DH',
+    
+    ## Ciphers
+    'CIPHER_AES_128_CBC', 'CIPHER_3DES_CBC', 'CIPHER_ARCFOUR_128', 'CIPHER_AES_256_CBC', 'CIPHER_DES_CBC',
+    
+    ## MAC algorithms
+    'MAC_SHA1', 'MAC_MD5', 'MAC_RMD160',
+    
+    ## Compressions
+    'COMP_DEFLATE', 'COMP_LZO', 'COMP_NULL',
+
+    ## Credential types
+    'CRED_CERTIFICATE', 'CRED_ANON',
+
+    ## X509 certificate/private key formats
+    'X509_FMT_DER', 'X509_FMT_PEM',
+
+    ## Miscellaneous
+    'CERT_REQUEST', 'CERT_REQUIRE', 'SHUT_RDWR', 'SHUT_WR'
+]
+
+__name_map__ = {
+    'PROTO_TLS1_1': 'TLS1_1', 'PROTO_TLS1_0': 'TLS1_0', 'PROTO_SSL3': 'SSL3',
+    'CRED_CERTIFICATE': 'CRD_CERTIFICATE', 'CRED_ANON': 'CRD_ANON'
+}
+
+
+from gnutls.library import constants
+
+class GNUTLSConstant(int):
+    def __new__(cls, name):
+        gnutls_name = 'GNUTLS_' + __name_map__.get(name, name)
+        instance = int.__new__(cls, getattr(constants, gnutls_name))
+        instance.name = name
+        return instance
+    def __repr__(self):
+        return self.name
+
+## Generate all exported constants
+code = '\n'.join(["%s = GNUTLSConstant('%s')" % (name, name) for name in __all__])
+exec code in locals(), globals()
+del code, name
+
+del constants
diff --git a/gnutls-1.1.9/gnutls/crypto.py b/gnutls-1.1.9/gnutls/crypto.py
new file mode 100644
index 0000000..d330144
--- /dev/null
+++ b/gnutls-1.1.9/gnutls/crypto.py
@@ -0,0 +1,317 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS crypto support"""
+
+__all__ = ['X509Name', 'X509Certificate', 'X509PrivateKey', 'X509Identity', 'X509CRL', 'DHParams', 'RSAParams']
+
+import re
+from ctypes import *
+
+from gnutls.validators import method_args, one_of
+from gnutls.constants import X509_FMT_DER, X509_FMT_PEM
+from gnutls.errors import *
+
+from gnutls.library.constants import GNUTLS_SAN_DNSNAME, GNUTLS_SAN_RFC822NAME, GNUTLS_SAN_URI
+from gnutls.library.constants import GNUTLS_SAN_IPADDRESS, GNUTLS_SAN_OTHERNAME, GNUTLS_SAN_DN
+from gnutls.library.constants import GNUTLS_E_SHORT_MEMORY_BUFFER
+from gnutls.library.types     import *
+from gnutls.library.functions import *
+
+
+class X509NameMeta(type):
+    long_names = {'country': 'C',
+                  'state': 'ST',
+                  'locality': 'L',
+                  'common_name': 'CN',
+                  'organization': 'O',
+                  'organization_unit': 'OU',
+                  'email': 'EMAIL'}
+    def __new__(cls, name, bases, dic):
+        instance = type.__new__(cls, name, bases, dic)
+        instance.ids = X509NameMeta.long_names.values()
+        for long_name, short_name in X509NameMeta.long_names.items():
+            ## Map a long_name property to the short_name attribute
+            cls.add_property(instance, long_name, short_name)
+        return instance
+    def add_property(instance, name, short_name):
+        setattr(instance, name, property(lambda self: getattr(self, short_name, None)))
+
+
+class X509Name(str):
+    __metaclass__ = X509NameMeta
+
+    def __init__(self, dname):
+        str.__init__(self)
+        pairs = [x.replace('\,', ',') for x in re.split(r'(?<!\\),\s*', dname)]
+        for pair in pairs:
+            try:
+                name, value = pair.split('=', 1)
+            except ValueError:
+                raise ValueError("Invalid X509 distinguished name: %s" % dname)
+            str.__setattr__(self, name, value)
+        for name in X509Name.ids:
+            if not hasattr(self, name):
+                str.__setattr__(self, name, None)
+    def __setattr__(self, name, value):
+        if name in X509Name.ids:
+            raise AttributeError("can't set attribute")
+        str.__setattr__(self, name, value)
+
+
+class AlternativeNames(object):
+    __slots__ = {'dns': GNUTLS_SAN_DNSNAME, 'email': GNUTLS_SAN_RFC822NAME, 'uri': GNUTLS_SAN_URI,
+                 'ip': GNUTLS_SAN_IPADDRESS, 'other': GNUTLS_SAN_OTHERNAME, 'dn': GNUTLS_SAN_DN}
+    def __init__(self, names):
+        object.__init__(self)
+        for name, key in self.__slots__.iteritems():
+            setattr(self, name, tuple(names.get(key, ())))
+
+
+class X509Certificate(object):
+
+    def __new__(cls, *args, **kwargs):
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_x509_crt_deinit
+        instance._c_object = gnutls_x509_crt_t()
+        instance._alternative_names = None
+        return instance
+
+    @method_args(str, one_of(X509_FMT_PEM, X509_FMT_DER))
+    def __init__(self, buf, format=X509_FMT_PEM):
+        gnutls_x509_crt_init(byref(self._c_object))
+        data = gnutls_datum_t(cast(c_char_p(buf), POINTER(c_ubyte)), c_uint(len(buf)))
+        gnutls_x509_crt_import(self._c_object, byref(data), format)
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
+    @property
+    def subject(self):
+        size = c_size_t(256)
+        dname = create_string_buffer(size.value)
+        try:
+            gnutls_x509_crt_get_dn(self._c_object, dname, byref(size))
+        except MemoryError:
+            dname = create_string_buffer(size.value)
+            gnutls_x509_crt_get_dn(self._c_object, dname, byref(size))
+        return X509Name(dname.value)
+
+    @property
+    def issuer(self):
+        size = c_size_t(256)
+        dname = create_string_buffer(size.value)
+        try:
+            gnutls_x509_crt_get_issuer_dn(self._c_object, dname, byref(size))
+        except MemoryError:
+            dname = create_string_buffer(size.value)
+            gnutls_x509_crt_get_issuer_dn(self._c_object, dname, byref(size))
+        return X509Name(dname.value)
+
+    @property
+    def alternative_names(self):
+        if self._alternative_names is not None:
+            return self._alternative_names
+        names = {}
+        size = c_size_t(256)
+        alt_name = create_string_buffer(size.value)
+        for i in xrange(65536):
+            try:
+                name_type = gnutls_x509_crt_get_subject_alt_name(self._c_object, i, alt_name, byref(size), None)
+            except RequestedDataNotAvailable:
+                break
+            except MemoryError:
+                alt_name = create_string_buffer(size.value)
+                name_type = gnutls_x509_crt_get_subject_alt_name(self._c_object, i, alt_name, byref(size), None)
+            names.setdefault(name_type, []).append(alt_name.value)
+        self._alternative_names = AlternativeNames(names)
+        return self._alternative_names
+
+    @property
+    def serial_number(self):
+        size = c_size_t(1)
+        serial = c_ulong()
+        try:
+            gnutls_x509_crt_get_serial(self._c_object, cast(byref(serial), c_void_p), byref(size))
+        except MemoryError:
+            import struct, sys
+            serial = create_string_buffer(size.value * sizeof(c_void_p))
+            gnutls_x509_crt_get_serial(self._c_object, cast(serial, c_void_p), byref(size))
+            pad = size.value * sizeof(c_void_p) - len(serial.value)
+            format = '@%dL' % size.value
+            numbers = list(struct.unpack(format, serial.value + pad*'\x00'))
+            if sys.byteorder == 'little':
+                numbers.reverse()
+            number = 0
+            offset = sizeof(c_void_p) * 8
+            for n in numbers:
+                number = (number<<offset) + n
+            return number
+        else:
+            return serial.value
+
+    @property
+    def activation_time(self):
+        return gnutls_x509_crt_get_activation_time(self._c_object)
+
+    @property
+    def expiration_time(self):
+        return gnutls_x509_crt_get_expiration_time(self._c_object)
+
+    @property
+    def version(self):
+        return gnutls_x509_crt_get_version(self._c_object)
+
+    #@method_args(X509Certificate)
+    def has_issuer(self, issuer):
+        """Return True if the certificate was issued by the given issuer, False otherwise."""
+        if not isinstance(issuer, X509Certificate):
+            raise TypeError("issuer must be an X509Certificate object")
+        return bool(gnutls_x509_crt_check_issuer(self._c_object, issuer._c_object))
+
+    @method_args(str)
+    def has_hostname(self, hostname):
+        """Return True if the hostname matches the DNSName/IPAddress subject alternative name extension
+           of this certificate, False otherwise."""
+        ## For details see http://www.ietf.org/rfc/rfc2459.txt, section 4.2.1.7 Subject Alternative Name
+        return bool(gnutls_x509_crt_check_hostname(self._c_object, hostname))
+
+    def check_issuer(self, issuer):
+        """Raise CertificateError if certificate was not issued by the given issuer"""
+        if not self.has_issuer(issuer):
+            raise CertificateError("certificate issuer doesn't match")
+
+    def check_hostname(self, hostname):
+        """Raise CertificateError if the certificate DNSName/IPAddress subject alternative name extension
+           doesn't match the given hostname"""
+        if not self.has_hostname(hostname):
+            raise CertificateError("certificate doesn't match hostname")
+
+
+class X509PrivateKey(object):
+    def __new__(cls, *args, **kwargs):
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_x509_privkey_deinit
+        instance._c_object = gnutls_x509_privkey_t()
+        return instance
+
+    @method_args(str, one_of(X509_FMT_PEM, X509_FMT_DER))
+    def __init__(self, buf, format=X509_FMT_PEM):
+        gnutls_x509_privkey_init(byref(self._c_object))
+        data = gnutls_datum_t(cast(c_char_p(buf), POINTER(c_ubyte)), c_uint(len(buf)))
+        gnutls_x509_privkey_import(self._c_object, byref(data), format)
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
+
+class X509Identity(object):
+    """A X509 identity represents a X509 certificate and private key pair"""
+    
+    __slots__ = ('cert', 'key')
+    
+    @method_args(X509Certificate, X509PrivateKey)
+    def __init__(self, cert, key):
+        self.cert = cert
+        self.key = key
+    
+    def __setattr__(self, name, value):
+        if name in self.__slots__ and hasattr(self, name):
+            raise AttributeError("can't set attribute")
+        object.__setattr__(self, name, value)
+
+    def __delattr__(self, name):
+        if name in self.__slots__:
+            raise AttributeError("can't delete attribute")
+        object.__delattr__(self, name)
+
+
+class X509CRL(object):
+    def __new__(cls, *args, **kwargs):
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_x509_crl_deinit
+        instance._c_object = gnutls_x509_crl_t()
+        return instance
+
+    @method_args(str, one_of(X509_FMT_PEM, X509_FMT_DER))
+    def __init__(self, buf, format=X509_FMT_PEM):
+        gnutls_x509_crl_init(byref(self._c_object))
+        data = gnutls_datum_t(cast(c_char_p(buf), POINTER(c_ubyte)), c_uint(len(buf)))
+        gnutls_x509_crl_import(self._c_object, byref(data), format)
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
+    @property
+    def count(self):
+        return gnutls_x509_crl_get_crt_count(self._c_object)
+
+    @property
+    def version(self):
+        return gnutls_x509_crl_get_version(self._c_object)
+
+    @property
+    def issuer(self):
+        size = c_size_t(256)
+        dname = create_string_buffer(size.value)
+        try:
+            gnutls_x509_crl_get_issuer_dn(self._c_object, dname, byref(size))
+        except MemoryError:
+            dname = create_string_buffer(size.value)
+            gnutls_x509_crl_get_issuer_dn(self._c_object, dname, byref(size))
+        return X509Name(dname.value)
+
+    @method_args(X509Certificate)
+    def is_revoked(self, cert):
+        """Return True if certificate is revoked, False otherwise"""
+        return bool(gnutls_x509_crt_check_revocation(cert._c_object, byref(self._c_object), 1))
+
+    def check_revocation(self, cert, cert_name='certificate'):
+        """Raise CertificateRevokedError if the given certificate is revoked"""
+        if self.is_revoked(cert):
+            raise CertificateRevokedError("%s was revoked" % cert_name)
+
+
+class DHParams(object):
+    def __new__(cls, *args, **kwargs):
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_dh_params_deinit
+        instance._c_object = gnutls_dh_params_t()
+        return instance
+
+    @method_args(int)
+    def __init__(self, bits=1024):
+        gnutls_dh_params_init(byref(self._c_object))
+        gnutls_dh_params_generate2(self._c_object, bits)
+
+    def __get__(self, obj, type_=None):
+        return self._c_object
+
+    def __set__(self, obj, value):
+        raise AttributeError("Read-only attribute")
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
+
+class RSAParams(object):
+    def __new__(cls, *args, **kwargs):
+        instance = object.__new__(cls)
+        instance.__deinit = gnutls_rsa_params_deinit
+        instance._c_object = gnutls_rsa_params_t()
+        return instance
+
+    @method_args(int)
+    def __init__(self, bits=1024):
+        gnutls_rsa_params_init(byref(self._c_object))
+        gnutls_rsa_params_generate2(self._c_object, bits)
+
+    def __get__(self, obj, type_=None):
+        return self._c_object
+
+    def __set__(self, obj, value):
+        raise AttributeError("Read-only attribute")
+
+    def __del__(self):
+        self.__deinit(self._c_object)
+
diff --git a/gnutls-1.1.9/gnutls/errors.py b/gnutls-1.1.9/gnutls/errors.py
new file mode 100644
index 0000000..592ba1d
--- /dev/null
+++ b/gnutls-1.1.9/gnutls/errors.py
@@ -0,0 +1,22 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS errors"""
+
+__all__ = ['Error', 'GNUTLSError', 'OperationWouldBlock', 'OperationInterrupted',
+           'CertificateError', 'CertificateAuthorityError', 'CertificateSecurityError',
+           'CertificateExpiredError', 'CertificateRevokedError', 'RequestedDataNotAvailable']
+
+class Error(Exception): pass
+
+class GNUTLSError(Error): pass
+class OperationWouldBlock(GNUTLSError): pass
+class OperationInterrupted(GNUTLSError): pass
+
+class CertificateError(GNUTLSError): pass
+class CertificateAuthorityError(CertificateError): pass
+class CertificateSecurityError(CertificateError): pass
+class CertificateExpiredError(CertificateError): pass
+class CertificateRevokedError(CertificateError): pass
+
+class RequestedDataNotAvailable(GNUTLSError): pass
diff --git a/gnutls-1.1.9/gnutls/interfaces/__init__.py b/gnutls-1.1.9/gnutls/interfaces/__init__.py
new file mode 100644
index 0000000..dc64199
--- /dev/null
+++ b/gnutls-1.1.9/gnutls/interfaces/__init__.py
@@ -0,0 +1,2 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
diff --git a/gnutls-1.1.9/gnutls/interfaces/twisted/__init__.py b/gnutls-1.1.9/gnutls/interfaces/twisted/__init__.py
new file mode 100644
index 0000000..cee60bf
--- /dev/null
+++ b/gnutls-1.1.9/gnutls/interfaces/twisted/__init__.py
@@ -0,0 +1,372 @@
+# Copyright (C) 2007-2008 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS Twisted interface"""
+
+__all__ = ['X509Credentials', 'connectTLS', 'listenTLS']
+
+import socket
+from time import time
+from errno import EWOULDBLOCK, EINTR
+
+from twisted.python import failure
+from twisted.internet import main, base, interfaces, address, tcp, error
+from twisted.internet.protocol import BaseProtocol
+
+from zope.interface import implements, implementsOnly, implementedBy
+
+from gnutls.connection import ClientSession, ServerSession, ServerSessionFactory
+from gnutls.connection import X509Credentials as _X509Credentials
+from gnutls.constants import SHUT_RDWR, SHUT_WR
+from gnutls.errors import *
+
+
+class KeepRunning:
+    """Return this class from a recurrent function to indicate that it should keep running"""
+    pass
+
+class RecurrentCall(object):
+    """Execute a function repeatedly at the given interval, until signaled to stop"""
+    def __init__(self, period, func, *args, **kwargs):
+        from twisted.internet import reactor
+        self.func = func
+        self.args = args
+        self.kwargs = kwargs
+        self.period = period
+        self.now = None
+        self.next = None
+        self.callid = reactor.callLater(period, self)
+    def __call__(self):
+        from twisted.internet import reactor
+        self.callid = None
+        if self.now is None:
+            self.now = time()
+            self.next = self.now + self.period
+        else:
+            self.now, self.next = self.next, self.next + self.period
+        result = self.func(*self.args, **self.kwargs)
+        if result is KeepRunning:
+            delay = max(self.next-time(), 0)
+            self.callid = reactor.callLater(delay, self)
+    def cancel(self):
+        if self.callid is not None:
+            try:
+                self.callid.cancel()
+            except ValueError:
+                pass
+            self.callid = None
+
+
+class CertificateOK: pass
+
+class X509Credentials(_X509Credentials):
+    """A Twisted enhanced X509Credentials"""
+    verify_peer = False
+    verify_period = None
+
+    def verify_callback(self, peer_cert, preverify_status=None):
+        """Verifies the peer certificate and raises an exception if it cannot be accepted"""
+        if isinstance(preverify_status, Exception):
+            raise preverify_status
+        self.check_certificate(peer_cert, cert_name='peer certificate')
+
+
+class TLSMixin:
+    """TLS specific functionality common to both clients and servers"""
+
+    def getPeerCertificate(self):
+        return self.socket.peer_certificate
+
+    def doRead(self):
+        try:
+            return tcp.Connection.doRead(self)
+        except (OperationWouldBlock, OperationInterrupted):
+            return
+        except GNUTLSError, e:
+            return e
+
+    def writeSomeData(self, data):
+        try:
+            return tcp.Connection.writeSomeData(self, data)
+        except OperationInterrupted:
+            return self.writeSomeData(data)
+        except OperationWouldBlock:
+            return 0
+        except GNUTLSError, e:
+            return e
+
+    def _sendCloseReason(self, reason):
+        try:
+            self.socket.send_alert(reason)
+        except OperationInterrupted:
+            self._sendCloseReason(reason)
+
+    def _sendCloseAlert(self, how=SHUT_RDWR):
+        try:
+            self.socket.bye(how)
+        except OperationInterrupted:
+            self._sendCloseAlert(how)
+
+    def closeTLSSession(self, reason):
+        try:
+            self._sendCloseReason(reason)
+            self._sendCloseAlert(SHUT_RDWR)
+        except Exception, e:
+            pass
+
+    def _postLoseConnection(self):
+        self.closeTLSSession(self._close_reason)
+        return self._close_reason
+
+    def endTLSWrite(self):
+        self.stopWriting()
+        try:
+            self._sendCloseAlert(SHUT_WR)
+        except OperationWouldBlock, e:
+            if self.socket.interrupted_while_writing:
+                self.startWriting()
+                return
+        except Exception, e:
+            return e
+        del self.doWrite
+
+    def _closeWriteConnection(self):
+        self.doWrite = self.endTLSWrite
+        result = self.endTLSWrite()
+        if isinstance(result, Exception):
+            return result
+        return tcp.Connection._closeWriteConnection(self)
+
+
+class TLSClient(TLSMixin, tcp.Client):
+    """Add TLS capabilities to a TCP client"""
+    
+    implementsOnly(interfaces.ISSLTransport, *[i for i in implementedBy(tcp.Client) if i != interfaces.ITLSTransport])
+    
+    def __init__(self, host, port, bindAddress, credentials, connector, reactor=None, server_name=None):
+        self.credentials = credentials
+        self.server_name = server_name
+        self.__watchdog = None
+        tcp.Client.__init__(self, host, port, bindAddress, connector, reactor)
+
+    def createInternetSocket(self):
+        sock = tcp.Client.createInternetSocket(self)
+        return ClientSession(sock, self.credentials, self.server_name)
+
+    def _recurrentVerify(self):
+        if not self.connected or self.disconnecting:
+            return
+        try:
+            self.credentials.verify_callback(self.socket.peer_certificate)
+        except Exception, e:
+            self.loseConnection(e)
+            return
+        else:
+            return KeepRunning
+
+    def _verifyPeer(self):
+        session = self.socket
+        credentials = self.credentials
+        if not credentials.verify_peer:
+            return
+        try:
+            session.verify_peer()
+        except Exception, e:
+            preverify_status = e
+        else:
+            preverify_status = CertificateOK
+        
+        credentials.verify_callback(session.peer_certificate, preverify_status)
+        
+        if credentials.verify_period > 0:
+            self.__watchdog = RecurrentCall(credentials.verify_period, self._recurrentVerify)
+
+    def doHandshake(self):
+        self.stopWriting()
+        try:
+            self.socket.handshake()
+        except (OperationWouldBlock, OperationInterrupted):
+            if self.socket.interrupted_while_writing:
+                self.startWriting()
+            return
+        except GNUTLSError, e:
+            del self.doRead
+            self.failIfNotConnected(err = e)
+            return
+        
+        ## reset any references to the old doRead
+        del self.doRead
+        self.stopReading()
+        
+        try:
+            self._verifyPeer()
+        except GNUTLSError, e:
+            self.closeTLSSession(e)
+            self.failIfNotConnected(err = e)
+            return
+        except Exception, e:
+            self.closeTLSSession(e)
+            self.failIfNotConnected(err = error.getConnectError(str(e)))
+            return
+        
+        ## TLS handshake (including certificate verification) finished succesfully
+        tcp.Client._connectDone(self)
+        
+    def startTLS(self):
+        self.doRead = self.doHandshake
+        self.startReading()
+        self.doHandshake()
+
+    def _connectDone(self):
+        self.startTLS()
+
+    def loseConnection(self, reason=failure.Failure(main.CONNECTION_DONE)):
+        reason = failure.Failure(reason) # accept python exceptions too
+        self._close_reason = reason.value
+        tcp.Client.loseConnection(self, reason)
+
+    def connectionLost(self, reason):
+        if self.__watchdog is not None:
+            self.__watchdog.cancel()
+            self.__watchdog = None
+        tcp.Client.connectionLost(self, reason)
+
+
+class TLSConnector(base.BaseConnector):
+    def __init__(self, host, port, factory, credentials, timeout, bindAddress, reactor=None, server_name=None):
+        self.host = host
+        self.port = port
+        self.bindAddress = bindAddress
+        self.credentials = credentials
+        self.server_name = server_name
+        base.BaseConnector.__init__(self, factory, timeout, reactor)
+
+    def _makeTransport(self):
+        return TLSClient(self.host, self.port, self.bindAddress, self.credentials, self, self.reactor, self.server_name)
+
+
+class TLSServer(TLSMixin, tcp.Server):
+    """Add TLS capabilities to a TCP server"""
+    
+    #implements(interfaces.ISSLTransport)
+    implementsOnly(interfaces.ISSLTransport, *[i for i in implementedBy(tcp.Server) if i != interfaces.ITLSTransport])
+    
+    def __init__(self, sock, protocol, client, server, sessionno, *args, **kw):
+        self.__watchdog = None
+        self.credentials = server.credentials
+        tcp.Server.__init__(self, sock, protocol, client, server, sessionno, *args, **kw)
+
+    def _recurrentVerify(self):
+        if not self.connected or self.disconnecting:
+            return
+        try:
+            self.credentials.verify_callback(self.socket.peer_certificate)
+        except Exception, e:
+            self.loseConnection(e)
+            return
+        else:
+            return KeepRunning
+
+    def _verifyPeer(self):
+        session = self.socket
+        credentials = self.credentials
+        if not credentials.verify_peer:
+            return
+        try:
+            session.verify_peer()
+        except Exception, e:
+            preverify_status = e
+        else:
+            preverify_status = CertificateOK
+        
+        credentials.verify_callback(session.peer_certificate, preverify_status)
+        
+        if credentials.verify_period > 0:
+            self.__watchdog = RecurrentCall(credentials.verify_period, self._recurrentVerify)
+
+    def doHandshake(self):
+        self.stopWriting()
+        try:
+            self.socket.handshake()
+        except (OperationWouldBlock, OperationInterrupted):
+            if self.socket.interrupted_while_writing:
+                self.startWriting()
+            return
+        except GNUTLSError, e:
+            del self.doRead
+            return e
+        
+        ## reset any references to the old doRead
+        del self.doRead
+        self.stopReading()
+        self.startReading()
+        
+        try:
+            self._verifyPeer()
+        except Exception, e:
+            self.loseConnection(e)
+            return
+        
+        ## TLS handshake (including certificate verification) finished succesfully
+        
+        del self.protocol.makeConnection
+        self.protocol.makeConnection(self)
+
+    def startTLS(self):
+        self.doRead = self.doHandshake
+        self.startReading()
+
+    def loseConnection(self, reason=failure.Failure(main.CONNECTION_DONE)):
+        reason = failure.Failure(reason) # accept python exceptions too
+        self._close_reason = reason.value
+        tcp.Server.loseConnection(self, reason)
+
+    def connectionLost(self, reason):
+        if self.__watchdog is not None:
+            self.__watchdog.cancel()
+            self.__watchdog = None
+        tcp.Server.connectionLost(self, reason)
+
+
+class TLSPort(tcp.Port):
+    """Add TLS capabilities to a TCP port"""
+
+    transport = TLSServer
+
+    def __init__(self, port, factory, credentials, backlog=50, interface='', reactor=None):
+        tcp.Port.__init__(self, port, factory, backlog, interface, reactor)
+        self.credentials = credentials
+
+    def createInternetSocket(self):
+        sock = tcp.Port.createInternetSocket(self)
+        return ServerSessionFactory(sock, self.credentials, ServerSession)
+
+    def _preMakeConnection(self, transport):
+        transport.protocol.makeConnection = lambda *args: None
+        transport.protocol.transport = transport ## because we may call connectionLost without connectionMade
+        transport.startTLS()
+        return tcp.Port._preMakeConnection(self, transport)
+
+
+def connectTLS(reactor, host, port, factory, credentials, timeout=30, bindAddress=None, server_name=None):
+    c = TLSConnector(host, port, factory, credentials, timeout, bindAddress, reactor, server_name)
+    c.connect()
+    return c
+
+
+def listenTLS(reactor, port, factory, credentials, backlog=50, interface=''):
+    p = TLSPort(port, factory, credentials, backlog, interface, reactor)
+    p.startListening()
+    return p
+
+## Add the connectTLS and listenTLS methods to the reactor
+
+import new
+from twisted.internet.posixbase import PosixReactorBase
+
+method = new.instancemethod(connectTLS, None, PosixReactorBase)
+setattr(PosixReactorBase, 'connectTLS', method)
+
+method = new.instancemethod(listenTLS, None, PosixReactorBase)
+setattr(PosixReactorBase, 'listenTLS', method)
+
diff --git a/gnutls-1.1.9/gnutls/library/__init__.py b/gnutls-1.1.9/gnutls/library/__init__.py
new file mode 100644
index 0000000..494460f
--- /dev/null
+++ b/gnutls-1.1.9/gnutls/library/__init__.py
@@ -0,0 +1,17 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+from gnutls.library import _gnutls_init
+from gnutls.library import constants
+from gnutls.library import types
+from gnutls.library import errors
+from gnutls.library import functions
+
+__need_version__ = '2.4.1'
+
+if functions.gnutls_check_version(__need_version__) is None:
+    version = functions.gnutls_check_version(None)
+    raise RuntimeError("Found GNUTLS library version %s, but at least version %s is required" % (version, __need_version__))
+if functions.gnutls_extra_check_version(__need_version__) is None:
+    version = functions.gnutls_extra_check_version(None)
+    raise RuntimeError("Found GNUTLS extra library version %s, but at least version %s is required" % (version, __need_version__))
diff --git a/gnutls-1.1.9/gnutls/library/_gnutls_init.c b/gnutls-1.1.9/gnutls/library/_gnutls_init.c
new file mode 100644
index 0000000..ff9156c
--- /dev/null
+++ b/gnutls-1.1.9/gnutls/library/_gnutls_init.c
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2007 AG Projects. See LICENSE for details.
+ * Author: Dan Pascu <dan@ag-projects.com>
+ *
+ * GNUTLS library initializations.
+ *
+ */
+
+#include <Python.h>
+
+#include <gnutls/gnutls.h>
+#include <gnutls/extra.h>
+#include <gcrypt.h>
+#include <errno.h>
+#include <pthread.h>
+
+// Use POSIX threads for libgcrypt locking
+GCRY_THREAD_OPTION_PTHREAD_IMPL;
+
+// List of functions defined in the module
+static PyMethodDef gnutls_methods[] = {
+    {NULL, NULL}   // sentinel
+};
+
+PyDoc_STRVAR(module_doc,
+"This module does behind the scenes GNUTLS initializations, like for example\n"
+"enabling thread safety in the gcrypt library and calling the GNUTLS global\n"
+"initialization functions.");
+
+// Initialization function for the module (must be called init_gnutls_init)
+PyMODINIT_FUNC
+init_gnutls_init(void)
+{
+    PyObject *m;
+
+    m = Py_InitModule3("_gnutls_init", gnutls_methods, module_doc);
+    if (m == NULL)
+        return;
+
+    // Enable thread safety for the posix threads library.
+    // This must be done before calling gnutls_global_init().
+    gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread);
+
+    gnutls_global_init();
+    gnutls_global_init_extra();
+}
+
diff --git a/gnutls-1.1.9/gnutls/library/constants.py b/gnutls-1.1.9/gnutls/library/constants.py
new file mode 100644
index 0000000..43c82d3
--- /dev/null
+++ b/gnutls-1.1.9/gnutls/library/constants.py
@@ -0,0 +1,648 @@
+from ctypes import *
+
+STRING = c_char_p
+
+
+GNUTLS_CRD_IA = 5
+GNUTLS_CERT_REQUIRE = 2
+GNUTLS_PKCS_USE_PKCS12_3DES = 2
+GNUTLS_CRD_CERTIFICATE = 1
+GNUTLS_HANDSHAKE_SERVER_HELLO_DONE = 14
+GNUTLS_SIGN_RSA_RMD160 = 5
+GNUTLS_PKCS_PLAIN = 1
+GNUTLS_A_UNKNOWN_CA = 48
+GNUTLS_CRT_PRINT_ONELINE = 1
+GNUTLS_PKCS_USE_PKCS12_ARCFOUR = 4
+GNUTLS_A_UNKNOWN_PSK_IDENTITY = 115
+GNUTLS_CRT_X509 = 1
+GNUTLS_KX_DHE_PSK = 10
+GNUTLS_PARAMS_RSA_EXPORT = 1
+GNUTLS_DIG_NULL = 1
+GNUTLS_KX_PSK = 9
+GNUTLS_CIPHER_RC2_40_CBC = 90
+GNUTLS_AL_WARNING = 1
+GNUTLS_DIG_SHA256 = 6
+GNUTLS_CERT_INSECURE_ALGORITHM = 256
+GNUTLS_SIGN_RSA_MD2 = 4
+GNUTLS_CRT_PRINT_UNSIGNED_FULL = 2
+GNUTLS_PK_DSA = 2
+GNUTLS_A_UNRECOGNIZED_NAME = 112
+GNUTLS_A_INNER_APPLICATION_FAILURE = 208
+GNUTLS_VERIFY_DO_NOT_ALLOW_SAME = 4
+GNUTLS_CIPHER_AES_128_CBC = 4
+GNUTLS_CRT_PRINT_FULL = 0
+GNUTLS_PKCS_USE_PBES2_3DES = 16
+GNUTLS_SSL3 = 1
+GNUTLS_SAN_OTHERNAME_XMPP = 1000
+GNUTLS_DIG_SHA384 = 7
+GNUTLS_MAC_UNKNOWN = 0
+GNUTLS_A_CERTIFICATE_UNOBTAINABLE = 111
+GNUTLS_OPENPGP_CERT_FINGERPRINT = 1
+GNUTLS_SIGN_RSA_SHA512 = 8
+GNUTLS_A_DECRYPT_ERROR = 51
+GNUTLS_SAN_DN = 6
+GNUTLS_SAN_DNSNAME = 1
+GNUTLS_CRT_UNKNOWN = 0
+GNUTLS_SERVER = 1
+GNUTLS_CIPHER_NULL = 1
+GNUTLS_CIPHER_DES_CBC = 91
+GNUTLS_A_USER_CANCELED = 90
+GNUTLS_TLS1_1 = 3
+GNUTLS_CRT_OPENPGP = 2
+GNUTLS_SHUT_WR = 1
+GNUTLS_KX_ANON_DH = 4
+GNUTLS_A_EXPORT_RESTRICTION = 60
+GNUTLS_HANDSHAKE_FINISHED = 20
+GNUTLS_KX_UNKNOWN = 0
+GNUTLS_MAC_NULL = 1
+GNUTLS_SAN_IPADDRESS = 4
+GNUTLS_HANDSHAKE_CLIENT_HELLO = 1
+GNUTLS_CRD_ANON = 2
+GNUTLS_SHUT_RDWR = 0
+GNUTLS_A_SSL3_NO_CERTIFICATE = 41
+GNUTLS_COMP_NULL = 1
+GNUTLS_TLS1_2 = 4
+GNUTLS_IA_APPLICATION_PAYLOAD = 0
+GNUTLS_SIGN_RSA_SHA224 = 9
+GNUTLS_HANDSHAKE_CERTIFICATE_PKT = 11
+GNUTLS_DIG_MD2 = 5
+GNUTLS_PK_RSA = 1
+GNUTLS_CIPHER_CAMELLIA_256_CBC = 8
+GNUTLS_HANDSHAKE_SUPPLEMENTAL = 23
+GNUTLS_SIGN_UNKNOWN = 0
+GNUTLS_PARAMS_DH = 2
+GNUTLS_PK_UNKNOWN = 0
+GNUTLS_A_INSUFFICIENT_SECURITY = 71
+GNUTLS_DIG_SHA512 = 8
+GNUTLS_SUPPLEMENTAL_USER_MAPPING_DATA = 0
+GNUTLS_KX_RSA = 1
+GNUTLS_SIGN_RSA_SHA384 = 7
+GNUTLS_A_RECORD_OVERFLOW = 22
+GNUTLS_KX_DHE_RSA = 3
+GNUTLS_COMP_LZO = 3
+GNUTLS_CERT_IGNORE = 0
+GNUTLS_SIGN_RSA_SHA1 = 1
+GNUTLS_A_ILLEGAL_PARAMETER = 47
+GNUTLS_A_NO_RENEGOTIATION = 100
+GNUTLS_A_PROTOCOL_VERSION = 70
+GNUTLS_A_DECOMPRESSION_FAILURE = 30
+GNUTLS_A_CERTIFICATE_REVOKED = 44
+GNUTLS_CIPHER_AES_256_CBC = 5
+GNUTLS_A_INTERNAL_ERROR = 80
+GNUTLS_HANDSHAKE_HELLO_REQUEST = 0
+GNUTLS_X509_FMT_DER = 0
+GNUTLS_HANDSHAKE_CERTIFICATE_REQUEST = 13
+GNUTLS_HANDSHAKE_SERVER_HELLO = 2
+GNUTLS_A_HANDSHAKE_FAILURE = 40
+GNUTLS_DIG_MD5 = 2
+GNUTLS_SIGN_RSA_MD5 = 3
+GNUTLS_MAC_SHA256 = 6
+GNUTLS_OPENPGP_CERT = 0
+GNUTLS_CERT_SIGNER_NOT_CA = 128
+GNUTLS_AL_FATAL = 2
+GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD2 = 16
+GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT = 2
+GNUTLS_CIPHER_3DES_CBC = 3
+GNUTLS_A_DECRYPTION_FAILED = 21
+GNUTLS_HANDSHAKE_CLIENT_KEY_EXCHANGE = 16
+GNUTLS_SAN_RFC822NAME = 2
+GNUTLS_CRD_PSK = 4
+GNUTLS_OPENPGP_FMT_RAW = 0
+GNUTLS_CERT_SIGNER_NOT_FOUND = 64
+GNUTLS_A_UNSUPPORTED_EXTENSION = 110
+GNUTLS_DIG_SHA1 = 3
+GNUTLS_DIG_RMD160 = 4
+GNUTLS_A_CLOSE_NOTIFY = 0
+GNUTLS_KX_SRP_RSA = 7
+GNUTLS_MAC_MD5 = 2
+GNUTLS_IA_FINAL_PHASE_FINISHED = 2
+GNUTLS_A_UNSUPPORTED_CERTIFICATE = 43
+GNUTLS_COMP_UNKNOWN = 0
+GNUTLS_PKCS_USE_PKCS12_RC2_40 = 8
+GNUTLS_CIPHER_UNKNOWN = 0
+GNUTLS_PSK_KEY_HEX = 1
+GNUTLS_KX_SRP_DSS = 8
+GNUTLS_MAC_SHA384 = 7
+GNUTLS_SAN_URI = 3
+GNUTLS_X509_FMT_PEM = 1
+GNUTLS_X509_CRT_LIST_IMPORT_FAIL_IF_EXCEED = 1
+GNUTLS_HANDSHAKE_CERTIFICATE_VERIFY = 15
+GNUTLS_A_DECODE_ERROR = 50
+GNUTLS_MAC_SHA1 = 3
+GNUTLS_HANDSHAKE_SERVER_KEY_EXCHANGE = 12
+GNUTLS_IA_INTERMEDIATE_PHASE_FINISHED = 1
+GNUTLS_A_CERTIFICATE_UNKNOWN = 46
+GNUTLS_OPENPGP_FMT_BASE64 = 1
+GNUTLS_CLIENT = 2
+GNUTLS_PSK_KEY_RAW = 0
+GNUTLS_A_UNEXPECTED_MESSAGE = 10
+GNUTLS_CERT_INVALID = 2
+GNUTLS_CRD_SRP = 3
+GNUTLS_A_BAD_RECORD_MAC = 20
+GNUTLS_MAC_RMD160 = 4
+GNUTLS_DIG_SHA224 = 9
+GNUTLS_TLS1_0 = 2
+GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD5 = 32
+GNUTLS_KX_SRP = 5
+GNUTLS_A_CERTIFICATE_EXPIRED = 45
+GNUTLS_MAC_MD2 = 5
+GNUTLS_VERIFY_ALLOW_ANY_X509_V1_CA_CRT = 8
+GNUTLS_A_ACCESS_DENIED = 49
+GNUTLS_VERIFY_DISABLE_CA_SIGN = 1
+GNUTLS_CIPHER_ARCFOUR_40 = 6
+GNUTLS_A_BAD_CERTIFICATE = 42
+GNUTLS_CERT_REVOKED = 32
+GNUTLS_CERT_REQUEST = 1
+GNUTLS_MAC_SHA512 = 8
+GNUTLS_SAN_OTHERNAME = 5
+GNUTLS_VERSION_UNKNOWN = 255
+GNUTLS_KX_RSA_EXPORT = 6
+GNUTLS_CIPHER_CAMELLIA_128_CBC = 7
+GNUTLS_COMP_DEFLATE = 2
+GNUTLS_NAME_DNS = 1
+GNUTLS_SIGN_DSA_SHA1 = 2
+GNUTLS_A_INNER_APPLICATION_VERIFICATION = 209
+GNUTLS_CIPHER_ARCFOUR_128 = 2
+GNUTLS_KX_DHE_DSS = 2
+GNUTLS_SIGN_RSA_SHA256 = 6
+GNUTLS_E_UNKNOWN_PK_ALGORITHM = -80 # Variable c_int
+TLS_MASTER_SIZE = 48 # Variable c_int
+LIBGNUTLS_VERSION_NUMBER = 132097 # Variable c_int
+GNUTLS_E_FATAL_ALERT_RECEIVED = -12 # Variable c_int
+GNUTLS_E_LARGE_PACKET = -7 # Variable c_int
+GNUTLS_E_ASN1_DER_OVERFLOW = -77 # Variable c_int
+GNUTLS_E_INCOMPATIBLE_LIBTASN1_LIBRARY = -203 # Variable c_int
+GNUTLS_E_SHORT_MEMORY_BUFFER = -51 # Variable c_int
+GNUTLS_E_UNKNOWN_ALGORITHM = -105 # Variable c_int
+GNUTLS_MAX_SESSION_ID = 32 # Variable c_int
+GNUTLS_E_OPENPGP_GETKEY_FAILED = -88 # Variable c_int
+GNUTLS_E_REHANDSHAKE = -37 # Variable c_int
+GNUTLS_E_ASN1_VALUE_NOT_FOUND = -70 # Variable c_int
+GNUTLS_E_SUCCESS = 0 # Variable c_int
+GNUTLS_E_ASN1_SYNTAX_ERROR = -76 # Variable c_int
+GNUTLS_OID_PKIX_COUNTRY_OF_RESIDENCE = '1.3.6.1.5.5.7.9.5' # Variable STRING
+GNUTLS_E_RECORD_LIMIT_REACHED = -39 # Variable c_int
+GNUTLS_E_WARNING_IA_FPHF_RECEIVED = -103 # Variable c_int
+GNUTLS_OID_X520_DN_QUALIFIER = '2.5.4.46' # Variable STRING
+GNUTLS_OID_X520_GIVEN_NAME = '2.5.4.42' # Variable STRING
+LIBGNUTLS_VERSION_MINOR = 4 # Variable c_int
+GNUTLS_E_ASN1_ELEMENT_NOT_FOUND = -67 # Variable c_int
+GNUTLS_E_CRYPTO_ALREADY_REGISTERED = -209 # Variable c_int
+GNUTLS_E_KEY_USAGE_VIOLATION = -48 # Variable c_int
+GNUTLS_E_WARNING_IA_IPHF_RECEIVED = -102 # Variable c_int
+GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM = -3 # Variable c_int
+GNUTLS_E_PK_DECRYPTION_FAILED = -45 # Variable c_int
+GNUTLS_CRL_REASON_CA_COMPROMISE = 32 # Variable c_int
+GNUTLS_E_UNKNOWN_PKCS_BAG_TYPE = -98 # Variable c_int
+GNUTLS_E_DECRYPTION_FAILED = -24 # Variable c_int
+GNUTLS_E_UNKNOWN_PKCS_CONTENT_TYPE = -97 # Variable c_int
+GNUTLS_KP_OCSP_SIGNING = '1.3.6.1.5.5.7.3.9' # Variable STRING
+GNUTLS_E_PK_SIGN_FAILED = -46 # Variable c_int
+GNUTLS_E_ASN1_TAG_IMPLICIT = -74 # Variable c_int
+GNUTLS_E_INIT_LIBEXTRA = -82 # Variable c_int
+GNUTLS_KP_TLS_WWW_SERVER = '1.3.6.1.5.5.7.3.1' # Variable STRING
+GNUTLS_E_OPENPGP_KEYRING_ERROR = -204 # Variable c_int
+GNUTLS_E_MEMORY_ERROR = -25 # Variable c_int
+GNUTLS_E_MAC_VERIFY_FAILED = -100 # Variable c_int
+GNUTLS_E_NO_TEMPORARY_DH_PARAMS = -93 # Variable c_int
+GNUTLS_KEY_NON_REPUDIATION = 64 # Variable c_int
+GNUTLS_MAX_ALGORITHM_NUM = 16 # Variable c_int
+GNUTLS_OID_X520_COUNTRY_NAME = '2.5.4.6' # Variable STRING
+GNUTLS_E_WARNING_ALERT_RECEIVED = -16 # Variable c_int
+GNUTLS_E_OPENPGP_UID_REVOKED = -79 # Variable c_int
+GNUTLS_E_PUSH_ERROR = -53 # Variable c_int
+GNUTLS_KEY_KEY_CERT_SIGN = 4 # Variable c_int
+GNUTLS_E_GOT_APPLICATION_DATA = -38 # Variable c_int
+GNUTLS_E_BASE64_DECODING_ERROR = -34 # Variable c_int
+GNUTLS_E_PULL_ERROR = -54 # Variable c_int
+GNUTLS_E_COMPRESSION_FAILED = -27 # Variable c_int
+GNUTLS_E_ASN1_DER_ERROR = -69 # Variable c_int
+GNUTLS_KEY_DECIPHER_ONLY = 32768 # Variable c_int
+GNUTLS_E_DECOMPRESSION_FAILED = -26 # Variable c_int
+LIBGNUTLS_VERSION_MAJOR = 2 # Variable c_int
+GNUTLS_E_NO_CIPHER_SUITES = -87 # Variable c_int
+GNUTLS_KEY_KEY_ENCIPHERMENT = 32 # Variable c_int
+GNUTLS_E_BASE64_UNEXPECTED_HEADER_ERROR = -207 # Variable c_int
+GNUTLS_E_ASN1_TYPE_ANY_ERROR = -75 # Variable c_int
+GNUTLS_OID_LDAP_UID = '0.9.2342.19200300.100.1.1' # Variable STRING
+GNUTLS_KEY_DATA_ENCIPHERMENT = 16 # Variable c_int
+GNUTLS_E_X509_UNSUPPORTED_OID = -205 # Variable c_int
+GNUTLS_E_NO_CERTIFICATE_FOUND = -49 # Variable c_int
+GNUTLS_E_UNIMPLEMENTED_FEATURE = -1250 # Variable c_int
+GNUTLS_E_UNSUPPORTED_VERSION_PACKET = -8 # Variable c_int
+GNUTLS_E_FILE_ERROR = -64 # Variable c_int
+GNUTLS_CRL_REASON_PRIVILEGE_WITHDRAWN = 1 # Variable c_int
+LIBGNUTLS_VERSION = '2.4.1' # Variable STRING
+GNUTLS_CRL_REASON_AFFILIATION_CHANGED = 16 # Variable c_int
+GNUTLS_OID_X520_ORGANIZATIONAL_UNIT_NAME = '2.5.4.11' # Variable STRING
+GNUTLS_OID_X520_COMMON_NAME = '2.5.4.3' # Variable STRING
+GNUTLS_E_HASH_FAILED = -33 # Variable c_int
+GNUTLS_E_PKCS1_WRONG_PAD = -57 # Variable c_int
+GNUTLS_OID_X520_GENERATION_QUALIFIER = '2.5.4.44' # Variable STRING
+GNUTLS_E_INCOMPATIBLE_CRYPTO_LIBRARY = -202 # Variable c_int
+GNUTLS_E_X509_UNSUPPORTED_CRITICAL_EXTENSION = -47 # Variable c_int
+GNUTLS_OID_X520_PSEUDONYM = '2.5.4.65' # Variable STRING
+GNUTLS_E_NO_COMPRESSION_ALGORITHMS = -86 # Variable c_int
+GNUTLS_E_UNEXPECTED_PACKET_LENGTH = -9 # Variable c_int
+GNUTLS_E_INCOMPATIBLE_GCRYPT_LIBRARY = -202 # Variable c_int
+GNUTLS_E_MPI_PRINT_FAILED = -35 # Variable c_int
+GNUTLS_E_INVALID_PASSWORD = -99 # Variable c_int
+GNUTLS_E_CERTIFICATE_KEY_MISMATCH = -60 # Variable c_int
+GNUTLS_OID_X520_STATE_OR_PROVINCE_NAME = '2.5.4.8' # Variable STRING
+GNUTLS_E_INSUFFICIENT_CREDENTIALS = -32 # Variable c_int
+GNUTLS_OID_X520_SURNAME = '2.5.4.4' # Variable STRING
+GNUTLS_E_X509_UNKNOWN_SAN = -62 # Variable c_int
+GNUTLS_KEY_CRL_SIGN = 2 # Variable c_int
+GNUTLS_E_PK_SIG_VERIFY_FAILED = -89 # Variable c_int
+GNUTLS_E_BASE64_ENCODING_ERROR = -201 # Variable c_int
+GNUTLS_E_ASN1_VALUE_NOT_VALID = -72 # Variable c_int
+GNUTLS_OID_X520_TITLE = '2.5.4.12' # Variable STRING
+GNUTLS_E_ENCRYPTION_FAILED = -40 # Variable c_int
+GNUTLS_OID_PKCS9_EMAIL = '1.2.840.113549.1.9.1' # Variable STRING
+GNUTLS_KP_ANY = '2.5.29.37.0' # Variable STRING
+GNUTLS_CRL_REASON_UNUSED = 128 # Variable c_int
+GNUTLS_E_OPENPGP_SUBKEY_ERROR = -208 # Variable c_int
+GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER = -55 # Variable c_int
+GNUTLS_E_EXPIRED = -29 # Variable c_int
+GNUTLS_E_DB_ERROR = -30 # Variable c_int
+GNUTLS_E_UNWANTED_ALGORITHM = -22 # Variable c_int
+GNUTLS_OID_PKIX_COUNTRY_OF_CITIZENSHIP = '1.3.6.1.5.5.7.9.4' # Variable STRING
+GNUTLS_E_APPLICATION_ERROR_MIN = -65500 # Variable c_int
+GNUTLS_E_INVALID_REQUEST = -50 # Variable c_int
+GNUTLS_E_ASN1_IDENTIFIER_NOT_FOUND = -68 # Variable c_int
+GNUTLS_OID_X520_INITIALS = '2.5.4.43' # Variable STRING
+GNUTLS_E_ASN1_TAG_ERROR = -73 # Variable c_int
+GNUTLS_E_X509_UNSUPPORTED_ATTRIBUTE = -95 # Variable c_int
+GNUTLS_KP_EMAIL_PROTECTION = '1.3.6.1.5.5.7.3.4' # Variable STRING
+GNUTLS_CRL_REASON_CESSATION_OF_OPERATION = 4 # Variable c_int
+GNUTLS_E_IA_VERIFY_FAILED = -104 # Variable c_int
+GNUTLS_KP_TIME_STAMPING = '1.3.6.1.5.5.7.3.8' # Variable STRING
+GNUTLS_E_INTERNAL_ERROR = -59 # Variable c_int
+GNUTLS_E_LZO_INIT_FAILED = -85 # Variable c_int
+GNUTLS_CRL_REASON_CERTIFICATE_HOLD = 2 # Variable c_int
+GNUTLS_OID_X520_ORGANIZATION_NAME = '2.5.4.10' # Variable STRING
+GNUTLS_CRL_REASON_KEY_COMPROMISE = 64 # Variable c_int
+GNUTLS_OID_PKIX_GENDER = '1.3.6.1.5.5.7.9.3' # Variable STRING
+GNUTLS_E_APPLICATION_ERROR_MAX = -65000 # Variable c_int
+GNUTLS_E_SRP_PWD_PARSING_ERROR = -91 # Variable c_int
+GNUTLS_E_NO_TEMPORARY_RSA_PARAMS = -84 # Variable c_int
+GNUTLS_OID_PKIX_PLACE_OF_BIRTH = '1.3.6.1.5.5.7.9.2' # Variable STRING
+GNUTLS_E_LIBRARY_VERSION_MISMATCH = -83 # Variable c_int
+GNUTLS_KEY_DIGITAL_SIGNATURE = 128 # Variable c_int
+GNUTLS_E_UNEXPECTED_HANDSHAKE_PACKET = -19 # Variable c_int
+GNUTLS_E_ASN1_GENERIC_ERROR = -71 # Variable c_int
+GNUTLS_E_ILLEGAL_SRP_USERNAME = -90 # Variable c_int
+_GNUTLS_GCC_VERSION = 40301 # Variable c_int
+GNUTLS_E_AGAIN = -28 # Variable c_int
+GNUTLS_E_DH_PRIME_UNACCEPTABLE = -63 # Variable c_int
+GNUTLS_E_UNSUPPORTED_CERTIFICATE_TYPE = -61 # Variable c_int
+GNUTLS_E_UNKNOWN_CIPHER_SUITE = -21 # Variable c_int
+GNUTLS_E_CONSTRAINT_ERROR = -101 # Variable c_int
+GNUTLS_E_UNEXPECTED_PACKET = -15 # Variable c_int
+TLS_RANDOM_SIZE = 32 # Variable c_int
+LIBGNUTLS_VERSION_PATCH = 1 # Variable c_int
+GNUTLS_E_RECEIVED_ILLEGAL_EXTENSION = -58 # Variable c_int
+GNUTLS_E_INVALID_SESSION = -10 # Variable c_int
+GNUTLS_KEY_KEY_AGREEMENT = 8 # Variable c_int
+GNUTLS_E_ERROR_IN_FINISHED_PACKET = -18 # Variable c_int
+GNUTLS_KEY_ENCIPHER_ONLY = 1 # Variable c_int
+GNUTLS_E_UNKNOWN_CIPHER_TYPE = -6 # Variable c_int
+GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE = -56 # Variable c_int
+GNUTLS_CRL_REASON_AA_COMPROMISE = 32768 # Variable c_int
+GNUTLS_E_CERTIFICATE_ERROR = -43 # Variable c_int
+GNUTLS_E_TOO_MANY_EMPTY_PACKETS = -78 # Variable c_int
+GNUTLS_OID_PKIX_DATE_OF_BIRTH = '1.3.6.1.5.5.7.9.1' # Variable STRING
+GNUTLS_E_PK_ENCRYPTION_FAILED = -44 # Variable c_int
+GNUTLS_OID_LDAP_DC = '0.9.2342.19200300.100.1.25' # Variable STRING
+GNUTLS_KP_TLS_WWW_CLIENT = '1.3.6.1.5.5.7.3.2' # Variable STRING
+GNUTLS_E_MPI_SCAN_FAILED = -23 # Variable c_int
+GNUTLS_E_OPENPGP_FINGERPRINT_UNSUPPORTED = -94 # Variable c_int
+GNUTLS_E_SRP_PWD_ERROR = -31 # Variable c_int
+GNUTLS_CRL_REASON_SUPERSEEDED = 8 # Variable c_int
+GNUTLS_E_INTERRUPTED = -52 # Variable c_int
+GNUTLS_OID_X520_LOCALITY_NAME = '2.5.4.7' # Variable STRING
+GNUTLS_E_UNKNOWN_HASH_ALGORITHM = -96 # Variable c_int
+GNUTLS_E_RANDOM_FAILED = -206 # Variable c_int
+GNUTLS_E_HANDSHAKE_TOO_LARGE = -210 # Variable c_int
+GNUTLS_KP_CODE_SIGNING = '1.3.6.1.5.5.7.3.3' # Variable STRING
+
+# values for enumeration 'gnutls_ia_apptype_t'
+gnutls_ia_apptype_t = c_int # enum
+
+# values for enumeration 'gnutls_cipher_algorithm_t'
+gnutls_cipher_algorithm_t = c_int # enum
+
+# values for enumeration 'gnutls_kx_algorithm_t'
+gnutls_kx_algorithm_t = c_int # enum
+
+# values for enumeration 'gnutls_params_type_t'
+gnutls_params_type_t = c_int # enum
+
+# values for enumeration 'gnutls_credentials_type_t'
+gnutls_credentials_type_t = c_int # enum
+
+# values for enumeration 'gnutls_mac_algorithm_t'
+gnutls_mac_algorithm_t = c_int # enum
+
+# values for enumeration 'gnutls_digest_algorithm_t'
+gnutls_digest_algorithm_t = c_int # enum
+
+# values for enumeration 'gnutls_compression_method_t'
+gnutls_compression_method_t = c_int # enum
+
+# values for enumeration 'gnutls_connection_end_t'
+gnutls_connection_end_t = c_int # enum
+
+# values for enumeration 'gnutls_alert_level_t'
+gnutls_alert_level_t = c_int # enum
+
+# values for enumeration 'gnutls_alert_description_t'
+gnutls_alert_description_t = c_int # enum
+
+# values for enumeration 'gnutls_handshake_description_t'
+gnutls_handshake_description_t = c_int # enum
+
+# values for enumeration 'gnutls_certificate_status_t'
+gnutls_certificate_status_t = c_int # enum
+
+# values for enumeration 'gnutls_certificate_request_t'
+gnutls_certificate_request_t = c_int # enum
+
+# values for enumeration 'gnutls_openpgp_crt_status_t'
+gnutls_openpgp_crt_status_t = c_int # enum
+
+# values for enumeration 'gnutls_close_request_t'
+gnutls_close_request_t = c_int # enum
+
+# values for enumeration 'gnutls_protocol_t'
+gnutls_protocol_t = c_int # enum
+
+# values for enumeration 'gnutls_certificate_type_t'
+gnutls_certificate_type_t = c_int # enum
+
+# values for enumeration 'gnutls_x509_crt_fmt_t'
+gnutls_x509_crt_fmt_t = c_int # enum
+
+# values for enumeration 'gnutls_certificate_print_formats'
+gnutls_certificate_print_formats = c_int # enum
+
+# values for enumeration 'gnutls_pk_algorithm_t'
+gnutls_pk_algorithm_t = c_int # enum
+
+# values for enumeration 'gnutls_sign_algorithm_t'
+gnutls_sign_algorithm_t = c_int # enum
+
+# values for enumeration 'gnutls_server_name_type_t'
+gnutls_server_name_type_t = c_int # enum
+
+# values for enumeration 'gnutls_supplemental_data_format_type_t'
+gnutls_supplemental_data_format_type_t = c_int # enum
+
+# values for enumeration 'gnutls_psk_key_flags'
+gnutls_psk_key_flags = c_int # enum
+
+# values for enumeration 'gnutls_x509_subject_alt_name_t'
+gnutls_x509_subject_alt_name_t = c_int # enum
+
+# values for enumeration 'gnutls_openpgp_crt_fmt'
+gnutls_openpgp_crt_fmt = c_int # enum
+
+# values for enumeration 'gnutls_certificate_import_flags'
+gnutls_certificate_import_flags = c_int # enum
+
+# values for enumeration 'gnutls_certificate_verify_flags'
+gnutls_certificate_verify_flags = c_int # enum
+
+# values for enumeration 'gnutls_pkcs_encrypt_flags_t'
+gnutls_pkcs_encrypt_flags_t = c_int # enum
+__all__ = ['GNUTLS_PKCS_USE_PKCS12_ARCFOUR',
+           'GNUTLS_HANDSHAKE_CLIENT_HELLO',
+           'GNUTLS_E_ASN1_DER_OVERFLOW',
+           'GNUTLS_CERT_INSECURE_ALGORITHM',
+           'GNUTLS_E_WARNING_ALERT_RECEIVED',
+           'GNUTLS_E_OPENPGP_GETKEY_FAILED', 'GNUTLS_KX_UNKNOWN',
+           'GNUTLS_E_SUCCESS', 'GNUTLS_CRT_PRINT_UNSIGNED_FULL',
+           'GNUTLS_DIG_NULL', 'GNUTLS_E_ASN1_IDENTIFIER_NOT_FOUND',
+           'GNUTLS_CIPHER_UNKNOWN', 'GNUTLS_KX_SRP_DSS',
+           'GNUTLS_A_UNSUPPORTED_EXTENSION',
+           'GNUTLS_E_WARNING_IA_IPHF_RECEIVED',
+           'GNUTLS_CRL_REASON_CA_COMPROMISE',
+           'GNUTLS_E_LZO_INIT_FAILED', 'gnutls_pkcs_encrypt_flags_t',
+           'GNUTLS_PKCS_USE_PKCS12_RC2_40',
+           'GNUTLS_A_CERTIFICATE_UNKNOWN',
+           'GNUTLS_E_MAC_VERIFY_FAILED', 'GNUTLS_OPENPGP_CERT',
+           'GNUTLS_E_NO_TEMPORARY_DH_PARAMS',
+           'GNUTLS_E_OPENPGP_UID_REVOKED', 'GNUTLS_KX_DHE_RSA',
+           'GNUTLS_E_PUSH_ERROR', 'GNUTLS_CRT_OPENPGP',
+           'GNUTLS_E_PULL_ERROR', 'GNUTLS_E_CONSTRAINT_ERROR',
+           'GNUTLS_KEY_DECIPHER_ONLY',
+           'GNUTLS_HANDSHAKE_HELLO_REQUEST',
+           'gnutls_certificate_verify_flags', 'GNUTLS_E_FILE_ERROR',
+           'GNUTLS_E_ASN1_TYPE_ANY_ERROR', 'GNUTLS_CERT_REVOKED',
+           'GNUTLS_E_NO_CERTIFICATE_FOUND', 'GNUTLS_SIGN_RSA_MD5',
+           'GNUTLS_E_DECOMPRESSION_FAILED', 'GNUTLS_DIG_MD5',
+           'GNUTLS_DIG_MD2', 'GNUTLS_A_HANDSHAKE_FAILURE',
+           'GNUTLS_E_ASN1_VALUE_NOT_FOUND',
+           'GNUTLS_VERIFY_ALLOW_ANY_X509_V1_CA_CRT',
+           'GNUTLS_E_PKCS1_WRONG_PAD', 'gnutls_params_type_t',
+           'GNUTLS_E_BASE64_DECODING_ERROR',
+           'GNUTLS_CIPHER_ARCFOUR_128', 'GNUTLS_X509_FMT_PEM',
+           'GNUTLS_E_CERTIFICATE_KEY_MISMATCH',
+           'GNUTLS_SIGN_RSA_SHA1', 'GNUTLS_DIG_SHA256',
+           'GNUTLS_HANDSHAKE_CERTIFICATE_REQUEST',
+           'LIBGNUTLS_VERSION', 'GNUTLS_OID_X520_TITLE',
+           'GNUTLS_MAC_SHA256', 'GNUTLS_E_DB_ERROR',
+           'GNUTLS_OID_PKIX_COUNTRY_OF_CITIZENSHIP',
+           'GNUTLS_SIGN_UNKNOWN', 'GNUTLS_DIG_SHA512',
+           'gnutls_x509_subject_alt_name_t', 'GNUTLS_AL_FATAL',
+           'GNUTLS_E_IA_VERIFY_FAILED', 'gnutls_certificate_type_t',
+           'GNUTLS_MAC_RMD160', 'GNUTLS_SIGN_RSA_SHA256',
+           'GNUTLS_CRT_PRINT_FULL',
+           'GNUTLS_E_LIBRARY_VERSION_MISMATCH',
+           'gnutls_pk_algorithm_t', 'GNUTLS_HANDSHAKE_SUPPLEMENTAL',
+           'GNUTLS_A_UNEXPECTED_MESSAGE',
+           'GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD5',
+           'GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD2',
+           'GNUTLS_E_UNEXPECTED_PACKET', 'GNUTLS_A_UNKNOWN_CA',
+           'gnutls_certificate_import_flags',
+           'LIBGNUTLS_VERSION_PATCH',
+           'GNUTLS_E_RECEIVED_ILLEGAL_EXTENSION',
+           'GNUTLS_SIGN_RSA_SHA512', 'GNUTLS_PKCS_USE_PBES2_3DES',
+           'GNUTLS_KEY_KEY_AGREEMENT',
+           'GNUTLS_E_DH_PRIME_UNACCEPTABLE',
+           'GNUTLS_E_INCOMPATIBLE_GCRYPT_LIBRARY',
+           'gnutls_cipher_algorithm_t',
+           'GNUTLS_IA_FINAL_PHASE_FINISHED', 'GNUTLS_SAN_DNSNAME',
+           'GNUTLS_E_PK_ENCRYPTION_FAILED',
+           'GNUTLS_E_MPI_SCAN_FAILED',
+           'GNUTLS_X509_CRT_LIST_IMPORT_FAIL_IF_EXCEED',
+           'GNUTLS_E_SRP_PWD_ERROR', 'gnutls_mac_algorithm_t',
+           'GNUTLS_PARAMS_RSA_EXPORT', 'GNUTLS_PSK_KEY_RAW',
+           'GNUTLS_E_UNKNOWN_HASH_ALGORITHM',
+           'GNUTLS_E_RANDOM_FAILED', 'GNUTLS_E_HANDSHAKE_TOO_LARGE',
+           'GNUTLS_A_NO_RENEGOTIATION', 'TLS_MASTER_SIZE',
+           'GNUTLS_E_FATAL_ALERT_RECEIVED', 'GNUTLS_E_LARGE_PACKET',
+           'GNUTLS_MAX_SESSION_ID',
+           'GNUTLS_A_INNER_APPLICATION_FAILURE',
+           'GNUTLS_E_RECORD_LIMIT_REACHED',
+           'GNUTLS_E_ASN1_ELEMENT_NOT_FOUND',
+           'GNUTLS_HANDSHAKE_CERTIFICATE_PKT',
+           'GNUTLS_A_INSUFFICIENT_SECURITY',
+           'GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM',
+           'GNUTLS_A_DECODE_ERROR',
+           'GNUTLS_A_INNER_APPLICATION_VERIFICATION',
+           'GNUTLS_E_UNKNOWN_PKCS_CONTENT_TYPE', 'GNUTLS_PK_RSA',
+           'GNUTLS_CRD_CERTIFICATE', 'GNUTLS_MAC_MD5',
+           'GNUTLS_MAC_MD2', 'GNUTLS_E_ASN1_TAG_IMPLICIT',
+           'GNUTLS_E_OPENPGP_KEYRING_ERROR', 'GNUTLS_SAN_OTHERNAME',
+           'GNUTLS_SAN_IPADDRESS', 'gnutls_compression_method_t',
+           'GNUTLS_SAN_DN', 'GNUTLS_COMP_NULL',
+           'GNUTLS_A_CERTIFICATE_EXPIRED',
+           'GNUTLS_OPENPGP_CERT_FINGERPRINT',
+           'GNUTLS_KEY_DATA_ENCIPHERMENT', 'GNUTLS_X509_FMT_DER',
+           'GNUTLS_CIPHER_AES_256_CBC', 'gnutls_sign_algorithm_t',
+           'GNUTLS_CRL_REASON_PRIVILEGE_WITHDRAWN', 'GNUTLS_SHUT_WR',
+           'GNUTLS_KX_DHE_PSK', 'GNUTLS_CLIENT', 'GNUTLS_DIG_SHA384',
+           'GNUTLS_E_X509_UNSUPPORTED_CRITICAL_EXTENSION',
+           'GNUTLS_E_UNKNOWN_CIPHER_TYPE',
+           'GNUTLS_E_MPI_PRINT_FAILED', 'GNUTLS_E_INVALID_PASSWORD',
+           'GNUTLS_CIPHER_3DES_CBC', 'gnutls_credentials_type_t',
+           'GNUTLS_SIGN_DSA_SHA1', 'GNUTLS_KEY_CRL_SIGN',
+           'GNUTLS_E_BASE64_ENCODING_ERROR', 'GNUTLS_A_CLOSE_NOTIFY',
+           'GNUTLS_OID_PKCS9_EMAIL', 'GNUTLS_CRL_REASON_UNUSED',
+           'GNUTLS_E_UNKNOWN_PK_ALGORITHM', 'GNUTLS_CERT_INVALID',
+           'GNUTLS_E_APPLICATION_ERROR_MIN',
+           'GNUTLS_HANDSHAKE_SERVER_HELLO_DONE',
+           'GNUTLS_E_OPENPGP_FINGERPRINT_UNSUPPORTED',
+           'GNUTLS_SAN_URI', 'GNUTLS_A_UNSUPPORTED_CERTIFICATE',
+           'GNUTLS_E_ASN1_TAG_ERROR', 'GNUTLS_E_INTERNAL_ERROR',
+           'GNUTLS_CRL_REASON_CERTIFICATE_HOLD',
+           'gnutls_certificate_status_t', 'GNUTLS_OID_PKIX_GENDER',
+           'GNUTLS_E_SRP_PWD_PARSING_ERROR', 'GNUTLS_MAC_SHA384',
+           'GNUTLS_COMP_DEFLATE', 'GNUTLS_E_ASN1_VALUE_NOT_VALID',
+           'GNUTLS_IA_INTERMEDIATE_PHASE_FINISHED',
+           'GNUTLS_COMP_UNKNOWN',
+           'GNUTLS_E_UNEXPECTED_HANDSHAKE_PACKET',
+           'GNUTLS_CIPHER_CAMELLIA_256_CBC',
+           'GNUTLS_CERT_SIGNER_NOT_FOUND',
+           'GNUTLS_A_PROTOCOL_VERSION', 'GNUTLS_E_AGAIN',
+           'GNUTLS_CIPHER_NULL', 'GNUTLS_KEY_ENCIPHER_ONLY',
+           'GNUTLS_NAME_DNS', 'GNUTLS_E_UNKNOWN_CIPHER_SUITE',
+           'gnutls_certificate_request_t',
+           'GNUTLS_CERT_SIGNER_NOT_CA', 'GNUTLS_A_USER_CANCELED',
+           'GNUTLS_E_PK_SIGN_FAILED',
+           'GNUTLS_E_ERROR_IN_FINISHED_PACKET',
+           'GNUTLS_CRL_REASON_AA_COMPROMISE', 'GNUTLS_MAC_SHA1',
+           'GNUTLS_CRD_ANON', 'GNUTLS_HANDSHAKE_SERVER_HELLO',
+           'GNUTLS_E_X509_UNSUPPORTED_ATTRIBUTE',
+           'GNUTLS_HANDSHAKE_CERTIFICATE_VERIFY',
+           'gnutls_ia_apptype_t', '_GNUTLS_GCC_VERSION',
+           'GNUTLS_CRL_REASON_SUPERSEEDED',
+           'gnutls_digest_algorithm_t', 'GNUTLS_A_DECRYPTION_FAILED',
+           'GNUTLS_MAC_NULL', 'GNUTLS_OID_PKIX_COUNTRY_OF_RESIDENCE',
+           'GNUTLS_E_ASN1_DER_ERROR', 'GNUTLS_PSK_KEY_HEX',
+           'GNUTLS_E_UNKNOWN_ALGORITHM', 'GNUTLS_DIG_SHA1',
+           'GNUTLS_E_INCOMPATIBLE_CRYPTO_LIBRARY',
+           'GNUTLS_E_ASN1_SYNTAX_ERROR',
+           'GNUTLS_E_WARNING_IA_FPHF_RECEIVED',
+           'GNUTLS_OID_X520_DN_QUALIFIER',
+           'GNUTLS_E_NO_CIPHER_SUITES', 'GNUTLS_KX_SRP',
+           'GNUTLS_E_CRYPTO_ALREADY_REGISTERED',
+           'GNUTLS_HANDSHAKE_FINISHED', 'GNUTLS_DIG_RMD160',
+           'gnutls_openpgp_crt_status_t', 'GNUTLS_KEY_KEY_CERT_SIGN',
+           'GNUTLS_CRD_SRP', 'GNUTLS_E_DECRYPTION_FAILED',
+           'GNUTLS_KX_SRP_RSA', 'gnutls_protocol_t',
+           'gnutls_openpgp_crt_fmt', 'GNUTLS_IA_APPLICATION_PAYLOAD',
+           'GNUTLS_SIGN_RSA_MD2', 'GNUTLS_A_CERTIFICATE_UNOBTAINABLE',
+           'GNUTLS_CIPHER_DES_CBC', 'GNUTLS_A_RECORD_OVERFLOW',
+           'GNUTLS_KX_DHE_DSS', 'GNUTLS_KEY_KEY_ENCIPHERMENT',
+           'GNUTLS_OID_LDAP_UID', 'GNUTLS_E_X509_UNSUPPORTED_OID',
+           'GNUTLS_VERIFY_DO_NOT_ALLOW_SAME',
+           'GNUTLS_E_UNIMPLEMENTED_FEATURE', 'GNUTLS_A_DECRYPT_ERROR',
+           'GNUTLS_TLS1_2', 'GNUTLS_TLS1_0', 'GNUTLS_TLS1_1',
+           'GNUTLS_CRL_REASON_AFFILIATION_CHANGED',
+           'GNUTLS_OPENPGP_FMT_RAW',
+           'GNUTLS_OID_X520_GENERATION_QUALIFIER',
+           'GNUTLS_OID_X520_PSEUDONYM',
+           'GNUTLS_A_DECOMPRESSION_FAILURE',
+           'GNUTLS_E_NO_COMPRESSION_ALGORITHMS',
+           'GNUTLS_E_UNEXPECTED_PACKET_LENGTH', 'GNUTLS_PK_UNKNOWN',
+           'GNUTLS_E_COMPRESSION_FAILED',
+           'GNUTLS_KEY_NON_REPUDIATION', 'GNUTLS_A_ACCESS_DENIED',
+           'GNUTLS_E_INSUFFICIENT_CREDENTIALS',
+           'gnutls_kx_algorithm_t', 'GNUTLS_OID_X520_COMMON_NAME',
+           'GNUTLS_OID_PKIX_PLACE_OF_BIRTH',
+           'GNUTLS_OID_X520_STATE_OR_PROVINCE_NAME',
+           'GNUTLS_VERIFY_DISABLE_CA_SIGN',
+           'GNUTLS_SAN_OTHERNAME_XMPP', 'GNUTLS_E_INVALID_REQUEST',
+           'GNUTLS_SSL3', 'GNUTLS_KP_TIME_STAMPING',
+           'GNUTLS_A_SSL3_NO_CERTIFICATE',
+           'GNUTLS_CRL_REASON_KEY_COMPROMISE',
+           'GNUTLS_E_APPLICATION_ERROR_MAX',
+           'GNUTLS_KEY_DIGITAL_SIGNATURE',
+           'gnutls_supplemental_data_format_type_t',
+           'gnutls_alert_description_t',
+           'GNUTLS_A_CERTIFICATE_REVOKED', 'gnutls_alert_level_t',
+           'gnutls_psk_key_flags', 'GNUTLS_A_BAD_CERTIFICATE',
+           'GNUTLS_MAC_UNKNOWN', 'GNUTLS_A_UNRECOGNIZED_NAME',
+           'TLS_RANDOM_SIZE', 'GNUTLS_E_INVALID_SESSION',
+           'GNUTLS_PARAMS_DH', 'GNUTLS_HANDSHAKE_CLIENT_KEY_EXCHANGE',
+           'gnutls_x509_crt_fmt_t', 'GNUTLS_KP_ANY',
+           'GNUTLS_E_TOO_MANY_EMPTY_PACKETS',
+           'GNUTLS_OID_PKIX_DATE_OF_BIRTH',
+           'GNUTLS_OPENPGP_FMT_BASE64',
+           'GNUTLS_E_NO_TEMPORARY_RSA_PARAMS',
+           'GNUTLS_VERSION_UNKNOWN', 'GNUTLS_E_INTERRUPTED',
+           'GNUTLS_COMP_LZO', 'GNUTLS_SERVER', 'GNUTLS_CRD_IA',
+           'GNUTLS_DIG_SHA224', 'GNUTLS_KX_RSA',
+           'LIBGNUTLS_VERSION_NUMBER', 'GNUTLS_CERT_IGNORE',
+           'GNUTLS_CERT_REQUEST', 'GNUTLS_MAC_SHA512',
+           'GNUTLS_E_SHORT_MEMORY_BUFFER', 'GNUTLS_SIGN_RSA_SHA224',
+           'GNUTLS_E_REHANDSHAKE', 'gnutls_close_request_t',
+           'GNUTLS_OID_X520_GIVEN_NAME', 'LIBGNUTLS_VERSION_MINOR',
+           'gnutls_handshake_description_t',
+           'GNUTLS_E_KEY_USAGE_VIOLATION',
+           'GNUTLS_E_PK_DECRYPTION_FAILED',
+           'GNUTLS_E_UNKNOWN_PKCS_BAG_TYPE', 'GNUTLS_KX_PSK',
+           'GNUTLS_SUPPLEMENTAL_USER_MAPPING_DATA',
+           'GNUTLS_KP_OCSP_SIGNING', 'GNUTLS_A_UNKNOWN_PSK_IDENTITY',
+           'GNUTLS_OID_X520_SURNAME', 'GNUTLS_E_MEMORY_ERROR',
+           'GNUTLS_CERT_REQUIRE', 'GNUTLS_KX_ANON_DH',
+           'GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT',
+           'GNUTLS_MAX_ALGORITHM_NUM', 'GNUTLS_A_EXPORT_RESTRICTION',
+           'GNUTLS_OID_X520_COUNTRY_NAME', 'GNUTLS_SHUT_RDWR',
+           'GNUTLS_AL_WARNING', 'GNUTLS_E_GOT_APPLICATION_DATA',
+           'LIBGNUTLS_VERSION_MAJOR', 'GNUTLS_CRT_UNKNOWN',
+           'GNUTLS_E_UNSUPPORTED_VERSION_PACKET',
+           'GNUTLS_KP_TLS_WWW_SERVER',
+           'GNUTLS_OID_X520_ORGANIZATIONAL_UNIT_NAME',
+           'GNUTLS_E_HASH_FAILED',
+           'GNUTLS_OID_X520_ORGANIZATION_NAME',
+           'gnutls_server_name_type_t', 'GNUTLS_E_ENCRYPTION_FAILED',
+           'GNUTLS_E_X509_UNKNOWN_SAN', 'GNUTLS_CRD_PSK',
+           'GNUTLS_E_PK_SIG_VERIFY_FAILED', 'GNUTLS_A_BAD_RECORD_MAC',
+           'GNUTLS_KX_RSA_EXPORT', 'GNUTLS_E_OPENPGP_SUBKEY_ERROR',
+           'GNUTLS_SIGN_RSA_SHA384', 'GNUTLS_CRT_X509',
+           'GNUTLS_E_EXPIRED', 'GNUTLS_E_UNWANTED_ALGORITHM',
+           'GNUTLS_SIGN_RSA_RMD160', 'GNUTLS_OID_X520_INITIALS',
+           'GNUTLS_KP_EMAIL_PROTECTION', 'gnutls_connection_end_t',
+           'GNUTLS_E_INIT_LIBEXTRA', 'GNUTLS_PKCS_PLAIN',
+           'GNUTLS_HANDSHAKE_SERVER_KEY_EXCHANGE',
+           'GNUTLS_CRL_REASON_CESSATION_OF_OPERATION',
+           'GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER',
+           'GNUTLS_CIPHER_CAMELLIA_128_CBC',
+           'GNUTLS_E_ASN1_GENERIC_ERROR',
+           'GNUTLS_E_ILLEGAL_SRP_USERNAME',
+           'GNUTLS_E_UNSUPPORTED_CERTIFICATE_TYPE', 'GNUTLS_PK_DSA',
+           'GNUTLS_E_INCOMPATIBLE_LIBTASN1_LIBRARY',
+           'GNUTLS_SAN_RFC822NAME',
+           'GNUTLS_E_BASE64_UNEXPECTED_HEADER_ERROR',
+           'GNUTLS_PKCS_USE_PKCS12_3DES', 'GNUTLS_CIPHER_ARCFOUR_40',
+           'GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE',
+           'GNUTLS_CIPHER_RC2_40_CBC', 'GNUTLS_CIPHER_AES_128_CBC',
+           'GNUTLS_OID_LDAP_DC', 'GNUTLS_KP_TLS_WWW_CLIENT',
+           'GNUTLS_A_INTERNAL_ERROR', 'GNUTLS_A_ILLEGAL_PARAMETER',
+           'gnutls_certificate_print_formats',
+           'GNUTLS_OID_X520_LOCALITY_NAME',
+           'GNUTLS_E_CERTIFICATE_ERROR', 'GNUTLS_CRT_PRINT_ONELINE',
+           'GNUTLS_KP_CODE_SIGNING']
diff --git a/gnutls-1.1.9/gnutls/library/errors.py b/gnutls-1.1.9/gnutls/library/errors.py
new file mode 100644
index 0000000..1e4dea7
--- /dev/null
+++ b/gnutls-1.1.9/gnutls/library/errors.py
@@ -0,0 +1,78 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS library errors"""
+
+from gnutls.errors import *
+from gnutls.errors import __all__
+
+from gnutls.library.constants import GNUTLS_E_AGAIN, GNUTLS_E_INTERRUPTED, GNUTLS_E_NO_CERTIFICATE_FOUND
+from gnutls.library.constants import GNUTLS_E_MEMORY_ERROR, GNUTLS_E_SHORT_MEMORY_BUFFER
+from gnutls.library.constants import GNUTLS_E_FATAL_ALERT_RECEIVED, GNUTLS_A_BAD_CERTIFICATE
+from gnutls.library.constants import GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE
+from gnutls.library.constants import GNUTLS_A_UNKNOWN_CA, GNUTLS_A_INSUFFICIENT_SECURITY
+from gnutls.library.constants import GNUTLS_A_CERTIFICATE_EXPIRED, GNUTLS_A_CERTIFICATE_REVOKED
+from gnutls.library.functions import gnutls_strerror, gnutls_alert_get
+
+class ErrorMessage(str):
+    def __new__(cls, code):
+        obj = str.__new__(cls, gnutls_strerror(code))
+        obj.code = code
+        return obj
+
+# Check functions which return an integer status code (negative codes being errors)
+#
+def _check_status(retcode, function, args):
+    if retcode >= 0:
+        return retcode
+    elif retcode == -1:
+        from gnutls.library import functions
+        if function in (functions.gnutls_certificate_activation_time_peers,
+                        functions.gnutls_x509_crt_get_activation_time,
+                        functions.gnutls_openpgp_key_get_creation_time):
+            raise GNUTLSError("cannot retrieve activation time")
+        elif function in (functions.gnutls_certificate_expiration_time_peers,
+                          functions.gnutls_x509_crt_get_expiration_time,
+                          functions.gnutls_openpgp_key_get_expiration_time):
+            raise GNUTLSError("cannot retrieve expiration time")
+        elif function in (functions.gnutls_x509_crl_get_this_update,
+                          functions.gnutls_x509_crl_get_next_update):
+            raise GNUTLSError("cannot retrieve CRL update time")
+        else:
+            raise GNUTLSError(ErrorMessage(retcode))
+    elif retcode == GNUTLS_E_AGAIN:
+        raise OperationWouldBlock(gnutls_strerror(retcode))
+    elif retcode == GNUTLS_E_INTERRUPTED:
+        raise OperationInterrupted(gnutls_strerror(retcode))
+    elif retcode in (GNUTLS_E_MEMORY_ERROR, GNUTLS_E_SHORT_MEMORY_BUFFER):
+        raise MemoryError(ErrorMessage(retcode))
+    elif retcode == GNUTLS_E_NO_CERTIFICATE_FOUND:
+        raise CertificateSecurityError(gnutls_strerror(retcode))
+    elif retcode == GNUTLS_E_FATAL_ALERT_RECEIVED:
+        alertdict = {
+            GNUTLS_A_BAD_CERTIFICATE: (CertificateError, "peer rejected our certificate as invalid"),
+            GNUTLS_A_UNKNOWN_CA: (CertificateAuthorityError, "peer does not trust our certificate authority"),
+            GNUTLS_A_INSUFFICIENT_SECURITY: (CertificateSecurityError, "peer rejected us on insufficient security"),
+            GNUTLS_A_CERTIFICATE_EXPIRED: (CertificateExpiredError, "peer rejected our certificate as expired"),
+            GNUTLS_A_CERTIFICATE_REVOKED: (CertificateRevokedError, "peer rejected our certificate as revoked")}
+        alert = gnutls_alert_get(args[0])
+        exception, reason = alertdict.get(alert, (GNUTLSError, ErrorMessage(retcode)))
+        raise exception(reason)
+    elif retcode == GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE:
+        raise RequestedDataNotAvailable(gnutls_strerror(retcode))
+    else:
+        raise GNUTLSError(ErrorMessage(retcode))
+
+# Attach the error checking function to all functions returning integers
+#
+from gnutls.library import functions
+from ctypes import c_int, c_long
+
+for func in functions.__dict__.values():
+    if not hasattr(func, 'errcheck'):
+        continue ## not a function
+    if func.restype in (c_int, c_long):
+        func.errcheck = _check_status
+
+del c_int, c_long, func, functions
+
diff --git a/gnutls-1.1.9/gnutls/library/functions.py b/gnutls-1.1.9/gnutls/library/functions.py
new file mode 100644
index 0000000..5ee3cab
--- /dev/null
+++ b/gnutls-1.1.9/gnutls/library/functions.py
@@ -0,0 +1,1836 @@
+from ctypes import *
+
+from gnutls.library.types import gnutls_ia_client_credentials_t
+_libraries = {}
+_libraries['libgnutls-extra.so.26'] = CDLL('libgnutls-extra.so.26')
+from gnutls.library.types import gnutls_ia_server_credentials_t
+from gnutls.library.types import gnutls_ia_avp_func
+from gnutls.library.types import gnutls_session_t
+from gnutls.library.types import size_t
+STRING = c_char_p
+from gnutls.library.types import ssize_t
+from gnutls.library.constants import gnutls_pk_algorithm_t
+_libraries['libgnutls.so.26'] = CDLL('libgnutls.so.26')
+from gnutls.library.constants import gnutls_sign_algorithm_t
+from gnutls.library.constants import gnutls_connection_end_t
+from gnutls.library.constants import gnutls_close_request_t
+from gnutls.library.constants import gnutls_alert_description_t
+from gnutls.library.constants import gnutls_alert_level_t
+from gnutls.library.constants import gnutls_cipher_algorithm_t
+from gnutls.library.constants import gnutls_kx_algorithm_t
+from gnutls.library.constants import gnutls_mac_algorithm_t
+from gnutls.library.constants import gnutls_compression_method_t
+from gnutls.library.constants import gnutls_certificate_type_t
+from gnutls.library.constants import gnutls_protocol_t
+from gnutls.library.constants import gnutls_handshake_description_t
+from gnutls.library.constants import gnutls_server_name_type_t
+from gnutls.library.constants import gnutls_supplemental_data_format_type_t
+from gnutls.library.types import gnutls_priority_t
+from gnutls.library.types import gnutls_datum_t
+from gnutls.library.types import gnutls_db_retr_func
+from gnutls.library.types import gnutls_db_remove_func
+from gnutls.library.types import gnutls_db_store_func
+from gnutls.library.types import gnutls_datum_t
+from gnutls.library.types import gnutls_handshake_post_client_hello_func
+from gnutls.library.constants import gnutls_credentials_type_t
+from gnutls.library.types import gnutls_anon_server_credentials_t
+from gnutls.library.types import gnutls_dh_params_t
+from gnutls.library.types import gnutls_params_function
+from gnutls.library.types import gnutls_anon_client_credentials_t
+from gnutls.library.types import gnutls_certificate_credentials_t
+from gnutls.library.types import gnutls_rsa_params_t
+from gnutls.library.constants import gnutls_x509_crt_fmt_t
+from gnutls.library.types import gnutls_x509_crt_t
+from gnutls.library.types import gnutls_x509_privkey_t
+from gnutls.library.types import gnutls_x509_crl_t
+from gnutls.library.types import gnutls_openpgp_keyring_t
+from gnutls.library.types import gnutls_alloc_function
+from gnutls.library.types import gnutls_is_secure_function
+from gnutls.library.types import gnutls_realloc_function
+from gnutls.library.types import gnutls_free_function
+from gnutls.library.types import gnutls_log_func
+from gnutls.library.types import gnutls_transport_ptr_t
+from gnutls.library.types import gnutls_push_func
+from gnutls.library.types import gnutls_pull_func
+from gnutls.library.constants import gnutls_openpgp_crt_status_t
+from gnutls.library.constants import gnutls_digest_algorithm_t
+from gnutls.library.types import gnutls_srp_client_credentials_t
+from gnutls.library.types import gnutls_srp_server_credentials_t
+from gnutls.library.types import gnutls_srp_server_credentials_function
+from gnutls.library.types import gnutls_srp_client_credentials_function
+from gnutls.library.types import gnutls_psk_client_credentials_t
+from gnutls.library.constants import gnutls_psk_key_flags
+from gnutls.library.types import gnutls_psk_server_credentials_t
+from gnutls.library.types import gnutls_psk_server_credentials_function
+from gnutls.library.types import gnutls_psk_client_credentials_function
+from gnutls.library.types import gnutls_sign_func
+from gnutls.library.types import gnutls_certificate_client_retrieve_function
+from gnutls.library.types import gnutls_certificate_server_retrieve_function
+from gnutls.library.constants import gnutls_certificate_request_t
+from gnutls.library.types import gnutls_openpgp_crt_t
+from gnutls.library.types import gnutls_openpgp_crt_fmt_t
+from gnutls.library.types import gnutls_certificate_print_formats_t
+from gnutls.library.types import gnutls_openpgp_privkey_t
+from gnutls.library.types import gnutls_openpgp_recv_key_func
+from gnutls.library.constants import gnutls_x509_subject_alt_name_t
+from gnutls.library.types import gnutls_x509_dn_t
+from gnutls.library.types import gnutls_x509_ava_st
+from gnutls.library.types import gnutls_pkcs7_t
+from gnutls.library.types import gnutls_x509_crq_t
+
+
+gnutls_ia_free_client_credentials = _libraries['libgnutls-extra.so.26'].gnutls_ia_free_client_credentials
+gnutls_ia_free_client_credentials.restype = None
+gnutls_ia_free_client_credentials.argtypes = [gnutls_ia_client_credentials_t]
+gnutls_ia_allocate_client_credentials = _libraries['libgnutls-extra.so.26'].gnutls_ia_allocate_client_credentials
+gnutls_ia_allocate_client_credentials.restype = c_int
+gnutls_ia_allocate_client_credentials.argtypes = [POINTER(gnutls_ia_client_credentials_t)]
+gnutls_ia_free_server_credentials = _libraries['libgnutls-extra.so.26'].gnutls_ia_free_server_credentials
+gnutls_ia_free_server_credentials.restype = None
+gnutls_ia_free_server_credentials.argtypes = [gnutls_ia_server_credentials_t]
+gnutls_ia_allocate_server_credentials = _libraries['libgnutls-extra.so.26'].gnutls_ia_allocate_server_credentials
+gnutls_ia_allocate_server_credentials.restype = c_int
+gnutls_ia_allocate_server_credentials.argtypes = [POINTER(gnutls_ia_server_credentials_t)]
+gnutls_ia_set_client_avp_function = _libraries['libgnutls-extra.so.26'].gnutls_ia_set_client_avp_function
+gnutls_ia_set_client_avp_function.restype = None
+gnutls_ia_set_client_avp_function.argtypes = [gnutls_ia_client_credentials_t, gnutls_ia_avp_func]
+gnutls_ia_set_client_avp_ptr = _libraries['libgnutls-extra.so.26'].gnutls_ia_set_client_avp_ptr
+gnutls_ia_set_client_avp_ptr.restype = None
+gnutls_ia_set_client_avp_ptr.argtypes = [gnutls_ia_client_credentials_t, c_void_p]
+gnutls_ia_get_client_avp_ptr = _libraries['libgnutls-extra.so.26'].gnutls_ia_get_client_avp_ptr
+gnutls_ia_get_client_avp_ptr.restype = c_void_p
+gnutls_ia_get_client_avp_ptr.argtypes = [gnutls_ia_client_credentials_t]
+gnutls_ia_set_server_avp_function = _libraries['libgnutls-extra.so.26'].gnutls_ia_set_server_avp_function
+gnutls_ia_set_server_avp_function.restype = None
+gnutls_ia_set_server_avp_function.argtypes = [gnutls_ia_server_credentials_t, gnutls_ia_avp_func]
+gnutls_ia_set_server_avp_ptr = _libraries['libgnutls-extra.so.26'].gnutls_ia_set_server_avp_ptr
+gnutls_ia_set_server_avp_ptr.restype = None
+gnutls_ia_set_server_avp_ptr.argtypes = [gnutls_ia_server_credentials_t, c_void_p]
+gnutls_ia_get_server_avp_ptr = _libraries['libgnutls-extra.so.26'].gnutls_ia_get_server_avp_ptr
+gnutls_ia_get_server_avp_ptr.restype = c_void_p
+gnutls_ia_get_server_avp_ptr.argtypes = [gnutls_ia_server_credentials_t]
+gnutls_ia_handshake_p = _libraries['libgnutls-extra.so.26'].gnutls_ia_handshake_p
+gnutls_ia_handshake_p.restype = c_int
+gnutls_ia_handshake_p.argtypes = [gnutls_session_t]
+gnutls_ia_handshake = _libraries['libgnutls-extra.so.26'].gnutls_ia_handshake
+gnutls_ia_handshake.restype = c_int
+gnutls_ia_handshake.argtypes = [gnutls_session_t]
+gnutls_ia_permute_inner_secret = _libraries['libgnutls-extra.so.26'].gnutls_ia_permute_inner_secret
+gnutls_ia_permute_inner_secret.restype = c_int
+gnutls_ia_permute_inner_secret.argtypes = [gnutls_session_t, size_t, STRING]
+gnutls_ia_endphase_send = _libraries['libgnutls-extra.so.26'].gnutls_ia_endphase_send
+gnutls_ia_endphase_send.restype = c_int
+gnutls_ia_endphase_send.argtypes = [gnutls_session_t, c_int]
+gnutls_ia_verify_endphase = _libraries['libgnutls-extra.so.26'].gnutls_ia_verify_endphase
+gnutls_ia_verify_endphase.restype = c_int
+gnutls_ia_verify_endphase.argtypes = [gnutls_session_t, STRING]
+gnutls_ia_send = _libraries['libgnutls-extra.so.26'].gnutls_ia_send
+gnutls_ia_send.restype = ssize_t
+gnutls_ia_send.argtypes = [gnutls_session_t, STRING, size_t]
+gnutls_ia_recv = _libraries['libgnutls-extra.so.26'].gnutls_ia_recv
+gnutls_ia_recv.restype = ssize_t
+gnutls_ia_recv.argtypes = [gnutls_session_t, STRING, size_t]
+gnutls_ia_generate_challenge = _libraries['libgnutls-extra.so.26'].gnutls_ia_generate_challenge
+gnutls_ia_generate_challenge.restype = c_int
+gnutls_ia_generate_challenge.argtypes = [gnutls_session_t, size_t, STRING]
+gnutls_ia_extract_inner_secret = _libraries['libgnutls-extra.so.26'].gnutls_ia_extract_inner_secret
+gnutls_ia_extract_inner_secret.restype = None
+gnutls_ia_extract_inner_secret.argtypes = [gnutls_session_t, STRING]
+gnutls_ia_enable = _libraries['libgnutls-extra.so.26'].gnutls_ia_enable
+gnutls_ia_enable.restype = None
+gnutls_ia_enable.argtypes = [gnutls_session_t, c_int]
+gnutls_global_init_extra = _libraries['libgnutls-extra.so.26'].gnutls_global_init_extra
+gnutls_global_init_extra.restype = c_int
+gnutls_global_init_extra.argtypes = []
+gnutls_extra_check_version = _libraries['libgnutls-extra.so.26'].gnutls_extra_check_version
+gnutls_extra_check_version.restype = STRING
+gnutls_extra_check_version.argtypes = [STRING]
+gnutls_pk_algorithm_get_name = _libraries['libgnutls.so.26'].gnutls_pk_algorithm_get_name
+gnutls_pk_algorithm_get_name.restype = STRING
+gnutls_pk_algorithm_get_name.argtypes = [gnutls_pk_algorithm_t]
+gnutls_sign_algorithm_get_name = _libraries['libgnutls.so.26'].gnutls_sign_algorithm_get_name
+gnutls_sign_algorithm_get_name.restype = STRING
+gnutls_sign_algorithm_get_name.argtypes = [gnutls_sign_algorithm_t]
+gnutls_init = _libraries['libgnutls.so.26'].gnutls_init
+gnutls_init.restype = c_int
+gnutls_init.argtypes = [POINTER(gnutls_session_t), gnutls_connection_end_t]
+gnutls_deinit = _libraries['libgnutls.so.26'].gnutls_deinit
+gnutls_deinit.restype = None
+gnutls_deinit.argtypes = [gnutls_session_t]
+gnutls_bye = _libraries['libgnutls.so.26'].gnutls_bye
+gnutls_bye.restype = c_int
+gnutls_bye.argtypes = [gnutls_session_t, gnutls_close_request_t]
+gnutls_handshake = _libraries['libgnutls.so.26'].gnutls_handshake
+gnutls_handshake.restype = c_int
+gnutls_handshake.argtypes = [gnutls_session_t]
+gnutls_rehandshake = _libraries['libgnutls.so.26'].gnutls_rehandshake
+gnutls_rehandshake.restype = c_int
+gnutls_rehandshake.argtypes = [gnutls_session_t]
+gnutls_alert_get = _libraries['libgnutls.so.26'].gnutls_alert_get
+gnutls_alert_get.restype = gnutls_alert_description_t
+gnutls_alert_get.argtypes = [gnutls_session_t]
+gnutls_alert_send = _libraries['libgnutls.so.26'].gnutls_alert_send
+gnutls_alert_send.restype = c_int
+gnutls_alert_send.argtypes = [gnutls_session_t, gnutls_alert_level_t, gnutls_alert_description_t]
+gnutls_alert_send_appropriate = _libraries['libgnutls.so.26'].gnutls_alert_send_appropriate
+gnutls_alert_send_appropriate.restype = c_int
+gnutls_alert_send_appropriate.argtypes = [gnutls_session_t, c_int]
+gnutls_alert_get_name = _libraries['libgnutls.so.26'].gnutls_alert_get_name
+gnutls_alert_get_name.restype = STRING
+gnutls_alert_get_name.argtypes = [gnutls_alert_description_t]
+gnutls_cipher_get = _libraries['libgnutls.so.26'].gnutls_cipher_get
+gnutls_cipher_get.restype = gnutls_cipher_algorithm_t
+gnutls_cipher_get.argtypes = [gnutls_session_t]
+gnutls_kx_get = _libraries['libgnutls.so.26'].gnutls_kx_get
+gnutls_kx_get.restype = gnutls_kx_algorithm_t
+gnutls_kx_get.argtypes = [gnutls_session_t]
+gnutls_mac_get = _libraries['libgnutls.so.26'].gnutls_mac_get
+gnutls_mac_get.restype = gnutls_mac_algorithm_t
+gnutls_mac_get.argtypes = [gnutls_session_t]
+gnutls_compression_get = _libraries['libgnutls.so.26'].gnutls_compression_get
+gnutls_compression_get.restype = gnutls_compression_method_t
+gnutls_compression_get.argtypes = [gnutls_session_t]
+gnutls_certificate_type_get = _libraries['libgnutls.so.26'].gnutls_certificate_type_get
+gnutls_certificate_type_get.restype = gnutls_certificate_type_t
+gnutls_certificate_type_get.argtypes = [gnutls_session_t]
+gnutls_cipher_get_key_size = _libraries['libgnutls.so.26'].gnutls_cipher_get_key_size
+gnutls_cipher_get_key_size.restype = size_t
+gnutls_cipher_get_key_size.argtypes = [gnutls_cipher_algorithm_t]
+gnutls_mac_get_key_size = _libraries['libgnutls.so.26'].gnutls_mac_get_key_size
+gnutls_mac_get_key_size.restype = size_t
+gnutls_mac_get_key_size.argtypes = [gnutls_mac_algorithm_t]
+gnutls_cipher_get_name = _libraries['libgnutls.so.26'].gnutls_cipher_get_name
+gnutls_cipher_get_name.restype = STRING
+gnutls_cipher_get_name.argtypes = [gnutls_cipher_algorithm_t]
+gnutls_mac_get_name = _libraries['libgnutls.so.26'].gnutls_mac_get_name
+gnutls_mac_get_name.restype = STRING
+gnutls_mac_get_name.argtypes = [gnutls_mac_algorithm_t]
+gnutls_compression_get_name = _libraries['libgnutls.so.26'].gnutls_compression_get_name
+gnutls_compression_get_name.restype = STRING
+gnutls_compression_get_name.argtypes = [gnutls_compression_method_t]
+gnutls_kx_get_name = _libraries['libgnutls.so.26'].gnutls_kx_get_name
+gnutls_kx_get_name.restype = STRING
+gnutls_kx_get_name.argtypes = [gnutls_kx_algorithm_t]
+gnutls_certificate_type_get_name = _libraries['libgnutls.so.26'].gnutls_certificate_type_get_name
+gnutls_certificate_type_get_name.restype = STRING
+gnutls_certificate_type_get_name.argtypes = [gnutls_certificate_type_t]
+gnutls_mac_get_id = _libraries['libgnutls.so.26'].gnutls_mac_get_id
+gnutls_mac_get_id.restype = gnutls_mac_algorithm_t
+gnutls_mac_get_id.argtypes = [STRING]
+gnutls_compression_get_id = _libraries['libgnutls.so.26'].gnutls_compression_get_id
+gnutls_compression_get_id.restype = gnutls_compression_method_t
+gnutls_compression_get_id.argtypes = [STRING]
+gnutls_cipher_get_id = _libraries['libgnutls.so.26'].gnutls_cipher_get_id
+gnutls_cipher_get_id.restype = gnutls_cipher_algorithm_t
+gnutls_cipher_get_id.argtypes = [STRING]
+gnutls_kx_get_id = _libraries['libgnutls.so.26'].gnutls_kx_get_id
+gnutls_kx_get_id.restype = gnutls_kx_algorithm_t
+gnutls_kx_get_id.argtypes = [STRING]
+gnutls_protocol_get_id = _libraries['libgnutls.so.26'].gnutls_protocol_get_id
+gnutls_protocol_get_id.restype = gnutls_protocol_t
+gnutls_protocol_get_id.argtypes = [STRING]
+gnutls_certificate_type_get_id = _libraries['libgnutls.so.26'].gnutls_certificate_type_get_id
+gnutls_certificate_type_get_id.restype = gnutls_certificate_type_t
+gnutls_certificate_type_get_id.argtypes = [STRING]
+gnutls_cipher_list = _libraries['libgnutls.so.26'].gnutls_cipher_list
+gnutls_cipher_list.restype = POINTER(gnutls_cipher_algorithm_t)
+gnutls_cipher_list.argtypes = []
+gnutls_mac_list = _libraries['libgnutls.so.26'].gnutls_mac_list
+gnutls_mac_list.restype = POINTER(gnutls_mac_algorithm_t)
+gnutls_mac_list.argtypes = []
+gnutls_compression_list = _libraries['libgnutls.so.26'].gnutls_compression_list
+gnutls_compression_list.restype = POINTER(gnutls_compression_method_t)
+gnutls_compression_list.argtypes = []
+gnutls_protocol_list = _libraries['libgnutls.so.26'].gnutls_protocol_list
+gnutls_protocol_list.restype = POINTER(gnutls_protocol_t)
+gnutls_protocol_list.argtypes = []
+gnutls_certificate_type_list = _libraries['libgnutls.so.26'].gnutls_certificate_type_list
+gnutls_certificate_type_list.restype = POINTER(gnutls_certificate_type_t)
+gnutls_certificate_type_list.argtypes = []
+gnutls_kx_list = _libraries['libgnutls.so.26'].gnutls_kx_list
+gnutls_kx_list.restype = POINTER(gnutls_kx_algorithm_t)
+gnutls_kx_list.argtypes = []
+gnutls_cipher_suite_info = _libraries['libgnutls.so.26'].gnutls_cipher_suite_info
+gnutls_cipher_suite_info.restype = STRING
+gnutls_cipher_suite_info.argtypes = [size_t, STRING, POINTER(gnutls_kx_algorithm_t), POINTER(gnutls_cipher_algorithm_t), POINTER(gnutls_mac_algorithm_t), POINTER(gnutls_protocol_t)]
+gnutls_error_is_fatal = _libraries['libgnutls.so.26'].gnutls_error_is_fatal
+gnutls_error_is_fatal.restype = c_int
+gnutls_error_is_fatal.argtypes = [c_int]
+gnutls_error_to_alert = _libraries['libgnutls.so.26'].gnutls_error_to_alert
+gnutls_error_to_alert.restype = c_int
+gnutls_error_to_alert.argtypes = [c_int, POINTER(c_int)]
+gnutls_perror = _libraries['libgnutls.so.26'].gnutls_perror
+gnutls_perror.restype = None
+gnutls_perror.argtypes = [c_int]
+gnutls_strerror = _libraries['libgnutls.so.26'].gnutls_strerror
+gnutls_strerror.restype = STRING
+gnutls_strerror.argtypes = [c_int]
+gnutls_handshake_set_private_extensions = _libraries['libgnutls.so.26'].gnutls_handshake_set_private_extensions
+gnutls_handshake_set_private_extensions.restype = None
+gnutls_handshake_set_private_extensions.argtypes = [gnutls_session_t, c_int]
+gnutls_handshake_get_last_out = _libraries['libgnutls.so.26'].gnutls_handshake_get_last_out
+gnutls_handshake_get_last_out.restype = gnutls_handshake_description_t
+gnutls_handshake_get_last_out.argtypes = [gnutls_session_t]
+gnutls_handshake_get_last_in = _libraries['libgnutls.so.26'].gnutls_handshake_get_last_in
+gnutls_handshake_get_last_in.restype = gnutls_handshake_description_t
+gnutls_handshake_get_last_in.argtypes = [gnutls_session_t]
+gnutls_record_send = _libraries['libgnutls.so.26'].gnutls_record_send
+gnutls_record_send.restype = ssize_t
+gnutls_record_send.argtypes = [gnutls_session_t, c_void_p, size_t]
+gnutls_record_recv = _libraries['libgnutls.so.26'].gnutls_record_recv
+gnutls_record_recv.restype = ssize_t
+gnutls_record_recv.argtypes = [gnutls_session_t, c_void_p, size_t]
+gnutls_session_enable_compatibility_mode = _libraries['libgnutls.so.26'].gnutls_session_enable_compatibility_mode
+gnutls_session_enable_compatibility_mode.restype = None
+gnutls_session_enable_compatibility_mode.argtypes = [gnutls_session_t]
+gnutls_record_disable_padding = _libraries['libgnutls.so.26'].gnutls_record_disable_padding
+gnutls_record_disable_padding.restype = None
+gnutls_record_disable_padding.argtypes = [gnutls_session_t]
+gnutls_record_get_direction = _libraries['libgnutls.so.26'].gnutls_record_get_direction
+gnutls_record_get_direction.restype = c_int
+gnutls_record_get_direction.argtypes = [gnutls_session_t]
+gnutls_record_get_max_size = _libraries['libgnutls.so.26'].gnutls_record_get_max_size
+gnutls_record_get_max_size.restype = size_t
+gnutls_record_get_max_size.argtypes = [gnutls_session_t]
+gnutls_record_set_max_size = _libraries['libgnutls.so.26'].gnutls_record_set_max_size
+gnutls_record_set_max_size.restype = ssize_t
+gnutls_record_set_max_size.argtypes = [gnutls_session_t, size_t]
+gnutls_record_check_pending = _libraries['libgnutls.so.26'].gnutls_record_check_pending
+gnutls_record_check_pending.restype = size_t
+gnutls_record_check_pending.argtypes = [gnutls_session_t]
+gnutls_prf = _libraries['libgnutls.so.26'].gnutls_prf
+gnutls_prf.restype = c_int
+gnutls_prf.argtypes = [gnutls_session_t, size_t, STRING, c_int, size_t, STRING, size_t, STRING]
+gnutls_prf_raw = _libraries['libgnutls.so.26'].gnutls_prf_raw
+gnutls_prf_raw.restype = c_int
+gnutls_prf_raw.argtypes = [gnutls_session_t, size_t, STRING, size_t, STRING, size_t, STRING]
+gnutls_server_name_set = _libraries['libgnutls.so.26'].gnutls_server_name_set
+gnutls_server_name_set.restype = c_int
+gnutls_server_name_set.argtypes = [gnutls_session_t, gnutls_server_name_type_t, c_void_p, size_t]
+gnutls_server_name_get = _libraries['libgnutls.so.26'].gnutls_server_name_get
+gnutls_server_name_get.restype = c_int
+gnutls_server_name_get.argtypes = [gnutls_session_t, c_void_p, POINTER(size_t), POINTER(c_uint), c_uint]
+gnutls_supplemental_get_name = _libraries['libgnutls.so.26'].gnutls_supplemental_get_name
+gnutls_supplemental_get_name.restype = STRING
+gnutls_supplemental_get_name.argtypes = [gnutls_supplemental_data_format_type_t]
+gnutls_cipher_set_priority = _libraries['libgnutls.so.26'].gnutls_cipher_set_priority
+gnutls_cipher_set_priority.restype = c_int
+gnutls_cipher_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)]
+gnutls_mac_set_priority = _libraries['libgnutls.so.26'].gnutls_mac_set_priority
+gnutls_mac_set_priority.restype = c_int
+gnutls_mac_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)]
+gnutls_compression_set_priority = _libraries['libgnutls.so.26'].gnutls_compression_set_priority
+gnutls_compression_set_priority.restype = c_int
+gnutls_compression_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)]
+gnutls_kx_set_priority = _libraries['libgnutls.so.26'].gnutls_kx_set_priority
+gnutls_kx_set_priority.restype = c_int
+gnutls_kx_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)]
+gnutls_protocol_set_priority = _libraries['libgnutls.so.26'].gnutls_protocol_set_priority
+gnutls_protocol_set_priority.restype = c_int
+gnutls_protocol_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)]
+gnutls_certificate_type_set_priority = _libraries['libgnutls.so.26'].gnutls_certificate_type_set_priority
+gnutls_certificate_type_set_priority.restype = c_int
+gnutls_certificate_type_set_priority.argtypes = [gnutls_session_t, POINTER(c_int)]
+gnutls_priority_init = _libraries['libgnutls.so.26'].gnutls_priority_init
+gnutls_priority_init.restype = c_int
+gnutls_priority_init.argtypes = [POINTER(gnutls_priority_t), STRING, POINTER(STRING)]
+gnutls_priority_deinit = _libraries['libgnutls.so.26'].gnutls_priority_deinit
+gnutls_priority_deinit.restype = None
+gnutls_priority_deinit.argtypes = [gnutls_priority_t]
+gnutls_priority_set = _libraries['libgnutls.so.26'].gnutls_priority_set
+gnutls_priority_set.restype = c_int
+gnutls_priority_set.argtypes = [gnutls_session_t, gnutls_priority_t]
+gnutls_priority_set_direct = _libraries['libgnutls.so.26'].gnutls_priority_set_direct
+gnutls_priority_set_direct.restype = c_int
+gnutls_priority_set_direct.argtypes = [gnutls_session_t, STRING, POINTER(STRING)]
+gnutls_set_default_priority = _libraries['libgnutls.so.26'].gnutls_set_default_priority
+gnutls_set_default_priority.restype = c_int
+gnutls_set_default_priority.argtypes = [gnutls_session_t]
+gnutls_set_default_export_priority = _libraries['libgnutls.so.26'].gnutls_set_default_export_priority
+gnutls_set_default_export_priority.restype = c_int
+gnutls_set_default_export_priority.argtypes = [gnutls_session_t]
+gnutls_cipher_suite_get_name = _libraries['libgnutls.so.26'].gnutls_cipher_suite_get_name
+gnutls_cipher_suite_get_name.restype = STRING
+gnutls_cipher_suite_get_name.argtypes = [gnutls_kx_algorithm_t, gnutls_cipher_algorithm_t, gnutls_mac_algorithm_t]
+gnutls_protocol_get_version = _libraries['libgnutls.so.26'].gnutls_protocol_get_version
+gnutls_protocol_get_version.restype = gnutls_protocol_t
+gnutls_protocol_get_version.argtypes = [gnutls_session_t]
+gnutls_protocol_get_name = _libraries['libgnutls.so.26'].gnutls_protocol_get_name
+gnutls_protocol_get_name.restype = STRING
+gnutls_protocol_get_name.argtypes = [gnutls_protocol_t]
+gnutls_session_set_data = _libraries['libgnutls.so.26'].gnutls_session_set_data
+gnutls_session_set_data.restype = c_int
+gnutls_session_set_data.argtypes = [gnutls_session_t, c_void_p, size_t]
+gnutls_session_get_data = _libraries['libgnutls.so.26'].gnutls_session_get_data
+gnutls_session_get_data.restype = c_int
+gnutls_session_get_data.argtypes = [gnutls_session_t, c_void_p, POINTER(size_t)]
+gnutls_session_get_data2 = _libraries['libgnutls.so.26'].gnutls_session_get_data2
+gnutls_session_get_data2.restype = c_int
+gnutls_session_get_data2.argtypes = [gnutls_session_t, POINTER(gnutls_datum_t)]
+gnutls_session_get_id = _libraries['libgnutls.so.26'].gnutls_session_get_id
+gnutls_session_get_id.restype = c_int
+gnutls_session_get_id.argtypes = [gnutls_session_t, c_void_p, POINTER(size_t)]
+gnutls_session_get_server_random = _libraries['libgnutls.so.26'].gnutls_session_get_server_random
+gnutls_session_get_server_random.restype = c_void_p
+gnutls_session_get_server_random.argtypes = [gnutls_session_t]
+gnutls_session_get_client_random = _libraries['libgnutls.so.26'].gnutls_session_get_client_random
+gnutls_session_get_client_random.restype = c_void_p
+gnutls_session_get_client_random.argtypes = [gnutls_session_t]
+gnutls_session_get_master_secret = _libraries['libgnutls.so.26'].gnutls_session_get_master_secret
+gnutls_session_get_master_secret.restype = c_void_p
+gnutls_session_get_master_secret.argtypes = [gnutls_session_t]
+gnutls_session_is_resumed = _libraries['libgnutls.so.26'].gnutls_session_is_resumed
+gnutls_session_is_resumed.restype = c_int
+gnutls_session_is_resumed.argtypes = [gnutls_session_t]
+gnutls_db_set_cache_expiration = _libraries['libgnutls.so.26'].gnutls_db_set_cache_expiration
+gnutls_db_set_cache_expiration.restype = None
+gnutls_db_set_cache_expiration.argtypes = [gnutls_session_t, c_int]
+gnutls_db_remove_session = _libraries['libgnutls.so.26'].gnutls_db_remove_session
+gnutls_db_remove_session.restype = None
+gnutls_db_remove_session.argtypes = [gnutls_session_t]
+gnutls_db_set_retrieve_function = _libraries['libgnutls.so.26'].gnutls_db_set_retrieve_function
+gnutls_db_set_retrieve_function.restype = None
+gnutls_db_set_retrieve_function.argtypes = [gnutls_session_t, gnutls_db_retr_func]
+gnutls_db_set_remove_function = _libraries['libgnutls.so.26'].gnutls_db_set_remove_function
+gnutls_db_set_remove_function.restype = None
+gnutls_db_set_remove_function.argtypes = [gnutls_session_t, gnutls_db_remove_func]
+gnutls_db_set_store_function = _libraries['libgnutls.so.26'].gnutls_db_set_store_function
+gnutls_db_set_store_function.restype = None
+gnutls_db_set_store_function.argtypes = [gnutls_session_t, gnutls_db_store_func]
+gnutls_db_set_ptr = _libraries['libgnutls.so.26'].gnutls_db_set_ptr
+gnutls_db_set_ptr.restype = None
+gnutls_db_set_ptr.argtypes = [gnutls_session_t, c_void_p]
+gnutls_db_get_ptr = _libraries['libgnutls.so.26'].gnutls_db_get_ptr
+gnutls_db_get_ptr.restype = c_void_p
+gnutls_db_get_ptr.argtypes = [gnutls_session_t]
+gnutls_db_check_entry = _libraries['libgnutls.so.26'].gnutls_db_check_entry
+gnutls_db_check_entry.restype = c_int
+gnutls_db_check_entry.argtypes = [gnutls_session_t, gnutls_datum_t]
+gnutls_handshake_set_post_client_hello_function = _libraries['libgnutls.so.26'].gnutls_handshake_set_post_client_hello_function
+gnutls_handshake_set_post_client_hello_function.restype = None
+gnutls_handshake_set_post_client_hello_function.argtypes = [gnutls_session_t, gnutls_handshake_post_client_hello_func]
+gnutls_handshake_set_max_packet_length = _libraries['libgnutls.so.26'].gnutls_handshake_set_max_packet_length
+gnutls_handshake_set_max_packet_length.restype = None
+gnutls_handshake_set_max_packet_length.argtypes = [gnutls_session_t, size_t]
+gnutls_check_version = _libraries['libgnutls.so.26'].gnutls_check_version
+gnutls_check_version.restype = STRING
+gnutls_check_version.argtypes = [STRING]
+gnutls_credentials_clear = _libraries['libgnutls.so.26'].gnutls_credentials_clear
+gnutls_credentials_clear.restype = None
+gnutls_credentials_clear.argtypes = [gnutls_session_t]
+gnutls_credentials_set = _libraries['libgnutls.so.26'].gnutls_credentials_set
+gnutls_credentials_set.restype = c_int
+gnutls_credentials_set.argtypes = [gnutls_session_t, gnutls_credentials_type_t, c_void_p]
+gnutls_anon_free_server_credentials = _libraries['libgnutls.so.26'].gnutls_anon_free_server_credentials
+gnutls_anon_free_server_credentials.restype = None
+gnutls_anon_free_server_credentials.argtypes = [gnutls_anon_server_credentials_t]
+gnutls_anon_allocate_server_credentials = _libraries['libgnutls.so.26'].gnutls_anon_allocate_server_credentials
+gnutls_anon_allocate_server_credentials.restype = c_int
+gnutls_anon_allocate_server_credentials.argtypes = [POINTER(gnutls_anon_server_credentials_t)]
+gnutls_anon_set_server_dh_params = _libraries['libgnutls.so.26'].gnutls_anon_set_server_dh_params
+gnutls_anon_set_server_dh_params.restype = None
+gnutls_anon_set_server_dh_params.argtypes = [gnutls_anon_server_credentials_t, gnutls_dh_params_t]
+gnutls_anon_set_server_params_function = _libraries['libgnutls.so.26'].gnutls_anon_set_server_params_function
+gnutls_anon_set_server_params_function.restype = None
+gnutls_anon_set_server_params_function.argtypes = [gnutls_anon_server_credentials_t, gnutls_params_function]
+gnutls_anon_free_client_credentials = _libraries['libgnutls.so.26'].gnutls_anon_free_client_credentials
+gnutls_anon_free_client_credentials.restype = None
+gnutls_anon_free_client_credentials.argtypes = [gnutls_anon_client_credentials_t]
+gnutls_anon_allocate_client_credentials = _libraries['libgnutls.so.26'].gnutls_anon_allocate_client_credentials
+gnutls_anon_allocate_client_credentials.restype = c_int
+gnutls_anon_allocate_client_credentials.argtypes = [POINTER(gnutls_anon_client_credentials_t)]
+gnutls_certificate_free_credentials = _libraries['libgnutls.so.26'].gnutls_certificate_free_credentials
+gnutls_certificate_free_credentials.restype = None
+gnutls_certificate_free_credentials.argtypes = [gnutls_certificate_credentials_t]
+gnutls_certificate_allocate_credentials = _libraries['libgnutls.so.26'].gnutls_certificate_allocate_credentials
+gnutls_certificate_allocate_credentials.restype = c_int
+gnutls_certificate_allocate_credentials.argtypes = [POINTER(gnutls_certificate_credentials_t)]
+gnutls_certificate_free_keys = _libraries['libgnutls.so.26'].gnutls_certificate_free_keys
+gnutls_certificate_free_keys.restype = None
+gnutls_certificate_free_keys.argtypes = [gnutls_certificate_credentials_t]
+gnutls_certificate_free_cas = _libraries['libgnutls.so.26'].gnutls_certificate_free_cas
+gnutls_certificate_free_cas.restype = None
+gnutls_certificate_free_cas.argtypes = [gnutls_certificate_credentials_t]
+gnutls_certificate_free_ca_names = _libraries['libgnutls.so.26'].gnutls_certificate_free_ca_names
+gnutls_certificate_free_ca_names.restype = None
+gnutls_certificate_free_ca_names.argtypes = [gnutls_certificate_credentials_t]
+gnutls_certificate_free_crls = _libraries['libgnutls.so.26'].gnutls_certificate_free_crls
+gnutls_certificate_free_crls.restype = None
+gnutls_certificate_free_crls.argtypes = [gnutls_certificate_credentials_t]
+gnutls_certificate_set_dh_params = _libraries['libgnutls.so.26'].gnutls_certificate_set_dh_params
+gnutls_certificate_set_dh_params.restype = None
+gnutls_certificate_set_dh_params.argtypes = [gnutls_certificate_credentials_t, gnutls_dh_params_t]
+gnutls_certificate_set_rsa_export_params = _libraries['libgnutls.so.26'].gnutls_certificate_set_rsa_export_params
+gnutls_certificate_set_rsa_export_params.restype = None
+gnutls_certificate_set_rsa_export_params.argtypes = [gnutls_certificate_credentials_t, gnutls_rsa_params_t]
+gnutls_certificate_set_verify_flags = _libraries['libgnutls.so.26'].gnutls_certificate_set_verify_flags
+gnutls_certificate_set_verify_flags.restype = None
+gnutls_certificate_set_verify_flags.argtypes = [gnutls_certificate_credentials_t, c_uint]
+gnutls_certificate_set_verify_limits = _libraries['libgnutls.so.26'].gnutls_certificate_set_verify_limits
+gnutls_certificate_set_verify_limits.restype = None
+gnutls_certificate_set_verify_limits.argtypes = [gnutls_certificate_credentials_t, c_uint, c_uint]
+gnutls_certificate_set_x509_trust_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_trust_file
+gnutls_certificate_set_x509_trust_file.restype = c_int
+gnutls_certificate_set_x509_trust_file.argtypes = [gnutls_certificate_credentials_t, STRING, gnutls_x509_crt_fmt_t]
+gnutls_certificate_set_x509_trust_mem = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_trust_mem
+gnutls_certificate_set_x509_trust_mem.restype = c_int
+gnutls_certificate_set_x509_trust_mem.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_certificate_set_x509_crl_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_crl_file
+gnutls_certificate_set_x509_crl_file.restype = c_int
+gnutls_certificate_set_x509_crl_file.argtypes = [gnutls_certificate_credentials_t, STRING, gnutls_x509_crt_fmt_t]
+gnutls_certificate_set_x509_crl_mem = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_crl_mem
+gnutls_certificate_set_x509_crl_mem.restype = c_int
+gnutls_certificate_set_x509_crl_mem.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_certificate_set_x509_key_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_key_file
+gnutls_certificate_set_x509_key_file.restype = c_int
+gnutls_certificate_set_x509_key_file.argtypes = [gnutls_certificate_credentials_t, STRING, STRING, gnutls_x509_crt_fmt_t]
+gnutls_certificate_set_x509_key_mem = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_key_mem
+gnutls_certificate_set_x509_key_mem.restype = c_int
+gnutls_certificate_set_x509_key_mem.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_certificate_send_x509_rdn_sequence = _libraries['libgnutls.so.26'].gnutls_certificate_send_x509_rdn_sequence
+gnutls_certificate_send_x509_rdn_sequence.restype = None
+gnutls_certificate_send_x509_rdn_sequence.argtypes = [gnutls_session_t, c_int]
+gnutls_certificate_set_x509_simple_pkcs12_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_simple_pkcs12_file
+gnutls_certificate_set_x509_simple_pkcs12_file.restype = c_int
+gnutls_certificate_set_x509_simple_pkcs12_file.argtypes = [gnutls_certificate_credentials_t, STRING, gnutls_x509_crt_fmt_t, STRING]
+gnutls_certificate_set_x509_key = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_key
+gnutls_certificate_set_x509_key.restype = c_int
+gnutls_certificate_set_x509_key.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_x509_crt_t), c_int, gnutls_x509_privkey_t]
+gnutls_certificate_set_x509_trust = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_trust
+gnutls_certificate_set_x509_trust.restype = c_int
+gnutls_certificate_set_x509_trust.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_x509_crt_t), c_int]
+gnutls_certificate_set_x509_crl = _libraries['libgnutls.so.26'].gnutls_certificate_set_x509_crl
+gnutls_certificate_set_x509_crl.restype = c_int
+gnutls_certificate_set_x509_crl.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_x509_crl_t), c_int]
+gnutls_certificate_get_x509_cas = _libraries['libgnutls.so.26'].gnutls_certificate_get_x509_cas
+gnutls_certificate_get_x509_cas.restype = None
+gnutls_certificate_get_x509_cas.argtypes = [gnutls_certificate_credentials_t, POINTER(POINTER(gnutls_x509_crt_t)), POINTER(c_uint)]
+gnutls_certificate_get_x509_crls = _libraries['libgnutls.so.26'].gnutls_certificate_get_x509_crls
+gnutls_certificate_get_x509_crls.restype = None
+gnutls_certificate_get_x509_crls.argtypes = [gnutls_certificate_credentials_t, POINTER(POINTER(gnutls_x509_crl_t)), POINTER(c_uint)]
+gnutls_certificate_get_openpgp_keyring = _libraries['libgnutls.so.26'].gnutls_certificate_get_openpgp_keyring
+gnutls_certificate_get_openpgp_keyring.restype = None
+gnutls_certificate_get_openpgp_keyring.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_openpgp_keyring_t)]
+gnutls_global_init = _libraries['libgnutls.so.26'].gnutls_global_init
+gnutls_global_init.restype = c_int
+gnutls_global_init.argtypes = []
+gnutls_global_deinit = _libraries['libgnutls.so.26'].gnutls_global_deinit
+gnutls_global_deinit.restype = None
+gnutls_global_deinit.argtypes = []
+gnutls_global_set_mem_functions = _libraries['libgnutls.so.26'].gnutls_global_set_mem_functions
+gnutls_global_set_mem_functions.restype = None
+gnutls_global_set_mem_functions.argtypes = [gnutls_alloc_function, gnutls_alloc_function, gnutls_is_secure_function, gnutls_realloc_function, gnutls_free_function]
+gnutls_global_set_log_function = _libraries['libgnutls.so.26'].gnutls_global_set_log_function
+gnutls_global_set_log_function.restype = None
+gnutls_global_set_log_function.argtypes = [gnutls_log_func]
+gnutls_global_set_log_level = _libraries['libgnutls.so.26'].gnutls_global_set_log_level
+gnutls_global_set_log_level.restype = None
+gnutls_global_set_log_level.argtypes = [c_int]
+gnutls_dh_params_init = _libraries['libgnutls.so.26'].gnutls_dh_params_init
+gnutls_dh_params_init.restype = c_int
+gnutls_dh_params_init.argtypes = [POINTER(gnutls_dh_params_t)]
+gnutls_dh_params_deinit = _libraries['libgnutls.so.26'].gnutls_dh_params_deinit
+gnutls_dh_params_deinit.restype = None
+gnutls_dh_params_deinit.argtypes = [gnutls_dh_params_t]
+gnutls_dh_params_import_raw = _libraries['libgnutls.so.26'].gnutls_dh_params_import_raw
+gnutls_dh_params_import_raw.restype = c_int
+gnutls_dh_params_import_raw.argtypes = [gnutls_dh_params_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_dh_params_import_pkcs3 = _libraries['libgnutls.so.26'].gnutls_dh_params_import_pkcs3
+gnutls_dh_params_import_pkcs3.restype = c_int
+gnutls_dh_params_import_pkcs3.argtypes = [gnutls_dh_params_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_dh_params_generate2 = _libraries['libgnutls.so.26'].gnutls_dh_params_generate2
+gnutls_dh_params_generate2.restype = c_int
+gnutls_dh_params_generate2.argtypes = [gnutls_dh_params_t, c_uint]
+gnutls_dh_params_export_pkcs3 = _libraries['libgnutls.so.26'].gnutls_dh_params_export_pkcs3
+gnutls_dh_params_export_pkcs3.restype = c_int
+gnutls_dh_params_export_pkcs3.argtypes = [gnutls_dh_params_t, gnutls_x509_crt_fmt_t, POINTER(c_ubyte), POINTER(size_t)]
+gnutls_dh_params_export_raw = _libraries['libgnutls.so.26'].gnutls_dh_params_export_raw
+gnutls_dh_params_export_raw.restype = c_int
+gnutls_dh_params_export_raw.argtypes = [gnutls_dh_params_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(c_uint)]
+gnutls_dh_params_cpy = _libraries['libgnutls.so.26'].gnutls_dh_params_cpy
+gnutls_dh_params_cpy.restype = c_int
+gnutls_dh_params_cpy.argtypes = [gnutls_dh_params_t, gnutls_dh_params_t]
+gnutls_rsa_params_init = _libraries['libgnutls.so.26'].gnutls_rsa_params_init
+gnutls_rsa_params_init.restype = c_int
+gnutls_rsa_params_init.argtypes = [POINTER(gnutls_rsa_params_t)]
+gnutls_rsa_params_deinit = _libraries['libgnutls.so.26'].gnutls_rsa_params_deinit
+gnutls_rsa_params_deinit.restype = None
+gnutls_rsa_params_deinit.argtypes = [gnutls_rsa_params_t]
+gnutls_rsa_params_cpy = _libraries['libgnutls.so.26'].gnutls_rsa_params_cpy
+gnutls_rsa_params_cpy.restype = c_int
+gnutls_rsa_params_cpy.argtypes = [gnutls_rsa_params_t, gnutls_rsa_params_t]
+gnutls_rsa_params_import_raw = _libraries['libgnutls.so.26'].gnutls_rsa_params_import_raw
+gnutls_rsa_params_import_raw.restype = c_int
+gnutls_rsa_params_import_raw.argtypes = [gnutls_rsa_params_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_rsa_params_generate2 = _libraries['libgnutls.so.26'].gnutls_rsa_params_generate2
+gnutls_rsa_params_generate2.restype = c_int
+gnutls_rsa_params_generate2.argtypes = [gnutls_rsa_params_t, c_uint]
+gnutls_rsa_params_export_raw = _libraries['libgnutls.so.26'].gnutls_rsa_params_export_raw
+gnutls_rsa_params_export_raw.restype = c_int
+gnutls_rsa_params_export_raw.argtypes = [gnutls_rsa_params_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(c_uint)]
+gnutls_rsa_params_export_pkcs1 = _libraries['libgnutls.so.26'].gnutls_rsa_params_export_pkcs1
+gnutls_rsa_params_export_pkcs1.restype = c_int
+gnutls_rsa_params_export_pkcs1.argtypes = [gnutls_rsa_params_t, gnutls_x509_crt_fmt_t, POINTER(c_ubyte), POINTER(size_t)]
+gnutls_rsa_params_import_pkcs1 = _libraries['libgnutls.so.26'].gnutls_rsa_params_import_pkcs1
+gnutls_rsa_params_import_pkcs1.restype = c_int
+gnutls_rsa_params_import_pkcs1.argtypes = [gnutls_rsa_params_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_transport_set_ptr = _libraries['libgnutls.so.26'].gnutls_transport_set_ptr
+gnutls_transport_set_ptr.restype = None
+gnutls_transport_set_ptr.argtypes = [gnutls_session_t, gnutls_transport_ptr_t]
+gnutls_transport_set_ptr2 = _libraries['libgnutls.so.26'].gnutls_transport_set_ptr2
+gnutls_transport_set_ptr2.restype = None
+gnutls_transport_set_ptr2.argtypes = [gnutls_session_t, gnutls_transport_ptr_t, gnutls_transport_ptr_t]
+gnutls_transport_get_ptr = _libraries['libgnutls.so.26'].gnutls_transport_get_ptr
+gnutls_transport_get_ptr.restype = gnutls_transport_ptr_t
+gnutls_transport_get_ptr.argtypes = [gnutls_session_t]
+gnutls_transport_get_ptr2 = _libraries['libgnutls.so.26'].gnutls_transport_get_ptr2
+gnutls_transport_get_ptr2.restype = None
+gnutls_transport_get_ptr2.argtypes = [gnutls_session_t, POINTER(gnutls_transport_ptr_t), POINTER(gnutls_transport_ptr_t)]
+gnutls_transport_set_lowat = _libraries['libgnutls.so.26'].gnutls_transport_set_lowat
+gnutls_transport_set_lowat.restype = None
+gnutls_transport_set_lowat.argtypes = [gnutls_session_t, c_int]
+gnutls_transport_set_push_function = _libraries['libgnutls.so.26'].gnutls_transport_set_push_function
+gnutls_transport_set_push_function.restype = None
+gnutls_transport_set_push_function.argtypes = [gnutls_session_t, gnutls_push_func]
+gnutls_transport_set_pull_function = _libraries['libgnutls.so.26'].gnutls_transport_set_pull_function
+gnutls_transport_set_pull_function.restype = None
+gnutls_transport_set_pull_function.argtypes = [gnutls_session_t, gnutls_pull_func]
+gnutls_transport_set_errno = _libraries['libgnutls.so.26'].gnutls_transport_set_errno
+gnutls_transport_set_errno.restype = None
+gnutls_transport_set_errno.argtypes = [gnutls_session_t, c_int]
+gnutls_transport_set_global_errno = _libraries['libgnutls.so.26'].gnutls_transport_set_global_errno
+gnutls_transport_set_global_errno.restype = None
+gnutls_transport_set_global_errno.argtypes = [c_int]
+gnutls_session_set_ptr = _libraries['libgnutls.so.26'].gnutls_session_set_ptr
+gnutls_session_set_ptr.restype = None
+gnutls_session_set_ptr.argtypes = [gnutls_session_t, c_void_p]
+gnutls_session_get_ptr = _libraries['libgnutls.so.26'].gnutls_session_get_ptr
+gnutls_session_get_ptr.restype = c_void_p
+gnutls_session_get_ptr.argtypes = [gnutls_session_t]
+gnutls_openpgp_send_cert = _libraries['libgnutls.so.26'].gnutls_openpgp_send_cert
+gnutls_openpgp_send_cert.restype = None
+gnutls_openpgp_send_cert.argtypes = [gnutls_session_t, gnutls_openpgp_crt_status_t]
+gnutls_fingerprint = _libraries['libgnutls.so.26'].gnutls_fingerprint
+gnutls_fingerprint.restype = c_int
+gnutls_fingerprint.argtypes = [gnutls_digest_algorithm_t, POINTER(gnutls_datum_t), c_void_p, POINTER(size_t)]
+gnutls_srp_free_client_credentials = _libraries['libgnutls.so.26'].gnutls_srp_free_client_credentials
+gnutls_srp_free_client_credentials.restype = None
+gnutls_srp_free_client_credentials.argtypes = [gnutls_srp_client_credentials_t]
+gnutls_srp_allocate_client_credentials = _libraries['libgnutls.so.26'].gnutls_srp_allocate_client_credentials
+gnutls_srp_allocate_client_credentials.restype = c_int
+gnutls_srp_allocate_client_credentials.argtypes = [POINTER(gnutls_srp_client_credentials_t)]
+gnutls_srp_set_client_credentials = _libraries['libgnutls.so.26'].gnutls_srp_set_client_credentials
+gnutls_srp_set_client_credentials.restype = c_int
+gnutls_srp_set_client_credentials.argtypes = [gnutls_srp_client_credentials_t, STRING, STRING]
+gnutls_srp_free_server_credentials = _libraries['libgnutls.so.26'].gnutls_srp_free_server_credentials
+gnutls_srp_free_server_credentials.restype = None
+gnutls_srp_free_server_credentials.argtypes = [gnutls_srp_server_credentials_t]
+gnutls_srp_allocate_server_credentials = _libraries['libgnutls.so.26'].gnutls_srp_allocate_server_credentials
+gnutls_srp_allocate_server_credentials.restype = c_int
+gnutls_srp_allocate_server_credentials.argtypes = [POINTER(gnutls_srp_server_credentials_t)]
+gnutls_srp_set_server_credentials_file = _libraries['libgnutls.so.26'].gnutls_srp_set_server_credentials_file
+gnutls_srp_set_server_credentials_file.restype = c_int
+gnutls_srp_set_server_credentials_file.argtypes = [gnutls_srp_server_credentials_t, STRING, STRING]
+gnutls_srp_server_get_username = _libraries['libgnutls.so.26'].gnutls_srp_server_get_username
+gnutls_srp_server_get_username.restype = STRING
+gnutls_srp_server_get_username.argtypes = [gnutls_session_t]
+gnutls_srp_verifier = _libraries['libgnutls.so.26'].gnutls_srp_verifier
+gnutls_srp_verifier.restype = c_int
+gnutls_srp_verifier.argtypes = [STRING, STRING, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_srp_set_server_credentials_function = _libraries['libgnutls.so.26'].gnutls_srp_set_server_credentials_function
+gnutls_srp_set_server_credentials_function.restype = None
+gnutls_srp_set_server_credentials_function.argtypes = [gnutls_srp_server_credentials_t, gnutls_srp_server_credentials_function]
+gnutls_srp_set_client_credentials_function = _libraries['libgnutls.so.26'].gnutls_srp_set_client_credentials_function
+gnutls_srp_set_client_credentials_function.restype = None
+gnutls_srp_set_client_credentials_function.argtypes = [gnutls_srp_client_credentials_t, gnutls_srp_client_credentials_function]
+gnutls_srp_base64_encode = _libraries['libgnutls.so.26'].gnutls_srp_base64_encode
+gnutls_srp_base64_encode.restype = c_int
+gnutls_srp_base64_encode.argtypes = [POINTER(gnutls_datum_t), STRING, POINTER(size_t)]
+gnutls_srp_base64_encode_alloc = _libraries['libgnutls.so.26'].gnutls_srp_base64_encode_alloc
+gnutls_srp_base64_encode_alloc.restype = c_int
+gnutls_srp_base64_encode_alloc.argtypes = [POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_srp_base64_decode = _libraries['libgnutls.so.26'].gnutls_srp_base64_decode
+gnutls_srp_base64_decode.restype = c_int
+gnutls_srp_base64_decode.argtypes = [POINTER(gnutls_datum_t), STRING, POINTER(size_t)]
+gnutls_srp_base64_decode_alloc = _libraries['libgnutls.so.26'].gnutls_srp_base64_decode_alloc
+gnutls_srp_base64_decode_alloc.restype = c_int
+gnutls_srp_base64_decode_alloc.argtypes = [POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_psk_free_client_credentials = _libraries['libgnutls.so.26'].gnutls_psk_free_client_credentials
+gnutls_psk_free_client_credentials.restype = None
+gnutls_psk_free_client_credentials.argtypes = [gnutls_psk_client_credentials_t]
+gnutls_psk_allocate_client_credentials = _libraries['libgnutls.so.26'].gnutls_psk_allocate_client_credentials
+gnutls_psk_allocate_client_credentials.restype = c_int
+gnutls_psk_allocate_client_credentials.argtypes = [POINTER(gnutls_psk_client_credentials_t)]
+gnutls_psk_set_client_credentials = _libraries['libgnutls.so.26'].gnutls_psk_set_client_credentials
+gnutls_psk_set_client_credentials.restype = c_int
+gnutls_psk_set_client_credentials.argtypes = [gnutls_psk_client_credentials_t, STRING, POINTER(gnutls_datum_t), gnutls_psk_key_flags]
+gnutls_psk_free_server_credentials = _libraries['libgnutls.so.26'].gnutls_psk_free_server_credentials
+gnutls_psk_free_server_credentials.restype = None
+gnutls_psk_free_server_credentials.argtypes = [gnutls_psk_server_credentials_t]
+gnutls_psk_allocate_server_credentials = _libraries['libgnutls.so.26'].gnutls_psk_allocate_server_credentials
+gnutls_psk_allocate_server_credentials.restype = c_int
+gnutls_psk_allocate_server_credentials.argtypes = [POINTER(gnutls_psk_server_credentials_t)]
+gnutls_psk_set_server_credentials_file = _libraries['libgnutls.so.26'].gnutls_psk_set_server_credentials_file
+gnutls_psk_set_server_credentials_file.restype = c_int
+gnutls_psk_set_server_credentials_file.argtypes = [gnutls_psk_server_credentials_t, STRING]
+gnutls_psk_set_server_credentials_hint = _libraries['libgnutls.so.26'].gnutls_psk_set_server_credentials_hint
+gnutls_psk_set_server_credentials_hint.restype = c_int
+gnutls_psk_set_server_credentials_hint.argtypes = [gnutls_psk_server_credentials_t, STRING]
+gnutls_psk_server_get_username = _libraries['libgnutls.so.26'].gnutls_psk_server_get_username
+gnutls_psk_server_get_username.restype = STRING
+gnutls_psk_server_get_username.argtypes = [gnutls_session_t]
+gnutls_psk_client_get_hint = _libraries['libgnutls.so.26'].gnutls_psk_client_get_hint
+gnutls_psk_client_get_hint.restype = STRING
+gnutls_psk_client_get_hint.argtypes = [gnutls_session_t]
+gnutls_psk_set_server_credentials_function = _libraries['libgnutls.so.26'].gnutls_psk_set_server_credentials_function
+gnutls_psk_set_server_credentials_function.restype = None
+gnutls_psk_set_server_credentials_function.argtypes = [gnutls_psk_server_credentials_t, gnutls_psk_server_credentials_function]
+gnutls_psk_set_client_credentials_function = _libraries['libgnutls.so.26'].gnutls_psk_set_client_credentials_function
+gnutls_psk_set_client_credentials_function.restype = None
+gnutls_psk_set_client_credentials_function.argtypes = [gnutls_psk_client_credentials_t, gnutls_psk_client_credentials_function]
+gnutls_hex_encode = _libraries['libgnutls.so.26'].gnutls_hex_encode
+gnutls_hex_encode.restype = c_int
+gnutls_hex_encode.argtypes = [POINTER(gnutls_datum_t), STRING, POINTER(size_t)]
+gnutls_hex_decode = _libraries['libgnutls.so.26'].gnutls_hex_decode
+gnutls_hex_decode.restype = c_int
+gnutls_hex_decode.argtypes = [POINTER(gnutls_datum_t), STRING, POINTER(size_t)]
+gnutls_psk_set_server_dh_params = _libraries['libgnutls.so.26'].gnutls_psk_set_server_dh_params
+gnutls_psk_set_server_dh_params.restype = None
+gnutls_psk_set_server_dh_params.argtypes = [gnutls_psk_server_credentials_t, gnutls_dh_params_t]
+gnutls_psk_set_server_params_function = _libraries['libgnutls.so.26'].gnutls_psk_set_server_params_function
+gnutls_psk_set_server_params_function.restype = None
+gnutls_psk_set_server_params_function.argtypes = [gnutls_psk_server_credentials_t, gnutls_params_function]
+gnutls_psk_netconf_derive_key = _libraries['libgnutls.so.26'].gnutls_psk_netconf_derive_key
+gnutls_psk_netconf_derive_key.restype = c_int
+gnutls_psk_netconf_derive_key.argtypes = [STRING, STRING, STRING, POINTER(gnutls_datum_t)]
+gnutls_auth_get_type = _libraries['libgnutls.so.26'].gnutls_auth_get_type
+gnutls_auth_get_type.restype = gnutls_credentials_type_t
+gnutls_auth_get_type.argtypes = [gnutls_session_t]
+gnutls_auth_server_get_type = _libraries['libgnutls.so.26'].gnutls_auth_server_get_type
+gnutls_auth_server_get_type.restype = gnutls_credentials_type_t
+gnutls_auth_server_get_type.argtypes = [gnutls_session_t]
+gnutls_auth_client_get_type = _libraries['libgnutls.so.26'].gnutls_auth_client_get_type
+gnutls_auth_client_get_type.restype = gnutls_credentials_type_t
+gnutls_auth_client_get_type.argtypes = [gnutls_session_t]
+gnutls_dh_set_prime_bits = _libraries['libgnutls.so.26'].gnutls_dh_set_prime_bits
+gnutls_dh_set_prime_bits.restype = None
+gnutls_dh_set_prime_bits.argtypes = [gnutls_session_t, c_uint]
+gnutls_dh_get_secret_bits = _libraries['libgnutls.so.26'].gnutls_dh_get_secret_bits
+gnutls_dh_get_secret_bits.restype = c_int
+gnutls_dh_get_secret_bits.argtypes = [gnutls_session_t]
+gnutls_dh_get_peers_public_bits = _libraries['libgnutls.so.26'].gnutls_dh_get_peers_public_bits
+gnutls_dh_get_peers_public_bits.restype = c_int
+gnutls_dh_get_peers_public_bits.argtypes = [gnutls_session_t]
+gnutls_dh_get_prime_bits = _libraries['libgnutls.so.26'].gnutls_dh_get_prime_bits
+gnutls_dh_get_prime_bits.restype = c_int
+gnutls_dh_get_prime_bits.argtypes = [gnutls_session_t]
+gnutls_dh_get_group = _libraries['libgnutls.so.26'].gnutls_dh_get_group
+gnutls_dh_get_group.restype = c_int
+gnutls_dh_get_group.argtypes = [gnutls_session_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_dh_get_pubkey = _libraries['libgnutls.so.26'].gnutls_dh_get_pubkey
+gnutls_dh_get_pubkey.restype = c_int
+gnutls_dh_get_pubkey.argtypes = [gnutls_session_t, POINTER(gnutls_datum_t)]
+gnutls_rsa_export_get_pubkey = _libraries['libgnutls.so.26'].gnutls_rsa_export_get_pubkey
+gnutls_rsa_export_get_pubkey.restype = c_int
+gnutls_rsa_export_get_pubkey.argtypes = [gnutls_session_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_rsa_export_get_modulus_bits = _libraries['libgnutls.so.26'].gnutls_rsa_export_get_modulus_bits
+gnutls_rsa_export_get_modulus_bits.restype = c_int
+gnutls_rsa_export_get_modulus_bits.argtypes = [gnutls_session_t]
+gnutls_sign_callback_set = _libraries['libgnutls.so.26'].gnutls_sign_callback_set
+gnutls_sign_callback_set.restype = None
+gnutls_sign_callback_set.argtypes = [gnutls_session_t, gnutls_sign_func, c_void_p]
+gnutls_sign_callback_get = _libraries['libgnutls.so.26'].gnutls_sign_callback_get
+gnutls_sign_callback_get.restype = gnutls_sign_func
+gnutls_sign_callback_get.argtypes = [gnutls_session_t, POINTER(c_void_p)]
+gnutls_certificate_client_set_retrieve_function = _libraries['libgnutls.so.26'].gnutls_certificate_client_set_retrieve_function
+gnutls_certificate_client_set_retrieve_function.restype = None
+gnutls_certificate_client_set_retrieve_function.argtypes = [gnutls_certificate_credentials_t, gnutls_certificate_client_retrieve_function]
+gnutls_certificate_server_set_retrieve_function = _libraries['libgnutls.so.26'].gnutls_certificate_server_set_retrieve_function
+gnutls_certificate_server_set_retrieve_function.restype = None
+gnutls_certificate_server_set_retrieve_function.argtypes = [gnutls_certificate_credentials_t, gnutls_certificate_server_retrieve_function]
+gnutls_certificate_server_set_request = _libraries['libgnutls.so.26'].gnutls_certificate_server_set_request
+gnutls_certificate_server_set_request.restype = None
+gnutls_certificate_server_set_request.argtypes = [gnutls_session_t, gnutls_certificate_request_t]
+gnutls_certificate_get_peers = _libraries['libgnutls.so.26'].gnutls_certificate_get_peers
+gnutls_certificate_get_peers.restype = POINTER(gnutls_datum_t)
+gnutls_certificate_get_peers.argtypes = [gnutls_session_t, POINTER(c_uint)]
+gnutls_certificate_get_ours = _libraries['libgnutls.so.26'].gnutls_certificate_get_ours
+gnutls_certificate_get_ours.restype = POINTER(gnutls_datum_t)
+gnutls_certificate_get_ours.argtypes = [gnutls_session_t]
+__time_t = c_long
+time_t = __time_t
+gnutls_certificate_activation_time_peers = _libraries['libgnutls.so.26'].gnutls_certificate_activation_time_peers
+gnutls_certificate_activation_time_peers.restype = time_t
+gnutls_certificate_activation_time_peers.argtypes = [gnutls_session_t]
+gnutls_certificate_expiration_time_peers = _libraries['libgnutls.so.26'].gnutls_certificate_expiration_time_peers
+gnutls_certificate_expiration_time_peers.restype = time_t
+gnutls_certificate_expiration_time_peers.argtypes = [gnutls_session_t]
+gnutls_certificate_client_get_request_status = _libraries['libgnutls.so.26'].gnutls_certificate_client_get_request_status
+gnutls_certificate_client_get_request_status.restype = c_int
+gnutls_certificate_client_get_request_status.argtypes = [gnutls_session_t]
+gnutls_certificate_verify_peers2 = _libraries['libgnutls.so.26'].gnutls_certificate_verify_peers2
+gnutls_certificate_verify_peers2.restype = c_int
+gnutls_certificate_verify_peers2.argtypes = [gnutls_session_t, POINTER(c_uint)]
+gnutls_certificate_verify_peers = _libraries['libgnutls.so.26'].gnutls_certificate_verify_peers
+gnutls_certificate_verify_peers.restype = c_int
+gnutls_certificate_verify_peers.argtypes = [gnutls_session_t]
+gnutls_pem_base64_encode = _libraries['libgnutls.so.26'].gnutls_pem_base64_encode
+gnutls_pem_base64_encode.restype = c_int
+gnutls_pem_base64_encode.argtypes = [STRING, POINTER(gnutls_datum_t), STRING, POINTER(size_t)]
+gnutls_pem_base64_decode = _libraries['libgnutls.so.26'].gnutls_pem_base64_decode
+gnutls_pem_base64_decode.restype = c_int
+gnutls_pem_base64_decode.argtypes = [STRING, POINTER(gnutls_datum_t), POINTER(c_ubyte), POINTER(size_t)]
+gnutls_pem_base64_encode_alloc = _libraries['libgnutls.so.26'].gnutls_pem_base64_encode_alloc
+gnutls_pem_base64_encode_alloc.restype = c_int
+gnutls_pem_base64_encode_alloc.argtypes = [STRING, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_pem_base64_decode_alloc = _libraries['libgnutls.so.26'].gnutls_pem_base64_decode_alloc
+gnutls_pem_base64_decode_alloc.restype = c_int
+gnutls_pem_base64_decode_alloc.argtypes = [STRING, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_certificate_set_params_function = _libraries['libgnutls.so.26'].gnutls_certificate_set_params_function
+gnutls_certificate_set_params_function.restype = None
+gnutls_certificate_set_params_function.argtypes = [gnutls_certificate_credentials_t, gnutls_params_function]
+gnutls_anon_set_params_function = _libraries['libgnutls.so.26'].gnutls_anon_set_params_function
+gnutls_anon_set_params_function.restype = None
+gnutls_anon_set_params_function.argtypes = [gnutls_anon_server_credentials_t, gnutls_params_function]
+gnutls_psk_set_params_function = _libraries['libgnutls.so.26'].gnutls_psk_set_params_function
+gnutls_psk_set_params_function.restype = None
+gnutls_psk_set_params_function.argtypes = [gnutls_psk_server_credentials_t, gnutls_params_function]
+gnutls_hex2bin = _libraries['libgnutls.so.26'].gnutls_hex2bin
+gnutls_hex2bin.restype = c_int
+gnutls_hex2bin.argtypes = [STRING, size_t, STRING, POINTER(size_t)]
+gnutls_openpgp_crt_init = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_init
+gnutls_openpgp_crt_init.restype = c_int
+gnutls_openpgp_crt_init.argtypes = [POINTER(gnutls_openpgp_crt_t)]
+gnutls_openpgp_crt_deinit = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_deinit
+gnutls_openpgp_crt_deinit.restype = None
+gnutls_openpgp_crt_deinit.argtypes = [gnutls_openpgp_crt_t]
+gnutls_openpgp_crt_import = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_import
+gnutls_openpgp_crt_import.restype = c_int
+gnutls_openpgp_crt_import.argtypes = [gnutls_openpgp_crt_t, POINTER(gnutls_datum_t), gnutls_openpgp_crt_fmt_t]
+gnutls_openpgp_crt_export = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_export
+gnutls_openpgp_crt_export.restype = c_int
+gnutls_openpgp_crt_export.argtypes = [gnutls_openpgp_crt_t, gnutls_openpgp_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_openpgp_crt_print = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_print
+gnutls_openpgp_crt_print.restype = c_int
+gnutls_openpgp_crt_print.argtypes = [gnutls_openpgp_crt_t, gnutls_certificate_print_formats_t, POINTER(gnutls_datum_t)]
+gnutls_openpgp_crt_get_key_usage = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_key_usage
+gnutls_openpgp_crt_get_key_usage.restype = c_int
+gnutls_openpgp_crt_get_key_usage.argtypes = [gnutls_openpgp_crt_t, POINTER(c_uint)]
+gnutls_openpgp_crt_get_fingerprint = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_fingerprint
+gnutls_openpgp_crt_get_fingerprint.restype = c_int
+gnutls_openpgp_crt_get_fingerprint.argtypes = [gnutls_openpgp_crt_t, c_void_p, POINTER(size_t)]
+gnutls_openpgp_crt_get_subkey_fingerprint = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_fingerprint
+gnutls_openpgp_crt_get_subkey_fingerprint.restype = c_int
+gnutls_openpgp_crt_get_subkey_fingerprint.argtypes = [gnutls_openpgp_crt_t, c_uint, c_void_p, POINTER(size_t)]
+gnutls_openpgp_crt_get_name = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_name
+gnutls_openpgp_crt_get_name.restype = c_int
+gnutls_openpgp_crt_get_name.argtypes = [gnutls_openpgp_crt_t, c_int, STRING, POINTER(size_t)]
+gnutls_openpgp_crt_get_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_pk_algorithm
+gnutls_openpgp_crt_get_pk_algorithm.restype = gnutls_pk_algorithm_t
+gnutls_openpgp_crt_get_pk_algorithm.argtypes = [gnutls_openpgp_crt_t, POINTER(c_uint)]
+gnutls_openpgp_crt_get_version = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_version
+gnutls_openpgp_crt_get_version.restype = c_int
+gnutls_openpgp_crt_get_version.argtypes = [gnutls_openpgp_crt_t]
+gnutls_openpgp_crt_get_creation_time = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_creation_time
+gnutls_openpgp_crt_get_creation_time.restype = time_t
+gnutls_openpgp_crt_get_creation_time.argtypes = [gnutls_openpgp_crt_t]
+gnutls_openpgp_crt_get_expiration_time = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_expiration_time
+gnutls_openpgp_crt_get_expiration_time.restype = time_t
+gnutls_openpgp_crt_get_expiration_time.argtypes = [gnutls_openpgp_crt_t]
+gnutls_openpgp_crt_get_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_key_id
+gnutls_openpgp_crt_get_key_id.restype = c_int
+gnutls_openpgp_crt_get_key_id.argtypes = [gnutls_openpgp_crt_t, POINTER(c_ubyte)]
+gnutls_openpgp_crt_check_hostname = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_check_hostname
+gnutls_openpgp_crt_check_hostname.restype = c_int
+gnutls_openpgp_crt_check_hostname.argtypes = [gnutls_openpgp_crt_t, STRING]
+gnutls_openpgp_crt_get_revoked_status = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_revoked_status
+gnutls_openpgp_crt_get_revoked_status.restype = c_int
+gnutls_openpgp_crt_get_revoked_status.argtypes = [gnutls_openpgp_crt_t]
+gnutls_openpgp_crt_get_subkey_count = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_count
+gnutls_openpgp_crt_get_subkey_count.restype = c_int
+gnutls_openpgp_crt_get_subkey_count.argtypes = [gnutls_openpgp_crt_t]
+gnutls_openpgp_crt_get_subkey_idx = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_idx
+gnutls_openpgp_crt_get_subkey_idx.restype = c_int
+gnutls_openpgp_crt_get_subkey_idx.argtypes = [gnutls_openpgp_crt_t, POINTER(c_ubyte)]
+gnutls_openpgp_crt_get_subkey_revoked_status = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_revoked_status
+gnutls_openpgp_crt_get_subkey_revoked_status.restype = c_int
+gnutls_openpgp_crt_get_subkey_revoked_status.argtypes = [gnutls_openpgp_crt_t, c_uint]
+gnutls_openpgp_crt_get_subkey_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_pk_algorithm
+gnutls_openpgp_crt_get_subkey_pk_algorithm.restype = gnutls_pk_algorithm_t
+gnutls_openpgp_crt_get_subkey_pk_algorithm.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(c_uint)]
+gnutls_openpgp_crt_get_subkey_creation_time = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_creation_time
+gnutls_openpgp_crt_get_subkey_creation_time.restype = time_t
+gnutls_openpgp_crt_get_subkey_creation_time.argtypes = [gnutls_openpgp_crt_t, c_uint]
+gnutls_openpgp_crt_get_subkey_expiration_time = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_expiration_time
+gnutls_openpgp_crt_get_subkey_expiration_time.restype = time_t
+gnutls_openpgp_crt_get_subkey_expiration_time.argtypes = [gnutls_openpgp_crt_t, c_uint]
+gnutls_openpgp_crt_get_subkey_id = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_id
+gnutls_openpgp_crt_get_subkey_id.restype = c_int
+gnutls_openpgp_crt_get_subkey_id.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(c_ubyte)]
+gnutls_openpgp_crt_get_subkey_usage = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_usage
+gnutls_openpgp_crt_get_subkey_usage.restype = c_int
+gnutls_openpgp_crt_get_subkey_usage.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(c_uint)]
+gnutls_openpgp_crt_get_subkey_pk_dsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_pk_dsa_raw
+gnutls_openpgp_crt_get_subkey_pk_dsa_raw.restype = c_int
+gnutls_openpgp_crt_get_subkey_pk_dsa_raw.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_crt_get_subkey_pk_rsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_subkey_pk_rsa_raw
+gnutls_openpgp_crt_get_subkey_pk_rsa_raw.restype = c_int
+gnutls_openpgp_crt_get_subkey_pk_rsa_raw.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_crt_get_pk_dsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_pk_dsa_raw
+gnutls_openpgp_crt_get_pk_dsa_raw.restype = c_int
+gnutls_openpgp_crt_get_pk_dsa_raw.argtypes = [gnutls_openpgp_crt_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_crt_get_pk_rsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_pk_rsa_raw
+gnutls_openpgp_crt_get_pk_rsa_raw.restype = c_int
+gnutls_openpgp_crt_get_pk_rsa_raw.argtypes = [gnutls_openpgp_crt_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_crt_get_preferred_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_preferred_key_id
+gnutls_openpgp_crt_get_preferred_key_id.restype = c_int
+gnutls_openpgp_crt_get_preferred_key_id.argtypes = [gnutls_openpgp_crt_t, POINTER(c_ubyte)]
+gnutls_openpgp_crt_set_preferred_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_set_preferred_key_id
+gnutls_openpgp_crt_set_preferred_key_id.restype = c_int
+gnutls_openpgp_crt_set_preferred_key_id.argtypes = [gnutls_openpgp_crt_t, POINTER(c_ubyte)]
+gnutls_openpgp_privkey_init = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_init
+gnutls_openpgp_privkey_init.restype = c_int
+gnutls_openpgp_privkey_init.argtypes = [POINTER(gnutls_openpgp_privkey_t)]
+gnutls_openpgp_privkey_deinit = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_deinit
+gnutls_openpgp_privkey_deinit.restype = None
+gnutls_openpgp_privkey_deinit.argtypes = [gnutls_openpgp_privkey_t]
+gnutls_openpgp_privkey_get_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_pk_algorithm
+gnutls_openpgp_privkey_get_pk_algorithm.restype = gnutls_pk_algorithm_t
+gnutls_openpgp_privkey_get_pk_algorithm.argtypes = [gnutls_openpgp_privkey_t, POINTER(c_uint)]
+gnutls_openpgp_privkey_import = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_import
+gnutls_openpgp_privkey_import.restype = c_int
+gnutls_openpgp_privkey_import.argtypes = [gnutls_openpgp_privkey_t, POINTER(gnutls_datum_t), gnutls_openpgp_crt_fmt_t, STRING, c_uint]
+gnutls_openpgp_privkey_sign_hash = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_sign_hash
+gnutls_openpgp_privkey_sign_hash.restype = c_int
+gnutls_openpgp_privkey_sign_hash.argtypes = [gnutls_openpgp_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_privkey_get_fingerprint = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_fingerprint
+gnutls_openpgp_privkey_get_fingerprint.restype = c_int
+gnutls_openpgp_privkey_get_fingerprint.argtypes = [gnutls_openpgp_privkey_t, c_void_p, POINTER(size_t)]
+gnutls_openpgp_privkey_get_subkey_fingerprint = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_fingerprint
+gnutls_openpgp_privkey_get_subkey_fingerprint.restype = c_int
+gnutls_openpgp_privkey_get_subkey_fingerprint.argtypes = [gnutls_openpgp_privkey_t, c_uint, c_void_p, POINTER(size_t)]
+gnutls_openpgp_privkey_get_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_key_id
+gnutls_openpgp_privkey_get_key_id.restype = c_int
+gnutls_openpgp_privkey_get_key_id.argtypes = [gnutls_openpgp_privkey_t, POINTER(c_ubyte)]
+gnutls_openpgp_privkey_get_subkey_count = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_count
+gnutls_openpgp_privkey_get_subkey_count.restype = c_int
+gnutls_openpgp_privkey_get_subkey_count.argtypes = [gnutls_openpgp_privkey_t]
+gnutls_openpgp_privkey_get_subkey_idx = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_idx
+gnutls_openpgp_privkey_get_subkey_idx.restype = c_int
+gnutls_openpgp_privkey_get_subkey_idx.argtypes = [gnutls_openpgp_privkey_t, POINTER(c_ubyte)]
+gnutls_openpgp_privkey_get_subkey_revoked_status = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_revoked_status
+gnutls_openpgp_privkey_get_subkey_revoked_status.restype = c_int
+gnutls_openpgp_privkey_get_subkey_revoked_status.argtypes = [gnutls_openpgp_privkey_t, c_uint]
+gnutls_openpgp_privkey_get_revoked_status = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_revoked_status
+gnutls_openpgp_privkey_get_revoked_status.restype = c_int
+gnutls_openpgp_privkey_get_revoked_status.argtypes = [gnutls_openpgp_privkey_t]
+gnutls_openpgp_privkey_get_subkey_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_pk_algorithm
+gnutls_openpgp_privkey_get_subkey_pk_algorithm.restype = gnutls_pk_algorithm_t
+gnutls_openpgp_privkey_get_subkey_pk_algorithm.argtypes = [gnutls_openpgp_privkey_t, c_uint, POINTER(c_uint)]
+gnutls_openpgp_privkey_get_subkey_expiration_time = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_expiration_time
+gnutls_openpgp_privkey_get_subkey_expiration_time.restype = time_t
+gnutls_openpgp_privkey_get_subkey_expiration_time.argtypes = [gnutls_openpgp_privkey_t, c_uint]
+gnutls_openpgp_privkey_get_subkey_id = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_id
+gnutls_openpgp_privkey_get_subkey_id.restype = c_int
+gnutls_openpgp_privkey_get_subkey_id.argtypes = [gnutls_openpgp_privkey_t, c_uint, POINTER(c_ubyte)]
+gnutls_openpgp_privkey_get_subkey_creation_time = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_subkey_creation_time
+gnutls_openpgp_privkey_get_subkey_creation_time.restype = time_t
+gnutls_openpgp_privkey_get_subkey_creation_time.argtypes = [gnutls_openpgp_privkey_t, c_uint]
+gnutls_openpgp_privkey_export_subkey_dsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_export_subkey_dsa_raw
+gnutls_openpgp_privkey_export_subkey_dsa_raw.restype = c_int
+gnutls_openpgp_privkey_export_subkey_dsa_raw.argtypes = [gnutls_openpgp_privkey_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_privkey_export_subkey_rsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_export_subkey_rsa_raw
+gnutls_openpgp_privkey_export_subkey_rsa_raw.restype = c_int
+gnutls_openpgp_privkey_export_subkey_rsa_raw.argtypes = [gnutls_openpgp_privkey_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_privkey_export_dsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_export_dsa_raw
+gnutls_openpgp_privkey_export_dsa_raw.restype = c_int
+gnutls_openpgp_privkey_export_dsa_raw.argtypes = [gnutls_openpgp_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_privkey_export_rsa_raw = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_export_rsa_raw
+gnutls_openpgp_privkey_export_rsa_raw.restype = c_int
+gnutls_openpgp_privkey_export_rsa_raw.argtypes = [gnutls_openpgp_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_openpgp_privkey_export = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_export
+gnutls_openpgp_privkey_export.restype = c_int
+gnutls_openpgp_privkey_export.argtypes = [gnutls_openpgp_privkey_t, gnutls_openpgp_crt_fmt_t, STRING, c_uint, c_void_p, POINTER(size_t)]
+gnutls_openpgp_privkey_set_preferred_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_set_preferred_key_id
+gnutls_openpgp_privkey_set_preferred_key_id.restype = c_int
+gnutls_openpgp_privkey_set_preferred_key_id.argtypes = [gnutls_openpgp_privkey_t, POINTER(c_ubyte)]
+gnutls_openpgp_privkey_get_preferred_key_id = _libraries['libgnutls.so.26'].gnutls_openpgp_privkey_get_preferred_key_id
+gnutls_openpgp_privkey_get_preferred_key_id.restype = c_int
+gnutls_openpgp_privkey_get_preferred_key_id.argtypes = [gnutls_openpgp_privkey_t, POINTER(c_ubyte)]
+gnutls_openpgp_crt_get_auth_subkey = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_get_auth_subkey
+gnutls_openpgp_crt_get_auth_subkey.restype = c_int
+gnutls_openpgp_crt_get_auth_subkey.argtypes = [gnutls_openpgp_crt_t, POINTER(c_ubyte), c_uint]
+gnutls_openpgp_keyring_init = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_init
+gnutls_openpgp_keyring_init.restype = c_int
+gnutls_openpgp_keyring_init.argtypes = [POINTER(gnutls_openpgp_keyring_t)]
+gnutls_openpgp_keyring_deinit = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_deinit
+gnutls_openpgp_keyring_deinit.restype = None
+gnutls_openpgp_keyring_deinit.argtypes = [gnutls_openpgp_keyring_t]
+gnutls_openpgp_keyring_import = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_import
+gnutls_openpgp_keyring_import.restype = c_int
+gnutls_openpgp_keyring_import.argtypes = [gnutls_openpgp_keyring_t, POINTER(gnutls_datum_t), gnutls_openpgp_crt_fmt_t]
+gnutls_openpgp_keyring_check_id = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_check_id
+gnutls_openpgp_keyring_check_id.restype = c_int
+gnutls_openpgp_keyring_check_id.argtypes = [gnutls_openpgp_keyring_t, POINTER(c_ubyte), c_uint]
+gnutls_openpgp_crt_verify_ring = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_verify_ring
+gnutls_openpgp_crt_verify_ring.restype = c_int
+gnutls_openpgp_crt_verify_ring.argtypes = [gnutls_openpgp_crt_t, gnutls_openpgp_keyring_t, c_uint, POINTER(c_uint)]
+gnutls_openpgp_crt_verify_self = _libraries['libgnutls.so.26'].gnutls_openpgp_crt_verify_self
+gnutls_openpgp_crt_verify_self.restype = c_int
+gnutls_openpgp_crt_verify_self.argtypes = [gnutls_openpgp_crt_t, c_uint, POINTER(c_uint)]
+gnutls_openpgp_keyring_get_crt = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_get_crt
+gnutls_openpgp_keyring_get_crt.restype = c_int
+gnutls_openpgp_keyring_get_crt.argtypes = [gnutls_openpgp_keyring_t, c_uint, POINTER(gnutls_openpgp_crt_t)]
+gnutls_openpgp_keyring_get_crt_count = _libraries['libgnutls.so.26'].gnutls_openpgp_keyring_get_crt_count
+gnutls_openpgp_keyring_get_crt_count.restype = c_int
+gnutls_openpgp_keyring_get_crt_count.argtypes = [gnutls_openpgp_keyring_t]
+gnutls_openpgp_set_recv_key_function = _libraries['libgnutls.so.26'].gnutls_openpgp_set_recv_key_function
+gnutls_openpgp_set_recv_key_function.restype = None
+gnutls_openpgp_set_recv_key_function.argtypes = [gnutls_session_t, gnutls_openpgp_recv_key_func]
+gnutls_certificate_set_openpgp_key = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_key
+gnutls_certificate_set_openpgp_key.restype = c_int
+gnutls_certificate_set_openpgp_key.argtypes = [gnutls_certificate_credentials_t, gnutls_openpgp_crt_t, gnutls_openpgp_privkey_t]
+gnutls_certificate_set_openpgp_key_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_key_file
+gnutls_certificate_set_openpgp_key_file.restype = c_int
+gnutls_certificate_set_openpgp_key_file.argtypes = [gnutls_certificate_credentials_t, STRING, STRING, gnutls_openpgp_crt_fmt_t]
+gnutls_certificate_set_openpgp_key_mem = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_key_mem
+gnutls_certificate_set_openpgp_key_mem.restype = c_int
+gnutls_certificate_set_openpgp_key_mem.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), gnutls_openpgp_crt_fmt_t]
+gnutls_certificate_set_openpgp_key_file2 = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_key_file2
+gnutls_certificate_set_openpgp_key_file2.restype = c_int
+gnutls_certificate_set_openpgp_key_file2.argtypes = [gnutls_certificate_credentials_t, STRING, STRING, STRING, gnutls_openpgp_crt_fmt_t]
+gnutls_certificate_set_openpgp_key_mem2 = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_key_mem2
+gnutls_certificate_set_openpgp_key_mem2.restype = c_int
+gnutls_certificate_set_openpgp_key_mem2.argtypes = [gnutls_certificate_credentials_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), STRING, gnutls_openpgp_crt_fmt_t]
+gnutls_certificate_set_openpgp_keyring_mem = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_keyring_mem
+gnutls_certificate_set_openpgp_keyring_mem.restype = c_int
+gnutls_certificate_set_openpgp_keyring_mem.argtypes = [gnutls_certificate_credentials_t, POINTER(c_ubyte), size_t, gnutls_openpgp_crt_fmt_t]
+gnutls_certificate_set_openpgp_keyring_file = _libraries['libgnutls.so.26'].gnutls_certificate_set_openpgp_keyring_file
+gnutls_certificate_set_openpgp_keyring_file.restype = c_int
+gnutls_certificate_set_openpgp_keyring_file.argtypes = [gnutls_certificate_credentials_t, STRING, gnutls_openpgp_crt_fmt_t]
+gnutls_x509_crt_init = _libraries['libgnutls.so.26'].gnutls_x509_crt_init
+gnutls_x509_crt_init.restype = c_int
+gnutls_x509_crt_init.argtypes = [POINTER(gnutls_x509_crt_t)]
+gnutls_x509_crt_deinit = _libraries['libgnutls.so.26'].gnutls_x509_crt_deinit
+gnutls_x509_crt_deinit.restype = None
+gnutls_x509_crt_deinit.argtypes = [gnutls_x509_crt_t]
+gnutls_x509_crt_import = _libraries['libgnutls.so.26'].gnutls_x509_crt_import
+gnutls_x509_crt_import.restype = c_int
+gnutls_x509_crt_import.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_x509_crt_list_import = _libraries['libgnutls.so.26'].gnutls_x509_crt_list_import
+gnutls_x509_crt_list_import.restype = c_int
+gnutls_x509_crt_list_import.argtypes = [POINTER(gnutls_x509_crt_t), POINTER(c_uint), POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t, c_uint]
+gnutls_x509_crt_export = _libraries['libgnutls.so.26'].gnutls_x509_crt_export
+gnutls_x509_crt_export.restype = c_int
+gnutls_x509_crt_export.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_issuer_dn = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_issuer_dn
+gnutls_x509_crt_get_issuer_dn.restype = c_int
+gnutls_x509_crt_get_issuer_dn.argtypes = [gnutls_x509_crt_t, STRING, POINTER(size_t)]
+gnutls_x509_crt_get_issuer_dn_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_issuer_dn_oid
+gnutls_x509_crt_get_issuer_dn_oid.restype = c_int
+gnutls_x509_crt_get_issuer_dn_oid.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_issuer_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_issuer_dn_by_oid
+gnutls_x509_crt_get_issuer_dn_by_oid.restype = c_int
+gnutls_x509_crt_get_issuer_dn_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_int, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_dn = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_dn
+gnutls_x509_crt_get_dn.restype = c_int
+gnutls_x509_crt_get_dn.argtypes = [gnutls_x509_crt_t, STRING, POINTER(size_t)]
+gnutls_x509_crt_get_dn_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_dn_oid
+gnutls_x509_crt_get_dn_oid.restype = c_int
+gnutls_x509_crt_get_dn_oid.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_dn_by_oid
+gnutls_x509_crt_get_dn_by_oid.restype = c_int
+gnutls_x509_crt_get_dn_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_int, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_check_hostname = _libraries['libgnutls.so.26'].gnutls_x509_crt_check_hostname
+gnutls_x509_crt_check_hostname.restype = c_int
+gnutls_x509_crt_check_hostname.argtypes = [gnutls_x509_crt_t, STRING]
+gnutls_x509_crt_get_signature_algorithm = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_signature_algorithm
+gnutls_x509_crt_get_signature_algorithm.restype = c_int
+gnutls_x509_crt_get_signature_algorithm.argtypes = [gnutls_x509_crt_t]
+gnutls_x509_crt_get_signature = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_signature
+gnutls_x509_crt_get_signature.restype = c_int
+gnutls_x509_crt_get_signature.argtypes = [gnutls_x509_crt_t, STRING, POINTER(size_t)]
+gnutls_x509_crt_get_version = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_version
+gnutls_x509_crt_get_version.restype = c_int
+gnutls_x509_crt_get_version.argtypes = [gnutls_x509_crt_t]
+gnutls_x509_crt_get_key_id = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_key_id
+gnutls_x509_crt_get_key_id.restype = c_int
+gnutls_x509_crt_get_key_id.argtypes = [gnutls_x509_crt_t, c_uint, POINTER(c_ubyte), POINTER(size_t)]
+gnutls_x509_crt_set_authority_key_id = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_authority_key_id
+gnutls_x509_crt_set_authority_key_id.restype = c_int
+gnutls_x509_crt_set_authority_key_id.argtypes = [gnutls_x509_crt_t, c_void_p, size_t]
+gnutls_x509_crt_get_authority_key_id = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_authority_key_id
+gnutls_x509_crt_get_authority_key_id.restype = c_int
+gnutls_x509_crt_get_authority_key_id.argtypes = [gnutls_x509_crt_t, c_void_p, POINTER(size_t), POINTER(c_uint)]
+gnutls_x509_crt_get_subject_key_id = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_subject_key_id
+gnutls_x509_crt_get_subject_key_id.restype = c_int
+gnutls_x509_crt_get_subject_key_id.argtypes = [gnutls_x509_crt_t, c_void_p, POINTER(size_t), POINTER(c_uint)]
+gnutls_x509_crt_get_crl_dist_points = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_crl_dist_points
+gnutls_x509_crt_get_crl_dist_points.restype = c_int
+gnutls_x509_crt_get_crl_dist_points.argtypes = [gnutls_x509_crt_t, c_uint, c_void_p, POINTER(size_t), POINTER(c_uint), POINTER(c_uint)]
+gnutls_x509_crt_set_crl_dist_points = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_crl_dist_points
+gnutls_x509_crt_set_crl_dist_points.restype = c_int
+gnutls_x509_crt_set_crl_dist_points.argtypes = [gnutls_x509_crt_t, gnutls_x509_subject_alt_name_t, c_void_p, c_uint]
+gnutls_x509_crt_cpy_crl_dist_points = _libraries['libgnutls.so.26'].gnutls_x509_crt_cpy_crl_dist_points
+gnutls_x509_crt_cpy_crl_dist_points.restype = c_int
+gnutls_x509_crt_cpy_crl_dist_points.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_t]
+gnutls_x509_crt_get_activation_time = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_activation_time
+gnutls_x509_crt_get_activation_time.restype = time_t
+gnutls_x509_crt_get_activation_time.argtypes = [gnutls_x509_crt_t]
+gnutls_x509_crt_get_expiration_time = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_expiration_time
+gnutls_x509_crt_get_expiration_time.restype = time_t
+gnutls_x509_crt_get_expiration_time.argtypes = [gnutls_x509_crt_t]
+gnutls_x509_crt_get_serial = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_serial
+gnutls_x509_crt_get_serial.restype = c_int
+gnutls_x509_crt_get_serial.argtypes = [gnutls_x509_crt_t, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_pk_algorithm
+gnutls_x509_crt_get_pk_algorithm.restype = c_int
+gnutls_x509_crt_get_pk_algorithm.argtypes = [gnutls_x509_crt_t, POINTER(c_uint)]
+gnutls_x509_crt_get_pk_rsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_pk_rsa_raw
+gnutls_x509_crt_get_pk_rsa_raw.restype = c_int
+gnutls_x509_crt_get_pk_rsa_raw.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_crt_get_pk_dsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_pk_dsa_raw
+gnutls_x509_crt_get_pk_dsa_raw.restype = c_int
+gnutls_x509_crt_get_pk_dsa_raw.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_crt_get_subject_alt_name = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_subject_alt_name
+gnutls_x509_crt_get_subject_alt_name.restype = c_int
+gnutls_x509_crt_get_subject_alt_name.argtypes = [gnutls_x509_crt_t, c_uint, c_void_p, POINTER(size_t), POINTER(c_uint)]
+gnutls_x509_crt_get_subject_alt_name2 = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_subject_alt_name2
+gnutls_x509_crt_get_subject_alt_name2.restype = c_int
+gnutls_x509_crt_get_subject_alt_name2.argtypes = [gnutls_x509_crt_t, c_uint, c_void_p, POINTER(size_t), POINTER(c_uint), POINTER(c_uint)]
+gnutls_x509_crt_get_subject_alt_othername_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_subject_alt_othername_oid
+gnutls_x509_crt_get_subject_alt_othername_oid.restype = c_int
+gnutls_x509_crt_get_subject_alt_othername_oid.argtypes = [gnutls_x509_crt_t, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_ca_status = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_ca_status
+gnutls_x509_crt_get_ca_status.restype = c_int
+gnutls_x509_crt_get_ca_status.argtypes = [gnutls_x509_crt_t, POINTER(c_uint)]
+gnutls_x509_crt_get_basic_constraints = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_basic_constraints
+gnutls_x509_crt_get_basic_constraints.restype = c_int
+gnutls_x509_crt_get_basic_constraints.argtypes = [gnutls_x509_crt_t, POINTER(c_uint), POINTER(c_int), POINTER(c_int)]
+gnutls_x509_crt_get_key_usage = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_key_usage
+gnutls_x509_crt_get_key_usage.restype = c_int
+gnutls_x509_crt_get_key_usage.argtypes = [gnutls_x509_crt_t, POINTER(c_uint), POINTER(c_uint)]
+gnutls_x509_crt_set_key_usage = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_key_usage
+gnutls_x509_crt_set_key_usage.restype = c_int
+gnutls_x509_crt_set_key_usage.argtypes = [gnutls_x509_crt_t, c_uint]
+gnutls_x509_crt_get_proxy = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_proxy
+gnutls_x509_crt_get_proxy.restype = c_int
+gnutls_x509_crt_get_proxy.argtypes = [gnutls_x509_crt_t, POINTER(c_uint), POINTER(c_int), POINTER(STRING), POINTER(STRING), POINTER(size_t)]
+gnutls_x509_dn_oid_known = _libraries['libgnutls.so.26'].gnutls_x509_dn_oid_known
+gnutls_x509_dn_oid_known.restype = c_int
+gnutls_x509_dn_oid_known.argtypes = [STRING]
+gnutls_x509_crt_get_extension_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_extension_oid
+gnutls_x509_crt_get_extension_oid.restype = c_int
+gnutls_x509_crt_get_extension_oid.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_extension_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_extension_by_oid
+gnutls_x509_crt_get_extension_by_oid.restype = c_int
+gnutls_x509_crt_get_extension_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_int, c_void_p, POINTER(size_t), POINTER(c_uint)]
+gnutls_x509_crt_get_extension_info = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_extension_info
+gnutls_x509_crt_get_extension_info.restype = c_int
+gnutls_x509_crt_get_extension_info.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t), POINTER(c_int)]
+gnutls_x509_crt_get_extension_data = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_extension_data
+gnutls_x509_crt_get_extension_data.restype = c_int
+gnutls_x509_crt_get_extension_data.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_set_extension_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_extension_by_oid
+gnutls_x509_crt_set_extension_by_oid.restype = c_int
+gnutls_x509_crt_set_extension_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_void_p, size_t, c_uint]
+gnutls_x509_crt_set_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_dn_by_oid
+gnutls_x509_crt_set_dn_by_oid.restype = c_int
+gnutls_x509_crt_set_dn_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_uint, c_void_p, c_uint]
+gnutls_x509_crt_set_issuer_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_issuer_dn_by_oid
+gnutls_x509_crt_set_issuer_dn_by_oid.restype = c_int
+gnutls_x509_crt_set_issuer_dn_by_oid.argtypes = [gnutls_x509_crt_t, STRING, c_uint, c_void_p, c_uint]
+gnutls_x509_crt_set_version = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_version
+gnutls_x509_crt_set_version.restype = c_int
+gnutls_x509_crt_set_version.argtypes = [gnutls_x509_crt_t, c_uint]
+gnutls_x509_crt_set_key = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_key
+gnutls_x509_crt_set_key.restype = c_int
+gnutls_x509_crt_set_key.argtypes = [gnutls_x509_crt_t, gnutls_x509_privkey_t]
+gnutls_x509_crt_set_ca_status = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_ca_status
+gnutls_x509_crt_set_ca_status.restype = c_int
+gnutls_x509_crt_set_ca_status.argtypes = [gnutls_x509_crt_t, c_uint]
+gnutls_x509_crt_set_basic_constraints = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_basic_constraints
+gnutls_x509_crt_set_basic_constraints.restype = c_int
+gnutls_x509_crt_set_basic_constraints.argtypes = [gnutls_x509_crt_t, c_uint, c_int]
+gnutls_x509_crt_set_subject_alternative_name = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_subject_alternative_name
+gnutls_x509_crt_set_subject_alternative_name.restype = c_int
+gnutls_x509_crt_set_subject_alternative_name.argtypes = [gnutls_x509_crt_t, gnutls_x509_subject_alt_name_t, STRING]
+gnutls_x509_crt_sign = _libraries['libgnutls.so.26'].gnutls_x509_crt_sign
+gnutls_x509_crt_sign.restype = c_int
+gnutls_x509_crt_sign.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_t, gnutls_x509_privkey_t]
+gnutls_x509_crt_sign2 = _libraries['libgnutls.so.26'].gnutls_x509_crt_sign2
+gnutls_x509_crt_sign2.restype = c_int
+gnutls_x509_crt_sign2.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_t, gnutls_x509_privkey_t, gnutls_digest_algorithm_t, c_uint]
+gnutls_x509_crt_set_activation_time = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_activation_time
+gnutls_x509_crt_set_activation_time.restype = c_int
+gnutls_x509_crt_set_activation_time.argtypes = [gnutls_x509_crt_t, time_t]
+gnutls_x509_crt_set_expiration_time = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_expiration_time
+gnutls_x509_crt_set_expiration_time.restype = c_int
+gnutls_x509_crt_set_expiration_time.argtypes = [gnutls_x509_crt_t, time_t]
+gnutls_x509_crt_set_serial = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_serial
+gnutls_x509_crt_set_serial.restype = c_int
+gnutls_x509_crt_set_serial.argtypes = [gnutls_x509_crt_t, c_void_p, size_t]
+gnutls_x509_crt_set_subject_key_id = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_subject_key_id
+gnutls_x509_crt_set_subject_key_id.restype = c_int
+gnutls_x509_crt_set_subject_key_id.argtypes = [gnutls_x509_crt_t, c_void_p, size_t]
+gnutls_x509_crt_set_proxy_dn = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_proxy_dn
+gnutls_x509_crt_set_proxy_dn.restype = c_int
+gnutls_x509_crt_set_proxy_dn.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_t, c_uint, c_void_p, c_uint]
+gnutls_x509_crt_set_proxy = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_proxy
+gnutls_x509_crt_set_proxy.restype = c_int
+gnutls_x509_crt_set_proxy.argtypes = [gnutls_x509_crt_t, c_int, STRING, STRING, size_t]
+gnutls_x509_crt_print = _libraries['libgnutls.so.26'].gnutls_x509_crt_print
+gnutls_x509_crt_print.restype = c_int
+gnutls_x509_crt_print.argtypes = [gnutls_x509_crt_t, gnutls_certificate_print_formats_t, POINTER(gnutls_datum_t)]
+gnutls_x509_crl_print = _libraries['libgnutls.so.26'].gnutls_x509_crl_print
+gnutls_x509_crl_print.restype = c_int
+gnutls_x509_crl_print.argtypes = [gnutls_x509_crl_t, gnutls_certificate_print_formats_t, POINTER(gnutls_datum_t)]
+gnutls_x509_crt_get_raw_issuer_dn = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_raw_issuer_dn
+gnutls_x509_crt_get_raw_issuer_dn.restype = c_int
+gnutls_x509_crt_get_raw_issuer_dn.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_datum_t)]
+gnutls_x509_crt_get_raw_dn = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_raw_dn
+gnutls_x509_crt_get_raw_dn.restype = c_int
+gnutls_x509_crt_get_raw_dn.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_datum_t)]
+gnutls_x509_rdn_get = _libraries['libgnutls.so.26'].gnutls_x509_rdn_get
+gnutls_x509_rdn_get.restype = c_int
+gnutls_x509_rdn_get.argtypes = [POINTER(gnutls_datum_t), STRING, POINTER(size_t)]
+gnutls_x509_rdn_get_oid = _libraries['libgnutls.so.26'].gnutls_x509_rdn_get_oid
+gnutls_x509_rdn_get_oid.restype = c_int
+gnutls_x509_rdn_get_oid.argtypes = [POINTER(gnutls_datum_t), c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_rdn_get_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_rdn_get_by_oid
+gnutls_x509_rdn_get_by_oid.restype = c_int
+gnutls_x509_rdn_get_by_oid.argtypes = [POINTER(gnutls_datum_t), STRING, c_int, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_subject = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_subject
+gnutls_x509_crt_get_subject.restype = c_int
+gnutls_x509_crt_get_subject.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_x509_dn_t)]
+gnutls_x509_crt_get_issuer = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_issuer
+gnutls_x509_crt_get_issuer.restype = c_int
+gnutls_x509_crt_get_issuer.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_x509_dn_t)]
+gnutls_x509_dn_get_rdn_ava = _libraries['libgnutls.so.26'].gnutls_x509_dn_get_rdn_ava
+gnutls_x509_dn_get_rdn_ava.restype = c_int
+gnutls_x509_dn_get_rdn_ava.argtypes = [gnutls_x509_dn_t, c_int, c_int, POINTER(gnutls_x509_ava_st)]
+gnutls_x509_dn_init = _libraries['libgnutls.so.26'].gnutls_x509_dn_init
+gnutls_x509_dn_init.restype = c_int
+gnutls_x509_dn_init.argtypes = [POINTER(gnutls_x509_dn_t)]
+gnutls_x509_dn_import = _libraries['libgnutls.so.26'].gnutls_x509_dn_import
+gnutls_x509_dn_import.restype = c_int
+gnutls_x509_dn_import.argtypes = [gnutls_x509_dn_t, POINTER(gnutls_datum_t)]
+gnutls_x509_dn_export = _libraries['libgnutls.so.26'].gnutls_x509_dn_export
+gnutls_x509_dn_export.restype = c_int
+gnutls_x509_dn_export.argtypes = [gnutls_x509_dn_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_x509_dn_deinit = _libraries['libgnutls.so.26'].gnutls_x509_dn_deinit
+gnutls_x509_dn_deinit.restype = None
+gnutls_x509_dn_deinit.argtypes = [gnutls_x509_dn_t]
+gnutls_x509_crl_init = _libraries['libgnutls.so.26'].gnutls_x509_crl_init
+gnutls_x509_crl_init.restype = c_int
+gnutls_x509_crl_init.argtypes = [POINTER(gnutls_x509_crl_t)]
+gnutls_x509_crl_deinit = _libraries['libgnutls.so.26'].gnutls_x509_crl_deinit
+gnutls_x509_crl_deinit.restype = None
+gnutls_x509_crl_deinit.argtypes = [gnutls_x509_crl_t]
+gnutls_x509_crl_import = _libraries['libgnutls.so.26'].gnutls_x509_crl_import
+gnutls_x509_crl_import.restype = c_int
+gnutls_x509_crl_import.argtypes = [gnutls_x509_crl_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_x509_crl_export = _libraries['libgnutls.so.26'].gnutls_x509_crl_export
+gnutls_x509_crl_export.restype = c_int
+gnutls_x509_crl_export.argtypes = [gnutls_x509_crl_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_x509_crl_get_issuer_dn = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_issuer_dn
+gnutls_x509_crl_get_issuer_dn.restype = c_int
+gnutls_x509_crl_get_issuer_dn.argtypes = [gnutls_x509_crl_t, STRING, POINTER(size_t)]
+gnutls_x509_crl_get_issuer_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_issuer_dn_by_oid
+gnutls_x509_crl_get_issuer_dn_by_oid.restype = c_int
+gnutls_x509_crl_get_issuer_dn_by_oid.argtypes = [gnutls_x509_crl_t, STRING, c_int, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_crl_get_dn_oid = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_dn_oid
+gnutls_x509_crl_get_dn_oid.restype = c_int
+gnutls_x509_crl_get_dn_oid.argtypes = [gnutls_x509_crl_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crl_get_signature_algorithm = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_signature_algorithm
+gnutls_x509_crl_get_signature_algorithm.restype = c_int
+gnutls_x509_crl_get_signature_algorithm.argtypes = [gnutls_x509_crl_t]
+gnutls_x509_crl_get_signature = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_signature
+gnutls_x509_crl_get_signature.restype = c_int
+gnutls_x509_crl_get_signature.argtypes = [gnutls_x509_crl_t, STRING, POINTER(size_t)]
+gnutls_x509_crl_get_version = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_version
+gnutls_x509_crl_get_version.restype = c_int
+gnutls_x509_crl_get_version.argtypes = [gnutls_x509_crl_t]
+gnutls_x509_crl_get_this_update = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_this_update
+gnutls_x509_crl_get_this_update.restype = time_t
+gnutls_x509_crl_get_this_update.argtypes = [gnutls_x509_crl_t]
+gnutls_x509_crl_get_next_update = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_next_update
+gnutls_x509_crl_get_next_update.restype = time_t
+gnutls_x509_crl_get_next_update.argtypes = [gnutls_x509_crl_t]
+gnutls_x509_crl_get_crt_count = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_crt_count
+gnutls_x509_crl_get_crt_count.restype = c_int
+gnutls_x509_crl_get_crt_count.argtypes = [gnutls_x509_crl_t]
+gnutls_x509_crl_get_crt_serial = _libraries['libgnutls.so.26'].gnutls_x509_crl_get_crt_serial
+gnutls_x509_crl_get_crt_serial.restype = c_int
+gnutls_x509_crl_get_crt_serial.argtypes = [gnutls_x509_crl_t, c_int, POINTER(c_ubyte), POINTER(size_t), POINTER(time_t)]
+gnutls_x509_crl_check_issuer = _libraries['libgnutls.so.26'].gnutls_x509_crl_check_issuer
+gnutls_x509_crl_check_issuer.restype = c_int
+gnutls_x509_crl_check_issuer.argtypes = [gnutls_x509_crl_t, gnutls_x509_crt_t]
+gnutls_x509_crl_set_version = _libraries['libgnutls.so.26'].gnutls_x509_crl_set_version
+gnutls_x509_crl_set_version.restype = c_int
+gnutls_x509_crl_set_version.argtypes = [gnutls_x509_crl_t, c_uint]
+gnutls_x509_crl_sign = _libraries['libgnutls.so.26'].gnutls_x509_crl_sign
+gnutls_x509_crl_sign.restype = c_int
+gnutls_x509_crl_sign.argtypes = [gnutls_x509_crl_t, gnutls_x509_crt_t, gnutls_x509_privkey_t]
+gnutls_x509_crl_sign2 = _libraries['libgnutls.so.26'].gnutls_x509_crl_sign2
+gnutls_x509_crl_sign2.restype = c_int
+gnutls_x509_crl_sign2.argtypes = [gnutls_x509_crl_t, gnutls_x509_crt_t, gnutls_x509_privkey_t, gnutls_digest_algorithm_t, c_uint]
+gnutls_x509_crl_set_this_update = _libraries['libgnutls.so.26'].gnutls_x509_crl_set_this_update
+gnutls_x509_crl_set_this_update.restype = c_int
+gnutls_x509_crl_set_this_update.argtypes = [gnutls_x509_crl_t, time_t]
+gnutls_x509_crl_set_next_update = _libraries['libgnutls.so.26'].gnutls_x509_crl_set_next_update
+gnutls_x509_crl_set_next_update.restype = c_int
+gnutls_x509_crl_set_next_update.argtypes = [gnutls_x509_crl_t, time_t]
+gnutls_x509_crl_set_crt_serial = _libraries['libgnutls.so.26'].gnutls_x509_crl_set_crt_serial
+gnutls_x509_crl_set_crt_serial.restype = c_int
+gnutls_x509_crl_set_crt_serial.argtypes = [gnutls_x509_crl_t, c_void_p, size_t, time_t]
+gnutls_x509_crl_set_crt = _libraries['libgnutls.so.26'].gnutls_x509_crl_set_crt
+gnutls_x509_crl_set_crt.restype = c_int
+gnutls_x509_crl_set_crt.argtypes = [gnutls_x509_crl_t, gnutls_x509_crt_t, time_t]
+gnutls_pkcs7_init = _libraries['libgnutls.so.26'].gnutls_pkcs7_init
+gnutls_pkcs7_init.restype = c_int
+gnutls_pkcs7_init.argtypes = [POINTER(gnutls_pkcs7_t)]
+gnutls_pkcs7_deinit = _libraries['libgnutls.so.26'].gnutls_pkcs7_deinit
+gnutls_pkcs7_deinit.restype = None
+gnutls_pkcs7_deinit.argtypes = [gnutls_pkcs7_t]
+gnutls_pkcs7_import = _libraries['libgnutls.so.26'].gnutls_pkcs7_import
+gnutls_pkcs7_import.restype = c_int
+gnutls_pkcs7_import.argtypes = [gnutls_pkcs7_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_pkcs7_export = _libraries['libgnutls.so.26'].gnutls_pkcs7_export
+gnutls_pkcs7_export.restype = c_int
+gnutls_pkcs7_export.argtypes = [gnutls_pkcs7_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_pkcs7_get_crt_count = _libraries['libgnutls.so.26'].gnutls_pkcs7_get_crt_count
+gnutls_pkcs7_get_crt_count.restype = c_int
+gnutls_pkcs7_get_crt_count.argtypes = [gnutls_pkcs7_t]
+gnutls_pkcs7_get_crt_raw = _libraries['libgnutls.so.26'].gnutls_pkcs7_get_crt_raw
+gnutls_pkcs7_get_crt_raw.restype = c_int
+gnutls_pkcs7_get_crt_raw.argtypes = [gnutls_pkcs7_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_pkcs7_set_crt_raw = _libraries['libgnutls.so.26'].gnutls_pkcs7_set_crt_raw
+gnutls_pkcs7_set_crt_raw.restype = c_int
+gnutls_pkcs7_set_crt_raw.argtypes = [gnutls_pkcs7_t, POINTER(gnutls_datum_t)]
+gnutls_pkcs7_set_crt = _libraries['libgnutls.so.26'].gnutls_pkcs7_set_crt
+gnutls_pkcs7_set_crt.restype = c_int
+gnutls_pkcs7_set_crt.argtypes = [gnutls_pkcs7_t, gnutls_x509_crt_t]
+gnutls_pkcs7_delete_crt = _libraries['libgnutls.so.26'].gnutls_pkcs7_delete_crt
+gnutls_pkcs7_delete_crt.restype = c_int
+gnutls_pkcs7_delete_crt.argtypes = [gnutls_pkcs7_t, c_int]
+gnutls_pkcs7_get_crl_raw = _libraries['libgnutls.so.26'].gnutls_pkcs7_get_crl_raw
+gnutls_pkcs7_get_crl_raw.restype = c_int
+gnutls_pkcs7_get_crl_raw.argtypes = [gnutls_pkcs7_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_pkcs7_get_crl_count = _libraries['libgnutls.so.26'].gnutls_pkcs7_get_crl_count
+gnutls_pkcs7_get_crl_count.restype = c_int
+gnutls_pkcs7_get_crl_count.argtypes = [gnutls_pkcs7_t]
+gnutls_pkcs7_set_crl_raw = _libraries['libgnutls.so.26'].gnutls_pkcs7_set_crl_raw
+gnutls_pkcs7_set_crl_raw.restype = c_int
+gnutls_pkcs7_set_crl_raw.argtypes = [gnutls_pkcs7_t, POINTER(gnutls_datum_t)]
+gnutls_pkcs7_set_crl = _libraries['libgnutls.so.26'].gnutls_pkcs7_set_crl
+gnutls_pkcs7_set_crl.restype = c_int
+gnutls_pkcs7_set_crl.argtypes = [gnutls_pkcs7_t, gnutls_x509_crl_t]
+gnutls_pkcs7_delete_crl = _libraries['libgnutls.so.26'].gnutls_pkcs7_delete_crl
+gnutls_pkcs7_delete_crl.restype = c_int
+gnutls_pkcs7_delete_crl.argtypes = [gnutls_pkcs7_t, c_int]
+gnutls_x509_crt_check_issuer = _libraries['libgnutls.so.26'].gnutls_x509_crt_check_issuer
+gnutls_x509_crt_check_issuer.restype = c_int
+gnutls_x509_crt_check_issuer.argtypes = [gnutls_x509_crt_t, gnutls_x509_crt_t]
+gnutls_x509_crt_list_verify = _libraries['libgnutls.so.26'].gnutls_x509_crt_list_verify
+gnutls_x509_crt_list_verify.restype = c_int
+gnutls_x509_crt_list_verify.argtypes = [POINTER(gnutls_x509_crt_t), c_int, POINTER(gnutls_x509_crt_t), c_int, POINTER(gnutls_x509_crl_t), c_int, c_uint, POINTER(c_uint)]
+gnutls_x509_crt_verify = _libraries['libgnutls.so.26'].gnutls_x509_crt_verify
+gnutls_x509_crt_verify.restype = c_int
+gnutls_x509_crt_verify.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_x509_crt_t), c_int, c_uint, POINTER(c_uint)]
+gnutls_x509_crl_verify = _libraries['libgnutls.so.26'].gnutls_x509_crl_verify
+gnutls_x509_crl_verify.restype = c_int
+gnutls_x509_crl_verify.argtypes = [gnutls_x509_crl_t, POINTER(gnutls_x509_crt_t), c_int, c_uint, POINTER(c_uint)]
+gnutls_x509_crt_check_revocation = _libraries['libgnutls.so.26'].gnutls_x509_crt_check_revocation
+gnutls_x509_crt_check_revocation.restype = c_int
+gnutls_x509_crt_check_revocation.argtypes = [gnutls_x509_crt_t, POINTER(gnutls_x509_crl_t), c_int]
+gnutls_x509_crt_get_fingerprint = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_fingerprint
+gnutls_x509_crt_get_fingerprint.restype = c_int
+gnutls_x509_crt_get_fingerprint.argtypes = [gnutls_x509_crt_t, gnutls_digest_algorithm_t, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_get_key_purpose_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_get_key_purpose_oid
+gnutls_x509_crt_get_key_purpose_oid.restype = c_int
+gnutls_x509_crt_get_key_purpose_oid.argtypes = [gnutls_x509_crt_t, c_int, c_void_p, POINTER(size_t), POINTER(c_uint)]
+gnutls_x509_crt_set_key_purpose_oid = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_key_purpose_oid
+gnutls_x509_crt_set_key_purpose_oid.restype = c_int
+gnutls_x509_crt_set_key_purpose_oid.argtypes = [gnutls_x509_crt_t, c_void_p, c_uint]
+gnutls_x509_privkey_init = _libraries['libgnutls.so.26'].gnutls_x509_privkey_init
+gnutls_x509_privkey_init.restype = c_int
+gnutls_x509_privkey_init.argtypes = [POINTER(gnutls_x509_privkey_t)]
+gnutls_x509_privkey_deinit = _libraries['libgnutls.so.26'].gnutls_x509_privkey_deinit
+gnutls_x509_privkey_deinit.restype = None
+gnutls_x509_privkey_deinit.argtypes = [gnutls_x509_privkey_t]
+gnutls_x509_privkey_cpy = _libraries['libgnutls.so.26'].gnutls_x509_privkey_cpy
+gnutls_x509_privkey_cpy.restype = c_int
+gnutls_x509_privkey_cpy.argtypes = [gnutls_x509_privkey_t, gnutls_x509_privkey_t]
+gnutls_x509_privkey_import = _libraries['libgnutls.so.26'].gnutls_x509_privkey_import
+gnutls_x509_privkey_import.restype = c_int
+gnutls_x509_privkey_import.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_x509_privkey_import_pkcs8 = _libraries['libgnutls.so.26'].gnutls_x509_privkey_import_pkcs8
+gnutls_x509_privkey_import_pkcs8.restype = c_int
+gnutls_x509_privkey_import_pkcs8.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t, STRING, c_uint]
+gnutls_x509_privkey_import_rsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_privkey_import_rsa_raw
+gnutls_x509_privkey_import_rsa_raw.restype = c_int
+gnutls_x509_privkey_import_rsa_raw.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_privkey_fix = _libraries['libgnutls.so.26'].gnutls_x509_privkey_fix
+gnutls_x509_privkey_fix.restype = c_int
+gnutls_x509_privkey_fix.argtypes = [gnutls_x509_privkey_t]
+gnutls_x509_privkey_export_dsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_privkey_export_dsa_raw
+gnutls_x509_privkey_export_dsa_raw.restype = c_int
+gnutls_x509_privkey_export_dsa_raw.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_privkey_import_dsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_privkey_import_dsa_raw
+gnutls_x509_privkey_import_dsa_raw.restype = c_int
+gnutls_x509_privkey_import_dsa_raw.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_privkey_get_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_x509_privkey_get_pk_algorithm
+gnutls_x509_privkey_get_pk_algorithm.restype = c_int
+gnutls_x509_privkey_get_pk_algorithm.argtypes = [gnutls_x509_privkey_t]
+gnutls_x509_privkey_get_key_id = _libraries['libgnutls.so.26'].gnutls_x509_privkey_get_key_id
+gnutls_x509_privkey_get_key_id.restype = c_int
+gnutls_x509_privkey_get_key_id.argtypes = [gnutls_x509_privkey_t, c_uint, POINTER(c_ubyte), POINTER(size_t)]
+gnutls_x509_privkey_generate = _libraries['libgnutls.so.26'].gnutls_x509_privkey_generate
+gnutls_x509_privkey_generate.restype = c_int
+gnutls_x509_privkey_generate.argtypes = [gnutls_x509_privkey_t, gnutls_pk_algorithm_t, c_uint, c_uint]
+gnutls_x509_privkey_export = _libraries['libgnutls.so.26'].gnutls_x509_privkey_export
+gnutls_x509_privkey_export.restype = c_int
+gnutls_x509_privkey_export.argtypes = [gnutls_x509_privkey_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_x509_privkey_export_pkcs8 = _libraries['libgnutls.so.26'].gnutls_x509_privkey_export_pkcs8
+gnutls_x509_privkey_export_pkcs8.restype = c_int
+gnutls_x509_privkey_export_pkcs8.argtypes = [gnutls_x509_privkey_t, gnutls_x509_crt_fmt_t, STRING, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_privkey_export_rsa_raw = _libraries['libgnutls.so.26'].gnutls_x509_privkey_export_rsa_raw
+gnutls_x509_privkey_export_rsa_raw.restype = c_int
+gnutls_x509_privkey_export_rsa_raw.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_privkey_sign_data = _libraries['libgnutls.so.26'].gnutls_x509_privkey_sign_data
+gnutls_x509_privkey_sign_data.restype = c_int
+gnutls_x509_privkey_sign_data.argtypes = [gnutls_x509_privkey_t, gnutls_digest_algorithm_t, c_uint, POINTER(gnutls_datum_t), c_void_p, POINTER(size_t)]
+gnutls_x509_privkey_verify_data = _libraries['libgnutls.so.26'].gnutls_x509_privkey_verify_data
+gnutls_x509_privkey_verify_data.restype = c_int
+gnutls_x509_privkey_verify_data.argtypes = [gnutls_x509_privkey_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_crt_verify_data = _libraries['libgnutls.so.26'].gnutls_x509_crt_verify_data
+gnutls_x509_crt_verify_data.restype = c_int
+gnutls_x509_crt_verify_data.argtypes = [gnutls_x509_crt_t, c_uint, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_privkey_sign_hash = _libraries['libgnutls.so.26'].gnutls_x509_privkey_sign_hash
+gnutls_x509_privkey_sign_hash.restype = c_int
+gnutls_x509_privkey_sign_hash.argtypes = [gnutls_x509_privkey_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t)]
+gnutls_x509_crq_init = _libraries['libgnutls.so.26'].gnutls_x509_crq_init
+gnutls_x509_crq_init.restype = c_int
+gnutls_x509_crq_init.argtypes = [POINTER(gnutls_x509_crq_t)]
+gnutls_x509_crq_deinit = _libraries['libgnutls.so.26'].gnutls_x509_crq_deinit
+gnutls_x509_crq_deinit.restype = None
+gnutls_x509_crq_deinit.argtypes = [gnutls_x509_crq_t]
+gnutls_x509_crq_import = _libraries['libgnutls.so.26'].gnutls_x509_crq_import
+gnutls_x509_crq_import.restype = c_int
+gnutls_x509_crq_import.argtypes = [gnutls_x509_crq_t, POINTER(gnutls_datum_t), gnutls_x509_crt_fmt_t]
+gnutls_x509_crq_get_pk_algorithm = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_pk_algorithm
+gnutls_x509_crq_get_pk_algorithm.restype = c_int
+gnutls_x509_crq_get_pk_algorithm.argtypes = [gnutls_x509_crq_t, POINTER(c_uint)]
+gnutls_x509_crq_get_dn = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_dn
+gnutls_x509_crq_get_dn.restype = c_int
+gnutls_x509_crq_get_dn.argtypes = [gnutls_x509_crq_t, STRING, POINTER(size_t)]
+gnutls_x509_crq_get_dn_oid = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_dn_oid
+gnutls_x509_crq_get_dn_oid.restype = c_int
+gnutls_x509_crq_get_dn_oid.argtypes = [gnutls_x509_crq_t, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crq_get_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_dn_by_oid
+gnutls_x509_crq_get_dn_by_oid.restype = c_int
+gnutls_x509_crq_get_dn_by_oid.argtypes = [gnutls_x509_crq_t, STRING, c_int, c_uint, c_void_p, POINTER(size_t)]
+gnutls_x509_crq_set_dn_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crq_set_dn_by_oid
+gnutls_x509_crq_set_dn_by_oid.restype = c_int
+gnutls_x509_crq_set_dn_by_oid.argtypes = [gnutls_x509_crq_t, STRING, c_uint, c_void_p, c_uint]
+gnutls_x509_crq_set_version = _libraries['libgnutls.so.26'].gnutls_x509_crq_set_version
+gnutls_x509_crq_set_version.restype = c_int
+gnutls_x509_crq_set_version.argtypes = [gnutls_x509_crq_t, c_uint]
+gnutls_x509_crq_set_key = _libraries['libgnutls.so.26'].gnutls_x509_crq_set_key
+gnutls_x509_crq_set_key.restype = c_int
+gnutls_x509_crq_set_key.argtypes = [gnutls_x509_crq_t, gnutls_x509_privkey_t]
+gnutls_x509_crq_sign2 = _libraries['libgnutls.so.26'].gnutls_x509_crq_sign2
+gnutls_x509_crq_sign2.restype = c_int
+gnutls_x509_crq_sign2.argtypes = [gnutls_x509_crq_t, gnutls_x509_privkey_t, gnutls_digest_algorithm_t, c_uint]
+gnutls_x509_crq_sign = _libraries['libgnutls.so.26'].gnutls_x509_crq_sign
+gnutls_x509_crq_sign.restype = c_int
+gnutls_x509_crq_sign.argtypes = [gnutls_x509_crq_t, gnutls_x509_privkey_t]
+gnutls_x509_crq_set_challenge_password = _libraries['libgnutls.so.26'].gnutls_x509_crq_set_challenge_password
+gnutls_x509_crq_set_challenge_password.restype = c_int
+gnutls_x509_crq_set_challenge_password.argtypes = [gnutls_x509_crq_t, STRING]
+gnutls_x509_crq_get_challenge_password = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_challenge_password
+gnutls_x509_crq_get_challenge_password.restype = c_int
+gnutls_x509_crq_get_challenge_password.argtypes = [gnutls_x509_crq_t, STRING, POINTER(size_t)]
+gnutls_x509_crq_set_attribute_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crq_set_attribute_by_oid
+gnutls_x509_crq_set_attribute_by_oid.restype = c_int
+gnutls_x509_crq_set_attribute_by_oid.argtypes = [gnutls_x509_crq_t, STRING, c_void_p, size_t]
+gnutls_x509_crq_get_attribute_by_oid = _libraries['libgnutls.so.26'].gnutls_x509_crq_get_attribute_by_oid
+gnutls_x509_crq_get_attribute_by_oid.restype = c_int
+gnutls_x509_crq_get_attribute_by_oid.argtypes = [gnutls_x509_crq_t, STRING, c_int, c_void_p, POINTER(size_t)]
+gnutls_x509_crq_export = _libraries['libgnutls.so.26'].gnutls_x509_crq_export
+gnutls_x509_crq_export.restype = c_int
+gnutls_x509_crq_export.argtypes = [gnutls_x509_crq_t, gnutls_x509_crt_fmt_t, c_void_p, POINTER(size_t)]
+gnutls_x509_crt_set_crq = _libraries['libgnutls.so.26'].gnutls_x509_crt_set_crq
+gnutls_x509_crt_set_crq.restype = c_int
+gnutls_x509_crt_set_crq.argtypes = [gnutls_x509_crt_t, gnutls_x509_crq_t]
+__all__ = ['gnutls_ia_set_server_avp_ptr',
+           'gnutls_openpgp_privkey_init',
+           'gnutls_certificate_activation_time_peers',
+           'gnutls_x509_crt_set_proxy_dn',
+           'gnutls_db_set_remove_function',
+           'gnutls_x509_crt_set_dn_by_oid',
+           'gnutls_x509_crt_check_hostname',
+           'gnutls_openpgp_keyring_get_crt',
+           'gnutls_global_init_extra',
+           'gnutls_srp_set_client_credentials_function',
+           'gnutls_x509_crl_import',
+           'gnutls_certificate_set_x509_trust_file',
+           'gnutls_x509_crt_get_pk_rsa_raw',
+           'gnutls_x509_privkey_export_rsa_raw',
+           'gnutls_priority_set', 'gnutls_cipher_get',
+           'gnutls_certificate_set_openpgp_keyring_mem',
+           'gnutls_x509_crt_get_ca_status',
+           'gnutls_cipher_get_key_size',
+           'gnutls_certificate_set_x509_crl_file',
+           'gnutls_x509_privkey_import_dsa_raw',
+           'gnutls_x509_crq_init', 'gnutls_session_get_master_secret',
+           'gnutls_x509_crq_get_challenge_password', '__time_t',
+           'gnutls_x509_crt_get_pk_algorithm',
+           'gnutls_x509_crt_set_crq',
+           'gnutls_certificate_set_openpgp_key_mem2',
+           'gnutls_certificate_free_keys', 'gnutls_srp_verifier',
+           'gnutls_x509_crl_deinit',
+           'gnutls_openpgp_crt_get_pk_dsa_raw',
+           'gnutls_certificate_free_ca_names', 'gnutls_cipher_list',
+           'gnutls_x509_crq_export',
+           'gnutls_certificate_client_set_retrieve_function',
+           'gnutls_x509_crl_get_crt_serial',
+           'gnutls_pkcs7_get_crt_count',
+           'gnutls_certificate_set_x509_trust',
+           'gnutls_openpgp_crt_get_subkey_fingerprint',
+           'gnutls_ia_handshake_p',
+           'gnutls_openpgp_privkey_get_subkey_fingerprint',
+           'gnutls_openpgp_keyring_import', 'gnutls_pkcs7_set_crl',
+           'gnutls_x509_crq_get_pk_algorithm',
+           'gnutls_pkcs7_set_crl_raw',
+           'gnutls_certificate_set_verify_limits',
+           'gnutls_x509_crt_get_authority_key_id',
+           'gnutls_x509_crt_set_activation_time', 'gnutls_db_set_ptr',
+           'gnutls_openpgp_crt_get_version',
+           'gnutls_x509_crt_get_subject_key_id',
+           'gnutls_credentials_clear', 'gnutls_x509_crt_get_key_id',
+           'gnutls_x509_crt_init', 'gnutls_dh_params_generate2',
+           'gnutls_pkcs7_delete_crt',
+           'gnutls_x509_crt_get_subject_alt_name2',
+           'gnutls_alert_get_name',
+           'gnutls_x509_crt_set_authority_key_id',
+           'gnutls_openpgp_crt_get_subkey_pk_rsa_raw',
+           'gnutls_x509_crt_list_verify', 'gnutls_priority_init',
+           'gnutls_openpgp_crt_get_expiration_time',
+           'gnutls_x509_crl_set_version',
+           'gnutls_certificate_set_openpgp_keyring_file',
+           'gnutls_pem_base64_encode',
+           'gnutls_handshake_set_max_packet_length',
+           'gnutls_openpgp_privkey_get_subkey_expiration_time',
+           'gnutls_x509_crq_set_dn_by_oid', 'gnutls_session_get_id',
+           'gnutls_cipher_set_priority',
+           'gnutls_openpgp_keyring_check_id',
+           'gnutls_openpgp_keyring_deinit',
+           'gnutls_srp_base64_encode_alloc',
+           'gnutls_db_set_store_function',
+           'gnutls_supplemental_get_name',
+           'gnutls_handshake_get_last_out',
+           'gnutls_x509_privkey_export_pkcs8',
+           'gnutls_x509_privkey_deinit', 'gnutls_compression_get_id',
+           'gnutls_openpgp_crt_get_subkey_idx',
+           'gnutls_x509_privkey_import_rsa_raw',
+           'gnutls_transport_set_errno',
+           'gnutls_openpgp_privkey_get_subkey_revoked_status',
+           'gnutls_x509_crt_get_issuer_dn',
+           'gnutls_ia_get_server_avp_ptr',
+           'gnutls_openpgp_keyring_get_crt_count', 'gnutls_ia_recv',
+           'gnutls_x509_crt_get_pk_dsa_raw', 'gnutls_x509_crt_sign',
+           'gnutls_certificate_verify_peers',
+           'gnutls_srp_free_server_credentials',
+           'gnutls_x509_crt_print',
+           'gnutls_openpgp_privkey_export_subkey_dsa_raw',
+           'gnutls_server_name_set', 'gnutls_kx_set_priority',
+           'gnutls_transport_set_push_function',
+           'gnutls_x509_crt_sign2',
+           'gnutls_x509_crt_cpy_crl_dist_points',
+           'gnutls_pem_base64_decode', 'gnutls_srp_base64_decode',
+           'gnutls_openpgp_privkey_get_subkey_count',
+           'gnutls_global_init', 'gnutls_x509_rdn_get_by_oid',
+           'gnutls_dh_params_import_raw',
+           'gnutls_global_set_mem_functions',
+           'gnutls_x509_crt_set_key_usage', 'time_t',
+           'gnutls_anon_set_server_params_function',
+           'gnutls_mac_get_key_size',
+           'gnutls_rsa_params_export_pkcs1',
+           'gnutls_certificate_type_set_priority',
+           'gnutls_x509_crt_get_issuer_dn_oid',
+           'gnutls_dh_params_init',
+           'gnutls_x509_crq_set_attribute_by_oid',
+           'gnutls_certificate_expiration_time_peers',
+           'gnutls_ia_endphase_send',
+           'gnutls_psk_allocate_server_credentials',
+           'gnutls_certificate_set_dh_params', 'gnutls_init',
+           'gnutls_openpgp_privkey_get_subkey_pk_algorithm',
+           'gnutls_x509_rdn_get_oid', 'gnutls_x509_crl_get_crt_count',
+           'gnutls_perror', 'gnutls_x509_crl_get_dn_oid',
+           'gnutls_certificate_get_peers',
+           'gnutls_ia_set_server_avp_function',
+           'gnutls_x509_crl_sign2',
+           'gnutls_x509_crt_get_extension_oid',
+           'gnutls_x509_crl_sign', 'gnutls_dh_get_pubkey',
+           'gnutls_record_get_max_size', 'gnutls_x509_crt_get_dn_oid',
+           'gnutls_x509_crt_get_extension_info',
+           'gnutls_transport_get_ptr', 'gnutls_db_check_entry',
+           'gnutls_ia_generate_challenge',
+           'gnutls_certificate_server_set_retrieve_function',
+           'gnutls_certificate_set_openpgp_key',
+           'gnutls_srp_base64_encode', 'gnutls_db_get_ptr',
+           'gnutls_pkcs7_export', 'gnutls_mac_set_priority',
+           'gnutls_x509_crt_get_basic_constraints',
+           'gnutls_x509_crt_get_subject_alt_othername_oid',
+           'gnutls_cipher_get_id', 'gnutls_x509_crl_get_this_update',
+           'gnutls_x509_dn_init', 'gnutls_openpgp_crt_import',
+           'gnutls_certificate_set_x509_crl',
+           'gnutls_rsa_export_get_modulus_bits',
+           'gnutls_x509_crl_get_version',
+           'gnutls_pkcs7_get_crl_count', 'gnutls_handshake',
+           'gnutls_dh_get_group', 'gnutls_x509_crq_get_dn',
+           'gnutls_pkcs7_deinit', 'gnutls_record_check_pending',
+           'gnutls_protocol_get_name',
+           'gnutls_openpgp_privkey_sign_hash',
+           'gnutls_srp_set_server_credentials_file',
+           'gnutls_pkcs7_delete_crl', 'gnutls_rsa_params_init',
+           'gnutls_x509_crt_set_key_purpose_oid', 'gnutls_mac_get',
+           'gnutls_record_get_direction',
+           'gnutls_certificate_type_list', 'gnutls_session_get_ptr',
+           'gnutls_psk_set_server_dh_params',
+           'gnutls_x509_crt_get_raw_issuer_dn',
+           'gnutls_x509_crt_get_raw_dn', 'gnutls_record_send',
+           'gnutls_psk_allocate_client_credentials',
+           'gnutls_certificate_set_x509_key',
+           'gnutls_certificate_type_get_id',
+           'gnutls_x509_privkey_export_dsa_raw',
+           'gnutls_pk_algorithm_get_name',
+           'gnutls_openpgp_crt_get_pk_algorithm',
+           'gnutls_psk_free_client_credentials',
+           'gnutls_openpgp_crt_check_hostname',
+           'gnutls_handshake_set_post_client_hello_function',
+           'gnutls_record_set_max_size',
+           'gnutls_openpgp_crt_verify_ring',
+           'gnutls_transport_set_ptr', 'gnutls_ia_set_client_avp_ptr',
+           'gnutls_x509_privkey_generate', 'gnutls_db_remove_session',
+           'gnutls_certificate_type_get_name',
+           'gnutls_openpgp_crt_verify_self',
+           'gnutls_x509_crq_get_dn_oid', 'gnutls_x509_dn_oid_known',
+           'gnutls_openpgp_crt_print', 'gnutls_alert_send',
+           'gnutls_x509_privkey_sign_data',
+           'gnutls_x509_crt_get_extension_data',
+           'gnutls_x509_crl_set_crt_serial',
+           'gnutls_x509_crt_set_basic_constraints',
+           'gnutls_credentials_set', 'gnutls_transport_set_ptr2',
+           'gnutls_x509_crt_set_issuer_dn_by_oid',
+           'gnutls_record_disable_padding', 'gnutls_prf_raw',
+           'gnutls_anon_allocate_server_credentials',
+           'gnutls_x509_crl_get_signature',
+           'gnutls_x509_crl_check_issuer', 'gnutls_cipher_suite_info',
+           'gnutls_x509_crt_get_issuer',
+           'gnutls_certificate_set_params_function',
+           'gnutls_openpgp_crt_get_subkey_id',
+           'gnutls_psk_set_server_credentials_hint',
+           'gnutls_sign_callback_set',
+           'gnutls_x509_crt_check_revocation',
+           'gnutls_openpgp_privkey_export',
+           'gnutls_x509_crt_get_activation_time', 'gnutls_kx_list',
+           'gnutls_x509_crt_get_subject_alt_name',
+           'gnutls_openpgp_privkey_get_subkey_creation_time',
+           'gnutls_x509_crt_get_dn_by_oid', 'gnutls_rsa_params_cpy',
+           'gnutls_x509_crt_set_subject_key_id',
+           'gnutls_check_version',
+           'gnutls_certificate_client_get_request_status',
+           'gnutls_prf', 'gnutls_srp_server_get_username',
+           'gnutls_pem_base64_encode_alloc',
+           'gnutls_certificate_set_openpgp_key_file2',
+           'gnutls_openpgp_privkey_export_rsa_raw',
+           'gnutls_certificate_set_openpgp_key_mem',
+           'gnutls_openpgp_privkey_get_key_id',
+           'gnutls_anon_free_client_credentials',
+           'gnutls_transport_get_ptr2',
+           'gnutls_ia_get_client_avp_ptr', 'gnutls_pkcs7_import',
+           'gnutls_compression_get',
+           'gnutls_x509_crl_get_signature_algorithm',
+           'gnutls_openpgp_keyring_init',
+           'gnutls_certificate_free_crls',
+           'gnutls_transport_set_global_errno', 'gnutls_record_recv',
+           'gnutls_certificate_type_get',
+           'gnutls_auth_server_get_type',
+           'gnutls_anon_set_params_function',
+           'gnutls_openpgp_crt_deinit', 'gnutls_pkcs7_set_crt',
+           'gnutls_rsa_params_export_raw',
+           'gnutls_x509_dn_get_rdn_ava', 'gnutls_x509_crt_deinit',
+           'gnutls_session_get_client_random',
+           'gnutls_openpgp_set_recv_key_function',
+           'gnutls_x509_crl_set_this_update',
+           'gnutls_ia_free_client_credentials',
+           'gnutls_protocol_get_version', 'gnutls_x509_crl_set_crt',
+           'gnutls_fingerprint', 'gnutls_x509_dn_export',
+           'gnutls_openpgp_privkey_import', 'gnutls_error_to_alert',
+           'gnutls_x509_privkey_get_key_id',
+           'gnutls_x509_crt_get_subject', 'gnutls_rsa_params_deinit',
+           'gnutls_cipher_get_name', 'gnutls_ia_send',
+           'gnutls_x509_crt_set_extension_by_oid',
+           'gnutls_x509_privkey_get_pk_algorithm',
+           'gnutls_hex_encode', 'gnutls_rsa_params_import_raw',
+           'gnutls_mac_get_name', 'gnutls_psk_server_get_username',
+           'gnutls_session_get_data2', 'gnutls_kx_get',
+           'gnutls_openpgp_crt_get_preferred_key_id',
+           'gnutls_certificate_get_x509_crls',
+           'gnutls_x509_crq_set_version', 'gnutls_x509_privkey_cpy',
+           'gnutls_openpgp_crt_get_subkey_revoked_status',
+           'gnutls_priority_set_direct', 'gnutls_dh_get_secret_bits',
+           'gnutls_x509_crt_get_expiration_time', 'gnutls_pkcs7_init',
+           'gnutls_transport_set_pull_function',
+           'gnutls_protocol_list',
+           'gnutls_srp_set_client_credentials',
+           'gnutls_x509_crt_get_key_purpose_oid',
+           'gnutls_certificate_verify_peers2',
+           'gnutls_srp_base64_decode_alloc', 'gnutls_x509_crq_sign',
+           'gnutls_x509_privkey_init', 'gnutls_global_set_log_level',
+           'gnutls_sign_callback_get', 'gnutls_x509_rdn_get',
+           'gnutls_openpgp_privkey_set_preferred_key_id',
+           'gnutls_certificate_free_credentials',
+           'gnutls_x509_dn_deinit',
+           'gnutls_certificate_set_rsa_export_params',
+           'gnutls_x509_crt_get_serial', 'gnutls_x509_crq_import',
+           'gnutls_x509_privkey_export',
+           'gnutls_cipher_suite_get_name',
+           'gnutls_ia_extract_inner_secret',
+           'gnutls_x509_crt_get_version', 'gnutls_ia_enable',
+           'gnutls_x509_crt_set_key',
+           'gnutls_srp_free_client_credentials', 'gnutls_mac_list',
+           'gnutls_dh_get_prime_bits', 'gnutls_certificate_free_cas',
+           'gnutls_alert_get', 'gnutls_ia_permute_inner_secret',
+           'gnutls_rehandshake',
+           'gnutls_x509_crt_set_subject_alternative_name',
+           'gnutls_psk_set_server_credentials_file',
+           'gnutls_dh_set_prime_bits', 'gnutls_priority_deinit',
+           'gnutls_x509_crt_set_version',
+           'gnutls_dh_params_export_pkcs3', 'gnutls_x509_crq_deinit',
+           'gnutls_x509_crt_get_fingerprint',
+           'gnutls_extra_check_version',
+           'gnutls_srp_allocate_client_credentials',
+           'gnutls_x509_crl_get_issuer_dn_by_oid',
+           'gnutls_pkcs7_get_crl_raw',
+           'gnutls_x509_crt_set_expiration_time',
+           'gnutls_compression_set_priority',
+           'gnutls_openpgp_crt_get_subkey_count',
+           'gnutls_openpgp_crt_get_key_usage',
+           'gnutls_ia_allocate_server_credentials',
+           'gnutls_ia_free_server_credentials',
+           'gnutls_transport_set_lowat',
+           'gnutls_x509_crt_set_crl_dist_points',
+           'gnutls_compression_list',
+           'gnutls_x509_privkey_import_pkcs8',
+           'gnutls_session_enable_compatibility_mode',
+           'gnutls_x509_crq_set_challenge_password',
+           'gnutls_strerror', 'gnutls_x509_crt_get_dn',
+           'gnutls_x509_crl_init',
+           'gnutls_certificate_set_verify_flags',
+           'gnutls_psk_free_server_credentials',
+           'gnutls_openpgp_privkey_get_subkey_idx',
+           'gnutls_ia_set_client_avp_function',
+           'gnutls_openpgp_crt_get_subkey_creation_time',
+           'gnutls_compression_get_name', 'gnutls_openpgp_crt_init',
+           'gnutls_x509_crq_get_dn_by_oid',
+           'gnutls_openpgp_privkey_get_pk_algorithm',
+           'gnutls_certificate_set_x509_key_file',
+           'gnutls_openpgp_crt_get_key_id',
+           'gnutls_set_default_export_priority',
+           'gnutls_x509_crl_print', 'gnutls_rsa_export_get_pubkey',
+           'gnutls_x509_crq_set_key',
+           'gnutls_x509_crt_get_signature_algorithm',
+           'gnutls_openpgp_crt_get_name',
+           'gnutls_openpgp_crt_get_subkey_pk_dsa_raw',
+           'gnutls_x509_crl_get_issuer_dn',
+           'gnutls_rsa_params_generate2',
+           'gnutls_handshake_set_private_extensions',
+           'gnutls_psk_set_client_credentials',
+           'gnutls_server_name_get',
+           'gnutls_openpgp_crt_get_subkey_usage',
+           'gnutls_rsa_params_import_pkcs1', 'gnutls_session_set_ptr',
+           'gnutls_bye', 'gnutls_auth_client_get_type',
+           'gnutls_openpgp_privkey_export_subkey_rsa_raw',
+           'gnutls_x509_crt_get_proxy', 'gnutls_kx_get_id',
+           'gnutls_session_get_data', 'gnutls_x509_crt_list_import',
+           'gnutls_pkcs7_get_crt_raw',
+           'gnutls_openpgp_privkey_get_subkey_id',
+           'gnutls_psk_set_server_credentials_function',
+           'gnutls_srp_set_server_credentials_function',
+           'gnutls_ia_verify_endphase', 'gnutls_error_is_fatal',
+           'gnutls_x509_crt_verify_data',
+           'gnutls_psk_netconf_derive_key',
+           'gnutls_certificate_server_set_request',
+           'gnutls_openpgp_privkey_get_fingerprint',
+           'gnutls_dh_params_export_raw',
+           'gnutls_protocol_set_priority',
+           'gnutls_psk_set_client_credentials_function',
+           'gnutls_set_default_priority', 'gnutls_hex2bin',
+           'gnutls_dh_params_cpy', 'gnutls_ia_handshake',
+           'gnutls_handshake_get_last_in', 'gnutls_protocol_get_id',
+           'gnutls_x509_crq_get_attribute_by_oid',
+           'gnutls_certificate_get_ours',
+           'gnutls_anon_free_server_credentials',
+           'gnutls_x509_crt_verify', 'gnutls_session_set_data',
+           'gnutls_certificate_allocate_credentials',
+           'gnutls_x509_crt_set_serial', 'gnutls_openpgp_send_cert',
+           'gnutls_certificate_set_x509_key_mem',
+           'gnutls_x509_crt_get_extension_by_oid',
+           'gnutls_session_get_server_random',
+           'gnutls_openpgp_privkey_get_revoked_status',
+           'gnutls_dh_params_deinit', 'gnutls_mac_get_id',
+           'gnutls_x509_crt_get_signature', 'gnutls_x509_crq_sign2',
+           'gnutls_global_deinit', 'gnutls_sign_algorithm_get_name',
+           'gnutls_anon_allocate_client_credentials',
+           'gnutls_x509_crt_export',
+           'gnutls_certificate_get_x509_cas',
+           'gnutls_dh_params_import_pkcs3', 'gnutls_hex_decode',
+           'gnutls_openpgp_crt_export',
+           'gnutls_psk_set_params_function',
+           'gnutls_x509_crt_check_issuer',
+           'gnutls_x509_crl_set_next_update',
+           'gnutls_ia_allocate_client_credentials',
+           'gnutls_psk_client_get_hint',
+           'gnutls_certificate_send_x509_rdn_sequence',
+           'gnutls_alert_send_appropriate',
+           'gnutls_anon_set_server_dh_params',
+           'gnutls_openpgp_crt_get_revoked_status',
+           'gnutls_openpgp_crt_get_subkey_pk_algorithm',
+           'gnutls_openpgp_privkey_get_preferred_key_id',
+           'gnutls_x509_privkey_sign_hash', 'gnutls_x509_crl_export',
+           'gnutls_openpgp_privkey_deinit',
+           'gnutls_pkcs7_set_crt_raw', 'gnutls_auth_get_type',
+           'gnutls_certificate_get_openpgp_keyring',
+           'gnutls_openpgp_privkey_export_dsa_raw',
+           'gnutls_openpgp_crt_set_preferred_key_id',
+           'gnutls_srp_allocate_server_credentials',
+           'gnutls_dh_get_peers_public_bits',
+           'gnutls_certificate_set_x509_crl_mem',
+           'gnutls_x509_privkey_fix', 'gnutls_kx_get_name',
+           'gnutls_psk_set_server_params_function',
+           'gnutls_openpgp_crt_get_fingerprint',
+           'gnutls_openpgp_crt_get_subkey_expiration_time',
+           'gnutls_x509_dn_import',
+           'gnutls_x509_crt_get_issuer_dn_by_oid',
+           'gnutls_openpgp_crt_get_creation_time',
+           'gnutls_openpgp_crt_get_pk_rsa_raw',
+           'gnutls_session_is_resumed', 'gnutls_x509_crt_set_proxy',
+           'gnutls_certificate_set_openpgp_key_file',
+           'gnutls_certificate_set_x509_trust_mem',
+           'gnutls_openpgp_crt_get_auth_subkey',
+           'gnutls_x509_privkey_verify_data', 'gnutls_deinit',
+           'gnutls_x509_crt_import',
+           'gnutls_db_set_retrieve_function',
+           'gnutls_x509_privkey_import',
+           'gnutls_certificate_set_x509_simple_pkcs12_file',
+           'gnutls_global_set_log_function',
+           'gnutls_db_set_cache_expiration',
+           'gnutls_x509_crt_set_ca_status',
+           'gnutls_x509_crl_get_next_update',
+           'gnutls_x509_crl_verify', 'gnutls_pem_base64_decode_alloc',
+           'gnutls_x509_crt_get_key_usage',
+           'gnutls_x509_crt_get_crl_dist_points']
diff --git a/gnutls-1.1.9/gnutls/library/types.py b/gnutls-1.1.9/gnutls/library/types.py
new file mode 100644
index 0000000..0d878bb
--- /dev/null
+++ b/gnutls-1.1.9/gnutls/library/types.py
@@ -0,0 +1,248 @@
+from ctypes import *
+
+STRING = c_char_p
+from gnutls.library.constants import gnutls_cipher_algorithm_t
+from gnutls.library.constants import gnutls_certificate_print_formats
+from gnutls.library.constants import gnutls_params_type_t
+from gnutls.library.constants import gnutls_psk_key_flags
+from gnutls.library.constants import gnutls_x509_subject_alt_name_t
+from gnutls.library.constants import gnutls_certificate_type_t
+from gnutls.library.constants import gnutls_pk_algorithm_t
+from gnutls.library.constants import gnutls_openpgp_crt_fmt
+from gnutls.library.constants import gnutls_certificate_import_flags
+from gnutls.library.constants import gnutls_certificate_verify_flags
+from gnutls.library.constants import gnutls_pkcs_encrypt_flags_t
+
+
+class gnutls_session_int(Structure):
+    pass
+gnutls_session_t = POINTER(gnutls_session_int)
+size_t = c_size_t
+gnutls_ia_avp_func = CFUNCTYPE(c_int, gnutls_session_t, c_void_p, STRING, size_t, POINTER(STRING), POINTER(size_t))
+class gnutls_ia_server_credentials_st(Structure):
+    pass
+gnutls_ia_server_credentials_st._fields_ = [
+]
+gnutls_ia_server_credentials_t = POINTER(gnutls_ia_server_credentials_st)
+class gnutls_ia_client_credentials_st(Structure):
+    pass
+gnutls_ia_client_credentials_st._fields_ = [
+]
+gnutls_ia_client_credentials_t = POINTER(gnutls_ia_client_credentials_st)
+gnutls_certificate_print_formats_t = gnutls_certificate_print_formats
+gnutls_transport_ptr_t = c_void_p
+gnutls_session_int._fields_ = [
+]
+class gnutls_dh_params_int(Structure):
+    pass
+gnutls_dh_params_int._fields_ = [
+]
+gnutls_dh_params_t = POINTER(gnutls_dh_params_int)
+class gnutls_x509_privkey_int(Structure):
+    pass
+gnutls_x509_privkey_int._fields_ = [
+]
+gnutls_rsa_params_t = POINTER(gnutls_x509_privkey_int)
+class gnutls_priority_st(Structure):
+    pass
+gnutls_priority_st._fields_ = [
+]
+gnutls_priority_t = POINTER(gnutls_priority_st)
+class gnutls_datum_t(Structure):
+    pass
+gnutls_datum_t._fields_ = [
+    ('data', POINTER(c_ubyte)),
+    ('size', c_uint),
+]
+class gnutls_params_st(Structure):
+    pass
+class params(Union):
+    pass
+params._fields_ = [
+    ('dh', gnutls_dh_params_t),
+    ('rsa_export', gnutls_rsa_params_t),
+]
+gnutls_params_st._fields_ = [
+    ('type', gnutls_params_type_t),
+    ('params', params),
+    ('deinit', c_int),
+]
+gnutls_params_function = CFUNCTYPE(c_int, gnutls_session_t, gnutls_params_type_t, POINTER(gnutls_params_st))
+gnutls_oprfi_callback_func = CFUNCTYPE(c_int, gnutls_session_t, c_void_p, size_t, POINTER(c_ubyte), POINTER(c_ubyte))
+gnutls_db_store_func = CFUNCTYPE(c_int, c_void_p, gnutls_datum_t, gnutls_datum_t)
+gnutls_db_remove_func = CFUNCTYPE(c_int, c_void_p, gnutls_datum_t)
+gnutls_db_retr_func = CFUNCTYPE(gnutls_datum_t, c_void_p, gnutls_datum_t)
+gnutls_handshake_post_client_hello_func = CFUNCTYPE(c_int, gnutls_session_t)
+class gnutls_certificate_credentials_st(Structure):
+    pass
+gnutls_certificate_credentials_st._fields_ = [
+]
+gnutls_certificate_credentials_t = POINTER(gnutls_certificate_credentials_st)
+gnutls_certificate_server_credentials = gnutls_certificate_credentials_t
+gnutls_certificate_client_credentials = gnutls_certificate_credentials_t
+class gnutls_anon_server_credentials_st(Structure):
+    pass
+gnutls_anon_server_credentials_st._fields_ = [
+]
+gnutls_anon_server_credentials_t = POINTER(gnutls_anon_server_credentials_st)
+class gnutls_anon_client_credentials_st(Structure):
+    pass
+gnutls_anon_client_credentials_st._fields_ = [
+]
+gnutls_anon_client_credentials_t = POINTER(gnutls_anon_client_credentials_st)
+gnutls_x509_privkey_t = POINTER(gnutls_x509_privkey_int)
+class gnutls_x509_crl_int(Structure):
+    pass
+gnutls_x509_crl_int._fields_ = [
+]
+gnutls_x509_crl_t = POINTER(gnutls_x509_crl_int)
+class gnutls_x509_crt_int(Structure):
+    pass
+gnutls_x509_crt_int._fields_ = [
+]
+gnutls_x509_crt_t = POINTER(gnutls_x509_crt_int)
+class gnutls_openpgp_keyring_int(Structure):
+    pass
+gnutls_openpgp_keyring_int._fields_ = [
+]
+gnutls_openpgp_keyring_t = POINTER(gnutls_openpgp_keyring_int)
+gnutls_alloc_function = CFUNCTYPE(c_void_p, size_t)
+gnutls_calloc_function = CFUNCTYPE(c_void_p, size_t, size_t)
+gnutls_is_secure_function = CFUNCTYPE(c_int, c_void_p)
+gnutls_free_function = CFUNCTYPE(None, c_void_p)
+gnutls_realloc_function = CFUNCTYPE(c_void_p, c_void_p, size_t)
+gnutls_log_func = CFUNCTYPE(None, c_int, STRING)
+__ssize_t = c_long
+ssize_t = __ssize_t
+gnutls_pull_func = CFUNCTYPE(ssize_t, gnutls_transport_ptr_t, c_void_p, size_t)
+gnutls_push_func = CFUNCTYPE(ssize_t, gnutls_transport_ptr_t, c_void_p, size_t)
+class gnutls_srp_server_credentials_st(Structure):
+    pass
+gnutls_srp_server_credentials_st._fields_ = [
+]
+gnutls_srp_server_credentials_t = POINTER(gnutls_srp_server_credentials_st)
+class gnutls_srp_client_credentials_st(Structure):
+    pass
+gnutls_srp_client_credentials_st._fields_ = [
+]
+gnutls_srp_client_credentials_t = POINTER(gnutls_srp_client_credentials_st)
+gnutls_srp_server_credentials_function = CFUNCTYPE(c_int, gnutls_session_t, STRING, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t))
+gnutls_srp_client_credentials_function = CFUNCTYPE(c_int, gnutls_session_t, POINTER(STRING), POINTER(STRING))
+class gnutls_psk_server_credentials_st(Structure):
+    pass
+gnutls_psk_server_credentials_st._fields_ = [
+]
+gnutls_psk_server_credentials_t = POINTER(gnutls_psk_server_credentials_st)
+class gnutls_psk_client_credentials_st(Structure):
+    pass
+gnutls_psk_client_credentials_st._fields_ = [
+]
+gnutls_psk_client_credentials_t = POINTER(gnutls_psk_client_credentials_st)
+gnutls_psk_server_credentials_function = CFUNCTYPE(c_int, gnutls_session_t, STRING, POINTER(gnutls_datum_t))
+gnutls_psk_client_credentials_function = CFUNCTYPE(c_int, gnutls_session_t, POINTER(STRING), POINTER(gnutls_datum_t))
+class gnutls_openpgp_crt_int(Structure):
+    pass
+gnutls_openpgp_crt_int._fields_ = [
+]
+gnutls_openpgp_crt_t = POINTER(gnutls_openpgp_crt_int)
+class gnutls_openpgp_privkey_int(Structure):
+    pass
+gnutls_openpgp_privkey_int._fields_ = [
+]
+gnutls_openpgp_privkey_t = POINTER(gnutls_openpgp_privkey_int)
+class gnutls_retr_st(Structure):
+    pass
+class cert(Union):
+    pass
+cert._fields_ = [
+    ('x509', POINTER(gnutls_x509_crt_t)),
+    ('pgp', gnutls_openpgp_crt_t),
+]
+class key(Union):
+    pass
+key._fields_ = [
+    ('x509', gnutls_x509_privkey_t),
+    ('pgp', gnutls_openpgp_privkey_t),
+]
+gnutls_retr_st._fields_ = [
+    ('type', gnutls_certificate_type_t),
+    ('cert', cert),
+    ('ncerts', c_uint),
+    ('key', key),
+    ('deinit_all', c_uint),
+]
+gnutls_certificate_client_retrieve_function = CFUNCTYPE(c_int, gnutls_session_t, POINTER(gnutls_datum_t), c_int, POINTER(gnutls_pk_algorithm_t), c_int, POINTER(gnutls_retr_st))
+gnutls_certificate_server_retrieve_function = CFUNCTYPE(c_int, gnutls_session_t, POINTER(gnutls_retr_st))
+gnutls_sign_func = CFUNCTYPE(c_int, gnutls_session_t, c_void_p, gnutls_certificate_type_t, POINTER(gnutls_datum_t), POINTER(gnutls_datum_t), POINTER(gnutls_datum_t))
+gnutls_openpgp_crt_fmt_t = gnutls_openpgp_crt_fmt
+gnutls_openpgp_keyid_t = c_ubyte * 8
+gnutls_openpgp_recv_key_func = CFUNCTYPE(c_int, gnutls_session_t, POINTER(c_ubyte), c_uint, POINTER(gnutls_datum_t))
+gnutls_x509_dn_t = c_void_p
+class gnutls_x509_ava_st(Structure):
+    pass
+gnutls_x509_ava_st._fields_ = [
+    ('oid', gnutls_datum_t),
+    ('value', gnutls_datum_t),
+    ('value_tag', c_ulong),
+]
+class gnutls_pkcs7_int(Structure):
+    pass
+gnutls_pkcs7_int._fields_ = [
+]
+gnutls_pkcs7_t = POINTER(gnutls_pkcs7_int)
+class gnutls_x509_crq_int(Structure):
+    pass
+gnutls_x509_crq_int._fields_ = [
+]
+gnutls_x509_crq_t = POINTER(gnutls_x509_crq_int)
+__all__ = ['key', 'gnutls_certificate_print_formats_t',
+           'gnutls_session_int', 'gnutls_srp_server_credentials_st',
+           'gnutls_oprfi_callback_func', '__ssize_t',
+           'gnutls_transport_ptr_t', 'gnutls_pkcs7_int',
+           'gnutls_psk_client_credentials_st', 'gnutls_priority_t',
+           'gnutls_certificate_credentials_st',
+           'gnutls_psk_server_credentials_t', 'gnutls_x509_crt_t',
+           'gnutls_x509_privkey_t', 'gnutls_openpgp_keyring_t',
+           'gnutls_x509_privkey_int', 'gnutls_push_func',
+           'gnutls_x509_crq_int', 'gnutls_psk_server_credentials_st',
+           'gnutls_openpgp_crt_t',
+           'gnutls_certificate_client_credentials', 'size_t',
+           'gnutls_ia_avp_func', 'gnutls_params_st',
+           'gnutls_anon_client_credentials_t', 'gnutls_dh_params_t',
+           'gnutls_anon_client_credentials_st', 'gnutls_sign_func',
+           'gnutls_srp_server_credentials_function', 'cert',
+           'gnutls_x509_crt_int', 'gnutls_realloc_function',
+           'gnutls_srp_client_credentials_function',
+           'gnutls_ia_server_credentials_st',
+           'gnutls_srp_client_credentials_st',
+           'gnutls_calloc_function', 'gnutls_priority_st',
+           'gnutls_x509_crl_int', 'params',
+           'gnutls_certificate_server_credentials',
+           'gnutls_handshake_post_client_hello_func',
+           'gnutls_session_t',
+           'gnutls_psk_client_credentials_function',
+           'gnutls_openpgp_privkey_int', 'gnutls_retr_st',
+           'gnutls_is_secure_function', 'gnutls_db_retr_func',
+           'gnutls_openpgp_keyring_int',
+           'gnutls_srp_client_credentials_t',
+           'gnutls_psk_client_credentials_t',
+           'gnutls_anon_server_credentials_t', 'gnutls_dh_params_int',
+           'gnutls_datum_t', 'gnutls_openpgp_crt_fmt_t',
+           'gnutls_ia_server_credentials_t', 'gnutls_x509_ava_st',
+           'gnutls_alloc_function',
+           'gnutls_psk_server_credentials_function',
+           'gnutls_anon_server_credentials_st',
+           'gnutls_params_function',
+           'gnutls_srp_server_credentials_t',
+           'gnutls_openpgp_crt_int', 'gnutls_log_func',
+           'gnutls_rsa_params_t',
+           'gnutls_certificate_server_retrieve_function',
+           'gnutls_x509_dn_t', 'gnutls_x509_crq_t',
+           'gnutls_pull_func', 'gnutls_db_remove_func',
+           'gnutls_ia_client_credentials_t',
+           'gnutls_certificate_credentials_t', 'gnutls_pkcs7_t',
+           'gnutls_ia_client_credentials_st', 'gnutls_db_store_func',
+           'ssize_t', 'gnutls_openpgp_recv_key_func',
+           'gnutls_openpgp_privkey_t', 'gnutls_openpgp_keyid_t',
+           'gnutls_free_function', 'gnutls_x509_crl_t',
+           'gnutls_certificate_client_retrieve_function']
diff --git a/gnutls-1.1.9/gnutls/validators.py b/gnutls-1.1.9/gnutls/validators.py
new file mode 100644
index 0000000..11c29c3
--- /dev/null
+++ b/gnutls-1.1.9/gnutls/validators.py
@@ -0,0 +1,286 @@
+# Copyright (C) 2007 AG Projects. See LICENSE for details.
+#
+
+"""GNUTLS data validators"""
+
+__all__ = ['function_args', 'method_args', 'none', 'ignore', 'list_of', 'one_of', 'ProtocolListValidator', 
+           'KeyExchangeListValidator', 'CipherListValidator', 'MACListValidator', 'CompressionListValidator']
+
+from gnutls.constants import *
+
+#
+# Priority list validators. They take a tuple or list on input and output a
+# tuple with the same elements if they check valid, else raise an exception.
+#
+
+class ProtocolListValidator(tuple):
+    _protocols = set((PROTO_TLS1_1, PROTO_TLS1_0, PROTO_SSL3))
+
+    def __new__(cls, arg):
+        if not isinstance(arg, (tuple, list)):
+            raise TypeError("Argument must be a tuple or list")
+        if not arg:
+            raise ValueError("Protocol list cannot be empty")
+        if not cls._protocols.issuperset(set(arg)):
+            raise ValueError("Got invalid protocol")
+        return tuple.__new__(cls, arg)
+
+
+class KeyExchangeListValidator(tuple):
+    _algorithms = set((KX_RSA, KX_DHE_DSS, KX_DHE_RSA, KX_RSA_EXPORT, KX_ANON_DH))
+
+    def __new__(cls, arg):
+        if not isinstance(arg, (tuple, list)):
+            raise TypeError("Argument must be a tuple or list")
+        if not arg:
+            raise ValueError("Key exchange algorithm list cannot be empty")
+        if not cls._algorithms.issuperset(set(arg)):
+            raise ValueError("Got invalid key exchange algorithm")
+        return tuple.__new__(cls, arg)
+
+
+class CipherListValidator(tuple):
+    _ciphers = set((CIPHER_AES_128_CBC, CIPHER_3DES_CBC, CIPHER_ARCFOUR_128, CIPHER_AES_256_CBC, CIPHER_DES_CBC))
+
+    def __new__(cls, arg):
+        if not isinstance(arg, (tuple, list)):
+            raise TypeError("Argument must be a tuple or list")
+        if not arg:
+            raise ValueError("Cipher list cannot be empty")
+        if not cls._ciphers.issuperset(set(arg)):
+            raise ValueError("Got invalid cipher")
+        return tuple.__new__(cls, arg)
+
+
+class MACListValidator(tuple):
+    _algorithms = set((MAC_SHA1, MAC_MD5, MAC_RMD160))
+
+    def __new__(cls, arg):
+        if not isinstance(arg, (tuple, list)):
+            raise TypeError("Argument must be a tuple or list")
+        if not arg:
+            raise ValueError("MAC algorithm list cannot be empty")
+        if not cls._algorithms.issuperset(set(arg)):
+            raise ValueError("Got invalid MAC algorithm")
+        return tuple.__new__(cls, arg)
+
+
+class CompressionListValidator(tuple):
+    _compressions = set((COMP_DEFLATE, COMP_LZO, COMP_NULL))
+
+    def __new__(cls, arg):
+        if not isinstance(arg, (tuple, list)):
+            raise TypeError("Argument must be a tuple or list")
+        if not arg:
+            raise ValueError("Compression list cannot be empty")
+        if not cls._compressions.issuperset(set(arg)):
+            raise ValueError("Got invalid compression")
+        return tuple.__new__(cls, arg)
+
+#
+# Argument validating
+#
+
+# Helper functions (internal use)
+#
+
+def isclass(obj):
+    return hasattr(obj, '__bases__') or isinstance(obj, type)
+
+# Internal validator classes
+#
+
+class Validator(object):
+    _registered = []
+    def __init__(self, typ):
+        self.type = typ
+    def check(self, value):
+        return False
+    @staticmethod
+    def can_validate(typ):
+        return False
+    @classmethod
+    def register(cls, validator):
+        cls._registered.append(validator)
+    @classmethod
+    def get(cls, typ):
+        for validator in cls._registered:
+            if validator.can_validate(typ):
+                return validator(typ)
+        else:
+            return None
+    @staticmethod
+    def join_names(names):
+        if type(names) in (tuple, list):
+            if len(names) <= 2:
+                return ' or '.join(names)
+            else:
+                return ' or '.join((', '.join(names[:-1]), names[-1]))
+        else:
+            return names
+    def _type_names(self):
+        if isinstance(self.type, tuple):
+            return self.join_names([t.__name__.replace('NoneType', 'None') for t in self.type])
+        else:
+            return self.type.__name__.replace('NoneType', 'None')
+    @property
+    def name(self):
+        name = self._type_names()
+        if name.startswith('None'):
+            prefix = ''
+        elif name[0] in ('a', 'e', 'i', 'o', 'u'):
+            prefix = 'an '
+        else:
+            prefix = 'a '
+        return prefix + name
+
+class IgnoringValidator(Validator):
+    def __init__(self, typ):
+        self.type = none
+    def check(self, value):
+        return True
+    @staticmethod
+    def can_validate(obj):
+        return obj is ignore
+
+class TypeValidator(Validator):
+    def check(self, value):
+        return isinstance(value, self.type)
+    @staticmethod
+    def can_validate(obj):
+        return isclass(obj)
+
+class MultiTypeValidator(TypeValidator):
+    @staticmethod
+    def can_validate(obj):
+        return isinstance(obj, tuple) and not filter(lambda x: not isclass(x), obj)
+
+class OneOfValidator(Validator):
+    def __init__(self, typ):
+        self.type = typ.type
+    def check(self, value):
+        return value in self.type
+    @staticmethod
+    def can_validate(obj):
+        return isinstance(obj, one_of)
+    @property
+    def name(self):
+        return 'one of %s' % self.join_names(["`%r'" % e for e in self.type])
+
+class ListOfValidator(Validator):
+    def __init__(self, typ):
+        self.type = typ.type
+    def check(self, value):
+        return isinstance(value, (tuple, list)) and not filter(lambda x: not isinstance(x, self.type), value)
+    @staticmethod
+    def can_validate(obj):
+        return isinstance(obj, list_of)
+    @property
+    def name(self):
+        return 'a list of %s' % self._type_names()
+
+class ComplexValidator(Validator):
+    def __init__(self, typ):
+        self.type = [Validator.get(x) for x in typ]
+    def check(self, value):
+        return bool(sum(t.check(value) for t in self.type))
+    @staticmethod
+    def can_validate(obj):
+        return isinstance(obj, tuple) and not filter(lambda x: Validator.get(x) is None, obj)
+    @property
+    def name(self):
+        return self.join_names([x.name for x in self.type])
+
+Validator.register(IgnoringValidator)
+Validator.register(TypeValidator)
+Validator.register(MultiTypeValidator)
+Validator.register(OneOfValidator)
+Validator.register(ListOfValidator)
+Validator.register(ComplexValidator)
+
+
+# Extra types to be used with argument validating decorators
+#
+
+none = type(None)
+
+class one_of(object):
+    def __init__(self, *args):
+        if len(args) < 2:
+            raise ValueError("one_of must have at least 2 arguments")
+        self.type = args
+
+class list_of(object):
+    def __init__(self, *args):
+        if filter(lambda x: not isclass(x), args):
+            raise TypeError("list_of arguments must be types")
+        if len(args) == 1:
+            self.type = args[0]
+        else:
+            self.type = args
+
+ignore = type('ignore', (), {})()
+
+
+# Helpers for writing well behaved decorators
+#
+
+def decorator(func):
+    """A syntactic marker with no other effect than improving readability."""
+    return func
+
+def preserve_signature(func):
+    """Preserve the original function signature and attributes in decorator wrappers."""
+    from inspect import getargspec, formatargspec
+    from gnutls.constants import GNUTLSConstant
+    constants  = [c for c in (getargspec(func)[3] or []) if isinstance(c, GNUTLSConstant)]
+    signature  = formatargspec(*getargspec(func))[1:-1]
+    parameters = formatargspec(*getargspec(func), **{'formatvalue': lambda value: ""})[1:-1]
+    def fix_signature(wrapper):
+        if constants:
+            ## import the required GNUTLSConstants used as function default arguments
+            code = "from gnutls.constants import %s\n" % ', '.join(c.name for c in constants)
+            exec code in locals(), locals()
+        code = "def %s(%s): return wrapper(%s)\nnew_wrapper = %s\n" % (func.__name__, signature, parameters, func.__name__)
+        exec code in locals(), locals()
+        new_wrapper.__name__ = func.__name__
+        new_wrapper.__doc__ = func.__doc__
+        new_wrapper.__module__ = func.__module__
+        new_wrapper.__dict__.update(func.__dict__)
+        return new_wrapper
+    return fix_signature
+
+# Argument validating decorators
+#
+
+def _callable_args(*args, **kwargs):
+    """Internal function used by argument checking decorators"""
+    start = kwargs.get('_start', 0)
+    validators = []
+    for i, arg in enumerate(args):
+        validator = Validator.get(arg)
+        if validator is None:
+            raise TypeError("unsupported type `%r' at position %d for argument checking decorator" % (arg, i+1))
+        validators.append(validator)
+    def check_args_decorator(func):
+        @preserve_signature(func)
+        def check_args(*func_args):
+            pos = start
+            for validator in validators:
+                if not validator.check(func_args[pos]):
+                    raise TypeError("argument %d must be %s" % (pos+1-start, validator.name))
+                pos += 1
+            return func(*func_args)
+        return check_args
+    return check_args_decorator
+
+@decorator
+def method_args(*args):
+    """Check class or instance method arguments"""
+    return _callable_args(*args, **{'_start': 1})
+
+@decorator
+def function_args(*args):
+    """Check functions or staticmethod arguments"""
+    return _callable_args(*args)
+
diff --git a/gnutls-1.1.9/setup.py b/gnutls-1.1.9/setup.py
new file mode 100755
index 0000000..e12da4e
--- /dev/null
+++ b/gnutls-1.1.9/setup.py
@@ -0,0 +1,82 @@
+#!/usr/bin/env python
+
+from distutils.core import setup, Extension
+from gnutls import __version__
+import subprocess
+import sys
+import platform
+import os
+
+# Get the title and description from README
+import re
+readme = open('README').read()
+title, intro = re.findall(r'^\s*([^\n]+)\s+(.*)$', readme, re.DOTALL)[0]
+
+# Get GNUTLS library version and compile/link options
+def get_options():
+    GNUTLS_CONF = 'libgnutls-config'
+    GNUTLS_EXTRA_CONF = 'libgnutls-extra-config'
+    library_init = open('gnutls/library/__init__.py').read()
+    gnutls_version_req = [int(num) for num in re.findall(r"__need_version__ = '(\d)\.(\d)\.(\d)'", library_init)[0]]
+    try:
+        sub = subprocess.Popen([GNUTLS_CONF, '--version'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    except OSError:
+        # return some sane defaults if libgnutls-config is not available
+        return [], [], ['gcrypt', 'gnutls', 'gnutls-extra']
+    sub.wait()
+    gnutls_version = [int(num) for num in sub.stdout.read().strip().split(".")]
+    # check the returned version number against the required version in the debian/control file
+    if not gnutls_version >= gnutls_version_req:
+        print 'python-gnutls requires version %d.%d.%d of libgnutls (found %d.%d.%d).' % tuple(gnutls_version_req + gnutls_version)
+        sys.exit()
+    sub = subprocess.Popen([GNUTLS_CONF, '--libs', '--cflags'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    sub.wait()
+    gnutls_options = re.findall('-(.*?)[\n ]', sub.stdout.read())
+    sub = subprocess.Popen([GNUTLS_EXTRA_CONF, '--libs', '--cflags'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    sub.wait()
+    gnutls_extra_options = re.findall('-(.*?)[\n ]', sub.stdout.read())
+    # filter out the unique options from the output of both scripts
+    include_dirs = list(set(option[1:] for option in gnutls_options + gnutls_extra_options if option.startswith('I')))
+    library_dirs = list(set(option[1:] for option in gnutls_options + gnutls_extra_options if option.startswith('L')))
+    libraries = list(set(option[1:] for option in gnutls_options + gnutls_extra_options if option.startswith('l')))
+    # on OS-X, replace the library names in gnutls/library/functions.py and include the full path to it
+    if platform.system() == "Darwin":
+        functions_py = open('gnutls/library/functions.py').read()
+        if gnutls_options.index('lgnutls') > 0:
+            gnutls_dir = gnutls_options[gnutls_options.index('lgnutls') - 1]
+            if gnutls_dir.startswith('L'):
+                functions_py = re.sub(r"_libraries\['libgnutls.so.26'\] = CDLL\('.*?'\)", "_libraries['libgnutls.so.26'] = CDLL('%s')" % os.path.join(gnutls_dir[1:], 'libgnutls.26.dylib'), functions_py, 1)
+        if gnutls_extra_options.index('lgnutls-extra'):
+            gnutls_extra_dir = gnutls_extra_options[gnutls_extra_options.index('lgnutls-extra') - 1]
+            if gnutls_extra_dir.startswith('L'):
+                functions_py = re.sub(r"_libraries\['libgnutls-extra.so.26'\] = CDLL\('.*?'\)", "_libraries['libgnutls-extra.so.26'] = CDLL('%s')" % os.path.join(gnutls_extra_dir[1:], 'libgnutls-extra.26.dylib'), functions_py, 1)
+        open('gnutls/library/functions.py', 'w').write(functions_py)
+    return include_dirs, library_dirs, libraries
+
+include_dirs, library_dirs, libraries = get_options()
+
+setup(name         = "python-gnutls",
+      version      = __version__,
+      author       = "Dan Pascu",
+      author_email = "dan@ag-projects.com",
+      url          = "http://ag-projects.com/",
+      download_url = "http://cheeseshop.python.org/pypi/python-gnutls/%s" % __version__,
+      description  = title,
+      long_description = intro,
+      license      = "LGPL",
+      platforms    = ["Platform Independent"],
+      classifiers  = [
+        "Development Status :: 5 - Production/Stable",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python",
+        "Topic :: Software Development :: Libraries :: Python Modules"
+      ],
+      packages     = ['gnutls', 'gnutls.interfaces', 'gnutls.interfaces.twisted', 'gnutls.library'],
+      ext_modules  = [Extension(name='gnutls.library._gnutls_init',
+                          sources=['gnutls/library/_gnutls_init.c'],
+                          include_dirs=include_dirs,
+                          library_dirs=library_dirs,
+                          libraries=libraries)])
+
diff --git a/python-gnutls_1.1.9-1.debian.tar.gz b/python-gnutls_1.1.9-1.debian.tar.gz
new file mode 100644
index 0000000..9ceb63f
--- /dev/null
+++ b/python-gnutls_1.1.9-1.debian.tar.gz
diff --git a/python-gnutls_1.1.9-1.dsc b/python-gnutls_1.1.9-1.dsc
new file mode 100644
index 0000000..2918d84
--- /dev/null
+++ b/python-gnutls_1.1.9-1.dsc
@@ -0,0 +1,40 @@
+-----BEGIN PGP SIGNED MESSAGE-----
+Hash: SHA1
+
+Format: 3.0 (quilt)
+Source: python-gnutls
+Binary: python-gnutls
+Architecture: any
+Version: 1.1.9-1
+Maintainer: Kristina Clair <kclair@leap.se>
+Homepage: http://pypi.python.org/pypi/python-gnutls/1.1.9
+Standards-Version: 3.8.4
+Build-Depends: cdbs (>= 0.4.47), debhelper (>= 5.0.42), python-all-dev (>= 2.5), python-support, libgnutls-dev (>= 2.4.1)
+Checksums-Sha1: 
+ 322517dc986ed63d36d3e03b4f07b7e6e6a41686 47233 python-gnutls_1.1.9.orig.tar.gz
+ 1f4eaa1985e7a91a44e4078abb7a8a8113503fed 11144 python-gnutls_1.1.9-1.debian.tar.gz
+Checksums-Sha256: 
+ 98a56396ff7a31028ca9f5ec45d4245531836e99cd5797a92c21ac39ed74317c 47233 python-gnutls_1.1.9.orig.tar.gz
+ af122684fcd29cecf01e7e163db73ea23f10f3be4a1e78a2c60c3fc66ccd25d9 11144 python-gnutls_1.1.9-1.debian.tar.gz
+Files: 
+ bdd81a9dd3c2f87393cd6c014bf6885b 47233 python-gnutls_1.1.9.orig.tar.gz
+ 09eb446cd4c4b3565759d3911309f456 11144 python-gnutls_1.1.9-1.debian.tar.gz
+
+-----BEGIN PGP SIGNATURE-----
+Version: GnuPG v1.4.10 (GNU/Linux)
+Comment: GPGTools - http://gpgtools.org
+
+iQIcBAEBAgAGBQJQbIRZAAoJEJ6m/xxX04TjaKMQAKCYg5yBIXTQWyZKtE74o/48
+OT+NXezNQ03YogedAxnsG/+Vyq9RFnVfyCLEo6I94vk2MTlbhn0vtzhx1lijKRX5
+GpcnEDxwV0lrJvtVlDgU8OSml4TfTbStIcwidV36dfyrOrcP8tf8ARkD7xeWbGv5
+fZrwhebkLjBhL3wcfn9xQvQ4BKnXfsWJxL4KdYeV2M4GGhOHQH/LmKXaMFlX/z3i
+lPnXXDogjlnJwubh1Sro35IKtfHuNJ8PwImInz5rCPGUHcoy/c/3hYUig2RN0C59
+ego72qNFpecFbgyjBu6Cysa1GAnUmdZfkxpGY6bSHfdbr4yOHV+OHsrql0mjWZbE
+KP+Idn70bHP9x6sWbMs5s4ZwbO+EclqsqW6KaXUmUUoUpsjzH9KS5HTtt7Ev82W3
+s9RH4VFNntFXMaLi2BP8MpsgtDPY+xsSkGxmaYWdn3EeleSlYqDn6hJFYFQePuql
+AQDItFMn7mes9pZb+8k+Dx+0jKuiKrwYYn0gp+igZrjcXkkM5kga0HaLt0Bx1VdY
+Ykbev644zq0nv5NQt32mudFGQBslu/XaG3Yty//+MUfehZlLQZHG3E4hvBdA/Ky+
+r4HxkUfirjvFzELgeu2uMc1UOSv467sPZo2LCEoOm/AMQvpIYgLVCA05KXYI5MfQ
+CJY6qo7ngpryXKt7vBR5
+=48q3
+-----END PGP SIGNATURE-----
diff --git a/python-gnutls_1.1.9-1_amd64.build b/python-gnutls_1.1.9-1_amd64.build
new file mode 100644
index 0000000..ebc52da
--- /dev/null
+++ b/python-gnutls_1.1.9-1_amd64.build
@@ -0,0 +1,250 @@
+ dpkg-buildpackage -rfakeroot -D -us -uc
+dpkg-buildpackage: export CFLAGS from dpkg-buildflags (origin: vendor): -g -O2
+dpkg-buildpackage: export CPPFLAGS from dpkg-buildflags (origin: vendor): 
+dpkg-buildpackage: export CXXFLAGS from dpkg-buildflags (origin: vendor): -g -O2
+dpkg-buildpackage: export FFLAGS from dpkg-buildflags (origin: vendor): -g -O2
+dpkg-buildpackage: export LDFLAGS from dpkg-buildflags (origin: vendor): 
+dpkg-buildpackage: source package python-gnutls
+dpkg-buildpackage: source version 1.1.9-1
+dpkg-buildpackage: source changed by Kristina Clair <kclair@leap.se>
+ dpkg-source --before-build gnutls-1.1.9
+dpkg-buildpackage: host architecture amd64
+ fakeroot debian/rules clean
+pyversions: missing X(S)-Python-Version in control file, fall back to debian/pyversions
+pyversions: missing debian/pyversions file, fall back to supported versions
+test -x debian/rules
+dh_testroot
+dh_clean 
+for buildver in 2.5 2.6; do \
+		cd /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9 && cd . && python$buildver setup.py clean -a; \
+	done
+running clean
+'build/lib.linux-x86_64-2.5' does not exist -- can't clean it
+'build/bdist.linux-x86_64' does not exist -- can't clean it
+'build/scripts-2.5' does not exist -- can't clean it
+running clean
+'build/lib.linux-x86_64-2.6' does not exist -- can't clean it
+'build/bdist.linux-x86_64' does not exist -- can't clean it
+'build/scripts-2.6' does not exist -- can't clean it
+rm -rf debian/python-module-stampdir
+find . -name '*.pyc' -exec rm '{}' ';'
+find . -prune -name '*.egg-info' -exec rm -rf '{}' ';'
+ dpkg-source -b gnutls-1.1.9
+dpkg-source: info: using source format `3.0 (quilt)'
+dpkg-source: info: building python-gnutls using existing ./python-gnutls_1.1.9.orig.tar.gz
+dpkg-source: info: building python-gnutls in python-gnutls_1.1.9-1.debian.tar.gz
+dpkg-source: info: building python-gnutls in python-gnutls_1.1.9-1.dsc
+ debian/rules build
+pyversions: missing X(S)-Python-Version in control file, fall back to debian/pyversions
+pyversions: missing debian/pyversions file, fall back to supported versions
+test -x debian/rules
+mkdir -p "."
+/usr/share/cdbs/1/rules/buildcore.mk:104: WARNING:  DEB_COMPRESS_EXCLUDE is a deprecated variable
+mkdir -p debian/python-module-stampdir
+set -e; for buildver in 2.5 2.6; do \
+		cd /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9 && cd . && python$buildver setup.py build --build-base="/home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build"; \
+	done
+running build
+running build_py
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/build
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/build/lib.linux-x86_64-2.5
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls
+copying gnutls/crypto.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.5/gnutls
+copying gnutls/validators.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.5/gnutls
+copying gnutls/__init__.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.5/gnutls
+copying gnutls/connection.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.5/gnutls
+copying gnutls/constants.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.5/gnutls
+copying gnutls/errors.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.5/gnutls
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/interfaces
+copying gnutls/interfaces/__init__.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.5/gnutls/interfaces
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/interfaces/twisted
+copying gnutls/interfaces/twisted/__init__.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.5/gnutls/interfaces/twisted
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/build/lib.linux-x86_64-2.5/gnutls/library
+copying gnutls/library/types.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.5/gnutls/library
+copying gnutls/library/__init__.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.5/gnutls/library
+copying gnutls/library/functions.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.5/gnutls/library
+copying gnutls/library/constants.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.5/gnutls/library
+copying gnutls/library/errors.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.5/gnutls/library
+running build_ext
+building 'gnutls.library._gnutls_init' extension
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/build/temp.linux-x86_64-2.5
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/build/temp.linux-x86_64-2.5/gnutls
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/build/temp.linux-x86_64-2.5/gnutls/library
+gcc -pthread -fno-strict-aliasing -DNDEBUG -g -fwrapv -O2 -Wall -Wstrict-prototypes -g -O2 -g -Wall -O2 -fPIC -I/usr/include/python2.5 -c gnutls/library/_gnutls_init.c -o /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/temp.linux-x86_64-2.5/gnutls/library/_gnutls_init.o
+gcc -pthread -shared -Wl,-O1 -Wl,-Bsymbolic-functions -g -O2 -g -Wall -O2 /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/temp.linux-x86_64-2.5/gnutls/library/_gnutls_init.o -lgcrypt -lgnutls -lgnutls-extra -o /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.5/gnutls/library/_gnutls_init.so
+running build
+running build_py
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/build/lib.linux-x86_64-2.6
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls
+copying gnutls/crypto.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.6/gnutls
+copying gnutls/validators.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.6/gnutls
+copying gnutls/__init__.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.6/gnutls
+copying gnutls/connection.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.6/gnutls
+copying gnutls/constants.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.6/gnutls
+copying gnutls/errors.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.6/gnutls
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/interfaces
+copying gnutls/interfaces/__init__.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.6/gnutls/interfaces
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/interfaces/twisted
+copying gnutls/interfaces/twisted/__init__.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.6/gnutls/interfaces/twisted
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/build/lib.linux-x86_64-2.6/gnutls/library
+copying gnutls/library/types.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.6/gnutls/library
+copying gnutls/library/__init__.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.6/gnutls/library
+copying gnutls/library/functions.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.6/gnutls/library
+copying gnutls/library/constants.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.6/gnutls/library
+copying gnutls/library/errors.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.6/gnutls/library
+running build_ext
+building 'gnutls.library._gnutls_init' extension
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/build/temp.linux-x86_64-2.6
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/build/temp.linux-x86_64-2.6/gnutls
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/build/temp.linux-x86_64-2.6/gnutls/library
+gcc -pthread -fno-strict-aliasing -DNDEBUG -g -fwrapv -O2 -Wall -Wstrict-prototypes -g -O2 -g -Wall -O2 -fPIC -I/usr/include/python2.6 -c gnutls/library/_gnutls_init.c -o /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/temp.linux-x86_64-2.6/gnutls/library/_gnutls_init.o
+gcc -pthread -shared -Wl,-O1 -Wl,-Bsymbolic-functions -g -O2 -g -Wall -O2 /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/temp.linux-x86_64-2.6/gnutls/library/_gnutls_init.o -lgcrypt -lgnutls -lgnutls-extra -o /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build/lib.linux-x86_64-2.6/gnutls/library/_gnutls_init.so
+touch debian/python-module-stampdir/python-gnutls
+ fakeroot debian/rules binary
+pyversions: missing X(S)-Python-Version in control file, fall back to debian/pyversions
+pyversions: missing debian/pyversions file, fall back to supported versions
+test -x debian/rules
+dh_testroot
+dh_prep 
+dh_installdirs -A 
+mkdir -p "."
+/usr/share/cdbs/1/rules/buildcore.mk:104: WARNING:  DEB_COMPRESS_EXCLUDE is a deprecated variable
+mkdir -p debian/python-module-stampdir
+set -e; for buildver in 2.5 2.6; do \
+		cd /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9 && cd . && python$buildver setup.py build --build-base="/home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/./build"; \
+	done
+running build
+running build_py
+running build_ext
+running build
+running build_py
+running build_ext
+touch debian/python-module-stampdir/python-gnutls
+Adding cdbs dependencies to debian/python-gnutls.substvars
+dh_installdirs -ppython-gnutls 
+set -e; for buildver in 2.5 2.6; do \
+		cd /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9 && cd . && python$buildver setup.py install \
+		--root=/home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/ --install-purelib=/usr/lib/python$buildver/site-packages/ \
+		--install-platlib=/usr/lib/python$buildver/site-packages/ --prefix=/usr --no-compile -O0; \
+	done
+running install
+running build
+running build_py
+running build_ext
+running install_lib
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.5
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.5/site-packages
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.5/site-packages/gnutls
+copying build/lib.linux-x86_64-2.5/gnutls/crypto.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.5/site-packages/gnutls
+copying build/lib.linux-x86_64-2.5/gnutls/validators.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.5/site-packages/gnutls
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.5/site-packages/gnutls/library
+copying build/lib.linux-x86_64-2.5/gnutls/library/types.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.5/site-packages/gnutls/library
+copying build/lib.linux-x86_64-2.5/gnutls/library/__init__.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.5/site-packages/gnutls/library
+copying build/lib.linux-x86_64-2.5/gnutls/library/_gnutls_init.so -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.5/site-packages/gnutls/library
+copying build/lib.linux-x86_64-2.5/gnutls/library/functions.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.5/site-packages/gnutls/library
+copying build/lib.linux-x86_64-2.5/gnutls/library/constants.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.5/site-packages/gnutls/library
+copying build/lib.linux-x86_64-2.5/gnutls/library/errors.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.5/site-packages/gnutls/library
+copying build/lib.linux-x86_64-2.5/gnutls/__init__.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.5/site-packages/gnutls
+copying build/lib.linux-x86_64-2.5/gnutls/connection.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.5/site-packages/gnutls
+copying build/lib.linux-x86_64-2.5/gnutls/constants.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.5/site-packages/gnutls
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.5/site-packages/gnutls/interfaces
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.5/site-packages/gnutls/interfaces/twisted
+copying build/lib.linux-x86_64-2.5/gnutls/interfaces/twisted/__init__.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.5/site-packages/gnutls/interfaces/twisted
+copying build/lib.linux-x86_64-2.5/gnutls/interfaces/__init__.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.5/site-packages/gnutls/interfaces
+copying build/lib.linux-x86_64-2.5/gnutls/errors.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.5/site-packages/gnutls
+running install_egg_info
+Writing /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.5/site-packages/python_gnutls-1.1.9.egg-info
+running install
+running build
+running build_py
+running build_ext
+running install_lib
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.6
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.6/site-packages
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.6/site-packages/gnutls
+copying build/lib.linux-x86_64-2.6/gnutls/crypto.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.6/site-packages/gnutls
+copying build/lib.linux-x86_64-2.6/gnutls/validators.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.6/site-packages/gnutls
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.6/site-packages/gnutls/library
+copying build/lib.linux-x86_64-2.6/gnutls/library/types.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.6/site-packages/gnutls/library
+copying build/lib.linux-x86_64-2.6/gnutls/library/__init__.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.6/site-packages/gnutls/library
+copying build/lib.linux-x86_64-2.6/gnutls/library/_gnutls_init.so -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.6/site-packages/gnutls/library
+copying build/lib.linux-x86_64-2.6/gnutls/library/functions.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.6/site-packages/gnutls/library
+copying build/lib.linux-x86_64-2.6/gnutls/library/constants.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.6/site-packages/gnutls/library
+copying build/lib.linux-x86_64-2.6/gnutls/library/errors.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.6/site-packages/gnutls/library
+copying build/lib.linux-x86_64-2.6/gnutls/__init__.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.6/site-packages/gnutls
+copying build/lib.linux-x86_64-2.6/gnutls/connection.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.6/site-packages/gnutls
+copying build/lib.linux-x86_64-2.6/gnutls/constants.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.6/site-packages/gnutls
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.6/site-packages/gnutls/interfaces
+creating /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.6/site-packages/gnutls/interfaces/twisted
+copying build/lib.linux-x86_64-2.6/gnutls/interfaces/twisted/__init__.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.6/site-packages/gnutls/interfaces/twisted
+copying build/lib.linux-x86_64-2.6/gnutls/interfaces/__init__.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.6/site-packages/gnutls/interfaces
+copying build/lib.linux-x86_64-2.6/gnutls/errors.py -> /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.6/site-packages/gnutls
+running install_egg_info
+Writing /home/kclair/dev/leap/build-deb/deps/python-gnutls/gnutls-1.1.9/debian/python-gnutls/usr/lib/python2.6/site-packages/python_gnutls-1.1.9-py2.6.egg-info
+dh_installdocs -ppython-gnutls ./README 
+dh_installexamples -ppython-gnutls 
+dh_installman -ppython-gnutls  
+dh_installinfo -ppython-gnutls  
+dh_installmenu -ppython-gnutls 
+dh_installcron -ppython-gnutls 
+dh_installinit -ppython-gnutls  
+dh_installdebconf -ppython-gnutls 
+dh_installemacsen -ppython-gnutls   
+dh_installcatalogs -ppython-gnutls 
+dh_installpam -ppython-gnutls 
+dh_installlogrotate -ppython-gnutls 
+dh_installlogcheck -ppython-gnutls 
+dh_installchangelogs -ppython-gnutls  ./ChangeLog 
+dh_installudev -ppython-gnutls 
+dh_lintian -ppython-gnutls 
+dh_install -ppython-gnutls  
+dh_link -ppython-gnutls  
+dh_installmime -ppython-gnutls 
+dh_pysupport -ppython-gnutls  
+dh_strip -ppython-gnutls  
+dh_compress -ppython-gnutls -X .py 
+dh_fixperms -ppython-gnutls  
+dh_makeshlibs -ppython-gnutls  
+dh_installdeb -ppython-gnutls 
+dh_perl -ppython-gnutls 
+dh_shlibdeps -ppython-gnutls    
+dh_gencontrol -ppython-gnutls  
+dpkg-gencontrol: warning: package python-gnutls: unused substitution variable ${python:Versions}
+dh_md5sums -ppython-gnutls 
+dh_builddeb -ppython-gnutls 
+dpkg-deb: building package `python-gnutls' in `../python-gnutls_1.1.9-1_amd64.deb'.
+ dpkg-genchanges  >../python-gnutls_1.1.9-1_amd64.changes
+dpkg-genchanges: including full source code in upload
+ dpkg-source --after-build gnutls-1.1.9
+dpkg-buildpackage: full upload (original source is included)
+Now running lintian...
+W: python-gnutls source: dh-make-template-in-source debian/emacsen-startup.ex
+W: python-gnutls source: dh-make-template-in-source debian/init.d.ex
+W: python-gnutls source: dh-make-template-in-source debian/manpage.1.ex
+W: python-gnutls source: dh-make-template-in-source debian/postinst.ex
+W: python-gnutls source: dh-make-template-in-source debian/python-gnutls.default.ex
+W: python-gnutls source: dh-make-template-in-source debian/python-gnutls.cron.d.ex
+W: python-gnutls source: dh-make-template-in-source debian/menu.ex
+W: python-gnutls source: dh-make-template-in-source debian/watch.ex
+W: python-gnutls source: dh-make-template-in-source debian/manpage.sgml.ex
+W: python-gnutls source: package-lacks-versioned-build-depends-on-debhelper 7
+W: python-gnutls source: dh-make-template-in-source debian/emacsen-install.ex
+W: python-gnutls source: dh-make-template-in-source debian/emacsen-remove.ex
+W: python-gnutls source: dh-make-template-in-source debian/manpage.xml.ex
+W: python-gnutls source: dh-make-template-in-source debian/python-gnutls.doc-base.EX
+W: python-gnutls source: dh-make-template-in-source debian/postrm.ex
+W: python-gnutls source: dh-make-template-in-source debian/preinst.ex
+W: python-gnutls source: dh-make-template-in-source debian/prerm.ex
+W: python-gnutls source: ancient-standards-version 3.8.4 (current is 3.9.1)
+W: python-gnutls: readme-debian-contains-debmake-template
+W: python-gnutls: new-package-should-close-itp-bug
+W: python-gnutls: wrong-bug-number-in-closes l3:#nnnn
+Finished running lintian.
+Now signing changes and any dsc files...
+ signfile python-gnutls_1.1.9-1.dsc Kristina Clair <kclair@leap.se>
+
+ signfile python-gnutls_1.1.9-1_amd64.changes Kristina Clair <kclair@leap.se>
+
+Successfully signed dsc and changes files
diff --git a/python-gnutls_1.1.9-1_amd64.changes b/python-gnutls_1.1.9-1_amd64.changes
new file mode 100644
index 0000000..a60fc70
--- /dev/null
+++ b/python-gnutls_1.1.9-1_amd64.changes
@@ -0,0 +1,53 @@
+-----BEGIN PGP SIGNED MESSAGE-----
+Hash: SHA1
+
+Format: 1.8
+Date: Wed, 03 Oct 2012 11:29:13 -0700
+Source: python-gnutls
+Binary: python-gnutls
+Architecture: source amd64
+Version: 1.1.9-1
+Distribution: unstable
+Urgency: low
+Maintainer: Kristina Clair <kclair@leap.se>
+Changed-By: Kristina Clair <kclair@leap.se>
+Description: 
+ python-gnutls - Python wrapper for the GNUTLS library
+Changes: 
+ python-gnutls (1.1.9-1) unstable; urgency=low
+ .
+   * Initial release (Closes: #nnnn)  <nnnn is the bug number of your ITP>
+Checksums-Sha1: 
+ be198ee4c876a621c1b37377cffacb425dab47db 1840 python-gnutls_1.1.9-1.dsc
+ 322517dc986ed63d36d3e03b4f07b7e6e6a41686 47233 python-gnutls_1.1.9.orig.tar.gz
+ 1f4eaa1985e7a91a44e4078abb7a8a8113503fed 11144 python-gnutls_1.1.9-1.debian.tar.gz
+ aba69b45f37fb1dfdc8abeedb936f9837917782f 41840 python-gnutls_1.1.9-1_amd64.deb
+Checksums-Sha256: 
+ 5c9327147069024fa19943cb4371b29311d76db89ce7b0c1c5f89a2ca9b7b50d 1840 python-gnutls_1.1.9-1.dsc
+ 98a56396ff7a31028ca9f5ec45d4245531836e99cd5797a92c21ac39ed74317c 47233 python-gnutls_1.1.9.orig.tar.gz
+ af122684fcd29cecf01e7e163db73ea23f10f3be4a1e78a2c60c3fc66ccd25d9 11144 python-gnutls_1.1.9-1.debian.tar.gz
+ 79b9ad64ec1b544d2ef020f7927a93013d74a8b110cf1c15ef0bd4d6859205bc 41840 python-gnutls_1.1.9-1_amd64.deb
+Files: 
+ 28ec58848da3a608eea3cbc1e868e4a8 1840 python optional python-gnutls_1.1.9-1.dsc
+ bdd81a9dd3c2f87393cd6c014bf6885b 47233 python optional python-gnutls_1.1.9.orig.tar.gz
+ 09eb446cd4c4b3565759d3911309f456 11144 python optional python-gnutls_1.1.9-1.debian.tar.gz
+ bad4f6c81f0452cd028bd5f9d18e07f0 41840 python optional python-gnutls_1.1.9-1_amd64.deb
+
+-----BEGIN PGP SIGNATURE-----
+Version: GnuPG v1.4.10 (GNU/Linux)
+Comment: GPGTools - http://gpgtools.org
+
+iQIcBAEBAgAGBQJQbIRfAAoJEJ6m/xxX04TjWtgQAIMBHSqb1xQoNan4pxLEwjJT
+1WKSqSeybPp6vBLtLFMMhrlZzDNSonIyPeXbOQSb9xDqodHCuo4n8SxPRbzkkI9V
+OzVhMMnA/Zjjb+lt/rSnjdq7um4e8QUqB14tB0HrKkt5pjLiR8T3UlBBgkd0/OrQ
+9F7zYbXSZEl4GUq9VYzLy5yP2/1AcIHLkY30SXcSol6SX9pPZakSkJ1Qgaj8X2cK
++1sPk2TwUtBtd3BpB2Xyvk7T0ZhtZPAomeldcq5dkf3P+d3+14YKB+M9Ewu/Kd3v
+E1XBPfbIpGDVxbvypbFho5nullZyIIRHAcULon8mmdHWBQAqsOzjZzRTn1yg3wr3
+Af3OUTHdEk4VOE9LNEje1eYy2Syw1T0x16gx72QmuVHvJ/yjtCVrV8G+RtNUrZ4Q
+OI8Y3uNFZyqCpZkQMsNCX2zScXZUIPigz3EB0MgjEWEDSdduMohoSEkOQ/LA0lEQ
+uZaz6Nc35GuHj30MZB6Fa4Lvi2mnZRTphHY/+7tdroe/Uiebie+zq83j+kgNHOCf
+KdXrV1nTHkMkqEGdce10f8mmWHnghwSgiMH4bS/QEajE7p/t0b6Nkfdmd4gdGvrz
+ZvqmszyFbGKezrQ4cfP7BLbApqJP18xDZLnnZIFTGq07KGqcYTr/yis6ITOgreX+
+8jat/8FJypJ1XsM8kKno
+=BOSG
+-----END PGP SIGNATURE-----
diff --git a/python-gnutls_1.1.9-1_amd64.deb b/python-gnutls_1.1.9-1_amd64.deb
new file mode 100644
index 0000000..5c09883
--- /dev/null
+++ b/python-gnutls_1.1.9-1_amd64.deb
diff --git a/python-gnutls_1.1.9.orig.tar.gz b/python-gnutls_1.1.9.orig.tar.gz
new file mode 100644
index 0000000..2afcb86
--- /dev/null
+++ b/python-gnutls_1.1.9.orig.tar.gz
diff --git a/python-gnutls_1.2.0-2.diff.gz b/python-gnutls_1.2.0-2.diff.gz
new file mode 100644
index 0000000..e985ca2
--- /dev/null
+++ b/python-gnutls_1.2.0-2.diff.gz