Added the '_t' suffix to all exported symbols.

163 files changed, 3137 insertions, 3141 deletions

diff --git a/NEWS b/NEWS
index 9e6df4e707..450b2c2372 100644
--- a/NEWS
+++ b/NEWS
@@ -1,3 +1,6 @@
+Version 1.1.11
+- Added the '_t' suffix to all exported symbols.
+
 Version 1.1.10 (12/06/2004)
 - Added gnutls_sign_algorithm_get_name() and gnutls_pk_algorithm_get_name()
 - Corrected bug in TLS renegotiation.
diff --git a/configure.in b/configure.in
index 7553beb568..810e74b13b 100644
--- a/configure.in
+++ b/configure.in
@@ -12,7 +12,7 @@ AC_DEFINE_UNQUOTED(T_OS, "$target_os", [OS name])
 dnl Gnutls Version
 GNUTLS_MAJOR_VERSION=1
 GNUTLS_MINOR_VERSION=1
-GNUTLS_MICRO_VERSION=10
+GNUTLS_MICRO_VERSION=11
 GNUTLS_VERSION=$GNUTLS_MAJOR_VERSION.$GNUTLS_MINOR_VERSION.$GNUTLS_MICRO_VERSION
 
 AC_DEFINE_UNQUOTED(GNUTLS_VERSION, "$GNUTLS_VERSION", [version of gnutls])
diff --git a/doc/TODO b/doc/TODO
index c11db3a340..9916fa1efd 100644
--- a/doc/TODO
+++ b/doc/TODO
@@ -3,6 +3,7 @@ anything), contact the developer's mailing list (gnutls-dev@lists.gnupg.org),
 in order to avoid having people working on the same thing. 
 
 Current list:
+* Do not store the Anon/DHE parameters in the resume DB.
 * Make the current ciphering code a bit more abstract to
   allow easy integration with TLS hardware.
 * Allow adding multiple subject alternative names.
diff --git a/doc/tex/auth.tex b/doc/tex/auth.tex
index 7e925ed62c..5dddd552ed 100644
--- a/doc/tex/auth.tex
+++ b/doc/tex/auth.tex
@@ -118,7 +118,7 @@ gnutls_dh_params dh_params;
  * or RSA parameters. The parameters returned (if any) will
  * be used for the first handshake only.
  */
-static int get_params( gnutls_session session, gnutls_params_type type,
+static int get_params( gnutls_session session, gnutls_params_type_t type,
         gnutls_params_st *st)
 {
    if (type == GNUTLS_PARAMS_RSA_EXPORT)
@@ -137,7 +137,7 @@ static int get_params( gnutls_session session, gnutls_params_type type,
 
 int main()
 {
-   gnutls_certificate_credentials cert_cred;
+   gnutls_certificate_credentials_t cert_cred;
 
    initialize_params();
 
diff --git a/doc/tex/certificate.tex b/doc/tex/certificate.tex
index 5c05233055..b3ecfc8d2c 100644
--- a/doc/tex/certificate.tex
+++ b/doc/tex/certificate.tex
@@ -105,8 +105,8 @@ CRL distribution points & 2.5.29.31 & This extension is set by the CA, in order
 \\
 \par
 In \gnutls{} the X.509 certificate structures are handled using the
-\emph{gnutls\_x509\_crt} type and the corresponding private keys with
-the \emph{gnutls\_x509\_privkey} type.
+\emph{gnutls\_x509\_crt\_t} type and the corresponding private keys with
+the \emph{gnutls\_x509\_privkey\_t} type.
 All the available functions for X.509 certificate handling have their 
 prototypes in \emph{gnutls/x509.h}. An example program to demonstrate the 
 X.509 parsing capabilities can be found at section \ref{ex:x509-info} on 
@@ -159,7 +159,7 @@ defined in PKCS \#10 \cite{RFC2986}. Other certificate request's format such as
 PKIX's RFC2511 \cite{RFC2511} are not currently supported.
 
 In \gnutls{} the PKCS \#10 structures are handled using the
-\emph{gnutls\_x509\_crq} type. 
+\emph{gnutls\_x509\_crq\_t} type. 
 An example of a certificate request generation can be found at section \ref{ex:crq}
 on page \pageref{ex:crq}.
 
@@ -169,8 +169,8 @@ certificates. It is commonly used in browsers to export and import
 the user's identities.
 \par
 In \gnutls{} the PKCS \#12 structures are handled using the
-\emph{gnutls\_pkcs12} type. This is an abstract type that
-may hold several \emph{gnutls\_pkcs12\_bag} types. The Bag types are the
+\emph{gnutls\_pkcs12\_t} type. This is an abstract type that
+may hold several \emph{gnutls\_pkcs12\_bag\_t} types. The Bag types are the
 holders of the actual data, which may be certificates, private
 keys or encrypted data. An Bag of type encrypted should be decrypted
 in order for its data to be accessed. 
@@ -211,8 +211,8 @@ actual owner.
 
 \subsection*{OpenPGP keys}
 In \gnutls{} the OpenPGP key structures \cite{RFC2440} are handled using the
-\emph{gnutls\_openpgp\_key} type and the corresponding private keys with
-the \emph{gnutls\_openpgp\_privkey} type. All the prototypes for the key handling
+\emph{gnutls\_openpgp\_key\_t} type and the corresponding private keys with
+the \emph{gnutls\_openpgp\_privkey\_t} type. All the prototypes for the key handling
 functions can be found at \emph{gnutls/openpgp.h}.
 
 \subsection*{Verifying an OpenPGP key}
diff --git a/doc/tex/ex-alert.tex b/doc/tex/ex-alert.tex
index b5cd0f9cfb..464a652f66 100644
--- a/doc/tex/ex-alert.tex
+++ b/doc/tex/ex-alert.tex
@@ -8,7 +8,7 @@
  * a gnutls function (recv/send), is an alert, and will print
  * that alert.
  */
-void check_alert(gnutls_session session, int ret)
+void check_alert(gnutls_session_t session, int ret)
 {
    int last_alert;
 
diff --git a/doc/tex/ex-cert-select.tex b/doc/tex/ex-cert-select.tex
index 35b829c524..999320cc30 100644
--- a/doc/tex/ex-cert-select.tex
+++ b/doc/tex/ex-cert-select.tex
@@ -24,21 +24,21 @@
 #define KEY_FILE "key.pem"
 #define CAFILE "ca.pem"
 
-static int cert_callback(gnutls_session session,
-                  const gnutls_datum* req_ca_rdn, int nreqs,
-                  const gnutls_pk_algorithm* sign_algos, int sign_algos_length,
+static int cert_callback(gnutls_session_t session,
+                  const gnutls_datum_t* req_ca_rdn, int nreqs,
+                  const gnutls_pk_algorithm_t* sign_algos, int sign_algos_length,
                   gnutls_retr_st * st);
 
-gnutls_x509_crt crt;
-gnutls_x509_privkey key;
+gnutls_x509_crt_t crt;
+gnutls_x509_privkey_t key;
 
 /* Helper functions to load a certificate and key
  * files into memory. They use mmap for simplicity.
  */
-static gnutls_datum mmap_file( const char* file)
+static gnutls_datum_t mmap_file( const char* file)
 {
 int fd;
-gnutls_datum mmaped_file = { NULL, 0 };
+gnutls_datum_t mmaped_file = { NULL, 0 };
 struct stat stat_st;
 void* ptr;
 
@@ -56,7 +56,7 @@ void* ptr;
    return mmaped_file;
 }
 
-static void munmap_file( gnutls_datum data)
+static void munmap_file( gnutls_datum_t data)
 {
    munmap( data.data, data.size);
 }
@@ -66,7 +66,7 @@ static void munmap_file( gnutls_datum data)
 static void load_keys( void)
 {
 int ret;
-gnutls_datum data;
+gnutls_datum_t data;
 
    data = mmap_file( CERT_FILE);
    if (data.data == NULL) {
@@ -104,9 +104,9 @@ gnutls_datum data;
 int main()
 {
    int ret, sd, ii;
-   gnutls_session session;
+   gnutls_session_t session;
    char buffer[MAX_BUF + 1];
-   gnutls_certificate_credentials xcred;
+   gnutls_certificate_credentials_t xcred;
    /* Allow connections to servers that have OpenPGP keys as well.
     */
 
@@ -138,7 +138,7 @@ int main()
     */
    sd = tcp_connect();
 
-   gnutls_transport_set_ptr( session, (gnutls_transport_ptr)sd);
+   gnutls_transport_set_ptr( session, (gnutls_transport_ptr_t)sd);
 
    /* Perform the TLS handshake
     */
@@ -191,15 +191,15 @@ int main()
  * before a handshake.
  */
 
-static int cert_callback(gnutls_session session,
-                  const gnutls_datum* req_ca_rdn, int nreqs,
-                  const gnutls_pk_algorithm* sign_algos, int sign_algos_length,
+static int cert_callback(gnutls_session_t session,
+                  const gnutls_datum_t* req_ca_rdn, int nreqs,
+                  const gnutls_pk_algorithm_t* sign_algos, int sign_algos_length,
                   gnutls_retr_st * st)
 {
    char issuer_dn[256];
    int i, ret;
    size_t len;
-   gnutls_certificate_type type;
+   gnutls_certificate_type_t type;
 
    /* Print the server's trusted CAs
     */
diff --git a/doc/tex/ex-client-resume.tex b/doc/tex/ex-client-resume.tex
index f3eb4b2b91..26c403b5b8 100644
--- a/doc/tex/ex-client-resume.tex
+++ b/doc/tex/ex-client-resume.tex
@@ -6,7 +6,7 @@
 
 /* Those functions are defined in other examples.
  */
-extern void check_alert(gnutls_session session, int ret);
+extern void check_alert(gnutls_session_t session, int ret);
 extern int tcp_connect( void);
 extern void tcp_close( int sd);
 
@@ -20,9 +20,9 @@ int main()
 {
    int ret;
    int sd, ii, alert;
-   gnutls_session session;
+   gnutls_session_t session;
    char buffer[MAX_BUF + 1];
-   gnutls_certificate_credentials xcred;
+   gnutls_certificate_credentials_t xcred;
 
    /* variables used in session resuming 
     */
@@ -52,7 +52,7 @@ int main()
          free(session_data);
       }
       
-      gnutls_transport_set_ptr( session, (gnutls_transport_ptr)sd);
+      gnutls_transport_set_ptr( session, (gnutls_transport_ptr_t)sd);
 
       /* Perform the TLS handshake
        */
diff --git a/doc/tex/ex-client-srp.tex b/doc/tex/ex-client-srp.tex
index 777ee92f7a..548c3e541f 100644
--- a/doc/tex/ex-client-srp.tex
+++ b/doc/tex/ex-client-srp.tex
@@ -7,7 +7,7 @@
 
 /* Those functions are defined in other examples.
  */
-extern void check_alert(gnutls_session session, int ret);
+extern void check_alert(gnutls_session_t session, int ret);
 extern int tcp_connect( void);
 extern void tcp_close( int sd);
 
@@ -25,10 +25,10 @@ int main()
 {
    int ret;
    int sd, ii;
-   gnutls_session session;
+   gnutls_session_t session;
    char buffer[MAX_BUF + 1];
-   gnutls_srp_client_credentials srp_cred;
-   gnutls_certificate_client_credentials cert_cred;
+   gnutls_srp_client_credentials_t srp_cred;
+   gnutls_certificate_client_credentials_t cert_cred;
 
    gnutls_global_init();
 
@@ -63,7 +63,7 @@ int main()
    gnutls_credentials_set(session, GNUTLS_CRD_SRP, srp_cred);
    gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE, cert_cred);
 
-   gnutls_transport_set_ptr( session, (gnutls_transport_ptr)sd);
+   gnutls_transport_set_ptr( session, (gnutls_transport_ptr_t)sd);
 
    /* Perform the TLS handshake
     */
diff --git a/doc/tex/ex-client2.tex b/doc/tex/ex-client2.tex
index c46413a4ae..9be2bf4037 100644
--- a/doc/tex/ex-client2.tex
+++ b/doc/tex/ex-client2.tex
@@ -57,9 +57,9 @@ void tcp_close( int sd)
 int main()
 {
    int ret, sd, ii;
-   gnutls_session session;
+   gnutls_session_t session;
    char buffer[MAX_BUF + 1];
-   gnutls_certificate_credentials xcred;
+   gnutls_certificate_credentials_t xcred;
    /* Allow connections to servers that have OpenPGP keys as well.
     */
    const int cert_type_priority[3] = { GNUTLS_CRT_X509, 
@@ -90,7 +90,7 @@ int main()
     */
    sd = tcp_connect();
 
-   gnutls_transport_set_ptr( session, (gnutls_transport_ptr)sd);
+   gnutls_transport_set_ptr( session, (gnutls_transport_ptr_t)sd);
 
    /* Perform the TLS handshake
     */
diff --git a/doc/tex/ex-crq.tex b/doc/tex/ex-crq.tex
index 55eb85cea7..a307a935c3 100644
--- a/doc/tex/ex-crq.tex
+++ b/doc/tex/ex-crq.tex
@@ -12,8 +12,8 @@
 
 int main()
 {
-   gnutls_x509_crq crq;
-   gnutls_x509_privkey key;
+   gnutls_x509_crq_t crq;
+   gnutls_x509_privkey_t key;
    unsigned char buffer[10*1024];
    int buffer_size = sizeof(buffer);
    int ret;
diff --git a/doc/tex/ex-pkcs12.tex b/doc/tex/ex-pkcs12.tex
index 71fba2fa24..4ba81b9535 100644
--- a/doc/tex/ex-pkcs12.tex
+++ b/doc/tex/ex-pkcs12.tex
@@ -13,12 +13,12 @@
  *  encrypted using a PKCS #12 cipher, or some browsers will crash)
  * password: is the password used to encrypt the PKCS #12 packet.
  */
-int write_pkcs12(const gnutls_datum * cert, const gnutls_datum * pkcs8_key,
+int write_pkcs12(const gnutls_datum_t * cert, const gnutls_datum_t * pkcs8_key,
                  const char *password)
 {
-   gnutls_pkcs12 pkcs12;
+   gnutls_pkcs12_t pkcs12;
    int ret, bag_index;
-   gnutls_pkcs12_bag bag, key_bag;
+   gnutls_pkcs12_bag_t bag, key_bag;
    char pkcs12_struct[10 * 1024];
    int pkcs12_struct_size;
    FILE *fd;
@@ -26,7 +26,7 @@ int write_pkcs12(const gnutls_datum * cert, const gnutls_datum * pkcs8_key,
    /* A good idea might be to use gnutls_x509_privkey_get_key_id()
     * to obtain a unique ID.
     */
-   gnutls_datum key_id = { "\x00\x00\x07", 3 };
+   gnutls_datum_t key_id = { "\x00\x00\x07", 3 };
 
    gnutls_global_init();
 
diff --git a/doc/tex/ex-serv-export.tex b/doc/tex/ex-serv-export.tex
index 3b5e33f839..b83d3cda3d 100644
--- a/doc/tex/ex-serv-export.tex
+++ b/doc/tex/ex-serv-export.tex
@@ -27,19 +27,19 @@
 #define DH_BITS 1024
 
 /* These are global */
-gnutls_certificate_credentials cert_cred;
+gnutls_certificate_credentials_t cert_cred;
 
 static void wrap_db_init(void);
 static void wrap_db_deinit(void);
-static int wrap_db_store(void *dbf, gnutls_datum key, gnutls_datum data);
-static gnutls_datum wrap_db_fetch(void *dbf, gnutls_datum key);
-static int wrap_db_delete(void *dbf, gnutls_datum key);
+static int wrap_db_store(void *dbf, gnutls_datum_t key, gnutls_datum_t data);
+static gnutls_datum_t wrap_db_fetch(void *dbf, gnutls_datum_t key);
+static int wrap_db_delete(void *dbf, gnutls_datum_t key);
 
 #define TLS_SESSION_CACHE 50
 
-gnutls_session initialize_tls_session()
+gnutls_session_t initialize_tls_session()
 {
-   gnutls_session session;
+   gnutls_session_t session;
 
    gnutls_init(&session, GNUTLS_SERVER);
 
@@ -65,11 +65,11 @@ gnutls_session initialize_tls_session()
    return session;
 }
 
-gnutls_dh_params dh_params;
+gnutls_dh_params_t dh_params;
 /* Export-grade cipher suites require temporary RSA
  * keys.
  */
-gnutls_rsa_params rsa_params;
+gnutls_rsa_params_t rsa_params;
 
 int generate_dh_params(void)
 {
@@ -107,7 +107,7 @@ int main()
    struct sockaddr_in sa_cli;
    int client_len;
    char topbuf[512];
-   gnutls_session session;
+   gnutls_session_t session;
    char buffer[MAX_BUF + 1];
    int optval = 1;
    char name[256];
@@ -168,7 +168,7 @@ int main()
              inet_ntop(AF_INET, &sa_cli.sin_addr, topbuf,
                        sizeof(topbuf)), ntohs(sa_cli.sin_port));
 
-      gnutls_transport_set_ptr(session, (gnutls_transport_ptr)sd);
+      gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t)sd);
       ret = gnutls_handshake(session);
       if (ret < 0) {
          close(sd);
@@ -251,7 +251,7 @@ static void wrap_db_deinit(void)
    return;
 }
 
-static int wrap_db_store(void *dbf, gnutls_datum key, gnutls_datum data)
+static int wrap_db_store(void *dbf, gnutls_datum_t key, gnutls_datum_t data)
 {
 
    if (cache_db == NULL)
@@ -274,9 +274,9 @@ static int wrap_db_store(void *dbf, gnutls_datum key, gnutls_datum data)
    return 0;
 }
 
-static gnutls_datum wrap_db_fetch(void *dbf, gnutls_datum key)
+static gnutls_datum_t wrap_db_fetch(void *dbf, gnutls_datum_t key)
 {
-   gnutls_datum res = { NULL, 0 };
+   gnutls_datum_t res = { NULL, 0 };
    int i;
 
    if (cache_db == NULL)
@@ -301,7 +301,7 @@ static gnutls_datum wrap_db_fetch(void *dbf, gnutls_datum key)
    return res;
 }
 
-static int wrap_db_delete(void *dbf, gnutls_datum key)
+static int wrap_db_delete(void *dbf, gnutls_datum_t key)
 {
    int i;
 
diff --git a/doc/tex/ex-serv-pgp.tex b/doc/tex/ex-serv-pgp.tex
index c9792a930f..44f98ad231 100644
--- a/doc/tex/ex-serv-pgp.tex
+++ b/doc/tex/ex-serv-pgp.tex
@@ -29,13 +29,13 @@
 #define DH_BITS 1024
 
 /* These are global */
-gnutls_certificate_credentials cred;
+gnutls_certificate_credentials_t cred;
 const int cert_type_priority[2] = { GNUTLS_CRT_OPENPGP, 0 };
-gnutls_dh_params dh_params;
+gnutls_dh_params_t dh_params;
 
 /* Defined in a previous example */
 extern int generate_dh_params( void);
-extern gnutls_session initialize_tls_session( void);
+extern gnutls_session_t initialize_tls_session( void);
 
 int main()
 {
@@ -45,7 +45,7 @@ int main()
    struct sockaddr_in sa_cli;
    int client_len;
    char topbuf[512];
-   gnutls_session session;
+   gnutls_session_t session;
    char buffer[MAX_BUF + 1];
    int optval = 1;
    char name[256];
@@ -95,7 +95,7 @@ int main()
              inet_ntop(AF_INET, &sa_cli.sin_addr, topbuf,
                        sizeof(topbuf)), ntohs(sa_cli.sin_port));
 
-      gnutls_transport_set_ptr( session, (gnutls_transport_ptr)sd);
+      gnutls_transport_set_ptr( session, (gnutls_transport_ptr_t)sd);
       ret = gnutls_handshake( session);
       if (ret < 0) {
          close(sd);
diff --git a/doc/tex/ex-serv-srp.tex b/doc/tex/ex-serv-srp.tex
index e671c182ed..5fb7ba2796 100644
--- a/doc/tex/ex-serv-srp.tex
+++ b/doc/tex/ex-serv-srp.tex
@@ -28,12 +28,12 @@
 #define PORT 5556               /* listen to 5556 port */
 
 /* These are global */
-gnutls_srp_server_credentials srp_cred;
-gnutls_certificate_credentials cert_cred;
+gnutls_srp_server_credentials_t srp_cred;
+gnutls_certificate_credentials_t cert_cred;
 
-gnutls_session initialize_tls_session()
+gnutls_session_t initialize_tls_session()
 {
-   gnutls_session session;
+   gnutls_session_t session;
    const int kx_priority[] = { GNUTLS_KX_SRP, GNUTLS_KX_SRP_DSS,
       GNUTLS_KX_SRP_RSA, 0 };
 
@@ -62,7 +62,7 @@ int main()
    struct sockaddr_in sa_cli;
    int client_len;
    char topbuf[512];
-   gnutls_session session;
+   gnutls_session_t session;
    char buffer[MAX_BUF + 1];
    int optval = 1;
    char name[256];
@@ -113,7 +113,7 @@ int main()
              inet_ntop(AF_INET, &sa_cli.sin_addr, topbuf,
                        sizeof(topbuf)), ntohs(sa_cli.sin_port));
 
-      gnutls_transport_set_ptr( session, (gnutls_transport_ptr)sd);
+      gnutls_transport_set_ptr( session, (gnutls_transport_ptr_t)sd);
       ret = gnutls_handshake( session);
       if (ret < 0) {
          close(sd);
diff --git a/doc/tex/ex-serv1.tex b/doc/tex/ex-serv1.tex
index 8b5febb916..8b935a2b1d 100644
--- a/doc/tex/ex-serv1.tex
+++ b/doc/tex/ex-serv1.tex
@@ -27,11 +27,11 @@
 #define DH_BITS 1024
 
 /* These are global */
-gnutls_certificate_credentials x509_cred;
+gnutls_certificate_credentials_t x509_cred;
 
-gnutls_session initialize_tls_session()
+gnutls_session_t initialize_tls_session()
 {
-   gnutls_session session;
+   gnutls_session_t session;
 
    gnutls_init(&session, GNUTLS_SERVER);
 
@@ -51,7 +51,7 @@ gnutls_session initialize_tls_session()
    return session;
 }
 
-static gnutls_dh_params dh_params;
+static gnutls_dh_params_t dh_params;
 
 static int generate_dh_params(void) {
 
@@ -74,7 +74,7 @@ int main()
    struct sockaddr_in sa_cli;
    int client_len;
    char topbuf[512];
-   gnutls_session session;
+   gnutls_session_t session;
    char buffer[MAX_BUF + 1];
    int optval = 1;
 
@@ -125,7 +125,7 @@ int main()
              inet_ntop(AF_INET, &sa_cli.sin_addr, topbuf,
                        sizeof(topbuf)), ntohs(sa_cli.sin_port));
 
-      gnutls_transport_set_ptr( session, (gnutls_transport_ptr)sd);
+      gnutls_transport_set_ptr( session, (gnutls_transport_ptr_t)sd);
       ret = gnutls_handshake( session);
       if (ret < 0) {
          close(sd);
diff --git a/doc/tex/ex-session-info.tex b/doc/tex/ex-session-info.tex
index 243469c2c1..cc0ffb8b8e 100644
--- a/doc/tex/ex-session-info.tex
+++ b/doc/tex/ex-session-info.tex
@@ -5,16 +5,16 @@
 #include <gnutls/gnutls.h>
 #include <gnutls/x509.h>
 
-extern void print_x509_certificate_info(gnutls_session);
+extern void print_x509_certificate_info(gnutls_session_t);
 
 /* This function will print some details of the
  * given session.
  */
-int print_info(gnutls_session session)
+int print_info(gnutls_session_t session)
 {
    const char *tmp;
-   gnutls_credentials_type cred;
-   gnutls_kx_algorithm kx;
+   gnutls_credentials_type_t cred;
+   gnutls_kx_algorithm_t kx;
 
    /* print the key exchange's algorithm name
     */
diff --git a/doc/tex/ex-verify.tex b/doc/tex/ex-verify.tex
index 2be398b473..164ee58e03 100644
--- a/doc/tex/ex-verify.tex
+++ b/doc/tex/ex-verify.tex
@@ -9,29 +9,29 @@
 
 /* All the available CRLs
  */
-extern gnutls_x509_crl* crl_list;
+extern gnutls_x509_crl_t* crl_list;
 extern int crl_list_size;
 
 /* All the available trusted CAs
  */
-extern gnutls_x509_crt* ca_list;
+extern gnutls_x509_crt_t* ca_list;
 extern int ca_list_size;
 
-static void verify_cert2(gnutls_x509_crt crt,
-   gnutls_x509_crt issuer, gnutls_x509_crl * crl_list, int crl_list_size);
-static void verify_last_cert(gnutls_x509_crt crt,
-   gnutls_x509_crt *ca_list, int ca_list_size,
-   gnutls_x509_crl * crl_list, int crl_list_size);
+static void verify_cert2(gnutls_x509_crt_t crt,
+   gnutls_x509_crt_t issuer, gnutls_x509_crl_t * crl_list, int crl_list_size);
+static void verify_last_cert(gnutls_x509_crt_t crt,
+   gnutls_x509_crt_t *ca_list, int ca_list_size,
+   gnutls_x509_crl_t * crl_list, int crl_list_size);
 
 
 /* This function will try to verify the peer's certificate chain, and
  * also check if the hostname matches, and the activation, expiration dates.
  */
-void verify_certificate_chain( gnutls_session session, const char* hostname,
-   const gnutls_datum* cert_chain, int cert_chain_length)
+void verify_certificate_chain( gnutls_session_t session, const char* hostname,
+   const gnutls_datum_t* cert_chain, int cert_chain_length)
 {
    int i, ret;
-   gnutls_x509_crt cert[cert_chain_length];
+   gnutls_x509_crt_t cert[cert_chain_length];
 
    /* Import all the certificates in the chain to
     * native certificate format.
@@ -71,8 +71,8 @@ void verify_certificate_chain( gnutls_session session, const char* hostname,
  * which is supposed to be it's issuer. Also checks the
  * crl_list if the certificate is revoked.
  */
-static void verify_cert2(gnutls_x509_crt crt,
-   gnutls_x509_crt issuer, gnutls_x509_crl * crl_list, int crl_list_size)
+static void verify_cert2(gnutls_x509_crt crt_t,
+   gnutls_x509_crt_t issuer, gnutls_x509_crl_t * crl_list, int crl_list_size)
 { 
    unsigned int output;
    int ret;
@@ -137,9 +137,9 @@ static void verify_cert2(gnutls_x509_crt crt,
 /* Verifies a certificate against the trusted CA list.
  * Also checks the crl_list if the certificate is revoked.
  */
-static void verify_last_cert(gnutls_x509_crt crt,
-   gnutls_x509_crt *ca_list, int ca_list_size,
-   gnutls_x509_crl * crl_list, int crl_list_size)
+static void verify_last_cert(gnutls_x509_crt_t crt,
+   gnutls_x509_crt_t *ca_list, int ca_list_size,
+   gnutls_x509_crl_t * crl_list, int crl_list_size)
 { 
    unsigned int output;
    int ret;
diff --git a/doc/tex/ex-x509-info.tex b/doc/tex/ex-x509-info.tex
index e7dd772059..a6b27a4c37 100644
--- a/doc/tex/ex-x509-info.tex
+++ b/doc/tex/ex-x509-info.tex
@@ -25,7 +25,7 @@ char* print;
 /* This function will print information about this session's peer
  * certificate. 
  */
-static void print_x509_certificate_info(gnutls_session session)
+static void print_x509_certificate_info(gnutls_session_t session)
 {
    char serial[40];
    char dn[128];
@@ -33,9 +33,9 @@ static void print_x509_certificate_info(gnutls_session session)
    size_t size;
    unsigned int algo, bits;
    time_t expiration_time, activation_time;
-   const gnutls_datum *cert_list;
+   const gnutls_datum_t *cert_list;
    int cert_list_size = 0;
-   gnutls_x509_crt cert;
+   gnutls_x509_crt_t cert;
 
    /* This function only works for X.509 certificates.
     */
diff --git a/includes/Makefile.am b/includes/Makefile.am
index cb35de5471..ba9f4001a4 100644
--- a/includes/Makefile.am
+++ b/includes/Makefile.am
@@ -1,7 +1,7 @@
 ## Process this file with automake to produce Makefile.in
 
 nobase_include_HEADERS = gnutls/extra.h gnutls/gnutls.h $(OPENSSL_H) \
-	gnutls/x509.h gnutls/pkcs12.h \
+	gnutls/x509.h gnutls/pkcs12.h gnutls/compat.h \
 	gnutls/openpgp.h
 
 if ENABLE_OPENSSL
diff --git a/includes/gnutls/Makefile.am b/includes/gnutls/Makefile.am
index 484ff83428..7d7099044a 100644
--- a/includes/gnutls/Makefile.am
+++ b/includes/gnutls/Makefile.am
@@ -1 +1 @@
-EXTRA_DIST = extra.h openssl.h gnutls.h x509.h pkcs12.h openpgp.h
+EXTRA_DIST = extra.h openssl.h gnutls.h x509.h pkcs12.h openpgp.h compat.h
diff --git a/includes/gnutls/compat.h b/includes/gnutls/compat.h
new file mode 100644
index 0000000000..eab5442262
--- /dev/null
+++ b/includes/gnutls/compat.h
@@ -0,0 +1,57 @@
+/* Typedefs to be fully compatible with the types of
+ * GnuTLS 1.0.x.
+ */
+
+#ifndef GCOMPAT_H
+# define GCOMPAT_H
+
+#define gnutls_cipher_algorithm gnutls_cipher_algorithm_t
+#define gnutls_kx_algorithm gnutls_kx_algorithm_t
+#define gnutls_paramsype gnutls_paramsype_t
+#define gnutls_mac_algorithm gnutls_mac_algorithm_t
+#define gnutls_digest_algorithm gnutls_digest_algorithm_t
+#define gnutls_compression_method gnutls_compression_method_t
+#define gnutls_connection_end gnutls_connection_end_t
+#define gnutls_credentialsype gnutls_credentialsype_t
+#define gnutls_certificateype gnutls_certificateype_t
+#define gnutls_x509_crt_fmt gnutls_x509_crt_fmt_t
+#define gnutls_openpgp_key_fmt gnutls_openpgp_key_fmt_t
+#define gnutls_pk_algorithm gnutls_pk_algorithm_t
+#define gnutls_sign_algorithm gnutls_sign_algorithm_t
+#define gnutls_server_name gnutls_server_nameype_t
+#define gnutls_protocol gnutls_protocol_version_t
+#define gnutls_close_request gnutls_close_request_t
+#define gnutls_openpgp_key_status gnutls_openpgp_key_status_t
+#define gnutls_certificate_request gnutls_certificate_request_t
+#define gnutls_certificate_status gnutls_certificate_status_t
+#define gnutls_session gnutls_session_t
+#define gnutls_alert_level gnutls_alert_level_t
+#define gnutls_alert_description gnutls_alert_description_t
+#define gnutls_x509_subject_alt_name gnutls_x509_subject_alt_name_t
+#define gnutls_openpgp_key gnutls_openpgp_key_t
+#define gnutls_openpgp_privkey gnutls_openpgp_privkey_t
+#define gnutls_openpgp_keyring gnutls_openpgp_keyring_t
+#define gnutls_openpgp_trustdb gnutls_openpgp_trustdb_t
+#define gnutls_x509_crt gnutls_x509_crt_t
+#define gnutls_x509_privkey gnutls_x509_privkey_t
+#define gnutls_x509_crl gnutls_x509_crl_t
+#define gnutls_pkcs7 gnutls_pkcs7_t
+#define gnutls_x509_crq gnutls_x509_crq_t
+#define gnutls_pkcs_encrypt_flags gnutls_pkcs_encrypt_flags_t
+#define gnutls_pkcs12_bag_type gnutls_pkcs12_bag_type_t
+#define gnutls_pkcs12_bag gnutls_pkcs12_bag_t
+#define gnutls_pkcs12 gnutls_pkcs12_t
+#define gnutls_certificate_credentials gnutls_certificate_credentials_t
+#define gnutls_anon_server_credentials gnutls_anon_server_credentials_t
+#define gnutls_anon_client_credentials gnutls_anon_client_credentials_t
+#define gnutls_srp_client_credentials gnutls_srp_client_credentials_t
+#define gnutls_srp_server_credentials gnutls_srp_server_credentials_t
+#define gnutls_dh_params gnutls_dh_params_t
+#define gnutls_rsa_params gnutls_rsa_params_t
+#define gnutls_params_type gnutls_params_type_t
+#define gnutls_credentials_type gnutls_credentials_type_t
+#define gnutls_certificate_type gnutls_certificate_type_t
+#define gnutls_datum gnutls_datum_t
+#define gnutls_transport_ptr gnutls_transport_ptr_t
+
+#endif /* GCOMPAT_H */
diff --git a/includes/gnutls/extra.h b/includes/gnutls/extra.h
index 46283171de..fb3900874a 100644
--- a/includes/gnutls/extra.h
+++ b/includes/gnutls/extra.h
@@ -30,76 +30,76 @@
 
 /* SRP */
 
-typedef struct DSTRUCT* gnutls_srp_server_credentials;
-typedef struct DSTRUCT* gnutls_srp_client_credentials;
+typedef struct DSTRUCT* gnutls_srp_server_credentials_t;
+typedef struct DSTRUCT* gnutls_srp_client_credentials_t;
 
-void gnutls_srp_free_client_credentials( gnutls_srp_client_credentials sc);
-int gnutls_srp_allocate_client_credentials( gnutls_srp_client_credentials *sc);
-int gnutls_srp_set_client_credentials( gnutls_srp_client_credentials res, char *username, char* password);
+void gnutls_srp_free_client_credentials( gnutls_srp_client_credentials_t sc);
+int gnutls_srp_allocate_client_credentials( gnutls_srp_client_credentials_t *sc);
+int gnutls_srp_set_client_credentials( gnutls_srp_client_credentials_t res, char *username, char* password);
 
-void gnutls_srp_free_server_credentials( gnutls_srp_server_credentials sc);
-int gnutls_srp_allocate_server_credentials( gnutls_srp_server_credentials *sc);
-int gnutls_srp_set_server_credentials_file( gnutls_srp_server_credentials res, 
+void gnutls_srp_free_server_credentials( gnutls_srp_server_credentials_t sc);
+int gnutls_srp_allocate_server_credentials( gnutls_srp_server_credentials_t *sc);
+int gnutls_srp_set_server_credentials_file( gnutls_srp_server_credentials_t res, 
     const char *password_file, const char* password_conf_file);
 
-const char* gnutls_srp_server_get_username( gnutls_session state);
+const char* gnutls_srp_server_get_username( gnutls_session_t state);
 
-int gnutls_srp_verifier( const char* username, const char* password, const gnutls_datum *salt, 
-    const gnutls_datum* g, const gnutls_datum* n, 
-    gnutls_datum * res);
+int gnutls_srp_verifier( const char* username, const char* password, const gnutls_datum_t *salt, 
+    const gnutls_datum_t* g, const gnutls_datum_t* n, 
+    gnutls_datum_t * res);
 
 /* The static parameters defined in draft-ietf-tls-srp-05
  * Those should be used as input to gnutls_srp_verifier().
  */
-extern const gnutls_datum gnutls_srp_2048_group_prime;
-extern const gnutls_datum gnutls_srp_2048_group_generator;
+extern const gnutls_datum_t gnutls_srp_2048_group_prime;
+extern const gnutls_datum_t gnutls_srp_2048_group_generator;
 
-extern const gnutls_datum gnutls_srp_1536_group_prime;
-extern const gnutls_datum gnutls_srp_1536_group_generator;
+extern const gnutls_datum_t gnutls_srp_1536_group_prime;
+extern const gnutls_datum_t gnutls_srp_1536_group_generator;
 
-extern const gnutls_datum gnutls_srp_1024_group_prime;
-extern const gnutls_datum gnutls_srp_1024_group_generator;
+extern const gnutls_datum_t gnutls_srp_1024_group_prime;
+extern const gnutls_datum_t gnutls_srp_1024_group_generator;
 
 typedef int gnutls_srp_server_credentials_function(
-    gnutls_session, 
-    const char* username, gnutls_datum* salt, 
-    gnutls_datum* verifier, gnutls_datum* generator,
-    gnutls_datum* prime
+    gnutls_session_t, 
+    const char* username, gnutls_datum_t* salt, 
+    gnutls_datum_t* verifier, gnutls_datum_t* generator,
+    gnutls_datum_t* prime
 );
 void gnutls_srp_set_server_credentials_function( 
-    gnutls_srp_server_credentials, 
+    gnutls_srp_server_credentials_t, 
     gnutls_srp_server_credentials_function *);
 
-typedef int gnutls_srp_client_credentials_function(gnutls_session, unsigned int,
+typedef int gnutls_srp_client_credentials_function(gnutls_session_t, unsigned int,
     char **, char**);
-void gnutls_srp_set_client_credentials_function( gnutls_srp_client_credentials, 
+void gnutls_srp_set_client_credentials_function( gnutls_srp_client_credentials_t, 
     gnutls_srp_client_credentials_function *);
 
 
 /* Openpgp certificate stuff 
  */
 
-typedef int (*gnutls_openpgp_recv_key_func)(gnutls_session, const unsigned char *keyfpr, 
-    unsigned int keyfpr_length, gnutls_datum *key);
+typedef int (*gnutls_openpgp_recv_key_func)(gnutls_session_t, const unsigned char *keyfpr, 
+    unsigned int keyfpr_length, gnutls_datum_t *key);
 
-void gnutls_openpgp_set_recv_key_function( gnutls_session, gnutls_openpgp_recv_key_func);
+void gnutls_openpgp_set_recv_key_function( gnutls_session_t, gnutls_openpgp_recv_key_func);
 
-int gnutls_certificate_set_openpgp_key_file( gnutls_certificate_credentials res, 
+int gnutls_certificate_set_openpgp_key_file( gnutls_certificate_credentials_t res, 
     const char *CERTFILE, const char* KEYFILE);
-int gnutls_certificate_set_openpgp_key_mem( gnutls_certificate_credentials res,
-    const gnutls_datum* CERT, const gnutls_datum* KEY);
+int gnutls_certificate_set_openpgp_key_mem( gnutls_certificate_credentials_t res,
+    const gnutls_datum_t* CERT, const gnutls_datum_t* KEY);
 
-int gnutls_certificate_set_openpgp_keyserver(gnutls_certificate_credentials res,
+int gnutls_certificate_set_openpgp_keyserver(gnutls_certificate_credentials_t res,
     const char* keyserver, int port);
 
-int gnutls_certificate_set_openpgp_trustdb(gnutls_certificate_credentials res,
+int gnutls_certificate_set_openpgp_trustdb(gnutls_certificate_credentials_t res,
     const char* trustdb);
 
 int gnutls_certificate_set_openpgp_keyring_mem(
-    gnutls_certificate_credentials c,
+    gnutls_certificate_credentials_t c,
     const unsigned char *data, size_t dlen );
 
-int gnutls_certificate_set_openpgp_keyring_file( gnutls_certificate_credentials res, 
+int gnutls_certificate_set_openpgp_keyring_file( gnutls_certificate_credentials_t res, 
     const char *name);
 
 int gnutls_global_init_extra(void);
@@ -109,12 +109,12 @@ int gnutls_global_init_extra(void);
 const char* gnutls_extra_check_version( const char*);
 
 /* base64 */
-int gnutls_srp_base64_encode( const gnutls_datum *data, char* result, int* result_size);
-int gnutls_srp_base64_encode_alloc( const gnutls_datum *data, gnutls_datum* result);
+int gnutls_srp_base64_encode( const gnutls_datum_t *data, char* result, int* result_size);
+int gnutls_srp_base64_encode_alloc( const gnutls_datum_t *data, gnutls_datum_t* result);
 
-int gnutls_srp_base64_decode( const gnutls_datum *b64_data, char* result, int* result_size);
-int gnutls_srp_base64_decode_alloc( const gnutls_datum *b64_data, 
-   gnutls_datum* result);
+int gnutls_srp_base64_decode( const gnutls_datum_t *b64_data, char* result, int* result_size);
+int gnutls_srp_base64_decode_alloc( const gnutls_datum_t *b64_data, 
+   gnutls_datum_t* result);
 
 
 #endif
diff --git a/includes/gnutls/openpgp.h b/includes/gnutls/openpgp.h
index 7d9dc237cd..3810388a61 100644
--- a/includes/gnutls/openpgp.h
+++ b/includes/gnutls/openpgp.h
@@ -33,53 +33,53 @@ extern "C" {
 #include <gnutls/gnutls.h>
 #include <gnutls/extra.h>
 
-/* gnutls_openpgp_key should be defined in gnutls.h
+/* gnutls_openpgp_key_t should be defined in gnutls.h
  */
 
 typedef enum gnutls_openpgp_key_fmt { GNUTLS_OPENPGP_FMT_RAW,
         GNUTLS_OPENPGP_FMT_BASE64 } gnutls_openpgp_key_fmt;
 
-int gnutls_openpgp_key_init( gnutls_openpgp_key* key); /* initializes the memory for gnutls_openpgp_key struct */
-void gnutls_openpgp_key_deinit(gnutls_openpgp_key key); /* frees all memory */
+int gnutls_openpgp_key_init( gnutls_openpgp_key* key); /* initializes the memory for gnutls_openpgp_key_t struct */
+void gnutls_openpgp_key_deinit(gnutls_openpgp_key_t key); /* frees all memory */
 
-int gnutls_openpgp_key_import(gnutls_openpgp_key key,
-    const gnutls_datum* data, gnutls_openpgp_key_fmt format);
-int gnutls_openpgp_key_export(gnutls_openpgp_key key, 
+int gnutls_openpgp_key_import(gnutls_openpgp_key_t key,
+    const gnutls_datum_t* data, gnutls_openpgp_key_fmt format);
+int gnutls_openpgp_key_export(gnutls_openpgp_key_t key, 
     gnutls_openpgp_key_fmt format, void* output_data,
     size_t* output_data_size);
 
 /* The key_usage flags are defined in gnutls.h. They are
  * the GNUTLS_KEY_* definitions.
  */
-int gnutls_openpgp_key_get_key_usage( gnutls_openpgp_key cert, unsigned int* key_usage);
-int gnutls_openpgp_key_get_fingerprint( gnutls_openpgp_key key,
+int gnutls_openpgp_key_get_key_usage( gnutls_openpgp_key_t cert, unsigned int* key_usage);
+int gnutls_openpgp_key_get_fingerprint( gnutls_openpgp_key_t key,
     void* result, size_t* result_size);
     
-int gnutls_openpgp_key_get_name( gnutls_openpgp_key key,
+int gnutls_openpgp_key_get_name( gnutls_openpgp_key_t key,
     int idx, char *buf, size_t *sizeof_buf);
 
-int gnutls_openpgp_key_get_pk_algorithm(gnutls_openpgp_key key,
+int gnutls_openpgp_key_get_pk_algorithm(gnutls_openpgp_key_t key,
                                             unsigned int *r_bits);
 
-int gnutls_openpgp_key_get_version( gnutls_openpgp_key key );
+int gnutls_openpgp_key_get_version( gnutls_openpgp_key_t key );
 
-time_t gnutls_openpgp_key_get_creation_time( gnutls_openpgp_key key );
-time_t gnutls_openpgp_key_get_expiration_time( gnutls_openpgp_key key );
+time_t gnutls_openpgp_key_get_creation_time( gnutls_openpgp_key_t key );
+time_t gnutls_openpgp_key_get_expiration_time( gnutls_openpgp_key_t key );
 
-int gnutls_openpgp_key_get_id( gnutls_openpgp_key key, unsigned char keyid[8]);
+int gnutls_openpgp_key_get_id( gnutls_openpgp_key_t key, unsigned char keyid[8]);
 
-int gnutls_openpgp_key_check_hostname( gnutls_openpgp_key key, const char *hostname);
+int gnutls_openpgp_key_check_hostname( gnutls_openpgp_key_t key, const char *hostname);
 
-int gnutls_openpgp_key_to_xml( gnutls_openpgp_key key, gnutls_datum *xmlkey,
+int gnutls_openpgp_key_to_xml( gnutls_openpgp_key_t key, gnutls_datum_t *xmlkey,
     int ext);
 
 /* privkey stuff.
  */
-int gnutls_openpgp_privkey_init(gnutls_openpgp_privkey * key);
-void gnutls_openpgp_privkey_deinit(gnutls_openpgp_privkey key);
-int gnutls_openpgp_privkey_get_pk_algorithm( gnutls_openpgp_privkey key, unsigned int *bits);
-int gnutls_openpgp_privkey_import(gnutls_openpgp_privkey key, 
-    const gnutls_datum * data, gnutls_openpgp_key_fmt format,
+int gnutls_openpgp_privkey_init(gnutls_openpgp_privkey_t * key);
+void gnutls_openpgp_privkey_deinit(gnutls_openpgp_privkey_t key);
+int gnutls_openpgp_privkey_get_pk_algorithm( gnutls_openpgp_privkey_t key, unsigned int *bits);
+int gnutls_openpgp_privkey_import(gnutls_openpgp_privkey_t key, 
+    const gnutls_datum_t * data, gnutls_openpgp_key_fmt format,
     const char* pass, unsigned int flags);
 
 /* Keyring stuff.
@@ -88,12 +88,12 @@ struct gnutls_openpgp_keyring_int; /* object to hold (parsed) openpgp keyrings *
 typedef struct gnutls_openpgp_keyring_int* gnutls_openpgp_keyring;
 
 int gnutls_openpgp_keyring_init( gnutls_openpgp_keyring* ring);
-void gnutls_openpgp_keyring_deinit(gnutls_openpgp_keyring ring);
+void gnutls_openpgp_keyring_deinit(gnutls_openpgp_keyring_t ring);
 
-int gnutls_openpgp_keyring_import(gnutls_openpgp_keyring ring,
-    const gnutls_datum* data, gnutls_openpgp_key_fmt format);
+int gnutls_openpgp_keyring_import(gnutls_openpgp_keyring_t ring,
+    const gnutls_datum_t* data, gnutls_openpgp_key_fmt format);
 
-int gnutls_openpgp_keyring_check_id( gnutls_openpgp_keyring ring,
+int gnutls_openpgp_keyring_check_id( gnutls_openpgp_keyring_t ring,
     const unsigned char keyid[8], unsigned int flags);
 
 /* Trustdb functions.
@@ -102,32 +102,32 @@ struct gnutls_openpgp_trustdb_int; /* object to hold (parsed) openpgp trustdbs *
 typedef struct gnutls_openpgp_trustdb_int* gnutls_openpgp_trustdb;
 
 int gnutls_openpgp_trustdb_init( gnutls_openpgp_trustdb* db);
-void gnutls_openpgp_trustdb_deinit(gnutls_openpgp_trustdb db);
+void gnutls_openpgp_trustdb_deinit(gnutls_openpgp_trustdb_t db);
 
-int gnutls_openpgp_trustdb_import(gnutls_openpgp_trustdb db,
+int gnutls_openpgp_trustdb_import(gnutls_openpgp_trustdb_t db,
     const char* file);
 
 
 int gnutls_openpgp_key_verify_ring( 
-    gnutls_openpgp_key key, 
-    gnutls_openpgp_keyring ring,
+    gnutls_openpgp_key_t key, 
+    gnutls_openpgp_keyring_t ring,
     unsigned int flags,
     unsigned int * verify /* the output of the verification */);
 
-int gnutls_openpgp_key_verify_self( gnutls_openpgp_key key,
+int gnutls_openpgp_key_verify_self( gnutls_openpgp_key_t key,
         unsigned int flags, unsigned int *verify);
 
 int gnutls_openpgp_key_verify_trustdb( 
-    gnutls_openpgp_key key, 
-    gnutls_openpgp_trustdb db,
+    gnutls_openpgp_key_t key, 
+    gnutls_openpgp_trustdb_t db,
     unsigned int flags,
     unsigned int * verify /* the output of the verification */);
 
 
 /* certificate authentication stuff.
  */
-int gnutls_certificate_set_openpgp_key(gnutls_certificate_credentials res,
-    gnutls_openpgp_key key, gnutls_openpgp_privkey pkey);
+int gnutls_certificate_set_openpgp_key(gnutls_certificate_credentials_t res,
+    gnutls_openpgp_key_t key, gnutls_openpgp_privkey_t pkey);
 
 #ifdef __cplusplus
 }
diff --git a/includes/gnutls/openssl.h b/includes/gnutls/openssl.h
index 07d2e510c3..eeb7161121 100644
--- a/includes/gnutls/openssl.h
+++ b/includes/gnutls/openssl.h
@@ -86,7 +86,7 @@ typedef struct {
 #define SSL_MODE_AUTO_RETRY (0x4)
 
 typedef gnutls_x509_dn X509_NAME;
-typedef gnutls_datum X509;
+typedef gnutls_datum_t X509;
 
 struct _SSL;
 
@@ -97,29 +97,29 @@ typedef struct
     int comp_priority[GNUTLS_MAX_ALGORITHM_NUM];
     int kx_priority[GNUTLS_MAX_ALGORITHM_NUM];
     int mac_priority[GNUTLS_MAX_ALGORITHM_NUM];
-    gnutls_connection_end connend;
+    gnutls_connection_end_t connend;
 } SSL_METHOD;
 
 typedef struct
 {
-    gnutls_protocol_version version;
-    gnutls_cipher_algorithm cipher;
-    gnutls_kx_algorithm kx;
-    gnutls_mac_algorithm mac;
-    gnutls_compression_method compression;
-    gnutls_certificate_type cert;
+    gnutls_protocol_t version;
+    gnutls_cipher_algorithm_t cipher;
+    gnutls_kx_algorithm_t kx;
+    gnutls_mac_algorithm_t mac;
+    gnutls_compression_method_t compression;
+    gnutls_certificate_type_t cert;
 } SSL_CIPHER;
 
 typedef struct _BIO
 {
-    gnutls_transport_ptr fd;
+    gnutls_transport_ptr_t fd;
 } BIO;
 
 typedef struct
 {
     struct _SSL *ssl;
     int error;
-    const gnutls_datum *cert_list;
+    const gnutls_datum_t *cert_list;
 #define current_cert cert_list
 } X509_STORE_CTX;
 
@@ -141,7 +141,7 @@ typedef struct _SSL_CTX
 
 typedef struct _SSL
 {
-    gnutls_session gnutls_state;
+    gnutls_session_t gnutls_state;
 #define rbio gnutls_state
 
     gnutls_certificate_client_credentials gnutls_cred;
@@ -157,8 +157,8 @@ typedef struct _SSL
     int (*verify_callback)(int, X509_STORE_CTX *);
     int verify_mode;
     
-    gnutls_transport_ptr rfd;
-    gnutls_transport_ptr wfd;
+    gnutls_transport_ptr_t rfd;
+    gnutls_transport_ptr_t wfd;
 } SSL;
 
 typedef struct
@@ -282,7 +282,7 @@ void X509_free(const X509 *cert);
 
 /* BIO functions */
 
-void BIO_get_fd(gnutls_session gnutls_state, int *fd);
+void BIO_get_fd(gnutls_session_t gnutls_state, int *fd);
 BIO *BIO_new_socket(int sock, int close_flag);
 
 /* error handling */
diff --git a/includes/gnutls/pkcs12.h b/includes/gnutls/pkcs12.h
index 05ef7fe211..3f04997d1d 100644
--- a/includes/gnutls/pkcs12.h
+++ b/includes/gnutls/pkcs12.h
@@ -31,29 +31,29 @@ extern "C" {
 /* PKCS12 structures handling 
  */
 struct gnutls_pkcs12_int;
-typedef struct gnutls_pkcs12_int* gnutls_pkcs12;
+typedef struct gnutls_pkcs12_int* gnutls_pkcs12_t;
 
 struct gnutls_pkcs12_bag_int;
-typedef struct gnutls_pkcs12_bag_int* gnutls_pkcs12_bag;
+typedef struct gnutls_pkcs12_bag_int* gnutls_pkcs12_bag_t;
 
-int gnutls_pkcs12_init(gnutls_pkcs12 * pkcs12);
-void gnutls_pkcs12_deinit(gnutls_pkcs12 pkcs12);
-int gnutls_pkcs12_import(gnutls_pkcs12 pkcs12, const gnutls_datum * data,
+int gnutls_pkcs12_init(gnutls_pkcs12_t * pkcs12);
+void gnutls_pkcs12_deinit(gnutls_pkcs12_t pkcs12);
+int gnutls_pkcs12_import(gnutls_pkcs12_t pkcs12, const gnutls_datum_t * data,
     gnutls_x509_crt_fmt format, unsigned int flags);
-int gnutls_pkcs12_export( gnutls_pkcs12 pkcs12,
+int gnutls_pkcs12_export( gnutls_pkcs12_t pkcs12,
     gnutls_x509_crt_fmt format, void* output_data, size_t* output_data_size);
 
-int gnutls_pkcs12_get_bag(gnutls_pkcs12 pkcs12, 
-    int indx, gnutls_pkcs12_bag bag);
-int gnutls_pkcs12_set_bag(gnutls_pkcs12 pkcs12, gnutls_pkcs12_bag bag);
+int gnutls_pkcs12_get_bag(gnutls_pkcs12_t pkcs12, 
+    int indx, gnutls_pkcs12_bag_t bag);
+int gnutls_pkcs12_set_bag(gnutls_pkcs12_t pkcs12, gnutls_pkcs12_bag_t bag);
 
-int gnutls_pkcs12_generate_mac(gnutls_pkcs12 pkcs12, const char* pass);
-int gnutls_pkcs12_verify_mac(gnutls_pkcs12 pkcs12, const char* pass);
+int gnutls_pkcs12_generate_mac(gnutls_pkcs12_t pkcs12, const char* pass);
+int gnutls_pkcs12_verify_mac(gnutls_pkcs12_t pkcs12, const char* pass);
 
-int gnutls_pkcs12_bag_decrypt(gnutls_pkcs12_bag bag, const char* pass);
-int gnutls_pkcs12_bag_encrypt(gnutls_pkcs12_bag bag, const char* pass, unsigned int flags);
+int gnutls_pkcs12_bag_decrypt(gnutls_pkcs12_bag_t bag, const char* pass);
+int gnutls_pkcs12_bag_encrypt(gnutls_pkcs12_bag_t bag, const char* pass, unsigned int flags);
 
-typedef enum gnutls_pkcs12_bag_type {
+typedef enum gnutls_pkcs12_bag_type_t {
     GNUTLS_BAG_EMPTY = 0,
 
     GNUTLS_BAG_PKCS8_ENCRYPTED_KEY=1,
@@ -62,27 +62,27 @@ typedef enum gnutls_pkcs12_bag_type {
     GNUTLS_BAG_CRL,
     GNUTLS_BAG_ENCRYPTED=10,
     GNUTLS_BAG_UNKNOWN=20
-} gnutls_pkcs12_bag_type;
+} gnutls_pkcs12_bag_type_t;
 
-gnutls_pkcs12_bag_type gnutls_pkcs12_bag_get_type(gnutls_pkcs12_bag bag, int indx);
-int gnutls_pkcs12_bag_get_data(gnutls_pkcs12_bag bag, int indx, gnutls_datum* data);
-int gnutls_pkcs12_bag_set_data(gnutls_pkcs12_bag bag, gnutls_pkcs12_bag_type type,
-        const gnutls_datum* data);
-int gnutls_pkcs12_bag_set_crl(gnutls_pkcs12_bag bag, gnutls_x509_crl crl);
-int gnutls_pkcs12_bag_set_crt(gnutls_pkcs12_bag bag, gnutls_x509_crt crt);
+gnutls_pkcs12_bag_type_t gnutls_pkcs12_bag_get_type(gnutls_pkcs12_bag_t bag, int indx);
+int gnutls_pkcs12_bag_get_data(gnutls_pkcs12_bag_t bag, int indx, gnutls_datum_t* data);
+int gnutls_pkcs12_bag_set_data(gnutls_pkcs12_bag_t bag, gnutls_pkcs12_bag_type_t type,
+        const gnutls_datum_t* data);
+int gnutls_pkcs12_bag_set_crl(gnutls_pkcs12_bag_t bag, gnutls_x509_crl_t crl);
+int gnutls_pkcs12_bag_set_crt(gnutls_pkcs12_bag_t bag, gnutls_x509_crt_t crt);
 
-int gnutls_pkcs12_bag_init(gnutls_pkcs12_bag * bag);
-void gnutls_pkcs12_bag_deinit(gnutls_pkcs12_bag bag);
-int gnutls_pkcs12_bag_get_count(gnutls_pkcs12_bag bag);
+int gnutls_pkcs12_bag_init(gnutls_pkcs12_bag_t * bag);
+void gnutls_pkcs12_bag_deinit(gnutls_pkcs12_bag_t bag);
+int gnutls_pkcs12_bag_get_count(gnutls_pkcs12_bag_t bag);
 
-int gnutls_pkcs12_bag_get_key_id(gnutls_pkcs12_bag bag, int indx, 
-    gnutls_datum* id);
-int gnutls_pkcs12_bag_set_key_id(gnutls_pkcs12_bag bag, int indx, 
-    const gnutls_datum* id);
+int gnutls_pkcs12_bag_get_key_id(gnutls_pkcs12_bag_t  bag, int indx, 
+    gnutls_datum_t* id);
+int gnutls_pkcs12_bag_set_key_id(gnutls_pkcs12_bag_t  bag, int indx, 
+    const gnutls_datum_t* id);
 
-int gnutls_pkcs12_bag_get_friendly_name(gnutls_pkcs12_bag bag, int indx, 
+int gnutls_pkcs12_bag_get_friendly_name(gnutls_pkcs12_bag_t  bag, int indx, 
     char **name);
-int gnutls_pkcs12_bag_set_friendly_name(gnutls_pkcs12_bag bag, int indx, 
+int gnutls_pkcs12_bag_set_friendly_name(gnutls_pkcs12_bag_t  bag, int indx, 
     const char* name);
 
 #ifdef __cplusplus
diff --git a/includes/gnutls/x509.h b/includes/gnutls/x509.h
index e644f78fab..8a061bc2da 100644
--- a/includes/gnutls/x509.h
+++ b/includes/gnutls/x509.h
@@ -77,40 +77,40 @@ extern "C" {
 /* Certificate handling functions 
  */
 
-int gnutls_x509_crt_init(gnutls_x509_crt * cert);
-void gnutls_x509_crt_deinit(gnutls_x509_crt cert);
-int gnutls_x509_crt_import(gnutls_x509_crt cert, const gnutls_datum * data,
-    gnutls_x509_crt_fmt format);
-int gnutls_x509_crt_export( gnutls_x509_crt cert,
-    gnutls_x509_crt_fmt format, void* output_data, size_t* output_data_size);
-int gnutls_x509_crt_get_issuer_dn(gnutls_x509_crt cert, char *buf,
+int gnutls_x509_crt_init(gnutls_x509_crt_t * cert);
+void gnutls_x509_crt_deinit(gnutls_x509_crt_t cert);
+int gnutls_x509_crt_import(gnutls_x509_crt_t cert, const gnutls_datum_t * data,
+    gnutls_x509_crt_fmt_t format);
+int gnutls_x509_crt_export( gnutls_x509_crt_t cert,
+    gnutls_x509_crt_fmt_t format, void* output_data, size_t* output_data_size);
+int gnutls_x509_crt_get_issuer_dn(gnutls_x509_crt_t cert, char *buf,
     size_t *sizeof_buf);
-int gnutls_x509_crt_get_issuer_dn_oid(gnutls_x509_crt cert, 
+int gnutls_x509_crt_get_issuer_dn_oid(gnutls_x509_crt_t cert, 
     int indx, void *oid, size_t *sizeof_oid);
-int gnutls_x509_crt_get_issuer_dn_by_oid(gnutls_x509_crt cert, 
+int gnutls_x509_crt_get_issuer_dn_by_oid(gnutls_x509_crt_t cert, 
     const char* oid, int indx, unsigned int raw_flag,
     void *buf, size_t *sizeof_buf);
-int gnutls_x509_crt_get_dn(gnutls_x509_crt cert, char *buf,
+int gnutls_x509_crt_get_dn(gnutls_x509_crt_t cert, char *buf,
      size_t *sizeof_buf);
-int gnutls_x509_crt_get_dn_oid(gnutls_x509_crt cert, 
+int gnutls_x509_crt_get_dn_oid(gnutls_x509_crt_t cert, 
     int indx, void *oid, size_t *sizeof_oid);
-int gnutls_x509_crt_get_dn_by_oid(gnutls_x509_crt cert, const char* oid, 
+int gnutls_x509_crt_get_dn_by_oid(gnutls_x509_crt_t cert, const char* oid, 
     int indx, unsigned int raw_flag, void *buf, size_t *sizeof_buf);
-int gnutls_x509_crt_check_hostname(gnutls_x509_crt cert,
-                                const char *hostname);
+int gnutls_x509_crt_check_hostname(gnutls_x509_crt_t cert,
+    const char *hostname);
 
-int gnutls_x509_crt_get_signature_algorithm(gnutls_x509_crt cert);
-int gnutls_x509_crt_get_version(gnutls_x509_crt cert);
-int gnutls_x509_crt_get_key_id( gnutls_x509_crt crt, unsigned int flags,
+int gnutls_x509_crt_get_signature_algorithm(gnutls_x509_crt_t cert);
+int gnutls_x509_crt_get_version(gnutls_x509_crt_t cert);
+int gnutls_x509_crt_get_key_id( gnutls_x509_crt_t crt, unsigned int flags,
     unsigned char* output_data, size_t* output_data_size);
 
-int gnutls_x509_crt_set_authority_key_id(gnutls_x509_crt cert, const void* id,
+int gnutls_x509_crt_set_authority_key_id(gnutls_x509_crt_t cert, const void* id,
     size_t id_size);
-int gnutls_x509_crt_get_authority_key_id(gnutls_x509_crt cert, void* ret, 
+int gnutls_x509_crt_get_authority_key_id(gnutls_x509_crt_t cert, void* ret, 
     size_t* ret_size, unsigned int* critical);
 
-int gnutls_x509_crt_get_subject_key_id(gnutls_x509_crt cert, void* ret,
-        size_t* ret_size, unsigned int* critical);
+int gnutls_x509_crt_get_subject_key_id(gnutls_x509_crt_t cert, void* ret,
+    size_t* ret_size, unsigned int* critical);
 
 #define GNUTLS_CRL_REASON_UNUSED 128
 #define GNUTLS_CRL_REASON_KEY_COMPROMISE 64
@@ -122,45 +122,45 @@ int gnutls_x509_crt_get_subject_key_id(gnutls_x509_crt cert, void* ret,
 #define GNUTLS_CRL_REASON_PRIVILEGE_WITHDRAWN 1
 #define GNUTLS_CRL_REASON_AA_COMPROMISE 32768
 
-int gnutls_x509_crt_get_crl_dist_points(gnutls_x509_crt cert, 
+int gnutls_x509_crt_get_crl_dist_points(gnutls_x509_crt_t cert, 
     unsigned int seq, void *ret, size_t *ret_size, unsigned int* reason_flags,
     unsigned int *critical);
-int gnutls_x509_crt_set_crl_dist_points(gnutls_x509_crt crt, gnutls_x509_subject_alt_name type,
+int gnutls_x509_crt_set_crl_dist_points(gnutls_x509_crt_t crt, gnutls_x509_subject_alt_name_t type,
     const void* data_string, unsigned int reason_flags);
-int gnutls_x509_crt_cpy_crl_dist_points(gnutls_x509_crt dst, 
-    gnutls_x509_crt src);
+int gnutls_x509_crt_cpy_crl_dist_points(gnutls_x509_crt_t dst, 
+    gnutls_x509_crt_t src);
 
-time_t gnutls_x509_crt_get_activation_time(gnutls_x509_crt cert);
-time_t gnutls_x509_crt_get_expiration_time(gnutls_x509_crt cert);
-int gnutls_x509_crt_get_serial(gnutls_x509_crt cert, void* result, size_t* result_size);
+time_t gnutls_x509_crt_get_activation_time(gnutls_x509_crt_t cert);
+time_t gnutls_x509_crt_get_expiration_time(gnutls_x509_crt_t cert);
+int gnutls_x509_crt_get_serial(gnutls_x509_crt_t cert, void* result, size_t* result_size);
 
-int gnutls_x509_crt_get_pk_algorithm( gnutls_x509_crt cert, unsigned int* bits);
-int gnutls_x509_crt_get_pk_rsa_raw(gnutls_x509_crt crt,
-    gnutls_datum * m, gnutls_datum *e);
-int gnutls_x509_crt_get_pk_dsa_raw(gnutls_x509_crt crt,
-    gnutls_datum * p, gnutls_datum *q,
-    gnutls_datum *g, gnutls_datum *y);
+int gnutls_x509_crt_get_pk_algorithm( gnutls_x509_crt_t cert, unsigned int* bits);
+int gnutls_x509_crt_get_pk_rsa_raw(gnutls_x509_crt_t crt,
+    gnutls_datum_t * m, gnutls_datum_t *e);
+int gnutls_x509_crt_get_pk_dsa_raw(gnutls_x509_crt_t crt,
+    gnutls_datum_t * p, gnutls_datum_t *q,
+    gnutls_datum_t *g, gnutls_datum_t *y);
 
-int gnutls_x509_crt_get_subject_alt_name(gnutls_x509_crt cert, 
+int gnutls_x509_crt_get_subject_alt_name(gnutls_x509_crt_t cert, 
     unsigned int seq, void *ret, size_t *ret_size, unsigned int* critical);
-int gnutls_x509_crt_get_ca_status(gnutls_x509_crt cert, unsigned int* critical);
+int gnutls_x509_crt_get_ca_status(gnutls_x509_crt_t cert, unsigned int* critical);
 
 /* The key_usage flags are defined in gnutls.h. They are
  * the GNUTLS_KEY_* definitions.
  */
-int gnutls_x509_crt_get_key_usage( gnutls_x509_crt cert, unsigned int* key_usage,
+int gnutls_x509_crt_get_key_usage( gnutls_x509_crt_t cert, unsigned int* key_usage,
     unsigned int* critical);
-int gnutls_x509_crt_set_key_usage(gnutls_x509_crt crt, unsigned int usage);
+int gnutls_x509_crt_set_key_usage(gnutls_x509_crt_t crt, unsigned int usage);
 
 int gnutls_x509_dn_oid_known(const char* oid);
 
-int gnutls_x509_crt_get_extension_oid(gnutls_x509_crt cert, int indx, 
+int gnutls_x509_crt_get_extension_oid(gnutls_x509_crt_t cert, int indx, 
     void* oid, size_t * sizeof_oid);
-int gnutls_x509_crt_get_extension_by_oid(gnutls_x509_crt cert, 
+int gnutls_x509_crt_get_extension_by_oid(gnutls_x509_crt_t cert, 
     const char* oid, int indx,
     void* buf, size_t * sizeof_buf, unsigned int * critical);
 
-int gnutls_x509_crt_to_xml(gnutls_x509_crt cert, gnutls_datum* res, int detail);
+int gnutls_x509_crt_to_xml(gnutls_x509_crt_t cert, gnutls_datum_t* res, int detail);
 
 /* possible values for detail.
  */
@@ -169,81 +169,81 @@ int gnutls_x509_crt_to_xml(gnutls_x509_crt cert, gnutls_datum* res, int detail);
 
 /* X.509 Certificate writing.
  */
-int gnutls_x509_crt_set_dn_by_oid(gnutls_x509_crt crt, const char* oid, 
+int gnutls_x509_crt_set_dn_by_oid(gnutls_x509_crt_t crt, const char* oid, 
     unsigned int raw_flag, const void *name, unsigned int sizeof_name);
-int gnutls_x509_crt_set_issuer_dn_by_oid(gnutls_x509_crt crt, const char* oid, 
+int gnutls_x509_crt_set_issuer_dn_by_oid(gnutls_x509_crt_t crt, const char* oid, 
     unsigned int raw_flag, const void *name, unsigned int sizeof_name);
-int gnutls_x509_crt_set_version(gnutls_x509_crt crt, unsigned int version);
-int gnutls_x509_crt_set_key(gnutls_x509_crt crt, gnutls_x509_privkey key);
-int gnutls_x509_crt_set_ca_status(gnutls_x509_crt crt, unsigned int ca);
-int gnutls_x509_crt_set_subject_alternative_name(gnutls_x509_crt crt, gnutls_x509_subject_alt_name type,
+int gnutls_x509_crt_set_version(gnutls_x509_crt_t crt, unsigned int version);
+int gnutls_x509_crt_set_key(gnutls_x509_crt_t crt, gnutls_x509_privkey_t key);
+int gnutls_x509_crt_set_ca_status(gnutls_x509_crt_t crt, unsigned int ca);
+int gnutls_x509_crt_set_subject_alternative_name(gnutls_x509_crt_t crt, gnutls_x509_subject_alt_name_t type,
     const char* data_string);
-int gnutls_x509_crt_sign(gnutls_x509_crt crt, gnutls_x509_crt issuer, 
-    gnutls_x509_privkey issuer_key);
-int gnutls_x509_crt_set_activation_time(gnutls_x509_crt cert, time_t act_time);
-int gnutls_x509_crt_set_expiration_time(gnutls_x509_crt cert, time_t exp_time);
-int gnutls_x509_crt_set_serial(gnutls_x509_crt cert, const void* serial, 
+int gnutls_x509_crt_sign(gnutls_x509_crt_t crt, gnutls_x509_crt_t issuer, 
+    gnutls_x509_privkey_t issuer_key);
+int gnutls_x509_crt_set_activation_time(gnutls_x509_crt_t cert, time_t act_time);
+int gnutls_x509_crt_set_expiration_time(gnutls_x509_crt_t cert, time_t exp_time);
+int gnutls_x509_crt_set_serial(gnutls_x509_crt_t cert, const void* serial, 
     size_t serial_size);
 
-int gnutls_x509_crt_set_subject_key_id(gnutls_x509_crt cert, const void* id, 
+int gnutls_x509_crt_set_subject_key_id(gnutls_x509_crt_t cert, const void* id, 
     size_t id_size);
 
 
 /* RDN handling 
  */
-int gnutls_x509_rdn_get(const gnutls_datum * idn,
+int gnutls_x509_rdn_get(const gnutls_datum_t * idn,
     char *buf, size_t *sizeof_buf);
-int gnutls_x509_rdn_get_oid(const gnutls_datum * idn, 
+int gnutls_x509_rdn_get_oid(const gnutls_datum_t * idn, 
     int indx, void *buf, size_t * sizeof_buf);
 
-int gnutls_x509_rdn_get_by_oid(const gnutls_datum * idn, const char* oid,
+int gnutls_x509_rdn_get_by_oid(const gnutls_datum_t * idn, const char* oid,
     int indx, unsigned int raw_flag, void *buf, size_t *sizeof_buf);
 
 
 /* CRL handling functions */
 
 
-int gnutls_x509_crl_init(gnutls_x509_crl * crl);
-void gnutls_x509_crl_deinit(gnutls_x509_crl crl);
+int gnutls_x509_crl_init(gnutls_x509_crl_t * crl);
+void gnutls_x509_crl_deinit(gnutls_x509_crl_t crl);
 
-int gnutls_x509_crl_import(gnutls_x509_crl crl, const gnutls_datum * data, 
-    gnutls_x509_crt_fmt format);
-int gnutls_x509_crl_export( gnutls_x509_crl crl,
-    gnutls_x509_crt_fmt format, void* output_data, size_t* output_data_size);
+int gnutls_x509_crl_import(gnutls_x509_crl_t crl, const gnutls_datum_t * data, 
+    gnutls_x509_crt_fmt_t format);
+int gnutls_x509_crl_export( gnutls_x509_crl_t crl,
+    gnutls_x509_crt_fmt_t format, void* output_data, size_t* output_data_size);
 
-int gnutls_x509_crl_get_issuer_dn(const gnutls_x509_crl crl, 
+int gnutls_x509_crl_get_issuer_dn(const gnutls_x509_crl_t crl, 
     char *buf, size_t *sizeof_buf);
-int gnutls_x509_crl_get_issuer_dn_by_oid(gnutls_x509_crl crl, 
+int gnutls_x509_crl_get_issuer_dn_by_oid(gnutls_x509_crl_t crl, 
     const char* oid, int indx, 
     unsigned int raw_flag, void *buf, size_t *sizeof_buf);
-int gnutls_x509_crl_get_dn_oid(gnutls_x509_crl crl, 
+int gnutls_x509_crl_get_dn_oid(gnutls_x509_crl_t crl, 
     int indx, void *oid, size_t *sizeof_oid);
 
-int gnutls_x509_crl_get_signature_algorithm(gnutls_x509_crl crl);
-int gnutls_x509_crl_get_version(gnutls_x509_crl crl);
+int gnutls_x509_crl_get_signature_algorithm(gnutls_x509_crl_t crl);
+int gnutls_x509_crl_get_version(gnutls_x509_crl_t crl);
 
-time_t gnutls_x509_crl_get_this_update(gnutls_x509_crl crl);
-time_t gnutls_x509_crl_get_next_update(gnutls_x509_crl crl);
+time_t gnutls_x509_crl_get_this_update(gnutls_x509_crl_t crl);
+time_t gnutls_x509_crl_get_next_update(gnutls_x509_crl_t crl);
 
-int gnutls_x509_crl_get_crt_count(gnutls_x509_crl crl);
-int gnutls_x509_crl_get_crt_serial(gnutls_x509_crl crl, int index, unsigned char* serial,
-        size_t* serial_size, time_t* time);
+int gnutls_x509_crl_get_crt_count(gnutls_x509_crl_t crl);
+int gnutls_x509_crl_get_crt_serial(gnutls_x509_crl_t crl, int index, unsigned char* serial,
+    size_t* serial_size, time_t* time);
 #define gnutls_x509_crl_get_certificate_count gnutls_x509_crl_get_crt_count
 #define gnutls_x509_crl_get_certificate gnutls_x509_crl_get_crt_serial
 
-int gnutls_x509_crl_check_issuer( gnutls_x509_crl crl,
-    gnutls_x509_crt issuer);
+int gnutls_x509_crl_check_issuer( gnutls_x509_crl_t crl,
+    gnutls_x509_crt_t issuer);
 
 /* CRL writing.
  */
-int gnutls_x509_crl_set_version(gnutls_x509_crl crl, unsigned int version);
-int gnutls_x509_crl_sign(gnutls_x509_crl crl, gnutls_x509_crt issuer, 
-    gnutls_x509_privkey issuer_key);
-int gnutls_x509_crl_set_this_update(gnutls_x509_crl crl, time_t act_time);
-int gnutls_x509_crl_set_next_update(gnutls_x509_crl crl, time_t exp_time);
-int gnutls_x509_crl_set_crt_serial(gnutls_x509_crl crl, const void* serial, 
+int gnutls_x509_crl_set_version(gnutls_x509_crl_t crl, unsigned int version);
+int gnutls_x509_crl_sign(gnutls_x509_crl_t crl, gnutls_x509_crt_t issuer, 
+    gnutls_x509_privkey_t issuer_key);
+int gnutls_x509_crl_set_this_update(gnutls_x509_crl_t crl, time_t act_time);
+int gnutls_x509_crl_set_next_update(gnutls_x509_crl_t crl, time_t exp_time);
+int gnutls_x509_crl_set_crt_serial(gnutls_x509_crl_t crl, const void* serial, 
     size_t serial_size, time_t revocation_time);
-int gnutls_x509_crl_set_crt(gnutls_x509_crl crl, gnutls_x509_crt crt,
+int gnutls_x509_crl_set_crt(gnutls_x509_crl_t crl, gnutls_x509_crt_t crt,
     time_t revocation_time);
 
 
@@ -251,31 +251,31 @@ int gnutls_x509_crl_set_crt(gnutls_x509_crl crl, gnutls_x509_crt crt,
  */
 
 struct gnutls_pkcs7_int;
-typedef struct gnutls_pkcs7_int* gnutls_pkcs7;
+typedef struct gnutls_pkcs7_int* gnutls_pkcs7_t;
 
 
-int gnutls_pkcs7_init(gnutls_pkcs7 * pkcs7);
-void gnutls_pkcs7_deinit(gnutls_pkcs7 pkcs7);
-int gnutls_pkcs7_import(gnutls_pkcs7 pkcs7, const gnutls_datum * data,
-    gnutls_x509_crt_fmt format);
-int gnutls_pkcs7_export( gnutls_pkcs7 pkcs7,
-    gnutls_x509_crt_fmt format, void* output_data, size_t* output_data_size);
+int gnutls_pkcs7_init(gnutls_pkcs7_t * pkcs7);
+void gnutls_pkcs7_deinit(gnutls_pkcs7_t pkcs7);
+int gnutls_pkcs7_import(gnutls_pkcs7_t pkcs7, const gnutls_datum_t * data,
+    gnutls_x509_crt_fmt_t format);
+int gnutls_pkcs7_export( gnutls_pkcs7_t pkcs7,
+    gnutls_x509_crt_fmt_t format, void* output_data, size_t* output_data_size);
 
-int gnutls_pkcs7_get_crt_count( gnutls_pkcs7 pkcs7);
-int gnutls_pkcs7_get_crt_raw(gnutls_pkcs7 pkcs7, int indx, 
+int gnutls_pkcs7_get_crt_count( gnutls_pkcs7_t pkcs7);
+int gnutls_pkcs7_get_crt_raw(gnutls_pkcs7_t pkcs7, int indx, 
     void* certificate, size_t* certificate_size);
 
-int gnutls_pkcs7_set_crt_raw(gnutls_pkcs7 pkcs7, const gnutls_datum* crt);
-int gnutls_pkcs7_set_crt(gnutls_pkcs7 pkcs7, gnutls_x509_crt crt);
-int gnutls_pkcs7_delete_crt(gnutls_pkcs7 pkcs7, int indx);
+int gnutls_pkcs7_set_crt_raw(gnutls_pkcs7_t pkcs7, const gnutls_datum_t* crt);
+int gnutls_pkcs7_set_crt(gnutls_pkcs7_t pkcs7, gnutls_x509_crt_t crt);
+int gnutls_pkcs7_delete_crt(gnutls_pkcs7_t pkcs7, int indx);
 
-int gnutls_pkcs7_get_crl_raw(gnutls_pkcs7 pkcs7, 
+int gnutls_pkcs7_get_crl_raw(gnutls_pkcs7_t pkcs7, 
     int indx, void* crl, size_t* crl_size);
-int gnutls_pkcs7_get_crl_count(gnutls_pkcs7 pkcs7);
+int gnutls_pkcs7_get_crl_count(gnutls_pkcs7_t pkcs7);
 
-int gnutls_pkcs7_set_crl_raw(gnutls_pkcs7 pkcs7, const gnutls_datum* crt);
-int gnutls_pkcs7_set_crl(gnutls_pkcs7 pkcs7, gnutls_x509_crl crl);
-int gnutls_pkcs7_delete_crl(gnutls_pkcs7 pkcs7, int indx);
+int gnutls_pkcs7_set_crl_raw(gnutls_pkcs7_t pkcs7, const gnutls_datum_t* crt);
+int gnutls_pkcs7_set_crl(gnutls_pkcs7_t pkcs7, gnutls_x509_crl_t crl);
+int gnutls_pkcs7_delete_crl(gnutls_pkcs7_t pkcs7, int indx);
 
 /* X.509 Certificate verification functions.
  */
@@ -290,32 +290,32 @@ typedef enum gnutls_certificate_verify_flags {
 					  */
 } gnutls_certificate_verify_flags;
 
-int gnutls_x509_crt_check_issuer( gnutls_x509_crt cert,
-    gnutls_x509_crt issuer);
+int gnutls_x509_crt_check_issuer( gnutls_x509_crt_t cert,
+    gnutls_x509_crt_t issuer);
 
-int gnutls_x509_crt_list_verify( gnutls_x509_crt* cert_list, int cert_list_length, 
-    const gnutls_x509_crt * CA_list, int CA_list_length, 
-    const gnutls_x509_crl* CRL_list, int CRL_list_length, 
+int gnutls_x509_crt_list_verify( gnutls_x509_crt_t* cert_list, int cert_list_length, 
+    const gnutls_x509_crt_t * CA_list, int CA_list_length, 
+    const gnutls_x509_crl_t* CRL_list, int CRL_list_length, 
     unsigned int flags, unsigned int *verify);
 
-int gnutls_x509_crt_verify( gnutls_x509_crt cert,
-    const gnutls_x509_crt *CA_list, int CA_list_length,
+int gnutls_x509_crt_verify( gnutls_x509_crt_t cert,
+    const gnutls_x509_crt_t *CA_list, int CA_list_length,
     unsigned int flags, unsigned int *verify);
-int gnutls_x509_crl_verify( gnutls_x509_crl crl,
-    const gnutls_x509_crt *CA_list, int CA_list_length,
+int gnutls_x509_crl_verify( gnutls_x509_crl_t crl,
+    const gnutls_x509_crt_t *CA_list, int CA_list_length,
     unsigned int flags, unsigned int *verify);
 
-int gnutls_x509_crt_check_revocation(gnutls_x509_crt cert,
-    const gnutls_x509_crl * crl_list,
+int gnutls_x509_crt_check_revocation(gnutls_x509_crt_t cert,
+    const gnutls_x509_crl_t * crl_list,
     int crl_list_length);
 
-int gnutls_x509_crt_get_fingerprint(gnutls_x509_crt cert, 
-    gnutls_digest_algorithm algo, void *buf,
+int gnutls_x509_crt_get_fingerprint(gnutls_x509_crt_t cert, 
+    gnutls_digest_algorithm_t algo, void *buf,
     size_t *sizeof_buf);
 
-int gnutls_x509_crt_get_key_purpose_oid(gnutls_x509_crt cert, 
+int gnutls_x509_crt_get_key_purpose_oid(gnutls_x509_crt_t cert, 
     int indx, void *oid, size_t *sizeof_oid, unsigned int* critical);
-int gnutls_x509_crt_set_key_purpose_oid(gnutls_x509_crt cert, 
+int gnutls_x509_crt_set_key_purpose_oid(gnutls_x509_crt_t cert, 
     const void *oid, unsigned int critical);
 
 /* Private key handling
@@ -323,7 +323,7 @@ int gnutls_x509_crt_set_key_purpose_oid(gnutls_x509_crt cert,
 
 /* Flags for the gnutls_x509_privkey_export_pkcs8() function.
  */
-typedef enum gnutls_pkcs_encrypt_flags {
+typedef enum gnutls_pkcs_encrypt_flags_t {
     GNUTLS_PKCS_PLAIN=1,  /* if set the private key will not
                            * be encrypted.
                            */
@@ -331,91 +331,91 @@ typedef enum gnutls_pkcs_encrypt_flags {
     GNUTLS_PKCS_USE_PKCS12_ARCFOUR=4,
     GNUTLS_PKCS_USE_PKCS12_RC2_40=8,
     GNUTLS_PKCS_USE_PBES2_3DES=16
-} gnutls_pkcs_encrypt_flags;
+} gnutls_pkcs_encrypt_flags_t;
 
 #define GNUTLS_PKCS8_PLAIN GNUTLS_PKCS_PLAIN
 #define GNUTLS_PKCS8_USE_PKCS12_3DES GNUTLS_PKCS_USE_PKCS12_3DES
 #define GNUTLS_PKCS8_USE_PKCS12_ARCFOUR GNUTLS_PKCS_USE_PKCS12_ARCFOUR
 #define GNUTLS_PKCS8_USE_PKCS12_RC2_40 GNUTLS_PKCS_USE_PKCS12_RC2_40
 
-int gnutls_x509_privkey_init(gnutls_x509_privkey * key);
-void gnutls_x509_privkey_deinit(gnutls_x509_privkey key);
-int gnutls_x509_privkey_cpy(gnutls_x509_privkey dst, gnutls_x509_privkey src);
-int gnutls_x509_privkey_import(gnutls_x509_privkey key, const gnutls_datum * data,
-    gnutls_x509_crt_fmt format);
-int gnutls_x509_privkey_import_pkcs8(gnutls_x509_privkey key, const gnutls_datum * data,
-    gnutls_x509_crt_fmt format, const char * pass, unsigned int flags);
-int gnutls_x509_privkey_import_rsa_raw(gnutls_x509_privkey privkey, 
-    const gnutls_datum *m, const gnutls_datum *e,
-    const gnutls_datum *d, const gnutls_datum *p, const gnutls_datum *q, 
-    const gnutls_datum *u);
-
-int gnutls_x509_privkey_export_dsa_raw(gnutls_x509_privkey key,
-    gnutls_datum * p, gnutls_datum *q,
-    gnutls_datum *g, gnutls_datum *y, gnutls_datum* x);
-int gnutls_x509_privkey_import_dsa_raw(gnutls_x509_privkey key, 
-    const gnutls_datum* p, const gnutls_datum* q,
-    const gnutls_datum* g, const gnutls_datum* y, 
-    const gnutls_datum* x);
-
-int gnutls_x509_privkey_get_pk_algorithm( gnutls_x509_privkey key);
-int gnutls_x509_privkey_get_key_id( gnutls_x509_privkey key, unsigned int flags,
+int gnutls_x509_privkey_init(gnutls_x509_privkey_t * key);
+void gnutls_x509_privkey_deinit(gnutls_x509_privkey_t key);
+int gnutls_x509_privkey_cpy(gnutls_x509_privkey_t dst, gnutls_x509_privkey_t src);
+int gnutls_x509_privkey_import(gnutls_x509_privkey_t key, const gnutls_datum_t * data,
+    gnutls_x509_crt_fmt_t format);
+int gnutls_x509_privkey_import_pkcs8(gnutls_x509_privkey_t key, const gnutls_datum_t * data,
+    gnutls_x509_crt_fmt_t format, const char * pass, unsigned int flags);
+int gnutls_x509_privkey_import_rsa_raw(gnutls_x509_privkey_t privkey, 
+    const gnutls_datum_t *m, const gnutls_datum_t *e,
+    const gnutls_datum_t *d, const gnutls_datum_t *p, const gnutls_datum_t *q, 
+    const gnutls_datum_t *u);
+
+int gnutls_x509_privkey_export_dsa_raw(gnutls_x509_privkey_t key,
+    gnutls_datum_t * p, gnutls_datum_t *q,
+    gnutls_datum_t *g, gnutls_datum_t *y, gnutls_datum_t* x);
+int gnutls_x509_privkey_import_dsa_raw(gnutls_x509_privkey_t key, 
+    const gnutls_datum_t* p, const gnutls_datum_t* q,
+    const gnutls_datum_t* g, const gnutls_datum_t* y, 
+    const gnutls_datum_t* x);
+
+int gnutls_x509_privkey_get_pk_algorithm( gnutls_x509_privkey_t key);
+int gnutls_x509_privkey_get_key_id( gnutls_x509_privkey_t key, unsigned int flags,
     unsigned char* output_data, size_t* output_data_size);
 
-int gnutls_x509_privkey_generate( gnutls_x509_privkey key, gnutls_pk_algorithm algo,
+int gnutls_x509_privkey_generate( gnutls_x509_privkey_t key, gnutls_pk_algorithm_t algo,
     unsigned int bits, unsigned int flags);
 
-int gnutls_x509_privkey_export( gnutls_x509_privkey key,
-    gnutls_x509_crt_fmt format, void* output_data, size_t* output_data_size);
-int gnutls_x509_privkey_export_pkcs8( gnutls_x509_privkey key,
-    gnutls_x509_crt_fmt format, const char* password, unsigned int flags,
+int gnutls_x509_privkey_export( gnutls_x509_privkey_t key,
+    gnutls_x509_crt_fmt_t format, void* output_data, size_t* output_data_size);
+int gnutls_x509_privkey_export_pkcs8( gnutls_x509_privkey_t key,
+    gnutls_x509_crt_fmt_t format, const char* password, unsigned int flags,
     void* output_data, size_t* output_data_size);
-int gnutls_x509_privkey_export_rsa_raw(gnutls_x509_privkey key,
-    gnutls_datum * m, gnutls_datum *e,
-    gnutls_datum *d, gnutls_datum *p, gnutls_datum* q, 
-    gnutls_datum* u);
+int gnutls_x509_privkey_export_rsa_raw(gnutls_x509_privkey_t key,
+    gnutls_datum_t * m, gnutls_datum_t *e,
+    gnutls_datum_t *d, gnutls_datum_t *p, gnutls_datum_t* q, 
+    gnutls_datum_t* u);
 
 /* signing stuff.
  */
-int gnutls_x509_privkey_sign_data( gnutls_x509_privkey key, gnutls_digest_algorithm digest,
-    unsigned int flags, const gnutls_datum* data,
+int gnutls_x509_privkey_sign_data( gnutls_x509_privkey_t key, gnutls_digest_algorithm_t digest,
+    unsigned int flags, const gnutls_datum_t* data,
     void* signature, size_t* signature_size);
-int gnutls_x509_privkey_verify_data( gnutls_x509_privkey key, unsigned int flags, 
-    const gnutls_datum* data, const gnutls_datum* signature);
-int gnutls_x509_crt_verify_data( gnutls_x509_crt crt, unsigned int flags, 
-    const gnutls_datum* data, const gnutls_datum* signature);
+int gnutls_x509_privkey_verify_data( gnutls_x509_privkey_t key, unsigned int flags, 
+    const gnutls_datum_t* data, const gnutls_datum_t* signature);
+int gnutls_x509_crt_verify_data( gnutls_x509_crt_t crt, unsigned int flags, 
+    const gnutls_datum_t* data, const gnutls_datum_t* signature);
 
 
 /* Certificate request stuff
  */
 struct gnutls_x509_crq_int;
-typedef struct gnutls_x509_crq_int* gnutls_x509_crq;
-
-int gnutls_x509_crq_init(gnutls_x509_crq * crq);
-void gnutls_x509_crq_deinit(gnutls_x509_crq crq);
-int gnutls_x509_crq_import(gnutls_x509_crq crq, const gnutls_datum * data,
-    gnutls_x509_crt_fmt format);
-int gnutls_x509_crq_get_pk_algorithm( gnutls_x509_crq crq, unsigned int* bits);
-int gnutls_x509_crq_get_dn(gnutls_x509_crq crq, char *buf,
+typedef struct gnutls_x509_crq_int* gnutls_x509_crq_t;
+
+int gnutls_x509_crq_init(gnutls_x509_crq_t * crq);
+void gnutls_x509_crq_deinit(gnutls_x509_crq_t crq);
+int gnutls_x509_crq_import(gnutls_x509_crq_t crq, const gnutls_datum_t * data,
+    gnutls_x509_crt_fmt_t format);
+int gnutls_x509_crq_get_pk_algorithm( gnutls_x509_crq_t crq, unsigned int* bits);
+int gnutls_x509_crq_get_dn(gnutls_x509_crq_t crq, char *buf,
     size_t *sizeof_buf);
-int gnutls_x509_crq_get_dn_oid(gnutls_x509_crq crq,
+int gnutls_x509_crq_get_dn_oid(gnutls_x509_crq_t crq,
     int indx, void *oid, size_t *sizeof_oid);
-int gnutls_x509_crq_get_dn_by_oid(gnutls_x509_crq crq, const char* oid, 
+int gnutls_x509_crq_get_dn_by_oid(gnutls_x509_crq_t crq, const char* oid, 
     int indx, unsigned int raw_flag, void *buf, size_t *sizeof_buf);
-int gnutls_x509_crq_set_dn_by_oid(gnutls_x509_crq crq, const char* oid, 
+int gnutls_x509_crq_set_dn_by_oid(gnutls_x509_crq_t crq, const char* oid, 
     unsigned int raw_flag, const void *name, unsigned int sizeof_name);
-int gnutls_x509_crq_set_version(gnutls_x509_crq crq, unsigned int version);
-int gnutls_x509_crq_set_key(gnutls_x509_crq crq, gnutls_x509_privkey key);
-int gnutls_x509_crq_sign(gnutls_x509_crq crq, gnutls_x509_privkey key);
+int gnutls_x509_crq_set_version(gnutls_x509_crq_t crq, unsigned int version);
+int gnutls_x509_crq_set_key(gnutls_x509_crq_t crq, gnutls_x509_privkey_t key);
+int gnutls_x509_crq_sign(gnutls_x509_crq_t crq, gnutls_x509_privkey_t key);
 
-int gnutls_x509_crq_set_challenge_password(gnutls_x509_crq crq, const char* pass);
-int gnutls_x509_crq_get_challenge_password(gnutls_x509_crq crq, 
+int gnutls_x509_crq_set_challenge_password(gnutls_x509_crq_t crq, const char* pass);
+int gnutls_x509_crq_get_challenge_password(gnutls_x509_crq_t crq, 
     const char* pass, size_t* sizeof_pass);
 
-int gnutls_x509_crq_export( gnutls_x509_crq crq,
-    gnutls_x509_crt_fmt format, void* output_data, size_t* output_data_size);
+int gnutls_x509_crq_export( gnutls_x509_crq_t crq,
+    gnutls_x509_crt_fmt_t format, void* output_data, size_t* output_data_size);
 
-int gnutls_x509_crt_set_crq(gnutls_x509_crt crt, gnutls_x509_crq crq);
+int gnutls_x509_crt_set_crq(gnutls_x509_crt_t crt, gnutls_x509_crq_t crq);
 
 
 #ifdef __cplusplus
diff --git a/lib/auth_anon.c b/lib/auth_anon.c
index 6d2feecd5b..efddc5c773 100644
--- a/lib/auth_anon.c
+++ b/lib/auth_anon.c
@@ -38,9 +38,9 @@
 #include <gnutls_state.h>
 #include <auth_dh_common.h>
 
-static int gen_anon_server_kx(gnutls_session, opaque **);
-static int proc_anon_client_kx(gnutls_session, opaque *, size_t);
-static int proc_anon_server_kx(gnutls_session, opaque *, size_t);
+static int gen_anon_server_kx(gnutls_session_t, opaque **);
+static int proc_anon_client_kx(gnutls_session_t, opaque *, size_t);
+static int proc_anon_server_kx(gnutls_session_t, opaque *, size_t);
 
 const mod_auth_st anon_auth_struct = {
     "ANON",
@@ -59,13 +59,13 @@ const mod_auth_st anon_auth_struct = {
     NULL
 };
 
-static int gen_anon_server_kx(gnutls_session session, opaque ** data)
+static int gen_anon_server_kx(gnutls_session_t session, opaque ** data)
 {
     mpi_t g, p;
     const mpi_t *mpis;
     int ret;
-    gnutls_dh_params dh_params;
-    const gnutls_anon_server_credentials cred;
+    gnutls_dh_params_t dh_params;
+    const gnutls_anon_server_credentials_t cred;
 
     cred = _gnutls_get_cred(session->key, GNUTLS_CRD_ANON, NULL);
     if (cred == NULL) {
@@ -101,14 +101,14 @@ static int gen_anon_server_kx(gnutls_session session, opaque ** data)
 }
 
 
-static int proc_anon_client_kx(gnutls_session session, opaque * data,
+static int proc_anon_client_kx(gnutls_session_t session, opaque * data,
 			       size_t _data_size)
 {
-    const gnutls_anon_server_credentials cred;
+    const gnutls_anon_server_credentials_t cred;
     int bits;
     int ret;
     mpi_t p, g;
-    gnutls_dh_params dh_params;
+    gnutls_dh_params_t dh_params;
     const mpi_t *mpis;
 
     bits = _gnutls_dh_get_allowed_prime_bits(session);
@@ -136,7 +136,7 @@ static int proc_anon_client_kx(gnutls_session session, opaque * data,
 
 }
 
-int proc_anon_server_kx(gnutls_session session, opaque * data,
+int proc_anon_server_kx(gnutls_session_t session, opaque * data,
 			size_t _data_size)
 {
 
diff --git a/lib/auth_anon.h b/lib/auth_anon.h
index c722826663..32fbfdfa25 100644
--- a/lib/auth_anon.h
+++ b/lib/auth_anon.h
@@ -3,15 +3,15 @@
 #include <auth_dh_common.h>
 
 typedef struct {
-    gnutls_dh_params dh_params;
+    gnutls_dh_params_t dh_params;
     /* this callback is used to retrieve the DH or RSA
      * parameters.
      */
     gnutls_params_function *params_func;
 } anon_server_credentials_st;
-#define gnutls_anon_server_credentials anon_server_credentials_st*
+#define gnutls_anon_server_credentials_t anon_server_credentials_st*
 
-#define gnutls_anon_client_credentials void*
+#define gnutls_anon_client_credentials_t void*
 
 typedef struct anon_client_auth_info_st {
     dh_info_t dh;
@@ -22,6 +22,6 @@ typedef anon_client_auth_info_t anon_server_auth_info_t;
 typedef struct anon_client_auth_info_st anon_client_auth_info_st;
 typedef anon_client_auth_info_st anon_server_auth_info_st;
 
-gnutls_dh_params _gnutls_anon_get_dh_params(const
-					    gnutls_anon_server_credentials
-					    sc, gnutls_session session);
+gnutls_dh_params_t _gnutls_anon_get_dh_params(const
+					    gnutls_anon_server_credentials_t
+					    sc, gnutls_session_t session);
diff --git a/lib/auth_cert.c b/lib/auth_cert.c
index 57cfc4c62f..e67678e80a 100644
--- a/lib/auth_cert.c
+++ b/lib/auth_cert.c
@@ -45,11 +45,11 @@
 #include <gnutls_extra.h>
 #include "debug.h"
 
-static gnutls_cert *alloc_and_load_x509_certs(gnutls_x509_crt * certs,
+static gnutls_cert *alloc_and_load_x509_certs(gnutls_x509_crt_t * certs,
 					      uint);
-static gnutls_privkey *alloc_and_load_x509_key(gnutls_x509_privkey key);
-static gnutls_cert *alloc_and_load_pgp_certs(gnutls_openpgp_key cert);
-static gnutls_privkey *alloc_and_load_pgp_key(const gnutls_openpgp_privkey
+static gnutls_privkey *alloc_and_load_x509_key(gnutls_x509_privkey_t key);
+static gnutls_cert *alloc_and_load_pgp_certs(gnutls_openpgp_key_t cert);
+static gnutls_privkey *alloc_and_load_pgp_key(const gnutls_openpgp_privkey_t
 					      key);
 
 
@@ -71,7 +71,7 @@ int _gnutls_copy_certificate_auth_info(cert_auth_info_t info,
     }
 
     info->raw_certificate_list =
-	gnutls_calloc(1, sizeof(gnutls_datum) * ncerts);
+	gnutls_calloc(1, sizeof(gnutls_datum_t) * ncerts);
     if (info->raw_certificate_list == NULL) {
 	gnutls_assert();
 	return GNUTLS_E_MEMORY_ERROR;
@@ -111,9 +111,9 @@ int _gnutls_copy_certificate_auth_info(cert_auth_info_t info,
  * -1 otherwise.
  */
 inline
-    static int _gnutls_check_pk_algo_in_list(const gnutls_pk_algorithm *
+    static int _gnutls_check_pk_algo_in_list(const gnutls_pk_algorithm_t *
 					     pk_algos, int pk_algos_length,
-					     gnutls_pk_algorithm
+					     gnutls_pk_algorithm_t
 					     algo_to_check)
 {
     int i;
@@ -130,7 +130,7 @@ inline
  * specified in cert.
  */
 static int _gnutls_cert_get_issuer_dn(gnutls_cert * cert,
-				      gnutls_datum * odn)
+				      gnutls_datum_t * odn)
 {
     ASN1_TYPE dn;
     int len, result;
@@ -177,13 +177,13 @@ static int _gnutls_cert_get_issuer_dn(gnutls_cert * cert,
  * That is to guess which certificate to use, based on the 
  * CAs and sign algorithms supported by the peer server.
  */
-static int _find_x509_cert(const gnutls_certificate_credentials cred,
+static int _find_x509_cert(const gnutls_certificate_credentials_t cred,
 			   opaque * _data, size_t _data_size,
-			   const gnutls_pk_algorithm * pk_algos,
+			   const gnutls_pk_algorithm_t * pk_algos,
 			   int pk_algos_length, int *indx)
 {
     uint size;
-    gnutls_datum odn;
+    gnutls_datum_t odn;
     opaque *data = _data;
     ssize_t data_size = _data_size;
     uint i, j;
@@ -242,8 +242,8 @@ static int _find_x509_cert(const gnutls_certificate_credentials cred,
 
 /* Locates the most appropriate openpgp cert
  */
-static int _find_openpgp_cert(const gnutls_certificate_credentials cred,
-			      gnutls_pk_algorithm * pk_algos,
+static int _find_openpgp_cert(const gnutls_certificate_credentials_t cred,
+			      gnutls_pk_algorithm_t * pk_algos,
 			      int pk_algos_length, int *indx)
 {
     uint i, j;
@@ -274,7 +274,7 @@ static int _find_openpgp_cert(const gnutls_certificate_credentials cred,
 /* Returns the number of issuers in the server's
  * certificate request packet.
  */
-static int get_issuers_num(gnutls_session session, opaque * data,
+static int get_issuers_num(gnutls_session_t session, opaque * data,
 			   ssize_t data_size)
 {
     int issuers_dn_len = 0, result;
@@ -320,8 +320,8 @@ static int get_issuers_num(gnutls_session session, opaque * data,
 /* Returns the issuers in the server's certificate request
  * packet.
  */
-static int get_issuers(gnutls_session session,
-		       gnutls_datum * issuers_dn, int issuers_len,
+static int get_issuers(gnutls_session_t session,
+		       gnutls_datum_t * issuers_dn, int issuers_len,
 		       opaque * data, size_t data_size)
 {
     int i;
@@ -362,10 +362,10 @@ OPENPGP_PRIVKEY_DEINIT _E_gnutls_openpgp_privkey_deinit;
 
 /* Calls the client get callback.
  */
-static int call_get_cert_callback(gnutls_session session,
-				  gnutls_datum * issuers_dn,
+static int call_get_cert_callback(gnutls_session_t session,
+				  gnutls_datum_t * issuers_dn,
 				  int issuers_dn_length,
-				  gnutls_pk_algorithm * pk_algos,
+				  gnutls_pk_algorithm_t * pk_algos,
 				  int pk_algos_length)
 {
     uint i;
@@ -373,8 +373,8 @@ static int call_get_cert_callback(gnutls_session session,
     gnutls_privkey *local_key = NULL;
     gnutls_retr_st st;
     int ret;
-    gnutls_certificate_type type = gnutls_certificate_type_get(session);
-    const gnutls_certificate_credentials cred;
+    gnutls_certificate_type_t type = gnutls_certificate_type_get(session);
+    const gnutls_certificate_credentials_t cred;
 
     cred = _gnutls_get_cred(session->key, GNUTLS_CRD_CERTIFICATE, NULL);
     if (cred == NULL) {
@@ -464,18 +464,18 @@ static int call_get_cert_callback(gnutls_session session,
  * 20020128: added ability to select a certificate depending on the SIGN
  * algorithm (only in automatic mode).
  */
-static int _select_client_cert(gnutls_session session,
+static int _select_client_cert(gnutls_session_t session,
 			       opaque * _data, size_t _data_size,
-			       gnutls_pk_algorithm * pk_algos,
+			       gnutls_pk_algorithm_t * pk_algos,
 			       int pk_algos_length)
 {
     int result;
     int indx = -1;
-    const gnutls_certificate_credentials cred;
+    const gnutls_certificate_credentials_t cred;
     opaque *data = _data;
     ssize_t data_size = _data_size;
     int issuers_dn_length;
-    gnutls_datum *issuers_dn = NULL;
+    gnutls_datum_t *issuers_dn = NULL;
 
     cred = _gnutls_get_cred(session->key, GNUTLS_CRD_CERTIFICATE, NULL);
     if (cred == NULL) {
@@ -498,7 +498,7 @@ static int _select_client_cert(gnutls_session session,
 
 	    if (issuers_dn_length > 0) {
 		issuers_dn =
-		    gnutls_malloc(sizeof(gnutls_datum) *
+		    gnutls_malloc(sizeof(gnutls_datum_t) *
 				  issuers_dn_length);
 		if (issuers_dn == NULL) {
 		    gnutls_assert();
@@ -561,7 +561,7 @@ static int _select_client_cert(gnutls_session session,
 /* Generate client certificate
  */
 
-int _gnutls_gen_x509_crt(gnutls_session session, opaque ** data)
+int _gnutls_gen_x509_crt(gnutls_session_t session, opaque ** data)
 {
     int ret, i;
     opaque *pdata;
@@ -614,7 +614,7 @@ int _gnutls_gen_x509_crt(gnutls_session session, opaque ** data)
 
 enum PGPKeyDescriptorType { PGP_KEY_FINGERPRINT, PGP_KEY };
 
-int _gnutls_gen_openpgp_certificate(gnutls_session session, opaque ** data)
+int _gnutls_gen_openpgp_certificate(gnutls_session_t session, opaque ** data)
 {
     int ret;
     opaque *pdata;
@@ -663,7 +663,7 @@ OPENPGP_FINGERPRINT _E_gnutls_openpgp_fingerprint = NULL;
 OPENPGP_KEY_REQUEST _E_gnutls_openpgp_request_key = NULL;
 extern OPENPGP_RAW_KEY_TO_GCERT _E_gnutls_openpgp_raw_key_to_gcert;
 
-int _gnutls_gen_openpgp_certificate_fpr(gnutls_session session,
+int _gnutls_gen_openpgp_certificate_fpr(gnutls_session_t session,
 					opaque ** data)
 {
     int ret, packet_size;
@@ -727,7 +727,7 @@ int _gnutls_gen_openpgp_certificate_fpr(gnutls_session session,
 
 
 
-int _gnutls_gen_cert_client_certificate(gnutls_session session,
+int _gnutls_gen_cert_client_certificate(gnutls_session_t session,
 					opaque ** data)
 {
     switch (session->security_parameters.cert_type) {
@@ -746,7 +746,7 @@ int _gnutls_gen_cert_client_certificate(gnutls_session session,
     }
 }
 
-int _gnutls_gen_cert_server_certificate(gnutls_session session,
+int _gnutls_gen_cert_server_certificate(gnutls_session_t session,
 					opaque ** data)
 {
     switch (session->security_parameters.cert_type) {
@@ -764,18 +764,18 @@ int _gnutls_gen_cert_server_certificate(gnutls_session session,
  */
 
 #define CLEAR_CERTS for(x=0;x<peer_certificate_list_size;x++) _gnutls_gcert_deinit(&peer_certificate_list[x])
-int _gnutls_proc_x509_server_certificate(gnutls_session session,
+int _gnutls_proc_x509_server_certificate(gnutls_session_t session,
 					 opaque * data, size_t data_size)
 {
     int size, len, ret;
     opaque *p = data;
     cert_auth_info_t info;
-    const gnutls_certificate_credentials cred;
+    const gnutls_certificate_credentials_t cred;
     ssize_t dsize = data_size;
     int i, j, x;
     gnutls_cert *peer_certificate_list;
     int peer_certificate_list_size = 0;
-    gnutls_datum tmp;
+    gnutls_datum_t tmp;
 
     cred = _gnutls_get_cred(session->key, GNUTLS_CRD_CERTIFICATE, NULL);
     if (cred == NULL) {
@@ -891,19 +891,19 @@ int _gnutls_proc_x509_server_certificate(gnutls_session session,
 }
 
 #define CLEAR_CERTS for(x=0;x<peer_certificate_list_size;x++) _gnutls_gcert_deinit(&peer_certificate_list[x])
-int _gnutls_proc_openpgp_server_certificate(gnutls_session session,
+int _gnutls_proc_openpgp_server_certificate(gnutls_session_t session,
 					    opaque * data,
 					    size_t data_size)
 {
     int size, ret, len;
     opaque *p = data;
     cert_auth_info_t info;
-    const gnutls_certificate_credentials cred;
+    const gnutls_certificate_credentials_t cred;
     ssize_t dsize = data_size;
     int i, x;
     gnutls_cert *peer_certificate_list = NULL;
     int peer_certificate_list_size = 0;
-    gnutls_datum tmp, akey = { NULL, 0 };
+    gnutls_datum_t tmp, akey = { NULL, 0 };
 
     cred = _gnutls_get_cred(session->key, GNUTLS_CRD_CERTIFICATE, NULL);
     if (cred == NULL) {
@@ -1052,7 +1052,7 @@ int _gnutls_proc_openpgp_server_certificate(gnutls_session session,
 
 }
 
-int _gnutls_proc_cert_server_certificate(gnutls_session session,
+int _gnutls_proc_cert_server_certificate(gnutls_session_t session,
 					 opaque * data, size_t data_size)
 {
     switch (session->security_parameters.cert_type) {
@@ -1073,7 +1073,7 @@ typedef enum CertificateSigType { RSA_SIGN = 1, DSA_SIGN
 } CertificateSigType;
 
 /* Checks if we support the given signature algorithm 
- * (RSA or DSA). Returns the corresponding gnutls_pk_algorithm
+ * (RSA or DSA). Returns the corresponding gnutls_pk_algorithm_t
  * if true;
  */
 inline static
@@ -1089,16 +1089,16 @@ int _gnutls_check_supported_sign_algo(CertificateSigType algo)
     return -1;
 }
 
-int _gnutls_proc_cert_cert_req(gnutls_session session, opaque * data,
+int _gnutls_proc_cert_cert_req(gnutls_session_t session, opaque * data,
 			       size_t data_size)
 {
     int size, ret;
     opaque *p;
-    const gnutls_certificate_credentials cred;
+    const gnutls_certificate_credentials_t cred;
     cert_auth_info_t info;
     ssize_t dsize;
     int i, j;
-    gnutls_pk_algorithm pk_algos[MAX_SIGN_ALGOS];
+    gnutls_pk_algorithm_t pk_algos[MAX_SIGN_ALGOS];
     int pk_algos_length;
 
     cred = _gnutls_get_cred(session->key, GNUTLS_CRD_CERTIFICATE, NULL);
@@ -1169,14 +1169,14 @@ int _gnutls_proc_cert_cert_req(gnutls_session session, opaque * data,
     return 0;
 }
 
-int _gnutls_gen_cert_client_cert_vrfy(gnutls_session session,
+int _gnutls_gen_cert_client_cert_vrfy(gnutls_session_t session,
 				      opaque ** data)
 {
     int ret;
     gnutls_cert *apr_cert_list;
     gnutls_privkey *apr_pkey;
     int apr_cert_list_length, size;
-    gnutls_datum signature;
+    gnutls_datum_t signature;
 
     *data = NULL;
 
@@ -1216,13 +1216,13 @@ int _gnutls_gen_cert_client_cert_vrfy(gnutls_session session,
     return size + 2;
 }
 
-int _gnutls_proc_cert_client_cert_vrfy(gnutls_session session,
+int _gnutls_proc_cert_client_cert_vrfy(gnutls_session_t session,
 				       opaque * data, size_t data_size)
 {
     int size, ret;
     ssize_t dsize = data_size;
     opaque *pdata = data;
-    gnutls_datum sig;
+    gnutls_datum_t sig;
     cert_auth_info_t info = _gnutls_get_auth_info(session);
     gnutls_cert peer_cert;
 
@@ -1262,10 +1262,10 @@ int _gnutls_proc_cert_client_cert_vrfy(gnutls_session session,
 }
 
 #define CERTTYPE_SIZE 3
-int _gnutls_gen_cert_server_cert_req(gnutls_session session,
+int _gnutls_gen_cert_server_cert_req(gnutls_session_t session,
 				     opaque ** data)
 {
-    const gnutls_certificate_credentials cred;
+    const gnutls_certificate_credentials_t cred;
     int size;
     opaque *pdata;
 
@@ -1280,7 +1280,7 @@ int _gnutls_gen_cert_server_cert_req(gnutls_session session,
 	return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
     }
 
-    size = CERTTYPE_SIZE + 2;	/* 2 for gnutls_certificate_type + 2 for size of rdn_seq 
+    size = CERTTYPE_SIZE + 2;	/* 2 for gnutls_certificate_type_t + 2 for size of rdn_seq 
 				 */
 
     if (session->security_parameters.cert_type == GNUTLS_CRT_X509 &&
@@ -1318,7 +1318,7 @@ int _gnutls_gen_cert_server_cert_req(gnutls_session session,
  * It is normal to return 0 with no certificates in client side.
  *
  */
-int _gnutls_get_selected_cert(gnutls_session session,
+int _gnutls_get_selected_cert(gnutls_session_t session,
 			      gnutls_cert ** apr_cert_list,
 			      int *apr_cert_list_length,
 			      gnutls_privkey ** apr_pkey)
@@ -1358,7 +1358,7 @@ int _gnutls_get_selected_cert(gnutls_session session,
 /* converts the given x509 certificate to gnutls_cert* and allocates
  * space for them.
  */
-static gnutls_cert *alloc_and_load_x509_certs(gnutls_x509_crt * certs,
+static gnutls_cert *alloc_and_load_x509_certs(gnutls_x509_crt_t * certs,
 					      uint ncerts)
 {
     gnutls_cert *local_certs;
@@ -1395,7 +1395,7 @@ static gnutls_cert *alloc_and_load_x509_certs(gnutls_x509_crt * certs,
 /* converts the given x509 key to gnutls_privkey* and allocates
  * space for it.
  */
-static gnutls_privkey *alloc_and_load_x509_key(gnutls_x509_privkey key)
+static gnutls_privkey *alloc_and_load_x509_key(gnutls_x509_privkey_t key)
 {
     gnutls_privkey *local_key;
     int ret = 0;
@@ -1425,7 +1425,7 @@ OPENPGP_PRIVKEY_TO_GKEY _E_gnutls_openpgp_privkey_to_gkey;
 /* converts the given pgp certificate to gnutls_cert* and allocates
  * space for them.
  */
-static gnutls_cert *alloc_and_load_pgp_certs(gnutls_openpgp_key cert)
+static gnutls_cert *alloc_and_load_pgp_certs(gnutls_openpgp_key_t cert)
 {
     gnutls_cert *local_certs;
     int ret = 0;
@@ -1463,7 +1463,7 @@ static gnutls_cert *alloc_and_load_pgp_certs(gnutls_openpgp_key cert)
 /* converts the given raw key to gnutls_privkey* and allocates
  * space for it.
  */
-static gnutls_privkey *alloc_and_load_pgp_key(const gnutls_openpgp_privkey
+static gnutls_privkey *alloc_and_load_pgp_key(const gnutls_openpgp_privkey_t
 					      key)
 {
     gnutls_privkey *local_key;
@@ -1493,7 +1493,7 @@ static gnutls_privkey *alloc_and_load_pgp_key(const gnutls_openpgp_privkey
 }
 
 
-void _gnutls_selected_certs_deinit(gnutls_session session)
+void _gnutls_selected_certs_deinit(gnutls_session_t session)
 {
     if (session->internals.selected_need_free != 0) {
 	int i;
@@ -1511,7 +1511,7 @@ void _gnutls_selected_certs_deinit(gnutls_session session)
     return;
 }
 
-void _gnutls_selected_certs_set(gnutls_session session,
+void _gnutls_selected_certs_set(gnutls_session_t session,
 				gnutls_cert * certs, int ncerts,
 				gnutls_privkey * key, int need_free)
 {
@@ -1535,12 +1535,12 @@ void _gnutls_selected_certs_set(gnutls_session session,
  * selected certificate will be in session->internals.selected_*.
  *
  */
-int _gnutls_server_select_cert(gnutls_session session,
-			       gnutls_pk_algorithm requested_algo)
+int _gnutls_server_select_cert(gnutls_session_t session,
+			       gnutls_pk_algorithm_t requested_algo)
 {
     uint i;
     int index, ret;
-    const gnutls_certificate_credentials cred;
+    const gnutls_certificate_credentials_t cred;
 
     cred = _gnutls_get_cred(session->key, GNUTLS_CRD_CERTIFICATE, NULL);
     if (cred == NULL) {
diff --git a/lib/auth_cert.h b/lib/auth_cert.h
index d7a0ebcb33..11a3197756 100644
--- a/lib/auth_cert.h
+++ b/lib/auth_cert.h
@@ -7,43 +7,35 @@
 #include "../libextra/openpgp/openpgp.h"
 
 typedef struct retr_st {
-    gnutls_certificate_type type;
+    gnutls_certificate_type_t type;
     union cert {
-	gnutls_x509_crt *x509;
-	gnutls_openpgp_key pgp;
+	gnutls_x509_crt_t *x509;
+	gnutls_openpgp_key_t pgp;
     } cert;
     uint ncerts;
 
     union key {
-	gnutls_x509_privkey x509;
-	gnutls_openpgp_privkey pgp;
+	gnutls_x509_privkey_t x509;
+	gnutls_openpgp_privkey_t pgp;
     } key;
 
     uint deinit_all;
 } gnutls_retr_st;
 
-typedef int gnutls_certificate_client_retrieve_function(gnutls_session,
-							const gnutls_datum
-							* req_ca_rdn,
-							int nreqs,
-							const
-							gnutls_pk_algorithm
-							* pk_algos,
-							int
-							pk_algos_length,
-							gnutls_retr_st *);
+typedef int gnutls_certificate_client_retrieve_function(gnutls_session_t,
+    const gnutls_datum_t *req_ca_rdn, int nreqs,
+    const gnutls_pk_algorithm_t* pk_algos, int pk_algos_length,
+    gnutls_retr_st *);
 
 typedef int gnutls_certificate_server_retrieve_function(struct
-							gnutls_session_int
-							*,
-							gnutls_retr_st *);
+    gnutls_session_int*, gnutls_retr_st *);
 
 /* This structure may be complex, but it's the only way to
  * support a server that has multiple certificates
  */
 typedef struct {
-    gnutls_dh_params dh_params;
-    gnutls_rsa_params rsa_params;
+    gnutls_dh_params_t dh_params;
+    gnutls_rsa_params_t rsa_params;
     /* this callback is used to retrieve the DH or RSA
      * parameters.
      */
@@ -71,7 +63,7 @@ typedef struct {
 
     /* OpenPGP specific stuff */
 
-    gnutls_datum keyring;
+    gnutls_datum_t keyring;
     char *pgp_key_server;
     int pgp_key_server_port;
 
@@ -79,11 +71,11 @@ typedef struct {
 
     /* X509 specific stuff */
 
-    gnutls_x509_crt *x509_ca_list;
+    gnutls_x509_crt_t *x509_ca_list;
     uint x509_ncas;		/* number of CAs in the ca_list 
 				 */
 
-    gnutls_x509_crl *x509_crl_list;
+    gnutls_x509_crl_t *x509_crl_list;
     uint x509_ncrls;		/* number of CRLs in the crl_list 
 				 */
 
@@ -96,13 +88,13 @@ typedef struct {
      * This is better than
      * generating on every handshake.
      */
-    gnutls_datum x509_rdn_sequence;
+    gnutls_datum_t x509_rdn_sequence;
 
     gnutls_certificate_client_retrieve_function *client_get_cert_callback;
     gnutls_certificate_server_retrieve_function *server_get_cert_callback;
 } certificate_credentials_st;
 
-#define gnutls_certificate_credentials certificate_credentials_st*
+#define gnutls_certificate_credentials_t certificate_credentials_st*
 
 typedef struct rsa_info_st {
     opaque modulus[65];
@@ -118,7 +110,7 @@ typedef struct cert_auth_info_st {
     dh_info_t dh;
 
     rsa_info_t rsa_export;
-    gnutls_datum *raw_certificate_list;	/* holds the raw certificate of the
+    gnutls_datum_t *raw_certificate_list;	/* holds the raw certificate of the
 					 * peer.
 					 */
     unsigned int ncerts;	/* holds the size of the list above */
@@ -127,35 +119,29 @@ typedef struct cert_auth_info_st {
 typedef struct cert_auth_info_st cert_auth_info_st;
 
 /* AUTH X509 functions */
-int _gnutls_gen_cert_server_certificate(gnutls_session, opaque **);
-int _gnutls_gen_cert_client_certificate(gnutls_session, opaque **);
-int _gnutls_gen_cert_client_cert_vrfy(gnutls_session, opaque **);
-int _gnutls_gen_cert_server_cert_req(gnutls_session, opaque **);
-int _gnutls_proc_cert_cert_req(gnutls_session, opaque *, size_t);
-int _gnutls_proc_cert_client_cert_vrfy(gnutls_session, opaque *, size_t);
-int _gnutls_proc_cert_server_certificate(gnutls_session, opaque *, size_t);
-int _gnutls_get_selected_cert(gnutls_session session,
-			      gnutls_cert ** apr_cert_list,
-			      int *apr_cert_list_length,
-			      gnutls_privkey ** apr_pkey);
+int _gnutls_gen_cert_server_certificate(gnutls_session_t, opaque **);
+int _gnutls_gen_cert_client_certificate(gnutls_session_t, opaque **);
+int _gnutls_gen_cert_client_cert_vrfy(gnutls_session_t, opaque **);
+int _gnutls_gen_cert_server_cert_req(gnutls_session_t, opaque **);
+int _gnutls_proc_cert_cert_req(gnutls_session_t, opaque *, size_t);
+int _gnutls_proc_cert_client_cert_vrfy(gnutls_session_t, opaque *, size_t);
+int _gnutls_proc_cert_server_certificate(gnutls_session_t, opaque *, size_t);
+int _gnutls_get_selected_cert(gnutls_session_t session,
+     gnutls_cert ** apr_cert_list, int *apr_cert_list_length,
+     gnutls_privkey ** apr_pkey);
 
 int _gnutls_server_select_cert(struct gnutls_session_int *,
-			       gnutls_pk_algorithm);
-void _gnutls_selected_certs_deinit(gnutls_session session);
-void _gnutls_selected_certs_set(gnutls_session session,
-				gnutls_cert * certs, int ncerts,
-				gnutls_privkey * key, int need_free);
+     gnutls_pk_algorithm_t);
+void _gnutls_selected_certs_deinit(gnutls_session_t session);
+void _gnutls_selected_certs_set(gnutls_session_t session,
+    gnutls_cert * certs, int ncerts,
+    gnutls_privkey * key, int need_free);
 
 #define _gnutls_proc_cert_client_certificate _gnutls_proc_cert_server_certificate
 
-gnutls_rsa_params _gnutls_certificate_get_rsa_params(const
-						     gnutls_certificate_credentials
-						     sc,
-						     gnutls_session
-						     session);
-gnutls_dh_params _gnutls_certificate_get_dh_params(const
-						   gnutls_certificate_credentials
-						   sc,
-						   gnutls_session session);
+gnutls_rsa_params_t _gnutls_certificate_get_rsa_params(const
+    gnutls_certificate_credentials_t sc, gnutls_session_t);
+gnutls_dh_params_t _gnutls_certificate_get_dh_params(const
+    gnutls_certificate_credentials_t sc, gnutls_session_t session);
 
 #endif
diff --git a/lib/auth_dh_common.c b/lib/auth_dh_common.c
index 3114435eeb..52de93fe65 100644
--- a/lib/auth_dh_common.c
+++ b/lib/auth_dh_common.c
@@ -37,7 +37,7 @@
 #include <gnutls_state.h>
 #include <auth_dh_common.h>
 
-int _gnutls_proc_dh_common_client_kx(gnutls_session session, opaque * data,
+int _gnutls_proc_dh_common_client_kx(gnutls_session_t session, opaque * data,
 				     size_t _data_size, mpi_t g, mpi_t p)
 {
     uint16 n_Y;
@@ -80,7 +80,7 @@ int _gnutls_proc_dh_common_client_kx(gnutls_session session, opaque * data,
     return 0;
 }
 
-int _gnutls_gen_dh_common_client_kx(gnutls_session session, opaque ** data)
+int _gnutls_gen_dh_common_client_kx(gnutls_session_t session, opaque ** data)
 {
     mpi_t x = NULL, X = NULL;
     size_t n_X;
@@ -147,7 +147,7 @@ int _gnutls_gen_dh_common_client_kx(gnutls_session session, opaque ** data)
     return ret;
 }
 
-int _gnutls_proc_dh_common_server_kx(gnutls_session session, opaque * data,
+int _gnutls_proc_dh_common_server_kx(gnutls_session_t session, opaque * data,
 				     size_t _data_size)
 {
     uint16 n_Y, n_g, n_p;
@@ -224,7 +224,7 @@ int _gnutls_proc_dh_common_server_kx(gnutls_session session, opaque * data,
     return n_Y + n_p + n_g + 6;
 }
 
-int _gnutls_dh_common_print_server_kx(gnutls_session session,
+int _gnutls_dh_common_print_server_kx(gnutls_session_t session,
 				      mpi_t g, mpi_t p, opaque ** data)
 {
     mpi_t x, X;
diff --git a/lib/auth_dh_common.h b/lib/auth_dh_common.h
index a1400cac2c..bcc6647f29 100644
--- a/lib/auth_dh_common.h
+++ b/lib/auth_dh_common.h
@@ -12,12 +12,12 @@ typedef struct dh_info_st {
     size_t public_key_size;
 } dh_info_t;
 
-int _gnutls_gen_dh_common_client_kx(gnutls_session, opaque **);
-int _gnutls_proc_dh_common_client_kx(gnutls_session session, opaque * data,
+int _gnutls_gen_dh_common_client_kx(gnutls_session_t, opaque **);
+int _gnutls_proc_dh_common_client_kx(gnutls_session_t session, opaque * data,
 				     size_t _data_size, mpi_t p, mpi_t g);
-int _gnutls_dh_common_print_server_kx(gnutls_session, mpi_t g,
+int _gnutls_dh_common_print_server_kx(gnutls_session_t, mpi_t g,
 				      mpi_t p, opaque ** data);
-int _gnutls_proc_dh_common_server_kx(gnutls_session session, opaque * data,
+int _gnutls_proc_dh_common_server_kx(gnutls_session_t session, opaque * data,
 				     size_t _data_size);
 
 #endif
diff --git a/lib/auth_dhe.c b/lib/auth_dhe.c
index 386545eb13..55d6b26e25 100644
--- a/lib/auth_dhe.c
+++ b/lib/auth_dhe.c
@@ -38,9 +38,9 @@
 #include <gnutls_state.h>
 #include <auth_dh_common.h>
 
-static int gen_dhe_server_kx(gnutls_session, opaque **);
-static int proc_dhe_server_kx(gnutls_session, opaque *, size_t);
-static int proc_dhe_client_kx(gnutls_session, opaque *, size_t);
+static int gen_dhe_server_kx(gnutls_session_t, opaque **);
+static int proc_dhe_server_kx(gnutls_session_t, opaque *, size_t);
+static int proc_dhe_client_kx(gnutls_session_t, opaque *, size_t);
 
 const mod_auth_st dhe_rsa_auth_struct = {
     "DHE_RSA",
@@ -77,7 +77,7 @@ const mod_auth_st dhe_dss_auth_struct = {
 };
 
 
-static int gen_dhe_server_kx(gnutls_session session, opaque ** data)
+static int gen_dhe_server_kx(gnutls_session_t session, opaque ** data)
 {
     mpi_t g, p;
     const mpi_t *mpis;
@@ -86,9 +86,9 @@ static int gen_dhe_server_kx(gnutls_session session, opaque ** data)
     gnutls_cert *apr_cert_list;
     gnutls_privkey *apr_pkey;
     int apr_cert_list_length;
-    gnutls_datum signature, ddata;
-    const gnutls_certificate_credentials cred;
-    gnutls_dh_params dh_params;
+    gnutls_datum_t signature, ddata;
+    const gnutls_certificate_credentials_t cred;
+    gnutls_dh_params_t dh_params;
 
     cred = _gnutls_get_cred(session->key, GNUTLS_CRD_CERTIFICATE, NULL);
     if (cred == NULL) {
@@ -165,11 +165,11 @@ static int gen_dhe_server_kx(gnutls_session session, opaque ** data)
     return data_size;
 }
 
-static int proc_dhe_server_kx(gnutls_session session, opaque * data,
+static int proc_dhe_server_kx(gnutls_session_t session, opaque * data,
 			      size_t _data_size)
 {
     int sigsize;
-    gnutls_datum vparams, signature;
+    gnutls_datum_t vparams, signature;
     int ret;
     cert_auth_info_t info = _gnutls_get_auth_info(session);
     ssize_t data_size = _data_size;
@@ -223,14 +223,14 @@ static int proc_dhe_server_kx(gnutls_session session, opaque * data,
 
 
 
-static int proc_dhe_client_kx(gnutls_session session, opaque * data,
+static int proc_dhe_client_kx(gnutls_session_t session, opaque * data,
 			      size_t _data_size)
 {
-    const gnutls_certificate_credentials cred;
+    const gnutls_certificate_credentials_t cred;
     int ret;
     mpi_t p, g;
     const mpi_t *mpis;
-    gnutls_dh_params dh_params;
+    gnutls_dh_params_t dh_params;
 
     cred = _gnutls_get_cred(session->key, GNUTLS_CRD_CERTIFICATE, NULL);
     if (cred == NULL) {
diff --git a/lib/auth_rsa.c b/lib/auth_rsa.c
index f62c7e5684..70dc42365a 100644
--- a/lib/auth_rsa.c
+++ b/lib/auth_rsa.c
@@ -41,8 +41,8 @@
 #include <gnutls_x509.h>
 #include <gnutls_extra.h>
 
-int _gnutls_gen_rsa_client_kx(gnutls_session, opaque **);
-int _gnutls_proc_rsa_client_kx(gnutls_session, opaque *, size_t);
+int _gnutls_gen_rsa_client_kx(gnutls_session_t, opaque **);
+int _gnutls_proc_rsa_client_kx(gnutls_session_t, opaque *, size_t);
 
 const mod_auth_st rsa_auth_struct = {
     "RSA",
@@ -63,7 +63,7 @@ const mod_auth_st rsa_auth_struct = {
 
 /* This function reads the RSA parameters from peer's certificate;
  */
-int _gnutls_get_public_rsa_params(gnutls_session session,
+int _gnutls_get_public_rsa_params(gnutls_session_t session,
 				  mpi_t params[MAX_PUBLIC_PARAMS_SIZE],
 				  int *params_len)
 {
@@ -136,12 +136,12 @@ int _gnutls_get_public_rsa_params(gnutls_session session,
 
 /* This function reads the RSA parameters from the private key
  */
-int _gnutls_get_private_rsa_params(gnutls_session session, mpi_t ** params,
+int _gnutls_get_private_rsa_params(gnutls_session_t session, mpi_t ** params,
 				   int *params_size)
 {
     int bits;
-    const gnutls_certificate_credentials cred;
-    gnutls_rsa_params rsa_params;
+    const gnutls_certificate_credentials_t cred;
+    gnutls_rsa_params_t rsa_params;
 
     cred = _gnutls_get_cred(session->key, GNUTLS_CRD_CERTIFICATE, NULL);
     if (cred == NULL) {
@@ -196,11 +196,11 @@ int _gnutls_get_private_rsa_params(gnutls_session session, mpi_t ** params,
 			return GNUTLS_E_MEMORY_ERROR; \
 		}
 
-int _gnutls_proc_rsa_client_kx(gnutls_session session, opaque * data,
+int _gnutls_proc_rsa_client_kx(gnutls_session_t session, opaque * data,
 			       size_t _data_size)
 {
-    gnutls_datum plaintext;
-    gnutls_datum ciphertext;
+    gnutls_datum_t plaintext;
+    gnutls_datum_t ciphertext;
     int ret, dsize;
     mpi_t *params;
     int params_len;
@@ -284,14 +284,14 @@ int _gnutls_proc_rsa_client_kx(gnutls_session session, opaque * data,
 
 /* return RSA(random) using the peers public key 
  */
-int _gnutls_gen_rsa_client_kx(gnutls_session session, opaque ** data)
+int _gnutls_gen_rsa_client_kx(gnutls_session_t session, opaque ** data)
 {
     cert_auth_info_t auth = session->key->auth_info;
-    gnutls_datum sdata;		/* data to send */
+    gnutls_datum_t sdata;		/* data to send */
     mpi_t params[MAX_PUBLIC_PARAMS_SIZE];
     int params_len = MAX_PUBLIC_PARAMS_SIZE;
     int ret, i;
-    gnutls_protocol_version ver;
+    gnutls_protocol_t ver;
 
     if (auth == NULL) {
 	/* this shouldn't have happened. The proc_certificate
diff --git a/lib/auth_rsa_export.c b/lib/auth_rsa_export.c
index 3246eacb77..5b2e6ab801 100644
--- a/lib/auth_rsa_export.c
+++ b/lib/auth_rsa_export.c
@@ -43,10 +43,10 @@
 #include <gnutls_rsa_export.h>
 #include <gnutls_state.h>
 
-int _gnutls_gen_rsa_client_kx(gnutls_session, opaque **);
-int _gnutls_proc_rsa_client_kx(gnutls_session, opaque *, size_t);
-static int gen_rsa_export_server_kx(gnutls_session, opaque **);
-static int proc_rsa_export_server_kx(gnutls_session, opaque *, size_t);
+int _gnutls_gen_rsa_client_kx(gnutls_session_t, opaque **);
+int _gnutls_proc_rsa_client_kx(gnutls_session_t, opaque *, size_t);
+static int gen_rsa_export_server_kx(gnutls_session_t, opaque **);
+static int proc_rsa_export_server_kx(gnutls_session_t, opaque *, size_t);
 
 const mod_auth_st rsa_export_auth_struct = {
     "RSA EXPORT",
@@ -65,9 +65,9 @@ const mod_auth_st rsa_export_auth_struct = {
     _gnutls_proc_cert_cert_req	/* proc server cert request */
 };
 
-static int gen_rsa_export_server_kx(gnutls_session session, opaque ** data)
+static int gen_rsa_export_server_kx(gnutls_session_t session, opaque ** data)
 {
-    gnutls_rsa_params rsa_params;
+    gnutls_rsa_params_t rsa_params;
     const mpi_t *rsa_mpis;
     size_t n_e, n_m;
     uint8 *data_e, *data_m;
@@ -75,9 +75,9 @@ static int gen_rsa_export_server_kx(gnutls_session session, opaque ** data)
     gnutls_cert *apr_cert_list;
     gnutls_privkey *apr_pkey;
     int apr_cert_list_length;
-    gnutls_datum signature, ddata;
+    gnutls_datum_t signature, ddata;
     cert_auth_info_t info;
-    const gnutls_certificate_credentials cred;
+    const gnutls_certificate_credentials_t cred;
 
     cred = _gnutls_get_cred(session->key, GNUTLS_CRD_CERTIFICATE, NULL);
     if (cred == NULL) {
@@ -175,7 +175,7 @@ static int gen_rsa_export_server_kx(gnutls_session session, opaque ** data)
 
 /* if the peer's certificate is of 512 bits or less, returns non zero.
  */
-int _gnutls_peers_cert_less_512(gnutls_session session)
+int _gnutls_peers_cert_less_512(gnutls_session_t session)
 {
     gnutls_cert peer_cert;
     int ret;
@@ -213,7 +213,7 @@ int _gnutls_peers_cert_less_512(gnutls_session session)
     return 0;
 }
 
-static int proc_rsa_export_server_kx(gnutls_session session, opaque * data,
+static int proc_rsa_export_server_kx(gnutls_session_t session, opaque * data,
 				     size_t _data_size)
 {
     uint16 n_m, n_e;
@@ -221,7 +221,7 @@ static int proc_rsa_export_server_kx(gnutls_session session, opaque * data,
     uint8 *data_m;
     uint8 *data_e;
     int i, sigsize;
-    gnutls_datum vparams, signature;
+    gnutls_datum_t vparams, signature;
     int ret;
     ssize_t data_size = _data_size;
     cert_auth_info_t info;
diff --git a/lib/debug.c b/lib/debug.c
index 1a9d519586..dada997704 100644
--- a/lib/debug.c
+++ b/lib/debug.c
@@ -28,7 +28,7 @@
 #ifdef DEBUG
 
 
-void _gnutls_print_state(gnutls_session session)
+void _gnutls_print_state(gnutls_session_t session)
 {
 
     _gnutls_debug_log("GNUTLS State:\n");
@@ -65,7 +65,7 @@ const char *_gnutls_packet2str(content_type_t packet)
     }
 }
 
-const char *_gnutls_handshake2str(HandshakeType handshake)
+const char *_gnutls_handshake2str(handshake_t handshake)
 {
 
     switch (handshake) {
diff --git a/lib/debug.h b/lib/debug.h
index e49190af01..cee2b799dd 100644
--- a/lib/debug.h
+++ b/lib/debug.h
@@ -19,8 +19,8 @@
  */
 
 #ifdef DEBUG
-void _gnutls_print_state(gnutls_session session);
+void _gnutls_print_state(gnutls_session_t session);
 #endif
 const char *_gnutls_packet2str(content_type_t packet);
-const char *_gnutls_handshake2str(HandshakeType handshake);
+const char *_gnutls_handshake2str(handshake_t handshake);
 void _gnutls_dump_mpi(const char *prefix, mpi_t a);
diff --git a/lib/ext_cert_type.c b/lib/ext_cert_type.c
index 1f927654f3..ad8f7893fb 100644
--- a/lib/ext_cert_type.c
+++ b/lib/ext_cert_type.c
@@ -43,7 +43,7 @@ inline static int _gnutls_cert_type2num(int record_size);
  *
  */
 
-int _gnutls_cert_type_recv_params(gnutls_session session,
+int _gnutls_cert_type_recv_params(gnutls_session_t session,
 				  const opaque * data, size_t _data_size)
 {
     int new_type = -1, ret, i;
@@ -126,7 +126,7 @@ int _gnutls_cert_type_recv_params(gnutls_session session,
 
 /* returns data_size or a negative number on failure
  */
-int _gnutls_cert_type_send_params(gnutls_session session, opaque * data,
+int _gnutls_cert_type_send_params(gnutls_session_t session, opaque * data,
 				  size_t data_size)
 {
     uint len, i;
diff --git a/lib/ext_cert_type.h b/lib/ext_cert_type.h
index 287125da3f..56c9efcc02 100644
--- a/lib/ext_cert_type.h
+++ b/lib/ext_cert_type.h
@@ -1,7 +1,7 @@
 /* Maps record size to numbers according to the
  * extensions draft.
  */
-int _gnutls_cert_type_recv_params(gnutls_session session,
+int _gnutls_cert_type_recv_params(gnutls_session_t session,
 				  const opaque * data, size_t data_size);
-int _gnutls_cert_type_send_params(gnutls_session session, opaque * data,
+int _gnutls_cert_type_send_params(gnutls_session_t session, opaque * data,
 				  size_t);
diff --git a/lib/ext_max_record.c b/lib/ext_max_record.c
index 52e9a72876..a82a466d5a 100644
--- a/lib/ext_max_record.c
+++ b/lib/ext_max_record.c
@@ -38,7 +38,7 @@
  *
  */
 
-int _gnutls_max_record_recv_params(gnutls_session session,
+int _gnutls_max_record_recv_params(gnutls_session_t session,
 				   const opaque * data, size_t _data_size)
 {
     ssize_t new_size;
@@ -88,7 +88,7 @@ int _gnutls_max_record_recv_params(gnutls_session session,
 
 /* returns data_size or a negative number on failure
  */
-int _gnutls_max_record_send_params(gnutls_session session, opaque * data,
+int _gnutls_max_record_send_params(gnutls_session_t session, opaque * data,
 				   size_t data_size)
 {
     uint16 len;
diff --git a/lib/ext_max_record.h b/lib/ext_max_record.h
index b6f158f353..2b4569cdaf 100644
--- a/lib/ext_max_record.h
+++ b/lib/ext_max_record.h
@@ -3,7 +3,7 @@
  */
 int _gnutls_mre_num2record(int num);
 int _gnutls_mre_record2num(uint16 record_size);
-int _gnutls_max_record_recv_params(gnutls_session session,
+int _gnutls_max_record_recv_params(gnutls_session_t session,
 				   const opaque * data, size_t data_size);
-int _gnutls_max_record_send_params(gnutls_session session, opaque * data,
+int _gnutls_max_record_send_params(gnutls_session_t session, opaque * data,
 				   size_t);
diff --git a/lib/ext_server_name.c b/lib/ext_server_name.c
index 7b83240f0e..cf3d7ddba4 100644
--- a/lib/ext_server_name.c
+++ b/lib/ext_server_name.c
@@ -35,7 +35,7 @@
  *
  */
 
-int _gnutls_server_name_recv_params(gnutls_session session,
+int _gnutls_server_name_recv_params(gnutls_session_t session,
 				    const opaque * data, size_t _data_size)
 {
     int i;
@@ -113,7 +113,7 @@ int _gnutls_server_name_recv_params(gnutls_session session,
 
 /* returns data_size or a negative number on failure
  */
-int _gnutls_server_name_send_params(gnutls_session session, opaque * data,
+int _gnutls_server_name_send_params(gnutls_session_t session, opaque * data,
 				    size_t _data_size)
 {
     uint16 len;
@@ -198,7 +198,7 @@ int _gnutls_server_name_send_params(gnutls_session session, opaque * data,
 
 /**
   * gnutls_server_name_get - Used to get the server name indicator send by a client
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @data: will hold the data
   * @data_length: will hold the data length. Must hold the maximum size of data.
   * @type: will hold the server name indicator type
@@ -206,7 +206,7 @@ int _gnutls_server_name_send_params(gnutls_session session, opaque * data,
   *
   * This function will allow you to get the name indication (if any),
   * a client has sent. The name indication may be any of the enumeration
-  * gnutls_server_name_type.
+  * gnutls_server_name_type_t.
   *
   * If @type is GNUTLS_NAME_DNS, then this function is to be used by servers
   * that support virtual hosting, and the data will be a null terminated UTF-8 string.
@@ -219,7 +219,7 @@ int _gnutls_server_name_send_params(gnutls_session session, opaque * data,
   * index exists GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE is returned.
   *
   **/
-int gnutls_server_name_get(gnutls_session session, void *data,
+int gnutls_server_name_get(gnutls_session_t session, void *data,
 			   size_t * data_length,
 			   unsigned int *type, unsigned int indx)
 {
@@ -263,7 +263,7 @@ int gnutls_server_name_get(gnutls_session session, void *data,
 
 /**
   * gnutls_server_name_set - Used to set a name indicator to be sent as an extension
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @type: specifies the indicator type
   * @name: is a string that contains the server name.
   * @name_length: holds the length of name
@@ -278,8 +278,8 @@ int gnutls_server_name_get(gnutls_session session, void *data,
   * IPv4 or IPv6 addresses are not permitted.
   *
   **/
-int gnutls_server_name_set(gnutls_session session,
-			   gnutls_server_name_type type,
+int gnutls_server_name_set(gnutls_session_t session,
+			   gnutls_server_name_type_t type,
 			   const void *name, size_t name_length)
 {
     int server_names;
diff --git a/lib/ext_server_name.h b/lib/ext_server_name.h
index a6eb92d94d..56ed33aad3 100644
--- a/lib/ext_server_name.h
+++ b/lib/ext_server_name.h
@@ -1,11 +1,11 @@
-int _gnutls_server_name_recv_params(gnutls_session session,
+int _gnutls_server_name_recv_params(gnutls_session_t session,
 				    const opaque * data, size_t data_size);
-int _gnutls_server_name_send_params(gnutls_session session, opaque * data,
+int _gnutls_server_name_send_params(gnutls_session_t session, opaque * data,
 				    size_t);
 
-int gnutls_get_server_name(gnutls_session session, void *data,
+int gnutls_get_server_name(gnutls_session_t session, void *data,
 			   int *data_length, int *type, int indx);
 
-int gnutls_set_server_name(gnutls_session session,
-			   gnutls_server_name_type type,
+int gnutls_set_server_name(gnutls_session_t session,
+			   gnutls_server_name_type_t type,
 			   const void *name, int name_length);
diff --git a/lib/gnutls.h.in.in b/lib/gnutls.h.in.in
index 883c80f865..26b6b7bb01 100644
--- a/lib/gnutls.h.in.in
+++ b/lib/gnutls.h.in.in
@@ -55,36 +55,38 @@ extern "C" {
 @DEFINE_TIME_T@
 #endif
 
+#include <gnutls/compat.h>
+
 #define GNUTLS_CIPHER_RIJNDAEL_128_CBC GNUTLS_CIPHER_AES_128_CBC
 #define GNUTLS_CIPHER_RIJNDAEL_256_CBC GNUTLS_CIPHER_AES_256_CBC
 #define GNUTLS_CIPHER_RIJNDAEL_CBC GNUTLS_CIPHER_AES_128_CBC
 #define GNUTLS_CIPHER_ARCFOUR GNUTLS_CIPHER_ARCFOUR_128
 
-typedef enum gnutls_cipher_algorithm { GNUTLS_CIPHER_NULL=1, 
+typedef enum { GNUTLS_CIPHER_NULL=1, 
     GNUTLS_CIPHER_ARCFOUR_128, GNUTLS_CIPHER_3DES_CBC, GNUTLS_CIPHER_AES_128_CBC, 
     GNUTLS_CIPHER_AES_256_CBC, GNUTLS_CIPHER_ARCFOUR_40
-} gnutls_cipher_algorithm;
+} gnutls_cipher_algorithm_t;
 
-typedef enum gnutls_kx_algorithm { GNUTLS_KX_RSA=1, GNUTLS_KX_DHE_DSS, 
+typedef enum { GNUTLS_KX_RSA=1, GNUTLS_KX_DHE_DSS, 
     GNUTLS_KX_DHE_RSA, GNUTLS_KX_ANON_DH, GNUTLS_KX_SRP,
     GNUTLS_KX_RSA_EXPORT, GNUTLS_KX_SRP_RSA, GNUTLS_KX_SRP_DSS
-} gnutls_kx_algorithm;
+} gnutls_kx_algorithm_t;
 
-typedef enum gnutls_params_type { GNUTLS_PARAMS_RSA_EXPORT=1,
+typedef enum { GNUTLS_PARAMS_RSA_EXPORT=1,
     GNUTLS_PARAMS_DH 
-} gnutls_params_type;
+} gnutls_params_type_t;
 
-typedef enum gnutls_credentials_type { GNUTLS_CRD_CERTIFICATE=1, GNUTLS_CRD_ANON, GNUTLS_CRD_SRP } gnutls_credentials_type;
+typedef enum { GNUTLS_CRD_CERTIFICATE=1, GNUTLS_CRD_ANON, GNUTLS_CRD_SRP } gnutls_credentials_type_t;
 
-typedef enum gnutls_mac_algorithm { GNUTLS_MAC_NULL=1, 
+typedef enum { GNUTLS_MAC_NULL=1, 
     GNUTLS_MAC_MD5, GNUTLS_MAC_SHA, GNUTLS_MAC_RMD160
-} gnutls_mac_algorithm;
+} gnutls_mac_algorithm_t;
 
-/* The enumerations here should have the same value with gnutls_mac_algorithm.
+/* The enumerations here should have the same value with gnutls_mac_algorithm_t.
  */
-typedef enum gnutls_digest_algorithm { GNUTLS_DIG_NULL=1, GNUTLS_DIG_MD5, 
+typedef enum { GNUTLS_DIG_NULL=1, GNUTLS_DIG_MD5, 
     GNUTLS_DIG_SHA, GNUTLS_DIG_RIPEMD160 
-} gnutls_digest_algorithm;
+} gnutls_digest_algorithm_t;
 
 /* exported for other gnutls headers. This is the maximum number
  * of algorithms (ciphers, kx or macs). 
@@ -92,17 +94,17 @@ typedef enum gnutls_digest_algorithm { GNUTLS_DIG_NULL=1, GNUTLS_DIG_MD5,
 #define GNUTLS_MAX_ALGORITHM_NUM 16
 
 #define GNUTLS_COMP_ZLIB GNUTLS_COMP_DEFLATE
-typedef enum gnutls_compression_method { GNUTLS_COMP_NULL=1, 
+typedef enum { GNUTLS_COMP_NULL=1, 
     GNUTLS_COMP_DEFLATE, 
     GNUTLS_COMP_LZO /* only available if gnutls-extra has been initialized 
                          */
-} gnutls_compression_method;
+} gnutls_compression_method_t;
 
-typedef enum gnutls_connection_end { GNUTLS_SERVER=1, GNUTLS_CLIENT } gnutls_connection_end;
+typedef enum { GNUTLS_SERVER=1, GNUTLS_CLIENT } gnutls_connection_end_t;
 
-typedef enum gnutls_alert_level { GNUTLS_AL_WARNING=1, GNUTLS_AL_FATAL } gnutls_alert_level;
+typedef enum { GNUTLS_AL_WARNING=1, GNUTLS_AL_FATAL } gnutls_alert_level_t;
 
-typedef enum gnutls_alert_description { GNUTLS_A_CLOSE_NOTIFY, 
+typedef enum { GNUTLS_A_CLOSE_NOTIFY, 
     GNUTLS_A_UNEXPECTED_MESSAGE=10, GNUTLS_A_BAD_RECORD_MAC=20,
     GNUTLS_A_DECRYPTION_FAILED, GNUTLS_A_RECORD_OVERFLOW, GNUTLS_A_DECOMPRESSION_FAILURE=30,
     GNUTLS_A_HANDSHAKE_FAILURE=40, GNUTLS_A_SSL3_NO_CERTIFICATE=41,
@@ -114,20 +116,20 @@ typedef enum gnutls_alert_description { GNUTLS_A_CLOSE_NOTIFY,
     GNUTLS_A_NO_RENEGOTIATION=100, GNUTLS_A_UNSUPPORTED_EXTENSION=110,
     GNUTLS_A_CERTIFICATE_UNOBTAINABLE=111, GNUTLS_A_UNRECOGNIZED_NAME=112,
     GNUTLS_A_UNKNOWN_SRP_USERNAME=120, GNUTLS_A_MISSING_SRP_USERNAME=121
-} gnutls_alert_description;
+} gnutls_alert_description_t;
 
-typedef enum gnutls_handshake_description { GNUTLS_HANDSHAKE_HELLO_REQUEST, 
+typedef enum { GNUTLS_HANDSHAKE_HELLO_REQUEST, 
     GNUTLS_HANDSHAKE_CLIENT_HELLO, GNUTLS_HANDSHAKE_SERVER_HELLO,
     GNUTLS_HANDSHAKE_CERTIFICATE_PKT=11, GNUTLS_HANDSHAKE_SERVER_KEY_EXCHANGE,
     GNUTLS_HANDSHAKE_CERTIFICATE_REQUEST, GNUTLS_HANDSHAKE_SERVER_HELLO_DONE,
     GNUTLS_HANDSHAKE_CERTIFICATE_VERIFY, GNUTLS_HANDSHAKE_CLIENT_KEY_EXCHANGE,
     GNUTLS_HANDSHAKE_FINISHED=20 
-} gnutls_handshake_description;
+} gnutls_handshake_description_t;
 
 /* Note that the status bits have different meanings
  * in openpgp keys and x.509 certificate verification.
  */
-typedef enum gnutls_certificate_status { 
+typedef enum { 
     GNUTLS_CERT_INVALID=2, /* will be set if the certificate
                 * was not verified.
                 */
@@ -140,90 +142,90 @@ typedef enum gnutls_certificate_status {
      */
     GNUTLS_CERT_SIGNER_NOT_FOUND=64,
     GNUTLS_CERT_SIGNER_NOT_CA=128
-} gnutls_certificate_status;
+} gnutls_certificate_status_t;
 
-typedef enum gnutls_certificate_request { GNUTLS_CERT_IGNORE, GNUTLS_CERT_REQUEST=1, GNUTLS_CERT_REQUIRE } gnutls_certificate_request;
+typedef enum { GNUTLS_CERT_IGNORE, GNUTLS_CERT_REQUEST=1, GNUTLS_CERT_REQUIRE } gnutls_certificate_request_t;
 
-typedef enum gnutls_openpgp_key_status { GNUTLS_OPENPGP_KEY, 
+typedef enum { GNUTLS_OPENPGP_KEY, 
     GNUTLS_OPENPGP_KEY_FINGERPRINT
-} gnutls_openpgp_key_status;
+} gnutls_openpgp_key_status_t;
 
-typedef enum gnutls_close_request { GNUTLS_SHUT_RDWR=0, GNUTLS_SHUT_WR=1 } gnutls_close_request;
+typedef enum { GNUTLS_SHUT_RDWR=0, GNUTLS_SHUT_WR=1 } gnutls_close_request_t;
 
 #define GNUTLS_TLS1 GNUTLS_TLS1_0
-typedef enum gnutls_protocol_version { GNUTLS_SSL3=1, GNUTLS_TLS1_0,
-    GNUTLS_TLS1_1 } gnutls_protocol_version;
+typedef enum { GNUTLS_SSL3=1, GNUTLS_TLS1_0,
+    GNUTLS_TLS1_1 } gnutls_protocol_t;
 
-typedef enum gnutls_certificate_type { GNUTLS_CRT_X509=1, GNUTLS_CRT_OPENPGP 
-} gnutls_certificate_type;
+typedef enum { GNUTLS_CRT_X509=1, GNUTLS_CRT_OPENPGP 
+} gnutls_certificate_type_t;
 
-typedef enum gnutls_x509_crt_fmt { GNUTLS_X509_FMT_DER, 
-    GNUTLS_X509_FMT_PEM } gnutls_x509_crt_fmt;
+typedef enum { GNUTLS_X509_FMT_DER, 
+    GNUTLS_X509_FMT_PEM } gnutls_x509_crt_fmt_t;
 
-typedef enum gnutls_pk_algorithm { GNUTLS_PK_RSA = 1, GNUTLS_PK_DSA,
+typedef enum { GNUTLS_PK_RSA = 1, GNUTLS_PK_DSA,
     GNUTLS_PK_UNKNOWN = 0xff
-} gnutls_pk_algorithm;
+} gnutls_pk_algorithm_t;
 
-const char *gnutls_pk_algorithm_get_name( gnutls_pk_algorithm algorithm);
+const char *gnutls_pk_algorithm_get_name( gnutls_pk_algorithm_t algorithm);
 
-typedef enum gnutls_sign_algorithm { GNUTLS_SIGN_RSA_SHA = 1, GNUTLS_SIGN_DSA_SHA,
+typedef enum { GNUTLS_SIGN_RSA_SHA = 1, GNUTLS_SIGN_DSA_SHA,
     GNUTLS_SIGN_RSA_MD5, GNUTLS_SIGN_RSA_MD2,
     GNUTLS_SIGN_UNKNOWN = 0xff
-} gnutls_sign_algorithm;
+} gnutls_sign_algorithm_t;
 
-const char *gnutls_sign_algorithm_get_name( gnutls_sign_algorithm algorithm);
+const char *gnutls_sign_algorithm_get_name( gnutls_sign_algorithm_t algorithm);
 
 /* If you want to change this, then also change the 
  * define in gnutls_int.h, and recompile.
  */
-typedef void * gnutls_transport_ptr;
+typedef void * gnutls_transport_ptr_t;
 
 struct gnutls_session_int;
-typedef struct gnutls_session_int* gnutls_session;
+typedef struct gnutls_session_int* gnutls_session_t;
 
 struct gnutls_dh_params_int;
-typedef struct gnutls_dh_params_int* gnutls_dh_params;
+typedef struct gnutls_dh_params_int* gnutls_dh_params_t;
 
 struct gnutls_rsa_params_int;
-typedef struct gnutls_rsa_params_int* gnutls_rsa_params;
+typedef struct gnutls_rsa_params_int* gnutls_rsa_params_t;
 
 typedef struct {
     unsigned char * data;
     unsigned int size;
-} gnutls_datum;
+} gnutls_datum_t;
 
 
 /* internal functions */
 
-int gnutls_init(gnutls_session * session, gnutls_connection_end con_end);
-void gnutls_deinit(gnutls_session session);
+int gnutls_init(gnutls_session_t * session, gnutls_connection_end_t con_end);
+void gnutls_deinit(gnutls_session_t session);
 #define _gnutls_deinit(x) gnutls_deinit(x)
 
-int gnutls_bye( gnutls_session session, gnutls_close_request how);
+int gnutls_bye( gnutls_session_t session, gnutls_close_request_t how);
 
-int gnutls_handshake( gnutls_session session);
-int gnutls_rehandshake( gnutls_session session);
+int gnutls_handshake( gnutls_session_t session);
+int gnutls_rehandshake( gnutls_session_t session);
 
-gnutls_alert_description gnutls_alert_get( gnutls_session session);
-int          gnutls_alert_send( gnutls_session, gnutls_alert_level, gnutls_alert_description);
-int          gnutls_alert_send_appropriate(  gnutls_session session, int err);
-const char*  gnutls_alert_get_name( gnutls_alert_description alert);
+gnutls_alert_description_t gnutls_alert_get( gnutls_session_t session);
+int          gnutls_alert_send( gnutls_session_t, gnutls_alert_level_t, gnutls_alert_description_t);
+int          gnutls_alert_send_appropriate(  gnutls_session_t session, int err);
+const char*  gnutls_alert_get_name( gnutls_alert_description_t alert);
 
 /* get information on the current session */
-gnutls_cipher_algorithm     gnutls_cipher_get( gnutls_session session);
-gnutls_kx_algorithm         gnutls_kx_get( gnutls_session session);
-gnutls_mac_algorithm        gnutls_mac_get( gnutls_session session);
-gnutls_compression_method   gnutls_compression_get( gnutls_session session);
-gnutls_certificate_type	    gnutls_certificate_type_get( gnutls_session session);
+gnutls_cipher_algorithm_t     gnutls_cipher_get( gnutls_session_t session);
+gnutls_kx_algorithm_t         gnutls_kx_get( gnutls_session_t session);
+gnutls_mac_algorithm_t        gnutls_mac_get( gnutls_session_t session);
+gnutls_compression_method_t   gnutls_compression_get( gnutls_session_t session);
+gnutls_certificate_type_t     gnutls_certificate_type_get( gnutls_session_t session);
 
-size_t gnutls_cipher_get_key_size( gnutls_cipher_algorithm algorithm);
+size_t gnutls_cipher_get_key_size( gnutls_cipher_algorithm_t algorithm);
 
 /* the name of the specified algorithms */
-const char *gnutls_cipher_get_name( gnutls_cipher_algorithm);
-const char *gnutls_mac_get_name( gnutls_mac_algorithm);
-const char *gnutls_compression_get_name( gnutls_compression_method);
-const char *gnutls_kx_get_name( gnutls_kx_algorithm algorithm);
-const char *gnutls_certificate_type_get_name( gnutls_certificate_type type);
+const char *gnutls_cipher_get_name( gnutls_cipher_algorithm_t);
+const char *gnutls_mac_get_name( gnutls_mac_algorithm_t);
+const char *gnutls_compression_get_name( gnutls_compression_method_t);
+const char *gnutls_kx_get_name( gnutls_kx_algorithm_t algorithm);
+const char *gnutls_certificate_type_get_name( gnutls_certificate_type_t type);
 
 
 /* error functions */
@@ -235,88 +237,88 @@ const char* gnutls_strerror( int error);
 
 /* Semi-internal functions.
  */
-void gnutls_handshake_set_private_extensions(gnutls_session session, int allow);
-gnutls_handshake_description gnutls_handshake_get_last_out( gnutls_session session);
-gnutls_handshake_description gnutls_handshake_get_last_in( gnutls_session session);
+void gnutls_handshake_set_private_extensions(gnutls_session_t session, int allow);
+gnutls_handshake_description_t gnutls_handshake_get_last_out( gnutls_session_t session);
+gnutls_handshake_description_t gnutls_handshake_get_last_in( gnutls_session_t session);
 
 /* Record layer functions.
  */
-ssize_t gnutls_record_send( gnutls_session session, const void *data, size_t sizeofdata);
-ssize_t gnutls_record_recv( gnutls_session session, void *data, size_t sizeofdata);
+ssize_t gnutls_record_send( gnutls_session_t session, const void *data, size_t sizeofdata);
+ssize_t gnutls_record_recv( gnutls_session_t session, void *data, size_t sizeofdata);
 #define gnutls_read gnutls_record_recv
 #define gnutls_write gnutls_record_send
 
-int gnutls_record_get_direction(gnutls_session session);
+int gnutls_record_get_direction(gnutls_session_t session);
 
-size_t gnutls_record_get_max_size( gnutls_session session);
-ssize_t gnutls_record_set_max_size( gnutls_session session, size_t size);
+size_t gnutls_record_get_max_size( gnutls_session_t session);
+ssize_t gnutls_record_set_max_size( gnutls_session_t session, size_t size);
 
-size_t gnutls_record_check_pending(gnutls_session session);
+size_t gnutls_record_check_pending(gnutls_session_t session);
 
 /* TLS Extensions */
 
-typedef enum gnutls_server_name_type { GNUTLS_NAME_DNS=1 
-} gnutls_server_name_type;
+typedef enum { GNUTLS_NAME_DNS=1 
+} gnutls_server_name_type_t;
 
-int gnutls_server_name_set(gnutls_session session,
-    gnutls_server_name_type type,
+int gnutls_server_name_set(gnutls_session_t session,
+    gnutls_server_name_type_t type,
     const void *name, size_t name_length);
 
-int gnutls_server_name_get(gnutls_session session, 
+int gnutls_server_name_get(gnutls_session_t session, 
     void *data, size_t *data_length,
     unsigned int * type, int unsigned indx);
 
 /* functions to set priority of cipher suites 
  */
-int gnutls_cipher_set_priority( gnutls_session session, const int*);
-int gnutls_mac_set_priority( gnutls_session session, const int*);
-int gnutls_compression_set_priority( gnutls_session session, const int*);
-int gnutls_kx_set_priority( gnutls_session session, const int*);
-int gnutls_protocol_set_priority( gnutls_session session, const int*);
-int gnutls_certificate_type_set_priority( gnutls_session session, const int*);
+int gnutls_cipher_set_priority( gnutls_session_t session, const int*);
+int gnutls_mac_set_priority( gnutls_session_t session, const int*);
+int gnutls_compression_set_priority( gnutls_session_t session, const int*);
+int gnutls_kx_set_priority( gnutls_session_t session, const int*);
+int gnutls_protocol_set_priority( gnutls_session_t session, const int*);
+int gnutls_certificate_type_set_priority( gnutls_session_t session, const int*);
 
 /* if you just want some defaults, use the following.
  */
-int gnutls_set_default_priority(gnutls_session session);
-int gnutls_set_default_export_priority(gnutls_session session);
+int gnutls_set_default_priority(gnutls_session_t session);
+int gnutls_set_default_export_priority(gnutls_session_t session);
 
 /* Returns the name of a cipher suite */
-const char *gnutls_cipher_suite_get_name(gnutls_kx_algorithm kx_algorithm,
-    gnutls_cipher_algorithm cipher_algorithm, gnutls_mac_algorithm mac_algorithm);
+const char *gnutls_cipher_suite_get_name(gnutls_kx_algorithm_t kx_algorithm,
+    gnutls_cipher_algorithm_t cipher_algorithm, gnutls_mac_algorithm_t mac_algorithm);
 
 /* get the currently used protocol version */
-gnutls_protocol_version gnutls_protocol_get_version(gnutls_session session);
+gnutls_protocol_t gnutls_protocol_get_version(gnutls_session_t session);
 
-const char *gnutls_protocol_get_name(gnutls_protocol_version version);
+const char *gnutls_protocol_get_name(gnutls_protocol_t version);
 
 
 /* get/set session 
  */
-int gnutls_session_set_data( gnutls_session session, const void* session_data, size_t session_data_size);
-int gnutls_session_get_data( gnutls_session session, void* session_data, size_t *session_data_size);
+int gnutls_session_set_data( gnutls_session_t session, const void* session_data, size_t session_data_size);
+int gnutls_session_get_data( gnutls_session_t session, void* session_data, size_t *session_data_size);
 /* returns the session ID */
 #define GNUTLS_MAX_SESSION_ID 32
-int gnutls_session_get_id( gnutls_session session, void* session_id, size_t *session_id_size);
+int gnutls_session_get_id( gnutls_session_t session, void* session_id, size_t *session_id_size);
 
 /* checks if this session is a resumed one 
  */
-int gnutls_session_is_resumed(gnutls_session session);
+int gnutls_session_is_resumed(gnutls_session_t session);
 
-typedef int (*gnutls_db_store_func)(void*, gnutls_datum key, gnutls_datum data);
-typedef int (*gnutls_db_remove_func)(void*, gnutls_datum key);
-typedef gnutls_datum (*gnutls_db_retr_func)(void*, gnutls_datum key);
+typedef int (*gnutls_db_store_func)(void*, gnutls_datum_t key, gnutls_datum_t data);
+typedef int (*gnutls_db_remove_func)(void*, gnutls_datum_t key);
+typedef gnutls_datum_t (*gnutls_db_retr_func)(void*, gnutls_datum_t key);
 
-void gnutls_db_set_cache_expiration( gnutls_session session, int seconds);
+void gnutls_db_set_cache_expiration( gnutls_session_t session, int seconds);
 
-void gnutls_db_remove_session( gnutls_session session);
-void gnutls_db_set_retrieve_function( gnutls_session, gnutls_db_retr_func);
-void gnutls_db_set_remove_function( gnutls_session, gnutls_db_remove_func);
-void gnutls_db_set_store_function( gnutls_session, gnutls_db_store_func);
-void gnutls_db_set_ptr( gnutls_session, void* db_ptr);
-void* gnutls_db_get_ptr( gnutls_session);
-int  gnutls_db_check_entry( gnutls_session session, gnutls_datum session_entry);
+void gnutls_db_remove_session( gnutls_session_t session);
+void gnutls_db_set_retrieve_function( gnutls_session_t, gnutls_db_retr_func);
+void gnutls_db_set_remove_function( gnutls_session_t, gnutls_db_remove_func);
+void gnutls_db_set_store_function( gnutls_session_t, gnutls_db_store_func);
+void gnutls_db_set_ptr( gnutls_session_t, void* db_ptr);
+void* gnutls_db_get_ptr( gnutls_session_t);
+int  gnutls_db_check_entry( gnutls_session_t session, gnutls_datum_t session_entry);
 
-void gnutls_handshake_set_max_packet_length( gnutls_session session, int max);
+void gnutls_handshake_set_max_packet_length( gnutls_session_t session, int max);
 
 /* returns libgnutls version (call it with a NULL argument) 
  */
@@ -324,82 +326,82 @@ const char* gnutls_check_version( const char*);
 
 /* Functions for setting/clearing credentials 
  */
-int gnutls_credentials_clear( gnutls_session session);
+int gnutls_credentials_clear( gnutls_session_t session);
 
 /* cred is a structure defined by the kx algorithm 
  */
-int gnutls_credentials_set( gnutls_session, gnutls_credentials_type type, void* cred);
+int gnutls_credentials_set( gnutls_session_t, gnutls_credentials_type_t type, void* cred);
 #define gnutls_cred_set	gnutls_credentials_set
 
 /* Credential structures for SRP - used in gnutls_credentials_set(); */
 
 struct DSTRUCT;
-typedef struct DSTRUCT* gnutls_certificate_credentials;
-typedef gnutls_certificate_credentials gnutls_certificate_server_credentials;
-typedef gnutls_certificate_credentials gnutls_certificate_client_credentials;
+typedef struct DSTRUCT* gnutls_certificate_credentials_t;
+typedef gnutls_certificate_credentials_t gnutls_certificate_server_credentials;
+typedef gnutls_certificate_credentials_t gnutls_certificate_client_credentials;
 
-typedef struct DSTRUCT* gnutls_anon_server_credentials;
-typedef struct DSTRUCT* gnutls_anon_client_credentials;
+typedef struct DSTRUCT* gnutls_anon_server_credentials_t;
+typedef struct DSTRUCT* gnutls_anon_client_credentials_t;
 
-void gnutls_anon_free_server_credentials( gnutls_anon_server_credentials sc);
-int gnutls_anon_allocate_server_credentials( gnutls_anon_server_credentials *sc);
+void gnutls_anon_free_server_credentials( gnutls_anon_server_credentials_t sc);
+int gnutls_anon_allocate_server_credentials( gnutls_anon_server_credentials_t *sc);
 
-void gnutls_anon_set_server_dh_params( gnutls_anon_server_credentials res, gnutls_dh_params dh_params);
+void gnutls_anon_set_server_dh_params( gnutls_anon_server_credentials_t res, gnutls_dh_params_t dh_params);
 
-void gnutls_anon_free_client_credentials( gnutls_anon_client_credentials sc);
-int gnutls_anon_allocate_client_credentials( gnutls_anon_client_credentials *sc);
+void gnutls_anon_free_client_credentials( gnutls_anon_client_credentials_t sc);
+int gnutls_anon_allocate_client_credentials( gnutls_anon_client_credentials_t *sc);
 
 /* CERTFILE is an x509 certificate in PEM form.
  * KEYFILE is a pkcs-1 private key in PEM form (for RSA keys).
  */
-void gnutls_certificate_free_credentials( gnutls_certificate_credentials sc);
-int gnutls_certificate_allocate_credentials( gnutls_certificate_credentials *sc);
+void gnutls_certificate_free_credentials( gnutls_certificate_credentials_t sc);
+int gnutls_certificate_allocate_credentials( gnutls_certificate_credentials_t *sc);
 
-void gnutls_certificate_free_keys(gnutls_certificate_credentials sc);
-void gnutls_certificate_free_cas(gnutls_certificate_credentials sc);
-void gnutls_certificate_free_ca_names(gnutls_certificate_credentials sc);
-void gnutls_certificate_free_crls(gnutls_certificate_credentials sc);
+void gnutls_certificate_free_keys(gnutls_certificate_credentials_t sc);
+void gnutls_certificate_free_cas(gnutls_certificate_credentials_t sc);
+void gnutls_certificate_free_ca_names(gnutls_certificate_credentials_t sc);
+void gnutls_certificate_free_crls(gnutls_certificate_credentials_t sc);
 
-void gnutls_certificate_set_dh_params(gnutls_certificate_credentials res, gnutls_dh_params);
-void gnutls_certificate_set_rsa_export_params(gnutls_certificate_credentials res, gnutls_rsa_params rsa_params);
-void gnutls_certificate_set_verify_flags(gnutls_certificate_credentials res, unsigned int flags);
+void gnutls_certificate_set_dh_params(gnutls_certificate_credentials_t res, gnutls_dh_params_t);
+void gnutls_certificate_set_rsa_export_params(gnutls_certificate_credentials_t res, gnutls_rsa_params_t rsa_params);
+void gnutls_certificate_set_verify_flags(gnutls_certificate_credentials_t res, unsigned int flags);
 
 
-int gnutls_certificate_set_x509_trust_file( gnutls_certificate_credentials res, const char* CAFILE, 
-    gnutls_x509_crt_fmt);
-int gnutls_certificate_set_x509_trust_mem(gnutls_certificate_credentials res, 
-    const gnutls_datum *CA, gnutls_x509_crt_fmt);
+int gnutls_certificate_set_x509_trust_file( gnutls_certificate_credentials_t res, const char* CAFILE, 
+    gnutls_x509_crt_fmt_t);
+int gnutls_certificate_set_x509_trust_mem(gnutls_certificate_credentials_t res, 
+    const gnutls_datum_t *CA, gnutls_x509_crt_fmt_t);
 
-int gnutls_certificate_set_x509_crl_file(gnutls_certificate_credentials res, 
-    const char *crlfile, gnutls_x509_crt_fmt type);
-int gnutls_certificate_set_x509_crl_mem(gnutls_certificate_credentials res, 
-    const gnutls_datum *CRL, gnutls_x509_crt_fmt type);
+int gnutls_certificate_set_x509_crl_file(gnutls_certificate_credentials_t res, 
+    const char *crlfile, gnutls_x509_crt_fmt_t type);
+int gnutls_certificate_set_x509_crl_mem(gnutls_certificate_credentials_t res, 
+    const gnutls_datum_t *CRL, gnutls_x509_crt_fmt_t type);
 
-int gnutls_certificate_set_x509_key_file( gnutls_certificate_credentials res, 
-    const char *CERTFILE, const char* KEYFILE, gnutls_x509_crt_fmt);
-int gnutls_certificate_set_x509_key_mem(gnutls_certificate_credentials res, 
-    const gnutls_datum* CERT, const gnutls_datum* KEY,
-    gnutls_x509_crt_fmt);
+int gnutls_certificate_set_x509_key_file( gnutls_certificate_credentials_t res, 
+    const char *CERTFILE, const char* KEYFILE, gnutls_x509_crt_fmt_t);
+int gnutls_certificate_set_x509_key_mem(gnutls_certificate_credentials_t res, 
+    const gnutls_datum_t* CERT, const gnutls_datum_t* KEY,
+    gnutls_x509_crt_fmt_t);
 
 
 /* New functions to allow setting already parsed X.509 stuff.
  */
 struct gnutls_x509_privkey_int;
-typedef struct gnutls_x509_privkey_int* gnutls_x509_privkey;
+typedef struct gnutls_x509_privkey_int* gnutls_x509_privkey_t;
 
 struct gnutls_x509_crl_int;
-typedef struct gnutls_x509_crl_int* gnutls_x509_crl;
+typedef struct gnutls_x509_crl_int* gnutls_x509_crl_t;
 
 struct gnutls_x509_crt_int;
-typedef struct gnutls_x509_crt_int* gnutls_x509_crt;
+typedef struct gnutls_x509_crt_int* gnutls_x509_crt_t;
 
-int gnutls_certificate_set_x509_key(gnutls_certificate_credentials res, 
-    gnutls_x509_crt *cert_list, int cert_list_size,
-    gnutls_x509_privkey key);
-int gnutls_certificate_set_x509_trust(gnutls_certificate_credentials res, 
-    gnutls_x509_crt * ca_list, int ca_list_size);
-int gnutls_certificate_set_x509_crl(gnutls_certificate_credentials res, 
-    gnutls_x509_crl* crl_list, int crl_list_size);
+int gnutls_certificate_set_x509_key(gnutls_certificate_credentials_t res, 
+    gnutls_x509_crt_t *cert_list, int cert_list_size,
+    gnutls_x509_privkey_t key);
+int gnutls_certificate_set_x509_trust(gnutls_certificate_credentials_t res, 
+    gnutls_x509_crt_t * ca_list, int ca_list_size);
+int gnutls_certificate_set_x509_crl(gnutls_certificate_credentials_t res, 
+    gnutls_x509_crl_t* crl_list, int crl_list_size);
 
 
 /* global state functions 
@@ -429,69 +431,69 @@ void gnutls_global_set_log_level( int level);
 
 /* Diffie Hellman parameter handling.
  */
-int gnutls_dh_params_init( gnutls_dh_params*);
-void gnutls_dh_params_deinit( gnutls_dh_params);
-int gnutls_dh_params_import_raw(gnutls_dh_params dh_params, const gnutls_datum *prime,
-    const gnutls_datum* generator);
-int gnutls_dh_params_import_pkcs3(gnutls_dh_params params, 
-    const gnutls_datum * pkcs3_params, gnutls_x509_crt_fmt format);
-int gnutls_dh_params_generate2(gnutls_dh_params params, int bits);
-int gnutls_dh_params_export_pkcs3( gnutls_dh_params params,
-    gnutls_x509_crt_fmt format, unsigned char* params_data, size_t* params_data_size);
-int gnutls_dh_params_export_raw(gnutls_dh_params params,
-    gnutls_datum * prime, gnutls_datum * generator, unsigned int *bits);
-int gnutls_dh_params_cpy(gnutls_dh_params dst, gnutls_dh_params src);
+int gnutls_dh_params_init( gnutls_dh_params_t*);
+void gnutls_dh_params_deinit( gnutls_dh_params_t);
+int gnutls_dh_params_import_raw(gnutls_dh_params_t dh_params, const gnutls_datum_t *prime,
+    const gnutls_datum_t* generator);
+int gnutls_dh_params_import_pkcs3(gnutls_dh_params_t params, 
+    const gnutls_datum_t * pkcs3_params, gnutls_x509_crt_fmt_t format);
+int gnutls_dh_params_generate2(gnutls_dh_params_t params, int bits);
+int gnutls_dh_params_export_pkcs3( gnutls_dh_params_t params,
+    gnutls_x509_crt_fmt_t format, unsigned char* params_data, size_t* params_data_size);
+int gnutls_dh_params_export_raw(gnutls_dh_params_t params,
+    gnutls_datum_t * prime, gnutls_datum_t * generator, unsigned int *bits);
+int gnutls_dh_params_cpy(gnutls_dh_params_t dst, gnutls_dh_params_t src);
 
 
 /* RSA params 
  */
-int gnutls_rsa_params_init(gnutls_rsa_params * rsa_params);
-void gnutls_rsa_params_deinit(gnutls_rsa_params rsa_params);
-int gnutls_rsa_params_cpy(gnutls_rsa_params dst, gnutls_rsa_params src);
-int gnutls_rsa_params_import_raw(gnutls_rsa_params rsa_params, 
-    const gnutls_datum *m, const gnutls_datum *e,
-    const gnutls_datum *d, const gnutls_datum *p, 
-    const gnutls_datum *q, const gnutls_datum *u);
-int gnutls_rsa_params_generate2(gnutls_rsa_params params, int bits);
-int gnutls_rsa_params_export_raw(gnutls_rsa_params params,
-    gnutls_datum * m, gnutls_datum *e,
-    gnutls_datum *d, gnutls_datum *p, gnutls_datum* q, 
-    gnutls_datum* u, unsigned int *bits);
-int gnutls_rsa_params_export_pkcs1( gnutls_rsa_params params,
-    gnutls_x509_crt_fmt format, unsigned char* params_data,
+int gnutls_rsa_params_init(gnutls_rsa_params_t * rsa_params);
+void gnutls_rsa_params_deinit(gnutls_rsa_params_t rsa_params);
+int gnutls_rsa_params_cpy(gnutls_rsa_params_t dst, gnutls_rsa_params_t src);
+int gnutls_rsa_params_import_raw(gnutls_rsa_params_t rsa_params, 
+    const gnutls_datum_t *m, const gnutls_datum_t *e,
+    const gnutls_datum_t *d, const gnutls_datum_t *p, 
+    const gnutls_datum_t *q, const gnutls_datum_t *u);
+int gnutls_rsa_params_generate2(gnutls_rsa_params_t params, int bits);
+int gnutls_rsa_params_export_raw(gnutls_rsa_params_t params,
+    gnutls_datum_t * m, gnutls_datum_t *e,
+    gnutls_datum_t *d, gnutls_datum_t *p, gnutls_datum_t* q, 
+    gnutls_datum_t* u, unsigned int *bits);
+int gnutls_rsa_params_export_pkcs1( gnutls_rsa_params_t params,
+    gnutls_x509_crt_fmt_t format, unsigned char* params_data,
     size_t* params_data_size);
-int gnutls_rsa_params_import_pkcs1(gnutls_rsa_params params,
-    const gnutls_datum * pkcs1_params, gnutls_x509_crt_fmt format);
+int gnutls_rsa_params_import_pkcs1(gnutls_rsa_params_t params,
+    const gnutls_datum_t * pkcs1_params, gnutls_x509_crt_fmt_t format);
 
 /* Session stuff
  */
-typedef ssize_t (*gnutls_pull_func)(gnutls_transport_ptr, void*, size_t);
-typedef ssize_t (*gnutls_push_func)(gnutls_transport_ptr, const void*, size_t);
-void gnutls_transport_set_ptr(gnutls_session session, gnutls_transport_ptr ptr);
-void gnutls_transport_set_ptr2(gnutls_session session, gnutls_transport_ptr recv_ptr,
-    gnutls_transport_ptr send_ptr);
+typedef ssize_t (*gnutls_pull_func)(gnutls_transport_ptr_t, void*, size_t);
+typedef ssize_t (*gnutls_push_func)(gnutls_transport_ptr_t, const void*, size_t);
+void gnutls_transport_set_ptr(gnutls_session_t session, gnutls_transport_ptr_t ptr);
+void gnutls_transport_set_ptr2(gnutls_session_t session, gnutls_transport_ptr_t recv_ptr,
+    gnutls_transport_ptr_t send_ptr);
 
-gnutls_transport_ptr gnutls_transport_get_ptr(gnutls_session session);
-void gnutls_transport_get_ptr2(gnutls_session session,
-    gnutls_transport_ptr *recv_ptr,
-    gnutls_transport_ptr *send_ptr);
+gnutls_transport_ptr_t gnutls_transport_get_ptr(gnutls_session_t session);
+void gnutls_transport_get_ptr2(gnutls_session_t session,
+    gnutls_transport_ptr_t *recv_ptr,
+    gnutls_transport_ptr_t *send_ptr);
 
-void gnutls_transport_set_lowat( gnutls_session session, int num);
+void gnutls_transport_set_lowat( gnutls_session_t session, int num);
 
 
-void gnutls_transport_set_push_function( gnutls_session, gnutls_push_func push_func);
-void gnutls_transport_set_pull_function( gnutls_session, gnutls_pull_func pull_func);
+void gnutls_transport_set_push_function( gnutls_session_t, gnutls_push_func push_func);
+void gnutls_transport_set_pull_function( gnutls_session_t, gnutls_pull_func pull_func);
 
 /* session specific 
  */
-void gnutls_session_set_ptr(gnutls_session session, void* ptr);
-void* gnutls_session_get_ptr(gnutls_session session);
+void gnutls_session_set_ptr(gnutls_session_t session, void* ptr);
+void* gnutls_session_get_ptr(gnutls_session_t session);
 
-void gnutls_openpgp_send_key(gnutls_session session, gnutls_openpgp_key_status status);
+void gnutls_openpgp_send_key(gnutls_session_t session, gnutls_openpgp_key_status_t status);
 
 /* fingerprint 
  * Actually this function returns the hash of the given data.
  */
-int gnutls_fingerprint(gnutls_digest_algorithm algo, const gnutls_datum* data, 
+int gnutls_fingerprint(gnutls_digest_algorithm_t algo, const gnutls_datum_t* data, 
     void* result, size_t* result_size);
 
diff --git a/lib/gnutls_alert.c b/lib/gnutls_alert.c
index 3e70b46027..3bd3f83e86 100644
--- a/lib/gnutls_alert.c
+++ b/lib/gnutls_alert.c
@@ -27,7 +27,7 @@
 #include <debug.h>
 
 typedef struct {
-    gnutls_alert_description alert;
+    gnutls_alert_description_t alert;
     const char *desc;
 } gnutls_alert_entry;
 
@@ -75,13 +75,13 @@ static const gnutls_alert_entry sup_alerts[] = {
 
 /**
   * gnutls_alert_get_name - Returns a string describing the alert number given
-  * @alert: is an alert number &gnutls_session structure.
+  * @alert: is an alert number &gnutls_session_t structure.
   *
   * Returns a string that describes the given alert number or NULL.
   * See gnutls_alert_get().
   *
   **/
-const char *gnutls_alert_get_name(gnutls_alert_level alert)
+const char *gnutls_alert_get_name(gnutls_alert_level_t alert)
 {
     const char *ret = NULL;
 
@@ -92,7 +92,7 @@ const char *gnutls_alert_get_name(gnutls_alert_level alert)
 
 /**
   * gnutls_alert_send - This function sends an alert message to the peer
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @level: is the level of the alert
   * @desc: is the alert description
   *
@@ -107,8 +107,8 @@ const char *gnutls_alert_get_name(gnutls_alert_level alert)
   * Returns 0 on success.
   *
   **/
-int gnutls_alert_send(gnutls_session session, gnutls_alert_level level,
-		      gnutls_alert_description desc)
+int gnutls_alert_send(gnutls_session_t session, gnutls_alert_level_t level,
+		      gnutls_alert_description_t desc)
 {
     uint8 data[2];
     int ret;
@@ -244,7 +244,7 @@ int gnutls_error_to_alert(int err, int *level)
  */
 /*-
   * gnutls_alert_send_appropriate - This function sends an alert to the peer depending on the error code
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @err: is an integer
   *
   * Sends an alert to the peer depending on the error code returned by a gnutls
@@ -257,7 +257,7 @@ int gnutls_error_to_alert(int err, int *level)
   * been sent to the peer.
   *
   -*/
-int gnutls_alert_send_appropriate(gnutls_session session, int err)
+int gnutls_alert_send_appropriate(gnutls_session_t session, int err)
 {
     int alert;
     int level;
@@ -272,7 +272,7 @@ int gnutls_alert_send_appropriate(gnutls_session session, int err)
 
 /**
   * gnutls_alert_get - Returns the last alert number received.
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * Returns the last alert number received. This function
   * should be called if GNUTLS_E_WARNING_ALERT_RECEIVED or
@@ -280,7 +280,7 @@ int gnutls_alert_send_appropriate(gnutls_session session, int err)
   * The peer may send alerts if he thinks some things were not 
   * right. Check gnutls.h for the available alert descriptions.
   **/
-gnutls_alert_description gnutls_alert_get(gnutls_session session)
+gnutls_alert_description_t gnutls_alert_get(gnutls_session_t session)
 {
     return session->internals.last_alert;
 }
diff --git a/lib/gnutls_alert.h b/lib/gnutls_alert.h
index b042c5a85a..ed1f122182 100644
--- a/lib/gnutls_alert.h
+++ b/lib/gnutls_alert.h
@@ -1,5 +1,5 @@
-typedef enum gnutls_alert_level { GNUTLS_AL_WARNING = 1, GNUTLS_AL_FATAL
-} gnutls_alert_level;
+typedef enum gnutls_alert_level_t { GNUTLS_AL_WARNING = 1, GNUTLS_AL_FATAL
+} gnutls_alert_level_t;
 
 typedef enum AlertDescription {
     GNUTLS_A_CLOSE_NOTIFY, GNUTLS_A_UNEXPECTED_MESSAGE = 10,
@@ -19,9 +19,9 @@ typedef enum AlertDescription {
 	112,
     GNUTLS_A_UNKNOWN_SRP_USERNAME = 120, GNUTLS_A_MISSING_SRP_USERNAME =
 	121
-} gnutls_alert_description;
+} gnutls_alert_description_t;
 
-gnutls_alert_description gnutls_alert_get(gnutls_session session);
-int gnutls_alert_send(gnutls_session session, gnutls_alert_level level,
-		      gnutls_alert_description desc);
-const char *gnutls_alert_get_name(gnutls_alert_level alert);
+gnutls_alert_description_t gnutls_alert_get(gnutls_session_t session);
+int gnutls_alert_send(gnutls_session_t session, gnutls_alert_level_t level,
+		      gnutls_alert_description_t desc);
+const char *gnutls_alert_get_name(gnutls_alert_level_t alert);
diff --git a/lib/gnutls_algorithms.c b/lib/gnutls_algorithms.c
index d0d3d8384e..e0ee6000db 100644
--- a/lib/gnutls_algorithms.c
+++ b/lib/gnutls_algorithms.c
@@ -31,9 +31,9 @@
  * more than one credentials type.
  */
 typedef struct {
-    gnutls_kx_algorithm algorithm;
-    gnutls_credentials_type client_type;
-    gnutls_credentials_type server_type;	/* The type of credentials a server
+    gnutls_kx_algorithm_t algorithm;
+    gnutls_credentials_type_t client_type;
+    gnutls_credentials_type_t server_type;	/* The type of credentials a server
 						 * needs to set */
 } gnutls_cred_map;
 
@@ -61,8 +61,8 @@ static const gnutls_cred_map cred_mappings[] = {
 
 /* KX mappings to PK algorithms */
 typedef struct {
-    gnutls_kx_algorithm kx_algorithm;
-    gnutls_pk_algorithm pk_algorithm;
+    gnutls_kx_algorithm_t kx_algorithm;
+    gnutls_pk_algorithm_t pk_algorithm;
     enum encipher_type encipher_type;	/* CIPHER_ENCRYPT if this algorithm is to be used
 					   * for encryption, CIPHER_SIGN if signature only,
 					   * CIPHER_IGN if this does not apply at all.
@@ -100,7 +100,7 @@ static const gnutls_pk_map pk_mappings[] = {
 
 typedef struct {
     const char *name;
-    gnutls_protocol_version id;	/* gnutls internal version number */
+    gnutls_protocol_t id;	/* gnutls internal version number */
     int major;			/* defined by the protocol */
     int minor;			/* defined by the protocol */
     int supported;		/* 0 not supported, > 0 is supported */
@@ -123,7 +123,7 @@ static const gnutls_version_entry sup_versions[] = {
 
 struct gnutls_cipher_entry {
     const char *name;
-    gnutls_cipher_algorithm id;
+    gnutls_cipher_algorithm_t id;
     uint16 blocksize;
     uint16 keysize;
     cipher_type_t block;
@@ -161,7 +161,7 @@ static const gnutls_cipher_entry algorithms[] = {
 
 struct gnutls_hash_entry {
     const char *name;
-    gnutls_mac_algorithm id;
+    gnutls_mac_algorithm_t id;
 };
 typedef struct gnutls_hash_entry gnutls_hash_entry;
 
@@ -252,10 +252,10 @@ gnutls_kx_algo_entry _gnutls_kx_algorithms[MAX_KX_ALGOS] = {
 typedef struct {
     const char *name;
     cipher_suite_st id;
-    gnutls_cipher_algorithm block_algorithm;
-    gnutls_kx_algorithm kx_algorithm;
-    gnutls_mac_algorithm mac_algorithm;
-    gnutls_protocol_version version;	/* this cipher suite is supported
+    gnutls_cipher_algorithm_t block_algorithm;
+    gnutls_kx_algorithm_t kx_algorithm;
+    gnutls_mac_algorithm_t mac_algorithm;
+    gnutls_protocol_t version;	/* this cipher suite is supported
 					   * from 'version' and above;
 					 */
 } gnutls_cipher_suite_entry;
@@ -485,8 +485,8 @@ static const gnutls_cipher_suite_entry cs_algorithms[] = {
 
 /* Generic Functions */
 
-inline int _gnutls_mac_priority(gnutls_session session,
-				gnutls_mac_algorithm algorithm)
+inline int _gnutls_mac_priority(gnutls_session_t session,
+				gnutls_mac_algorithm_t algorithm)
 {				/* actually returns the priority */
     unsigned int i;
     for (i = 0;
@@ -505,7 +505,7 @@ inline int _gnutls_mac_priority(gnutls_session session,
   * Returns a string that contains the name
   * of the specified MAC algorithm or NULL.
   **/
-const char *gnutls_mac_get_name(gnutls_mac_algorithm algorithm)
+const char *gnutls_mac_get_name(gnutls_mac_algorithm_t algorithm)
 {
     const char *ret = NULL;
 
@@ -515,7 +515,7 @@ const char *gnutls_mac_get_name(gnutls_mac_algorithm algorithm)
     return ret;
 }
 
-int _gnutls_mac_is_ok(gnutls_mac_algorithm algorithm)
+int _gnutls_mac_is_ok(gnutls_mac_algorithm_t algorithm)
 {
     ssize_t ret = -1;
     GNUTLS_HASH_ALG_LOOP(ret = p->id);
@@ -528,8 +528,8 @@ int _gnutls_mac_is_ok(gnutls_mac_algorithm algorithm)
 
 /* Compression Functions */
 inline
-    int _gnutls_compression_priority(gnutls_session session,
-				     gnutls_compression_method algorithm)
+    int _gnutls_compression_priority(gnutls_session_t session,
+				     gnutls_compression_method_t algorithm)
 {				/* actually returns the priority */
     unsigned int i;
     for (i = 0;
@@ -549,7 +549,7 @@ inline
   * Returns a pointer to a string that contains the name
   * of the specified compression algorithm or NULL.
   **/
-const char *gnutls_compression_get_name(gnutls_compression_method
+const char *gnutls_compression_get_name(gnutls_compression_method_t
 					algorithm)
 {
     const char *ret = NULL;
@@ -562,7 +562,7 @@ const char *gnutls_compression_get_name(gnutls_compression_method
 }
 
 /* return the tls number of the specified algorithm */
-int _gnutls_compression_get_num(gnutls_compression_method algorithm)
+int _gnutls_compression_get_num(gnutls_compression_method_t algorithm)
 {
     int ret = -1;
 
@@ -572,7 +572,7 @@ int _gnutls_compression_get_num(gnutls_compression_method algorithm)
     return ret;
 }
 
-int _gnutls_compression_get_wbits(gnutls_compression_method algorithm)
+int _gnutls_compression_get_wbits(gnutls_compression_method_t algorithm)
 {
     int ret = -1;
     /* avoid prefix */
@@ -580,7 +580,7 @@ int _gnutls_compression_get_wbits(gnutls_compression_method algorithm)
     return ret;
 }
 
-int _gnutls_compression_get_mem_level(gnutls_compression_method algorithm)
+int _gnutls_compression_get_mem_level(gnutls_compression_method_t algorithm)
 {
     int ret = -1;
     /* avoid prefix */
@@ -588,7 +588,7 @@ int _gnutls_compression_get_mem_level(gnutls_compression_method algorithm)
     return ret;
 }
 
-int _gnutls_compression_get_comp_level(gnutls_compression_method algorithm)
+int _gnutls_compression_get_comp_level(gnutls_compression_method_t algorithm)
 {
     int ret = -1;
     /* avoid prefix */
@@ -599,9 +599,9 @@ int _gnutls_compression_get_comp_level(gnutls_compression_method algorithm)
 /* returns the gnutls internal ID of the TLS compression
  * method num
  */
-gnutls_compression_method _gnutls_compression_get_id(int num)
+gnutls_compression_method_t _gnutls_compression_get_id(int num)
 {
-    gnutls_compression_method ret = -1;
+    gnutls_compression_method_t ret = -1;
 
     /* avoid prefix */
     GNUTLS_COMPRESSION_ALG_LOOP_NUM(ret = p->id);
@@ -609,7 +609,7 @@ gnutls_compression_method _gnutls_compression_get_id(int num)
     return ret;
 }
 
-int _gnutls_compression_is_ok(gnutls_compression_method algorithm)
+int _gnutls_compression_is_ok(gnutls_compression_method_t algorithm)
 {
     ssize_t ret = -1;
     GNUTLS_COMPRESSION_ALG_LOOP(ret = p->id);
@@ -623,7 +623,7 @@ int _gnutls_compression_is_ok(gnutls_compression_method algorithm)
 
 
 /* CIPHER functions */
-int _gnutls_cipher_get_block_size(gnutls_cipher_algorithm algorithm)
+int _gnutls_cipher_get_block_size(gnutls_cipher_algorithm_t algorithm)
 {
     size_t ret = 0;
     GNUTLS_ALG_LOOP(ret = p->blocksize);
@@ -634,8 +634,8 @@ int _gnutls_cipher_get_block_size(gnutls_cipher_algorithm algorithm)
  /* returns the priority */
 inline
     int
-_gnutls_cipher_priority(gnutls_session session,
-			gnutls_cipher_algorithm algorithm)
+_gnutls_cipher_priority(gnutls_session_t session,
+			gnutls_cipher_algorithm_t algorithm)
 {
     unsigned int i;
     for (i = 0;
@@ -649,7 +649,7 @@ _gnutls_cipher_priority(gnutls_session session,
 }
 
 
-int _gnutls_cipher_is_block(gnutls_cipher_algorithm algorithm)
+int _gnutls_cipher_is_block(gnutls_cipher_algorithm_t algorithm)
 {
     size_t ret = 0;
 
@@ -666,7 +666,7 @@ int _gnutls_cipher_is_block(gnutls_cipher_algorithm algorithm)
   * Returns 0 if the given cipher is invalid.
   *
   **/
-size_t gnutls_cipher_get_key_size(gnutls_cipher_algorithm algorithm)
+size_t gnutls_cipher_get_key_size(gnutls_cipher_algorithm_t algorithm)
 {				/* In bytes */
     size_t ret = 0;
     GNUTLS_ALG_LOOP(ret = p->keysize);
@@ -674,7 +674,7 @@ size_t gnutls_cipher_get_key_size(gnutls_cipher_algorithm algorithm)
 
 }
 
-int _gnutls_cipher_get_iv_size(gnutls_cipher_algorithm algorithm)
+int _gnutls_cipher_get_iv_size(gnutls_cipher_algorithm_t algorithm)
 {				/* In bytes */
     size_t ret = 0;
     GNUTLS_ALG_LOOP(ret = p->iv);
@@ -682,7 +682,7 @@ int _gnutls_cipher_get_iv_size(gnutls_cipher_algorithm algorithm)
 
 }
 
-int _gnutls_cipher_get_export_flag(gnutls_cipher_algorithm algorithm)
+int _gnutls_cipher_get_export_flag(gnutls_cipher_algorithm_t algorithm)
 {				/* In bytes */
     size_t ret = 0;
     GNUTLS_ALG_LOOP(ret = p->export_flag);
@@ -697,7 +697,7 @@ int _gnutls_cipher_get_export_flag(gnutls_cipher_algorithm algorithm)
   * Returns a pointer to a string that contains the name
   * of the specified cipher or NULL.
   **/
-const char *gnutls_cipher_get_name(gnutls_cipher_algorithm algorithm)
+const char *gnutls_cipher_get_name(gnutls_cipher_algorithm_t algorithm)
 {
     const char *ret = NULL;
 
@@ -707,7 +707,7 @@ const char *gnutls_cipher_get_name(gnutls_cipher_algorithm algorithm)
     return ret;
 }
 
-int _gnutls_cipher_is_ok(gnutls_cipher_algorithm algorithm)
+int _gnutls_cipher_is_ok(gnutls_cipher_algorithm_t algorithm)
 {
     ssize_t ret = -1;
     GNUTLS_ALG_LOOP(ret = p->id);
@@ -720,7 +720,7 @@ int _gnutls_cipher_is_ok(gnutls_cipher_algorithm algorithm)
 
 
 /* Key EXCHANGE functions */
-mod_auth_st *_gnutls_kx_auth_struct(gnutls_kx_algorithm algorithm)
+mod_auth_st *_gnutls_kx_auth_struct(gnutls_kx_algorithm_t algorithm)
 {
     mod_auth_st *ret = NULL;
     GNUTLS_KX_ALG_LOOP(ret = p->auth_struct);
@@ -729,8 +729,8 @@ mod_auth_st *_gnutls_kx_auth_struct(gnutls_kx_algorithm algorithm)
 }
 
 
-inline int _gnutls_kx_priority(gnutls_session session,
-			       gnutls_kx_algorithm algorithm)
+inline int _gnutls_kx_priority(gnutls_session_t session,
+			       gnutls_kx_algorithm_t algorithm)
 {
     unsigned int i;
     for (i = 0;
@@ -749,7 +749,7 @@ inline int _gnutls_kx_priority(gnutls_session session,
   * Returns a pointer to a string that contains the name 
   * of the specified key exchange algorithm or NULL.
   **/
-const char *gnutls_kx_get_name(gnutls_kx_algorithm algorithm)
+const char *gnutls_kx_get_name(gnutls_kx_algorithm_t algorithm)
 {
     const char *ret = NULL;
 
@@ -759,7 +759,7 @@ const char *gnutls_kx_get_name(gnutls_kx_algorithm algorithm)
     return ret;
 }
 
-int _gnutls_kx_is_ok(gnutls_kx_algorithm algorithm)
+int _gnutls_kx_is_ok(gnutls_kx_algorithm_t algorithm)
 {
     ssize_t ret = -1;
     GNUTLS_KX_ALG_LOOP(ret = p->algorithm);
@@ -770,14 +770,14 @@ int _gnutls_kx_is_ok(gnutls_kx_algorithm algorithm)
     return ret;
 }
 
-int _gnutls_kx_needs_rsa_params(gnutls_kx_algorithm algorithm)
+int _gnutls_kx_needs_rsa_params(gnutls_kx_algorithm_t algorithm)
 {
     ssize_t ret = 0;
     GNUTLS_KX_ALG_LOOP(ret = p->needs_rsa_params);
     return ret;
 }
 
-int _gnutls_kx_needs_dh_params(gnutls_kx_algorithm algorithm)
+int _gnutls_kx_needs_dh_params(gnutls_kx_algorithm_t algorithm)
 {
     ssize_t ret = 0;
     GNUTLS_KX_ALG_LOOP(ret = p->needs_dh_params);
@@ -786,8 +786,8 @@ int _gnutls_kx_needs_dh_params(gnutls_kx_algorithm algorithm)
 
 
 /* Version */
-int _gnutls_version_priority(gnutls_session session,
-			     gnutls_protocol_version version)
+int _gnutls_version_priority(gnutls_session_t session,
+			     gnutls_protocol_t version)
 {				/* actually returns the priority */
     unsigned int i;
 
@@ -803,7 +803,7 @@ int _gnutls_version_priority(gnutls_session session,
     return -1;
 }
 
-gnutls_protocol_version _gnutls_version_lowest(gnutls_session session)
+gnutls_protocol_t _gnutls_version_lowest(gnutls_session_t session)
 {				/* returns the lowest version supported */
     unsigned int i, min = 0xff;
 
@@ -822,7 +822,7 @@ gnutls_protocol_version _gnutls_version_lowest(gnutls_session session)
     return min;
 }
 
-gnutls_protocol_version _gnutls_version_max(gnutls_session session)
+gnutls_protocol_t _gnutls_version_max(gnutls_session_t session)
 {				/* returns the maximum version supported */
     unsigned int i, max = 0x00;
 
@@ -849,7 +849,7 @@ gnutls_protocol_version _gnutls_version_max(gnutls_session session)
   * Returns a string that contains the name
   * of the specified TLS version or NULL.
   **/
-const char *gnutls_protocol_get_name(gnutls_protocol_version version)
+const char *gnutls_protocol_get_name(gnutls_protocol_t version)
 {
     const char *ret = NULL;
 
@@ -858,7 +858,7 @@ const char *gnutls_protocol_get_name(gnutls_protocol_version version)
     return ret;
 }
 
-int _gnutls_version_get_minor(gnutls_protocol_version version)
+int _gnutls_version_get_minor(gnutls_protocol_t version)
 {
     int ret = -1;
 
@@ -866,7 +866,7 @@ int _gnutls_version_get_minor(gnutls_protocol_version version)
     return ret;
 }
 
-gnutls_protocol_version _gnutls_version_get(int major, int minor)
+gnutls_protocol_t _gnutls_version_get(int major, int minor)
 {
     int ret = -1;
 
@@ -875,7 +875,7 @@ gnutls_protocol_version _gnutls_version_get(int major, int minor)
     return ret;
 }
 
-int _gnutls_version_get_major(gnutls_protocol_version version)
+int _gnutls_version_get_major(gnutls_protocol_t version)
 {
     int ret = -1;
 
@@ -886,8 +886,8 @@ int _gnutls_version_get_major(gnutls_protocol_version version)
 /* Version Functions */
 
 int
-_gnutls_version_is_supported(gnutls_session session,
-			     const gnutls_protocol_version version)
+_gnutls_version_is_supported(gnutls_session_t session,
+			     const gnutls_protocol_t version)
 {
     int ret = 0;
 
@@ -902,10 +902,10 @@ _gnutls_version_is_supported(gnutls_session session,
 }
 
 /* Type to KX mappings */
-gnutls_kx_algorithm _gnutls_map_kx_get_kx(gnutls_credentials_type type,
+gnutls_kx_algorithm_t _gnutls_map_kx_get_kx(gnutls_credentials_type_t type,
 					  int server)
 {
-    gnutls_kx_algorithm ret = -1;
+    gnutls_kx_algorithm_t ret = -1;
 
     if (server) {
 	GNUTLS_KX_MAP_ALG_LOOP_SERVER(ret = p->algorithm);
@@ -915,10 +915,10 @@ gnutls_kx_algorithm _gnutls_map_kx_get_kx(gnutls_credentials_type type,
     return ret;
 }
 
-gnutls_credentials_type _gnutls_map_kx_get_cred(gnutls_kx_algorithm
+gnutls_credentials_type_t _gnutls_map_kx_get_cred(gnutls_kx_algorithm_t
 						algorithm, int server)
 {
-    gnutls_credentials_type ret = -1;
+    gnutls_credentials_type_t ret = -1;
     if (server) {
 	GNUTLS_KX_MAP_LOOP(if (p->algorithm == algorithm) ret =
 			   p->server_type);
@@ -932,7 +932,7 @@ gnutls_credentials_type _gnutls_map_kx_get_cred(gnutls_kx_algorithm
 
 
 /* Cipher Suite's functions */
-gnutls_cipher_algorithm
+gnutls_cipher_algorithm_t
 _gnutls_cipher_suite_get_cipher_algo(const cipher_suite_st * suite)
 {
     int ret = 0;
@@ -940,7 +940,7 @@ _gnutls_cipher_suite_get_cipher_algo(const cipher_suite_st * suite)
     return ret;
 }
 
-gnutls_protocol_version
+gnutls_protocol_t
 _gnutls_cipher_suite_get_version(const cipher_suite_st * suite)
 {
     int ret = 0;
@@ -948,7 +948,7 @@ _gnutls_cipher_suite_get_version(const cipher_suite_st * suite)
     return ret;
 }
 
-gnutls_kx_algorithm _gnutls_cipher_suite_get_kx_algo(const cipher_suite_st
+gnutls_kx_algorithm_t _gnutls_cipher_suite_get_kx_algo(const cipher_suite_st
 						     * suite)
 {
     int ret = 0;
@@ -958,7 +958,7 @@ gnutls_kx_algorithm _gnutls_cipher_suite_get_kx_algo(const cipher_suite_st
 
 }
 
-gnutls_mac_algorithm
+gnutls_mac_algorithm_t
 _gnutls_cipher_suite_get_mac_algo(const cipher_suite_st * suite)
 {				/* In bytes */
     int ret = 0;
@@ -990,10 +990,10 @@ const char *_gnutls_cipher_suite_get_name(cipher_suite_st * suite)
   * by TLS or SSL depending of the protocol in use.
   *
   **/
-const char *gnutls_cipher_suite_get_name(gnutls_kx_algorithm kx_algorithm,
-					 gnutls_cipher_algorithm
+const char *gnutls_cipher_suite_get_name(gnutls_kx_algorithm_t kx_algorithm,
+					 gnutls_cipher_algorithm_t
 					 cipher_algorithm,
-					 gnutls_mac_algorithm
+					 gnutls_mac_algorithm_t
 					 mac_algorithm)
 {
     const char *ret = NULL;
@@ -1027,9 +1027,9 @@ inline static int _gnutls_cipher_suite_is_ok(cipher_suite_st * suite)
 
 #define MAX_ELEM_SIZE 4
 inline
-    static int _gnutls_partition(gnutls_session session, void *_base,
+    static int _gnutls_partition(gnutls_session_t session, void *_base,
 				 size_t nmemb, size_t size,
-				 int (*compar) (gnutls_session,
+				 int (*compar) (gnutls_session_t,
 						const void *,
 						const void *))
 {
@@ -1068,8 +1068,8 @@ inline
 }
 
 static void
-_gnutls_qsort(gnutls_session session, void *_base, size_t nmemb,
-	      size_t size, int (*compar) (gnutls_session, const void *,
+_gnutls_qsort(gnutls_session_t session, void *_base, size_t nmemb,
+	      size_t size, int (*compar) (gnutls_session_t, const void *,
 					  const void *))
 {
     unsigned int pivot;
@@ -1099,23 +1099,23 @@ _gnutls_qsort(gnutls_session session, void *_base, size_t nmemb,
  * For use with qsort 
  */
 static int
-_gnutls_compare_algo(gnutls_session session, const void *i_A1,
+_gnutls_compare_algo(gnutls_session_t session, const void *i_A1,
 		     const void *i_A2)
 {
-    gnutls_kx_algorithm kA1 =
+    gnutls_kx_algorithm_t kA1 =
 	_gnutls_cipher_suite_get_kx_algo((const cipher_suite_st *) i_A1);
-    gnutls_kx_algorithm kA2 =
+    gnutls_kx_algorithm_t kA2 =
 	_gnutls_cipher_suite_get_kx_algo((const cipher_suite_st *) i_A2);
-    gnutls_cipher_algorithm cA1 =
+    gnutls_cipher_algorithm_t cA1 =
 	_gnutls_cipher_suite_get_cipher_algo((const cipher_suite_st *)
 					     i_A1);
-    gnutls_cipher_algorithm cA2 =
+    gnutls_cipher_algorithm_t cA2 =
 	_gnutls_cipher_suite_get_cipher_algo((const cipher_suite_st *)
 					     i_A2);
-    gnutls_mac_algorithm mA1 =
+    gnutls_mac_algorithm_t mA1 =
 	_gnutls_cipher_suite_get_mac_algo((const cipher_suite_st *)
 					  i_A1);
-    gnutls_mac_algorithm mA2 =
+    gnutls_mac_algorithm_t mA2 =
 	_gnutls_cipher_suite_get_mac_algo((const cipher_suite_st *)
 					  i_A2);
 
@@ -1138,8 +1138,8 @@ _gnutls_compare_algo(gnutls_session session, const void *i_A1,
 
 #ifdef SORT_DEBUG
 static void
-_gnutls_bsort(gnutls_session session, void *_base, size_t nmemb,
-	      size_t size, int (*compar) (gnutls_session, const void *,
+_gnutls_bsort(gnutls_session_t session, void *_base, size_t nmemb,
+	      size_t size, int (*compar) (gnutls_session_t, const void *,
 					  const void *))
 {
     unsigned int i, j;
@@ -1159,7 +1159,7 @@ _gnutls_bsort(gnutls_session session, void *_base, size_t nmemb,
 #endif
 
 int
-_gnutls_supported_ciphersuites_sorted(gnutls_session session,
+_gnutls_supported_ciphersuites_sorted(gnutls_session_t session,
 				      cipher_suite_st ** ciphers)
 {
 
@@ -1194,7 +1194,7 @@ _gnutls_supported_ciphersuites_sorted(gnutls_session session,
 }
 
 int
-_gnutls_supported_ciphersuites(gnutls_session session,
+_gnutls_supported_ciphersuites(gnutls_session_t session,
 			       cipher_suite_st ** _ciphers)
 {
 
@@ -1202,7 +1202,7 @@ _gnutls_supported_ciphersuites(gnutls_session session,
     unsigned int count = CIPHER_SUITES_COUNT;
     cipher_suite_st *tmp_ciphers;
     cipher_suite_st *ciphers;
-    gnutls_protocol_version version;
+    gnutls_protocol_t version;
 
     if (count == 0) {
 	return 0;
@@ -1294,7 +1294,7 @@ _gnutls_supported_ciphersuites(gnutls_session session,
  */
 #define SUPPORTED_COMPRESSION_METHODS session->internals.compression_method_priority.algorithms
 int
-_gnutls_supported_compression_methods(gnutls_session session,
+_gnutls_supported_compression_methods(gnutls_session_t session,
 				      uint8 ** comp)
 {
     unsigned int i, j;
@@ -1336,7 +1336,7 @@ _gnutls_supported_compression_methods(gnutls_session session,
   * Returns a string (or NULL) that contains the name
   * of the specified certificate type.
   **/
-const char *gnutls_certificate_type_get_name(gnutls_certificate_type type)
+const char *gnutls_certificate_type_get_name(gnutls_certificate_type_t type)
 {
     const char *ret = NULL;
 
@@ -1348,12 +1348,12 @@ const char *gnutls_certificate_type_get_name(gnutls_certificate_type type)
     return ret;
 }
 
-/* returns the gnutls_pk_algorithm which is compatible with
- * the given gnutls_kx_algorithm.
+/* returns the gnutls_pk_algorithm_t which is compatible with
+ * the given gnutls_kx_algorithm_t.
  */
-gnutls_pk_algorithm _gnutls_map_pk_get_pk(gnutls_kx_algorithm kx_algorithm)
+gnutls_pk_algorithm_t _gnutls_map_pk_get_pk(gnutls_kx_algorithm_t kx_algorithm)
 {
-    gnutls_pk_algorithm ret = -1;
+    gnutls_pk_algorithm_t ret = -1;
 
     GNUTLS_PK_MAP_ALG_LOOP(ret = p->pk_algorithm)
 	return ret;
@@ -1364,7 +1364,7 @@ gnutls_pk_algorithm _gnutls_map_pk_get_pk(gnutls_kx_algorithm kx_algorithm)
  *
  * ex. GNUTLS_KX_RSA requires a certificate able to encrypt... so returns CIPHER_ENCRYPT.
  */
-enum encipher_type _gnutls_kx_encipher_type(gnutls_kx_algorithm
+enum encipher_type _gnutls_kx_encipher_type(gnutls_kx_algorithm_t
 					    kx_algorithm)
 {
     int ret = CIPHER_IGN;
@@ -1377,7 +1377,7 @@ enum encipher_type _gnutls_kx_encipher_type(gnutls_kx_algorithm
  */
 struct gnutls_sign_entry {
     const char *name;
-    gnutls_sign_algorithm id;
+    gnutls_sign_algorithm_t id;
 };
 typedef struct gnutls_sign_entry gnutls_sign_entry;
 
@@ -1405,7 +1405,7 @@ static const gnutls_sign_entry sign_algorithms[] = {
   * Returns a string that contains the name
   * of the specified sign algorithm or NULL.
   **/
-const char *gnutls_sign_algorithm_get_name(gnutls_sign_algorithm algorithm)
+const char *gnutls_sign_algorithm_get_name(gnutls_sign_algorithm_t algorithm)
 {
     const char *ret = NULL;
 
@@ -1419,7 +1419,7 @@ const char *gnutls_sign_algorithm_get_name(gnutls_sign_algorithm algorithm)
  */
 struct gnutls_pk_entry {
     const char *name;
-    gnutls_pk_algorithm id;
+    gnutls_pk_algorithm_t id;
 };
 typedef struct gnutls_pk_entry gnutls_pk_entry;
 
@@ -1445,7 +1445,7 @@ static const gnutls_pk_entry pk_algorithms[] = {
   * Returns a string that contains the name
   * of the specified public key algorithm or NULL.
   **/
-const char *gnutls_pk_algorithm_get_name(gnutls_pk_algorithm algorithm)
+const char *gnutls_pk_algorithm_get_name(gnutls_pk_algorithm_t algorithm)
 {
     const char *ret = NULL;
 
diff --git a/lib/gnutls_algorithms.h b/lib/gnutls_algorithms.h
index b43398a10d..409a0e2740 100644
--- a/lib/gnutls_algorithms.h
+++ b/lib/gnutls_algorithms.h
@@ -22,98 +22,98 @@
 
 /* functions for version */
 
-gnutls_protocol_version _gnutls_version_lowest(gnutls_session session);
-gnutls_protocol_version _gnutls_version_max(gnutls_session session);
-int _gnutls_version_priority(gnutls_session session,
-			     gnutls_protocol_version version);
-int _gnutls_version_is_supported(gnutls_session session,
-				 const gnutls_protocol_version version);
-int _gnutls_version_get_major(gnutls_protocol_version ver);
-int _gnutls_version_get_minor(gnutls_protocol_version ver);
-gnutls_protocol_version _gnutls_version_get(int major, int minor);
+gnutls_protocol_t _gnutls_version_lowest(gnutls_session_t session);
+gnutls_protocol_t _gnutls_version_max(gnutls_session_t session);
+int _gnutls_version_priority(gnutls_session_t session,
+			     gnutls_protocol_t version);
+int _gnutls_version_is_supported(gnutls_session_t session,
+				 const gnutls_protocol_t version);
+int _gnutls_version_get_major(gnutls_protocol_t ver);
+int _gnutls_version_get_minor(gnutls_protocol_t ver);
+gnutls_protocol_t _gnutls_version_get(int major, int minor);
 
 /* functions for macs */
-const char *gnutls_mac_get_name(gnutls_mac_algorithm algorithm);
-int _gnutls_mac_is_ok(gnutls_mac_algorithm algorithm);
-int _gnutls_mac_priority(gnutls_session session,
-			 gnutls_mac_algorithm algorithm);
+const char *gnutls_mac_get_name(gnutls_mac_algorithm_t algorithm);
+int _gnutls_mac_is_ok(gnutls_mac_algorithm_t algorithm);
+int _gnutls_mac_priority(gnutls_session_t session,
+			 gnutls_mac_algorithm_t algorithm);
 
 /* functions for cipher suites */
-int _gnutls_supported_ciphersuites(gnutls_session session,
+int _gnutls_supported_ciphersuites(gnutls_session_t session,
 				   cipher_suite_st ** ciphers);
-int _gnutls_supported_ciphersuites_sorted(gnutls_session session,
+int _gnutls_supported_ciphersuites_sorted(gnutls_session_t session,
 					  cipher_suite_st ** ciphers);
-int _gnutls_supported_compression_methods(gnutls_session session,
+int _gnutls_supported_compression_methods(gnutls_session_t session,
 					  uint8 ** comp);
 
 const char *_gnutls_cipher_suite_get_name(cipher_suite_st * algorithm);
-gnutls_cipher_algorithm _gnutls_cipher_suite_get_cipher_algo(const
+gnutls_cipher_algorithm_t _gnutls_cipher_suite_get_cipher_algo(const
 							     cipher_suite_st
 							     * algorithm);
-gnutls_kx_algorithm _gnutls_cipher_suite_get_kx_algo(const cipher_suite_st
+gnutls_kx_algorithm_t _gnutls_cipher_suite_get_kx_algo(const cipher_suite_st
 						     * algorithm);
-gnutls_mac_algorithm _gnutls_cipher_suite_get_mac_algo(const
+gnutls_mac_algorithm_t _gnutls_cipher_suite_get_mac_algo(const
 						       cipher_suite_st *
 						       algorithm);
-gnutls_protocol_version _gnutls_cipher_suite_get_version(const
+gnutls_protocol_t _gnutls_cipher_suite_get_version(const
 							 cipher_suite_st *
 							 algorithm);
 cipher_suite_st _gnutls_cipher_suite_get_suite_name(cipher_suite_st *
 						    algorithm);
 
 /* functions for ciphers */
-int _gnutls_cipher_priority(gnutls_session session,
-			    gnutls_cipher_algorithm algorithm);
-int _gnutls_cipher_get_block_size(gnutls_cipher_algorithm algorithm);
-int _gnutls_cipher_is_block(gnutls_cipher_algorithm algorithm);
-int _gnutls_cipher_is_ok(gnutls_cipher_algorithm algorithm);
-size_t gnutls_cipher_get_key_size(gnutls_cipher_algorithm algorithm);
-int _gnutls_cipher_get_iv_size(gnutls_cipher_algorithm algorithm);
-int _gnutls_cipher_get_export_flag(gnutls_cipher_algorithm algorithm);
-const char *gnutls_cipher_get_name(gnutls_cipher_algorithm algorithm);
+int _gnutls_cipher_priority(gnutls_session_t session,
+			    gnutls_cipher_algorithm_t algorithm);
+int _gnutls_cipher_get_block_size(gnutls_cipher_algorithm_t algorithm);
+int _gnutls_cipher_is_block(gnutls_cipher_algorithm_t algorithm);
+int _gnutls_cipher_is_ok(gnutls_cipher_algorithm_t algorithm);
+size_t gnutls_cipher_get_key_size(gnutls_cipher_algorithm_t algorithm);
+int _gnutls_cipher_get_iv_size(gnutls_cipher_algorithm_t algorithm);
+int _gnutls_cipher_get_export_flag(gnutls_cipher_algorithm_t algorithm);
+const char *gnutls_cipher_get_name(gnutls_cipher_algorithm_t algorithm);
 
 /* functions for key exchange */
-int _gnutls_kx_priority(gnutls_session session,
-			gnutls_kx_algorithm algorithm);
-int _gnutls_kx_needs_dh_params(gnutls_kx_algorithm algorithm);
-int _gnutls_kx_needs_rsa_params(gnutls_kx_algorithm algorithm);
+int _gnutls_kx_priority(gnutls_session_t session,
+			gnutls_kx_algorithm_t algorithm);
+int _gnutls_kx_needs_dh_params(gnutls_kx_algorithm_t algorithm);
+int _gnutls_kx_needs_rsa_params(gnutls_kx_algorithm_t algorithm);
 
 
-mod_auth_st *_gnutls_kx_auth_struct(gnutls_kx_algorithm algorithm);
-const char *gnutls_kx_get_name(gnutls_kx_algorithm algorithm);
-int _gnutls_kx_is_ok(gnutls_kx_algorithm algorithm);
+mod_auth_st *_gnutls_kx_auth_struct(gnutls_kx_algorithm_t algorithm);
+const char *gnutls_kx_get_name(gnutls_kx_algorithm_t algorithm);
+int _gnutls_kx_is_ok(gnutls_kx_algorithm_t algorithm);
 
 /* functions for compression */
-int _gnutls_compression_priority(gnutls_session session,
-				 gnutls_compression_method algorithm);
-int _gnutls_compression_is_ok(gnutls_compression_method algorithm);
-int _gnutls_compression_get_num(gnutls_compression_method algorithm);
-gnutls_compression_method _gnutls_compression_get_id(int num);
-const char *gnutls_compression_get_name(gnutls_compression_method
+int _gnutls_compression_priority(gnutls_session_t session,
+				 gnutls_compression_method_t algorithm);
+int _gnutls_compression_is_ok(gnutls_compression_method_t algorithm);
+int _gnutls_compression_get_num(gnutls_compression_method_t algorithm);
+gnutls_compression_method_t _gnutls_compression_get_id(int num);
+const char *gnutls_compression_get_name(gnutls_compression_method_t
 					algorithm);
 
-int _gnutls_compression_get_mem_level(gnutls_compression_method algorithm);
-int _gnutls_compression_get_comp_level(gnutls_compression_method
+int _gnutls_compression_get_mem_level(gnutls_compression_method_t algorithm);
+int _gnutls_compression_get_comp_level(gnutls_compression_method_t
 				       algorithm);
-int _gnutls_compression_get_wbits(gnutls_compression_method algorithm);
+int _gnutls_compression_get_wbits(gnutls_compression_method_t algorithm);
 
 /* Type to KX mappings */
-gnutls_kx_algorithm _gnutls_map_kx_get_kx(gnutls_credentials_type type,
+gnutls_kx_algorithm_t _gnutls_map_kx_get_kx(gnutls_credentials_type_t type,
 					  int server);
-gnutls_credentials_type _gnutls_map_kx_get_cred(gnutls_kx_algorithm
+gnutls_credentials_type_t _gnutls_map_kx_get_cred(gnutls_kx_algorithm_t
 						algorithm, int server);
 
 /* KX to PK mapping */
-gnutls_pk_algorithm _gnutls_map_pk_get_pk(gnutls_kx_algorithm
+gnutls_pk_algorithm_t _gnutls_map_pk_get_pk(gnutls_kx_algorithm_t
 					  kx_algorithm);
 
 enum encipher_type { CIPHER_ENCRYPT = 0, CIPHER_SIGN = 1, CIPHER_IGN };
 
-enum encipher_type _gnutls_kx_encipher_type(gnutls_kx_algorithm algorithm);
+enum encipher_type _gnutls_kx_encipher_type(gnutls_kx_algorithm_t algorithm);
 
 struct gnutls_kx_algo_entry {
     const char *name;
-    gnutls_kx_algorithm algorithm;
+    gnutls_kx_algorithm_t algorithm;
     mod_auth_st *auth_struct;
     int needs_dh_params;
     int needs_rsa_params;
@@ -122,7 +122,7 @@ typedef struct gnutls_kx_algo_entry gnutls_kx_algo_entry;
 
 struct gnutls_compression_entry {
     const char *name;
-    gnutls_compression_method id;
+    gnutls_compression_method_t id;
     int num;			/* the number reserved in TLS for the specific compression method */
 
     /* used in zlib compressor */
diff --git a/lib/gnutls_anon_cred.c b/lib/gnutls_anon_cred.c
index 55e088c06e..c2ac568ed4 100644
--- a/lib/gnutls_anon_cred.c
+++ b/lib/gnutls_anon_cred.c
@@ -34,13 +34,13 @@
 static const int anon_dummy;
 
 /**
-  * gnutls_anon_free_server_credentials - Used to free an allocated gnutls_anon_server_credentials structure
-  * @sc: is an &gnutls_anon_server_credentials structure.
+  * gnutls_anon_free_server_credentials - Used to free an allocated gnutls_anon_server_credentials_t structure
+  * @sc: is an &gnutls_anon_server_credentials_t structure.
   *
   * This structure is complex enough to manipulate directly thus
   * this helper function is provided in order to free (deallocate) it.
   **/
-void gnutls_anon_free_server_credentials(gnutls_anon_server_credentials sc)
+void gnutls_anon_free_server_credentials(gnutls_anon_server_credentials_t sc)
 {
 
     gnutls_free(sc);
@@ -48,14 +48,14 @@ void gnutls_anon_free_server_credentials(gnutls_anon_server_credentials sc)
 
 /*-
   * _gnutls_anon_get_dh_params - Returns the DH parameters pointer
-  * @sc: is an &gnutls_certificate_credentials structure.
+  * @sc: is an &gnutls_certificate_credentials_t structure.
   *
   * This function will return the dh parameters pointer.
   *
   -*/
-gnutls_dh_params _gnutls_anon_get_dh_params(const
-					    gnutls_anon_server_credentials
-					    sc, gnutls_session session)
+gnutls_dh_params_t _gnutls_anon_get_dh_params(const
+					    gnutls_anon_server_credentials_t
+					    sc, gnutls_session_t session)
 {
     gnutls_params_st params;
     int ret;
@@ -77,13 +77,13 @@ gnutls_dh_params _gnutls_anon_get_dh_params(const
 }
 
 /**
-  * gnutls_anon_allocate_server_credentials - Used to allocate an gnutls_anon_server_credentials structure
-  * @sc: is a pointer to an &gnutls_anon_server_credentials structure.
+  * gnutls_anon_allocate_server_credentials - Used to allocate an gnutls_anon_server_credentials_t structure
+  * @sc: is a pointer to an &gnutls_anon_server_credentials_t structure.
   *
   * This structure is complex enough to manipulate directly thus
   * this helper function is provided in order to allocate it.
   **/
-int gnutls_anon_allocate_server_credentials(gnutls_anon_server_credentials
+int gnutls_anon_allocate_server_credentials(gnutls_anon_server_credentials_t
 					    * sc)
 {
 
@@ -94,24 +94,24 @@ int gnutls_anon_allocate_server_credentials(gnutls_anon_server_credentials
 
 
 /**
-  * gnutls_anon_free_client_credentials - Used to free an allocated gnutls_anon_client_credentials structure
-  * @sc: is an &gnutls_anon_client_credentials structure.
+  * gnutls_anon_free_client_credentials - Used to free an allocated gnutls_anon_client_credentials_t structure
+  * @sc: is an &gnutls_anon_client_credentials_t structure.
   *
   * This structure is complex enough to manipulate directly thus
   * this helper function is provided in order to free (deallocate) it.
   **/
-void gnutls_anon_free_client_credentials(gnutls_anon_client_credentials sc)
+void gnutls_anon_free_client_credentials(gnutls_anon_client_credentials_t sc)
 {
 }
 
 /**
   * gnutls_allocate_anon_client_credentials - Used to allocate a credentials structure
-  * @sc: is a pointer to an &gnutls_anon_client_credentials structure.
+  * @sc: is a pointer to an &gnutls_anon_client_credentials_t structure.
   *
   * This structure is complex enough to manipulate directly thus
   * this helper function is provided in order to allocate it.
   **/
-int gnutls_anon_allocate_client_credentials(gnutls_anon_client_credentials
+int gnutls_anon_allocate_client_credentials(gnutls_anon_client_credentials_t
 					    * sc)
 {
     /* anon_dummy is only there for *sc not to be null.
diff --git a/lib/gnutls_auth.c b/lib/gnutls_auth.c
index 1819a6ab76..c4b547a4a8 100644
--- a/lib/gnutls_auth.c
+++ b/lib/gnutls_auth.c
@@ -36,12 +36,12 @@
 
 /**
   * gnutls_credentials_clear - Clears all the credentials previously set
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * Clears all the credentials previously set in this session.
   *
   **/
-void gnutls_credentials_clear(gnutls_session session)
+void gnutls_credentials_clear(gnutls_session_t session)
 {
     if (session->key && session->key->cred) {	/* beginning of the list */
 	auth_cred_st *ccred, *ncred;
@@ -61,7 +61,7 @@ void gnutls_credentials_clear(gnutls_session session)
  */
 /**
   * gnutls_credentials_set - Sets the needed credentials for the specified authentication algorithm.
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @type: is the type of the credentials
   * @cred: is a pointer to a structure.
   *
@@ -74,18 +74,18 @@ void gnutls_credentials_clear(gnutls_session session)
   * structure. Thus you will have to keep the structure allocated until   
   * you call gnutls_deinit(). ]
   *
-  * For GNUTLS_CRD_ANON cred should be gnutls_anon_client_credentials in case of a client.
-  * In case of a server it should be gnutls_anon_server_credentials.
+  * For GNUTLS_CRD_ANON cred should be gnutls_anon_client_credentials_t in case of a client.
+  * In case of a server it should be gnutls_anon_server_credentials_t.
   * 
-  * For GNUTLS_CRD_SRP cred should be gnutls_srp_client_credentials
-  * in case of a client, and gnutls_srp_server_credentials, in case
+  * For GNUTLS_CRD_SRP cred should be gnutls_srp_client_credentials_t
+  * in case of a client, and gnutls_srp_server_credentials_t, in case
   * of a server.
   *
-  * For GNUTLS_CRD_CERTIFICATE cred should be gnutls_certificate_credentials.
+  * For GNUTLS_CRD_CERTIFICATE cred should be gnutls_certificate_credentials_t.
   *
   **/
-int gnutls_credentials_set(gnutls_session session,
-			   gnutls_credentials_type type, void *cred)
+int gnutls_credentials_set(gnutls_session_t session,
+			   gnutls_credentials_type_t type, void *cred)
 {
     auth_cred_st *ccred = NULL, *pcred = NULL;
     int exists = 0;
@@ -137,7 +137,7 @@ int gnutls_credentials_set(gnutls_session session,
 
 /**
   * gnutls_auth_get_type - Returns the type of credentials for the current authentication schema.
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * Returns type of credentials for the current authentication schema.
   * The returned information is to be used to distinguish the function used
@@ -146,7 +146,7 @@ int gnutls_credentials_set(gnutls_session session,
   * Eg. for CERTIFICATE ciphersuites (key exchange algorithms: KX_RSA, KX_DHE_RSA),
   * the same function are to be used to access the authentication data.
   **/
-gnutls_credentials_type gnutls_auth_get_type(gnutls_session session)
+gnutls_credentials_type_t gnutls_auth_get_type(gnutls_session_t session)
 {
 /* This is not the credentials we must set, but the authentication data
  * we get by the peer, so it should be reversed.
@@ -162,14 +162,14 @@ gnutls_credentials_type gnutls_auth_get_type(gnutls_session session)
 
 /**
   * gnutls_auth_server_get_type - Returns the type of credentials for the server authentication schema.
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * Returns the type of credentials that were used for server authentication.
   * The returned information is to be used to distinguish the function used
   * to access authentication data.
   * 
   **/
-gnutls_credentials_type gnutls_auth_server_get_type(gnutls_session session)
+gnutls_credentials_type_t gnutls_auth_server_get_type(gnutls_session_t session)
 {
     return
 	_gnutls_map_kx_get_cred(_gnutls_cipher_suite_get_kx_algo
@@ -179,14 +179,14 @@ gnutls_credentials_type gnutls_auth_server_get_type(gnutls_session session)
 
 /**
   * gnutls_auth_client_get_type - Returns the type of credentials for the client authentication schema.
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * Returns the type of credentials that were used for client authentication.
   * The returned information is to be used to distinguish the function used
   * to access authentication data.
   * 
   **/
-gnutls_credentials_type gnutls_auth_client_get_type(gnutls_session session)
+gnutls_credentials_type_t gnutls_auth_client_get_type(gnutls_session_t session)
 {
     return
 	_gnutls_map_kx_get_cred(_gnutls_cipher_suite_get_kx_algo
@@ -199,8 +199,8 @@ gnutls_credentials_type gnutls_auth_client_get_type(gnutls_session session)
  * This returns a pointer to the linked list. Don't
  * free that!!!
  */
-const void *_gnutls_get_kx_cred(gnutls_session session,
-				gnutls_kx_algorithm algo, int *err)
+const void *_gnutls_get_kx_cred(gnutls_session_t session,
+				gnutls_kx_algorithm_t algo, int *err)
 {
     int server =
 	session->security_parameters.entity == GNUTLS_SERVER ? 1 : 0;
@@ -210,7 +210,7 @@ const void *_gnutls_get_kx_cred(gnutls_session session,
 }
 
 const void *_gnutls_get_cred(gnutls_key_st key,
-			     gnutls_credentials_type type, int *err)
+			     gnutls_credentials_type_t type, int *err)
 {
     const void *retval = NULL;
     int _err = -1;
@@ -240,7 +240,7 @@ const void *_gnutls_get_cred(gnutls_key_st key,
 
 /*-
   * _gnutls_get_auth_info - Returns a pointer to authentication information.
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * This function must be called after a succesful gnutls_handshake().
   * Returns a pointer to authentication information. That information
@@ -251,20 +251,20 @@ const void *_gnutls_get_cred(gnutls_key_st key,
   * In case of GNUTLS_CRD_CERTIFICATE returns a type of &cert_auth_info_t;
   * In case of GNUTLS_CRD_SRP returns a type of &srp_(server/client)_auth_info_t;
   -*/
-void *_gnutls_get_auth_info(gnutls_session session)
+void *_gnutls_get_auth_info(gnutls_session_t session)
 {
     return session->key->auth_info;
 }
 
 /*-
   * _gnutls_free_auth_info - Frees the auth info structure
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * This function frees the auth info structure and sets it to
   * null. It must be called since some structures contain malloced
   * elements.
   -*/
-void _gnutls_free_auth_info(gnutls_session session)
+void _gnutls_free_auth_info(gnutls_session_t session)
 {
     if (session == NULL || session->key == NULL) {
 	gnutls_assert();
@@ -310,8 +310,8 @@ void _gnutls_free_auth_info(gnutls_session session)
  * If allow change is !=0 then this will allow changing the auth
  * info structure to a different type.
  */
-int _gnutls_auth_info_set(gnutls_session session,
-			  gnutls_credentials_type type, int size,
+int _gnutls_auth_info_set(gnutls_session_t session,
+			  gnutls_credentials_type_t type, int size,
 			  int allow_change)
 {
     if (session->key->auth_info == NULL) {
diff --git a/lib/gnutls_auth.h b/lib/gnutls_auth.h
index 1012ad0b0d..28ac50a9dd 100644
--- a/lib/gnutls_auth.h
+++ b/lib/gnutls_auth.h
@@ -3,24 +3,19 @@
 
 typedef struct mod_auth_st_int {
     const char *name;		/* null terminated */
-    int (*gnutls_generate_server_certificate) (gnutls_session, opaque **);
-    int (*gnutls_generate_client_certificate) (gnutls_session, opaque **);
-    int (*gnutls_generate_server_kx) (gnutls_session, opaque **);
-    int (*gnutls_generate_client_kx) (gnutls_session, opaque **);	/* used in SRP */
-    int (*gnutls_generate_client_cert_vrfy) (gnutls_session, opaque **);
-    int (*gnutls_generate_server_certificate_request) (gnutls_session,
-						       opaque **);
+    int (*gnutls_generate_server_certificate) (gnutls_session_t, opaque **);
+    int (*gnutls_generate_client_certificate) (gnutls_session_t, opaque **);
+    int (*gnutls_generate_server_kx) (gnutls_session_t, opaque **);
+    int (*gnutls_generate_client_kx) (gnutls_session_t, opaque **);	/* used in SRP */
+    int (*gnutls_generate_client_cert_vrfy) (gnutls_session_t, opaque **);
+    int (*gnutls_generate_server_certificate_request) (gnutls_session_t, opaque **);
 
-    int (*gnutls_process_server_certificate) (gnutls_session, opaque *,
-					      size_t);
-    int (*gnutls_process_client_certificate) (gnutls_session, opaque *,
-					      size_t);
-    int (*gnutls_process_server_kx) (gnutls_session, opaque *, size_t);
-    int (*gnutls_process_client_kx) (gnutls_session, opaque *, size_t);
-    int (*gnutls_process_client_cert_vrfy) (gnutls_session, opaque *,
-					    size_t);
-    int (*gnutls_process_server_certificate_request) (gnutls_session,
-						      opaque *, size_t);
+    int (*gnutls_process_server_certificate) (gnutls_session_t, opaque *, size_t);
+    int (*gnutls_process_client_certificate) (gnutls_session_t, opaque *, size_t);
+    int (*gnutls_process_server_kx) (gnutls_session_t, opaque *, size_t);
+    int (*gnutls_process_client_kx) (gnutls_session_t, opaque *, size_t);
+    int (*gnutls_process_client_cert_vrfy) (gnutls_session_t, opaque *, size_t);
+    int (*gnutls_process_server_certificate_request) (gnutls_session_t, opaque *, size_t);
 } mod_auth_st;
 
 #endif
diff --git a/lib/gnutls_auth_int.h b/lib/gnutls_auth_int.h
index e0de2f440a..d4e690d6a7 100644
--- a/lib/gnutls_auth_int.h
+++ b/lib/gnutls_auth_int.h
@@ -1,13 +1,13 @@
-void gnutls_credentials_clear(gnutls_session session);
-int gnutls_credentials_set(gnutls_session session,
-			   gnutls_credentials_type type, void *cred);
-const void *_gnutls_get_cred(gnutls_key_st key, gnutls_credentials_type kx,
+void gnutls_credentials_clear(gnutls_session_t session);
+int gnutls_credentials_set(gnutls_session_t session,
+			   gnutls_credentials_type_t type, void *cred);
+const void *_gnutls_get_cred(gnutls_key_st key, gnutls_credentials_type_t kx,
 			     int *err);
-const void *_gnutls_get_kx_cred(gnutls_session session,
-				gnutls_kx_algorithm algo, int *err);
+const void *_gnutls_get_kx_cred(gnutls_session_t session,
+				gnutls_kx_algorithm_t algo, int *err);
 int _gnutls_generate_session_key(gnutls_key_st key);
-gnutls_credentials_type gnutls_auth_get_type(gnutls_session session);
-void *_gnutls_get_auth_info(gnutls_session session);
-int _gnutls_auth_info_set(gnutls_session session,
-			  gnutls_credentials_type type, int size,
+gnutls_credentials_type_t gnutls_auth_get_type(gnutls_session_t session);
+void *_gnutls_get_auth_info(gnutls_session_t session);
+int _gnutls_auth_info_set(gnutls_session_t session,
+			  gnutls_credentials_type_t type, int size,
 			  int allow_change);
diff --git a/lib/gnutls_buffers.c b/lib/gnutls_buffers.c
index 13fb79035f..ec48505118 100644
--- a/lib/gnutls_buffers.c
+++ b/lib/gnutls_buffers.c
@@ -77,7 +77,7 @@ inline static int RET(int err)
 /* Buffers received packets of type APPLICATION DATA and
  * HANDSHAKE DATA.
  */
-int _gnutls_record_buffer_put(content_type_t type, gnutls_session session,
+int _gnutls_record_buffer_put(content_type_t type, gnutls_session_t session,
 			      opaque * data, size_t length)
 {
     if (length == 0)
@@ -118,7 +118,7 @@ int _gnutls_record_buffer_put(content_type_t type, gnutls_session session,
 }
 
 int _gnutls_record_buffer_get_size(content_type_t type,
-				   gnutls_session session)
+				   gnutls_session_t session)
 {
     switch (type) {
     case GNUTLS_APPLICATION_DATA:
@@ -134,7 +134,7 @@ int _gnutls_record_buffer_get_size(content_type_t type,
 
 /**
   * gnutls_record_check_pending - checks if there are any data to receive in gnutls buffers.
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * This function checks if there are any data to receive
   * in the gnutls buffers. Returns the size of that data or 0.
@@ -143,13 +143,13 @@ int _gnutls_record_buffer_get_size(content_type_t type,
   * (gnutls leaves some data in the tcp buffer in order for select
   * to work).
   **/
-size_t gnutls_record_check_pending(gnutls_session session)
+size_t gnutls_record_check_pending(gnutls_session_t session)
 {
     return _gnutls_record_buffer_get_size(GNUTLS_APPLICATION_DATA,
 					  session);
 }
 
-int _gnutls_record_buffer_get(content_type_t type, gnutls_session session,
+int _gnutls_record_buffer_get(content_type_t type, gnutls_session_t session,
 			      opaque * data, size_t length)
 {
     if (length == 0 || data == NULL) {
@@ -215,14 +215,14 @@ int _gnutls_record_buffer_get(content_type_t type, gnutls_session session,
  *
  * Flags are only used if the default recv() function is being used.
  */
-static ssize_t _gnutls_read(gnutls_session session, void *iptr,
+static ssize_t _gnutls_read(gnutls_session_t session, void *iptr,
 			    size_t sizeOfPtr, int flags)
 {
     size_t left;
     ssize_t i = 0;
     char *ptr = iptr;
     uint j, x, sum = 0;
-    gnutls_transport_ptr fd = session->internals.transport_recv_ptr;
+    gnutls_transport_ptr_t fd = session->internals.transport_recv_ptr;
 
     session->internals.direction = 0;
 
@@ -302,7 +302,7 @@ static ssize_t _gnutls_read(gnutls_session session, void *iptr,
 /* This function is only used with berkeley style sockets.
  * Clears the peeked data (read with MSG_PEEK).
  */
-int _gnutls_io_clear_peeked_data(gnutls_session session)
+int _gnutls_io_clear_peeked_data(gnutls_session_t session)
 {
     char *peekdata;
     int ret, sum;
@@ -338,7 +338,7 @@ int _gnutls_io_clear_peeked_data(gnutls_session session)
 }
 
 
-void _gnutls_io_clear_read_buffer(gnutls_session session)
+void _gnutls_io_clear_read_buffer(gnutls_session_t session)
 {
     session->internals.record_recv_buffer.length = 0;
 }
@@ -352,7 +352,7 @@ void _gnutls_io_clear_read_buffer(gnutls_session session)
  * which are stored in a local (in the session) buffer. A pointer (iptr) to this buffer is returned.
  *
  */
-ssize_t _gnutls_io_read_buffered(gnutls_session session, opaque ** iptr,
+ssize_t _gnutls_io_read_buffered(gnutls_session_t session, opaque ** iptr,
 				 size_t sizeOfPtr,
 				 content_type_t recv_type)
 {
@@ -577,7 +577,7 @@ inline
  * to decrypt and verify the integrity. 
  *
  */
-ssize_t _gnutls_io_write_buffered(gnutls_session session, const void *iptr,
+ssize_t _gnutls_io_write_buffered(gnutls_session_t session, const void *iptr,
 				  size_t n)
 {
     size_t left;
@@ -585,7 +585,7 @@ ssize_t _gnutls_io_write_buffered(gnutls_session session, const void *iptr,
     ssize_t retval, i;
     const opaque *ptr;
     int ret;
-    gnutls_transport_ptr fd = session->internals.transport_send_ptr;
+    gnutls_transport_ptr_t fd = session->internals.transport_send_ptr;
 
     /* to know where the procedure was interrupted.
      */
@@ -701,7 +701,7 @@ ssize_t _gnutls_io_write_buffered(gnutls_session session, const void *iptr,
 /* This is exactly like write_buffered, but will use two buffers to read
  * from.
  */
-ssize_t _gnutls_io_write_buffered2(gnutls_session session,
+ssize_t _gnutls_io_write_buffered2(gnutls_session_t session,
 				   const void *iptr, size_t n,
 				   const void *iptr2, size_t n2)
 {
@@ -733,7 +733,7 @@ ssize_t _gnutls_io_write_buffered2(gnutls_session session,
  * TLS write buffer (ie. because the previous write was
  * interrupted.
  */
-ssize_t _gnutls_io_write_flush(gnutls_session session)
+ssize_t _gnutls_io_write_flush(gnutls_session_t session)
 {
     ssize_t ret;
 
@@ -751,7 +751,7 @@ ssize_t _gnutls_io_write_flush(gnutls_session session)
  * Handshake write buffer (ie. because the previous write was
  * interrupted.
  */
-ssize_t _gnutls_handshake_io_write_flush(gnutls_session session)
+ssize_t _gnutls_handshake_io_write_flush(gnutls_session_t session)
 {
     ssize_t ret;
     ret = _gnutls_handshake_io_send_int(session, 0, 0, NULL, 0);
@@ -774,9 +774,9 @@ ssize_t _gnutls_handshake_io_write_flush(gnutls_session session)
 /* This is a send function for the gnutls handshake 
  * protocol. Just makes sure that all data have been sent.
  */
-ssize_t _gnutls_handshake_io_send_int(gnutls_session session,
+ssize_t _gnutls_handshake_io_send_int(gnutls_session_t session,
 				      content_type_t type,
-				      HandshakeType htype,
+				      handshake_t htype,
 				      const void *iptr, size_t n)
 {
     size_t left;
@@ -892,9 +892,9 @@ ssize_t _gnutls_handshake_io_send_int(gnutls_session session,
 /* This is a receive function for the gnutls handshake 
  * protocol. Makes sure that we have received all data.
  */
-ssize_t _gnutls_handshake_io_recv_int(gnutls_session session,
+ssize_t _gnutls_handshake_io_recv_int(gnutls_session_t session,
 				      content_type_t type,
-				      HandshakeType htype, void *iptr,
+				      handshake_t htype, void *iptr,
 				      size_t sizeOfPtr)
 {
     size_t left;
@@ -988,7 +988,7 @@ ssize_t _gnutls_handshake_io_recv_int(gnutls_session session,
  * for finished messages to use them. Used in HMAC calculation
  * and finished messages.
  */
-int _gnutls_handshake_buffer_put(gnutls_session session, opaque * data,
+int _gnutls_handshake_buffer_put(gnutls_session_t session, opaque * data,
 				 size_t length)
 {
 
@@ -1013,7 +1013,7 @@ int _gnutls_handshake_buffer_put(gnutls_session session, opaque * data,
     return 0;
 }
 
-int _gnutls_handshake_buffer_get_size(gnutls_session session)
+int _gnutls_handshake_buffer_get_size(gnutls_session_t session)
 {
 
     return session->internals.handshake_hash_buffer.length;
@@ -1022,7 +1022,7 @@ int _gnutls_handshake_buffer_get_size(gnutls_session session)
 /* this function does not touch the buffer
  * and returns data from it (peek mode!)
  */
-int _gnutls_handshake_buffer_peek(gnutls_session session, opaque * data,
+int _gnutls_handshake_buffer_peek(gnutls_session_t session, opaque * data,
 				  size_t length)
 {
     if (length > session->internals.handshake_hash_buffer.length) {
@@ -1038,7 +1038,7 @@ int _gnutls_handshake_buffer_peek(gnutls_session session, opaque * data,
 /* this function does not touch the buffer
  * and returns data from it (peek mode!)
  */
-int _gnutls_handshake_buffer_get_ptr(gnutls_session session,
+int _gnutls_handshake_buffer_get_ptr(gnutls_session_t session,
 				     opaque ** data_ptr, size_t * length)
 {
     if (length != NULL)
@@ -1054,7 +1054,7 @@ int _gnutls_handshake_buffer_get_ptr(gnutls_session session,
 
 /* Does not free the buffer
  */
-int _gnutls_handshake_buffer_empty(gnutls_session session)
+int _gnutls_handshake_buffer_empty(gnutls_session_t session)
 {
 
     _gnutls_buffers_log("BUF[HSK]: Emptied buffer\n");
@@ -1065,7 +1065,7 @@ int _gnutls_handshake_buffer_empty(gnutls_session session)
 }
 
 
-int _gnutls_handshake_buffer_clear(gnutls_session session)
+int _gnutls_handshake_buffer_clear(gnutls_session_t session)
 {
 
     _gnutls_buffers_log("BUF[HSK]: Cleared Data from buffer\n");
diff --git a/lib/gnutls_buffers.h b/lib/gnutls_buffers.h
index b858d10860..c73a225c02 100644
--- a/lib/gnutls_buffers.h
+++ b/lib/gnutls_buffers.h
@@ -18,30 +18,30 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 
-int _gnutls_record_buffer_put(content_type_t type, gnutls_session session,
+int _gnutls_record_buffer_put(content_type_t type, gnutls_session_t session,
 			      opaque * data, size_t length);
 int _gnutls_record_buffer_get_size(content_type_t type,
-				   gnutls_session session);
-int _gnutls_record_buffer_get(content_type_t type, gnutls_session session,
+				   gnutls_session_t session);
+int _gnutls_record_buffer_get(content_type_t type, gnutls_session_t session,
 			      opaque * data, size_t length);
-ssize_t _gnutls_io_read_buffered(gnutls_session, opaque ** iptr, size_t n,
+ssize_t _gnutls_io_read_buffered(gnutls_session_t, opaque ** iptr, size_t n,
 				 content_type_t);
-void _gnutls_io_clear_read_buffer(gnutls_session);
-int _gnutls_io_clear_peeked_data(gnutls_session session);
+void _gnutls_io_clear_read_buffer(gnutls_session_t);
+int _gnutls_io_clear_peeked_data(gnutls_session_t session);
 
-ssize_t _gnutls_io_write_buffered(gnutls_session, const void *iptr,
+ssize_t _gnutls_io_write_buffered(gnutls_session_t, const void *iptr,
 				  size_t n);
-ssize_t _gnutls_io_write_buffered2(gnutls_session, const void *iptr,
+ssize_t _gnutls_io_write_buffered2(gnutls_session_t, const void *iptr,
 				   size_t n, const void *iptr2, size_t n2);
 
-int _gnutls_handshake_buffer_get_size(gnutls_session session);
-int _gnutls_handshake_buffer_peek(gnutls_session session, opaque * data,
+int _gnutls_handshake_buffer_get_size(gnutls_session_t session);
+int _gnutls_handshake_buffer_peek(gnutls_session_t session, opaque * data,
 				  size_t length);
-int _gnutls_handshake_buffer_put(gnutls_session session, opaque * data,
+int _gnutls_handshake_buffer_put(gnutls_session_t session, opaque * data,
 				 size_t length);
-int _gnutls_handshake_buffer_clear(gnutls_session session);
-int _gnutls_handshake_buffer_empty(gnutls_session session);
-int _gnutls_handshake_buffer_get_ptr(gnutls_session session,
+int _gnutls_handshake_buffer_clear(gnutls_session_t session);
+int _gnutls_handshake_buffer_empty(gnutls_session_t session);
+int _gnutls_handshake_buffer_get_ptr(gnutls_session_t session,
 				     opaque ** data_ptr, size_t * length);
 
 #define _gnutls_handshake_io_buffer_clear( session) \
@@ -49,11 +49,11 @@ int _gnutls_handshake_buffer_get_ptr(gnutls_session session,
         _gnutls_buffer_clear( &session->internals.handshake_recv_buffer); \
         session->internals.handshake_send_buffer_prev_size = 0
 
-ssize_t _gnutls_handshake_io_recv_int(gnutls_session, content_type_t,
-				      HandshakeType, void *, size_t);
-ssize_t _gnutls_handshake_io_send_int(gnutls_session, content_type_t,
-				      HandshakeType, const void *, size_t);
-ssize_t _gnutls_io_write_flush(gnutls_session session);
-ssize_t _gnutls_handshake_io_write_flush(gnutls_session session);
+ssize_t _gnutls_handshake_io_recv_int(gnutls_session_t, content_type_t,
+				      handshake_t, void *, size_t);
+ssize_t _gnutls_handshake_io_send_int(gnutls_session_t, content_type_t,
+				      handshake_t, const void *, size_t);
+ssize_t _gnutls_io_write_flush(gnutls_session_t session);
+ssize_t _gnutls_handshake_io_write_flush(gnutls_session_t session);
 
-size_t gnutls_record_check_pending(gnutls_session session);
+size_t gnutls_record_check_pending(gnutls_session_t session);
diff --git a/lib/gnutls_cert.c b/lib/gnutls_cert.c
index b2a9a942fe..a6bd211d9c 100644
--- a/lib/gnutls_cert.c
+++ b/lib/gnutls_cert.c
@@ -43,18 +43,18 @@
 #include "x509/x509.h"
 #include "x509/mpi.h"
 
-void gnutls_certificate_free_crls(gnutls_certificate_credentials sc);
+void gnutls_certificate_free_crls(gnutls_certificate_credentials_t sc);
 
 /**
-  * gnutls_certificate_free_keys - Used to free all the keys from a gnutls_certificate_credentials structure
-  * @sc: is an &gnutls_certificate_credentials structure.
+  * gnutls_certificate_free_keys - Used to free all the keys from a gnutls_certificate_credentials_t structure
+  * @sc: is an &gnutls_certificate_credentials_t structure.
   *
   * This function will delete all the keys and the certificates associated
   * with the given credentials. This function must not be called when a
   * TLS negotiation that uses the credentials is in progress.
   *
   **/
-void gnutls_certificate_free_keys(gnutls_certificate_credentials sc)
+void gnutls_certificate_free_keys(gnutls_certificate_credentials_t sc)
 {
     uint i, j;
 
@@ -83,8 +83,8 @@ void gnutls_certificate_free_keys(gnutls_certificate_credentials sc)
 }
 
 /**
-  * gnutls_certificate_free_cas - Used to free all the CAs from a gnutls_certificate_credentials structure
-  * @sc: is an &gnutls_certificate_credentials structure.
+  * gnutls_certificate_free_cas - Used to free all the CAs from a gnutls_certificate_credentials_t structure
+  * @sc: is an &gnutls_certificate_credentials_t structure.
   *
   * This function will delete all the CAs associated
   * with the given credentials. Servers that do not use
@@ -92,7 +92,7 @@ void gnutls_certificate_free_keys(gnutls_certificate_credentials sc)
   * save some memory.
   *
   **/
-void gnutls_certificate_free_cas(gnutls_certificate_credentials sc)
+void gnutls_certificate_free_cas(gnutls_certificate_credentials_t sc)
 {
     uint j;
 
@@ -108,8 +108,8 @@ void gnutls_certificate_free_cas(gnutls_certificate_credentials sc)
 }
 
 /**
-  * gnutls_certificate_free_ca_names - Used to free all the CA names from a gnutls_certificate_credentials structure
-  * @sc: is an &gnutls_certificate_credentials structure.
+  * gnutls_certificate_free_ca_names - Used to free all the CA names from a gnutls_certificate_credentials_t structure
+  * @sc: is an &gnutls_certificate_credentials_t structure.
   *
   * This function will delete all the CA name in the
   * given credentials. Clients may call this to save some memory
@@ -119,24 +119,24 @@ void gnutls_certificate_free_cas(gnutls_certificate_credentials sc)
   * support to clients.
   *
   **/
-void gnutls_certificate_free_ca_names(gnutls_certificate_credentials sc)
+void gnutls_certificate_free_ca_names(gnutls_certificate_credentials_t sc)
 {
     _gnutls_free_datum(&sc->x509_rdn_sequence);
 }
 
 /*-
   * _gnutls_certificate_get_dh_params - Returns the DH parameters pointer
-  * @sc: is an &gnutls_certificate_credentials structure.
+  * @sc: is an &gnutls_certificate_credentials_t structure.
   *
   * This function will return the dh parameters pointer. This will read the
   * credentials structure, and cache the output to the session, so later
   * calls would not examine the credentials (or call a callback).
   *
   -*/
-gnutls_dh_params _gnutls_certificate_get_dh_params(const
-						   gnutls_certificate_credentials
+gnutls_dh_params_t _gnutls_certificate_get_dh_params(const
+						   gnutls_certificate_credentials_t
 						   sc,
-						   gnutls_session session)
+						   gnutls_session_t session)
 {
     gnutls_params_st params;
     int ret;
@@ -160,16 +160,13 @@ gnutls_dh_params _gnutls_certificate_get_dh_params(const
 
 /*-
   * _gnutls_certificate_get_rsa_params - Returns the RSA parameters pointer
-  * @sc: is an &gnutls_certificate_credentials structure.
+  * @sc: is an &gnutls_certificate_credentials_t structure.
   *
   * This function will return the rsa parameters pointer.
   *
   -*/
-gnutls_rsa_params _gnutls_certificate_get_rsa_params(const
-						     gnutls_certificate_credentials
-						     sc,
-						     gnutls_session
-						     session)
+gnutls_rsa_params_t _gnutls_certificate_get_rsa_params(const
+    gnutls_certificate_credentials_t sc, gnutls_session_t session)
 {
     gnutls_params_st params;
     int ret;
@@ -194,8 +191,8 @@ gnutls_rsa_params _gnutls_certificate_get_rsa_params(const
 
 
 /**
-  * gnutls_certificate_free_credentials - Used to free an allocated gnutls_certificate_credentials structure
-  * @sc: is an &gnutls_certificate_credentials structure.
+  * gnutls_certificate_free_credentials - Used to free an allocated gnutls_certificate_credentials_t structure
+  * @sc: is an &gnutls_certificate_credentials_t structure.
   *
   * This structure is complex enough to manipulate directly thus
   * this helper function is provided in order to free (deallocate) it.
@@ -204,7 +201,7 @@ gnutls_rsa_params _gnutls_certificate_get_rsa_params(const
   * with this structure (ie RSA and DH parameters are not freed by
   * this function).
   **/
-void gnutls_certificate_free_credentials(gnutls_certificate_credentials sc)
+void gnutls_certificate_free_credentials(gnutls_certificate_credentials_t sc)
 {
     gnutls_certificate_free_keys(sc);
     gnutls_certificate_free_cas(sc);
@@ -219,15 +216,15 @@ void gnutls_certificate_free_credentials(gnutls_certificate_credentials sc)
 
 
 /**
-  * gnutls_certificate_allocate_credentials - Used to allocate a gnutls_certificate_credentials structure
-  * @res: is a pointer to an &gnutls_certificate_credentials structure.
+  * gnutls_certificate_allocate_credentials - Used to allocate a gnutls_certificate_credentials_t structure
+  * @res: is a pointer to an &gnutls_certificate_credentials_t structure.
   *
   * This structure is complex enough to manipulate directly thus
   * this helper function is provided in order to allocate it.
   *
   * Returns 0 on success.
   **/
-int gnutls_certificate_allocate_credentials(gnutls_certificate_credentials
+int gnutls_certificate_allocate_credentials(gnutls_certificate_credentials_t
 					    * res)
 {
     *res = gnutls_calloc(1, sizeof(certificate_credentials_st));
@@ -245,13 +242,13 @@ int gnutls_certificate_allocate_credentials(gnutls_certificate_credentials
  * This function also uses the KeyUsage field of the certificate
  * extensions in order to disable unneded algorithms.
  */
-int _gnutls_selected_cert_supported_kx(gnutls_session session,
-				       gnutls_kx_algorithm ** alg,
+int _gnutls_selected_cert_supported_kx(gnutls_session_t session,
+				       gnutls_kx_algorithm_t ** alg,
 				       int *alg_size)
 {
-    gnutls_kx_algorithm kx;
-    gnutls_pk_algorithm pk;
-    gnutls_kx_algorithm kxlist[MAX_ALGOS];
+    gnutls_kx_algorithm_t kx;
+    gnutls_pk_algorithm_t pk;
+    gnutls_kx_algorithm_t kxlist[MAX_ALGOS];
     gnutls_cert *cert;
     int i;
 
@@ -280,13 +277,13 @@ int _gnutls_selected_cert_supported_kx(gnutls_session session,
 	return GNUTLS_E_INVALID_REQUEST;
     }
 
-    *alg = gnutls_calloc(1, sizeof(gnutls_kx_algorithm) * i);
+    *alg = gnutls_calloc(1, sizeof(gnutls_kx_algorithm_t) * i);
     if (*alg == NULL)
 	return GNUTLS_E_MEMORY_ERROR;
 
     *alg_size = i;
 
-    memcpy(*alg, kxlist, i * sizeof(gnutls_kx_algorithm));
+    memcpy(*alg, kxlist, i * sizeof(gnutls_kx_algorithm_t));
 
     return 0;
 }
@@ -294,7 +291,7 @@ int _gnutls_selected_cert_supported_kx(gnutls_session session,
 
 /**
   * gnutls_certificate_server_set_request - Used to set whether to request a client certificate
-  * @session: is an &gnutls_session structure.
+  * @session: is an &gnutls_session_t structure.
   * @req: is one of GNUTLS_CERT_REQUEST, GNUTLS_CERT_REQUIRE
   *
   * This function specifies if we (in case of a server) are going
@@ -304,22 +301,22 @@ int _gnutls_selected_cert_supported_kx(gnutls_session session,
   * call this function then the client will not be asked to
   * send a certificate.
   **/
-void gnutls_certificate_server_set_request(gnutls_session session,
-					   gnutls_certificate_request req)
+void gnutls_certificate_server_set_request(gnutls_session_t session,
+					   gnutls_certificate_request_t req)
 {
     session->internals.send_cert_req = req;
 }
 
 /**
   * gnutls_certificate_client_set_retrieve_function - Used to set a callback to retrieve the certificate
-  * @cred: is a &gnutls_certificate_credentials structure.
+  * @cred: is a &gnutls_certificate_credentials_t structure.
   * @func: is the callback function
   *
   * This function sets a callback to be called in order to retrieve the certificate
   * to be used in the handshake.
   * The callback's function prototype is:
-  * int (*callback)(gnutls_session, const gnutls_datum* req_ca_dn, int nreqs, 
-  * gnutls_pk_algorithm* pk_algos, int pk_algos_length, gnutls_retr_st st);
+  * int (*callback)(gnutls_session_t, const gnutls_datum_t* req_ca_dn, int nreqs, 
+  * gnutls_pk_algorithm_t* pk_algos, int pk_algos_length, gnutls_retr_st st);
   *
   * @st should contain the certificates and private keys.
   *
@@ -341,21 +338,21 @@ void gnutls_certificate_server_set_request(gnutls_session session,
   * will be terminated.
   **/
 void gnutls_certificate_client_set_retrieve_function
-    (gnutls_certificate_credentials cred,
+    (gnutls_certificate_credentials_t cred,
      gnutls_certificate_client_retrieve_function * func) {
     cred->client_get_cert_callback = func;
 }
 
 /**
   * gnutls_certificate_server_set_retrieve_function - Used to set a callback to retrieve the certificate
-  * @cred: is a &gnutls_certificate_credentials structure.
+  * @cred: is a &gnutls_certificate_credentials_t structure.
   * @func: is the callback function
   *
   * This function sets a callback to be called in order to retrieve the certificate
   * to be used in the handshake.
   * The callback's function prototype is:
-  * int (*callback)(gnutls_session, const gnutls_datum* req_ca_dn, int nreqs, 
-  * gnutls_pk_algorithm* pk_algos, int pk_algos_length, gnutls_retr_st st);
+  * int (*callback)(gnutls_session_t, const gnutls_datum_t* req_ca_dn, int nreqs, 
+  * gnutls_pk_algorithm_t* pk_algos, int pk_algos_length, gnutls_retr_st st);
   *
   * @st should contain the certificates and private keys.
   *
@@ -367,7 +364,7 @@ void gnutls_certificate_client_set_retrieve_function
   * will be terminated.
   **/
 void gnutls_certificate_server_set_retrieve_function
-    (gnutls_certificate_credentials cred,
+    (gnutls_certificate_credentials_t cred,
      gnutls_certificate_server_retrieve_function * func) {
     cred->server_get_cert_callback = func;
 }
@@ -390,10 +387,10 @@ OPENPGP_VERIFY_KEY_FUNC _E_gnutls_openpgp_verify_key = NULL;
   * Returns a negative error code in case of an error, or GNUTLS_E_NO_CERTIFICATE_FOUND if no certificate was sent.
   *
   -*/
-int _gnutls_openpgp_cert_verify_peers(gnutls_session session)
+int _gnutls_openpgp_cert_verify_peers(gnutls_session_t session)
 {
     cert_auth_info_t info;
-    const gnutls_certificate_credentials cred;
+    const gnutls_certificate_credentials_t cred;
     int verify;
     int peer_certificate_list_size;
 
@@ -450,13 +447,13 @@ int _gnutls_openpgp_cert_verify_peers(gnutls_session session)
   * However you must also check the peer's name in order to check if the verified certificate belongs to the
   * actual peer.
   *
-  * The return value should be one or more of the gnutls_certificate_status
+  * The return value should be one or more of the gnutls_certificate_status_t
   * enumerated elements bitwise or'd.
   *
   * This is the same as gnutls_x509_verify_certificate().
   *
   **/
-int gnutls_certificate_verify_peers(gnutls_session session)
+int gnutls_certificate_verify_peers(gnutls_session_t session)
 {
     cert_auth_info_t info;
 
@@ -489,7 +486,7 @@ int gnutls_certificate_verify_peers(gnutls_session session)
   * Returns (time_t) -1 on error.
   *
   **/
-time_t gnutls_certificate_expiration_time_peers(gnutls_session session)
+time_t gnutls_certificate_expiration_time_peers(gnutls_session_t session)
 {
     cert_auth_info_t info;
 
@@ -531,7 +528,7 @@ time_t gnutls_certificate_expiration_time_peers(gnutls_session session)
   * Returns (time_t) -1 on error.
   *
   **/
-time_t gnutls_certificate_activation_time_peers(gnutls_session session)
+time_t gnutls_certificate_activation_time_peers(gnutls_session_t session)
 {
     cert_auth_info_t info;
 
@@ -567,8 +564,8 @@ OPENPGP_RAW_KEY_TO_GCERT _E_gnutls_openpgp_raw_key_to_gcert;
 OPENPGP_RAW_PRIVKEY_TO_GKEY _E_gnutls_openpgp_raw_privkey_to_gkey;
 
 int _gnutls_raw_cert_to_gcert(gnutls_cert * gcert,
-			      gnutls_certificate_type type,
-			      const gnutls_datum * raw_cert,
+			      gnutls_certificate_type_t type,
+			      const gnutls_datum_t * raw_cert,
 			      int flags /* OR of ConvFlags */ )
 {
     switch (type) {
@@ -587,8 +584,8 @@ int _gnutls_raw_cert_to_gcert(gnutls_cert * gcert,
 }
 
 int _gnutls_raw_privkey_to_gkey(gnutls_privkey * key,
-				gnutls_certificate_type type,
-				const gnutls_datum * raw_key,
+				gnutls_certificate_type_t type,
+				const gnutls_datum_t * raw_key,
 				int key_enc /* DER or PEM */ )
 {
     switch (type) {
@@ -617,11 +614,10 @@ int _gnutls_raw_privkey_to_gkey(gnutls_privkey * key,
  * The critical extensions will be catched by the verification functions.
  */
 int _gnutls_x509_raw_cert_to_gcert(gnutls_cert * gcert,
-				   const gnutls_datum * derCert,
-				   int flags /* OR of ConvFlags */ )
+    const gnutls_datum_t * derCert, int flags /* OR of ConvFlags */ )
 {
     int ret;
-    gnutls_x509_crt cert;
+    gnutls_x509_crt_t cert;
 
     ret = gnutls_x509_crt_init(&cert);
     if (ret < 0) {
@@ -644,7 +640,7 @@ int _gnutls_x509_raw_cert_to_gcert(gnutls_cert * gcert,
 
 /* Like above but it accepts a parsed certificate instead.
  */
-int _gnutls_x509_crt_to_gcert(gnutls_cert * gcert, gnutls_x509_crt cert,
+int _gnutls_x509_crt_to_gcert(gnutls_cert * gcert, gnutls_x509_crt_t cert,
 			      unsigned int flags)
 {
     int ret = 0;
diff --git a/lib/gnutls_cert.h b/lib/gnutls_cert.h
index 37e1a821f6..82c5e260ee 100644
--- a/lib/gnutls_cert.h
+++ b/lib/gnutls_cert.h
@@ -37,7 +37,7 @@ typedef struct gnutls_cert {
 						 */
     int params_size;		/* holds the size of MPI params */
 
-    gnutls_pk_algorithm subject_pk_algorithm;
+    gnutls_pk_algorithm_t subject_pk_algorithm;
 
     unsigned int keyUsage;	/* bits from KEY_* 
 				 */
@@ -45,9 +45,9 @@ typedef struct gnutls_cert {
     unsigned int version;
     /* holds the type (PGP, X509)
      */
-    gnutls_certificate_type cert_type;
+    gnutls_certificate_type_t cert_type;
 
-    gnutls_datum raw;
+    gnutls_datum_t raw;
 
 } gnutls_cert;
 
@@ -70,10 +70,10 @@ typedef struct gnutls_privkey_int {
      */
     int params_size;		/* holds the number of params */
 
-    gnutls_pk_algorithm pk_algorithm;
+    gnutls_pk_algorithm_t pk_algorithm;
 } gnutls_privkey;
 
-struct gnutls_session_int;	/* because gnutls_session is not defined when this file is included */
+struct gnutls_session_int;	/* because gnutls_session_t is not defined when this file is included */
 
 typedef enum ConvFlags {
     CERT_NO_COPY = 2,
@@ -82,25 +82,25 @@ typedef enum ConvFlags {
 } ConvFlags;
 
 int _gnutls_x509_raw_cert_to_gcert(gnutls_cert * gcert,
-				   const gnutls_datum * derCert,
+				   const gnutls_datum_t * derCert,
 				   int flags);
-int _gnutls_x509_crt_to_gcert(gnutls_cert * gcert, gnutls_x509_crt cert,
+int _gnutls_x509_crt_to_gcert(gnutls_cert * gcert, gnutls_x509_crt_t cert,
 			      unsigned int flags);
 
 void _gnutls_gkey_deinit(gnutls_privkey * key);
 void _gnutls_gcert_deinit(gnutls_cert * cert);
 
 int _gnutls_selected_cert_supported_kx(struct gnutls_session_int *session,
-				       gnutls_kx_algorithm ** alg,
+				       gnutls_kx_algorithm_t ** alg,
 				       int *alg_size);
 
 int _gnutls_raw_cert_to_gcert(gnutls_cert * gcert,
-			      gnutls_certificate_type type,
-			      const gnutls_datum * raw_cert,
+			      gnutls_certificate_type_t type,
+			      const gnutls_datum_t * raw_cert,
 			      int flags /* OR of ConvFlags */ );
 int _gnutls_raw_privkey_to_gkey(gnutls_privkey * key,
-				gnutls_certificate_type type,
-				const gnutls_datum * raw_key,
+				gnutls_certificate_type_t type,
+				const gnutls_datum_t * raw_key,
 				int key_enc /* DER or PEM */ );
 
 #endif
diff --git a/lib/gnutls_cipher.c b/lib/gnutls_cipher.c
index 259a752abc..d59935bb8c 100644
--- a/lib/gnutls_cipher.c
+++ b/lib/gnutls_cipher.c
@@ -39,7 +39,7 @@
 #include "gnutls_record.h"
 #include "gnutls_constate.h"
 
-inline static int is_write_comp_null(gnutls_session session)
+inline static int is_write_comp_null(gnutls_session_t session)
 {
     if (session->security_parameters.write_compression_algorithm ==
 	GNUTLS_COMP_NULL)
@@ -48,7 +48,7 @@ inline static int is_write_comp_null(gnutls_session session)
     return 1;
 }
 
-inline static int is_read_comp_null(gnutls_session session)
+inline static int is_read_comp_null(gnutls_session_t session)
 {
     if (session->security_parameters.read_compression_algorithm ==
 	GNUTLS_COMP_NULL)
@@ -63,14 +63,14 @@ inline static int is_read_comp_null(gnutls_session session)
  * 
  * If random pad != 0 then the random pad data will be appended.
  */
-int _gnutls_encrypt(gnutls_session session, const opaque * headers,
+int _gnutls_encrypt(gnutls_session_t session, const opaque * headers,
 		    size_t headers_size, const opaque * data,
 		    size_t data_size, opaque * ciphertext,
 		    size_t ciphertext_size, content_type_t type,
 		    int random_pad)
 {
-    gnutls_datum plain;
-    gnutls_datum comp;
+    gnutls_datum_t plain;
+    gnutls_datum_t comp;
     int ret;
     int free_comp = 1;
 
@@ -114,12 +114,12 @@ int _gnutls_encrypt(gnutls_session session, const opaque * headers,
 /* Decrypts the given data.
  * Returns the decrypted data length.
  */
-int _gnutls_decrypt(gnutls_session session, opaque * ciphertext,
+int _gnutls_decrypt(gnutls_session_t session, opaque * ciphertext,
 		    size_t ciphertext_size, uint8 * data,
 		    size_t max_data_size, content_type_t type)
 {
-    gnutls_datum gtxt;
-    gnutls_datum gcipher;
+    gnutls_datum_t gtxt;
+    gnutls_datum_t gcipher;
     int ret;
 
     if (ciphertext_size == 0)
@@ -139,7 +139,7 @@ int _gnutls_decrypt(gnutls_session session, opaque * ciphertext,
 	/* ret == ret */
 
     } else {
-	gnutls_datum gcomp;
+	gnutls_datum_t gcomp;
 
 	/* compression has this malloc overhead.
 	 */
@@ -171,7 +171,7 @@ int _gnutls_decrypt(gnutls_session session, opaque * ciphertext,
 
 inline
     static mac_hd_t
-mac_init(gnutls_mac_algorithm mac, opaque * secret, int secret_size,
+mac_init(gnutls_mac_algorithm_t mac, opaque * secret, int secret_size,
 	 int ver)
 {
     mac_hd_t td;
@@ -198,7 +198,7 @@ inline static void mac_deinit(mac_hd_t td, opaque * res, int ver)
 }
 
 inline
-    static int calc_enc_length(gnutls_session session, int data_size,
+    static int calc_enc_length(gnutls_session_t session, int data_size,
 			       int hash_size, uint8 * pad, int random_pad,
 			       cipher_type_t block_algo, uint16 blocksize)
 {
@@ -253,9 +253,9 @@ inline
  * which has cipher_size size.
  * return the actual encrypted data length.
  */
-int _gnutls_compressed2ciphertext(gnutls_session session,
+int _gnutls_compressed2ciphertext(gnutls_session_t session,
 				  opaque * cipher_data, int cipher_size,
-				  gnutls_datum compressed,
+				  gnutls_datum_t compressed,
 				  content_type_t _type, int random_pad)
 {
     uint8 MAC[MAX_HASH_SIZE];
@@ -268,7 +268,7 @@ int _gnutls_compressed2ciphertext(gnutls_session session,
     int hash_size =
 	_gnutls_hash_get_algo_len(session->security_parameters.
 				  write_mac_algorithm);
-    gnutls_protocol_version ver;
+    gnutls_protocol_t ver;
     int blocksize =
 	_gnutls_cipher_get_block_size(session->security_parameters.
 				      write_bulk_cipher_algorithm);
@@ -370,10 +370,10 @@ int _gnutls_compressed2ciphertext(gnutls_session session,
 /* Deciphers the ciphertext packet, and puts the result to compress_data, of compress_size.
  * Returns the actual compressed packet size.
  */
-int _gnutls_ciphertext2compressed(gnutls_session session,
+int _gnutls_ciphertext2compressed(gnutls_session_t session,
 				  opaque * compress_data,
 				  int compress_size,
-				  gnutls_datum ciphertext, uint8 type)
+				  gnutls_datum_t ciphertext, uint8 type)
 {
     uint8 MAC[MAX_HASH_SIZE];
     uint16 c_length;
@@ -383,7 +383,7 @@ int _gnutls_ciphertext2compressed(gnutls_session session,
     uint16 blocksize;
     int ret, i, pad_failed = 0;
     uint8 major, minor;
-    gnutls_protocol_version ver;
+    gnutls_protocol_t ver;
     int hash_size =
 	_gnutls_hash_get_algo_len(session->security_parameters.
 				  read_mac_algorithm);
diff --git a/lib/gnutls_cipher.h b/lib/gnutls_cipher.h
index 972c01cf87..78414a98f0 100644
--- a/lib/gnutls_cipher.h
+++ b/lib/gnutls_cipher.h
@@ -18,20 +18,20 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 
-int _gnutls_encrypt(gnutls_session session, const opaque * headers,
+int _gnutls_encrypt(gnutls_session_t session, const opaque * headers,
 		    size_t headers_size, const opaque * data,
 		    size_t data_size, opaque * ciphertext,
 		    size_t ciphertext_size, content_type_t type,
 		    int random_pad);
 
-int _gnutls_decrypt(gnutls_session session, opaque * ciphertext,
+int _gnutls_decrypt(gnutls_session_t session, opaque * ciphertext,
 		    size_t ciphertext_size, uint8 * data, size_t data_size,
 		    content_type_t type);
-int _gnutls_compressed2ciphertext(gnutls_session session,
+int _gnutls_compressed2ciphertext(gnutls_session_t session,
 				  opaque * cipher_data, int cipher_size,
-				  gnutls_datum compressed,
+				  gnutls_datum_t compressed,
 				  content_type_t _type, int random_pad);
-int _gnutls_ciphertext2compressed(gnutls_session session,
+int _gnutls_ciphertext2compressed(gnutls_session_t session,
 				  opaque * compress_data,
 				  int compress_size,
-				  gnutls_datum ciphertext, uint8 type);
+				  gnutls_datum_t ciphertext, uint8 type);
diff --git a/lib/gnutls_cipher_int.c b/lib/gnutls_cipher_int.c
index 24ff0370ee..07cff67a67 100644
--- a/lib/gnutls_cipher_int.c
+++ b/lib/gnutls_cipher_int.c
@@ -25,9 +25,9 @@
 #include <gnutls_cipher_int.h>
 #include <gnutls_datum.h>
 
-cipher_hd_t _gnutls_cipher_init(gnutls_cipher_algorithm cipher,
-				const gnutls_datum * key,
-				const gnutls_datum * iv)
+cipher_hd_t _gnutls_cipher_init(gnutls_cipher_algorithm_t cipher,
+				const gnutls_datum_t * key,
+				const gnutls_datum_t * iv)
 {
     cipher_hd_t ret = NULL;
     gcry_error_t err = GPG_ERR_GENERAL;	/* doesn't matter */
diff --git a/lib/gnutls_cipher_int.h b/lib/gnutls_cipher_int.h
index c27631a319..3e51b7b421 100644
--- a/lib/gnutls_cipher_int.h
+++ b/lib/gnutls_cipher_int.h
@@ -24,12 +24,11 @@
 #define cipher_hd_t gcry_cipher_hd_t
 #define GNUTLS_CIPHER_FAILED NULL
 
-cipher_hd_t _gnutls_cipher_init(gnutls_cipher_algorithm cipher,
-				const gnutls_datum * key,
-				const gnutls_datum * iv);
+cipher_hd_t _gnutls_cipher_init(gnutls_cipher_algorithm_t cipher,
+    const gnutls_datum_t * key, const gnutls_datum_t * iv);
 int _gnutls_cipher_encrypt(cipher_hd_t handle, void *text, int textlen);
 int _gnutls_cipher_decrypt(cipher_hd_t handle, void *ciphertext,
-			   int ciphertextlen);
+    int ciphertextlen);
 void _gnutls_cipher_deinit(cipher_hd_t handle);
 
-#endif				/* GNUTLS_CIPHER_INT */
+#endif	/* GNUTLS_CIPHER_INT */
diff --git a/lib/gnutls_compress.c b/lib/gnutls_compress.c
index 80b3036110..26ff373e0c 100644
--- a/lib/gnutls_compress.c
+++ b/lib/gnutls_compress.c
@@ -31,9 +31,9 @@
 
 /* These functions allocate the return value internally
  */
-int _gnutls_m_plaintext2compressed(gnutls_session session,
-				   gnutls_datum *
-				   compress, gnutls_datum plaintext)
+int _gnutls_m_plaintext2compressed(gnutls_session_t session,
+				   gnutls_datum_t *
+				   compress, gnutls_datum_t plaintext)
 {
     int size;
     opaque *data;
@@ -52,9 +52,9 @@ int _gnutls_m_plaintext2compressed(gnutls_session session,
     return 0;
 }
 
-int _gnutls_m_compressed2plaintext(gnutls_session session,
-				   gnutls_datum * plain,
-				   gnutls_datum compressed)
+int _gnutls_m_compressed2plaintext(gnutls_session_t session,
+				   gnutls_datum_t * plain,
+				   gnutls_datum_t compressed)
 {
     int size;
     opaque *data;
diff --git a/lib/gnutls_compress.h b/lib/gnutls_compress.h
index 865344b982..2b6e25a490 100644
--- a/lib/gnutls_compress.h
+++ b/lib/gnutls_compress.h
@@ -18,9 +18,9 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 
-int _gnutls_m_plaintext2compressed(gnutls_session session,
-				   gnutls_datum * compress,
-				   gnutls_datum plaintext);
-int _gnutls_m_compressed2plaintext(gnutls_session session,
-				   gnutls_datum * plain,
-				   gnutls_datum compressed);
+int _gnutls_m_plaintext2compressed(gnutls_session_t session,
+				   gnutls_datum_t * compress,
+				   gnutls_datum_t plaintext);
+int _gnutls_m_compressed2plaintext(gnutls_session_t session,
+				   gnutls_datum_t * plain,
+				   gnutls_datum_t compressed);
diff --git a/lib/gnutls_compress_int.c b/lib/gnutls_compress_int.c
index bee6454f79..66bf42dd13 100644
--- a/lib/gnutls_compress_int.c
+++ b/lib/gnutls_compress_int.c
@@ -45,7 +45,7 @@ LZO_FUNC _gnutls_lzo1x_1_compress = NULL;
 /* The flag d is the direction (compress, decompress). Non zero is
  * decompress.
  */
-comp_hd_t _gnutls_comp_init(gnutls_compression_method method, int d)
+comp_hd_t _gnutls_comp_init(gnutls_compression_method_t method, int d)
 {
     comp_hd_t ret;
     int err;
diff --git a/lib/gnutls_compress_int.h b/lib/gnutls_compress_int.h
index f285ce828f..803747cc0b 100644
--- a/lib/gnutls_compress_int.h
+++ b/lib/gnutls_compress_int.h
@@ -29,10 +29,10 @@
 
 typedef struct comp_hd_t_STRUCT {
     void *handle;
-    gnutls_compression_method algo;
+    gnutls_compression_method_t algo;
 } *comp_hd_t;
 
-comp_hd_t _gnutls_comp_init(gnutls_compression_method, int d);
+comp_hd_t _gnutls_comp_init(gnutls_compression_method_t, int d);
 void _gnutls_comp_deinit(comp_hd_t handle, int d);
 
 int _gnutls_decompress(comp_hd_t handle, opaque * compressed,
diff --git a/lib/gnutls_constate.c b/lib/gnutls_constate.c
index 78fee15e2b..be5c83f1b3 100644
--- a/lib/gnutls_constate.c
+++ b/lib/gnutls_constate.c
@@ -52,7 +52,7 @@ static const int servwrite_length = sizeof(servwrite) - 1;
  * This function creates the keys and stores them into pending session.
  * (session->cipher_specs)
  */
-int _gnutls_set_keys(gnutls_session session, int hash_size, int IV_size,
+int _gnutls_set_keys(gnutls_session_t session, int hash_size, int IV_size,
 		     int key_size, int export_flag)
 {
 
@@ -349,13 +349,13 @@ int _gnutls_set_keys(gnutls_session session, int hash_size, int IV_size,
     return 0;
 }
 
-int _gnutls_set_read_keys(gnutls_session session)
+int _gnutls_set_read_keys(gnutls_session_t session)
 {
     int hash_size;
     int IV_size;
     int key_size, export_flag;
-    gnutls_cipher_algorithm algo;
-    gnutls_mac_algorithm mac_algo;
+    gnutls_cipher_algorithm_t algo;
+    gnutls_mac_algorithm_t mac_algo;
 
     mac_algo = session->security_parameters.read_mac_algorithm;
     algo = session->security_parameters.read_bulk_cipher_algorithm;
@@ -369,13 +369,13 @@ int _gnutls_set_read_keys(gnutls_session session)
 			    export_flag);
 }
 
-int _gnutls_set_write_keys(gnutls_session session)
+int _gnutls_set_write_keys(gnutls_session_t session)
 {
     int hash_size;
     int IV_size;
     int key_size, export_flag;
-    gnutls_cipher_algorithm algo;
-    gnutls_mac_algorithm mac_algo;
+    gnutls_cipher_algorithm_t algo;
+    gnutls_mac_algorithm_t mac_algo;
 
     mac_algo = session->security_parameters.write_mac_algorithm;
     algo = session->security_parameters.write_bulk_cipher_algorithm;
@@ -434,7 +434,7 @@ static void _gnutls_cpy_write_security_parameters(security_parameters_st *
  * secrets and random numbers to have been negotiated)
  * This is to be called after sending the Change Cipher Spec packet.
  */
-int _gnutls_connection_state_init(gnutls_session session)
+int _gnutls_connection_state_init(gnutls_session_t session)
 {
     int ret;
 
@@ -453,7 +453,7 @@ int _gnutls_connection_state_init(gnutls_session session)
 /* Initializes the read connection session
  * (read encrypted data)
  */
-int _gnutls_read_connection_state_init(gnutls_session session)
+int _gnutls_read_connection_state_init(gnutls_session_t session)
 {
     int mac_size;
     int rc;
@@ -632,7 +632,7 @@ int _gnutls_read_connection_state_init(gnutls_session session)
 /* Initializes the write connection session
  * (write encrypted data)
  */
-int _gnutls_write_connection_state_init(gnutls_session session)
+int _gnutls_write_connection_state_init(gnutls_session_t session)
 {
     int mac_size;
     int rc;
@@ -812,8 +812,8 @@ int _gnutls_write_connection_state_init(gnutls_session session)
 
 /* Sets the specified cipher into the pending session 
  */
-int _gnutls_set_read_cipher(gnutls_session session,
-			    gnutls_cipher_algorithm algo)
+int _gnutls_set_read_cipher(gnutls_session_t session,
+			    gnutls_cipher_algorithm_t algo)
 {
 
     if (_gnutls_cipher_is_ok(algo) == 0) {
@@ -833,8 +833,8 @@ int _gnutls_set_read_cipher(gnutls_session session,
 
 }
 
-int _gnutls_set_write_cipher(gnutls_session session,
-			     gnutls_cipher_algorithm algo)
+int _gnutls_set_write_cipher(gnutls_session_t session,
+			     gnutls_cipher_algorithm_t algo)
 {
 
     if (_gnutls_cipher_is_ok(algo) == 0) {
@@ -857,8 +857,8 @@ int _gnutls_set_write_cipher(gnutls_session session,
 
 /* Sets the specified algorithm into pending compression session 
  */
-int _gnutls_set_read_compression(gnutls_session session,
-				 gnutls_compression_method algo)
+int _gnutls_set_read_compression(gnutls_session_t session,
+				 gnutls_compression_method_t algo)
 {
 
     if (_gnutls_compression_is_ok(algo) == 0) {
@@ -871,8 +871,8 @@ int _gnutls_set_read_compression(gnutls_session session,
 
 }
 
-int _gnutls_set_write_compression(gnutls_session session,
-				  gnutls_compression_method algo)
+int _gnutls_set_write_compression(gnutls_session_t session,
+				  gnutls_compression_method_t algo)
 {
 
     if (_gnutls_compression_is_ok(algo) == 0) {
@@ -887,7 +887,7 @@ int _gnutls_set_write_compression(gnutls_session session,
 
 /* Sets the specified kx algorithm into pending session 
  */
-int _gnutls_set_kx(gnutls_session session, gnutls_kx_algorithm algo)
+int _gnutls_set_kx(gnutls_session_t session, gnutls_kx_algorithm_t algo)
 {
 
     if (_gnutls_kx_is_ok(algo) == 0) {
@@ -907,7 +907,7 @@ int _gnutls_set_kx(gnutls_session session, gnutls_kx_algorithm algo)
 }
 
 /* Sets the specified mac algorithm into pending session */
-int _gnutls_set_read_mac(gnutls_session session, gnutls_mac_algorithm algo)
+int _gnutls_set_read_mac(gnutls_session_t session, gnutls_mac_algorithm_t algo)
 {
 
     if (_gnutls_mac_is_ok(algo) == 0) {
@@ -926,8 +926,8 @@ int _gnutls_set_read_mac(gnutls_session session, gnutls_mac_algorithm algo)
 
 }
 
-int _gnutls_set_write_mac(gnutls_session session,
-			  gnutls_mac_algorithm algo)
+int _gnutls_set_write_mac(gnutls_session_t session,
+			  gnutls_mac_algorithm_t algo)
 {
 
     if (_gnutls_mac_is_ok(algo) == 0) {
diff --git a/lib/gnutls_constate.h b/lib/gnutls_constate.h
index 8a0e3deb70..57874af241 100644
--- a/lib/gnutls_constate.h
+++ b/lib/gnutls_constate.h
@@ -1,16 +1,16 @@
-int _gnutls_connection_state_init(gnutls_session session);
-int _gnutls_read_connection_state_init(gnutls_session session);
-int _gnutls_write_connection_state_init(gnutls_session session);
-int _gnutls_set_write_cipher(gnutls_session session,
-			     gnutls_cipher_algorithm algo);
-int _gnutls_set_write_mac(gnutls_session session,
-			  gnutls_mac_algorithm algo);
-int _gnutls_set_read_cipher(gnutls_session session,
-			    gnutls_cipher_algorithm algo);
-int _gnutls_set_read_mac(gnutls_session session,
-			 gnutls_mac_algorithm algo);
-int _gnutls_set_read_compression(gnutls_session session,
-				 gnutls_compression_method algo);
-int _gnutls_set_write_compression(gnutls_session session,
-				  gnutls_compression_method algo);
-int _gnutls_set_kx(gnutls_session session, gnutls_kx_algorithm algo);
+int _gnutls_connection_state_init(gnutls_session_t session);
+int _gnutls_read_connection_state_init(gnutls_session_t session);
+int _gnutls_write_connection_state_init(gnutls_session_t session);
+int _gnutls_set_write_cipher(gnutls_session_t session,
+			     gnutls_cipher_algorithm_t algo);
+int _gnutls_set_write_mac(gnutls_session_t session,
+			  gnutls_mac_algorithm_t algo);
+int _gnutls_set_read_cipher(gnutls_session_t session,
+			    gnutls_cipher_algorithm_t algo);
+int _gnutls_set_read_mac(gnutls_session_t session,
+			 gnutls_mac_algorithm_t algo);
+int _gnutls_set_read_compression(gnutls_session_t session,
+				 gnutls_compression_method_t algo);
+int _gnutls_set_write_compression(gnutls_session_t session,
+				  gnutls_compression_method_t algo);
+int _gnutls_set_kx(gnutls_session_t session, gnutls_kx_algorithm_t algo);
diff --git a/lib/gnutls_datum.c b/lib/gnutls_datum.c
index 667e88fbf4..b9ccc85ad8 100644
--- a/lib/gnutls_datum.c
+++ b/lib/gnutls_datum.c
@@ -31,32 +31,32 @@
 #include <gnutls_errors.h>
 
 
-void _gnutls_write_datum16(opaque * dest, gnutls_datum dat)
+void _gnutls_write_datum16(opaque * dest, gnutls_datum_t dat)
 {
     _gnutls_write_uint16(dat.size, dest);
     memcpy(&dest[2], dat.data, dat.size);
 }
 
-void _gnutls_write_datum24(opaque * dest, gnutls_datum dat)
+void _gnutls_write_datum24(opaque * dest, gnutls_datum_t dat)
 {
     _gnutls_write_uint24(dat.size, dest);
     memcpy(&dest[3], dat.data, dat.size);
 }
 
-void _gnutls_write_datum32(opaque * dest, gnutls_datum dat)
+void _gnutls_write_datum32(opaque * dest, gnutls_datum_t dat)
 {
     _gnutls_write_uint32(dat.size, dest);
     memcpy(&dest[4], dat.data, dat.size);
 }
 
-void _gnutls_write_datum8(opaque * dest, gnutls_datum dat)
+void _gnutls_write_datum8(opaque * dest, gnutls_datum_t dat)
 {
     dest[0] = (uint8) dat.size;
     memcpy(&dest[1], dat.data, dat.size);
 }
 
 
-int _gnutls_set_datum_m(gnutls_datum * dat, const void *data,
+int _gnutls_set_datum_m(gnutls_datum_t * dat, const void *data,
 			int data_size, gnutls_alloc_function galloc_func)
 {
     if (data_size == 0) {
@@ -75,7 +75,7 @@ int _gnutls_set_datum_m(gnutls_datum * dat, const void *data,
     return 0;
 }
 
-int _gnutls_datum_append_m(gnutls_datum * dst, const void *data,
+int _gnutls_datum_append_m(gnutls_datum_t * dst, const void *data,
 			   int data_size,
 			   gnutls_realloc_function grealloc_func)
 {
@@ -90,7 +90,7 @@ int _gnutls_datum_append_m(gnutls_datum * dst, const void *data,
     return 0;
 }
 
-void _gnutls_free_datum_m(gnutls_datum * dat,
+void _gnutls_free_datum_m(gnutls_datum_t * dat,
 			  gnutls_free_function gfree_func)
 {
     if (dat->data != NULL && dat->size != 0)
diff --git a/lib/gnutls_datum.h b/lib/gnutls_datum.h
index 8c6ee283de..cf0fdde7ab 100644
--- a/lib/gnutls_datum.h
+++ b/lib/gnutls_datum.h
@@ -1,16 +1,16 @@
-void _gnutls_write_datum16(opaque * dest, gnutls_datum dat);
-void _gnutls_write_datum24(opaque * dest, gnutls_datum dat);
-void _gnutls_write_datum32(opaque * dest, gnutls_datum dat);
-void _gnutls_write_datum8(opaque * dest, gnutls_datum dat);
+void _gnutls_write_datum16(opaque * dest, gnutls_datum_t dat);
+void _gnutls_write_datum24(opaque * dest, gnutls_datum_t dat);
+void _gnutls_write_datum32(opaque * dest, gnutls_datum_t dat);
+void _gnutls_write_datum8(opaque * dest, gnutls_datum_t dat);
 
-int _gnutls_set_datum_m(gnutls_datum * dat, const void *data,
+int _gnutls_set_datum_m(gnutls_datum_t * dat, const void *data,
 			int data_size, gnutls_alloc_function);
 #define _gnutls_set_datum( x, y, z) _gnutls_set_datum_m(x,y,z, gnutls_malloc)
 #define _gnutls_sset_datum( x, y, z) _gnutls_set_datum_m(x,y,z, gnutls_secure_malloc)
 
-int _gnutls_datum_append_m(gnutls_datum * dat, const void *data,
+int _gnutls_datum_append_m(gnutls_datum_t * dat, const void *data,
 			   int data_size, gnutls_realloc_function);
 #define _gnutls_datum_append(x,y,z) _gnutls_datum_append_m(x,y,z, gnutls_realloc)
 
-void _gnutls_free_datum_m(gnutls_datum * dat, gnutls_free_function);
+void _gnutls_free_datum_m(gnutls_datum_t * dat, gnutls_free_function);
 #define _gnutls_free_datum(x) _gnutls_free_datum_m(x, gnutls_free)
diff --git a/lib/gnutls_db.c b/lib/gnutls_db.c
index ee90096491..a519190cca 100644
--- a/lib/gnutls_db.c
+++ b/lib/gnutls_db.c
@@ -33,12 +33,12 @@
 
 /**
   * gnutls_db_set_retrieve_function - Sets the function that will be used to get data
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @retr_func: is the function.
   *
   * Sets the function that will be used to retrieve data from the resumed
-  * sessions database. This function must return a gnutls_datum containing the
-  * data on success, or a gnutls_datum containing null and 0 on failure.
+  * sessions database. This function must return a gnutls_datum_t containing the
+  * data on success, or a gnutls_datum_t containing null and 0 on failure.
   *
   * The datum's data must be allocated using the function
   * gnutls_malloc().
@@ -47,7 +47,7 @@
   * has been called.
   *
   **/
-void gnutls_db_set_retrieve_function(gnutls_session session,
+void gnutls_db_set_retrieve_function(gnutls_session_t session,
 				     gnutls_db_retr_func retr_func)
 {
     session->internals.db_retrieve_func = retr_func;
@@ -55,7 +55,7 @@ void gnutls_db_set_retrieve_function(gnutls_session session,
 
 /**
   * gnutls_db_set_remove_function - Sets the function that will be used to remove data
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @rem_func: is the function.
   *
   * Sets the function that will be used to remove data from the resumed
@@ -65,7 +65,7 @@ void gnutls_db_set_retrieve_function(gnutls_session session,
   * has been called.
   *
   **/
-void gnutls_db_set_remove_function(gnutls_session session,
+void gnutls_db_set_remove_function(gnutls_session_t session,
 				   gnutls_db_remove_func rem_func)
 {
     session->internals.db_remove_func = rem_func;
@@ -73,7 +73,7 @@ void gnutls_db_set_remove_function(gnutls_session session,
 
 /**
   * gnutls_db_set_store_function - Sets the function that will be used to put data
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @store_func: is the function
   *
   * Sets the function that will be used to store data from the resumed
@@ -83,7 +83,7 @@ void gnutls_db_set_remove_function(gnutls_session session,
   * has been called.
   *
   **/
-void gnutls_db_set_store_function(gnutls_session session,
+void gnutls_db_set_store_function(gnutls_session_t session,
 				  gnutls_db_store_func store_func)
 {
     session->internals.db_store_func = store_func;
@@ -91,47 +91,47 @@ void gnutls_db_set_store_function(gnutls_session session,
 
 /**
   * gnutls_db_set_ptr - Sets a pointer to be sent to db functions
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @ptr: is the pointer
   *
   * Sets the pointer that will be provided to db store, retrieve and delete functions, as
   * the first argument. 
   *
   **/
-void gnutls_db_set_ptr(gnutls_session session, void *ptr)
+void gnutls_db_set_ptr(gnutls_session_t session, void *ptr)
 {
     session->internals.db_ptr = ptr;
 }
 
 /**
   * gnutls_db_get_ptr - Returns the pointer which is sent to db functions
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * Returns the pointer that will be sent to db store, retrieve and delete functions, as
   * the first argument. 
   *
   **/
-void *gnutls_db_get_ptr(gnutls_session session)
+void *gnutls_db_get_ptr(gnutls_session_t session)
 {
     return session->internals.db_ptr;
 }
 
 /**
   * gnutls_db_set_cache_expiration - Sets the expiration time for resumed sessions.
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @seconds: is the number of seconds.
   *
   * Sets the expiration time for resumed sessions. The default is 3600 (one hour)
   * at the time writing this.
   **/
-void gnutls_db_set_cache_expiration(gnutls_session session, int seconds)
+void gnutls_db_set_cache_expiration(gnutls_session_t session, int seconds)
 {
     session->internals.expire_time = seconds;
 }
 
 /**
   * gnutls_db_check_entry - checks if the given db entry has expired
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @session_entry: is the session data (not key)
   *
   * This function returns GNUTLS_E_EXPIRED, if the database entry
@@ -140,8 +140,8 @@ void gnutls_db_set_cache_expiration(gnutls_session session, int seconds)
   * backend.
   *
   **/
-int gnutls_db_check_entry(gnutls_session session,
-			  gnutls_datum session_entry)
+int gnutls_db_check_entry(gnutls_session_t session,
+			  gnutls_datum_t session_entry)
 {
     time_t timestamp;
 
@@ -163,10 +163,10 @@ int gnutls_db_check_entry(gnutls_session session,
 /* The format of storing data is:
  * (forget it). Check gnutls_session_pack.c
  */
-int _gnutls_server_register_current_session(gnutls_session session)
+int _gnutls_server_register_current_session(gnutls_session_t session)
 {
-    gnutls_datum key;
-    gnutls_datum content;
+    gnutls_datum_t key;
+    gnutls_datum_t content;
     int ret = 0;
 
     key.data = session->security_parameters.session_id;
@@ -215,7 +215,7 @@ int _gnutls_server_register_current_session(gnutls_session session)
 /* Checks if both db_store and db_retrieve functions have
  * been set up.
  */
-static int _gnutls_db_func_is_ok(gnutls_session session)
+static int _gnutls_db_func_is_ok(gnutls_session_t session)
 {
     if (session->internals.db_store_func != NULL &&
 	session->internals.db_retrieve_func != NULL &&
@@ -226,11 +226,11 @@ static int _gnutls_db_func_is_ok(gnutls_session session)
 }
 
 
-int _gnutls_server_restore_session(gnutls_session session,
+int _gnutls_server_restore_session(gnutls_session_t session,
 				   uint8 * session_id, int session_id_size)
 {
-    gnutls_datum data;
-    gnutls_datum key;
+    gnutls_datum_t data;
+    gnutls_datum_t key;
     int ret;
 
     key.data = session_id;
@@ -260,10 +260,10 @@ int _gnutls_server_restore_session(gnutls_session session,
     return 0;
 }
 
-int _gnutls_db_remove_session(gnutls_session session, uint8 * session_id,
+int _gnutls_db_remove_session(gnutls_session_t session, uint8 * session_id,
 			      int session_id_size)
 {
-    gnutls_datum key;
+    gnutls_datum_t key;
 
     key.data = session_id;
     key.size = session_id_size;
@@ -274,8 +274,8 @@ int _gnutls_db_remove_session(gnutls_session session, uint8 * session_id,
 
 /* Stores session data to the db backend.
  */
-int _gnutls_store_session(gnutls_session session, gnutls_datum session_id,
-			  gnutls_datum session_data)
+int _gnutls_store_session(gnutls_session_t session, gnutls_datum_t session_id,
+			  gnutls_datum_t session_data)
 {
     int ret = 0;
 
@@ -310,10 +310,10 @@ int _gnutls_store_session(gnutls_session session, gnutls_datum session_id,
 
 /* Retrieves session data from the db backend.
  */
-gnutls_datum _gnutls_retrieve_session(gnutls_session session,
-				      gnutls_datum session_id)
+gnutls_datum_t _gnutls_retrieve_session(gnutls_session_t session,
+				      gnutls_datum_t session_id)
 {
-    gnutls_datum ret = { NULL, 0 };
+    gnutls_datum_t ret = { NULL, 0 };
 
     if (session_id.data == NULL || session_id.size == 0) {
 	gnutls_assert();
@@ -331,7 +331,7 @@ gnutls_datum _gnutls_retrieve_session(gnutls_session session,
 
 /* Removes session data from the db backend.
  */
-int _gnutls_remove_session(gnutls_session session, gnutls_datum session_id)
+int _gnutls_remove_session(gnutls_session_t session, gnutls_datum_t session_id)
 {
     int ret = 0;
 
@@ -354,7 +354,7 @@ int _gnutls_remove_session(gnutls_session session, gnutls_datum session_id)
 
 /**
   * gnutls_db_remove_session - This function will remove the current session data from the database
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * This function will remove the current session data from the session
   * database. This will prevent future handshakes reusing these session
@@ -364,7 +364,7 @@ int _gnutls_remove_session(gnutls_session session, gnutls_datum session_id)
   * Normally gnutls_deinit() will remove abnormally terminated sessions.
   *
   **/
-void gnutls_db_remove_session(gnutls_session session)
+void gnutls_db_remove_session(gnutls_session_t session)
 {
     /* if the session has failed abnormally it has 
      * to be removed from the db 
diff --git a/lib/gnutls_db.h b/lib/gnutls_db.h
index 1d0f4a717c..d18fcf4444 100644
--- a/lib/gnutls_db.h
+++ b/lib/gnutls_db.h
@@ -18,19 +18,19 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 
-void gnutls_set_cache_expiration(gnutls_session session, int seconds);
-int gnutls_db_set_name(gnutls_session session, const char *filename);
-int _gnutls_server_register_current_session(gnutls_session session);
-int _gnutls_server_restore_session(gnutls_session session,
+void gnutls_set_cache_expiration(gnutls_session_t session, int seconds);
+int gnutls_db_set_name(gnutls_session_t session, const char *filename);
+int _gnutls_server_register_current_session(gnutls_session_t session);
+int _gnutls_server_restore_session(gnutls_session_t session,
 				   uint8 * session_id,
 				   int session_id_size);
-int gnutls_db_clean(gnutls_session session);
-int _gnutls_db_remove_session(gnutls_session session, uint8 * session_id,
+int gnutls_db_clean(gnutls_session_t session);
+int _gnutls_db_remove_session(gnutls_session_t session, uint8 * session_id,
 			      int session_id_size);
-void gnutls_db_remove_session(gnutls_session session);
-int _gnutls_store_session(gnutls_session session, gnutls_datum session_id,
-			  gnutls_datum session_data);
-gnutls_datum _gnutls_retrieve_session(gnutls_session session,
-				      gnutls_datum session_id);
-int _gnutls_remove_session(gnutls_session session,
-			   gnutls_datum session_id);
+void gnutls_db_remove_session(gnutls_session_t session);
+int _gnutls_store_session(gnutls_session_t session, gnutls_datum_t session_id,
+			  gnutls_datum_t session_data);
+gnutls_datum_t _gnutls_retrieve_session(gnutls_session_t session,
+				      gnutls_datum_t session_id);
+int _gnutls_remove_session(gnutls_session_t session,
+			   gnutls_datum_t session_id);
diff --git a/lib/gnutls_dh.h b/lib/gnutls_dh.h
index 9336a31230..781cf08e04 100644
--- a/lib/gnutls_dh.h
+++ b/lib/gnutls_dh.h
@@ -18,8 +18,8 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 
-const mpi_t *_gnutls_get_dh_params(gnutls_dh_params);
+const mpi_t *_gnutls_get_dh_params(gnutls_dh_params_t);
 mpi_t gnutls_calc_dh_secret(mpi_t * ret_x, mpi_t g, mpi_t prime);
 mpi_t gnutls_calc_dh_key(mpi_t f, mpi_t x, mpi_t prime);
 int _gnutls_dh_generate_prime(mpi_t * ret_g, mpi_t * ret_n, uint bits);
-void gnutls_dh_params_deinit(gnutls_dh_params dh_params);
+void gnutls_dh_params_deinit(gnutls_dh_params_t dh_params);
diff --git a/lib/gnutls_dh_primes.c b/lib/gnutls_dh_primes.c
index e6da92c4ae..6eda6a1a11 100644
--- a/lib/gnutls_dh_primes.c
+++ b/lib/gnutls_dh_primes.c
@@ -32,7 +32,7 @@
 
 /* returns the prime and the generator of DH params.
  */
-const mpi_t *_gnutls_get_dh_params(gnutls_dh_params dh_primes)
+const mpi_t *_gnutls_get_dh_params(gnutls_dh_params_t dh_primes)
 {
     if (dh_primes == NULL || dh_primes->params[1] == NULL ||
 	dh_primes->params[0] == NULL) {
@@ -138,9 +138,9 @@ int _gnutls_dh_generate_prime(mpi_t * ret_g, mpi_t * ret_n,
   * appropriate gnutls_datum. 
   * 
   **/
-int gnutls_dh_params_import_raw(gnutls_dh_params dh_params,
-				const gnutls_datum * prime,
-				const gnutls_datum * generator)
+int gnutls_dh_params_import_raw(gnutls_dh_params_t dh_params,
+				const gnutls_datum_t * prime,
+				const gnutls_datum_t * generator)
 {
     mpi_t tmp_prime, tmp_g;
     size_t siz;
@@ -174,7 +174,7 @@ int gnutls_dh_params_import_raw(gnutls_dh_params dh_params,
   * This function will initialize the DH parameters structure.
   *
   **/
-int gnutls_dh_params_init(gnutls_dh_params * dh_params)
+int gnutls_dh_params_init(gnutls_dh_params_t * dh_params)
 {
 
     (*dh_params) = gnutls_calloc(1, sizeof(dh_params_st));
@@ -194,7 +194,7 @@ int gnutls_dh_params_init(gnutls_dh_params * dh_params)
   * This function will deinitialize the DH parameters structure.
   *
   **/
-void gnutls_dh_params_deinit(gnutls_dh_params dh_params)
+void gnutls_dh_params_deinit(gnutls_dh_params_t dh_params)
 {
     if (dh_params == NULL)
 	return;
@@ -215,7 +215,7 @@ void gnutls_dh_params_deinit(gnutls_dh_params dh_params)
   * to destination.
   *
   **/
-int gnutls_dh_params_cpy(gnutls_dh_params dst, gnutls_dh_params src)
+int gnutls_dh_params_cpy(gnutls_dh_params_t dst, gnutls_dh_params_t src)
 {
     if (src == NULL)
 	return GNUTLS_E_INVALID_REQUEST;
@@ -246,7 +246,7 @@ int gnutls_dh_params_cpy(gnutls_dh_params dst, gnutls_dh_params src)
   * no use to call this in client side.
   *
   **/
-int gnutls_dh_params_generate2(gnutls_dh_params params, unsigned int bits)
+int gnutls_dh_params_generate2(gnutls_dh_params_t params, unsigned int bits)
 {
     int ret;
 
@@ -276,13 +276,13 @@ int gnutls_dh_params_generate2(gnutls_dh_params params, unsigned int bits)
   * 0 on success.
   *
   **/
-int gnutls_dh_params_import_pkcs3(gnutls_dh_params params,
-				  const gnutls_datum * pkcs3_params,
-				  gnutls_x509_crt_fmt format)
+int gnutls_dh_params_import_pkcs3(gnutls_dh_params_t params,
+				  const gnutls_datum_t * pkcs3_params,
+				  gnutls_x509_crt_fmt_t format)
 {
     ASN1_TYPE c2;
     int result, need_free = 0;
-    gnutls_datum _params;
+    gnutls_datum_t _params;
 
     if (format == GNUTLS_X509_FMT_PEM) {
 	opaque *out;
@@ -378,8 +378,8 @@ int gnutls_dh_params_import_pkcs3(gnutls_dh_params params,
   * 0 on success.
   *
   **/
-int gnutls_dh_params_export_pkcs3(gnutls_dh_params params,
-				  gnutls_x509_crt_fmt format,
+int gnutls_dh_params_export_pkcs3(gnutls_dh_params_t params,
+				  gnutls_x509_crt_fmt_t format,
 				  unsigned char *params_data,
 				  size_t * params_data_size)
 {
@@ -534,10 +534,8 @@ int gnutls_dh_params_export_pkcs3(gnutls_dh_params params,
   * gnutls_malloc() and will be stored in the appropriate datum.
   * 
   **/
-int gnutls_dh_params_export_raw(gnutls_dh_params params,
-				gnutls_datum * prime,
-				gnutls_datum * generator,
-				unsigned int *bits)
+int gnutls_dh_params_export_raw(gnutls_dh_params_t params,
+    gnutls_datum_t * prime, gnutls_datum_t * generator, unsigned int *bits)
 {
 
     size_t size;
diff --git a/lib/gnutls_extensions.c b/lib/gnutls_extensions.c
index 868cd9ca7c..adfd109552 100644
--- a/lib/gnutls_extensions.c
+++ b/lib/gnutls_extensions.c
@@ -93,7 +93,7 @@ const char *_gnutls_extension_get_name(uint16 type)
 /* Checks if the extension we just received is one of the 
  * requested ones. Otherwise it's a fatal error.
  */
-static int _gnutls_extension_list_check(gnutls_session session,
+static int _gnutls_extension_list_check(gnutls_session_t session,
 					uint16 type)
 {
     if (session->security_parameters.entity == GNUTLS_CLIENT) {
@@ -108,7 +108,7 @@ static int _gnutls_extension_list_check(gnutls_session session,
     return 0;
 }
 
-int _gnutls_parse_extensions(gnutls_session session, const opaque * data,
+int _gnutls_parse_extensions(gnutls_session_t session, const opaque * data,
 			     int data_size)
 {
     int next, ret;
@@ -177,7 +177,7 @@ int _gnutls_parse_extensions(gnutls_session session, const opaque * data,
  * This list is used to check whether the (later) received
  * extensions are the ones we requested.
  */
-static void _gnutls_extension_list_add(gnutls_session session, uint16 type)
+static void _gnutls_extension_list_add(gnutls_session_t session, uint16 type)
 {
 
     if (session->security_parameters.entity == GNUTLS_CLIENT) {
@@ -192,7 +192,7 @@ static void _gnutls_extension_list_add(gnutls_session session, uint16 type)
     }
 }
 
-int _gnutls_gen_extensions(gnutls_session session, opaque * data,
+int _gnutls_gen_extensions(gnutls_session_t session, opaque * data,
 			   size_t data_size)
 {
     int next, size;
diff --git a/lib/gnutls_extensions.h b/lib/gnutls_extensions.h
index 288ec183be..0d97c7ef3e 100644
--- a/lib/gnutls_extensions.h
+++ b/lib/gnutls_extensions.h
@@ -21,12 +21,12 @@
 #include <gnutls_int.h>
 
 const char *_gnutls_extension_get_name(uint16 type);
-int _gnutls_parse_extensions(gnutls_session, const opaque *, int);
-int _gnutls_gen_extensions(gnutls_session session, opaque * data,
+int _gnutls_parse_extensions(gnutls_session_t, const opaque *, int);
+int _gnutls_gen_extensions(gnutls_session_t session, opaque * data,
 			   size_t data_size);
 
-typedef int (*ext_recv_func) (gnutls_session, const opaque *, size_t);	/* recv data */
-typedef int (*ext_send_func) (gnutls_session, opaque *, size_t);	/* send data */
+typedef int (*ext_recv_func) (gnutls_session_t, const opaque *, size_t);	/* recv data */
+typedef int (*ext_send_func) (gnutls_session_t, opaque *, size_t);	/* send data */
 
 ext_send_func _gnutls_ext_func_send(uint16 type);
 ext_recv_func _gnutls_ext_func_recv(uint16 type);
diff --git a/lib/gnutls_global.c b/lib/gnutls_global.c
index c3bf7d334e..90de8b969d 100644
--- a/lib/gnutls_global.c
+++ b/lib/gnutls_global.c
@@ -267,9 +267,9 @@ void gnutls_global_deinit(void)
   * probably be ok.
   * This function should be called once and after gnutls_global_init().
   * PULL_FUNC is of the form, 
-  * ssize_t (*gnutls_pull_func)(gnutls_transport_ptr, const void*, size_t);
+  * ssize_t (*gnutls_pull_func)(gnutls_transport_ptr_t, const void*, size_t);
   **/
-void gnutls_transport_set_pull_function(gnutls_session session,
+void gnutls_transport_set_pull_function(gnutls_session_t session,
 					gnutls_pull_func pull_func)
 {
     session->internals._gnutls_pull_func = pull_func;
@@ -288,9 +288,9 @@ void gnutls_transport_set_pull_function(gnutls_session session,
   *  
   * This function should be called once and after gnutls_global_init().
   * PUSH_FUNC is of the form, 
-  * ssize_t (*gnutls_push_func)(gnutls_transport_ptr, const void*, size_t);
+  * ssize_t (*gnutls_push_func)(gnutls_transport_ptr_t, const void*, size_t);
   **/
-void gnutls_transport_set_push_function(gnutls_session session,
+void gnutls_transport_set_push_function(gnutls_session_t session,
 					gnutls_push_func push_func)
 {
     session->internals._gnutls_push_func = push_func;
diff --git a/lib/gnutls_handshake.c b/lib/gnutls_handshake.c
index 7c9351336e..25aa741230 100644
--- a/lib/gnutls_handshake.c
+++ b/lib/gnutls_handshake.c
@@ -48,7 +48,7 @@
 #include <gnutls_state.h>
 #include <ext_srp.h>
 #include <gnutls_rsa_export.h>	/* for gnutls_get_rsa_params() */
-#include <auth_anon.h>		/* for gnutls_anon_server_credentials */
+#include <auth_anon.h>		/* for gnutls_anon_server_credentials_t */
 
 #ifdef HANDSHAKE_DEBUG
 #define ERR(x, y) _gnutls_handshake_log( "HSK[%x]: %s (%d)\n", session, x,y)
@@ -59,14 +59,14 @@
 #define TRUE 1
 #define FALSE 0
 
-int _gnutls_server_select_comp_method(gnutls_session session,
+int _gnutls_server_select_comp_method(gnutls_session_t session,
 				      opaque * data, int datalen);
 
 
 /* Clears the handshake hash buffers and handles.
  */
 inline static
-void _gnutls_handshake_hash_buffers_clear(gnutls_session session)
+void _gnutls_handshake_hash_buffers_clear(gnutls_session_t session)
 {
     _gnutls_hash_deinit(session->internals.handshake_mac_handle_md5, NULL);
     _gnutls_hash_deinit(session->internals.handshake_mac_handle_sha, NULL);
@@ -79,7 +79,7 @@ void _gnutls_handshake_hash_buffers_clear(gnutls_session session)
  * internals, and to security_parameters.
  * this will keep as less data to security_parameters.
  */
-static void resume_copy_required_values(gnutls_session session)
+static void resume_copy_required_values(gnutls_session_t session)
 {
     /* get the new random values */
     memcpy(session->internals.resumed_security_parameters.
@@ -122,13 +122,13 @@ static void resume_copy_required_values(gnutls_session session)
 	session->internals.resumed_security_parameters.session_id_size;
 }
 
-void _gnutls_set_server_random(gnutls_session session, uint8 * random)
+void _gnutls_set_server_random(gnutls_session_t session, uint8 * random)
 {
     memcpy(session->security_parameters.server_random, random,
 	   TLS_RANDOM_SIZE);
 }
 
-void _gnutls_set_client_random(gnutls_session session, uint8 * random)
+void _gnutls_set_client_random(gnutls_session_t session, uint8 * random)
 {
     memcpy(session->security_parameters.client_random, random,
 	   TLS_RANDOM_SIZE);
@@ -139,7 +139,7 @@ void _gnutls_set_client_random(gnutls_session session, uint8 * random)
 #define SSL3_CLIENT_MSG "CLNT"
 #define SSL3_SERVER_MSG "SRVR"
 #define SSL_MSG_LEN 4
-static int _gnutls_ssl3_finished(gnutls_session session, int type,
+static int _gnutls_ssl3_finished(gnutls_session_t session, int type,
 				 opaque * ret)
 {
     const int siz = SSL_MSG_LEN;
@@ -186,7 +186,7 @@ static int _gnutls_ssl3_finished(gnutls_session session, int type,
 #define SERVER_MSG "server finished"
 #define CLIENT_MSG "client finished"
 #define TLS_MSG_LEN 15
-int _gnutls_finished(gnutls_session session, int type, void *ret)
+int _gnutls_finished(gnutls_session_t session, int type, void *ret)
 {
     const int siz = TLS_MSG_LEN;
     opaque concat[36];
@@ -255,16 +255,16 @@ int _gnutls_tls_create_random(opaque * dst)
  * or version 2.0 client hello (only for compatibility
  * since SSL version 2.0 is not supported).
  */
-int _gnutls_read_client_hello(gnutls_session session, opaque * data,
+int _gnutls_read_client_hello(gnutls_session_t session, opaque * data,
 			      int datalen)
 {
     uint8 session_id_len, z;
     int pos = 0, ret;
     uint16 suite_size;
-    gnutls_protocol_version version;
+    gnutls_protocol_t version;
     int len = datalen;
     opaque random[TLS_RANDOM_SIZE], *suite_ptr;
-    gnutls_protocol_version ver;
+    gnutls_protocol_t ver;
 
     if (session->internals.v2_hello != 0) {	/* version 2.0 */
 	return _gnutls_read_client_hello_v2(session, data, datalen);
@@ -382,7 +382,7 @@ int _gnutls_read_client_hello(gnutls_session session, opaque * data,
 
 /* here we hash all pending data. 
  */
-inline static int _gnutls_handshake_hash_pending(gnutls_session session)
+inline static int _gnutls_handshake_hash_pending(gnutls_session_t session)
 {
     size_t siz;
     int ret;
@@ -418,7 +418,7 @@ inline static int _gnutls_handshake_hash_pending(gnutls_session session)
  * and initializing encryption. This is the first encrypted message
  * we send.
  */
-int _gnutls_send_finished(gnutls_session session, int again)
+int _gnutls_send_finished(gnutls_session_t session, int again)
 {
     uint8 data[36];
     int ret;
@@ -465,7 +465,7 @@ int _gnutls_send_finished(gnutls_session session, int again)
 /* This is to be called after sending our finished message. If everything
  * went fine we have negotiated a secure connection 
  */
-int _gnutls_recv_finished(gnutls_session session)
+int _gnutls_recv_finished(gnutls_session_t session)
 {
     uint8 data[36], *vrfy;
     int data_size;
@@ -528,8 +528,8 @@ static int _gnutls_server_find_pk_algos_in_ciphersuites(const opaque *
 							data, int datalen)
 {
     int j;
-    gnutls_pk_algorithm algo = GNUTLS_PK_NONE, prev_algo = 0;
-    gnutls_kx_algorithm kx;
+    gnutls_pk_algorithm_t algo = GNUTLS_PK_NONE, prev_algo = 0;
+    gnutls_kx_algorithm_t kx;
     cipher_suite_st cs;
 
     if (datalen % 2 != 0) {
@@ -557,13 +557,13 @@ static int _gnutls_server_find_pk_algos_in_ciphersuites(const opaque *
 /* This selects the best supported ciphersuite from the given ones. Then
  * it adds the suite to the session and performs some checks.
  */
-int _gnutls_server_select_suite(gnutls_session session, opaque * data,
+int _gnutls_server_select_suite(gnutls_session_t session, opaque * data,
 				int datalen)
 {
     int x, i, j;
     cipher_suite_st *ciphers, cs;
     int retval, err;
-    gnutls_pk_algorithm pk_algo;	/* will hold the pk algorithms
+    gnutls_pk_algorithm_t pk_algo;	/* will hold the pk algorithms
 					   * supported by the peer.
 					 */
 
@@ -676,7 +676,7 @@ int _gnutls_server_select_suite(gnutls_session session, opaque * data,
 
 /* This selects the best supported compression method from the ones provided 
  */
-int _gnutls_server_select_comp_method(gnutls_session session,
+int _gnutls_server_select_comp_method(gnutls_session_t session,
 				      opaque * data, int datalen)
 {
     int x, i, j;
@@ -689,12 +689,12 @@ int _gnutls_server_select_comp_method(gnutls_session session,
     }
 
     memset(&session->internals.compression_method, 0,
-	   sizeof(gnutls_compression_method));
+	   sizeof(gnutls_compression_method_t));
 
     for (j = 0; j < datalen; j++) {
 	for (i = 0; i < x; i++) {
 	    if (comps[i] == data[j]) {
-		gnutls_compression_method method =
+		gnutls_compression_method_t method =
 		    _gnutls_compression_get_id(comps[i]);
 
 		session->internals.compression_method = method;
@@ -725,8 +725,8 @@ int _gnutls_server_select_comp_method(gnutls_session session,
  * GNUTLS_E_AGAIN or GNUTLS_E_INTERRUPTED, then it must be called again 
  * (until it returns ok), with NULL parameters.
  */
-int _gnutls_send_empty_handshake(gnutls_session session,
-				 HandshakeType type, int again)
+int _gnutls_send_empty_handshake(gnutls_session_t session,
+				 handshake_t type, int again)
 {
     opaque data = 0;
     opaque *ptr;
@@ -743,8 +743,8 @@ int _gnutls_send_empty_handshake(gnutls_session session,
 /* This function will hash the handshake message we sent.
  */
 static
-int _gnutls_handshake_hash_add_sent(gnutls_session session,
-				    HandshakeType type, opaque * dataptr,
+int _gnutls_handshake_hash_add_sent(gnutls_session_t session,
+				    handshake_t type, opaque * dataptr,
 				    uint32 datalen)
 {
     int ret;
@@ -770,8 +770,8 @@ int _gnutls_handshake_hash_add_sent(gnutls_session session,
  * GNUTLS_E_AGAIN or GNUTLS_E_INTERRUPTED, then it must be called again 
  * (until it returns ok), with NULL parameters.
  */
-int _gnutls_send_handshake(gnutls_session session, void *i_data,
-			   uint32 i_datasize, HandshakeType type)
+int _gnutls_send_handshake(gnutls_session_t session, void *i_data,
+			   uint32 i_datasize, handshake_t type)
 {
     int ret;
     uint8 *data;
@@ -840,9 +840,8 @@ int _gnutls_send_handshake(gnutls_session session, void *i_data,
  * FIXME: This function is complex.
  */
 #define SSL2_HEADERS 1
-static int _gnutls_recv_handshake_header(gnutls_session session,
-					 HandshakeType type,
-					 HandshakeType * recv_type)
+static int _gnutls_recv_handshake_header(gnutls_session_t session,
+    handshake_t type, handshake_t * recv_type)
 {
     int ret;
     uint32 length32 = 0;
@@ -965,10 +964,9 @@ static int _gnutls_recv_handshake_header(gnutls_session session,
  * handshake data.
  */
 static
-int _gnutls_handshake_hash_add_recvd(gnutls_session session,
-				     HandshakeType recv_type,
-				     opaque * header, uint16 header_size,
-				     opaque * dataptr, uint32 datalen)
+int _gnutls_handshake_hash_add_recvd(gnutls_session_t session,
+     handshake_t recv_type, opaque * header, uint16 header_size,
+     opaque * dataptr, uint32 datalen)
 {
     int ret;
 
@@ -1010,14 +1008,14 @@ int _gnutls_handshake_hash_add_recvd(gnutls_session session,
  * E.g. for the SERVER_HELLO message (if it is expected), it will be
  * passed to _gnutls_recv_hello().
  */
-int _gnutls_recv_handshake(gnutls_session session, uint8 ** data,
-			   int *datalen, HandshakeType type,
+int _gnutls_recv_handshake(gnutls_session_t session, uint8 ** data,
+			   int *datalen, handshake_t type,
 			   Optional optional)
 {
     int ret;
     uint32 length32 = 0;
     opaque *dataptr = NULL;
-    HandshakeType recv_type;
+    handshake_t recv_type;
 
     ret = _gnutls_recv_handshake_header(session, type, &recv_type);
     if (ret < 0) {
@@ -1134,7 +1132,7 @@ int _gnutls_recv_handshake(gnutls_session session, uint8 ** data,
 /* This function checks if the given cipher suite is supported, and sets it
  * to the session;
  */
-static int _gnutls_client_set_ciphersuite(gnutls_session session,
+static int _gnutls_client_set_ciphersuite(gnutls_session_t session,
 					  opaque suite[2])
 {
     uint8 z;
@@ -1210,7 +1208,7 @@ static int _gnutls_client_set_ciphersuite(gnutls_session session,
 
 /* This function sets the given comp method to the session.
  */
-static int _gnutls_client_set_comp_method(gnutls_session session,
+static int _gnutls_client_set_comp_method(gnutls_session_t session,
 					  opaque comp_method)
 {
     int comp_methods_num;
@@ -1249,7 +1247,7 @@ static int _gnutls_client_set_comp_method(gnutls_session session,
  * This also sets the variables in the session. Used only while reading a server
  * hello.
  */
-static int _gnutls_client_check_if_resuming(gnutls_session session,
+static int _gnutls_client_check_if_resuming(gnutls_session_t session,
 					    opaque * session_id,
 					    int session_id_len)
 {
@@ -1292,13 +1290,13 @@ static int _gnutls_client_check_if_resuming(gnutls_session session,
  * This function also restores resumed parameters if we are resuming a
  * session.
  */
-static int _gnutls_read_server_hello(gnutls_session session, opaque * data,
+static int _gnutls_read_server_hello(gnutls_session_t session, opaque * data,
 				     int datalen)
 {
     uint8 session_id_len = 0;
     int pos = 0;
     int ret = 0;
-    gnutls_protocol_version version;
+    gnutls_protocol_t version;
     int len = datalen;
 
     if (datalen < 38) {
@@ -1386,7 +1384,7 @@ static int _gnutls_read_server_hello(gnutls_session session, opaque * data,
 /* This function copies the appropriate ciphersuites to a locally allocated buffer
  * Needed in client hello messages. Returns the new data length.
  */
-static int _gnutls_copy_ciphersuites(gnutls_session session,
+static int _gnutls_copy_ciphersuites(gnutls_session_t session,
 				     opaque * ret_data,
 				     size_t ret_data_size)
 {
@@ -1451,7 +1449,7 @@ static int _gnutls_copy_ciphersuites(gnutls_session session,
 /* This function copies the appropriate compression methods, to a locally allocated buffer 
  * Needed in hello messages. Returns the new data length.
  */
-static int _gnutls_copy_comp_methods(gnutls_session session,
+static int _gnutls_copy_comp_methods(gnutls_session_t session,
 				     opaque * ret_data,
 				     size_t ret_data_size)
 {
@@ -1495,14 +1493,14 @@ static int _gnutls_copy_comp_methods(gnutls_session session,
 
 /* This function sends the client hello handshake message.
  */
-static int _gnutls_send_client_hello(gnutls_session session, int again)
+static int _gnutls_send_client_hello(gnutls_session_t session, int again)
 {
     opaque *data = NULL;
     int extdatalen;
     int pos = 0;
     int datalen = 0, ret = 0;
     opaque random[TLS_RANDOM_SIZE];
-    gnutls_protocol_version hver;
+    gnutls_protocol_t hver;
     opaque extdata[MAX_EXT_DATA_LENGTH];
 
     opaque *SessionID =
@@ -1660,7 +1658,7 @@ static int _gnutls_send_client_hello(gnutls_session session, int again)
     return ret;
 }
 
-static int _gnutls_send_server_hello(gnutls_session session, int again)
+static int _gnutls_send_server_hello(gnutls_session_t session, int again)
 {
     opaque *data = NULL;
     opaque extdata[MAX_EXT_DATA_LENGTH];
@@ -1766,7 +1764,7 @@ static int _gnutls_send_server_hello(gnutls_session session, int again)
     return ret;
 }
 
-int _gnutls_send_hello(gnutls_session session, int again)
+int _gnutls_send_hello(gnutls_session_t session, int again)
 {
     int ret;
 
@@ -1784,7 +1782,7 @@ int _gnutls_send_hello(gnutls_session session, int again)
  * hello message is expected. It uses the security_parameters.current_cipher_suite
  * and internals.compression_method.
  */
-int _gnutls_recv_hello(gnutls_session session, opaque * data, int datalen)
+int _gnutls_recv_hello(gnutls_session_t session, opaque * data, int datalen)
 {
     int ret;
 
@@ -1831,7 +1829,7 @@ int _gnutls_recv_hello(gnutls_session session, opaque * data, int datalen)
 
 /**
   * gnutls_rehandshake - This function will renegotiate security parameters
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * This function will renegotiate security parameters with the
   * client. This should only be called in case of a server.
@@ -1850,7 +1848,7 @@ int _gnutls_recv_hello(gnutls_session session, opaque * data, int datalen)
   * this message.
   *
   **/
-int gnutls_rehandshake(gnutls_session session)
+int gnutls_rehandshake(gnutls_session_t session)
 {
     int ret;
 
@@ -1872,7 +1870,7 @@ int gnutls_rehandshake(gnutls_session session)
     return 0;
 }
 
-inline static int _gnutls_abort_handshake(gnutls_session session, int ret)
+inline static int _gnutls_abort_handshake(gnutls_session_t session, int ret)
 {
     if (((ret == GNUTLS_E_WARNING_ALERT_RECEIVED) &&
 	 (gnutls_alert_get(session) == GNUTLS_A_NO_RENEGOTIATION))
@@ -1887,7 +1885,7 @@ inline static int _gnutls_abort_handshake(gnutls_session session, int ret)
 /* This function initialized the handshake hash session.
  * required for finished messages.
  */
-inline static int _gnutls_handshake_hash_init(gnutls_session session)
+inline static int _gnutls_handshake_hash_init(gnutls_session_t session)
 {
 
     if (session->internals.handshake_mac_handle_md5 == NULL) {
@@ -1916,7 +1914,7 @@ inline static int _gnutls_handshake_hash_init(gnutls_session session)
 
 /**
   * gnutls_handshake - This is the main function in the handshake protocol.
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * This function does the handshake of the TLS/SSL protocol,
   * and initializes the TLS connection. 
@@ -1938,7 +1936,7 @@ inline static int _gnutls_handshake_hash_init(gnutls_session session)
   * rejected the rehandshake request.
   *
   **/
-int gnutls_handshake(gnutls_session session)
+int gnutls_handshake(gnutls_session_t session)
 {
     int ret;
 
@@ -2007,7 +2005,7 @@ int gnutls_handshake(gnutls_session session)
  * _gnutls_handshake_client 
  * This function performs the client side of the handshake of the TLS/SSL protocol.
  */
-int _gnutls_handshake_client(gnutls_session session)
+int _gnutls_handshake_client(gnutls_session_t session)
 {
     int ret = 0;
 
@@ -2108,7 +2106,7 @@ int _gnutls_handshake_client(gnutls_session session)
 
 /* This function sends the final handshake packets and initializes connection 
  */
-static int _gnutls_send_handshake_final(gnutls_session session, int init)
+static int _gnutls_send_handshake_final(gnutls_session_t session, int init)
 {
     int ret = 0;
 
@@ -2163,7 +2161,7 @@ static int _gnutls_send_handshake_final(gnutls_session session, int init)
  * And executes the appropriate function to initialize the
  * read session.
  */
-static int _gnutls_recv_handshake_final(gnutls_session session, int init)
+static int _gnutls_recv_handshake_final(gnutls_session_t session, int init)
 {
     int ret = 0;
     uint8 ch;
@@ -2218,7 +2216,7 @@ static int _gnutls_recv_handshake_final(gnutls_session session, int init)
   * This function does the server stuff of the handshake protocol.
   */
 
-int _gnutls_handshake_server(gnutls_session session)
+int _gnutls_handshake_server(gnutls_session_t session)
 {
     int ret = 0;
 
@@ -2304,7 +2302,7 @@ int _gnutls_handshake_server(gnutls_session session)
     return 0;
 }
 
-int _gnutls_handshake_common(gnutls_session session)
+int _gnutls_handshake_common(gnutls_session_t session)
 {
     int ret = 0;
 
@@ -2354,7 +2352,7 @@ int _gnutls_generate_session_id(opaque * session_id, uint8 * len)
     return 0;
 }
 
-int _gnutls_recv_hello_request(gnutls_session session, void *data,
+int _gnutls_recv_hello_request(gnutls_session_t session, void *data,
 			       uint32 data_size)
 {
     uint8 type;
@@ -2379,16 +2377,16 @@ int _gnutls_recv_hello_request(gnutls_session session, void *data,
 /* Returns 1 if the given KX has not the corresponding parameters
  * (DH or RSA) set up. Otherwise returns 0.
  */
-inline static int check_server_params(gnutls_session session,
-				      gnutls_kx_algorithm kx,
-				      gnutls_kx_algorithm * alg,
+inline static int check_server_params(gnutls_session_t session,
+				      gnutls_kx_algorithm_t kx,
+				      gnutls_kx_algorithm_t * alg,
 				      int alg_size)
 {
     int cred_type;
-    const gnutls_certificate_credentials x509_cred;
-    const gnutls_anon_server_credentials anon_cred;
-    gnutls_dh_params dh_params = NULL;
-    gnutls_rsa_params rsa_params = NULL;
+    const gnutls_certificate_credentials_t x509_cred;
+    const gnutls_anon_server_credentials_t anon_cred;
+    gnutls_dh_params_t dh_params = NULL;
+    gnutls_rsa_params_t rsa_params = NULL;
     int j, remove;
 
     cred_type = _gnutls_map_kx_get_cred(kx, 1);
@@ -2456,21 +2454,21 @@ inline static int check_server_params(gnutls_session session,
  * This does a more high level check than  gnutls_supported_ciphersuites(),
  * by checking certificates etc.
  */
-int _gnutls_remove_unwanted_ciphersuites(gnutls_session session,
+int _gnutls_remove_unwanted_ciphersuites(gnutls_session_t session,
 					 cipher_suite_st **
 					 cipherSuites, int numCipherSuites,
-					 gnutls_pk_algorithm
+					 gnutls_pk_algorithm_t
 					 requested_pk_algo)
 {
 
     int ret = 0;
     cipher_suite_st *newSuite, cs;
     int newSuiteSize = 0, i, remove;
-    const gnutls_certificate_credentials x509_cred;
-    gnutls_kx_algorithm kx;
+    const gnutls_certificate_credentials_t x509_cred;
+    gnutls_kx_algorithm_t kx;
     int server =
 	session->security_parameters.entity == GNUTLS_SERVER ? 1 : 0;
-    gnutls_kx_algorithm *alg;
+    gnutls_kx_algorithm_t *alg;
     int alg_size;
 
     /* if we should use a specific certificate, 
@@ -2564,7 +2562,7 @@ int _gnutls_remove_unwanted_ciphersuites(gnutls_session session,
 
 /**
   * gnutls_handshake_set_max_packet_length - This function will set the maximum length of a handshake message
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @max: is the maximum number.
   *
   * This function will set the maximum size of a handshake message.
@@ -2573,20 +2571,20 @@ int _gnutls_remove_unwanted_ciphersuites(gnutls_session session,
   * to set an upper limit.
   *
   **/
-void gnutls_handshake_set_max_packet_length(gnutls_session session,
+void gnutls_handshake_set_max_packet_length(gnutls_session_t session,
 					    int max)
 {
     session->internals.max_handshake_data_buffer_size = max;
 }
 
-void _gnutls_set_adv_version(gnutls_session session,
-			     gnutls_protocol_version ver)
+void _gnutls_set_adv_version(gnutls_session_t session,
+			     gnutls_protocol_t ver)
 {
     set_adv_version(session, _gnutls_version_get_major(ver),
 		    _gnutls_version_get_minor(ver));
 }
 
-gnutls_protocol_version _gnutls_get_adv_version(gnutls_session session)
+gnutls_protocol_t _gnutls_get_adv_version(gnutls_session_t session)
 {
     return _gnutls_version_get(_gnutls_get_adv_version_major(session),
 			       _gnutls_get_adv_version_minor(session));
@@ -2594,7 +2592,7 @@ gnutls_protocol_version _gnutls_get_adv_version(gnutls_session session)
 
 /**
   * gnutls_handshake_get_last_in - Returns the last handshake message received.
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * Returns the last handshake message received. This function is only useful
   * to check where the last performed handshake failed. If the previous handshake
@@ -2602,15 +2600,14 @@ gnutls_protocol_version _gnutls_get_adv_version(gnutls_session session)
   *
   * Check gnutls.h for the available handshake descriptions.
   **/
-gnutls_handshake_description gnutls_handshake_get_last_in(gnutls_session
-							  session)
+gnutls_handshake_description_t gnutls_handshake_get_last_in(gnutls_session_t session)
 {
     return session->internals.last_handshake_in;
 }
 
 /**
   * gnutls_handshake_get_last_out - Returns the last handshake message sent.
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * Returns the last handshake message sent. This function is only useful
   * to check where the last performed handshake failed. If the previous handshake
@@ -2619,8 +2616,7 @@ gnutls_handshake_description gnutls_handshake_get_last_in(gnutls_session
   * Check gnutls.h for the available handshake descriptions.
   *
   **/
-gnutls_handshake_description gnutls_handshake_get_last_out(gnutls_session
-							   session)
+gnutls_handshake_description_t gnutls_handshake_get_last_out(gnutls_session_t session)
 {
     return session->internals.last_handshake_out;
 }
diff --git a/lib/gnutls_handshake.h b/lib/gnutls_handshake.h
index 52bb61dc9d..a93d5a71dc 100644
--- a/lib/gnutls_handshake.h
+++ b/lib/gnutls_handshake.h
@@ -20,31 +20,31 @@
 
 typedef enum Optional { OPTIONAL_PACKET, MANDATORY_PACKET } Optional;
 
-int _gnutls_send_handshake(gnutls_session session, void *i_data,
-			   uint32 i_datasize, HandshakeType type);
-int gnutls_send_hello_request(gnutls_session session);
-int _gnutls_recv_hello_request(gnutls_session session, void *data,
+int _gnutls_send_handshake(gnutls_session_t session, void *i_data,
+			   uint32 i_datasize, handshake_t type);
+int gnutls_send_hello_request(gnutls_session_t session);
+int _gnutls_recv_hello_request(gnutls_session_t session, void *data,
 			       uint32 data_size);
-int _gnutls_send_hello(gnutls_session session, int again);
-int _gnutls_recv_hello(gnutls_session session, opaque * data, int datalen);
-int gnutls_handshake(gnutls_session session);
-int _gnutls_recv_handshake(gnutls_session session, uint8 **, int *,
-			   HandshakeType, Optional optional);
+int _gnutls_send_hello(gnutls_session_t session, int again);
+int _gnutls_recv_hello(gnutls_session_t session, opaque * data, int datalen);
+int gnutls_handshake(gnutls_session_t session);
+int _gnutls_recv_handshake(gnutls_session_t session, uint8 **, int *,
+			   handshake_t, Optional optional);
 int _gnutls_generate_session_id(opaque * session_id, uint8 * len);
-int _gnutls_handshake_common(gnutls_session session);
-int _gnutls_handshake_client(gnutls_session session);
-int _gnutls_handshake_server(gnutls_session session);
-void _gnutls_set_server_random(gnutls_session session, uint8 * random);
-void _gnutls_set_client_random(gnutls_session session, uint8 * random);
+int _gnutls_handshake_common(gnutls_session_t session);
+int _gnutls_handshake_client(gnutls_session_t session);
+int _gnutls_handshake_server(gnutls_session_t session);
+void _gnutls_set_server_random(gnutls_session_t session, uint8 * random);
+void _gnutls_set_client_random(gnutls_session_t session, uint8 * random);
 int _gnutls_tls_create_random(opaque * dst);
-int _gnutls_remove_unwanted_ciphersuites(gnutls_session session,
+int _gnutls_remove_unwanted_ciphersuites(gnutls_session_t session,
 					 cipher_suite_st ** cipherSuites,
 					 int numCipherSuites,
-					 gnutls_pk_algorithm);
-void gnutls_handshake_set_max_packet_length(gnutls_session session,
+					 gnutls_pk_algorithm_t);
+void gnutls_handshake_set_max_packet_length(gnutls_session_t session,
 					    int max);
 int _gnutls_find_pk_algos_in_ciphersuites(opaque * data, int datalen);
-int _gnutls_server_select_suite(gnutls_session session, opaque * data,
+int _gnutls_server_select_suite(gnutls_session_t session, opaque * data,
 				int datalen);
 
 #define STATE session->internals.handshake_state
diff --git a/lib/gnutls_hash_int.c b/lib/gnutls_hash_int.c
index af09e431e1..81872edb2a 100644
--- a/lib/gnutls_hash_int.c
+++ b/lib/gnutls_hash_int.c
@@ -29,12 +29,12 @@
 #include <gnutls_hash_int.h>
 #include <gnutls_errors.h>
 
-GNUTLS_HASH_HANDLE _gnutls_hash_init(gnutls_mac_algorithm algorithm)
+GNUTLS_HASH_HANDLE _gnutls_hash_init(gnutls_mac_algorithm_t algorithm)
 {
     mac_hd_t ret;
     gcry_error_t result;
 
-    ret = gnutls_malloc(sizeof(mac_hd_t_INT));
+    ret = gnutls_malloc(sizeof(mac_hd_st));
     if (ret == NULL) {
 	gnutls_assert();
 	return GNUTLS_HASH_FAILED;
@@ -66,7 +66,7 @@ GNUTLS_HASH_HANDLE _gnutls_hash_init(gnutls_mac_algorithm algorithm)
     return ret;
 }
 
-int _gnutls_hash_get_algo_len(gnutls_mac_algorithm algorithm)
+int _gnutls_hash_get_algo_len(gnutls_mac_algorithm_t algorithm)
 {
     int ret;
 
@@ -102,7 +102,7 @@ GNUTLS_HASH_HANDLE _gnutls_hash_copy(GNUTLS_HASH_HANDLE handle)
     GNUTLS_HASH_HANDLE ret;
     gcry_error_t result;
 
-    ret = gnutls_malloc(sizeof(mac_hd_t_INT));
+    ret = gnutls_malloc(sizeof(mac_hd_st));
 
     if (ret == NULL)
 	return GNUTLS_HASH_FAILED;
@@ -139,13 +139,13 @@ void _gnutls_hash_deinit(GNUTLS_HASH_HANDLE handle, void *digest)
 }
 
 
-mac_hd_t _gnutls_hmac_init(gnutls_mac_algorithm algorithm,
+mac_hd_t _gnutls_hmac_init(gnutls_mac_algorithm_t algorithm,
 			   const void *key, int keylen)
 {
     mac_hd_t ret;
     gcry_error_t result;
 
-    ret = gnutls_malloc(sizeof(mac_hd_t_INT));
+    ret = gnutls_malloc(sizeof(mac_hd_st));
     if (ret == NULL)
 	return GNUTLS_MAC_FAILED;
 
@@ -200,7 +200,7 @@ void _gnutls_hmac_deinit(mac_hd_t handle, void *digest)
     gnutls_free(handle);
 }
 
-inline static int get_padsize(gnutls_mac_algorithm algorithm)
+inline static int get_padsize(gnutls_mac_algorithm_t algorithm)
 {
     switch (algorithm) {
     case GNUTLS_MAC_MD5:
@@ -212,7 +212,7 @@ inline static int get_padsize(gnutls_mac_algorithm algorithm)
     }
 }
 
-mac_hd_t _gnutls_mac_init_ssl3(gnutls_mac_algorithm algorithm, void *key,
+mac_hd_t _gnutls_mac_init_ssl3(gnutls_mac_algorithm_t algorithm, void *key,
 			       int keylen)
 {
     mac_hd_t ret;
diff --git a/lib/gnutls_hash_int.h b/lib/gnutls_hash_int.h
index 2e626c9f8e..caa989bf21 100644
--- a/lib/gnutls_hash_int.h
+++ b/lib/gnutls_hash_int.h
@@ -27,28 +27,28 @@
 
 typedef struct {
     gcry_md_hd_t handle;
-    gnutls_mac_algorithm algorithm;
+    gnutls_mac_algorithm_t algorithm;
     const void *key;
     int keysize;
-} mac_hd_t_INT;
-typedef mac_hd_t_INT *mac_hd_t;
+} mac_hd_st;
+typedef mac_hd_st *mac_hd_t;
 typedef mac_hd_t GNUTLS_HASH_HANDLE;
 
 #define GNUTLS_HASH_FAILED NULL
 #define GNUTLS_MAC_FAILED NULL
 
-mac_hd_t _gnutls_hmac_init(gnutls_mac_algorithm algorithm, const void *key,
+mac_hd_t _gnutls_hmac_init(gnutls_mac_algorithm_t algorithm, const void *key,
 			   int keylen);
 #define _gnutls_hmac_get_algo_len _gnutls_hash_get_algo_len
 #define _gnutls_hmac _gnutls_hash
 void _gnutls_hmac_deinit(mac_hd_t handle, void *digest);
 
-mac_hd_t _gnutls_mac_init_ssl3(gnutls_mac_algorithm algorithm, void *key,
+mac_hd_t _gnutls_mac_init_ssl3(gnutls_mac_algorithm_t algorithm, void *key,
 			       int keylen);
 void _gnutls_mac_deinit_ssl3(mac_hd_t handle, void *digest);
 
-GNUTLS_HASH_HANDLE _gnutls_hash_init(gnutls_mac_algorithm algorithm);
-int _gnutls_hash_get_algo_len(gnutls_mac_algorithm algorithm);
+GNUTLS_HASH_HANDLE _gnutls_hash_init(gnutls_mac_algorithm_t algorithm);
+int _gnutls_hash_get_algo_len(gnutls_mac_algorithm_t algorithm);
 int _gnutls_hash(GNUTLS_HASH_HANDLE handle, const void *text,
 		 size_t textlen);
 void _gnutls_hash_deinit(GNUTLS_HASH_HANDLE handle, void *digest);
diff --git a/lib/gnutls_int.h b/lib/gnutls_int.h
index 8f7e13dbc5..525dae2159 100644
--- a/lib/gnutls_int.h
+++ b/lib/gnutls_int.h
@@ -41,7 +41,7 @@
 /* It might be a good idea to replace int with void*
  * here.
  */
-typedef void *gnutls_transport_ptr;
+typedef void *gnutls_transport_ptr_t;
 
 #define MAX32 4294967295
 #define MAX24 16777215
@@ -107,12 +107,11 @@ typedef struct {
 typedef struct {
     opaque *data;
     unsigned int size;
-} gnutls_datum;
+} gnutls_datum_t;
 
 #include <gnutls_mpi.h>
 
-typedef enum ChangeCipherSpecType { GNUTLS_TYPE_CHANGE_CIPHER_SPEC =
-	1 } ChangeCipherSpecType;
+typedef enum change_cipher_spec_t { GNUTLS_TYPE_CHANGE_CIPHER_SPEC = 1 } change_cipher_spec_t;
 
 typedef enum gnutls_certificate_status {
     GNUTLS_CERT_INVALID = 2,	/* will be set if the certificate
@@ -127,35 +126,35 @@ typedef enum gnutls_certificate_status {
      */
     GNUTLS_CERT_SIGNER_NOT_FOUND = 64,
     GNUTLS_CERT_SIGNER_NOT_CA = 128
-} gnutls_certificate_status;
+} gnutls_certificate_status_t;
 
 typedef enum gnutls_certificate_request { GNUTLS_CERT_IGNORE,
-	GNUTLS_CERT_REQUEST =
-	1, GNUTLS_CERT_REQUIRE } gnutls_certificate_request;
+	GNUTLS_CERT_REQUEST = 1, GNUTLS_CERT_REQUIRE 
+} gnutls_certificate_request_t;
 
 typedef enum gnutls_openpgp_key_status { GNUTLS_OPENPGP_KEY,
     GNUTLS_OPENPGP_KEY_FINGERPRINT
-} gnutls_openpgp_key_status;
+} gnutls_openpgp_key_status_t;
 
-typedef enum gnutls_close_request { 
+typedef enum gnutls_close_request_t { 
     GNUTLS_SHUT_RDWR = 0, GNUTLS_SHUT_WR = 1 
-} gnutls_close_request;
+} gnutls_close_request_t;
 
-typedef enum HandshakeState { STATE0 = 0, STATE1, STATE2, 
+typedef enum handshake_state_t { STATE0 = 0, STATE1, STATE2, 
     STATE3, STATE4, STATE5,
     STATE6, STATE7, STATE8, STATE9, STATE20 = 20, STATE21,
     STATE30 = 30, STATE31, STATE50 = 50, STATE60 = 60, STATE61, STATE62
-} HandshakeState;
+} handshake_state_t;
 
-typedef enum HandshakeType { GNUTLS_HELLO_REQUEST, 
+typedef enum handshake_t { GNUTLS_HELLO_REQUEST, 
     GNUTLS_CLIENT_HELLO, GNUTLS_SERVER_HELLO,
     GNUTLS_CERTIFICATE_PKT = 11, GNUTLS_SERVER_KEY_EXCHANGE,
     GNUTLS_CERTIFICATE_REQUEST, GNUTLS_SERVER_HELLO_DONE,
     GNUTLS_CERTIFICATE_VERIFY, GNUTLS_CLIENT_KEY_EXCHANGE,
     GNUTLS_FINISHED = 20
-} HandshakeType;
+} handshake_t;
 
-typedef HandshakeType gnutls_handshake_description;
+typedef handshake_t gnutls_handshake_description_t;
 
 #include <gnutls_buffer.h>
 
@@ -166,38 +165,37 @@ typedef HandshakeType gnutls_handshake_description;
 
 #define MAX_CIPHERSUITES 256
 
-/* STATE */
 
 typedef enum gnutls_cipher_algorithm { GNUTLS_CIPHER_NULL = 1,
     GNUTLS_CIPHER_ARCFOUR_128, GNUTLS_CIPHER_3DES_CBC,
     GNUTLS_CIPHER_AES_128_CBC, GNUTLS_CIPHER_AES_256_CBC, 
     GNUTLS_CIPHER_ARCFOUR_40,
     GNUTLS_CIPHER_RC2_40_CBC = 90, GNUTLS_CIPHER_DES_CBC
-} gnutls_cipher_algorithm;
+} gnutls_cipher_algorithm_t;
 
 typedef enum gnutls_kx_algorithm { GNUTLS_KX_RSA = 1, GNUTLS_KX_DHE_DSS,
     GNUTLS_KX_DHE_RSA, GNUTLS_KX_ANON_DH, GNUTLS_KX_SRP,
     GNUTLS_KX_RSA_EXPORT, GNUTLS_KX_SRP_RSA, GNUTLS_KX_SRP_DSS
-} gnutls_kx_algorithm;
+} gnutls_kx_algorithm_t;
 
 typedef enum gnutls_params_type { GNUTLS_PARAMS_RSA_EXPORT = 1,
     GNUTLS_PARAMS_DH
-} gnutls_params_type;
+} gnutls_params_type_t;
 
 typedef enum gnutls_mac_algorithm { GNUTLS_MAC_UNKNOWN = 0,
     GNUTLS_MAC_NULL = 1, GNUTLS_MAC_MD5, GNUTLS_MAC_SHA, 
     GNUTLS_MAC_RMD160
-} gnutls_mac_algorithm;
-typedef gnutls_mac_algorithm gnutls_digest_algorithm;
+} gnutls_mac_algorithm_t;
+typedef gnutls_mac_algorithm_t gnutls_digest_algorithm_t;
 
 typedef enum gnutls_compression_method { 
     GNUTLS_COMP_NULL = 1, GNUTLS_COMP_DEFLATE,
     GNUTLS_COMP_LZO
-} gnutls_compression_method;
+} gnutls_compression_method_t;
 
 typedef enum gnutls_connection_end { 
     GNUTLS_SERVER = 1, GNUTLS_CLIENT 
-} gnutls_connection_end;
+} gnutls_connection_end_t;
 
 typedef enum extensions_t { GNUTLS_EXTENSION_SERVER_NAME = 0,
     GNUTLS_EXTENSION_MAX_RECORD_SIZE = 1, GNUTLS_EXTENSION_SRP = 6,
@@ -207,11 +205,11 @@ typedef enum extensions_t { GNUTLS_EXTENSION_SERVER_NAME = 0,
 typedef enum gnutls_credentials_type { 
     GNUTLS_CRD_CERTIFICATE = 1, GNUTLS_CRD_ANON, 
     GNUTLS_CRD_SRP 
-} gnutls_credentials_type;
+} gnutls_credentials_type_t;
 
 typedef enum gnutls_certificate_type { 
     GNUTLS_CRT_X509 = 1, GNUTLS_CRT_OPENPGP
-} gnutls_certificate_type;
+} gnutls_certificate_type_t;
 
 typedef enum { CIPHER_STREAM, CIPHER_BLOCK } cipher_type_t;
 
@@ -227,21 +225,21 @@ typedef enum content_type_t {
 typedef enum gnutls_x509_crt_fmt { 
     GNUTLS_X509_FMT_DER,
     GNUTLS_X509_FMT_PEM
-} gnutls_x509_crt_fmt;
+} gnutls_x509_crt_fmt_t;
 
 typedef enum gnutls_pk_algorithm { 
     GNUTLS_PK_RSA = 1, GNUTLS_PK_DSA,
     GNUTLS_PK_UNKNOWN = 0xff
-} gnutls_pk_algorithm;
+} gnutls_pk_algorithm_t;
 
-#define GNUTLS_PK_ANY (gnutls_pk_algorithm)-1
-#define GNUTLS_PK_NONE (gnutls_pk_algorithm)0
+#define GNUTLS_PK_ANY (gnutls_pk_algorithm_t)-1
+#define GNUTLS_PK_NONE (gnutls_pk_algorithm_t)0
 
 typedef enum gnutls_sign_algorithm { 
     GNUTLS_SIGN_RSA_SHA = 1, GNUTLS_SIGN_DSA_SHA,
     GNUTLS_SIGN_RSA_MD5, GNUTLS_SIGN_RSA_MD2,
     GNUTLS_SIGN_UNKNOWN = 0xff
-} gnutls_sign_algorithm;
+} gnutls_sign_algorithm_t;
 
 /* STATE (stop) */
 
@@ -249,20 +247,20 @@ typedef void (*LOG_FUNC) (int, const char *);
 
 /* Pull & Push functions defines: 
  */
-typedef ssize_t(*gnutls_pull_func) (gnutls_transport_ptr, void *, size_t);
-typedef ssize_t(*gnutls_push_func) (gnutls_transport_ptr, const void *,
-				    size_t);
+typedef ssize_t(*gnutls_pull_func) (gnutls_transport_ptr_t, void *, size_t);
+typedef ssize_t(*gnutls_push_func) (gnutls_transport_ptr_t, const void *,
+    size_t);
 
 
 /* Store & Retrieve functions defines: 
  */
-typedef int (*gnutls_db_store_func) (void *, gnutls_datum key,
-				     gnutls_datum data);
-typedef int (*gnutls_db_remove_func) (void *, gnutls_datum key);
-typedef gnutls_datum(*gnutls_db_retr_func) (void *, gnutls_datum key);
+typedef int (*gnutls_db_store_func) (void *, gnutls_datum_t key,
+				     gnutls_datum_t data);
+typedef int (*gnutls_db_remove_func) (void *, gnutls_datum_t key);
+typedef gnutls_datum_t(*gnutls_db_retr_func) (void *, gnutls_datum_t key);
 
 typedef struct auth_cred_st {
-    gnutls_credentials_type algorithm;
+    gnutls_credentials_type_t algorithm;
 
     /* the type of credentials depends on algorithm 
      */
@@ -273,7 +271,7 @@ typedef struct auth_cred_st {
 
 struct gnutls_key_st {
     /* For DH KX */
-    gnutls_datum key;
+    gnutls_datum_t key;
     mpi_t KEY;
     mpi_t client_Y;
     mpi_t client_g;
@@ -297,7 +295,7 @@ struct gnutls_key_st {
      * Rememember that this should be calloced!
      */
     void *auth_info;
-    gnutls_credentials_type auth_info_type;
+    gnutls_credentials_type_t auth_info_type;
     int auth_info_size;		/* needed in order to store to db for restoring 
 				 */
     uint8 crypt_algo;
@@ -335,20 +333,20 @@ typedef struct {
 typedef enum gnutls_protocol_version { 
     GNUTLS_SSL3 = 1, GNUTLS_TLS1_0,
     GNUTLS_TLS1_1, GNUTLS_VERSION_UNKNOWN = 0xff
-} gnutls_protocol_version;
+} gnutls_protocol_t;
 
 /* This structure holds parameters got from TLS extension
  * mechanism. (some extensions may hold parameters in auth_info_t
  * structures also - see SRP).
  */
 
-typedef enum gnutls_server_name_type { GNUTLS_NAME_DNS = 1
-} gnutls_server_name_type;
+typedef enum { GNUTLS_NAME_DNS = 1
+} gnutls_server_name_type_t;
 
 typedef struct {
     opaque name[MAX_SERVER_NAME_SIZE];
     uint name_length;
-    gnutls_server_name_type type;
+    gnutls_server_name_type_t type;
 } server_name_st;
 
 #define MAX_SERVER_NAME_EXTENSIONS 3
@@ -379,19 +377,19 @@ typedef struct {
  * the handshake is in progress is the cipher suite value.
  */
 typedef struct {
-    gnutls_connection_end entity;
-    gnutls_kx_algorithm kx_algorithm;
+    gnutls_connection_end_t entity;
+    gnutls_kx_algorithm_t kx_algorithm;
     /* we've got separate write/read bulk/macs because
      * there is a time in handshake where the peer has
      * null cipher and we don't
      */
-    gnutls_cipher_algorithm read_bulk_cipher_algorithm;
-    gnutls_mac_algorithm read_mac_algorithm;
-    gnutls_compression_method read_compression_algorithm;
+    gnutls_cipher_algorithm_t      read_bulk_cipher_algorithm;
+    gnutls_mac_algorithm_t         read_mac_algorithm;
+    gnutls_compression_method_t    read_compression_algorithm;
 
-    gnutls_cipher_algorithm write_bulk_cipher_algorithm;
-    gnutls_mac_algorithm write_mac_algorithm;
-    gnutls_compression_method write_compression_algorithm;
+    gnutls_cipher_algorithm_t      write_bulk_cipher_algorithm;
+    gnutls_mac_algorithm_t         write_mac_algorithm;
+    gnutls_compression_method_t    write_compression_algorithm;
 
     /* this is the ciphersuite we are going to use 
      * moved here from internals in order to be restored
@@ -412,19 +410,19 @@ typedef struct {
     uint16 max_record_send_size;
     uint16 max_record_recv_size;
     /* holds the negotiated certificate type */
-    gnutls_certificate_type cert_type;
-    gnutls_protocol_version version;	/* moved here */
+    gnutls_certificate_type_t cert_type;
+    gnutls_protocol_t version; /* moved here */
 } security_parameters_st;
 
 /* This structure holds the generated keys
  */
 typedef struct {
-    gnutls_datum server_write_mac_secret;
-    gnutls_datum client_write_mac_secret;
-    gnutls_datum server_write_IV;
-    gnutls_datum client_write_IV;
-    gnutls_datum server_write_key;
-    gnutls_datum client_write_key;
+    gnutls_datum_t server_write_mac_secret;
+    gnutls_datum_t client_write_mac_secret;
+    gnutls_datum_t server_write_IV;
+    gnutls_datum_t client_write_IV;
+    gnutls_datum_t server_write_key;
+    gnutls_datum_t client_write_key;
     int generated_keys;		/* zero if keys have not
 				 * been generated. Non zero
 				 * otherwise.
@@ -437,8 +435,8 @@ typedef struct {
     cipher_hd_t read_cipher_state;
     comp_hd_t read_compression_state;
     comp_hd_t write_compression_state;
-    gnutls_datum read_mac_secret;
-    gnutls_datum write_mac_secret;
+    gnutls_datum_t read_mac_secret;
+    gnutls_datum_t write_mac_secret;
     uint64 read_sequence_number;
     uint64 write_sequence_number;
 } conn_stat_st;
@@ -457,24 +455,24 @@ typedef struct {
     mpi_t params[2];
 } dh_params_st;
 
-#define gnutls_dh_params dh_params_st*
+#define gnutls_dh_params_t dh_params_st*
 
-#define gnutls_rsa_params gnutls_x509_privkey
+#define gnutls_rsa_params_t gnutls_x509_privkey_t
 
 typedef struct {
-    gnutls_dh_params anon_dh_params;
+    gnutls_dh_params_t anon_dh_params;
     int free_anon_dh_params;
-    gnutls_dh_params cert_dh_params;
+    gnutls_dh_params_t cert_dh_params;
     int free_cert_dh_params;
-    gnutls_rsa_params rsa_params;
+    gnutls_rsa_params_t rsa_params;
     int free_rsa_params;
 } internal_params_st;
 
 typedef struct gnutls_params_st {
-    gnutls_params_type type;
+    gnutls_params_type_t type;
     union params {
-	gnutls_dh_params dh;
-	gnutls_rsa_params rsa_export;
+	gnutls_dh_params_t dh;
+	gnutls_rsa_params_t rsa_export;
     } params;
     int deinit;
 } gnutls_params_st;
@@ -487,14 +485,14 @@ typedef struct {
     size_t header_size;
     /* this holds the length of the handshake packet */
     size_t packet_length;
-    HandshakeType recv_type;
+    handshake_t recv_type;
 } handshake_header_buffer_st;
 
 /* Openpgp key retrieval callback */
 typedef int (*gnutls_openpgp_recv_key_func) (struct gnutls_session_int *,
 					     const unsigned char *keyfpr,
 					     unsigned int keyfpr_length,
-					     gnutls_datum *);
+					     gnutls_datum_t *);
 
 typedef struct {
     gnutls_buffer application_data_buffer;	/* holds data to be delivered to application layer */
@@ -505,7 +503,7 @@ typedef struct {
 
     gnutls_buffer handshake_data_buffer;	/* this is a buffer that holds the current handshake message */
     resumable_session_t resumable;	/* TRUE or FALSE - if we can resume that session */
-    HandshakeState handshake_state;	/* holds
+    handshake_state_t handshake_state;	/* holds
 					   * a number which indicates where
 					   * the handshake procedure has been
 					   * interrupted. If it is 0 then
@@ -527,7 +525,7 @@ typedef struct {
     int last_handshake_out;
 
     /* this is the compression method we are going to use */
-    gnutls_compression_method compression_method;
+    gnutls_compression_method_t compression_method;
     /* priorities */
     priority_st cipher_algorithm_priority;
     priority_st mac_algorithm_priority;
@@ -549,9 +547,9 @@ typedef struct {
     gnutls_buffer handshake_send_buffer;
     size_t handshake_send_buffer_prev_size;
     content_type_t handshake_send_buffer_type;
-    HandshakeType handshake_send_buffer_htype;
+    handshake_t handshake_send_buffer_htype;
     content_type_t handshake_recv_buffer_type;
-    HandshakeType handshake_recv_buffer_htype;
+    handshake_t handshake_recv_buffer_htype;
     gnutls_buffer handshake_recv_buffer;
 
     /* this buffer holds a record packet -mostly used for
@@ -612,8 +610,8 @@ typedef struct {
     /* Holds the first argument of PUSH and PULL
      * functions;
      */
-    gnutls_transport_ptr transport_recv_ptr;
-    gnutls_transport_ptr transport_send_ptr;
+    gnutls_transport_ptr_t transport_recv_ptr;
+    gnutls_transport_ptr_t transport_send_ptr;
 
     /* STORE & RETRIEVE functions. Only used if other
      * backend than gdbm is used.
@@ -699,7 +697,7 @@ typedef struct {
     /* This buffer is used by the record recv functions,
      * as a temporary store buffer.
      */
-    gnutls_datum recv_buffer;
+    gnutls_datum_t recv_buffer;
 
     /* If you add anything here, check _gnutls_handshake_internal_state_clear().
      */
@@ -713,17 +711,16 @@ struct gnutls_session_int {
     gnutls_key_st key;
 };
 
-typedef struct gnutls_session_int *gnutls_session;
+typedef struct gnutls_session_int *gnutls_session_t;
 
 
 
 /* functions 
  */
-void _gnutls_set_current_version(gnutls_session session,
-				 gnutls_protocol_version version);
-gnutls_protocol_version gnutls_protocol_get_version(gnutls_session
-						    session);
-void _gnutls_free_auth_info(gnutls_session session);
+void _gnutls_set_current_version(gnutls_session_t session,
+				 gnutls_protocol_t version);
+gnutls_protocol_t gnutls_protocol_get_version(gnutls_session_t session);
+void _gnutls_free_auth_info(gnutls_session_t session);
 
 /* These two macros return the advertized TLS version of
  * the peer.
@@ -738,14 +735,14 @@ void _gnutls_free_auth_info(gnutls_session session);
 	session->internals.adv_version_major = major; \
 	session->internals.adv_version_minor = minor
 
-void _gnutls_set_adv_version(gnutls_session, gnutls_protocol_version);
-gnutls_protocol_version _gnutls_get_adv_version(gnutls_session);
+void _gnutls_set_adv_version(gnutls_session_t, gnutls_protocol_t);
+gnutls_protocol_t _gnutls_get_adv_version(gnutls_session_t);
 
-int gnutls_fingerprint(gnutls_digest_algorithm algo,
-		       const gnutls_datum * data, void *result,
-		       size_t * result_size);
+int gnutls_fingerprint(gnutls_digest_algorithm_t algo,
+    const gnutls_datum_t * data, void *result,
+    size_t * result_size);
 
-typedef int gnutls_params_function(gnutls_session, gnutls_params_type,
-				   gnutls_params_st *);
+typedef int gnutls_params_function(gnutls_session_t, gnutls_params_type_t,
+    gnutls_params_st *);
 
 #endif				/* GNUTLS_INT_H */
diff --git a/lib/gnutls_kx.c b/lib/gnutls_kx.c
index 0de4eaff99..69330cf58d 100644
--- a/lib/gnutls_kx.c
+++ b/lib/gnutls_kx.c
@@ -41,9 +41,9 @@
  */
 
 #define MASTER_SECRET "master secret"
-static int generate_normal_master(gnutls_session session, int);
+static int generate_normal_master(gnutls_session_t session, int);
 
-int _gnutls_generate_master(gnutls_session session, int keep_premaster)
+int _gnutls_generate_master(gnutls_session_t session, int keep_premaster)
 {
     if (session->internals.resumed == RESUME_FALSE)
 	return generate_normal_master(session, keep_premaster);
@@ -53,7 +53,7 @@ int _gnutls_generate_master(gnutls_session session, int keep_premaster)
 /* here we generate the TLS Master secret.
  */
 #define PREMASTER session->key->key
-static int generate_normal_master(gnutls_session session,
+static int generate_normal_master(gnutls_session_t session,
 				  int keep_premaster)
 {
     int ret = 0;
@@ -110,7 +110,7 @@ static int generate_normal_master(gnutls_session session,
  * server. It does nothing if this type of message is not required
  * by the selected ciphersuite. 
  */
-int _gnutls_send_server_kx_message(gnutls_session session, int again)
+int _gnutls_send_server_kx_message(gnutls_session_t session, int again)
 {
     uint8 *data = NULL;
     int data_size = 0;
@@ -153,7 +153,7 @@ int _gnutls_send_server_kx_message(gnutls_session session, int again)
 /* This function sends a certificate request message to the
  * client.
  */
-int _gnutls_send_server_certificate_request(gnutls_session session,
+int _gnutls_send_server_certificate_request(gnutls_session_t session,
 					    int again)
 {
     uint8 *data = NULL;
@@ -196,7 +196,7 @@ int _gnutls_send_server_certificate_request(gnutls_session session,
 /* This is the function for the client to send the key
  * exchange message 
  */
-int _gnutls_send_client_kx_message(gnutls_session session, int again)
+int _gnutls_send_client_kx_message(gnutls_session_t session, int again)
 {
     uint8 *data;
     int data_size;
@@ -235,7 +235,7 @@ int _gnutls_send_client_kx_message(gnutls_session session, int again)
 /* This is the function for the client to send the certificate
  * verify message
  */
-int _gnutls_send_client_certificate_verify(gnutls_session session,
+int _gnutls_send_client_certificate_verify(gnutls_session_t session,
 					   int again)
 {
     uint8 *data;
@@ -283,7 +283,7 @@ int _gnutls_send_client_certificate_verify(gnutls_session session,
 }
 
 
-int _gnutls_recv_server_kx_message(gnutls_session session)
+int _gnutls_recv_server_kx_message(gnutls_session_t session)
 {
     uint8 *data = NULL;
     int datasize;
@@ -323,7 +323,7 @@ int _gnutls_recv_server_kx_message(gnutls_session session)
     return ret;
 }
 
-int _gnutls_recv_server_certificate_request(gnutls_session session)
+int _gnutls_recv_server_certificate_request(gnutls_session_t session)
 {
     uint8 *data;
     int datasize;
@@ -355,7 +355,7 @@ int _gnutls_recv_server_certificate_request(gnutls_session session)
     return ret;
 }
 
-int _gnutls_recv_client_kx_message(gnutls_session session)
+int _gnutls_recv_client_kx_message(gnutls_session_t session)
 {
     uint8 *data;
     int datasize;
@@ -388,7 +388,7 @@ int _gnutls_recv_client_kx_message(gnutls_session session)
 
 /* This is called when we want send our certificate
  */
-int _gnutls_send_client_certificate(gnutls_session session, int again)
+int _gnutls_send_client_certificate(gnutls_session_t session, int again)
 {
     uint8 *data = NULL;
     int data_size = 0;
@@ -450,7 +450,7 @@ int _gnutls_send_client_certificate(gnutls_session session, int again)
 
 /* This is called when we want send our certificate
  */
-int _gnutls_send_server_certificate(gnutls_session session, int again)
+int _gnutls_send_server_certificate(gnutls_session_t session, int again)
 {
     uint8 *data = NULL;
     int data_size = 0;
@@ -488,7 +488,7 @@ int _gnutls_send_server_certificate(gnutls_session session, int again)
 }
 
 
-int _gnutls_recv_client_certificate(gnutls_session session)
+int _gnutls_recv_client_certificate(gnutls_session_t session)
 {
     int datasize;
     opaque *data;
@@ -567,7 +567,7 @@ int _gnutls_recv_client_certificate(gnutls_session session)
     return ret;
 }
 
-int _gnutls_recv_server_certificate(gnutls_session session)
+int _gnutls_recv_server_certificate(gnutls_session_t session)
 {
     int datasize;
     opaque *data;
@@ -603,7 +603,7 @@ int _gnutls_recv_server_certificate(gnutls_session session)
 /* Recv the client certificate verify. This packet may not
  * arrive if the peer did not send us a certificate.
  */
-int _gnutls_recv_client_certificate_verify_message(gnutls_session session)
+int _gnutls_recv_client_certificate_verify_message(gnutls_session_t session)
 {
     uint8 *data;
     int datasize;
diff --git a/lib/gnutls_kx.h b/lib/gnutls_kx.h
index 41f9ad4506..f6a6e4eb6a 100644
--- a/lib/gnutls_kx.h
+++ b/lib/gnutls_kx.h
@@ -18,18 +18,18 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 
-int _gnutls_send_server_kx_message(gnutls_session session, int again);
-int _gnutls_send_client_kx_message(gnutls_session session, int again);
-int _gnutls_recv_server_kx_message(gnutls_session session);
-int _gnutls_recv_client_kx_message(gnutls_session session);
-int _gnutls_send_client_certificate_verify(gnutls_session session,
+int _gnutls_send_server_kx_message(gnutls_session_t session, int again);
+int _gnutls_send_client_kx_message(gnutls_session_t session, int again);
+int _gnutls_recv_server_kx_message(gnutls_session_t session);
+int _gnutls_recv_client_kx_message(gnutls_session_t session);
+int _gnutls_send_client_certificate_verify(gnutls_session_t session,
 					   int again);
-int _gnutls_send_server_certificate(gnutls_session session, int again);
-int _gnutls_generate_master(gnutls_session session, int keep_premaster);
-int _gnutls_recv_client_certificate(gnutls_session session);
-int _gnutls_recv_server_certificate(gnutls_session session);
-int _gnutls_send_client_certificate(gnutls_session session, int again);
-int _gnutls_recv_server_certificate_request(gnutls_session session);
-int _gnutls_send_server_certificate_request(gnutls_session session,
+int _gnutls_send_server_certificate(gnutls_session_t session, int again);
+int _gnutls_generate_master(gnutls_session_t session, int keep_premaster);
+int _gnutls_recv_client_certificate(gnutls_session_t session);
+int _gnutls_recv_server_certificate(gnutls_session_t session);
+int _gnutls_send_client_certificate(gnutls_session_t session, int again);
+int _gnutls_recv_server_certificate_request(gnutls_session_t session);
+int _gnutls_send_server_certificate_request(gnutls_session_t session,
 					    int again);
-int _gnutls_recv_client_certificate_verify_message(gnutls_session session);
+int _gnutls_recv_client_certificate_verify_message(gnutls_session_t session);
diff --git a/lib/gnutls_mpi.c b/lib/gnutls_mpi.c
index 2ba9ac7713..7a8154cc67 100644
--- a/lib/gnutls_mpi.c
+++ b/lib/gnutls_mpi.c
@@ -109,7 +109,7 @@ int _gnutls_mpi_print_lz(void *buffer, size_t * nbytes, const mpi_t a)
 }
 
 /* Always has the first bit zero */
-int _gnutls_mpi_dprint_lz(gnutls_datum * dest, const mpi_t a)
+int _gnutls_mpi_dprint_lz(gnutls_datum_t * dest, const mpi_t a)
 {
     int ret;
     opaque *buf = NULL;
diff --git a/lib/gnutls_mpi.h b/lib/gnutls_mpi.h
index 41a05bf7ee..46058b1d94 100644
--- a/lib/gnutls_mpi.h
+++ b/lib/gnutls_mpi.h
@@ -6,7 +6,6 @@
 # include <gnutls_int.h>
 
 typedef gcry_mpi_t mpi_t;
-typedef mpi_t GNUTLS_MPI;
 
 #define _gnutls_mpi_cmp gcry_mpi_cmp
 #define _gnutls_mpi_cmp_ui gcry_mpi_cmp_ui
@@ -44,7 +43,7 @@ int _gnutls_mpi_scan_pgp(mpi_t * ret_mpi, const opaque * buffer,
 int _gnutls_mpi_print(void *buffer, size_t * nbytes, const mpi_t a);
 int _gnutls_mpi_print_lz(void *buffer, size_t * nbytes, const mpi_t a);
 
-int _gnutls_mpi_dprint_lz(gnutls_datum * dest, const mpi_t a);
+int _gnutls_mpi_dprint_lz(gnutls_datum_t * dest, const mpi_t a);
 #define _gnutls_mpi_dprint _gnutls_mpi_dprint_lz
 
 #endif
diff --git a/lib/gnutls_pk.c b/lib/gnutls_pk.c
index fce507b6de..ad59220a38 100644
--- a/lib/gnutls_pk.c
+++ b/lib/gnutls_pk.c
@@ -49,8 +49,8 @@ static int _gnutls_pk_decrypt(int algo, mpi_t * resarr, mpi_t data,
 /* Do PKCS-1 RSA encryption. 
  * params is modulus, public exp.
  */
-int _gnutls_pkcs1_rsa_encrypt(gnutls_datum * ciphertext,
-			      const gnutls_datum * plaintext,
+int _gnutls_pkcs1_rsa_encrypt(gnutls_datum_t * ciphertext,
+			      const gnutls_datum_t * plaintext,
 			      mpi_t * params, uint params_len, uint btype)
 {
     unsigned int i, pad;
@@ -210,8 +210,8 @@ int _gnutls_pkcs1_rsa_encrypt(gnutls_datum * ciphertext,
  * params is modulus, public exp., private key
  * Can decrypt block type 1 and type 2 packets.
  */
-int _gnutls_pkcs1_rsa_decrypt(gnutls_datum * plaintext,
-			      const gnutls_datum * ciphertext,
+int _gnutls_pkcs1_rsa_decrypt(gnutls_datum_t * plaintext,
+			      const gnutls_datum_t * ciphertext,
 			      mpi_t * params, uint params_len, uint btype)
 {
     uint k, i;
@@ -325,12 +325,12 @@ int _gnutls_pkcs1_rsa_decrypt(gnutls_datum * plaintext,
 }
 
 
-int _gnutls_rsa_verify(const gnutls_datum * vdata,
-		       const gnutls_datum * ciphertext, mpi_t * params,
+int _gnutls_rsa_verify(const gnutls_datum_t * vdata,
+		       const gnutls_datum_t * ciphertext, mpi_t * params,
 		       int params_len, int btype)
 {
 
-    gnutls_datum plain;
+    gnutls_datum_t plain;
     int ret;
 
     /* decrypt signature */
@@ -360,7 +360,7 @@ int _gnutls_rsa_verify(const gnutls_datum * vdata,
 
 /* encodes the Dss-Sig-Value structure
  */
-static int encode_ber_rs(gnutls_datum * sig_value, mpi_t r, mpi_t s)
+static int encode_ber_rs(gnutls_datum_t * sig_value, mpi_t r, mpi_t s)
 {
     ASN1_TYPE sig;
     int result, tot_len;
@@ -404,7 +404,7 @@ static int encode_ber_rs(gnutls_datum * sig_value, mpi_t r, mpi_t s)
 
 /* Do DSA signature calculation. params is p, q, g, y, x in that order.
  */
-int _gnutls_dsa_sign(gnutls_datum * signature, const gnutls_datum * hash,
+int _gnutls_dsa_sign(gnutls_datum_t * signature, const gnutls_datum_t * hash,
 		     mpi_t * params, uint params_len)
 {
     mpi_t rs[2], mdata;
@@ -447,7 +447,7 @@ int _gnutls_dsa_sign(gnutls_datum * signature, const gnutls_datum * hash,
 
 /* decodes the Dss-Sig-Value structure
  */
-static int decode_ber_rs(const gnutls_datum * sig_value, mpi_t * r,
+static int decode_ber_rs(const gnutls_datum_t * sig_value, mpi_t * r,
 			 mpi_t * s)
 {
     ASN1_TYPE sig;
@@ -491,8 +491,8 @@ static int decode_ber_rs(const gnutls_datum * sig_value, mpi_t * r,
 
 /* params is p, q, g, y in that order
  */
-int _gnutls_dsa_verify(const gnutls_datum * vdata,
-		       const gnutls_datum * sig_value, mpi_t * params,
+int _gnutls_dsa_verify(const gnutls_datum_t * vdata,
+		       const gnutls_datum_t * sig_value, mpi_t * params,
 		       int params_len)
 {
 
diff --git a/lib/gnutls_pk.h b/lib/gnutls_pk.h
index 9378706af0..54fac1f8c2 100644
--- a/lib/gnutls_pk.h
+++ b/lib/gnutls_pk.h
@@ -1,20 +1,19 @@
 #ifndef GNUTLS_PK_H
 # define GNUTLS_PK_H
 
-int _gnutls_pkcs1_rsa_encrypt(gnutls_datum * ciphertext,
-			      const gnutls_datum * plaintext,
+int _gnutls_pkcs1_rsa_encrypt(gnutls_datum_t * ciphertext,
+			      const gnutls_datum_t * plaintext,
 			      mpi_t * params, uint params_len, uint btype);
-int _gnutls_dsa_sign(gnutls_datum * signature,
-		     const gnutls_datum * plaintext, mpi_t * params,
+int _gnutls_dsa_sign(gnutls_datum_t * signature,
+		     const gnutls_datum_t * plaintext, mpi_t * params,
 		     uint params_len);
-int _gnutls_pkcs1_rsa_decrypt(gnutls_datum * plaintext,
-			      const gnutls_datum * ciphertext,
+int _gnutls_pkcs1_rsa_decrypt(gnutls_datum_t * plaintext,
+			      const gnutls_datum_t * ciphertext,
 			      mpi_t * params, uint params_len, uint btype);
-int _gnutls_rsa_verify(const gnutls_datum * vdata,
-		       const gnutls_datum * ciphertext, mpi_t * params,
+int _gnutls_rsa_verify(const gnutls_datum_t * vdata,
+		       const gnutls_datum_t * ciphertext, mpi_t * params,
 		       int params_len, int btype);
-int _gnutls_dsa_verify(const gnutls_datum * vdata,
-		       const gnutls_datum * sig_value, mpi_t * params,
-		       int params_len);
+int _gnutls_dsa_verify(const gnutls_datum_t * vdata,
+     const gnutls_datum_t * sig_value, mpi_t * params, int params_len);
 
 #endif				/* GNUTLS_PK_H */
diff --git a/lib/gnutls_priority.c b/lib/gnutls_priority.c
index e3fa10e409..2dd3215873 100644
--- a/lib/gnutls_priority.c
+++ b/lib/gnutls_priority.c
@@ -30,8 +30,8 @@
 
 /**
   * gnutls_cipher_set_priority - Sets the priority on the ciphers supported by gnutls.
-  * @session: is a &gnutls_session structure.
-  * @list: is a 0 terminated list of gnutls_cipher_algorithm elements.
+  * @session: is a &gnutls_session_t structure.
+  * @list: is a 0 terminated list of gnutls_cipher_algorithm_t elements.
   *
   * Sets the priority on the ciphers supported by gnutls.
   * Priority is higher for ciphers specified before others.
@@ -40,7 +40,7 @@
   * not use the algorithm's priority except for disabling
   * algorithms that were not specified.
   **/
-int gnutls_cipher_set_priority(gnutls_session session, const int *list)
+int gnutls_cipher_set_priority(gnutls_session_t session, const int *list)
 {
     int num = 0, i;
 
@@ -59,8 +59,8 @@ int gnutls_cipher_set_priority(gnutls_session session, const int *list)
 
 /**
   * gnutls_kx_set_priority - Sets the priority on the key exchange algorithms supported by gnutls.
-  * @session: is a &gnutls_session structure.
-  * @list: is a 0 terminated list of gnutls_kx_algorithm elements.
+  * @session: is a &gnutls_session_t structure.
+  * @list: is a 0 terminated list of gnutls_kx_algorithm_t elements.
   *
   * Sets the priority on the key exchange algorithms supported by gnutls.
   * Priority is higher for algorithms specified before others.
@@ -69,7 +69,7 @@ int gnutls_cipher_set_priority(gnutls_session session, const int *list)
   * not use the algorithm's priority except for disabling
   * algorithms that were not specified.
  **/
-int gnutls_kx_set_priority(gnutls_session session, const int *list)
+int gnutls_kx_set_priority(gnutls_session_t session, const int *list)
 {
     int num = 0, i;
 
@@ -88,8 +88,8 @@ int gnutls_kx_set_priority(gnutls_session session, const int *list)
 
 /**
   * gnutls_mac_set_priority - Sets the priority on the mac algorithms supported by gnutls.
-  * @session: is a &gnutls_session structure.
-  * @list: is a 0 terminated list of gnutls_mac_algorithm elements.
+  * @session: is a &gnutls_session_t structure.
+  * @list: is a 0 terminated list of gnutls_mac_algorithm_t elements.
   *
   * Sets the priority on the mac algorithms supported by gnutls.
   * Priority is higher for algorithms specified before others.
@@ -98,7 +98,7 @@ int gnutls_kx_set_priority(gnutls_session session, const int *list)
   * not use the algorithm's priority except for disabling
   * algorithms that were not specified.
   **/
-int gnutls_mac_set_priority(gnutls_session session, const int *list)
+int gnutls_mac_set_priority(gnutls_session_t session, const int *list)
 {
     int num = 0, i;
 
@@ -117,8 +117,8 @@ int gnutls_mac_set_priority(gnutls_session session, const int *list)
 
 /**
   * gnutls_compression_set_priority - Sets the priority on the compression algorithms supported by gnutls.
-  * @session: is a &gnutls_session structure.
-  * @list: is a 0 terminated list of gnutls_compression_method elements.
+  * @session: is a &gnutls_session_t structure.
+  * @list: is a 0 terminated list of gnutls_compression_method_t elements.
   *
   * Sets the priority on the compression algorithms supported by gnutls.
   * Priority is higher for algorithms specified before others.
@@ -132,7 +132,7 @@ int gnutls_mac_set_priority(gnutls_session session, const int *list)
   * as gnutls extensions.
   *
   **/
-int gnutls_compression_set_priority(gnutls_session session,
+int gnutls_compression_set_priority(gnutls_session_t session,
 				    const int *list)
 {
     int num = 0, i;
@@ -152,15 +152,15 @@ int gnutls_compression_set_priority(gnutls_session session,
 
 /**
   * gnutls_protocol_set_priority - Sets the priority on the protocol versions supported by gnutls.
-  * @session: is a &gnutls_session structure.
-  * @list: is a 0 terminated list of gnutls_protocol_version elements.
+  * @session: is a &gnutls_session_t structure.
+  * @list: is a 0 terminated list of gnutls_protocol_t elements.
   *
   * Sets the priority on the protocol versions supported by gnutls.
   * This function actually enables or disables protocols. Newer protocol
   * versions always have highest priority.
   *
   **/
-int gnutls_protocol_set_priority(gnutls_session session, const int *list)
+int gnutls_protocol_set_priority(gnutls_session_t session, const int *list)
 {
     int num = 0, i;
 
@@ -185,8 +185,8 @@ int gnutls_protocol_set_priority(gnutls_session session, const int *list)
 
 /**
   * gnutls_certificate_type_set_priority - Sets the priority on the certificate types supported by gnutls.
-  * @session: is a &gnutls_session structure.
-  * @list: is a 0 terminated list of gnutls_certificate_type elements.
+  * @session: is a &gnutls_session_t structure.
+  * @list: is a 0 terminated list of gnutls_certificate_type_t elements.
   *
   * Sets the priority on the certificate types supported by gnutls.
   * Priority is higher for types specified before others.
@@ -195,7 +195,7 @@ int gnutls_protocol_set_priority(gnutls_session session, const int *list)
   * The server does not use the cert type priority except for disabling
   * types that were not specified.
   **/
-int gnutls_certificate_type_set_priority(gnutls_session session,
+int gnutls_certificate_type_set_priority(gnutls_session_t session,
 					 const int *list)
 {
 #ifdef USE_OPENPGP
@@ -223,7 +223,7 @@ int gnutls_certificate_type_set_priority(gnutls_session session,
 
 /**
   * gnutls_set_default_priority - Sets some default priority on the cipher suites supported by gnutls.
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * Sets some default priority on the ciphers, key exchange methods, macs
   * and compression methods. This is to avoid using the gnutls_*_priority() functions, if
@@ -237,7 +237,7 @@ int gnutls_certificate_type_set_priority(gnutls_session session,
   * and ARCFOUR_128 for ciphers.
   *
   **/
-int gnutls_set_default_priority(gnutls_session session)
+int gnutls_set_default_priority(gnutls_session_t session)
 {
     static const int protocol_priority[] = { GNUTLS_TLS1, GNUTLS_SSL3, 0 };
     static const int kx_priority[] =
@@ -261,7 +261,7 @@ int gnutls_set_default_priority(gnutls_session session)
 
 /**
   * gnutls_set_default_export_priority - Sets some default priority on the cipher suites supported by gnutls.
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * Sets some default priority on the ciphers, key exchange methods, macs
   * and compression methods. This is to avoid using the gnutls_*_priority() functions, if
@@ -273,7 +273,7 @@ int gnutls_set_default_priority(gnutls_session session)
   * and 3DES_CBC, ARCFOUR_128, ARCFOUR_40 for ciphers.
   *
   **/
-int gnutls_set_default_export_priority(gnutls_session session)
+int gnutls_set_default_export_priority(gnutls_session_t session)
 {
     static const int protocol_priority[] = {
 	GNUTLS_TLS1, GNUTLS_SSL3, 0
diff --git a/lib/gnutls_priority.h b/lib/gnutls_priority.h
index 45b84c35d1..099ed23e95 100644
--- a/lib/gnutls_priority.h
+++ b/lib/gnutls_priority.h
@@ -18,10 +18,10 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 
-int gnutls_cipher_set_priority(gnutls_session session, const int *);
-int gnutls_kx_set_priority(gnutls_session session, const int *);
-int gnutls_mac_set_priority(gnutls_session session, const int *);
-int gnutls_compression_set_priority(gnutls_session session, const int *);
-int gnutls_protocol_set_priority(gnutls_session session, const int *);
-int gnutls_certificate_type_set_priority(gnutls_session session,
+int gnutls_cipher_set_priority(gnutls_session_t session, const int *);
+int gnutls_kx_set_priority(gnutls_session_t session, const int *);
+int gnutls_mac_set_priority(gnutls_session_t session, const int *);
+int gnutls_compression_set_priority(gnutls_session_t session, const int *);
+int gnutls_protocol_set_priority(gnutls_session_t session, const int *);
+int gnutls_certificate_type_set_priority(gnutls_session_t session,
 					 const int *);
diff --git a/lib/gnutls_record.c b/lib/gnutls_record.c
index 1ec13724e3..e3a842aebb 100644
--- a/lib/gnutls_record.c
+++ b/lib/gnutls_record.c
@@ -46,25 +46,25 @@
 
 /**
   * gnutls_protocol_get_version - Returns the version of the currently used protocol
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * Returns the version of the currently used protocol. 
   *
   **/
-gnutls_protocol_version gnutls_protocol_get_version(gnutls_session session)
+gnutls_protocol_t gnutls_protocol_get_version(gnutls_session_t session)
 {
     return session->security_parameters.version;
 }
 
-void _gnutls_set_current_version(gnutls_session session,
-				 gnutls_protocol_version version)
+void _gnutls_set_current_version(gnutls_session_t session,
+				 gnutls_protocol_t version)
 {
     session->security_parameters.version = version;
 }
 
 /**
   * gnutls_transport_set_lowat - Used to set the lowat value in order for select to check for pending data.
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @num: is the low water value.
   *
   * Used to set the lowat value in order for select to check
@@ -75,14 +75,14 @@ void _gnutls_set_current_version(gnutls_session session,
   * Otherwise it must be called and set lowat to zero.
   *
   **/
-void gnutls_transport_set_lowat(gnutls_session session, int num)
+void gnutls_transport_set_lowat(gnutls_session_t session, int num)
 {
     session->internals.lowat = num;
 }
 
 /**
   * gnutls_transport_set_ptr - Used to set first argument of the transport functions
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @ptr: is the value.
   *
   * Used to set the first argument of the transport function (like PUSH and
@@ -90,8 +90,8 @@ void gnutls_transport_set_lowat(gnutls_session session, int num)
   * handle.
   *
   **/
-void gnutls_transport_set_ptr(gnutls_session session,
-			      gnutls_transport_ptr ptr)
+void gnutls_transport_set_ptr(gnutls_session_t session,
+			      gnutls_transport_ptr_t ptr)
 {
     session->internals.transport_recv_ptr = ptr;
     session->internals.transport_send_ptr = ptr;
@@ -100,7 +100,7 @@ void gnutls_transport_set_ptr(gnutls_session session,
 
 /**
   * gnutls_transport_set_ptr2 - Used to set first argument of the transport functions
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @recv_ptr: is the value for the pull function
   * @send_ptr: is the value for the push function
   *
@@ -110,9 +110,9 @@ void gnutls_transport_set_ptr(gnutls_session session,
   * receiving and sending.
   *
   **/
-void gnutls_transport_set_ptr2(gnutls_session session,
-			       gnutls_transport_ptr recv_ptr,
-			       gnutls_transport_ptr send_ptr)
+void gnutls_transport_set_ptr2(gnutls_session_t session,
+			       gnutls_transport_ptr_t recv_ptr,
+			       gnutls_transport_ptr_t send_ptr)
 {
     session->internals.transport_send_ptr = send_ptr;
     session->internals.transport_recv_ptr = recv_ptr;
@@ -120,20 +120,20 @@ void gnutls_transport_set_ptr2(gnutls_session session,
 
 /**
   * gnutls_transport_get_ptr - Used to return the first argument of the transport functions
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * Used to get the first argument of the transport function (like PUSH and
   * PULL). This must have been set using gnutls_transport_set_ptr().
   *
   **/
-gnutls_transport_ptr gnutls_transport_get_ptr(gnutls_session session)
+gnutls_transport_ptr_t gnutls_transport_get_ptr(gnutls_session_t session)
 {
     return session->internals.transport_recv_ptr;
 }
 
 /**
   * gnutls_transport_get_ptr2 - Used to return the first argument of the transport functions
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @recv_ptr: will hold the value for the pull function
   * @send_ptr: will hold the value for the push function
   *
@@ -141,9 +141,9 @@ gnutls_transport_ptr gnutls_transport_get_ptr(gnutls_session session)
   * PULL). These should have been set using gnutls_transport_set_ptr2().
   *
   **/
-void gnutls_transport_get_ptr2(gnutls_session session,
-			       gnutls_transport_ptr * recv_ptr,
-			       gnutls_transport_ptr * send_ptr)
+void gnutls_transport_get_ptr2(gnutls_session_t session,
+			       gnutls_transport_ptr_t * recv_ptr,
+			       gnutls_transport_ptr_t * send_ptr)
 {
 
     *recv_ptr = session->internals.transport_recv_ptr;
@@ -152,7 +152,7 @@ void gnutls_transport_get_ptr2(gnutls_session session,
 
 /**
   * gnutls_bye - This function terminates the current TLS/SSL connection.
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @how: is an integer
   *
   * Terminates the current TLS/SSL connection. The connection should
@@ -174,7 +174,7 @@ void gnutls_transport_get_ptr2(gnutls_session session,
   * gnutls_record_get_direction().
   *
   **/
-int gnutls_bye(gnutls_session session, gnutls_close_request how)
+int gnutls_bye(gnutls_session_t session, gnutls_close_request_t how)
 {
     int ret = 0;
 
@@ -222,20 +222,20 @@ int gnutls_bye(gnutls_session session, gnutls_close_request how)
     return 0;
 }
 
-inline static void session_invalidate(gnutls_session session)
+inline static void session_invalidate(gnutls_session_t session)
 {
     session->internals.valid_connection = VALID_FALSE;
 }
 
 
-inline static void session_unresumable(gnutls_session session)
+inline static void session_unresumable(gnutls_session_t session)
 {
     session->internals.resumable = RESUME_FALSE;
 }
 
 /* returns 0 if session is valid
  */
-inline static int session_is_valid(gnutls_session session)
+inline static int session_is_valid(gnutls_session_t session)
 {
     if (session->internals.valid_connection == VALID_FALSE)
 	return GNUTLS_E_INVALID_SESSION;
@@ -247,10 +247,10 @@ inline static int session_is_valid(gnutls_session session)
  * version must have 2 bytes at least.
  */
 inline static
-void copy_record_version(gnutls_session session, HandshakeType htype,
+void copy_record_version(gnutls_session_t session, handshake_t htype,
 			 opaque version[2])
 {
-    gnutls_protocol_version lver;
+    gnutls_protocol_t lver;
 
     if (htype != GNUTLS_CLIENT_HELLO
 	|| session->internals.default_record_version[0] == 0) {
@@ -265,7 +265,7 @@ void copy_record_version(gnutls_session session, HandshakeType htype,
 }
 
 /* This function behaves exactly like write(). The only difference is
- * that it accepts, the gnutls_session and the content_type_t of data to
+ * that it accepts, the gnutls_session_t and the content_type_t of data to
  * send (if called by the user the Content is specific)
  * It is intended to transfer data, under the current session.    
  *
@@ -278,8 +278,8 @@ void copy_record_version(gnutls_session session, HandshakeType htype,
  * and only if the previous send was interrupted for some reason.
  *
  */
-ssize_t _gnutls_send_int(gnutls_session session, content_type_t type,
-			 HandshakeType htype, const void *_data,
+ssize_t _gnutls_send_int(gnutls_session_t session, content_type_t type,
+			 handshake_t htype, const void *_data,
 			 size_t sizeofdata)
 {
     uint8 *cipher;
@@ -420,7 +420,7 @@ ssize_t _gnutls_send_int(gnutls_session session, content_type_t type,
 /* This function is to be called if the handshake was successfully 
  * completed. This sends a Change Cipher Spec packet to the peer.
  */
-ssize_t _gnutls_send_change_cipher_spec(gnutls_session session, int again)
+ssize_t _gnutls_send_change_cipher_spec(gnutls_session_t session, int again)
 {
     static const opaque data[1] = { GNUTLS_TYPE_CHANGE_CIPHER_SPEC };
 
@@ -453,7 +453,7 @@ static int check_recv_type(content_type_t recv_type)
 /* Checks if there are pending data in the record buffers. If there are
  * then it copies the data.
  */
-static int check_buffers(gnutls_session session, content_type_t type,
+static int check_buffers(gnutls_session_t session, content_type_t type,
 			 opaque * data, int sizeofdata)
 {
     if ((type == GNUTLS_APPLICATION_DATA || type == GNUTLS_HANDSHAKE)
@@ -486,9 +486,9 @@ static int check_buffers(gnutls_session session, content_type_t type,
  * content type.
  */
 static
-int record_check_headers(gnutls_session session,
+int record_check_headers(gnutls_session_t session,
 			 uint8 headers[RECORD_HEADER_SIZE],
-			 content_type_t type, HandshakeType htype,
+			 content_type_t type, handshake_t htype,
 			 /*output */ content_type_t * recv_type,
 			 opaque version[2], uint16 * length,
 			 uint16 * header_size)
@@ -542,8 +542,8 @@ int record_check_headers(gnutls_session session,
  */
 #ifdef CHECK_RECORD_VERSION
 inline
-    static int record_check_version(gnutls_session session,
-				    HandshakeType htype, opaque version[2])
+    static int record_check_version(gnutls_session_t session,
+				    handshake_t htype, opaque version[2])
 {
     if ((htype != GNUTLS_CLIENT_HELLO && htype != GNUTLS_SERVER_HELLO) &&
 	gnutls_protocol_get_version(session) !=
@@ -565,9 +565,9 @@ inline
 /* This function will check if the received record type is
  * the one we actually expect.
  */
-static int record_check_type(gnutls_session session,
+static int record_check_type(gnutls_session_t session,
 			     content_type_t recv_type, content_type_t type,
-			     HandshakeType htype, opaque * data,
+			     handshake_t htype, opaque * data,
 			     int data_size)
 {
 
@@ -683,8 +683,8 @@ static int record_check_type(gnutls_session session,
  * also initialize it.
  */
 inline
-    static int get_temp_recv_buffer(gnutls_session session,
-				    gnutls_datum * tmp)
+    static int get_temp_recv_buffer(gnutls_session_t session,
+				    gnutls_datum_t * tmp)
 {
 
     /* We allocate MAX_RECORD_RECV_SIZE length
@@ -719,17 +719,17 @@ inline
 #define MAX_EMPTY_PACKETS_SEQUENCE 4
 
 /* This function behaves exactly like read(). The only difference is
- * that it accepts the gnutls_session and the content_type_t of data to
+ * that it accepts the gnutls_session_t and the content_type_t of data to
  * receive (if called by the user the Content is Userdata only)
  * It is intended to receive data, under the current session.
  *
- * The HandshakeType was introduced to support SSL V2.0 client hellos.
+ * The handshake_t was introduced to support SSL V2.0 client hellos.
  */
-ssize_t _gnutls_recv_int(gnutls_session session, content_type_t type,
-			 HandshakeType htype, opaque * data,
+ssize_t _gnutls_recv_int(gnutls_session_t session, content_type_t type,
+			 handshake_t htype, opaque * data,
 			 size_t sizeofdata)
 {
-    gnutls_datum tmp;
+    gnutls_datum_t tmp;
     int decrypted_length;
     opaque version[2];
     uint8 *headers;
@@ -964,7 +964,7 @@ ssize_t _gnutls_recv_int(gnutls_session session, content_type_t type,
 
 /**
   * gnutls_record_send - sends to the peer the specified data
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @data: contains the data to send
   * @sizeofdata: is the length of the data
   *
@@ -986,7 +986,7 @@ ssize_t _gnutls_recv_int(gnutls_session session, content_type_t type,
   * maximum record size.
   *
   **/
-ssize_t gnutls_record_send(gnutls_session session, const void *data,
+ssize_t gnutls_record_send(gnutls_session_t session, const void *data,
 			   size_t sizeofdata)
 {
     return _gnutls_send_int(session, GNUTLS_APPLICATION_DATA, -1, data,
@@ -995,7 +995,7 @@ ssize_t gnutls_record_send(gnutls_session session, const void *data,
 
 /**
   * gnutls_record_recv - reads data from the TLS record protocol
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @data: contains the data to send
   * @sizeofdata: is the length of the data
   *
@@ -1015,7 +1015,7 @@ ssize_t gnutls_record_send(gnutls_session session, const void *data,
   * A negative error code is returned in case of an error.
   *
   **/
-ssize_t gnutls_record_recv(gnutls_session session, void *data,
+ssize_t gnutls_record_recv(gnutls_session_t session, void *data,
 			   size_t sizeofdata)
 {
     return _gnutls_recv_int(session, GNUTLS_APPLICATION_DATA, -1, data,
@@ -1024,14 +1024,14 @@ ssize_t gnutls_record_recv(gnutls_session session, void *data,
 
 /**
   * gnutls_record_get_max_size - returns the maximum record size
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * This function returns the maximum record packet size in this connection.
   * The maximum record size is negotiated by the client after the
   * first handshake message.
   *
   **/
-size_t gnutls_record_get_max_size(gnutls_session session)
+size_t gnutls_record_get_max_size(gnutls_session_t session)
 {
     /* Recv will hold the negotiated max record size
      * always.
@@ -1042,7 +1042,7 @@ size_t gnutls_record_get_max_size(gnutls_session session)
 
 /**
   * gnutls_record_set_max_size - sets the maximum record size
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @size: is the new size
   *
   * This function sets the maximum record packet size in this connection.
@@ -1058,7 +1058,7 @@ size_t gnutls_record_get_max_size(gnutls_session session)
   * Not all TLS implementations use or even understand this extension.
   *
   **/
-ssize_t gnutls_record_set_max_size(gnutls_session session, size_t size)
+ssize_t gnutls_record_set_max_size(gnutls_session_t session, size_t size)
 {
     ssize_t new_size;
 
diff --git a/lib/gnutls_record.h b/lib/gnutls_record.h
index 1952f487da..5e38a2de5d 100644
--- a/lib/gnutls_record.h
+++ b/lib/gnutls_record.h
@@ -1,7 +1,7 @@
-ssize_t _gnutls_send_int(gnutls_session session, content_type_t type,
-			 HandshakeType htype, const void *data,
+ssize_t _gnutls_send_int(gnutls_session_t session, content_type_t type,
+			 handshake_t htype, const void *data,
 			 size_t sizeofdata);
-ssize_t _gnutls_recv_int(gnutls_session session, content_type_t type,
-			 HandshakeType, opaque * data, size_t sizeofdata);
-ssize_t _gnutls_send_change_cipher_spec(gnutls_session session, int again);
-void gnutls_transport_set_lowat(gnutls_session session, int num);
+ssize_t _gnutls_recv_int(gnutls_session_t session, content_type_t type,
+			 handshake_t, opaque * data, size_t sizeofdata);
+ssize_t _gnutls_send_change_cipher_spec(gnutls_session_t session, int again);
+void gnutls_transport_set_lowat(gnutls_session_t session, int num);
diff --git a/lib/gnutls_rsa_export.c b/lib/gnutls_rsa_export.c
index 84d25436d9..3777f752d7 100644
--- a/lib/gnutls_rsa_export.c
+++ b/lib/gnutls_rsa_export.c
@@ -42,7 +42,7 @@
 /* returns e and m, depends on the requested bits.
  * We only support limited key sizes.
  */
-const mpi_t *_gnutls_get_rsa_params(gnutls_rsa_params rsa_params)
+const mpi_t *_gnutls_get_rsa_params(gnutls_rsa_params_t rsa_params)
 {
     if (rsa_params == NULL) {
 	return NULL;
@@ -168,13 +168,13 @@ int _gnutls_rsa_generate_params(mpi_t * resarr, int *resarr_len, int bits)
   * The new parameters should be stored in the appropriate gnutls_datum. 
   * 
   **/
-int gnutls_rsa_params_import_raw(gnutls_rsa_params rsa_params,
-				 const gnutls_datum * m,
-				 const gnutls_datum * e,
-				 const gnutls_datum * d,
-				 const gnutls_datum * p,
-				 const gnutls_datum * q,
-				 const gnutls_datum * u)
+int gnutls_rsa_params_import_raw(gnutls_rsa_params_t rsa_params,
+				 const gnutls_datum_t * m,
+				 const gnutls_datum_t * e,
+				 const gnutls_datum_t * d,
+				 const gnutls_datum_t * p,
+				 const gnutls_datum_t * q,
+				 const gnutls_datum_t * u)
 {
     return gnutls_x509_privkey_import_rsa_raw(rsa_params,
 					      m, e, d, p, q, u);
@@ -187,7 +187,7 @@ int gnutls_rsa_params_import_raw(gnutls_rsa_params rsa_params,
   * This function will initialize the temporary RSA parameters structure.
   *
   **/
-int gnutls_rsa_params_init(gnutls_rsa_params * rsa_params)
+int gnutls_rsa_params_init(gnutls_rsa_params_t * rsa_params)
 {
     int ret;
 
@@ -209,7 +209,7 @@ int gnutls_rsa_params_init(gnutls_rsa_params * rsa_params)
   * This function will deinitialize the RSA parameters structure.
   *
   **/
-void gnutls_rsa_params_deinit(gnutls_rsa_params rsa_params)
+void gnutls_rsa_params_deinit(gnutls_rsa_params_t rsa_params)
 {
     gnutls_x509_privkey_deinit(rsa_params);
 }
@@ -223,7 +223,7 @@ void gnutls_rsa_params_deinit(gnutls_rsa_params rsa_params)
   * to destination.
   *
   **/
-int gnutls_rsa_params_cpy(gnutls_rsa_params dst, gnutls_rsa_params src)
+int gnutls_rsa_params_cpy(gnutls_rsa_params_t dst, gnutls_rsa_params_t src)
 {
     return gnutls_x509_privkey_cpy(dst, src);
 }
@@ -243,7 +243,7 @@ int gnutls_rsa_params_cpy(gnutls_rsa_params dst, gnutls_rsa_params src)
   * no use calling this in client side.
   *
   **/
-int gnutls_rsa_params_generate2(gnutls_rsa_params params,
+int gnutls_rsa_params_generate2(gnutls_rsa_params_t params,
 				unsigned int bits)
 {
     return gnutls_x509_privkey_generate(params, GNUTLS_PK_RSA, bits, 0);
@@ -265,9 +265,9 @@ int gnutls_rsa_params_generate2(gnutls_rsa_params params,
   * 0 on success.
   *
   **/
-int gnutls_rsa_params_import_pkcs1(gnutls_rsa_params params,
-				   const gnutls_datum * pkcs1_params,
-				   gnutls_x509_crt_fmt format)
+int gnutls_rsa_params_import_pkcs1(gnutls_rsa_params_t params,
+				   const gnutls_datum_t * pkcs1_params,
+				   gnutls_x509_crt_fmt_t format)
 {
     return gnutls_x509_privkey_import(params, pkcs1_params, format);
 }
@@ -291,8 +291,8 @@ int gnutls_rsa_params_import_pkcs1(gnutls_rsa_params params,
   * 0 on success.
   *
   **/
-int gnutls_rsa_params_export_pkcs1(gnutls_rsa_params params,
-				   gnutls_x509_crt_fmt format,
+int gnutls_rsa_params_export_pkcs1(gnutls_rsa_params_t params,
+				   gnutls_x509_crt_fmt_t format,
 				   unsigned char *params_data,
 				   size_t * params_data_size)
 {
@@ -317,11 +317,10 @@ int gnutls_rsa_params_export_pkcs1(gnutls_rsa_params params,
   * gnutls_malloc() and will be stored in the appropriate datum.
   * 
   **/
-int gnutls_rsa_params_export_raw(gnutls_rsa_params params,
-				 gnutls_datum * m, gnutls_datum * e,
-				 gnutls_datum * d, gnutls_datum * p,
-				 gnutls_datum * q, gnutls_datum * u,
-				 unsigned int *bits)
+int gnutls_rsa_params_export_raw(gnutls_rsa_params_t params,
+    gnutls_datum_t * m, gnutls_datum_t * e,
+    gnutls_datum_t * d, gnutls_datum_t * p,
+    gnutls_datum_t * q, gnutls_datum_t * u, unsigned int *bits)
 {
     int ret;
 
diff --git a/lib/gnutls_rsa_export.h b/lib/gnutls_rsa_export.h
index 0d18464982..f68f4afcf6 100644
--- a/lib/gnutls_rsa_export.h
+++ b/lib/gnutls_rsa_export.h
@@ -18,7 +18,7 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 
-const mpi_t *_gnutls_get_rsa_params(gnutls_rsa_params);
-int _gnutls_peers_cert_less_512(gnutls_session session);
+const mpi_t *_gnutls_get_rsa_params(gnutls_rsa_params_t);
+int _gnutls_peers_cert_less_512(gnutls_session_t session);
 int _gnutls_rsa_generate_params(mpi_t * resarr, int *resarr_len, int bits);
-void gnutls_rsa_params_deinit(gnutls_rsa_params rsa_params);
+void gnutls_rsa_params_deinit(gnutls_rsa_params_t rsa_params);
diff --git a/lib/gnutls_session.c b/lib/gnutls_session.c
index 9eabfa043f..19af8cd482 100644
--- a/lib/gnutls_session.c
+++ b/lib/gnutls_session.c
@@ -28,7 +28,7 @@
 
 /**
   * gnutls_session_get_data - Returns all session parameters.
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @session_data: is a pointer to space to hold the session.
   * @session_data_size: is the session_data's size, or it will be set by the function.
   *
@@ -39,11 +39,11 @@
   *
   * Resuming sessions is really useful and speedups connections after a succesful one.
   **/
-int gnutls_session_get_data(gnutls_session session,
+int gnutls_session_get_data(gnutls_session_t session,
 			    void *session_data, size_t * session_data_size)
 {
 
-    gnutls_datum psession;
+    gnutls_datum_t psession;
     int ret;
 
     if (*session_data_size < SESSION_SIZE || session_data == NULL) {
@@ -73,7 +73,7 @@ int gnutls_session_get_data(gnutls_session session,
 
 /**
   * gnutls_session_get_id - Returns session id.
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @session_id: is a pointer to space to hold the session id.
   * @session_id_size: is the session id's size, or it will be set by the function.
   *
@@ -85,7 +85,7 @@ int gnutls_session_get_data(gnutls_session session,
   * Session id is some data set by the server, that identify the current session. 
   * In TLS 1.0 and SSL 3.0 session id is always less than 32 bytes.
   **/
-int gnutls_session_get_id(gnutls_session session,
+int gnutls_session_get_id(gnutls_session_t session,
 			  void *session_id, size_t * session_id_size)
 {
 
@@ -103,7 +103,7 @@ int gnutls_session_get_id(gnutls_session session,
 
 /**
   * gnutls_session_set_data - Sets all session parameters
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @session_data: is a pointer to space to hold the session.
   * @session_data_size: is the session's size
   *
@@ -118,12 +118,12 @@ int gnutls_session_get_id(gnutls_session session,
   * Returns a negative value on error.
   *
   **/
-int gnutls_session_set_data(gnutls_session session,
+int gnutls_session_set_data(gnutls_session_t session,
 			    const void *session_data,
 			    size_t session_data_size)
 {
     int ret;
-    gnutls_datum psession;
+    gnutls_datum_t psession;
 
     psession.data = (opaque *) session_data;
     psession.size = session_data_size;
diff --git a/lib/gnutls_session.h b/lib/gnutls_session.h
index 882d56fed0..1ff8e2b210 100644
--- a/lib/gnutls_session.h
+++ b/lib/gnutls_session.h
@@ -18,8 +18,8 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 
-int gnutls_session_set_data(gnutls_session session,
+int gnutls_session_set_data(gnutls_session_t session,
 			    const opaque * session_data,
 			    int session_data_size);
-int gnutls_session_get_data(gnutls_session session, opaque * session_data,
+int gnutls_session_get_data(gnutls_session_t session, opaque * session_data,
 			    int *session_data_size);
diff --git a/lib/gnutls_session_pack.c b/lib/gnutls_session_pack.c
index ff0c990621..7edc36ae42 100644
--- a/lib/gnutls_session_pack.c
+++ b/lib/gnutls_session_pack.c
@@ -36,9 +36,9 @@
 
 #define PACK_HEADER_SIZE 1
 int _gnutls_pack_certificate_auth_info(cert_auth_info_t info,
-				       gnutls_datum * packed_session);
+				       gnutls_datum_t * packed_session);
 int _gnutls_unpack_certificate_auth_info(cert_auth_info_t info,
-					 const gnutls_datum *
+					 const gnutls_datum_t *
 					 packed_session);
 static int _gnutls_pack_certificate_auth_info_size(cert_auth_info_t info);
 
@@ -47,8 +47,8 @@ static int _gnutls_pack_certificate_auth_info_size(cert_auth_info_t info);
  * is required in order to pack these structures in a vector in
  * order to store them to the DB.
  */
-int _gnutls_session_pack(gnutls_session session,
-			 gnutls_datum * packed_session)
+int _gnutls_session_pack(gnutls_session_t session,
+			 gnutls_datum_t * packed_session)
 {
     uint32 pack_size;
     int ret;
@@ -147,7 +147,7 @@ int _gnutls_session_pack(gnutls_session session,
 
 /* Returns the size needed to hold the current session.
  */
-uint _gnutls_session_size(gnutls_session session)
+uint _gnutls_session_size(gnutls_session_t session)
 {
     uint32 pack_size;
 
@@ -173,8 +173,8 @@ uint _gnutls_session_size(gnutls_session session)
     return pack_size;
 }
 
-int _gnutls_session_unpack(gnutls_session session,
-			   const gnutls_datum * packed_session)
+int _gnutls_session_unpack(gnutls_session_t session,
+			   const gnutls_datum_t * packed_session)
 {
     uint32 pack_size;
     int ret;
@@ -321,7 +321,7 @@ int _gnutls_session_unpack(gnutls_session session,
 }
 
 int _gnutls_pack_certificate_auth_info(cert_auth_info_t info,
-				       gnutls_datum * packed_session)
+				       gnutls_datum_t * packed_session)
 {
     unsigned int pos, i;
     int info_size;
@@ -378,7 +378,7 @@ static int _gnutls_pack_certificate_auth_info_size(cert_auth_info_t info)
 
 
 int _gnutls_unpack_certificate_auth_info(cert_auth_info_t info,
-					 const gnutls_datum *
+					 const gnutls_datum_t *
 					 packed_session)
 {
     unsigned int i, j, pos;
@@ -392,7 +392,7 @@ int _gnutls_unpack_certificate_auth_info(cert_auth_info_t info,
     pos = PACK_HEADER_SIZE + sizeof(uint32) + sizeof(cert_auth_info_st);
     if (info->ncerts > 0) {
 	info->raw_certificate_list =
-	    gnutls_calloc(1, info->ncerts * sizeof(gnutls_datum));
+	    gnutls_calloc(1, info->ncerts * sizeof(gnutls_datum_t));
 	if (info->raw_certificate_list == NULL) {
 	    gnutls_assert();
 	    return GNUTLS_E_MEMORY_ERROR;
diff --git a/lib/gnutls_session_pack.h b/lib/gnutls_session_pack.h
index 0956beb758..d49e972b17 100644
--- a/lib/gnutls_session_pack.h
+++ b/lib/gnutls_session_pack.h
@@ -1,5 +1,5 @@
-int _gnutls_session_pack(gnutls_session session,
-			 gnutls_datum * packed_session);
-int _gnutls_session_unpack(gnutls_session session,
-			   const gnutls_datum * packed_session);
-uint _gnutls_session_size(gnutls_session session);
+int _gnutls_session_pack(gnutls_session_t session,
+			 gnutls_datum_t * packed_session);
+int _gnutls_session_unpack(gnutls_session_t session,
+			   const gnutls_datum_t * packed_session);
+uint _gnutls_session_size(gnutls_session_t session);
diff --git a/lib/gnutls_sig.c b/lib/gnutls_sig.c
index e84508b3a9..f9987de062 100644
--- a/lib/gnutls_sig.c
+++ b/lib/gnutls_sig.c
@@ -37,23 +37,23 @@
 
 static
 int _gnutls_tls_sign(gnutls_cert * cert, gnutls_privkey * pkey,
-		     const gnutls_datum * hash_concat,
-		     gnutls_datum * signature);
+		     const gnutls_datum_t * hash_concat,
+		     gnutls_datum_t * signature);
 
 
 /* Generates a signature of all the previous sent packets in the 
  * handshake procedure. (20040227: now it works for SSL 3.0 as well)
  */
-int _gnutls_tls_sign_hdata(gnutls_session session,
+int _gnutls_tls_sign_hdata(gnutls_session_t session,
 			   gnutls_cert * cert, gnutls_privkey * pkey,
-			   gnutls_datum * signature)
+			   gnutls_datum_t * signature)
 {
-    gnutls_datum dconcat;
+    gnutls_datum_t dconcat;
     int ret;
     opaque concat[36];
     mac_hd_t td_md5;
     mac_hd_t td_sha;
-    gnutls_protocol_version ver = gnutls_protocol_get_version(session);
+    gnutls_protocol_t ver = gnutls_protocol_get_version(session);
 
     td_sha =
 	_gnutls_hash_copy(session->internals.handshake_mac_handle_sha);
@@ -116,11 +116,11 @@ int _gnutls_tls_sign_hdata(gnutls_session session,
 /* Generates a signature of all the random data and the parameters.
  * Used in DHE_* ciphersuites.
  */
-int _gnutls_tls_sign_params(gnutls_session session, gnutls_cert * cert,
-			    gnutls_privkey * pkey, gnutls_datum * params,
-			    gnutls_datum * signature)
+int _gnutls_tls_sign_params(gnutls_session_t session, gnutls_cert * cert,
+			    gnutls_privkey * pkey, gnutls_datum_t * params,
+			    gnutls_datum_t * signature)
 {
-    gnutls_datum dconcat;
+    gnutls_datum_t dconcat;
     int ret;
     mac_hd_t td_md5;
     mac_hd_t td_sha;
@@ -182,8 +182,8 @@ int _gnutls_tls_sign_params(gnutls_session session, gnutls_cert * cert,
 /* This will create a PKCS1 or DSA signature, using the given parameters, and the
  * given data. The output will be allocated and be put in signature.
  */
-int _gnutls_sign(gnutls_pk_algorithm algo, mpi_t * params, int params_size,
-		 const gnutls_datum * data, gnutls_datum * signature)
+int _gnutls_sign(gnutls_pk_algorithm_t algo, mpi_t * params, int params_size,
+		 const gnutls_datum_t * data, gnutls_datum_t * signature)
 {
     int ret;
 
@@ -220,8 +220,8 @@ int _gnutls_sign(gnutls_pk_algorithm algo, mpi_t * params, int params_size,
  */
 static
 int _gnutls_tls_sign(gnutls_cert * cert, gnutls_privkey * pkey,
-		     const gnutls_datum * hash_concat,
-		     gnutls_datum * signature)
+		     const gnutls_datum_t * hash_concat,
+		     gnutls_datum_t * signature)
 {
 
     /* If our certificate supports signing
@@ -242,11 +242,11 @@ int _gnutls_tls_sign(gnutls_cert * cert, gnutls_privkey * pkey,
 
 static
 int _gnutls_pkcs1_rsa_verify_sig(gnutls_cert * cert,
-				 const gnutls_datum * hash_concat,
-				 gnutls_datum * signature)
+				 const gnutls_datum_t * hash_concat,
+				 gnutls_datum_t * signature)
 {
     int ret;
-    gnutls_datum vdata;
+    gnutls_datum_t vdata;
 
     if (cert->version == 0 || cert == NULL) {	/* this is the only way to check
 						   * if it is initialized
@@ -306,15 +306,15 @@ int _gnutls_pkcs1_rsa_verify_sig(gnutls_cert * cert,
 /* Verifies a TLS signature (like the one in the client certificate
  * verify message). 
  */
-int _gnutls_verify_sig_hdata(gnutls_session session, gnutls_cert * cert,
-			     gnutls_datum * signature)
+int _gnutls_verify_sig_hdata(gnutls_session_t session, gnutls_cert * cert,
+			     gnutls_datum_t * signature)
 {
     int ret;
     opaque concat[36];
     mac_hd_t td_md5;
     mac_hd_t td_sha;
-    gnutls_datum dconcat;
-    gnutls_protocol_version ver = gnutls_protocol_get_version(session);
+    gnutls_datum_t dconcat;
+    gnutls_protocol_t ver = gnutls_protocol_get_version(session);
 
     td_md5 =
 	_gnutls_hash_copy(session->internals.handshake_mac_handle_md5);
@@ -365,11 +365,11 @@ int _gnutls_verify_sig_hdata(gnutls_session session, gnutls_cert * cert,
 /* Generates a signature of all the random data and the parameters.
  * Used in DHE_* ciphersuites.
  */
-int _gnutls_verify_sig_params(gnutls_session session, gnutls_cert * cert,
-			      const gnutls_datum * params,
-			      gnutls_datum * signature)
+int _gnutls_verify_sig_params(gnutls_session_t session, gnutls_cert * cert,
+			      const gnutls_datum_t * params,
+			      gnutls_datum_t * signature)
 {
-    gnutls_datum dconcat;
+    gnutls_datum_t dconcat;
     int ret;
     mac_hd_t td_md5;
     mac_hd_t td_sha;
diff --git a/lib/gnutls_sig.h b/lib/gnutls_sig.h
index 4cc217fb77..c7b79a14ea 100644
--- a/lib/gnutls_sig.h
+++ b/lib/gnutls_sig.h
@@ -2,21 +2,17 @@
 # define GNUTLS_SIG_H
 # include <auth_cert.h>
 
-gnutls_certificate_status gnutls_x509_verify_signature(gnutls_cert * cert,
-						       gnutls_cert *
-						       issuer);
-int _gnutls_tls_sign_hdata(gnutls_session session, gnutls_cert * cert,
-			   gnutls_privkey * pkey,
-			   gnutls_datum * signature);
-int _gnutls_tls_sign_params(gnutls_session session, gnutls_cert * cert,
-			    gnutls_privkey * pkey, gnutls_datum * params,
-			    gnutls_datum * signature);
-int _gnutls_verify_sig_hdata(gnutls_session session, gnutls_cert * cert,
-			     gnutls_datum * signature);
-int _gnutls_verify_sig_params(gnutls_session session, gnutls_cert * cert,
-			      const gnutls_datum * params,
-			      gnutls_datum * signature);
-int _gnutls_sign(gnutls_pk_algorithm algo, mpi_t * params, int params_size,
-		 const gnutls_datum * data, gnutls_datum * signature);
+gnutls_certificate_status_t gnutls_x509_verify_signature(gnutls_cert * cert,
+     gnutls_cert * issuer);
+int _gnutls_tls_sign_hdata(gnutls_session_t session, gnutls_cert * cert,
+     gnutls_privkey * pkey, gnutls_datum_t * signature);
+int _gnutls_tls_sign_params(gnutls_session_t session, gnutls_cert * cert,
+     gnutls_privkey * pkey, gnutls_datum_t * params, gnutls_datum_t * signature);
+int _gnutls_verify_sig_hdata(gnutls_session_t session, gnutls_cert * cert,
+     gnutls_datum_t * signature);
+int _gnutls_verify_sig_params(gnutls_session_t session, gnutls_cert * cert,
+     const gnutls_datum_t * params, gnutls_datum_t * signature);
+int _gnutls_sign(gnutls_pk_algorithm_t algo, mpi_t * params, int params_size,
+     const gnutls_datum_t * data, gnutls_datum_t * signature);
 
 #endif
diff --git a/lib/gnutls_state.c b/lib/gnutls_state.c
index 2e1b78dcc7..246ab4d87d 100644
--- a/lib/gnutls_state.c
+++ b/lib/gnutls_state.c
@@ -47,65 +47,65 @@
 	return ret; \
 	}
 
-void _gnutls_session_cert_type_set(gnutls_session session,
-				   gnutls_certificate_type ct)
+void _gnutls_session_cert_type_set(gnutls_session_t session,
+				   gnutls_certificate_type_t ct)
 {
     session->security_parameters.cert_type = ct;
 }
 
 /**
   * gnutls_cipher_get - Returns the currently used cipher.
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * Returns the currently used cipher.
   **/
-gnutls_cipher_algorithm gnutls_cipher_get(gnutls_session session)
+gnutls_cipher_algorithm_t gnutls_cipher_get(gnutls_session_t session)
 {
     return session->security_parameters.read_bulk_cipher_algorithm;
 }
 
 /**
   * gnutls_certificate_type_get - Returns the currently used certificate type.
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * Returns the currently used certificate type. The certificate type
   * is by default X.509, unless it is negotiated as a TLS extension.
   *
   **/
-gnutls_certificate_type gnutls_certificate_type_get(gnutls_session session)
+gnutls_certificate_type_t gnutls_certificate_type_get(gnutls_session_t session)
 {
     return session->security_parameters.cert_type;
 }
 
 /**
   * gnutls_kx_get - Returns the key exchange algorithm.
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * Returns the key exchange algorithm used in the last handshake.
   **/
-gnutls_kx_algorithm gnutls_kx_get(gnutls_session session)
+gnutls_kx_algorithm_t gnutls_kx_get(gnutls_session_t session)
 {
     return session->security_parameters.kx_algorithm;
 }
 
 /**
   * gnutls_mac_get - Returns the currently used mac algorithm.
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * Returns the currently used mac algorithm.
   **/
-gnutls_mac_algorithm gnutls_mac_get(gnutls_session session)
+gnutls_mac_algorithm_t gnutls_mac_get(gnutls_session_t session)
 {
     return session->security_parameters.read_mac_algorithm;
 }
 
 /**
   * gnutls_compression_get - Returns the currently used compression algorithm.
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * Returns the currently used compression method.
   **/
-gnutls_compression_method gnutls_compression_get(gnutls_session session)
+gnutls_compression_method_t gnutls_compression_get(gnutls_session_t session)
 {
     return session->security_parameters.read_compression_algorithm;
 }
@@ -114,12 +114,12 @@ gnutls_compression_method gnutls_compression_get(gnutls_session session)
  * This means that it is enabled by the priority functions,
  * and a matching certificate exists.
  */
-int _gnutls_session_cert_type_supported(gnutls_session session,
-					gnutls_certificate_type cert_type)
+int _gnutls_session_cert_type_supported(gnutls_session_t session,
+					gnutls_certificate_type_t cert_type)
 {
     uint i;
     uint cert_found = 0;
-    const gnutls_certificate_credentials cred;
+    const gnutls_certificate_credentials_t cred;
 
     if (session->security_parameters.entity == GNUTLS_SERVER) {
 	cred =
@@ -158,7 +158,7 @@ int _gnutls_session_cert_type_supported(gnutls_session session,
 /* this function deinitializes all the internal parameters stored
  * in a session struct.
  */
-inline static void deinit_internal_params(gnutls_session session)
+inline static void deinit_internal_params(gnutls_session_t session)
 {
     if (session->internals.params.free_anon_dh_params)
 	gnutls_dh_params_deinit(session->internals.params.anon_dh_params);
@@ -177,7 +177,7 @@ inline static void deinit_internal_params(gnutls_session session)
  * structure within the session, which depend on the current handshake.
  * This is used to allow further handshakes.
  */
-void _gnutls_handshake_internal_state_clear(gnutls_session session)
+void _gnutls_handshake_internal_state_clear(gnutls_session_t session)
 {
     session->internals.extensions_sent_size = 0;
 
@@ -212,14 +212,14 @@ void _gnutls_handshake_internal_state_clear(gnutls_session session)
   * gnutls_init - This function initializes the session to null (null encryption etc...).
   * @con_end: is used to indicate if this session is to be used for server or 
   * client. Can be one of GNUTLS_CLIENT and GNUTLS_SERVER. 
-  * @session: is a pointer to a &gnutls_session structure.
+  * @session: is a pointer to a &gnutls_session_t structure.
   *
   * This function initializes the current session to null. Every session
   * must be initialized before use, so internal structures can be allocated.
   * This function allocates structures which can only be free'd
   * by calling gnutls_deinit(). Returns zero on success.
   **/
-int gnutls_init(gnutls_session * session, gnutls_connection_end con_end)
+int gnutls_init(gnutls_session_t * session, gnutls_connection_end_t con_end)
 {
     *session = gnutls_calloc(1, sizeof(struct gnutls_session_int));
     if (*session == NULL)
@@ -287,8 +287,8 @@ int gnutls_init(gnutls_session * session, gnutls_connection_end con_end)
 
     /* set the socket pointers to -1;
      */
-    (*session)->internals.transport_recv_ptr = (gnutls_transport_ptr) - 1;
-    (*session)->internals.transport_send_ptr = (gnutls_transport_ptr) - 1;
+    (*session)->internals.transport_recv_ptr = (gnutls_transport_ptr_t) - 1;
+    (*session)->internals.transport_send_ptr = (gnutls_transport_ptr_t) - 1;
 
     /* set the default maximum record size for TLS
      */
@@ -308,7 +308,7 @@ int gnutls_init(gnutls_session * session, gnutls_connection_end con_end)
 
 /* returns RESUME_FALSE or RESUME_TRUE.
  */
-int _gnutls_session_is_resumable(gnutls_session session)
+int _gnutls_session_is_resumable(gnutls_session_t session)
 {
     return session->internals.resumable;
 }
@@ -316,14 +316,14 @@ int _gnutls_session_is_resumable(gnutls_session session)
 
 /**
   * gnutls_deinit - This function clears all buffers associated with the &session
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * This function clears all buffers associated with the &session.
   * This function will also remove session data from the session database
   * if the session was terminated abnormally.
   *
   **/
-void gnutls_deinit(gnutls_session session)
+void gnutls_deinit(gnutls_session_t session)
 {
 
     if (session == NULL)
@@ -404,12 +404,12 @@ void gnutls_deinit(gnutls_session session)
 
 /* Returns the minimum prime bits that are acceptable.
  */
-int _gnutls_dh_get_allowed_prime_bits(gnutls_session session)
+int _gnutls_dh_get_allowed_prime_bits(gnutls_session_t session)
 {
     return session->internals.dh_prime_bits;
 }
 
-int _gnutls_dh_set_peer_public(gnutls_session session, mpi_t public)
+int _gnutls_dh_set_peer_public(gnutls_session_t session, mpi_t public)
 {
     dh_info_t *dh;
     int ret;
@@ -451,7 +451,7 @@ int _gnutls_dh_set_peer_public(gnutls_session session, mpi_t public)
     return 0;
 }
 
-int _gnutls_dh_set_secret_bits(gnutls_session session, uint bits)
+int _gnutls_dh_set_secret_bits(gnutls_session_t session, uint bits)
 {
     switch (gnutls_auth_get_type(session)) {
     case GNUTLS_CRD_ANON:{
@@ -483,7 +483,7 @@ int _gnutls_dh_set_secret_bits(gnutls_session session, uint bits)
 /* This function will set in the auth info structure the
  * RSA exponent and the modulus.
  */
-int _gnutls_rsa_export_set_pubkey(gnutls_session session, mpi_t exp,
+int _gnutls_rsa_export_set_pubkey(gnutls_session_t session, mpi_t exp,
 				  mpi_t mod)
 {
     cert_auth_info_t info;
@@ -520,7 +520,7 @@ int _gnutls_rsa_export_set_pubkey(gnutls_session session, mpi_t exp,
 
 /* Sets the prime and the generator in the auth info structure.
  */
-int _gnutls_dh_set_group(gnutls_session session, mpi_t gen, mpi_t prime)
+int _gnutls_dh_set_group(gnutls_session_t session, mpi_t gen, mpi_t prime)
 {
     dh_info_t *dh;
     int ret;
@@ -572,7 +572,7 @@ int _gnutls_dh_set_group(gnutls_session session, mpi_t gen, mpi_t prime)
 
 /**
   * gnutls_openpgp_send_key - This function will order gnutls to send the openpgp fingerprint instead of the key
-  * @session: is a pointer to a &gnutls_session structure.
+  * @session: is a pointer to a &gnutls_session_t structure.
   * @status: is one of OPENPGP_KEY, or OPENPGP_KEY_FINGERPRINT
   *
   * This function will order gnutls to send the key fingerprint instead
@@ -581,15 +581,15 @@ int _gnutls_dh_set_group(gnutls_session session, mpi_t gen, mpi_t prime)
   * server can obtain the client's key.
   *
   **/
-void gnutls_openpgp_send_key(gnutls_session session,
-			     gnutls_openpgp_key_status status)
+void gnutls_openpgp_send_key(gnutls_session_t session,
+			     gnutls_openpgp_key_status_t status)
 {
     session->internals.pgp_fingerprint = status;
 }
 
 /**
   * gnutls_certificate_send_x509_rdn_sequence - This function will order gnutls to or not to send the x.509 rdn sequence
-  * @session: is a pointer to a &gnutls_session structure.
+  * @session: is a pointer to a &gnutls_session_t structure.
   * @status: is 0 or 1
   *
   * If status is non zero, this function will order gnutls not to send the rdnSequence 
@@ -601,20 +601,20 @@ void gnutls_openpgp_send_key(gnutls_session session,
   * certificate with X.509 certificates.
   *
   **/
-void gnutls_certificate_send_x509_rdn_sequence(gnutls_session session,
+void gnutls_certificate_send_x509_rdn_sequence(gnutls_session_t session,
 					       int status)
 {
     session->internals.ignore_rdn_sequence = status;
 }
 
-int _gnutls_openpgp_send_fingerprint(gnutls_session session)
+int _gnutls_openpgp_send_fingerprint(gnutls_session_t session)
 {
     return session->internals.pgp_fingerprint;
 }
 
 /*-
   * _gnutls_record_set_default_version - Used to set the default version for the first record packet
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @major: is a tls major version
   * @minor: is a tls minor version
   *
@@ -623,7 +623,7 @@ int _gnutls_openpgp_send_fingerprint(gnutls_session session)
   * that know TLS internals and want to debug other implementations.
   *
   -*/
-void _gnutls_record_set_default_version(gnutls_session session,
+void _gnutls_record_set_default_version(gnutls_session_t session,
 					unsigned char major,
 					unsigned char minor)
 {
@@ -633,7 +633,7 @@ void _gnutls_record_set_default_version(gnutls_session session,
 
 /**
   * gnutls_handshake_set_private_extensions - Used to enable the private cipher suites
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @allow: is an integer (0 or 1)
   *
   * This function will enable or disable the use of private
@@ -649,14 +649,14 @@ void _gnutls_record_set_default_version(gnutls_session session,
   * servers and clients may cause interoperability problems.
   *
   **/
-void gnutls_handshake_set_private_extensions(gnutls_session session,
+void gnutls_handshake_set_private_extensions(gnutls_session_t session,
 					     int allow)
 {
     session->internals.enable_private = allow;
 }
 
 inline
-    static int _gnutls_cal_PRF_A(gnutls_mac_algorithm algorithm,
+    static int _gnutls_cal_PRF_A(gnutls_mac_algorithm_t algorithm,
 				 const void *secret, int secret_size,
 				 const void *seed, int seed_size,
 				 void *result)
@@ -680,7 +680,7 @@ inline
 /* Produces "total_bytes" bytes using the hash algorithm specified.
  * (used in the PRF function)
  */
-static int _gnutls_P_hash(gnutls_mac_algorithm algorithm,
+static int _gnutls_P_hash(gnutls_mac_algorithm_t algorithm,
 			  const opaque * secret, int secret_size,
 			  const opaque * seed, int seed_size,
 			  int total_bytes, opaque * ret)
@@ -825,13 +825,13 @@ int _gnutls_PRF(const opaque * secret, int secret_size, const char *label,
 
 /**
   * gnutls_session_is_resumed - Used to check whether this session is a resumed one
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * This function will return non zero if this session is a resumed one,
   * or a zero if this is a new session.
   *
   **/
-int gnutls_session_is_resumed(gnutls_session session)
+int gnutls_session_is_resumed(gnutls_session_t session)
 {
     if (session->security_parameters.entity == GNUTLS_CLIENT) {
 	if (session->security_parameters.session_id_size > 0 &&
@@ -851,14 +851,14 @@ int gnutls_session_is_resumed(gnutls_session session)
 
 /*-
   * _gnutls_session_is_export - Used to check whether this session is of export grade
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * This function will return non zero if this session is of export grade.
   *
   -*/
-int _gnutls_session_is_export(gnutls_session session)
+int _gnutls_session_is_export(gnutls_session_t session)
 {
-    gnutls_cipher_algorithm cipher;
+    gnutls_cipher_algorithm_t cipher;
 
     cipher =
 	_gnutls_cipher_suite_get_cipher_algo(&session->security_parameters.
@@ -872,27 +872,27 @@ int _gnutls_session_is_export(gnutls_session session)
 
 /**
   * gnutls_session_get_ptr - Used to get the user pointer from the session structure
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * This function will return the user given pointer from the session structure.
   * This is the pointer set with gnutls_session_set_ptr().
   *
   **/
-void *gnutls_session_get_ptr(gnutls_session session)
+void *gnutls_session_get_ptr(gnutls_session_t session)
 {
     return session->internals.user_ptr;
 }
 
 /**
   * gnutls_session_set_ptr - Used to set the user pointer to the session structure
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @ptr: is the user pointer
   *
   * This function will set (assosiate) the user given pointer to the session structure.
   * This is pointer can be accessed with gnutls_session_get_ptr().
   *
   **/
-void gnutls_session_set_ptr(gnutls_session session, void *ptr)
+void gnutls_session_set_ptr(gnutls_session_t session, void *ptr)
 {
     session->internals.user_ptr = ptr;
 }
@@ -900,7 +900,7 @@ void gnutls_session_set_ptr(gnutls_session session, void *ptr)
 
 /**
   * gnutls_record_get_direction - This function will return the direction of the last interrupted function call
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   *
   * This function provides information about the internals of the record
   * protocol and is only useful if a prior gnutls function call (e.g.
@@ -913,14 +913,14 @@ void gnutls_session_set_ptr(gnutls_session session, void *ptr)
   * write data.
   *
   **/
-int gnutls_record_get_direction(gnutls_session session)
+int gnutls_record_get_direction(gnutls_session_t session)
 {
     return session->internals.direction;
 }
 
 /*-
   * _gnutls_rsa_pms_set_version - Sets a version to be used at the RSA PMS
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @major: is the major version to use
   * @minor: is the minor version to use
   *
@@ -929,7 +929,7 @@ int gnutls_record_get_direction(gnutls_session session)
   * test server's capabilities.
   *
   -*/
-void _gnutls_rsa_pms_set_version(gnutls_session session,
+void _gnutls_rsa_pms_set_version(gnutls_session_t session,
 				 unsigned char major, unsigned char minor)
 {
     session->internals.rsa_pms_version[0] = major;
diff --git a/lib/gnutls_state.h b/lib/gnutls_state.h
index 19433fef05..e7053370aa 100644
--- a/lib/gnutls_state.h
+++ b/lib/gnutls_state.h
@@ -3,12 +3,11 @@
 
 #include <gnutls_int.h>
 
-void _gnutls_session_cert_type_set(gnutls_session session,
-				   gnutls_certificate_type);
-gnutls_kx_algorithm gnutls_kx_get(gnutls_session session);
-gnutls_cipher_algorithm gnutls_cipher_get(gnutls_session session);
-gnutls_certificate_type gnutls_certificate_type_get(gnutls_session
-						    session);
+void _gnutls_session_cert_type_set(gnutls_session_t session,
+    gnutls_certificate_type_t);
+gnutls_kx_algorithm_t gnutls_kx_get(gnutls_session_t session);
+gnutls_cipher_algorithm_t gnutls_cipher_get(gnutls_session_t session);
+gnutls_certificate_type_t gnutls_certificate_type_get(gnutls_session_t);
 
 #include <gnutls_auth_int.h>
 
@@ -19,28 +18,27 @@ gnutls_certificate_type gnutls_certificate_type_get(gnutls_session
 
 #endif
 
-int _gnutls_session_cert_type_supported(gnutls_session,
-					gnutls_certificate_type);
+int _gnutls_session_cert_type_supported(gnutls_session_t, gnutls_certificate_type_t);
 
-int _gnutls_dh_set_secret_bits(gnutls_session session, uint bits);
+int _gnutls_dh_set_secret_bits(gnutls_session_t session, uint bits);
 
-int _gnutls_dh_set_peer_public(gnutls_session session, mpi_t public);
-int _gnutls_dh_set_group(gnutls_session session, mpi_t gen, mpi_t prime);
+int _gnutls_dh_set_peer_public(gnutls_session_t session, mpi_t public);
+int _gnutls_dh_set_group(gnutls_session_t session, mpi_t gen, mpi_t prime);
 
-int _gnutls_dh_get_allowed_prime_bits(gnutls_session session);
-void gnutls_dh_set_prime_bits(gnutls_session session, unsigned int bits);
-void _gnutls_handshake_internal_state_clear(gnutls_session);
+int _gnutls_dh_get_allowed_prime_bits(gnutls_session_t session);
+void gnutls_dh_set_prime_bits(gnutls_session_t session, unsigned int bits);
+void _gnutls_handshake_internal_state_clear(gnutls_session_t);
 
-int _gnutls_rsa_export_set_pubkey(gnutls_session session, mpi_t exp,
-				  mpi_t mod);
+int _gnutls_rsa_export_set_pubkey(gnutls_session_t session, mpi_t exp,
+    mpi_t mod);
 
-int _gnutls_session_is_resumable(gnutls_session session);
-int _gnutls_session_is_export(gnutls_session session);
+int _gnutls_session_is_resumable(gnutls_session_t session);
+int _gnutls_session_is_export(gnutls_session_t session);
 
-int _gnutls_openpgp_send_fingerprint(gnutls_session session);
+int _gnutls_openpgp_send_fingerprint(gnutls_session_t session);
 
 int _gnutls_PRF(const opaque * secret, int secret_size, const char *label,
-		int label_size, opaque * seed, int seed_size,
-		int total_bytes, void *ret);
+    int label_size, opaque * seed, int seed_size,
+    int total_bytes, void *ret);
 
 #define DEFAULT_CERT_TYPE GNUTLS_CRT_X509
diff --git a/lib/gnutls_str.c b/lib/gnutls_str.c
index 0e55c35d9a..ad30a94799 100644
--- a/lib/gnutls_str.c
+++ b/lib/gnutls_str.c
@@ -100,9 +100,9 @@ void _gnutls_string_clear(gnutls_string * str)
 
 /* This one does not copy the string.
  */
-gnutls_datum _gnutls_string2datum(gnutls_string * str)
+gnutls_datum_t _gnutls_string2datum(gnutls_string * str)
 {
-    gnutls_datum ret;
+    gnutls_datum_t ret;
 
     ret.data = str->data;
     ret.size = str->length;
diff --git a/lib/gnutls_str.h b/lib/gnutls_str.h
index ec94878593..3162b8ff9c 100644
--- a/lib/gnutls_str.h
+++ b/lib/gnutls_str.h
@@ -24,7 +24,7 @@ void _gnutls_string_clear(gnutls_string *);
 /* Beware, do not clear the string, after calling this
  * function
  */
-gnutls_datum _gnutls_string2datum(gnutls_string * str);
+gnutls_datum_t _gnutls_string2datum(gnutls_string * str);
 
 int _gnutls_string_copy_str(gnutls_string * dest, const char *src);
 int _gnutls_string_append_str(gnutls_string *, const char *str);
diff --git a/lib/gnutls_ui.c b/lib/gnutls_ui.c
index d65011df4f..4956283eb4 100644
--- a/lib/gnutls_ui.c
+++ b/lib/gnutls_ui.c
@@ -37,7 +37,7 @@
 
 /**
   * gnutls_dh_set_prime_bits - Used to set the bits for a DH ciphersuite
-  * @session: is a &gnutls_session structure.
+  * @session: is a &gnutls_session_t structure.
   * @bits: is the number of bits
   *
   * This function sets the number of bits, for use in an 
@@ -51,7 +51,7 @@
   * handshake.
   *
   **/
-void gnutls_dh_set_prime_bits(gnutls_session session, unsigned int bits)
+void gnutls_dh_set_prime_bits(gnutls_session_t session, unsigned int bits)
 {
     session->internals.dh_prime_bits = bits;
 }
@@ -71,8 +71,8 @@ void gnutls_dh_set_prime_bits(gnutls_session session, unsigned int bits)
   * Returns a negative value in case of an error.
   *
   **/
-int gnutls_dh_get_group(gnutls_session session,
-			gnutls_datum * raw_gen, gnutls_datum * raw_prime)
+int gnutls_dh_get_group(gnutls_session_t session,
+			gnutls_datum_t * raw_gen, gnutls_datum_t * raw_prime)
 {
     dh_info_t *dh;
     int ret;
@@ -125,7 +125,7 @@ int gnutls_dh_get_group(gnutls_session session,
   * Returns a negative value in case of an error.
   *
   **/
-int gnutls_dh_get_pubkey(gnutls_session session, gnutls_datum * raw_key)
+int gnutls_dh_get_pubkey(gnutls_session_t session, gnutls_datum_t * raw_key)
 {
     dh_info_t *dh;
     anon_server_auth_info_t anon_info;
@@ -167,8 +167,8 @@ int gnutls_dh_get_pubkey(gnutls_session session, gnutls_datum * raw_key)
   * Returns a negative value in case of an error.
   *
   **/
-int gnutls_rsa_export_get_pubkey(gnutls_session session,
-				 gnutls_datum * exp, gnutls_datum * mod)
+int gnutls_rsa_export_get_pubkey(gnutls_session_t session,
+				 gnutls_datum_t * exp, gnutls_datum_t * mod)
 {
     cert_auth_info_t info;
     int ret;
@@ -209,7 +209,7 @@ int gnutls_rsa_export_get_pubkey(gnutls_session session,
   * Returns a negative value in case of an error.
   *
   **/
-int gnutls_dh_get_secret_bits(gnutls_session session)
+int gnutls_dh_get_secret_bits(gnutls_session_t session)
 {
     switch (gnutls_auth_get_type(session)) {
     case GNUTLS_CRD_ANON:{
@@ -245,7 +245,7 @@ int gnutls_dh_get_secret_bits(gnutls_session session)
   * Returns a negative value in case of an error.
   *
   **/
-int gnutls_dh_get_prime_bits(gnutls_session session)
+int gnutls_dh_get_prime_bits(gnutls_session_t session)
 {
     dh_info_t *dh;
 
@@ -287,7 +287,7 @@ int gnutls_dh_get_prime_bits(gnutls_session session)
   * Returns a negative value in case of an error.
   *
   **/
-int gnutls_rsa_export_get_modulus_bits(gnutls_session session)
+int gnutls_rsa_export_get_modulus_bits(gnutls_session_t session)
 {
     cert_auth_info_t info;
 
@@ -307,7 +307,7 @@ int gnutls_rsa_export_get_modulus_bits(gnutls_session session)
   * Returns a negative value in case of an error.
   *
   **/
-int gnutls_dh_get_peers_public_bits(gnutls_session session)
+int gnutls_dh_get_peers_public_bits(gnutls_session_t session)
 {
     dh_info_t *dh;
 
@@ -354,9 +354,9 @@ int gnutls_dh_get_peers_public_bits(gnutls_session session)
   * Returns NULL in case of an error, or if no certificate was used.
   *
   **/
-const gnutls_datum *gnutls_certificate_get_ours(gnutls_session session)
+const gnutls_datum_t *gnutls_certificate_get_ours(gnutls_session_t session)
 {
-    const gnutls_certificate_credentials cred;
+    const gnutls_certificate_credentials_t cred;
 
     CHECK_AUTH(GNUTLS_CRD_CERTIFICATE, NULL);
 
@@ -389,7 +389,7 @@ const gnutls_datum *gnutls_certificate_get_ours(gnutls_session session)
   * Returns NULL in case of an error, or if no certificate was sent.
   *
   **/
-const gnutls_datum *gnutls_certificate_get_peers(gnutls_session session,
+const gnutls_datum_t *gnutls_certificate_get_peers(gnutls_session_t session,
 						 unsigned int *list_size)
 {
     cert_auth_info_t info;
@@ -414,7 +414,7 @@ const gnutls_datum *gnutls_certificate_get_peers(gnutls_session session,
   * Returns a negative value in case of an error.
   *
   **/
-int gnutls_certificate_client_get_request_status(gnutls_session session)
+int gnutls_certificate_client_get_request_status(gnutls_session_t session)
 {
     cert_auth_info_t info;
 
@@ -446,8 +446,8 @@ int gnutls_certificate_client_get_request_status(gnutls_session session)
   * Returns a negative value in case of an error.
   *
   **/
-int gnutls_fingerprint(gnutls_digest_algorithm algo,
-		       const gnutls_datum * data, void *result,
+int gnutls_fingerprint(gnutls_digest_algorithm_t algo,
+		       const gnutls_datum_t * data, void *result,
 		       size_t * result_size)
 {
     GNUTLS_HASH_HANDLE td;
@@ -474,7 +474,7 @@ int gnutls_fingerprint(gnutls_digest_algorithm algo,
 
 /**
   * gnutls_anon_set_server_dh_params - This function will set the DH parameters for a server to use
-  * @res: is a gnutls_anon_server_credentials structure
+  * @res: is a gnutls_anon_server_credentials_t structure
   * @dh_params: is a structure that holds diffie hellman parameters.
   *
   * This function will set the diffie hellman parameters for an anonymous
@@ -482,15 +482,15 @@ int gnutls_fingerprint(gnutls_digest_algorithm algo,
   * cipher suites.
   *
   **/
-void gnutls_anon_set_server_dh_params(gnutls_anon_server_credentials res,
-				      gnutls_dh_params dh_params)
+void gnutls_anon_set_server_dh_params(gnutls_anon_server_credentials_t res,
+				      gnutls_dh_params_t dh_params)
 {
     res->dh_params = dh_params;
 }
 
 /**
   * gnutls_certificate_set_dh_params - This function will set the DH parameters for a server to use
-  * @res: is a gnutls_certificate_credentials structure
+  * @res: is a gnutls_certificate_credentials_t structure
   * @dh_params: is a structure that holds diffie hellman parameters.
   *
   * This function will set the diffie hellman parameters for a certificate
@@ -498,15 +498,15 @@ void gnutls_anon_set_server_dh_params(gnutls_anon_server_credentials res,
   * cipher suites.
   *
   **/
-void gnutls_certificate_set_dh_params(gnutls_certificate_credentials res,
-				      gnutls_dh_params dh_params)
+void gnutls_certificate_set_dh_params(gnutls_certificate_credentials_t res,
+				      gnutls_dh_params_t dh_params)
 {
     res->dh_params = dh_params;
 }
 
 /**
   * gnutls_certificate_set_params_function - This function will set the DH or RSA parameters callback
-  * @res: is a gnutls_certificate_credentials structure
+  * @res: is a gnutls_certificate_credentials_t structure
   * @func: is the function to be called
   *
   * This function will set a callback in order for the server to get the 
@@ -514,7 +514,7 @@ void gnutls_certificate_set_dh_params(gnutls_certificate_credentials res,
   * should return zero on success.
   *
   **/
-void gnutls_certificate_set_params_function(gnutls_certificate_credentials
+void gnutls_certificate_set_params_function(gnutls_certificate_credentials_t
 					    res,
 					    gnutls_params_function * func)
 {
@@ -523,7 +523,7 @@ void gnutls_certificate_set_params_function(gnutls_certificate_credentials
 
 /**
   * gnutls_anon_set_params_function - This function will set the DH parameters callback
-  * @res: is a gnutls_certificate_credentials structure
+  * @res: is a gnutls_certificate_credentials_t structure
   * @func: is the function to be called
   *
   * This function will set a callback in order for the server to get the 
@@ -531,7 +531,7 @@ void gnutls_certificate_set_params_function(gnutls_certificate_credentials
   * return zero on success.
   *
   **/
-void gnutls_anon_set_params_function(gnutls_anon_server_credentials res,
+void gnutls_anon_set_params_function(gnutls_anon_server_credentials_t res,
 				     gnutls_params_function * func)
 {
     res->params_func = func;
@@ -540,14 +540,14 @@ void gnutls_anon_set_params_function(gnutls_anon_server_credentials res,
 
 /**
   * gnutls_certificate_set_verify_flags - This function will set the flags to be used at certificate verification
-  * @res: is a gnutls_certificate_credentials structure
+  * @res: is a gnutls_certificate_credentials_t structure
   * @flags: are the flagsis a structure that holds diffie hellman parameters.
   *
   * This function will set the flags to be used at verification of the certificates.
   * Flags must be OR of the gnutls_certificate_verify_flags enumerations.
   *
   **/
-void gnutls_certificate_set_verify_flags(gnutls_certificate_credentials
+void gnutls_certificate_set_verify_flags(gnutls_certificate_credentials_t
 					 res, unsigned int flags)
 {
     res->verify_flags = flags;
@@ -555,7 +555,7 @@ void gnutls_certificate_set_verify_flags(gnutls_certificate_credentials
 
 /**
   * gnutls_certificate_set_rsa_export_params - This function will set the RSA parameters for a server to use
-  * @res: is a gnutls_certificate_credentials structure
+  * @res: is a gnutls_certificate_credentials_t structure
   * @rsa_params: is a structure that holds temporary RSA parameters.
   *
   * This function will set the temporary RSA parameters for a certificate
@@ -564,8 +564,8 @@ void gnutls_certificate_set_verify_flags(gnutls_certificate_credentials
   *
   **/
 void
-gnutls_certificate_set_rsa_export_params(gnutls_certificate_credentials
-					 res, gnutls_rsa_params rsa_params)
+gnutls_certificate_set_rsa_export_params(gnutls_certificate_credentials_t
+					 res, gnutls_rsa_params_t rsa_params)
 {
     res->rsa_params = rsa_params;
 }
diff --git a/lib/gnutls_ui.h b/lib/gnutls_ui.h
index 29f6baa8b3..455625870c 100644
--- a/lib/gnutls_ui.h
+++ b/lib/gnutls_ui.h
@@ -1,128 +1,110 @@
 #ifndef GNUTLS_UI_H
 # define GNUTLS_UI_H
 
-typedef enum gnutls_x509_subject_alt_name {
+typedef enum gnutls_x509_subject_alt_name_t {
     GNUTLS_SAN_DNSNAME = 1, GNUTLS_SAN_RFC822NAME,
     GNUTLS_SAN_URI, GNUTLS_SAN_IPADDRESS
-} gnutls_x509_subject_alt_name;
+} gnutls_x509_subject_alt_name_t;
 
 # ifdef LIBGNUTLS_VERSION	/* These are defined only in gnutls.h */
 
 struct gnutls_openpgp_key_int;
-typedef struct gnutls_openpgp_key_int *gnutls_openpgp_key;
+typedef struct gnutls_openpgp_key_int *gnutls_openpgp_key_t;
 
 struct gnutls_openpgp_privkey_int;
-typedef struct gnutls_openpgp_privkey_int *gnutls_openpgp_privkey;
+typedef struct gnutls_openpgp_privkey_int *gnutls_openpgp_privkey_t;
 
 typedef struct gnutls_retr_st {
-    gnutls_certificate_type type;
+    gnutls_certificate_type_t type;
     union cert {
-	gnutls_x509_crt *x509;
-	gnutls_openpgp_key pgp;
+	gnutls_x509_crt_t *x509;
+	gnutls_openpgp_key_t pgp;
     } cert;
     unsigned int ncerts;	/* one for pgp keys */
 
     union key {
-	gnutls_x509_privkey x509;
-	gnutls_openpgp_privkey pgp;
+	gnutls_x509_privkey_t x509;
+	gnutls_openpgp_privkey_t pgp;
     } key;
 
     unsigned int deinit_all;	/* if non zero all keys will be deinited */
 } gnutls_retr_st;
 
-typedef int gnutls_certificate_client_retrieve_function(gnutls_session,
-							const gnutls_datum
-							* req_ca_rdn,
-							int nreqs,
-							const
-							gnutls_pk_algorithm
-							* pk_algos,
-							int
-							pk_algos_length,
-							gnutls_retr_st *);
-typedef int gnutls_certificate_server_retrieve_function(gnutls_session,
-							gnutls_retr_st *);
+typedef int gnutls_certificate_client_retrieve_function(gnutls_session_t,
+    const gnutls_datum_t* req_ca_rdn, int nreqs,
+    const gnutls_pk_algorithm_t* pk_algos, int pk_algos_length, gnutls_retr_st *);
+typedef int gnutls_certificate_server_retrieve_function(gnutls_session_t,
+    gnutls_retr_st *);
 
 
 /* Functions that allow auth_info_t structures handling
  */
 
-gnutls_credentials_type gnutls_auth_get_type(gnutls_session session);
-gnutls_credentials_type gnutls_auth_server_get_type(gnutls_session
-						    session);
-gnutls_credentials_type gnutls_auth_client_get_type(gnutls_session
-						    session);
+gnutls_credentials_type_t gnutls_auth_get_type(gnutls_session_t session);
+gnutls_credentials_type_t gnutls_auth_server_get_type(gnutls_session_t session);
+gnutls_credentials_type_t gnutls_auth_client_get_type(gnutls_session_t session);
 
 /* DH */
 
-void gnutls_dh_set_prime_bits(gnutls_session session, int bits);
-int gnutls_dh_get_secret_bits(gnutls_session);
-int gnutls_dh_get_peers_public_bits(gnutls_session);
-int gnutls_dh_get_prime_bits(gnutls_session);
+void gnutls_dh_set_prime_bits(gnutls_session_t session, int bits);
+int gnutls_dh_get_secret_bits(gnutls_session_t);
+int gnutls_dh_get_peers_public_bits(gnutls_session_t);
+int gnutls_dh_get_prime_bits(gnutls_session_t);
 
-int gnutls_dh_get_group(gnutls_session, gnutls_datum * gen,
-			gnutls_datum * prime);
-int gnutls_dh_get_pubkey(gnutls_session, gnutls_datum * pub);
+int gnutls_dh_get_group(gnutls_session_t, gnutls_datum_t * gen,
+    gnutls_datum_t * prime);
+int gnutls_dh_get_pubkey(gnutls_session_t, gnutls_datum_t * pub);
 
 /* RSA */
-int gnutls_rsa_export_get_pubkey(gnutls_session session,
-				 gnutls_datum * exp, gnutls_datum * mod);
-int gnutls_rsa_export_get_modulus_bits(gnutls_session session);
+int gnutls_rsa_export_get_pubkey(gnutls_session_t session,
+				 gnutls_datum_t * exp, gnutls_datum_t * mod);
+int gnutls_rsa_export_get_modulus_bits(gnutls_session_t session);
 
 /* X509PKI */
 
 /* These are set on the credentials structure.
  */
 void
-gnutls_certificate_client_set_retrieve_function
-(gnutls_certificate_client_credentials,
-gnutls_certificate_client_retrieve_function *);
-void
-gnutls_certificate_server_set_retrieve_function
-(gnutls_certificate_server_credentials,
-gnutls_certificate_server_retrieve_function *);
+gnutls_certificate_client_set_retrieve_function( gnutls_certificate_credentials_t,
+    gnutls_certificate_client_retrieve_function *);
+void gnutls_certificate_server_set_retrieve_function(gnutls_certificate_credentials_t,
+    gnutls_certificate_server_retrieve_function *);
 
-void gnutls_certificate_server_set_request(gnutls_session,
-					   gnutls_certificate_request);
+void gnutls_certificate_server_set_request(gnutls_session_t,
+    gnutls_certificate_request_t);
 
 /* X.509 certificate handling functions 
  */
 
-int gnutls_pkcs3_extract_dh_params(const gnutls_datum * params,
-				   gnutls_x509_crt_fmt format,
-				   gnutls_datum * prime,
-				   gnutls_datum * generator,
-				   int *prime_bits);
-int gnutls_pkcs3_export_dh_params(const gnutls_datum * prime,
-				  const gnutls_datum * generator,
-				  gnutls_x509_crt_fmt format,
-				  unsigned char *params_data,
-				  int *params_data_size);
+int gnutls_pkcs3_extract_dh_params(const gnutls_datum_t * params,
+    gnutls_x509_crt_fmt_t format,
+    gnutls_datum_t * prime, gnutls_datum_t * generator, int *prime_bits);
+int gnutls_pkcs3_export_dh_params(const gnutls_datum_t * prime,
+    const gnutls_datum_t * generator, gnutls_x509_crt_fmt_t format,
+    unsigned char *params_data, int *params_data_size);
 
 /* get data from the session 
  */
-const gnutls_datum *gnutls_certificate_get_peers(gnutls_session,
-						 unsigned int *list_size);
-const gnutls_datum *gnutls_certificate_get_ours(gnutls_session session);
+const gnutls_datum_t *gnutls_certificate_get_peers(gnutls_session_t,
+    unsigned int *list_size);
+const gnutls_datum_t *gnutls_certificate_get_ours(gnutls_session_t session);
 
-time_t gnutls_certificate_activation_time_peers(gnutls_session session);
-time_t gnutls_certificate_expiration_time_peers(gnutls_session session);
+time_t gnutls_certificate_activation_time_peers(gnutls_session_t session);
+time_t gnutls_certificate_expiration_time_peers(gnutls_session_t session);
 
-int gnutls_certificate_client_get_request_status(gnutls_session);
-int gnutls_certificate_verify_peers(gnutls_session);
+int gnutls_certificate_client_get_request_status(gnutls_session_t);
+int gnutls_certificate_verify_peers(gnutls_session_t);
 
-int gnutls_pem_base64_encode(const char *header, const gnutls_datum * data,
-			     char *result, size_t * result_size);
+int gnutls_pem_base64_encode(const char *header, const gnutls_datum_t * data,
+    char *result, size_t * result_size);
 int gnutls_pem_base64_decode(const char *header,
-			     const gnutls_datum * b64_data,
-			     unsigned char *result, size_t * result_size);
+    const gnutls_datum_t * b64_data,
+    unsigned char *result, size_t * result_size);
 
 int gnutls_pem_base64_encode_alloc(const char *header,
-				   const gnutls_datum * data,
-				   gnutls_datum * result);
+    const gnutls_datum_t * data, gnutls_datum_t * result);
 int gnutls_pem_base64_decode_alloc(const char *header,
-				   const gnutls_datum * b64_data,
-				   gnutls_datum * result);
+    const gnutls_datum_t * b64_data, gnutls_datum_t * result);
 
 /* key_usage will be an OR of the following values:
  */
@@ -141,21 +123,21 @@ int gnutls_pem_base64_decode_alloc(const char *header,
 #define GNUTLS_KEY_DECIPHER_ONLY                32768
 
 typedef struct gnutls_params_st {
-    gnutls_params_type type;
+    gnutls_params_type_t type;
     union params {
-	gnutls_dh_params dh;
-	gnutls_rsa_params rsa_export;
+	gnutls_dh_params_t dh;
+	gnutls_rsa_params_t rsa_export;
     } params;
     int deinit;
 } gnutls_params_st;
 
-typedef int gnutls_params_function(gnutls_session, gnutls_params_type,
+typedef int gnutls_params_function(gnutls_session_t, gnutls_params_type_t,
 				   gnutls_params_st *);
 
-void gnutls_certificate_set_params_function(gnutls_certificate_credentials
+void gnutls_certificate_set_params_function(gnutls_certificate_credentials_t
 					    res,
 					    gnutls_params_function * func);
-void gnutls_anon_set_params_function(gnutls_certificate_credentials res,
+void gnutls_anon_set_params_function(gnutls_certificate_credentials_t res,
 				     gnutls_params_function * func);
 
 
diff --git a/lib/gnutls_v2_compat.c b/lib/gnutls_v2_compat.c
index 0cda405a00..983c631475 100644
--- a/lib/gnutls_v2_compat.c
+++ b/lib/gnutls_v2_compat.c
@@ -41,7 +41,7 @@
 #include "gnutls_auth_int.h"
 
 /* This selects the best supported ciphersuite from the ones provided */
-static int _gnutls_handshake_select_v2_suite(gnutls_session session,
+static int _gnutls_handshake_select_v2_suite(gnutls_session_t session,
 					     opaque * data, int datalen)
 {
     int i, j, ret;
@@ -82,20 +82,20 @@ static int _gnutls_handshake_select_v2_suite(gnutls_session session,
 /* Read a v2 client hello. Some browsers still use that beast!
  * However they set their version to 3.0 or 3.1.
  */
-int _gnutls_read_client_hello_v2(gnutls_session session, opaque * data,
+int _gnutls_read_client_hello_v2(gnutls_session_t session, opaque * data,
 				 int datalen)
 {
     uint16 session_id_len = 0;
     int pos = 0;
     int ret = 0;
     uint16 sizeOfSuites;
-    gnutls_protocol_version version;
+    gnutls_protocol_t version;
     opaque random[TLS_RANDOM_SIZE];
     int len = datalen;
     int err;
     uint16 challenge;
     opaque session_id[TLS_MAX_SESSION_ID_SIZE];
-    gnutls_protocol_version ver;
+    gnutls_protocol_t ver;
 
     /* we only want to get here once - only in client hello */
     session->internals.v2_hello = 0;
diff --git a/lib/gnutls_v2_compat.h b/lib/gnutls_v2_compat.h
index ce935d5782..1573e7549e 100644
--- a/lib/gnutls_v2_compat.h
+++ b/lib/gnutls_v2_compat.h
@@ -1,2 +1,2 @@
-int _gnutls_read_client_hello_v2(gnutls_session session, opaque * data,
+int _gnutls_read_client_hello_v2(gnutls_session_t session, opaque * data,
 				 int datalen);
diff --git a/lib/gnutls_x509.c b/lib/gnutls_x509.c
index 6e6ca037c5..4c4dd71a2d 100644
--- a/lib/gnutls_x509.c
+++ b/lib/gnutls_x509.c
@@ -64,17 +64,17 @@
   * @session: is a gnutls session
   *
   * This function will try to verify the peer's certificate and return its status (TRUSTED, REVOKED etc.). 
-  * The return value (status) should be one of the gnutls_certificate_status enumerated elements.
+  * The return value (status) should be one of the gnutls_certificate_status_t enumerated elements.
   * However you must also check the peer's name in order to check if the verified certificate belongs to the 
   * actual peer. Returns a negative error code in case of an error, or GNUTLS_E_NO_CERTIFICATE_FOUND if no certificate was sent.
   *
   -*/
-int _gnutls_x509_cert_verify_peers(gnutls_session session)
+int _gnutls_x509_cert_verify_peers(gnutls_session_t session)
 {
     cert_auth_info_t info;
-    const gnutls_certificate_credentials cred;
+    const gnutls_certificate_credentials_t cred;
     unsigned int verify;
-    gnutls_x509_crt *peer_certificate_list;
+    gnutls_x509_crt_t *peer_certificate_list;
     int peer_certificate_list_size, i, x, ret;
 
     CHECK_AUTH(GNUTLS_CRD_CERTIFICATE, GNUTLS_E_INVALID_REQUEST);
@@ -101,7 +101,7 @@ int _gnutls_x509_cert_verify_peers(gnutls_session session)
     peer_certificate_list =
 	gnutls_calloc(1,
 		      peer_certificate_list_size *
-		      sizeof(gnutls_x509_crt));
+		      sizeof(gnutls_x509_crt_t));
     if (peer_certificate_list == NULL) {
 	gnutls_assert();
 	return GNUTLS_E_MEMORY_ERROR;
@@ -153,10 +153,10 @@ int _gnutls_x509_cert_verify_peers(gnutls_session session)
 /* returns error if the certificate has different algorithm than
  * the given key parameters.
  */
-static int _gnutls_check_key_cert_match(gnutls_certificate_credentials res)
+static int _gnutls_check_key_cert_match(gnutls_certificate_credentials_t res)
 {
-    gnutls_datum cid;
-    gnutls_datum kid;
+    gnutls_datum_t cid;
+    gnutls_datum_t kid;
     uint pk = res->cert_list[res->ncerts - 1][0].subject_pk_algorithm;
 
     if (res->pkey[res->ncerts - 1].pk_algorithm != pk) {
@@ -212,7 +212,7 @@ static int _gnutls_check_key_cert_match(gnutls_certificate_credentials res)
  * returns the number of certificates parsed (1)
  */
 static int parse_crt_mem(gnutls_cert ** cert_list, uint * ncerts,
-			 gnutls_x509_crt cert)
+			 gnutls_x509_crt_t cert)
 {
     int i;
     int ret;
@@ -246,8 +246,8 @@ static int parse_crt_mem(gnutls_cert ** cert_list, uint * ncerts,
 static int parse_der_cert_mem(gnutls_cert ** cert_list, uint * ncerts,
 			      const void *input_cert, int input_cert_size)
 {
-    gnutls_datum tmp;
-    gnutls_x509_crt cert;
+    gnutls_datum_t tmp;
+    gnutls_x509_crt_t cert;
     int ret;
 
     ret = gnutls_x509_crt_init(&cert);
@@ -285,11 +285,11 @@ static int parse_pkcs7_cert_mem(gnutls_cert ** cert_list, uint * ncerts, const
 {
 #ifdef ENABLE_PKI
     int i, j, count;
-    gnutls_datum tmp, tmp2;
+    gnutls_datum_t tmp, tmp2;
     int ret;
     opaque *pcert = NULL;
     size_t pcert_size;
-    gnutls_pkcs7 pkcs7;
+    gnutls_pkcs7_t pkcs7;
 
     ret = gnutls_pkcs7_init(&pkcs7);
     if (ret < 0) {
@@ -400,7 +400,7 @@ static int parse_pem_cert_mem(gnutls_cert ** cert_list, uint * ncerts,
     int size, siz2, i;
     const char *ptr;
     opaque *ptr2;
-    gnutls_datum tmp;
+    gnutls_datum_t tmp;
     int ret, count;
 
 #ifdef ENABLE_PKI
@@ -490,8 +490,8 @@ static int parse_pem_cert_mem(gnutls_cert ** cert_list, uint * ncerts,
 /* Reads a DER or PEM certificate from memory
  */
 static
-int read_cert_mem(gnutls_certificate_credentials res, const void *cert,
-		  int cert_size, gnutls_x509_crt_fmt type)
+int read_cert_mem(gnutls_certificate_credentials_t res, const void *cert,
+		  int cert_size, gnutls_x509_crt_fmt_t type)
 {
     int ret;
 
@@ -538,7 +538,7 @@ int read_cert_mem(gnutls_certificate_credentials res, const void *cert,
 
 
 int _gnutls_x509_privkey_to_gkey(gnutls_privkey * dest,
-				 gnutls_x509_privkey src)
+				 gnutls_x509_privkey_t src)
 {
     int i, ret;
 
@@ -578,10 +578,10 @@ void _gnutls_gkey_deinit(gnutls_privkey * key)
 }
 
 int _gnutls_x509_raw_privkey_to_gkey(gnutls_privkey * privkey,
-				     const gnutls_datum * raw_key,
-				     gnutls_x509_crt_fmt type)
+				     const gnutls_datum_t * raw_key,
+				     gnutls_x509_crt_fmt_t type)
 {
-    gnutls_x509_privkey tmpkey;
+    gnutls_x509_privkey_t tmpkey;
     int ret;
 
     ret = gnutls_x509_privkey_init(&tmpkey);
@@ -613,12 +613,12 @@ int _gnutls_x509_raw_privkey_to_gkey(gnutls_privkey * privkey,
  * 2002-01-26: Added ability to read DSA keys.
  * type indicates the certificate format.
  */
-static int read_key_mem(gnutls_certificate_credentials res,
+static int read_key_mem(gnutls_certificate_credentials_t res,
 			const void *key, int key_size,
-			gnutls_x509_crt_fmt type)
+			gnutls_x509_crt_fmt_t type)
 {
     int ret;
-    gnutls_datum tmp;
+    gnutls_datum_t tmp;
 
     /* allocate space for the pkey list
      */
@@ -752,8 +752,8 @@ strfile _gnutls_file_to_str(const char *file)
 
 /* Reads a certificate file
  */
-static int read_cert_file(gnutls_certificate_credentials res,
-			  const char *certfile, gnutls_x509_crt_fmt type)
+static int read_cert_file(gnutls_certificate_credentials_t res,
+			  const char *certfile, gnutls_x509_crt_fmt_t type)
 {
     int ret;
     strfile x;
@@ -776,8 +776,8 @@ static int read_cert_file(gnutls_certificate_credentials res,
 /* Reads PKCS-1 RSA private key file or a DSA file (in the format openssl
  * stores it).
  */
-static int read_key_file(gnutls_certificate_credentials res,
-			 const char *keyfile, gnutls_x509_crt_fmt type)
+static int read_key_file(gnutls_certificate_credentials_t res,
+			 const char *keyfile, gnutls_x509_crt_fmt_t type)
 {
     int ret;
     strfile x;
@@ -795,14 +795,14 @@ static int read_key_file(gnutls_certificate_credentials res,
 }
 
 /**
-  * gnutls_certificate_set_x509_key_mem - Used to set keys in a gnutls_certificate_credentials structure
-  * @res: is an &gnutls_certificate_credentials structure.
+  * gnutls_certificate_set_x509_key_mem - Used to set keys in a gnutls_certificate_credentials_t structure
+  * @res: is an &gnutls_certificate_credentials_t structure.
   * @cert: contains a certificate list (path) for the specified private key
   * @key: is the private key
   * @type: is PEM or DER
   *
   * This function sets a certificate/private key pair in the 
-  * gnutls_certificate_credentials structure. This function may be called
+  * gnutls_certificate_credentials_t structure. This function may be called
   * more than once (in case multiple keys/certificates exist for the
   * server).
   *
@@ -820,10 +820,10 @@ static int read_key_file(gnutls_certificate_credentials res,
   * then the strings that hold their values must be null terminated.
   *
   **/
-int gnutls_certificate_set_x509_key_mem(gnutls_certificate_credentials res,
-					const gnutls_datum * cert,
-					const gnutls_datum * key,
-					gnutls_x509_crt_fmt type)
+int gnutls_certificate_set_x509_key_mem(gnutls_certificate_credentials_t res,
+					const gnutls_datum_t * cert,
+					const gnutls_datum_t * key,
+					gnutls_x509_crt_fmt_t type)
 {
     int ret;
 
@@ -846,22 +846,22 @@ int gnutls_certificate_set_x509_key_mem(gnutls_certificate_credentials res,
 }
 
 /**
-  * gnutls_certificate_set_x509_key - Used to set keys in a gnutls_certificate_credentials structure
-  * @res: is an &gnutls_certificate_credentials structure.
+  * gnutls_certificate_set_x509_key - Used to set keys in a gnutls_certificate_credentials_t structure
+  * @res: is an &gnutls_certificate_credentials_t structure.
   * @cert_list: contains a certificate list (path) for the specified private key
   * @cert_list_size: holds the size of the certificate list
-  * @key: is a gnutls_x509_privkey key
+  * @key: is a gnutls_x509_privkey_t key
   *
   * This function sets a certificate/private key pair in the 
-  * gnutls_certificate_credentials structure. This function may be called
+  * gnutls_certificate_credentials_t structure. This function may be called
   * more than once (in case multiple keys/certificates exist for the
   * server).
   *
   **/
-int gnutls_certificate_set_x509_key(gnutls_certificate_credentials res,
-				    gnutls_x509_crt * cert_list,
+int gnutls_certificate_set_x509_key(gnutls_certificate_credentials_t res,
+				    gnutls_x509_crt_t * cert_list,
 				    int cert_list_size,
-				    gnutls_x509_privkey key)
+				    gnutls_x509_privkey_t key)
 {
     int ret, i;
 
@@ -924,15 +924,15 @@ int gnutls_certificate_set_x509_key(gnutls_certificate_credentials res,
 }
 
 /**
-  * gnutls_certificate_set_x509_key_file - Used to set keys in a gnutls_certificate_credentials structure
-  * @res: is an &gnutls_certificate_credentials structure.
+  * gnutls_certificate_set_x509_key_file - Used to set keys in a gnutls_certificate_credentials_t structure
+  * @res: is an &gnutls_certificate_credentials_t structure.
   * @CERTFILE: is a file that containing the certificate list (path) for
   * the specified private key, in PKCS7 format, or a list of certificates
   * @KEYFILE: is a file that contains the private key
   * @type: is PEM or DER
   *
   * This function sets a certificate/private key pair in the 
-  * gnutls_certificate_credentials structure. This function may be called
+  * gnutls_certificate_credentials_t structure. This function may be called
   * more than once (in case multiple keys/certificates exist for the
   * server).
   *
@@ -940,10 +940,10 @@ int gnutls_certificate_set_x509_key(gnutls_certificate_credentials res,
   * this function.
   *
   **/
-int gnutls_certificate_set_x509_key_file(gnutls_certificate_credentials
+int gnutls_certificate_set_x509_key_file(gnutls_certificate_credentials_t
 					 res, const char *CERTFILE,
 					 const char *KEYFILE,
-					 gnutls_x509_crt_fmt type)
+					 gnutls_x509_crt_fmt_t type)
 {
     int ret;
 
@@ -965,10 +965,10 @@ int gnutls_certificate_set_x509_key_file(gnutls_certificate_credentials
     return 0;
 }
 
-static int generate_rdn_seq(gnutls_certificate_credentials res)
+static int generate_rdn_seq(gnutls_certificate_credentials_t res)
 {
-    gnutls_datum tmp;
-    gnutls_datum _tmp;
+    gnutls_datum_t tmp;
+    gnutls_datum_t _tmp;
     int ret;
     uint size, i;
     opaque *pdata;
@@ -1030,11 +1030,11 @@ static int generate_rdn_seq(gnutls_certificate_credentials res)
 
 
 
-/* Returns 0 if it's ok to use the gnutls_kx_algorithm with this 
+/* Returns 0 if it's ok to use the gnutls_kx_algorithm_t with this 
  * certificate (uses the KeyUsage field). 
  */
 int _gnutls_check_key_usage(const gnutls_cert * cert,
-			    gnutls_kx_algorithm alg)
+			    gnutls_kx_algorithm_t alg)
 {
     unsigned int keyUsage = 0;
     int encipher_type;
@@ -1081,12 +1081,12 @@ int _gnutls_check_key_usage(const gnutls_cert * cert,
 
 
 
-static int parse_pem_ca_mem(gnutls_x509_crt ** cert_list, uint * ncerts,
+static int parse_pem_ca_mem(gnutls_x509_crt_t ** cert_list, uint * ncerts,
 			    const opaque * input_cert, int input_cert_size)
 {
     int i, size;
     const opaque *ptr;
-    gnutls_datum tmp;
+    gnutls_datum_t tmp;
     int ret, count;
 
     /* move to the certificate
@@ -1107,10 +1107,10 @@ static int parse_pem_ca_mem(gnutls_x509_crt ** cert_list, uint * ncerts,
     do {
 
 	*cert_list =
-	    (gnutls_x509_crt *) gnutls_realloc_fast(*cert_list,
+	    (gnutls_x509_crt_t *) gnutls_realloc_fast(*cert_list,
 						    i *
 						    sizeof
-						    (gnutls_x509_crt));
+						    (gnutls_x509_crt_t));
 
 	if (*cert_list == NULL) {
 	    gnutls_assert();
@@ -1167,19 +1167,19 @@ static int parse_pem_ca_mem(gnutls_x509_crt ** cert_list, uint * ncerts,
  * a gnutls_cert structure. This is only called if PKCS7 read fails.
  * returns the number of certificates parsed (1)
  */
-static int parse_der_ca_mem(gnutls_x509_crt ** cert_list, uint * ncerts,
+static int parse_der_ca_mem(gnutls_x509_crt_t ** cert_list, uint * ncerts,
 			    const void *input_cert, int input_cert_size)
 {
     int i;
-    gnutls_datum tmp;
+    gnutls_datum_t tmp;
     int ret;
 
     i = *ncerts + 1;
 
     *cert_list =
-	(gnutls_x509_crt *) gnutls_realloc_fast(*cert_list,
+	(gnutls_x509_crt_t *) gnutls_realloc_fast(*cert_list,
 						i *
-						sizeof(gnutls_x509_crt));
+						sizeof(gnutls_x509_crt_t));
 
     if (*cert_list == NULL) {
 	gnutls_assert();
@@ -1209,8 +1209,8 @@ static int parse_der_ca_mem(gnutls_x509_crt ** cert_list, uint * ncerts,
 }
 
 /**
-  * gnutls_certificate_set_x509_trust_mem - Used to add trusted CAs in a gnutls_certificate_credentials structure
-  * @res: is an &gnutls_certificate_credentials structure.
+  * gnutls_certificate_set_x509_trust_mem - Used to add trusted CAs in a gnutls_certificate_credentials_t structure
+  * @res: is an &gnutls_certificate_credentials_t structure.
   * @ca: is a list of trusted CAs or a DER certificate
   * @type: is DER or PEM
   *
@@ -1228,9 +1228,9 @@ static int parse_der_ca_mem(gnutls_x509_crt ** cert_list, uint * ncerts,
   * value on error.
   *
   **/
-int gnutls_certificate_set_x509_trust_mem(gnutls_certificate_credentials
-					  res, const gnutls_datum * ca,
-					  gnutls_x509_crt_fmt type)
+int gnutls_certificate_set_x509_trust_mem(gnutls_certificate_credentials_t
+					  res, const gnutls_datum_t * ca,
+					  gnutls_x509_crt_fmt_t type)
 {
     int ret, ret2;
 
@@ -1248,8 +1248,8 @@ int gnutls_certificate_set_x509_trust_mem(gnutls_certificate_credentials
 }
 
 /**
-  * gnutls_certificate_set_x509_trust - Used to add trusted CAs in a gnutls_certificate_credentials structure
-  * @res: is an &gnutls_certificate_credentials structure.
+  * gnutls_certificate_set_x509_trust - Used to add trusted CAs in a gnutls_certificate_credentials_t structure
+  * @res: is an &gnutls_certificate_credentials_t structure.
   * @ca_list: is a list of trusted CAs
   * @ca_list_size: holds the size of the CA list
   *
@@ -1266,8 +1266,8 @@ int gnutls_certificate_set_x509_trust_mem(gnutls_certificate_credentials
   * Returns 0 on success.
   *
   **/
-int gnutls_certificate_set_x509_trust(gnutls_certificate_credentials res,
-				      gnutls_x509_crt * ca_list,
+int gnutls_certificate_set_x509_trust(gnutls_certificate_credentials_t res,
+				      gnutls_x509_crt_t * ca_list,
 				      int ca_list_size)
 {
     int ret, i, ret2;
@@ -1275,7 +1275,7 @@ int gnutls_certificate_set_x509_trust(gnutls_certificate_credentials res,
     res->x509_ca_list = gnutls_realloc_fast(res->x509_ca_list,
 					    (ca_list_size +
 					     res->x509_ncas) *
-					    sizeof(gnutls_x509_crt));
+					    sizeof(gnutls_x509_crt_t));
     if (res->x509_ca_list == NULL) {
 	gnutls_assert();
 	return GNUTLS_E_MEMORY_ERROR;
@@ -1298,8 +1298,8 @@ int gnutls_certificate_set_x509_trust(gnutls_certificate_credentials res,
 }
 
 /**
-  * gnutls_certificate_set_x509_trust_file - Used to add trusted CAs in a gnutls_certificate_credentials structure
-  * @res: is an &gnutls_certificate_credentials structure.
+  * gnutls_certificate_set_x509_trust_file - Used to add trusted CAs in a gnutls_certificate_credentials_t structure
+  * @res: is an &gnutls_certificate_credentials_t structure.
   * @cafile: is a file containing the list of trusted CAs (DER or PEM list)
   * @type: is PEM or DER
   *
@@ -1317,9 +1317,9 @@ int gnutls_certificate_set_x509_trust(gnutls_certificate_credentials res,
   * value on error.
   *
   **/
-int gnutls_certificate_set_x509_trust_file(gnutls_certificate_credentials
+int gnutls_certificate_set_x509_trust_file(gnutls_certificate_credentials_t
 					   res, const char *cafile,
-					   gnutls_x509_crt_fmt type)
+					   gnutls_x509_crt_fmt_t type)
 {
     int ret, ret2;
     strfile x;
@@ -1352,12 +1352,12 @@ int gnutls_certificate_set_x509_trust_file(gnutls_certificate_credentials
 
 #ifdef ENABLE_PKI
 
-static int parse_pem_crl_mem(gnutls_x509_crl ** crl_list, uint * ncrls,
+static int parse_pem_crl_mem(gnutls_x509_crl_t ** crl_list, uint * ncrls,
 			     const opaque * input_crl, int input_crl_size)
 {
     int size, i;
     const opaque *ptr;
-    gnutls_datum tmp;
+    gnutls_datum_t tmp;
     int ret, count;
 
     /* move to the certificate
@@ -1376,10 +1376,10 @@ static int parse_pem_crl_mem(gnutls_x509_crl ** crl_list, uint * ncrls,
     do {
 
 	*crl_list =
-	    (gnutls_x509_crl *) gnutls_realloc_fast(*crl_list,
+	    (gnutls_x509_crl_t *) gnutls_realloc_fast(*crl_list,
 						    i *
 						    sizeof
-						    (gnutls_x509_crl));
+						    (gnutls_x509_crl_t));
 
 	if (*crl_list == NULL) {
 	    gnutls_assert();
@@ -1429,19 +1429,19 @@ static int parse_pem_crl_mem(gnutls_x509_crl ** crl_list, uint * ncrls,
  * a gnutls_cert structure. This is only called if PKCS7 read fails.
  * returns the number of certificates parsed (1)
  */
-static int parse_der_crl_mem(gnutls_x509_crl ** crl_list, uint * ncrls,
+static int parse_der_crl_mem(gnutls_x509_crl_t ** crl_list, uint * ncrls,
 			     const void *input_crl, int input_crl_size)
 {
     int i;
-    gnutls_datum tmp;
+    gnutls_datum_t tmp;
     int ret;
 
     i = *ncrls + 1;
 
     *crl_list =
-	(gnutls_x509_crl *) gnutls_realloc_fast(*crl_list,
+	(gnutls_x509_crl_t *) gnutls_realloc_fast(*crl_list,
 						i *
-						sizeof(gnutls_x509_crl));
+						sizeof(gnutls_x509_crl_t));
 
     if (*crl_list == NULL) {
 	gnutls_assert();
@@ -1474,8 +1474,8 @@ static int parse_der_crl_mem(gnutls_x509_crl ** crl_list, uint * ncrls,
 /* Reads a DER or PEM CRL from memory
  */
 static
-int read_crl_mem(gnutls_certificate_credentials res, const void *crl,
-		 int crl_size, gnutls_x509_crt_fmt type)
+int read_crl_mem(gnutls_certificate_credentials_t res, const void *crl,
+		 int crl_size, gnutls_x509_crt_fmt_t type)
 {
     int ret;
 
@@ -1484,7 +1484,7 @@ int read_crl_mem(gnutls_certificate_credentials res, const void *crl,
     res->x509_crl_list = gnutls_realloc_fast(res->x509_crl_list,
 					     (1 +
 					      res->x509_ncrls) *
-					     sizeof(gnutls_x509_crl));
+					     sizeof(gnutls_x509_crl_t));
     if (res->x509_crl_list == NULL) {
 	gnutls_assert();
 	return GNUTLS_E_MEMORY_ERROR;
@@ -1506,8 +1506,8 @@ int read_crl_mem(gnutls_certificate_credentials res, const void *crl,
 }
 
 /**
-  * gnutls_certificate_set_x509_crl_mem - Used to add CRLs in a gnutls_certificate_credentials structure
-  * @res: is an &gnutls_certificate_credentials structure.
+  * gnutls_certificate_set_x509_crl_mem - Used to add CRLs in a gnutls_certificate_credentials_t structure
+  * @res: is an &gnutls_certificate_credentials_t structure.
   * @CRL: is a list of trusted CRLs. They should have been verified before.
   * @type: is DER or PEM
   *
@@ -1521,9 +1521,9 @@ int read_crl_mem(gnutls_certificate_credentials res, const void *crl,
   * on error. 
   *
   **/
-int gnutls_certificate_set_x509_crl_mem(gnutls_certificate_credentials res,
-					const gnutls_datum * CRL,
-					gnutls_x509_crt_fmt type)
+int gnutls_certificate_set_x509_crl_mem(gnutls_certificate_credentials_t res,
+					const gnutls_datum_t * CRL,
+					gnutls_x509_crt_fmt_t type)
 {
     int ret;
 
@@ -1534,8 +1534,8 @@ int gnutls_certificate_set_x509_crl_mem(gnutls_certificate_credentials res,
 }
 
 /**
-  * gnutls_certificate_set_x509_crl - Used to add CRLs in a gnutls_certificate_credentials structure
-  * @res: is an &gnutls_certificate_credentials structure.
+  * gnutls_certificate_set_x509_crl - Used to add CRLs in a gnutls_certificate_credentials_t structure
+  * @res: is an &gnutls_certificate_credentials_t structure.
   * @crl_list: is a list of trusted CRLs. They should have been verified before.
   * @crl_list_size: holds the size of the crl_list
   *
@@ -1548,8 +1548,8 @@ int gnutls_certificate_set_x509_crl_mem(gnutls_certificate_credentials res,
   * Returns 0 on success.
   *
   **/
-int gnutls_certificate_set_x509_crl(gnutls_certificate_credentials res,
-				    gnutls_x509_crl * crl_list,
+int gnutls_certificate_set_x509_crl(gnutls_certificate_credentials_t res,
+				    gnutls_x509_crl_t * crl_list,
 				    int crl_list_size)
 {
     int ret, i;
@@ -1557,7 +1557,7 @@ int gnutls_certificate_set_x509_crl(gnutls_certificate_credentials res,
     res->x509_crl_list = gnutls_realloc_fast(res->x509_crl_list,
 					     (crl_list_size +
 					      res->x509_ncrls) *
-					     sizeof(gnutls_x509_crl));
+					     sizeof(gnutls_x509_crl_t));
     if (res->x509_crl_list == NULL) {
 	gnutls_assert();
 	return GNUTLS_E_MEMORY_ERROR;
@@ -1577,8 +1577,8 @@ int gnutls_certificate_set_x509_crl(gnutls_certificate_credentials res,
 }
 
 /**
-  * gnutls_certificate_set_x509_crl_file - Used to add CRLs in a gnutls_certificate_credentials structure
-  * @res: is an &gnutls_certificate_credentials structure.
+  * gnutls_certificate_set_x509_crl_file - Used to add CRLs in a gnutls_certificate_credentials_t structure
+  * @res: is an &gnutls_certificate_credentials_t structure.
   * @crlfile: is a file containing the list of verified CRLs (DER or PEM list)
   * @type: is PEM or DER
   *
@@ -1592,9 +1592,9 @@ int gnutls_certificate_set_x509_crl(gnutls_certificate_credentials res,
   * on error. 
   *
   **/
-int gnutls_certificate_set_x509_crl_file(gnutls_certificate_credentials
+int gnutls_certificate_set_x509_crl_file(gnutls_certificate_credentials_t
 					 res, const char *crlfile,
-					 gnutls_x509_crt_fmt type)
+					 gnutls_x509_crt_fmt_t type)
 {
     int ret;
     strfile x;
@@ -1624,14 +1624,14 @@ int gnutls_certificate_set_x509_crl_file(gnutls_certificate_credentials
 
 
 /**
-  * gnutls_certificate_free_crls - Used to free all the CRLs from a gnutls_certificate_credentials structure
-  * @sc: is an &gnutls_certificate_credentials structure.
+  * gnutls_certificate_free_crls - Used to free all the CRLs from a gnutls_certificate_credentials_t structure
+  * @sc: is an &gnutls_certificate_credentials_t structure.
   *
   * This function will delete all the CRLs associated
   * with the given credentials.
   *
   **/
-void gnutls_certificate_free_crls(gnutls_certificate_credentials sc)
+void gnutls_certificate_free_crls(gnutls_certificate_credentials_t sc)
 {
     uint j;
 
diff --git a/lib/gnutls_x509.h b/lib/gnutls_x509.h
index ed29e3534a..d815b749da 100644
--- a/lib/gnutls_x509.h
+++ b/lib/gnutls_x509.h
@@ -1,6 +1,6 @@
 #include <libtasn1.h>
 
-int _gnutls_x509_cert_verify_peers(gnutls_session session);
+int _gnutls_x509_cert_verify_peers(gnutls_session_t session);
 
 #define PEM_CERT_SEP2 "-----BEGIN X509 CERTIFICATE"
 #define PEM_CERT_SEP "-----BEGIN CERTIFICATE"
@@ -12,7 +12,7 @@ int _gnutls_x509_cert_verify_peers(gnutls_session session);
 #define PEM_KEY_DSA_SEP "-----BEGIN DSA"
 
 int _gnutls_check_key_usage(const gnutls_cert * cert,
-			    gnutls_kx_algorithm alg);
+			    gnutls_kx_algorithm_t alg);
 
 int _gnutls_x509_read_rsa_params(opaque * der, int dersize,
 				 mpi_t * params);
@@ -20,7 +20,6 @@ int _gnutls_x509_read_dsa_pubkey(opaque * der, int dersize,
 				 mpi_t * params);
 
 int _gnutls_x509_raw_privkey_to_gkey(gnutls_privkey * privkey,
-				     const gnutls_datum * raw_key,
-				     gnutls_x509_crt_fmt type);
+     const gnutls_datum_t * raw_key, gnutls_x509_crt_fmt_t type);
 int _gnutls_x509_privkey_to_gkey(gnutls_privkey * privkey,
-				 gnutls_x509_privkey);
+				 gnutls_x509_privkey_t);
diff --git a/lib/x509/common.c b/lib/x509/common.c
index 9b281dfe4d..51da2b11df 100644
--- a/lib/x509/common.c
+++ b/lib/x509/common.c
@@ -255,7 +255,7 @@ void _gnutls_int2str(unsigned int k, char *data)
 }
 
 
-gnutls_pk_algorithm _gnutls_x509_oid2pk_algorithm(const char *oid)
+gnutls_pk_algorithm_t _gnutls_x509_oid2pk_algorithm(const char *oid)
 {
     if (strcmp(oid, PKIX1_RSA_OID) == 0)	/* pkix-1 1 - RSA */
 	return GNUTLS_PK_RSA;
@@ -267,7 +267,7 @@ gnutls_pk_algorithm _gnutls_x509_oid2pk_algorithm(const char *oid)
     return GNUTLS_PK_UNKNOWN;
 }
 
-gnutls_sign_algorithm _gnutls_x509_oid2sign_algorithm(const char *oid)
+gnutls_sign_algorithm_t _gnutls_x509_oid2sign_algorithm(const char *oid)
 {
     if (strcmp(oid, RSA_MD5_OID) == 0) {
 	return GNUTLS_SIGN_RSA_MD5;
@@ -287,7 +287,7 @@ gnutls_sign_algorithm _gnutls_x509_oid2sign_algorithm(const char *oid)
 
 /* returns -1 on error
  */
-gnutls_mac_algorithm _gnutls_x509_oid2mac_algorithm(const char *oid)
+gnutls_mac_algorithm_t _gnutls_x509_oid2mac_algorithm(const char *oid)
 {
     if (strcmp(oid, OID_SHA1) == 0)
 	return GNUTLS_MAC_SHA;
@@ -297,7 +297,7 @@ gnutls_mac_algorithm _gnutls_x509_oid2mac_algorithm(const char *oid)
     return GNUTLS_MAC_UNKNOWN;
 }
 
-const char *_gnutls_x509_mac_to_oid(gnutls_mac_algorithm mac)
+const char *_gnutls_x509_mac_to_oid(gnutls_mac_algorithm_t mac)
 {
     if (mac == GNUTLS_MAC_SHA)
 	return OID_SHA1;
@@ -307,7 +307,7 @@ const char *_gnutls_x509_mac_to_oid(gnutls_mac_algorithm mac)
 	return NULL;
 }
 
-const char *_gnutls_x509_pk_to_oid(gnutls_pk_algorithm pk)
+const char *_gnutls_x509_pk_to_oid(gnutls_pk_algorithm_t pk)
 {
     if (pk == GNUTLS_PK_RSA)
 	return PKIX1_RSA_OID;
@@ -317,8 +317,8 @@ const char *_gnutls_x509_pk_to_oid(gnutls_pk_algorithm pk)
 	return NULL;
 }
 
-gnutls_sign_algorithm _gnutls_x509_pk_to_sign(gnutls_pk_algorithm pk,
-					      gnutls_mac_algorithm mac)
+gnutls_sign_algorithm_t _gnutls_x509_pk_to_sign(gnutls_pk_algorithm_t pk,
+					      gnutls_mac_algorithm_t mac)
 {
     if (pk == GNUTLS_PK_RSA) {
 	if (mac == GNUTLS_MAC_SHA)
@@ -332,10 +332,10 @@ gnutls_sign_algorithm _gnutls_x509_pk_to_sign(gnutls_pk_algorithm pk,
     return GNUTLS_SIGN_UNKNOWN;
 }
 
-const char *_gnutls_x509_sign_to_oid(gnutls_pk_algorithm pk,
-				     gnutls_mac_algorithm mac)
+const char *_gnutls_x509_sign_to_oid(gnutls_pk_algorithm_t pk,
+				     gnutls_mac_algorithm_t mac)
 {
-    gnutls_sign_algorithm sign;
+    gnutls_sign_algorithm_t sign;
 
     sign = _gnutls_x509_pk_to_sign(pk, mac);
 
@@ -646,7 +646,7 @@ int _gnutls_x509_set_time(ASN1_TYPE c2, const char *where, time_t tim)
 }
 
 
-gnutls_x509_subject_alt_name _gnutls_x509_san_find_type(char *str_type)
+gnutls_x509_subject_alt_name_t _gnutls_x509_san_find_type(char *str_type)
 {
     if (strcmp(str_type, "dNSName") == 0)
 	return GNUTLS_SAN_DNSNAME;
@@ -656,14 +656,14 @@ gnutls_x509_subject_alt_name _gnutls_x509_san_find_type(char *str_type)
 	return GNUTLS_SAN_URI;
     if (strcmp(str_type, "iPAddress") == 0)
 	return GNUTLS_SAN_IPADDRESS;
-    return (gnutls_x509_subject_alt_name) - 1;
+    return (gnutls_x509_subject_alt_name_t) - 1;
 }
 
 /* A generic export function. Will export the given ASN.1 encoded data
  * to PEM or DER raw data.
  */
 int _gnutls_x509_export_int(ASN1_TYPE asn1_data,
-			    gnutls_x509_crt_fmt format, char *pem_header,
+			    gnutls_x509_crt_fmt_t format, char *pem_header,
 			    int tmp_buf_size, unsigned char *output_data,
 			    size_t * output_data_size)
 {
@@ -758,7 +758,7 @@ int _gnutls_x509_export_int(ASN1_TYPE asn1_data,
  * an octet string.
  */
 int _gnutls_x509_read_value(ASN1_TYPE c, const char *root,
-			    gnutls_datum * ret, int str)
+			    gnutls_datum_t * ret, int str)
 {
     int len = 0, result;
     opaque *tmp = NULL;
@@ -833,7 +833,7 @@ int _gnutls_x509_read_value(ASN1_TYPE c, const char *root,
  * an OCTET STRING.
  */
 int _gnutls_x509_der_encode(ASN1_TYPE src, const char *src_name,
-			    gnutls_datum * res, int str)
+			    gnutls_datum_t * res, int str)
 {
     int size, result;
     int asize;
@@ -919,7 +919,7 @@ int _gnutls_x509_der_encode_and_copy(ASN1_TYPE src, const char *src_name,
 				     int str)
 {
     int result;
-    gnutls_datum encoded;
+    gnutls_datum_t encoded;
 
     result = _gnutls_x509_der_encode(src, src_name, &encoded, str);
 
@@ -946,12 +946,12 @@ int _gnutls_x509_der_encode_and_copy(ASN1_TYPE src, const char *src_name,
  * zero it encodes it as OCTET STRING.
  */
 int _gnutls_x509_write_value(ASN1_TYPE c, const char *root,
-			     const gnutls_datum * data, int str)
+			     const gnutls_datum_t * data, int str)
 {
     int result;
     int asize;
     ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
-    gnutls_datum val;
+    gnutls_datum_t val;
 
     asize = data->size + 16;
 
@@ -1017,12 +1017,12 @@ int _gnutls_x509_write_value(ASN1_TYPE c, const char *root,
  */
 int _gnutls_x509_encode_and_copy_PKI_params(ASN1_TYPE dst,
 					    const char *dst_name,
-					    gnutls_pk_algorithm
+					    gnutls_pk_algorithm_t
 					    pk_algorithm, mpi_t * params,
 					    int params_size)
 {
     const char *pk;
-    gnutls_datum der = { NULL, 0 };
+    gnutls_datum_t der = { NULL, 0 };
     int result;
     char name[128];
 
@@ -1221,7 +1221,7 @@ int _gnutls_asn1_copy_node(ASN1_TYPE * dst, const char *dst_name,
 {
 
     int result;
-    gnutls_datum der;
+    gnutls_datum_t der;
     ASN1_TYPE dst_node;
 
     result = _gnutls_x509_der_encode(src, src_name, &der, 0);
@@ -1257,9 +1257,9 @@ int _gnutls_asn1_copy_node(ASN1_TYPE * dst, const char *dst_name,
  * returns them into signed_data.
  */
 int _gnutls_x509_get_signed_data(ASN1_TYPE src, const char *src_name,
-				 gnutls_datum * signed_data)
+				 gnutls_datum_t * signed_data)
 {
-    gnutls_datum der;
+    gnutls_datum_t der;
     int start, end, result;
 
     result = _gnutls_x509_der_encode(src, "", &der, 0);
@@ -1298,7 +1298,7 @@ int _gnutls_x509_get_signed_data(ASN1_TYPE src, const char *src_name,
  * returns them into signed_data.
  */
 int _gnutls_x509_get_signature(ASN1_TYPE src, const char *src_name,
-			       gnutls_datum * signature)
+     gnutls_datum_t * signature)
 {
     int bits, result, len;
 
diff --git a/lib/x509/common.h b/lib/x509/common.h
index 6464e819b0..ce3025fadf 100644
--- a/lib/x509/common.h
+++ b/lib/x509/common.h
@@ -32,44 +32,44 @@ const char* _gnutls_x509_oid2ldap_string( const char* OID);
 int _gnutls_x509_oid_data_choice( const char* OID);
 int _gnutls_x509_oid_data_printable( const char* OID);
 
-gnutls_pk_algorithm _gnutls_x509_oid2pk_algorithm( const char* oid);
-gnutls_mac_algorithm _gnutls_x509_oid2mac_algorithm( const char* oid);
-gnutls_sign_algorithm _gnutls_x509_oid2sign_algorithm( const char* oid);
+gnutls_pk_algorithm_t _gnutls_x509_oid2pk_algorithm( const char* oid);
+gnutls_mac_algorithm_t _gnutls_x509_oid2mac_algorithm( const char* oid);
+gnutls_sign_algorithm_t _gnutls_x509_oid2sign_algorithm( const char* oid);
 
-const char* _gnutls_x509_pk_to_oid( gnutls_pk_algorithm pk);
+const char* _gnutls_x509_pk_to_oid( gnutls_pk_algorithm_t pk);
 
-gnutls_sign_algorithm _gnutls_x509_pk_to_sign(
-        gnutls_pk_algorithm pk, gnutls_mac_algorithm mac);
-const char* _gnutls_x509_sign_to_oid( gnutls_pk_algorithm, gnutls_mac_algorithm mac);
-const char* _gnutls_x509_mac_to_oid( gnutls_mac_algorithm mac);
+gnutls_sign_algorithm_t _gnutls_x509_pk_to_sign(
+        gnutls_pk_algorithm_t pk, gnutls_mac_algorithm_t mac);
+const char* _gnutls_x509_sign_to_oid( gnutls_pk_algorithm_t, gnutls_mac_algorithm_t mac);
+const char* _gnutls_x509_mac_to_oid( gnutls_mac_algorithm_t mac);
 
 time_t _gnutls_x509_get_time(ASN1_TYPE c2, const char *when);
 
-gnutls_x509_subject_alt_name _gnutls_x509_san_find_type( char* str_type);
+gnutls_x509_subject_alt_name_t _gnutls_x509_san_find_type( char* str_type);
 
 int _gnutls_x509_der_encode_and_copy( ASN1_TYPE src, const char* src_name,
 	ASN1_TYPE dest, const char* dest_name, int str);
 int _gnutls_x509_der_encode( ASN1_TYPE src, const char* src_name,
-        gnutls_datum *res, int str);
+        gnutls_datum_t *res, int str);
 
 int _gnutls_x509_export_int( ASN1_TYPE asn1_data,
-	gnutls_x509_crt_fmt format, char* pem_header,
+	gnutls_x509_crt_fmt_t format, char* pem_header,
 	int tmp_buf_size, unsigned char* output_data, size_t* output_data_size);
 
-int _gnutls_x509_read_value( ASN1_TYPE c, const char* root, gnutls_datum *ret, int str);
-int _gnutls_x509_write_value( ASN1_TYPE c, const char* root, const gnutls_datum* data, int str);
+int _gnutls_x509_read_value( ASN1_TYPE c, const char* root, gnutls_datum_t *ret, int str);
+int _gnutls_x509_write_value( ASN1_TYPE c, const char* root, const gnutls_datum_t* data, int str);
 
 int _gnutls_x509_encode_and_write_attribute( const char* given_oid, ASN1_TYPE asn1_struct, 
 	const char* where, const void* data, int sizeof_data, int multi);
 int _gnutls_x509_decode_and_read_attribute(ASN1_TYPE asn1_struct, const char* where,
-        char* oid, int oid_size, gnutls_datum* value, int multi);
+        char* oid, int oid_size, gnutls_datum_t* value, int multi);
 
 int _gnutls_x509_get_pk_algorithm( ASN1_TYPE src, const char* src_name, unsigned int* bits);
 
 int _gnutls_x509_encode_and_copy_PKI_params( ASN1_TYPE dst, const char* dst_name,
-	gnutls_pk_algorithm pk_algorithm, mpi_t* params, int params_size);
+	gnutls_pk_algorithm_t pk_algorithm, mpi_t* params, int params_size);
 int _gnutls_asn1_copy_node( ASN1_TYPE *dst, const char* dst_name,
 	ASN1_TYPE src, const char* src_name);
 
-int _gnutls_x509_get_signed_data( ASN1_TYPE src, const char* src_name, gnutls_datum * signed_data);
-int _gnutls_x509_get_signature( ASN1_TYPE src, const char* src_name, gnutls_datum * signature);
+int _gnutls_x509_get_signed_data( ASN1_TYPE src, const char* src_name, gnutls_datum_t * signed_data);
+int _gnutls_x509_get_signature( ASN1_TYPE src, const char* src_name, gnutls_datum_t * signature);
diff --git a/lib/x509/compat.c b/lib/x509/compat.c
index 90aae9e60a..6e9797252c 100644
--- a/lib/x509/compat.c
+++ b/lib/x509/compat.c
@@ -25,11 +25,6 @@
  * API.
  */
 
-#include <gnutls_global.h>
-#include <gnutls_errors.h>
-#include <string.h>		/* memset */
-#include <dn.h>
-#include <libtasn1.h>
 #include <gnutls/x509.h>
 
 /**
@@ -41,9 +36,9 @@
   * Returns a (time_t) -1 in case of an error.
   *
   **/
-time_t _gnutls_x509_get_raw_crt_activation_time(const gnutls_datum * cert)
+time_t _gnutls_x509_get_raw_crt_activation_time(const gnutls_datum_t * cert)
 {
-    gnutls_x509_crt xcert;
+    gnutls_x509_crt_t xcert;
     time_t result;
 
     result = gnutls_x509_crt_init(&xcert);
@@ -72,9 +67,9 @@ time_t _gnutls_x509_get_raw_crt_activation_time(const gnutls_datum * cert)
   * Returns a (time_t) -1 in case of an error.
   *
   **/
-time_t _gnutls_x509_get_raw_crt_expiration_time(const gnutls_datum * cert)
+time_t _gnutls_x509_get_raw_crt_expiration_time(const gnutls_datum_t * cert)
 {
-    gnutls_x509_crt xcert;
+    gnutls_x509_crt_t xcert;
     time_t result;
 
     result = gnutls_x509_crt_init(&xcert);
diff --git a/lib/x509/compat.h b/lib/x509/compat.h
index 4e9a0f5e13..c312001bb3 100644
--- a/lib/x509/compat.h
+++ b/lib/x509/compat.h
@@ -1,2 +1,2 @@
-time_t _gnutls_x509_get_raw_crt_activation_time( const gnutls_datum*);
-time_t _gnutls_x509_get_raw_crt_expiration_time( const gnutls_datum*);
+time_t _gnutls_x509_get_raw_crt_activation_time( const gnutls_datum_t*);
+time_t _gnutls_x509_get_raw_crt_expiration_time( const gnutls_datum_t*);
diff --git a/lib/x509/crl.c b/lib/x509/crl.c
index 3a6673b76d..5bda8bfabd 100644
--- a/lib/x509/crl.c
+++ b/lib/x509/crl.c
@@ -34,7 +34,7 @@
 #include <dn.h>
 
 /**
-  * gnutls_x509_crl_init - This function initializes a gnutls_x509_crl structure
+  * gnutls_x509_crl_init - This function initializes a gnutls_x509_crl_t structure
   * @crl: The structure to be initialized
   *
   * This function will initialize a CRL structure. CRL stands for
@@ -46,7 +46,7 @@
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_crl_init(gnutls_x509_crl * crl)
+int gnutls_x509_crl_init(gnutls_x509_crl_t * crl)
 {
     *crl = gnutls_calloc(1, sizeof(gnutls_x509_crl_int));
 
@@ -65,13 +65,13 @@ int gnutls_x509_crl_init(gnutls_x509_crl * crl)
 }
 
 /**
-  * gnutls_x509_crl_deinit - This function deinitializes memory used by a gnutls_x509_crl structure
+  * gnutls_x509_crl_deinit - This function deinitializes memory used by a gnutls_x509_crl_t structure
   * @crl: The structure to be initialized
   *
   * This function will deinitialize a CRL structure. 
   *
   **/
-void gnutls_x509_crl_deinit(gnutls_x509_crl crl)
+void gnutls_x509_crl_deinit(gnutls_x509_crl_t crl)
 {
     if (!crl)
 	return;
@@ -89,18 +89,18 @@ void gnutls_x509_crl_deinit(gnutls_x509_crl crl)
   * @format: One of DER or PEM
   *
   * This function will convert the given DER or PEM encoded CRL
-  * to the native gnutls_x509_crl format. The output will be stored in 'crl'.
+  * to the native gnutls_x509_crl_t format. The output will be stored in 'crl'.
   *
   * If the CRL is PEM encoded it should have a header of "X509 CRL".
   *
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_crl_import(gnutls_x509_crl crl, const gnutls_datum * data,
-			   gnutls_x509_crt_fmt format)
+int gnutls_x509_crl_import(gnutls_x509_crl_t crl, const gnutls_datum_t * data,
+			   gnutls_x509_crt_fmt_t format)
 {
     int result = 0, need_free = 0;
-    gnutls_datum _data;
+    gnutls_datum_t _data;
 
     _data.data = data->data;
     _data.size = data->size;
@@ -153,7 +153,7 @@ int gnutls_x509_crl_import(gnutls_x509_crl crl, const gnutls_datum * data,
 
 /**
   * gnutls_x509_crl_get_issuer_dn - This function returns the CRL's issuer distinguished name
-  * @crl: should contain a gnutls_x509_crl structure
+  * @crl: should contain a gnutls_x509_crl_t structure
   * @buf: a pointer to a structure to hold the peer's name (may be null)
   * @sizeof_buf: initially holds the size of @buf
   *
@@ -168,7 +168,7 @@ int gnutls_x509_crl_import(gnutls_x509_crl crl, const gnutls_datum * data,
   * 0 on success.
   *
   **/
-int gnutls_x509_crl_get_issuer_dn(gnutls_x509_crl crl, char *buf,
+int gnutls_x509_crl_get_issuer_dn(gnutls_x509_crl_t crl, char *buf,
 				  size_t * sizeof_buf)
 {
     if (crl == NULL) {
@@ -183,7 +183,7 @@ int gnutls_x509_crl_get_issuer_dn(gnutls_x509_crl crl, char *buf,
 
 /**
   * gnutls_x509_crl_get_issuer_dn_by_oid - This function returns the CRL's issuer distinguished name
-  * @crl: should contain a gnutls_x509_crl structure
+  * @crl: should contain a gnutls_x509_crl_t structure
   * @oid: holds an Object Identified in null terminated string
   * @indx: In case multiple same OIDs exist in the RDN, this specifies which to send. Use zero to get the first one.
   * @raw_flag: If non zero returns the raw DER data of the DN part.
@@ -206,7 +206,7 @@ int gnutls_x509_crl_get_issuer_dn(gnutls_x509_crl crl, char *buf,
   * and 0 on success.
   *
   **/
-int gnutls_x509_crl_get_issuer_dn_by_oid(gnutls_x509_crl crl,
+int gnutls_x509_crl_get_issuer_dn_by_oid(gnutls_x509_crl_t crl,
 					 const char *oid, int indx,
 					 unsigned int raw_flag, void *buf,
 					 size_t * sizeof_buf)
@@ -223,7 +223,7 @@ int gnutls_x509_crl_get_issuer_dn_by_oid(gnutls_x509_crl crl,
 
 /**
   * gnutls_x509_crl_get_issuer_dn_oid - This function returns the Certificate request issuer's distinguished name OIDs
-  * @crl: should contain a gnutls_x509_crl structure
+  * @crl: should contain a gnutls_x509_crl_t structure
   * @indx: Specifies which DN OID to send. Use zero to get the first one.
   * @oid: a pointer to a structure to hold the name (may be null)
   * @sizeof_oid: initially holds the size of 'oid'
@@ -238,7 +238,7 @@ int gnutls_x509_crl_get_issuer_dn_by_oid(gnutls_x509_crl crl,
   * On success 0 is returned.
   *
   **/
-int gnutls_x509_crl_get_dn_oid(gnutls_x509_crl crl,
+int gnutls_x509_crl_get_dn_oid(gnutls_x509_crl_t crl,
 			       int indx, void *oid, size_t * sizeof_oid)
 {
     if (crl == NULL) {
@@ -254,18 +254,18 @@ int gnutls_x509_crl_get_dn_oid(gnutls_x509_crl crl,
 
 /**
   * gnutls_x509_crl_get_signature_algorithm - This function returns the CRL's signature algorithm
-  * @crl: should contain a gnutls_x509_crl structure
+  * @crl: should contain a gnutls_x509_crl_t structure
   *
-  * This function will return a value of the gnutls_sign_algorithm enumeration that 
+  * This function will return a value of the gnutls_sign_algorithm_t enumeration that 
   * is the signature algorithm. 
   *
   * Returns a negative value on error.
   *
   **/
-int gnutls_x509_crl_get_signature_algorithm(gnutls_x509_crl crl)
+int gnutls_x509_crl_get_signature_algorithm(gnutls_x509_crl_t crl)
 {
     int result;
-    gnutls_datum sa;
+    gnutls_datum_t sa;
 
     if (crl == NULL) {
 	gnutls_assert();
@@ -294,14 +294,14 @@ int gnutls_x509_crl_get_signature_algorithm(gnutls_x509_crl crl)
 
 /**
   * gnutls_x509_crl_get_version - This function returns the CRL's version number
-  * @crl: should contain a gnutls_x509_crl structure
+  * @crl: should contain a gnutls_x509_crl_t structure
   *
   * This function will return the version of the specified CRL.
   *
   * Returns a negative value on error.
   *
   **/
-int gnutls_x509_crl_get_version(gnutls_x509_crl crl)
+int gnutls_x509_crl_get_version(gnutls_x509_crl_t crl)
 {
     opaque version[5];
     int len, result;
@@ -324,14 +324,14 @@ int gnutls_x509_crl_get_version(gnutls_x509_crl crl)
 
 /**
   * gnutls_x509_crl_get_this_update - This function returns the CRL's thisUpdate time
-  * @crl: should contain a gnutls_x509_crl structure
+  * @crl: should contain a gnutls_x509_crl_t structure
   *
   * This function will return the time this CRL was issued.
   *
   * Returns (time_t)-1 on error.
   *
   **/
-time_t gnutls_x509_crl_get_this_update(gnutls_x509_crl crl)
+time_t gnutls_x509_crl_get_this_update(gnutls_x509_crl_t crl)
 {
     if (crl == NULL) {
 	gnutls_assert();
@@ -343,7 +343,7 @@ time_t gnutls_x509_crl_get_this_update(gnutls_x509_crl crl)
 
 /**
   * gnutls_x509_crl_get_next_update - This function returns the CRL's nextUpdate time
-  * @crl: should contain a gnutls_x509_crl structure
+  * @crl: should contain a gnutls_x509_crl_t structure
   *
   * This function will return the time the next CRL will be issued.
   * This field is optional in a CRL so it might be normal to get
@@ -352,7 +352,7 @@ time_t gnutls_x509_crl_get_this_update(gnutls_x509_crl crl)
   * Returns (time_t)-1 on error.
   *
   **/
-time_t gnutls_x509_crl_get_next_update(gnutls_x509_crl crl)
+time_t gnutls_x509_crl_get_next_update(gnutls_x509_crl_t crl)
 {
     if (crl == NULL) {
 	gnutls_assert();
@@ -364,7 +364,7 @@ time_t gnutls_x509_crl_get_next_update(gnutls_x509_crl crl)
 
 /**
   * gnutls_x509_crl_get_crt_count - This function returns the number of revoked certificates in a CRL
-  * @crl: should contain a gnutls_x509_crl structure
+  * @crl: should contain a gnutls_x509_crl_t structure
   *
   * This function will return the number of revoked certificates in the
   * given CRL.
@@ -372,7 +372,7 @@ time_t gnutls_x509_crl_get_next_update(gnutls_x509_crl crl)
   * Returns a negative value on failure.
   *
   **/
-int gnutls_x509_crl_get_crt_count(gnutls_x509_crl crl)
+int gnutls_x509_crl_get_crt_count(gnutls_x509_crl_t crl)
 {
 
     int count, result;
@@ -396,7 +396,7 @@ int gnutls_x509_crl_get_crt_count(gnutls_x509_crl crl)
 
 /**
   * gnutls_x509_crl_get_crt_serial - This function returns the serial number of a revoked certificate
-  * @crl: should contain a gnutls_x509_crl structure
+  * @crl: should contain a gnutls_x509_crl_t structure
   * @index: the index of the certificate to extract (starting from 0)
   * @serial: where the serial number will be copied
   * @serial_size: initially holds the size of serial
@@ -408,7 +408,7 @@ int gnutls_x509_crl_get_crt_count(gnutls_x509_crl crl)
   * Returns a negative value on failure.
   *
   **/
-int gnutls_x509_crl_get_crt_serial(gnutls_x509_crl crl, int index,
+int gnutls_x509_crl_get_crt_serial(gnutls_x509_crl_t crl, int index,
 				   unsigned char *serial,
 				   size_t * serial_size, time_t * time)
 {
@@ -454,7 +454,7 @@ int gnutls_x509_crl_get_crt_serial(gnutls_x509_crl crl, int index,
 
 /*-
   * _gnutls_x509_crl_get_raw_issuer_dn - This function returns the issuer's DN DER encoded
-  * @crl: should contain a gnutls_x509_crl structure
+  * @crl: should contain a gnutls_x509_crl_t structure
   * @dn: will hold the starting point of the DN
   *
   * This function will return a pointer to the DER encoded DN structure and
@@ -463,13 +463,13 @@ int gnutls_x509_crl_get_crt_serial(gnutls_x509_crl crl, int index,
   * Returns a negative value on error, and zero on success.
   *
   -*/
-int _gnutls_x509_crl_get_raw_issuer_dn(gnutls_x509_crl crl,
-				       gnutls_datum * dn)
+int _gnutls_x509_crl_get_raw_issuer_dn(gnutls_x509_crl_t crl,
+				       gnutls_datum_t * dn)
 {
     ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
     int result, len1;
     int start1, end1;
-    gnutls_datum crl_signed_data;
+    gnutls_datum_t crl_signed_data;
 
     if (crl == NULL) {
 	gnutls_assert();
@@ -545,8 +545,8 @@ int _gnutls_x509_crl_get_raw_issuer_dn(gnutls_x509_crl crl,
   * Returns 0 on success, and a negative value on failure.
   *
   **/
-int gnutls_x509_crl_export(gnutls_x509_crl crl,
-			   gnutls_x509_crt_fmt format, void *output_data,
+int gnutls_x509_crl_export(gnutls_x509_crl_t crl,
+			   gnutls_x509_crt_fmt_t format, void *output_data,
 			   size_t * output_data_size)
 {
     if (crl == NULL) {
@@ -560,7 +560,7 @@ int gnutls_x509_crl_export(gnutls_x509_crl crl,
 }
 
 /*-
-  * _gnutls_x509_crl_cpy - This function copies a gnutls_x509_crl structure
+  * _gnutls_x509_crl_cpy - This function copies a gnutls_x509_crl_t structure
   * @dest: The structure where to copy
   * @src: The structure to be copied
   *
@@ -569,12 +569,12 @@ int gnutls_x509_crl_export(gnutls_x509_crl crl,
   * Returns 0 on success.
   *
   -*/
-int _gnutls_x509_crl_cpy(gnutls_x509_crl dest, gnutls_x509_crl src)
+int _gnutls_x509_crl_cpy(gnutls_x509_crl_t dest, gnutls_x509_crl_t src)
 {
     int ret;
     size_t der_size;
     opaque *der;
-    gnutls_datum tmp;
+    gnutls_datum_t tmp;
 
     ret =
 	gnutls_x509_crl_export(src, GNUTLS_X509_FMT_DER, NULL, &der_size);
diff --git a/lib/x509/crl_write.c b/lib/x509/crl_write.c
index c68889cf52..8b802dd0fb 100644
--- a/lib/x509/crl_write.c
+++ b/lib/x509/crl_write.c
@@ -41,11 +41,11 @@
 #include <libtasn1.h>
 #include <gnutls_ui.h>
 
-static void disable_optional_stuff(gnutls_x509_crl crl);
+static void disable_optional_stuff(gnutls_x509_crl_t crl);
 
 /**
   * gnutls_x509_crl_set_version - This function will set the CRL version
-  * @crl: should contain a gnutls_x509_crl structure
+  * @crl: should contain a gnutls_x509_crl_t structure
   * @version: holds the version number. For CRLv1 crls must be 1.
   *
   * This function will set the version of the CRL. This
@@ -55,7 +55,7 @@ static void disable_optional_stuff(gnutls_x509_crl crl);
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_crl_set_version(gnutls_x509_crl crl, unsigned int version)
+int gnutls_x509_crl_set_version(gnutls_x509_crl_t crl, unsigned int version)
 {
     int result;
     char null = version;
@@ -80,7 +80,7 @@ int gnutls_x509_crl_set_version(gnutls_x509_crl crl, unsigned int version)
 
 /**
   * gnutls_x509_crl_sign - This function will sign a CRL with a key
-  * @crl: should contain a gnutls_x509_crl structure
+  * @crl: should contain a gnutls_x509_crl_t structure
   * @issuer: is the certificate of the certificate issuer
   * @issuer_key: holds the issuer's private key
   *
@@ -93,8 +93,8 @@ int gnutls_x509_crl_set_version(gnutls_x509_crl crl, unsigned int version)
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_crl_sign(gnutls_x509_crl crl, gnutls_x509_crt issuer,
-			 gnutls_x509_privkey issuer_key)
+int gnutls_x509_crl_sign(gnutls_x509_crl_t crl, gnutls_x509_crt_t issuer,
+			 gnutls_x509_privkey_t issuer_key)
 {
     int result;
 
@@ -119,7 +119,7 @@ int gnutls_x509_crl_sign(gnutls_x509_crl crl, gnutls_x509_crt issuer,
 
 /**
   * gnutls_x509_crl_set_this_update - This function will set the CRL's issuing time
-  * @crl: should contain a gnutls_x509_crl structure
+  * @crl: should contain a gnutls_x509_crl_t structure
   * @act_time: The actual time
   *
   * This function will set the time this CRL was issued.
@@ -127,7 +127,7 @@ int gnutls_x509_crl_sign(gnutls_x509_crl crl, gnutls_x509_crt issuer,
   * Returns 0 on success, or a negative value in case of an error.
   *
   **/
-int gnutls_x509_crl_set_this_update(gnutls_x509_crl crl, time_t act_time)
+int gnutls_x509_crl_set_this_update(gnutls_x509_crl_t crl, time_t act_time)
 {
     if (crl == NULL) {
 	gnutls_assert();
@@ -140,7 +140,7 @@ int gnutls_x509_crl_set_this_update(gnutls_x509_crl crl, time_t act_time)
 
 /**
   * gnutls_x509_crl_set_next_update - This function will set the CRL next update time
-  * @crl: should contain a gnutls_x509_crl structure
+  * @crl: should contain a gnutls_x509_crl_t structure
   * @exp_time: The actual time
   *
   * This function will set the time this CRL will be updated.
@@ -148,7 +148,7 @@ int gnutls_x509_crl_set_this_update(gnutls_x509_crl crl, time_t act_time)
   * Returns 0 on success, or a negative value in case of an error.
   *
   **/
-int gnutls_x509_crl_set_next_update(gnutls_x509_crl crl, time_t exp_time)
+int gnutls_x509_crl_set_next_update(gnutls_x509_crl_t crl, time_t exp_time)
 {
     if (crl == NULL) {
 	gnutls_assert();
@@ -160,7 +160,7 @@ int gnutls_x509_crl_set_next_update(gnutls_x509_crl crl, time_t exp_time)
 
 /**
   * gnutls_x509_crl_set_crt_serial - This function will set a revoked certificate's serial number
-  * @crl: should contain a gnutls_x509_crl structure
+  * @crl: should contain a gnutls_x509_crl_t structure
   * @serial: The revoked certificate's serial number
   * @serial_size: Holds the size of the serial field.
   * @revocation_time: The time this certificate was revoked
@@ -170,7 +170,7 @@ int gnutls_x509_crl_set_next_update(gnutls_x509_crl crl, time_t exp_time)
   * Returns 0 on success, or a negative value in case of an error.
   *
   **/
-int gnutls_x509_crl_set_crt_serial(gnutls_x509_crl crl, const void *serial,
+int gnutls_x509_crl_set_crt_serial(gnutls_x509_crl_t crl, const void *serial,
 				   size_t serial_size,
 				   time_t revocation_time)
 {
@@ -221,8 +221,8 @@ int gnutls_x509_crl_set_crt_serial(gnutls_x509_crl crl, const void *serial,
 
 /**
   * gnutls_x509_crl_set_crt - This function will set a revoked certificate's serial number
-  * @crl: should contain a gnutls_x509_crl structure
-  * @crt: should contain a gnutls_x509_crt structure with the revoked certificate
+  * @crl: should contain a gnutls_x509_crl_t structure
+  * @crt: should contain a gnutls_x509_crt_t structure with the revoked certificate
   * @revocation_time: The time this certificate was revoked
   *
   * This function will set a revoked certificate's serial number to the CRL. 
@@ -230,7 +230,7 @@ int gnutls_x509_crl_set_crt_serial(gnutls_x509_crl crl, const void *serial,
   * Returns 0 on success, or a negative value in case of an error.
   *
   **/
-int gnutls_x509_crl_set_crt(gnutls_x509_crl crl, gnutls_x509_crt crt,
+int gnutls_x509_crl_set_crt(gnutls_x509_crl_t crl, gnutls_x509_crt_t crt,
 			    time_t revocation_time)
 {
     int ret;
@@ -264,7 +264,7 @@ int gnutls_x509_crl_set_crt(gnutls_x509_crl crl, gnutls_x509_crt crt,
 /* If OPTIONAL fields have not been initialized then
  * disable them.
  */
-static void disable_optional_stuff(gnutls_x509_crl crl)
+static void disable_optional_stuff(gnutls_x509_crl_t crl)
 {
 
     asn1_write_value(crl->crl, "tbsCertList.crlExtensions", NULL, 0);
diff --git a/lib/x509/crq.c b/lib/x509/crq.c
index 0bbf0b903b..9bca8c79ef 100644
--- a/lib/x509/crq.c
+++ b/lib/x509/crq.c
@@ -42,7 +42,7 @@
 #include <gnutls_ui.h>
 
 /**
-  * gnutls_x509_crq_init - This function initializes a gnutls_x509_crq structure
+  * gnutls_x509_crq_init - This function initializes a gnutls_x509_crq_t structure
   * @crq: The structure to be initialized
   *
   * This function will initialize a PKCS10 certificate request structure. 
@@ -50,7 +50,7 @@
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_crq_init(gnutls_x509_crq * crq)
+int gnutls_x509_crq_init(gnutls_x509_crq_t * crq)
 {
     *crq = gnutls_calloc(1, sizeof(gnutls_x509_crq_int));
 
@@ -69,13 +69,13 @@ int gnutls_x509_crq_init(gnutls_x509_crq * crq)
 }
 
 /**
-  * gnutls_x509_crq_deinit - This function deinitializes memory used by a gnutls_x509_crq structure
+  * gnutls_x509_crq_deinit - This function deinitializes memory used by a gnutls_x509_crq_t structure
   * @crq: The structure to be initialized
   *
   * This function will deinitialize a CRL structure. 
   *
   **/
-void gnutls_x509_crq_deinit(gnutls_x509_crq crq)
+void gnutls_x509_crq_deinit(gnutls_x509_crq_t crq)
 {
     if (!crq)
 	return;
@@ -96,18 +96,18 @@ void gnutls_x509_crq_deinit(gnutls_x509_crq crq)
   * @format: One of DER or PEM
   *
   * This function will convert the given DER or PEM encoded Certificate
-  * to the native gnutls_x509_crq format. The output will be stored in @cert.
+  * to the native gnutls_x509_crq_t format. The output will be stored in @cert.
   *
   * If the Certificate is PEM encoded it should have a header of "NEW CERTIFICATE REQUEST".
   *
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_crq_import(gnutls_x509_crq crq, const gnutls_datum * data,
-			   gnutls_x509_crt_fmt format)
+int gnutls_x509_crq_import(gnutls_x509_crq_t crq, const gnutls_datum_t * data,
+			   gnutls_x509_crt_fmt_t format)
 {
     int result = 0, need_free = 0;
-    gnutls_datum _data;
+    gnutls_datum_t _data;
 
     if (crq == NULL) {
 	gnutls_assert();
@@ -163,7 +163,7 @@ int gnutls_x509_crq_import(gnutls_x509_crq crq, const gnutls_datum * data,
 
 /**
   * gnutls_x509_crq_get_dn - This function returns the Certificate request subject's distinguished name
-  * @crq: should contain a gnutls_x509_crq structure
+  * @crq: should contain a gnutls_x509_crq_t structure
   * @buf: a pointer to a structure to hold the name (may be null)
   * @sizeof_buf: initially holds the size of @buf
   *
@@ -178,7 +178,7 @@ int gnutls_x509_crq_import(gnutls_x509_crq crq, const gnutls_datum * data,
   * On success 0 is returned.
   *
   **/
-int gnutls_x509_crq_get_dn(gnutls_x509_crq crq, char *buf,
+int gnutls_x509_crq_get_dn(gnutls_x509_crq_t crq, char *buf,
 			   size_t * sizeof_buf)
 {
     if (crq == NULL) {
@@ -193,7 +193,7 @@ int gnutls_x509_crq_get_dn(gnutls_x509_crq crq, char *buf,
 
 /**
   * gnutls_x509_crq_get_dn_by_oid - This function returns the Certificate request subject's distinguished name
-  * @crq: should contain a gnutls_x509_crq structure
+  * @crq: should contain a gnutls_x509_crq_t structure
   * @oid: holds an Object Identified in null terminated string
   * @indx: In case multiple same OIDs exist in the RDN, this specifies which to send. Use zero to get the first one.
   * @raw_flag: If non zero returns the raw DER data of the DN part.
@@ -216,7 +216,7 @@ int gnutls_x509_crq_get_dn(gnutls_x509_crq crq, char *buf,
   * On success 0 is returned.
   *
   **/
-int gnutls_x509_crq_get_dn_by_oid(gnutls_x509_crq crq, const char *oid,
+int gnutls_x509_crq_get_dn_by_oid(gnutls_x509_crq_t crq, const char *oid,
 				  int indx, unsigned int raw_flag,
 				  void *buf, size_t * sizeof_buf)
 {
@@ -232,7 +232,7 @@ int gnutls_x509_crq_get_dn_by_oid(gnutls_x509_crq crq, const char *oid,
 
 /**
   * gnutls_x509_crq_get_dn_oid - This function returns the Certificate request subject's distinguished name OIDs
-  * @crq: should contain a gnutls_x509_crq structure
+  * @crq: should contain a gnutls_x509_crq_t structure
   * @indx: Specifies which DN OID to send. Use zero to get the first one.
   * @oid: a pointer to a structure to hold the name (may be null)
   * @sizeof_oid: initially holds the size of @oid
@@ -247,7 +247,7 @@ int gnutls_x509_crq_get_dn_by_oid(gnutls_x509_crq crq, const char *oid,
   * On success 0 is returned.
   *
   **/
-int gnutls_x509_crq_get_dn_oid(gnutls_x509_crq crq,
+int gnutls_x509_crq_get_dn_oid(gnutls_x509_crq_t crq,
 			       int indx, void *oid, size_t * sizeof_oid)
 {
     if (crq == NULL) {
@@ -384,7 +384,7 @@ static int parse_attribute(ASN1_TYPE asn1_struct,
 
 /**
   * gnutls_x509_crq_get_challenge_password - This function will get the challenge password 
-  * @crq: should contain a gnutls_x509_crq structure
+  * @crq: should contain a gnutls_x509_crq_t structure
   * @pass: will hold a null terminated password
   * @sizeof_pass: Initially holds the size of @pass.
   *
@@ -394,7 +394,7 @@ static int parse_attribute(ASN1_TYPE asn1_struct,
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_crq_get_challenge_password(gnutls_x509_crq crq,
+int gnutls_x509_crq_get_challenge_password(gnutls_x509_crq_t crq,
 					   char *pass,
 					   size_t * sizeof_pass)
 {
@@ -409,7 +409,7 @@ int gnutls_x509_crq_get_challenge_password(gnutls_x509_crq crq,
 
 /**
   * gnutls_x509_crq_set_dn_by_oid - This function will set the Certificate request subject's distinguished name
-  * @crq: should contain a gnutls_x509_crq structure
+  * @crq: should contain a gnutls_x509_crq_t structure
   * @oid: holds an Object Identifier in a null terminated string
   * @raw_flag: must be 0, or 1 if the data are DER encoded
   * @data: a pointer to the input data
@@ -427,7 +427,7 @@ int gnutls_x509_crq_get_challenge_password(gnutls_x509_crq crq,
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_crq_set_dn_by_oid(gnutls_x509_crq crq, const char *oid,
+int gnutls_x509_crq_set_dn_by_oid(gnutls_x509_crq_t crq, const char *oid,
 				  unsigned int raw_flag, const void *data,
 				  unsigned int sizeof_data)
 {
@@ -442,7 +442,7 @@ int gnutls_x509_crq_set_dn_by_oid(gnutls_x509_crq crq, const char *oid,
 
 /**
   * gnutls_x509_crq_set_version - This function will set the Certificate request version
-  * @crq: should contain a gnutls_x509_crq structure
+  * @crq: should contain a gnutls_x509_crq_t structure
   * @version: holds the version number. For v1 Requests must be 1.
   *
   * This function will set the version of the certificate request. For
@@ -451,7 +451,7 @@ int gnutls_x509_crq_set_dn_by_oid(gnutls_x509_crq crq, const char *oid,
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_crq_set_version(gnutls_x509_crq crq, unsigned int version)
+int gnutls_x509_crq_set_version(gnutls_x509_crq_t crq, unsigned int version)
 {
     int result;
     unsigned char null = version;
@@ -477,14 +477,14 @@ int gnutls_x509_crq_set_version(gnutls_x509_crq crq, unsigned int version)
 
 /**
   * gnutls_x509_crq_get_version - This function returns the Certificate request's version number
-  * @crq: should contain a gnutls_x509_crq structure
+  * @crq: should contain a gnutls_x509_crq_t structure
   *
   * This function will return the version of the specified Certificate request.
   *
   * Returns a negative value on error.
   *
   **/
-int gnutls_x509_crq_get_version(gnutls_x509_crq crq)
+int gnutls_x509_crq_get_version(gnutls_x509_crq_t crq)
 {
     opaque version[5];
     int len, result;
@@ -510,7 +510,7 @@ int gnutls_x509_crq_get_version(gnutls_x509_crq crq)
 
 /**
   * gnutls_x509_crq_set_key - This function will associate the Certificate request with a key
-  * @crq: should contain a gnutls_x509_crq structure
+  * @crq: should contain a gnutls_x509_crq_t structure
   * @key: holds a private key
   *
   * This function will set the public parameters from the given private key to the
@@ -519,7 +519,7 @@ int gnutls_x509_crq_get_version(gnutls_x509_crq crq)
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_crq_set_key(gnutls_x509_crq crq, gnutls_x509_privkey key)
+int gnutls_x509_crq_set_key(gnutls_x509_crq_t crq, gnutls_x509_privkey_t key)
 {
     int result;
 
@@ -544,7 +544,7 @@ int gnutls_x509_crq_set_key(gnutls_x509_crq crq, gnutls_x509_privkey key)
 
 /**
   * gnutls_x509_crq_set_challenge_password - This function will set a challenge password 
-  * @crq: should contain a gnutls_x509_crq structure
+  * @crq: should contain a gnutls_x509_crq_t structure
   * @pass: holds a null terminated password
   *
   * This function will set a challenge password to be used when revoking the request.
@@ -552,7 +552,7 @@ int gnutls_x509_crq_set_key(gnutls_x509_crq crq, gnutls_x509_privkey key)
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_crq_set_challenge_password(gnutls_x509_crq crq,
+int gnutls_x509_crq_set_challenge_password(gnutls_x509_crq_t crq,
 					   const char *pass)
 {
     int result;
@@ -588,7 +588,7 @@ int gnutls_x509_crq_set_challenge_password(gnutls_x509_crq crq,
 
 /**
   * gnutls_x509_crq_sign - This function will sign a Certificate request with a key
-  * @crq: should contain a gnutls_x509_crq structure
+  * @crq: should contain a gnutls_x509_crq_t structure
   * @key: holds a private key
   *
   * This function will sign the certificate request with a private key.
@@ -601,10 +601,10 @@ int gnutls_x509_crq_set_challenge_password(gnutls_x509_crq crq,
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_crq_sign(gnutls_x509_crq crq, gnutls_x509_privkey key)
+int gnutls_x509_crq_sign(gnutls_x509_crq_t crq, gnutls_x509_privkey_t key)
 {
     int result;
-    gnutls_datum signature;
+    gnutls_datum_t signature;
 
     if (crq == NULL) {
 	gnutls_assert();
@@ -667,8 +667,8 @@ int gnutls_x509_crq_sign(gnutls_x509_crq crq, gnutls_x509_privkey key)
   * 0 on success.
   *
   **/
-int gnutls_x509_crq_export(gnutls_x509_crq crq,
-			   gnutls_x509_crt_fmt format, void *output_data,
+int gnutls_x509_crq_export(gnutls_x509_crq_t crq,
+			   gnutls_x509_crt_fmt_t format, void *output_data,
 			   size_t * output_data_size)
 {
     if (crq == NULL) {
@@ -683,7 +683,7 @@ int gnutls_x509_crq_export(gnutls_x509_crq crq,
 
 /**
   * gnutls_x509_crq_get_pk_algorithm - This function returns the certificate request's PublicKey algorithm
-  * @crq: should contain a gnutls_x509_crq structure
+  * @crq: should contain a gnutls_x509_crq_t structure
   * @bits: if bits is non null it will hold the size of the parameters' in bits
   *
   * This function will return the public key algorithm of a PKCS \#10 
@@ -694,11 +694,11 @@ int gnutls_x509_crq_export(gnutls_x509_crq crq,
   * For DSA the bits returned are of the public
   * exponent.
   *
-  * Returns a member of the gnutls_pk_algorithm enumeration on success,
+  * Returns a member of the gnutls_pk_algorithm_t enumeration on success,
   * or a negative value on error.
   *
   **/
-int gnutls_x509_crq_get_pk_algorithm(gnutls_x509_crq crq,
+int gnutls_x509_crq_get_pk_algorithm(gnutls_x509_crq_t crq,
 				     unsigned int *bits)
 {
     int result;
diff --git a/lib/x509/crq.h b/lib/x509/crq.h
index 35b89caf12..579b0a0983 100644
--- a/lib/x509/crq.h
+++ b/lib/x509/crq.h
@@ -5,17 +5,17 @@ typedef struct gnutls_x509_crq_int {
 	ASN1_TYPE crq;
 } gnutls_x509_crq_int;
 
-typedef struct gnutls_x509_crq_int *gnutls_x509_crq;
+typedef struct gnutls_x509_crq_int *gnutls_x509_crq_t;
 
-int gnutls_x509_crq_get_dn_by_oid(gnutls_x509_crq crq, const char* oid, 
+int gnutls_x509_crq_get_dn_by_oid(gnutls_x509_crq_t crq, const char* oid, 
 	int indx, unsigned int raw_flag, void *buf, size_t *sizeof_buf);
 
-int gnutls_x509_crq_init(gnutls_x509_crq * crq);
-void gnutls_x509_crq_deinit(gnutls_x509_crq crq);
+int gnutls_x509_crq_init(gnutls_x509_crq_t * crq);
+void gnutls_x509_crq_deinit(gnutls_x509_crq_t crq);
 
-int gnutls_x509_crq_import(gnutls_x509_crq crq, const gnutls_datum * data,
-	gnutls_x509_crt_fmt format);
+int gnutls_x509_crq_import(gnutls_x509_crq_t crq, const gnutls_datum_t * data,
+	gnutls_x509_crt_fmt_t format);
 
-int gnutls_x509_crq_get_pk_algorithm( gnutls_x509_crq crq, unsigned int* bits);
+int gnutls_x509_crq_get_pk_algorithm( gnutls_x509_crq_t crq, unsigned int* bits);
 
 #endif
diff --git a/lib/x509/dn.c b/lib/x509/dn.c
index aa626c8a4a..184dcf318f 100644
--- a/lib/x509/dn.c
+++ b/lib/x509/dn.c
@@ -794,7 +794,7 @@ int _gnutls_x509_write_attribute(const char *given_oid,
 int _gnutls_x509_decode_and_read_attribute(ASN1_TYPE asn1_struct,
 					   const char *where, char *oid,
 					   int oid_size,
-					   gnutls_datum * value, int multi)
+					   gnutls_datum_t * value, int multi)
 {
     char tmpbuffer[128];
     int len, result;
@@ -923,7 +923,7 @@ int _gnutls_x509_set_dn_oid(ASN1_TYPE asn1_struct,
   * and 0 on success.
   *
   **/
-int gnutls_x509_rdn_get(const gnutls_datum * idn,
+int gnutls_x509_rdn_get(const gnutls_datum_t * idn,
 			char *buf, size_t * sizeof_buf)
 {
     int result;
@@ -977,7 +977,7 @@ int gnutls_x509_rdn_get(const gnutls_datum * idn,
   * and 0 on success.
   *
   **/
-int gnutls_x509_rdn_get_by_oid(const gnutls_datum * idn, const char *oid,
+int gnutls_x509_rdn_get_by_oid(const gnutls_datum_t * idn, const char *oid,
 			       int indx, unsigned int raw_flag,
 			       void *buf, size_t * sizeof_buf)
 {
@@ -1026,7 +1026,7 @@ int gnutls_x509_rdn_get_by_oid(const gnutls_datum * idn, const char *oid,
   * and 0 on success.
   *
   **/
-int gnutls_x509_rdn_get_oid(const gnutls_datum * idn,
+int gnutls_x509_rdn_get_oid(const gnutls_datum_t * idn,
 			    int indx, void *buf, size_t * sizeof_buf)
 {
     int result;
@@ -1067,8 +1067,8 @@ int gnutls_x509_rdn_get_oid(const gnutls_datum * idn,
  * Returns 1 if the DN's match and zero if they don't match. Otherwise
  * a negative value is returned to indicate error.
  */
-int _gnutls_x509_compare_raw_dn(const gnutls_datum * dn1,
-				const gnutls_datum * dn2)
+int _gnutls_x509_compare_raw_dn(const gnutls_datum_t * dn1,
+				const gnutls_datum_t * dn2)
 {
 
     if (dn1->size != dn2->size) {
diff --git a/lib/x509/extensions.c b/lib/x509/extensions.c
index 1d499f6abf..33392aa06a 100644
--- a/lib/x509/extensions.c
+++ b/lib/x509/extensions.c
@@ -41,9 +41,9 @@
  * If the extension does not exist, GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE will
  * be returned.
  */
-int _gnutls_x509_crt_get_extension(gnutls_x509_crt cert,
+int _gnutls_x509_crt_get_extension(gnutls_x509_crt_t cert,
 				   const char *extension_id, int indx,
-				   gnutls_datum * ret,
+				   gnutls_datum_t * ret,
 				   unsigned int *_critical)
 {
     int k, result, len;
@@ -52,7 +52,7 @@ int _gnutls_x509_crt_get_extension(gnutls_x509_crt cert,
     char str_critical[10];
     int critical = 0;
     char extnID[128];
-    gnutls_datum value;
+    gnutls_datum_t value;
     int indx_counter = 0;
 
     ret->data = NULL;
@@ -160,7 +160,7 @@ int _gnutls_x509_crt_get_extension(gnutls_x509_crt cert,
  * If you have passed the last extension, GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE will
  * be returned.
  */
-int _gnutls_x509_crt_get_extension_oid(gnutls_x509_crt cert,
+int _gnutls_x509_crt_get_extension_oid(gnutls_x509_crt_t cert,
 				       int indx, void *oid,
 				       size_t * sizeof_oid)
 {
@@ -239,7 +239,7 @@ int _gnutls_x509_crt_get_extension_oid(gnutls_x509_crt cert,
  * Critical will be either 0 or 1.
  */
 static int set_extension(ASN1_TYPE asn, const char *extension_id,
-			 const gnutls_datum * ext_data,
+			 const gnutls_datum_t * ext_data,
 			 unsigned int critical)
 {
     int result;
@@ -291,7 +291,7 @@ static int set_extension(ASN1_TYPE asn, const char *extension_id,
  * index here starts from one.
  */
 static int overwrite_extension(ASN1_TYPE asn, unsigned int indx,
-			       const gnutls_datum * ext_data,
+			       const gnutls_datum_t * ext_data,
 			       unsigned int critical)
 {
     char name[128], name2[128], counter[MAX_INT_DIGITS];
@@ -333,9 +333,9 @@ static int overwrite_extension(ASN1_TYPE asn, unsigned int indx,
  *
  * Critical will be either 0 or 1.
  */
-int _gnutls_x509_crt_set_extension(gnutls_x509_crt cert,
+int _gnutls_x509_crt_set_extension(gnutls_x509_crt_t cert,
 				   const char *ext_id,
-				   const gnutls_datum * ext_data,
+				   const gnutls_datum_t * ext_data,
 				   unsigned int critical)
 {
     int result;
@@ -495,7 +495,7 @@ int _gnutls_x509_ext_extract_basicConstraints(int *CA, opaque * extnValue,
 /* generate the basicConstraints in a DER encoded extension
  * Use 0 or 1 (TRUE) for CA.
  */
-int _gnutls_x509_ext_gen_basicConstraints(int CA, gnutls_datum * der_ext)
+int _gnutls_x509_ext_gen_basicConstraints(int CA, gnutls_datum_t * der_ext)
 {
     ASN1_TYPE ext = ASN1_TYPE_EMPTY;
     const char *str;
@@ -538,7 +538,7 @@ int _gnutls_x509_ext_gen_basicConstraints(int CA, gnutls_datum * der_ext)
 /* generate the keyUsage in a DER encoded extension
  * Use an ORed SEQUENCE of GNUTLS_KEY_* for usage.
  */
-int _gnutls_x509_ext_gen_keyUsage(uint16 usage, gnutls_datum * der_ext)
+int _gnutls_x509_ext_gen_keyUsage(uint16 usage, gnutls_datum_t * der_ext)
 {
     ASN1_TYPE ext = ASN1_TYPE_EMPTY;
     int result;
@@ -574,7 +574,7 @@ int _gnutls_x509_ext_gen_keyUsage(uint16 usage, gnutls_datum * der_ext)
 }
 
 static int write_new_general_name(ASN1_TYPE ext, const char *ext_name,
-				  gnutls_x509_subject_alt_name type,
+				  gnutls_x509_subject_alt_name_t type,
 				  const char *data_string)
 {
     const char *str;
@@ -634,9 +634,9 @@ static int write_new_general_name(ASN1_TYPE ext, const char *ext_name,
 /* Convert the given name to GeneralNames in a DER encoded extension.
  * This is the same as subject alternative name.
  */
-int _gnutls_x509_ext_gen_subject_alt_name(gnutls_x509_subject_alt_name
+int _gnutls_x509_ext_gen_subject_alt_name(gnutls_x509_subject_alt_name_t
 					  type, const char *data_string,
-					  gnutls_datum * der_ext)
+					  gnutls_datum_t * der_ext)
 {
     ASN1_TYPE ext = ASN1_TYPE_EMPTY;
     int result;
@@ -671,7 +671,7 @@ int _gnutls_x509_ext_gen_subject_alt_name(gnutls_x509_subject_alt_name
 /* generate the SubjectKeyID in a DER encoded extension
  */
 int _gnutls_x509_ext_gen_key_id(const void *id, size_t id_size,
-				gnutls_datum * der_ext)
+				gnutls_datum_t * der_ext)
 {
     ASN1_TYPE ext = ASN1_TYPE_EMPTY;
     int result;
@@ -706,7 +706,7 @@ int _gnutls_x509_ext_gen_key_id(const void *id, size_t id_size,
 /* generate the AuthorityKeyID in a DER encoded extension
  */
 int _gnutls_x509_ext_gen_auth_key_id(const void *id, size_t id_size,
-				     gnutls_datum * der_ext)
+				     gnutls_datum_t * der_ext)
 {
     ASN1_TYPE ext = ASN1_TYPE_EMPTY;
     int result;
@@ -747,13 +747,12 @@ int _gnutls_x509_ext_gen_auth_key_id(const void *id, size_t id_size,
  * reason_flags should be an or'ed sequence of GNUTLS_CRL_REASON_*.
  *
  */
-int _gnutls_x509_ext_gen_crl_dist_points(gnutls_x509_subject_alt_name type,
-					 const void *data_string,
-					 unsigned int reason_flags,
-					 gnutls_datum * der_ext)
+int _gnutls_x509_ext_gen_crl_dist_points(gnutls_x509_subject_alt_name_t type,
+    const void *data_string, unsigned int reason_flags,
+    gnutls_datum_t * der_ext)
 {
     ASN1_TYPE ext = ASN1_TYPE_EMPTY;
-    gnutls_datum gnames = { NULL, 0 };
+    gnutls_datum_t gnames = { NULL, 0 };
     int result;
     uint8 reasons[2];
 
diff --git a/lib/x509/extensions.h b/lib/x509/extensions.h
index b3ca4c963a..c9f50a99ef 100644
--- a/lib/x509/extensions.h
+++ b/lib/x509/extensions.h
@@ -1,20 +1,20 @@
-int _gnutls_x509_crt_get_extension( gnutls_x509_crt cert, const char* extension_id, 
-	int indx, gnutls_datum* ret, unsigned int* critical);
+int _gnutls_x509_crt_get_extension( gnutls_x509_crt_t cert, const char* extension_id, 
+	int indx, gnutls_datum_t* ret, unsigned int* critical);
 
-int _gnutls_x509_crt_get_extension_oid( gnutls_x509_crt cert,
+int _gnutls_x509_crt_get_extension_oid( gnutls_x509_crt_t cert,
 	int indx, void* ret, size_t * ret_size);
 int _gnutls_x509_ext_extract_keyUsage(uint16 *keyUsage, opaque * extnValue,
 			     int extnValueLen);
 int _gnutls_x509_ext_extract_basicConstraints(int *CA, opaque * extnValue,
 				     int extnValueLen);
 
-int _gnutls_x509_crt_set_extension( gnutls_x509_crt cert, const char* extension_id, 
-	const gnutls_datum* ext_data, unsigned int critical);
-int _gnutls_x509_ext_gen_basicConstraints(int CA, gnutls_datum* der_ext);
-int _gnutls_x509_ext_gen_keyUsage(uint16 usage, gnutls_datum* der_ext);
-int _gnutls_x509_ext_gen_subject_alt_name(gnutls_x509_subject_alt_name type, 
-	const char* data_string, gnutls_datum* der_ext);
-int _gnutls_x509_ext_gen_crl_dist_points(gnutls_x509_subject_alt_name type, 
-	const void* data_string, unsigned int reason_flags, gnutls_datum* der_ext);
-int _gnutls_x509_ext_gen_key_id( const void* id, size_t id_size, gnutls_datum* der_data);
-int _gnutls_x509_ext_gen_auth_key_id( const void* id, size_t id_size, gnutls_datum* der_data);
+int _gnutls_x509_crt_set_extension( gnutls_x509_crt_t cert, const char* extension_id, 
+	const gnutls_datum_t* ext_data, unsigned int critical);
+int _gnutls_x509_ext_gen_basicConstraints(int CA, gnutls_datum_t* der_ext);
+int _gnutls_x509_ext_gen_keyUsage(uint16 usage, gnutls_datum_t* der_ext);
+int _gnutls_x509_ext_gen_subject_alt_name(gnutls_x509_subject_alt_name_t type, 
+	const char* data_string, gnutls_datum_t* der_ext);
+int _gnutls_x509_ext_gen_crl_dist_points(gnutls_x509_subject_alt_name_t type, 
+	const void* data_string, unsigned int reason_flags, gnutls_datum_t* der_ext);
+int _gnutls_x509_ext_gen_key_id( const void* id, size_t id_size, gnutls_datum_t* der_data);
+int _gnutls_x509_ext_gen_auth_key_id( const void* id, size_t id_size, gnutls_datum_t* der_data);
diff --git a/lib/x509/mpi.c b/lib/x509/mpi.c
index f7ea8ac213..8d37c021b5 100644
--- a/lib/x509/mpi.c
+++ b/lib/x509/mpi.c
@@ -179,7 +179,7 @@ int _gnutls_x509_read_dsa_pubkey(opaque * der, int dersize, mpi_t * params)
 
 /* Extracts DSA and RSA parameters from a certificate.
  */
-int _gnutls_x509_crt_get_mpis(gnutls_x509_crt cert,
+int _gnutls_x509_crt_get_mpis(gnutls_x509_crt_t cert,
 			      mpi_t * params, int *params_size)
 {
     int len, result;
@@ -280,7 +280,7 @@ int _gnutls_x509_crt_get_mpis(gnutls_x509_crt cert,
  * Allocates the space used to store the DER data.
  */
 int _gnutls_x509_write_rsa_params(mpi_t * params, int params_size,
-				  gnutls_datum * der)
+				  gnutls_datum_t * der)
 {
     int result;
     ASN1_TYPE spk = ASN1_TYPE_EMPTY;
@@ -333,10 +333,10 @@ int _gnutls_x509_write_rsa_params(mpi_t * params, int params_size,
  * This is the "signatureAlgorithm" fields.
  */
 int _gnutls_x509_write_sig_params(ASN1_TYPE dst, const char *dst_name,
-				  gnutls_pk_algorithm pk_algorithm,
+				  gnutls_pk_algorithm_t pk_algorithm,
 				  mpi_t * params, int params_size)
 {
-    gnutls_datum der;
+    gnutls_datum_t der;
     int result;
     char name[128];
     const char *pk;
@@ -398,7 +398,7 @@ int _gnutls_x509_write_sig_params(ASN1_TYPE dst, const char *dst_name,
  * Allocates the space used to store the DER data.
  */
 int _gnutls_x509_write_dsa_params(mpi_t * params, int params_size,
-				  gnutls_datum * der)
+				  gnutls_datum_t * der)
 {
     int result;
     ASN1_TYPE spk = ASN1_TYPE_EMPTY;
@@ -458,7 +458,7 @@ int _gnutls_x509_write_dsa_params(mpi_t * params, int params_size,
  * Allocates the space used to store the DER data.
  */
 int _gnutls_x509_write_dsa_public_key(mpi_t * params, int params_size,
-				      gnutls_datum * der)
+				      gnutls_datum_t * der)
 {
     int result;
     ASN1_TYPE spk = ASN1_TYPE_EMPTY;
diff --git a/lib/x509/mpi.h b/lib/x509/mpi.h
index ce452ef2e1..161f9d6e26 100644
--- a/lib/x509/mpi.h
+++ b/lib/x509/mpi.h
@@ -1,18 +1,18 @@
 #include <gnutls_int.h>
 #include "x509.h"
 
-int _gnutls_x509_crt_get_mpis( gnutls_x509_crt cert,
+int _gnutls_x509_crt_get_mpis( gnutls_x509_crt_t cert,
 	mpi_t* params, int *params_size);
 int _gnutls_x509_read_rsa_params(opaque * der, int dersize, mpi_t * params);
 int _gnutls_x509_read_dsa_pubkey(opaque * der, int dersize, mpi_t * params);
 int _gnutls_x509_read_dsa_params(opaque * der, int dersize, mpi_t * params);
 
 int _gnutls_x509_write_rsa_params( mpi_t * params, int params_size,
-	gnutls_datum* der);
+	gnutls_datum_t* der);
 int _gnutls_x509_write_dsa_params( mpi_t * params, int params_size,
-        gnutls_datum* der);
+        gnutls_datum_t* der);
 int _gnutls_x509_write_dsa_public_key( mpi_t * params, int params_size,
-	gnutls_datum* der);
+	gnutls_datum_t* der);
 
 int _gnutls_x509_read_uint( ASN1_TYPE node, const char* value, 
 	unsigned int* ret);
@@ -23,4 +23,4 @@ int _gnutls_x509_write_int( ASN1_TYPE node, const char* value, mpi_t mpi, int lz
 int _gnutls_x509_write_uint32( ASN1_TYPE node, const char* value, uint32 num);
 
 int _gnutls_x509_write_sig_params( ASN1_TYPE dst, const char* dst_name,
-	gnutls_pk_algorithm pk_algorithm, mpi_t * params, int params_size);
+	gnutls_pk_algorithm_t pk_algorithm, mpi_t * params, int params_size);
diff --git a/lib/x509/pkcs12.c b/lib/x509/pkcs12.c
index ee48262401..3bd761bd4c 100644
--- a/lib/x509/pkcs12.c
+++ b/lib/x509/pkcs12.c
@@ -45,11 +45,11 @@
  */
 static
 int _decode_pkcs12_auth_safe(ASN1_TYPE pkcs12, ASN1_TYPE * authen_safe,
-			     gnutls_datum * raw)
+			     gnutls_datum_t * raw)
 {
     char oid[128];
     ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
-    gnutls_datum auth_safe = { NULL, 0 };
+    gnutls_datum_t auth_safe = { NULL, 0 };
     int tmp_size, len, result;
 
     len = sizeof(oid) - 1;
@@ -114,7 +114,7 @@ int _decode_pkcs12_auth_safe(ASN1_TYPE pkcs12, ASN1_TYPE * authen_safe,
 }
 
 /**
-  * gnutls_pkcs12_init - This function initializes a gnutls_pkcs12 structure
+  * gnutls_pkcs12_init - This function initializes a gnutls_pkcs12_t structure
   * @pkcs12: The structure to be initialized
   *
   * This function will initialize a PKCS12 structure. PKCS12 structures
@@ -124,7 +124,7 @@ int _decode_pkcs12_auth_safe(ASN1_TYPE pkcs12, ASN1_TYPE * authen_safe,
   * Returns 0 on success.
   *
   **/
-int gnutls_pkcs12_init(gnutls_pkcs12 * pkcs12)
+int gnutls_pkcs12_init(gnutls_pkcs12_t * pkcs12)
 {
     *pkcs12 = gnutls_calloc(1, sizeof(gnutls_pkcs12_int));
 
@@ -143,13 +143,13 @@ int gnutls_pkcs12_init(gnutls_pkcs12 * pkcs12)
 }
 
 /**
-  * gnutls_pkcs12_deinit - This function deinitializes memory used by a gnutls_pkcs12 structure
+  * gnutls_pkcs12_deinit - This function deinitializes memory used by a gnutls_pkcs12_t structure
   * @pkcs12: The structure to be initialized
   *
   * This function will deinitialize a PKCS12 structure. 
   *
   **/
-void gnutls_pkcs12_deinit(gnutls_pkcs12 pkcs12)
+void gnutls_pkcs12_deinit(gnutls_pkcs12_t pkcs12)
 {
     if (!pkcs12)
 	return;
@@ -168,18 +168,18 @@ void gnutls_pkcs12_deinit(gnutls_pkcs12 pkcs12)
   * @flags: an ORed sequence of gnutls_privkey_pkcs8_flags
   *
   * This function will convert the given DER or PEM encoded PKCS12
-  * to the native gnutls_pkcs12 format. The output will be stored in 'pkcs12'.
+  * to the native gnutls_pkcs12_t format. The output will be stored in 'pkcs12'.
   *
   * If the PKCS12 is PEM encoded it should have a header of "PKCS12".
   *
   * Returns 0 on success.
   *
   **/
-int gnutls_pkcs12_import(gnutls_pkcs12 pkcs12, const gnutls_datum * data,
-			 gnutls_x509_crt_fmt format, unsigned int flags)
+int gnutls_pkcs12_import(gnutls_pkcs12_t pkcs12, const gnutls_datum_t * data,
+			 gnutls_x509_crt_fmt_t format, unsigned int flags)
 {
     int result = 0, need_free = 0;
-    gnutls_datum _data;
+    gnutls_datum_t _data;
 
     _data.data = data->data;
     _data.size = data->size;
@@ -249,8 +249,8 @@ int gnutls_pkcs12_import(gnutls_pkcs12 pkcs12, const gnutls_datum * data,
   * 0 on success.
   *
   **/
-int gnutls_pkcs12_export(gnutls_pkcs12 pkcs12,
-			 gnutls_x509_crt_fmt format, void *output_data,
+int gnutls_pkcs12_export(gnutls_pkcs12_t pkcs12,
+			 gnutls_x509_crt_fmt_t format, void *output_data,
 			 size_t * output_data_size)
 {
     if (pkcs12 == NULL) {
@@ -307,14 +307,14 @@ static inline char *ucs2_to_ascii(char *data, int size)
  * the given bag. 
  */
 int
-_pkcs12_decode_safe_contents(const gnutls_datum * content,
-			     gnutls_pkcs12_bag bag)
+_pkcs12_decode_safe_contents(const gnutls_datum_t * content,
+			     gnutls_pkcs12_bag_t  bag)
 {
     char oid[128], root[128];
     ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
     int len, result;
     int bag_type;
-    gnutls_datum attr_val;
+    gnutls_datum_t attr_val;
     int count = 0, i, attributes, j;
     char counter[MAX_INT_DIGITS];
 
@@ -388,7 +388,7 @@ _pkcs12_decode_safe_contents(const gnutls_datum * content,
 
 	if (bag_type == GNUTLS_BAG_CERTIFICATE ||
 	    bag_type == GNUTLS_BAG_CRL) {
-	    gnutls_datum tmp = bag->element[i].data;
+	    gnutls_datum_t tmp = bag->element[i].data;
 
 	    result =
 		_pkcs12_decode_crt_bag(bag_type, &tmp,
@@ -470,9 +470,9 @@ _pkcs12_decode_safe_contents(const gnutls_datum * content,
 
 static
 int _parse_safe_contents(ASN1_TYPE sc, const char *sc_name,
-			 gnutls_pkcs12_bag bag)
+			 gnutls_pkcs12_bag_t  bag)
 {
-    gnutls_datum content = { NULL, 0 };
+    gnutls_datum_t content = { NULL, 0 };
     int result;
 
     /* Step 1. Extract the content.
@@ -502,7 +502,7 @@ int _parse_safe_contents(ASN1_TYPE sc, const char *sc_name,
 
 /**
   * gnutls_pkcs12_get_bag - This function returns a Bag from a PKCS12 structure
-  * @pkcs12_struct: should contain a gnutls_pkcs12 structure
+  * @pkcs12_struct: should contain a gnutls_pkcs12_t structure
   * @indx: contains the index of the bag to extract
   * @bag: An initialized bag, where the contents of the bag will be copied
   *
@@ -513,15 +513,15 @@ int _parse_safe_contents(ASN1_TYPE sc, const char *sc_name,
   * will be returned.
   *
   **/
-int gnutls_pkcs12_get_bag(gnutls_pkcs12 pkcs12,
-			  int indx, gnutls_pkcs12_bag bag)
+int gnutls_pkcs12_get_bag(gnutls_pkcs12_t pkcs12,
+			  int indx, gnutls_pkcs12_bag_t  bag)
 {
     ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
     int result, len;
     char root2[64];
     char oid[128];
     char counter[MAX_INT_DIGITS];
-    gnutls_datum tmp = { NULL, 0 };
+    gnutls_datum_t tmp = { NULL, 0 };
 
     if (pkcs12 == NULL) {
 	gnutls_assert();
@@ -649,14 +649,14 @@ static int create_empty_pfx(ASN1_TYPE pkcs12)
 
 /**
   * gnutls_pkcs12_set_bag - This function inserts a Bag into a PKCS12 structure
-  * @pkcs12_struct: should contain a gnutls_pkcs12 structure
+  * @pkcs12_struct: should contain a gnutls_pkcs12_t structure
   * @bag: An initialized bag
   *
   * This function will insert a Bag into the PKCS12 structure.
   * Returns 0 on success.
   *
   **/
-int gnutls_pkcs12_set_bag(gnutls_pkcs12 pkcs12, gnutls_pkcs12_bag bag)
+int gnutls_pkcs12_set_bag(gnutls_pkcs12_t pkcs12, gnutls_pkcs12_bag_t  bag)
 {
     ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
     ASN1_TYPE safe_cont = ASN1_TYPE_EMPTY;
@@ -768,20 +768,20 @@ int gnutls_pkcs12_set_bag(gnutls_pkcs12 pkcs12, gnutls_pkcs12_bag bag)
 
 /**
   * gnutls_pkcs12_generate_mac - This function generates the MAC of the PKCS12 structure
-  * @pkcs12_struct: should contain a gnutls_pkcs12 structure
+  * @pkcs12_struct: should contain a gnutls_pkcs12_t structure
   * @pass: The password for the MAC
   *
   * This function will generate a MAC for the PKCS12 structure.
   * Returns 0 on success.
   *
   **/
-int gnutls_pkcs12_generate_mac(gnutls_pkcs12 pkcs12, const char *pass)
+int gnutls_pkcs12_generate_mac(gnutls_pkcs12_t pkcs12, const char *pass)
 {
     opaque salt[8], key[20];
     int result;
     const int iter = 1;
     mac_hd_t td1 = NULL;
-    gnutls_datum tmp = { NULL, 0 };
+    gnutls_datum_t tmp = { NULL, 0 };
     opaque sha_mac[20];
 
     if (pkcs12 == NULL) {
@@ -887,20 +887,20 @@ int gnutls_pkcs12_generate_mac(gnutls_pkcs12 pkcs12, const char *pass)
 
 /**
   * gnutls_pkcs12_verify_mac - This function verifies the MAC of the PKCS12 structure
-  * @pkcs12_struct: should contain a gnutls_pkcs12 structure
+  * @pkcs12_struct: should contain a gnutls_pkcs12_t structure
   * @pass: The password for the MAC
   *
   * This function will verify the MAC for the PKCS12 structure.
   * Returns 0 on success.
   *
   **/
-int gnutls_pkcs12_verify_mac(gnutls_pkcs12 pkcs12, const char *pass)
+int gnutls_pkcs12_verify_mac(gnutls_pkcs12_t pkcs12, const char *pass)
 {
     opaque key[20];
     int result;
     unsigned int iter, len;
     mac_hd_t td1 = NULL;
-    gnutls_datum tmp = { NULL, 0 }, salt = {
+    gnutls_datum_t tmp = { NULL, 0 }, salt = {
     NULL, 0};
     opaque sha_mac[20];
     opaque sha_mac_orig[20];
@@ -989,7 +989,7 @@ int gnutls_pkcs12_verify_mac(gnutls_pkcs12 pkcs12, const char *pass)
 }
 
 
-static int write_attributes(gnutls_pkcs12_bag bag, int elem, ASN1_TYPE c2,
+static int write_attributes(gnutls_pkcs12_bag_t  bag, int elem, ASN1_TYPE c2,
 			    const char *where)
 {
     int result;
@@ -1089,7 +1089,7 @@ static int write_attributes(gnutls_pkcs12_bag bag, int elem, ASN1_TYPE c2,
  * the given datum. Enc is set to non zero if the data are encrypted;
  */
 int
-_pkcs12_encode_safe_contents(gnutls_pkcs12_bag bag, ASN1_TYPE * contents,
+_pkcs12_encode_safe_contents(gnutls_pkcs12_bag_t  bag, ASN1_TYPE * contents,
 			     int *enc)
 {
     ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
@@ -1152,7 +1152,7 @@ _pkcs12_encode_safe_contents(gnutls_pkcs12_bag bag, ASN1_TYPE * contents,
 
 	if (bag->element[i].type == GNUTLS_BAG_CERTIFICATE ||
 	    bag->element[i].type == GNUTLS_BAG_CRL) {
-	    gnutls_datum tmp;
+	    gnutls_datum_t tmp;
 
 	    /* in that case encode it to a CertBag or
 	     * a CrlBag.
diff --git a/lib/x509/pkcs12.h b/lib/x509/pkcs12.h
index a0d86411bb..21cd6aa275 100644
--- a/lib/x509/pkcs12.h
+++ b/lib/x509/pkcs12.h
@@ -3,7 +3,7 @@ typedef struct gnutls_pkcs12_int {
 	ASN1_TYPE pkcs12;
 } gnutls_pkcs12_int;
 
-typedef enum gnutls_pkcs12_bag_type {
+typedef enum gnutls_pkcs12_bag_type_t {
 	GNUTLS_BAG_EMPTY = 0,
 
 	GNUTLS_BAG_PKCS8_ENCRYPTED_KEY=1,
@@ -12,14 +12,14 @@ typedef enum gnutls_pkcs12_bag_type {
 	GNUTLS_BAG_CRL,
 	GNUTLS_BAG_ENCRYPTED=10,
 	GNUTLS_BAG_UNKNOWN=20
-} gnutls_pkcs12_bag_type;
+} gnutls_pkcs12_bag_type_t;
 
 #define MAX_BAG_ELEMENTS 32
 
 struct bag_element {
-	gnutls_datum data;
-	gnutls_pkcs12_bag_type type;
-	gnutls_datum local_key_id;
+	gnutls_datum_t data;
+	gnutls_pkcs12_bag_type_t type;
+	gnutls_datum_t local_key_id;
 	char * friendly_name;
 };
 
@@ -43,27 +43,27 @@ typedef struct gnutls_pkcs12_bag_int {
 #define FRIENDLY_NAME_OID "1.2.840.113549.1.9.20"
 #define KEY_ID_OID "1.2.840.113549.1.9.21"
 
-typedef struct gnutls_pkcs12_int *gnutls_pkcs12;
-typedef struct gnutls_pkcs12_bag_int *gnutls_pkcs12_bag;
+typedef struct gnutls_pkcs12_int *gnutls_pkcs12_t;
+typedef struct gnutls_pkcs12_bag_int *gnutls_pkcs12_bag_t;
 
-int gnutls_pkcs12_init(gnutls_pkcs12 * pkcs12);
-void gnutls_pkcs12_deinit(gnutls_pkcs12 pkcs12);
-int gnutls_pkcs12_import(gnutls_pkcs12 pkcs12, const gnutls_datum * data,
-	gnutls_x509_crt_fmt format, unsigned int flags);
+int gnutls_pkcs12_init(gnutls_pkcs12_t * pkcs12);
+void gnutls_pkcs12_deinit(gnutls_pkcs12_t pkcs12);
+int gnutls_pkcs12_import(gnutls_pkcs12_t pkcs12, const gnutls_datum_t * data,
+	gnutls_x509_crt_fmt_t format, unsigned int flags);
 
-int gnutls_pkcs12_get_bag(gnutls_pkcs12 pkcs12, 
-	int indx, gnutls_pkcs12_bag bag);
+int gnutls_pkcs12_get_bag(gnutls_pkcs12_t pkcs12, 
+	int indx, gnutls_pkcs12_bag_t bag);
 
-int gnutls_pkcs12_bag_init(gnutls_pkcs12_bag * bag);
-void gnutls_pkcs12_bag_deinit(gnutls_pkcs12_bag bag);
+int gnutls_pkcs12_bag_init(gnutls_pkcs12_bag_t * bag);
+void gnutls_pkcs12_bag_deinit(gnutls_pkcs12_bag_t  bag);
 
 int 
 _pkcs12_string_to_key (unsigned int id, const opaque *salt, unsigned int salt_size, 
 	unsigned int iter, const char *pw,
 	unsigned int req_keylen, opaque *keybuf);
 
-int _gnutls_pkcs7_decrypt_data( const gnutls_datum* data,
-        const char* password, gnutls_datum* dec);
+int _gnutls_pkcs7_decrypt_data( const gnutls_datum_t* data,
+        const char* password, gnutls_datum_t* dec);
 
 typedef enum schema_id {
 	PBES2,			/* the stuff in PKCS #5 */
@@ -72,15 +72,15 @@ typedef enum schema_id {
 	PKCS12_RC2_40_SHA1
 } schema_id;
 
-int _gnutls_pkcs7_encrypt_data(schema_id schema, const gnutls_datum * data,
+int _gnutls_pkcs7_encrypt_data(schema_id schema, const gnutls_datum_t * data,
 					      const char *password,
-					      gnutls_datum * enc);
-int _pkcs12_decode_safe_contents( const gnutls_datum* content, gnutls_pkcs12_bag bag);
+					      gnutls_datum_t * enc);
+int _pkcs12_decode_safe_contents( const gnutls_datum_t* content, gnutls_pkcs12_bag_t bag);
 
 int
-_pkcs12_encode_safe_contents( gnutls_pkcs12_bag bag, ASN1_TYPE* content, int *enc);
+_pkcs12_encode_safe_contents( gnutls_pkcs12_bag_t bag, ASN1_TYPE* content, int *enc);
 
-int _pkcs12_decode_crt_bag( gnutls_pkcs12_bag_type type, const gnutls_datum* in,
-		gnutls_datum* out);
-int _pkcs12_encode_crt_bag( gnutls_pkcs12_bag_type type, const gnutls_datum* raw,
-		gnutls_datum* out);
+int _pkcs12_decode_crt_bag( gnutls_pkcs12_bag_type_t type, const gnutls_datum_t* in,
+		gnutls_datum_t* out);
+int _pkcs12_encode_crt_bag( gnutls_pkcs12_bag_type_t type, const gnutls_datum_t* raw,
+		gnutls_datum_t* out);
diff --git a/lib/x509/pkcs12_bag.c b/lib/x509/pkcs12_bag.c
index 352ddb279a..972067bebc 100644
--- a/lib/x509/pkcs12_bag.c
+++ b/lib/x509/pkcs12_bag.c
@@ -35,7 +35,7 @@
 #include <privkey.h>
 
 /**
-  * gnutls_pkcs12_bag_init - This function initializes a gnutls_pkcs12_bag structure
+  * gnutls_pkcs12_bag_init - This function initializes a gnutls_pkcs12_bag_t  structure
   * @bag: The structure to be initialized
   *
   * This function will initialize a PKCS12 bag structure. PKCS12 Bags
@@ -45,7 +45,7 @@
   * Returns 0 on success.
   *
   **/
-int gnutls_pkcs12_bag_init(gnutls_pkcs12_bag * bag)
+int gnutls_pkcs12_bag_init(gnutls_pkcs12_bag_t  * bag)
 {
     *bag = gnutls_calloc(1, sizeof(gnutls_pkcs12_bag_int));
 
@@ -55,7 +55,7 @@ int gnutls_pkcs12_bag_init(gnutls_pkcs12_bag * bag)
     return GNUTLS_E_MEMORY_ERROR;
 }
 
-static inline void _pkcs12_bag_free_data(gnutls_pkcs12_bag bag)
+static inline void _pkcs12_bag_free_data(gnutls_pkcs12_bag_t  bag)
 {
     int i;
 
@@ -71,13 +71,13 @@ static inline void _pkcs12_bag_free_data(gnutls_pkcs12_bag bag)
 
 
 /**
-  * gnutls_pkcs12_bag_deinit - This function deinitializes memory used by a gnutls_pkcs12 structure
+  * gnutls_pkcs12_bag_deinit - This function deinitializes memory used by a gnutls_pkcs12_t structure
   * @bag: The structure to be initialized
   *
   * This function will deinitialize a PKCS12 Bag structure. 
   *
   **/
-void gnutls_pkcs12_bag_deinit(gnutls_pkcs12_bag bag)
+void gnutls_pkcs12_bag_deinit(gnutls_pkcs12_bag_t  bag)
 {
     if (!bag)
 	return;
@@ -92,11 +92,11 @@ void gnutls_pkcs12_bag_deinit(gnutls_pkcs12_bag bag)
   * @bag: The bag
   * @indx: The element of the bag to get the type
   *
-  * This function will return the bag's type. One of the gnutls_pkcs12_bag_type
+  * This function will return the bag's type. One of the gnutls_pkcs12_bag_type_t
   * enumerations.
   *
   **/
-gnutls_pkcs12_bag_type gnutls_pkcs12_bag_get_type(gnutls_pkcs12_bag bag,
+gnutls_pkcs12_bag_type_t gnutls_pkcs12_bag_get_type(gnutls_pkcs12_bag_t  bag,
 						  int indx)
 {
     if (bag == NULL) {
@@ -116,7 +116,7 @@ gnutls_pkcs12_bag_type gnutls_pkcs12_bag_get_type(gnutls_pkcs12_bag bag,
   * This function will return the number of the elements withing the bag. 
   *
   **/
-int gnutls_pkcs12_bag_get_count(gnutls_pkcs12_bag bag)
+int gnutls_pkcs12_bag_get_count(gnutls_pkcs12_bag_t  bag)
 {
     if (bag == NULL) {
 	gnutls_assert();
@@ -139,8 +139,8 @@ int gnutls_pkcs12_bag_get_count(gnutls_pkcs12_bag bag)
   * Returns 0 on success and a negative error code on error.
   *
   **/
-int gnutls_pkcs12_bag_get_data(gnutls_pkcs12_bag bag, int indx,
-			       gnutls_datum * data)
+int gnutls_pkcs12_bag_get_data(gnutls_pkcs12_bag_t  bag, int indx,
+			       gnutls_datum_t * data)
 {
     if (bag == NULL) {
 	gnutls_assert();
@@ -159,8 +159,8 @@ int gnutls_pkcs12_bag_get_data(gnutls_pkcs12_bag bag, int indx,
 #define X509_CERT_OID "1.2.840.113549.1.9.22.1"
 #define X509_CRL_OID  "1.2.840.113549.1.9.23.1"
 
-int _pkcs12_decode_crt_bag(gnutls_pkcs12_bag_type type,
-			   const gnutls_datum * in, gnutls_datum * out)
+int _pkcs12_decode_crt_bag(gnutls_pkcs12_bag_type_t type,
+			   const gnutls_datum_t * in, gnutls_datum_t * out)
 {
     int ret;
     ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
@@ -222,8 +222,8 @@ int _pkcs12_decode_crt_bag(gnutls_pkcs12_bag_type type,
 }
 
 
-int _pkcs12_encode_crt_bag(gnutls_pkcs12_bag_type type,
-			   const gnutls_datum * raw, gnutls_datum * out)
+int _pkcs12_encode_crt_bag(gnutls_pkcs12_bag_type_t type,
+			   const gnutls_datum_t * raw, gnutls_datum_t * out)
 {
     int ret;
     ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
@@ -305,9 +305,9 @@ int _pkcs12_encode_crt_bag(gnutls_pkcs12_bag_type type,
   * value on error.
   *
   **/
-int gnutls_pkcs12_bag_set_data(gnutls_pkcs12_bag bag,
-			       gnutls_pkcs12_bag_type type,
-			       const gnutls_datum * data)
+int gnutls_pkcs12_bag_set_data(gnutls_pkcs12_bag_t  bag,
+			       gnutls_pkcs12_bag_type_t type,
+			       const gnutls_datum_t * data)
 {
     int ret;
     if (bag == NULL) {
@@ -362,10 +362,10 @@ int gnutls_pkcs12_bag_set_data(gnutls_pkcs12_bag bag,
   * value on failure.
   *
   **/
-int gnutls_pkcs12_bag_set_crt(gnutls_pkcs12_bag bag, gnutls_x509_crt crt)
+int gnutls_pkcs12_bag_set_crt(gnutls_pkcs12_bag_t  bag, gnutls_x509_crt_t crt)
 {
     int ret;
-    gnutls_datum data;
+    gnutls_datum_t data;
 
     if (bag == NULL) {
 	gnutls_assert();
@@ -397,10 +397,10 @@ int gnutls_pkcs12_bag_set_crt(gnutls_pkcs12_bag bag, gnutls_x509_crt crt)
   * value on failure.
   *
   **/
-int gnutls_pkcs12_bag_set_crl(gnutls_pkcs12_bag bag, gnutls_x509_crl crl)
+int gnutls_pkcs12_bag_set_crl(gnutls_pkcs12_bag_t  bag, gnutls_x509_crl_t crl)
 {
     int ret;
-    gnutls_datum data;
+    gnutls_datum_t data;
 
 
     if (bag == NULL) {
@@ -434,8 +434,8 @@ int gnutls_pkcs12_bag_set_crl(gnutls_pkcs12_bag bag, gnutls_x509_crl crl)
   * Returns 0 on success, or a negative value on error.
   *
   **/
-int gnutls_pkcs12_bag_set_key_id(gnutls_pkcs12_bag bag, int indx,
-				 const gnutls_datum * id)
+int gnutls_pkcs12_bag_set_key_id(gnutls_pkcs12_bag_t  bag, int indx,
+				 const gnutls_datum_t * id)
 {
     int ret;
 
@@ -473,8 +473,8 @@ int gnutls_pkcs12_bag_set_key_id(gnutls_pkcs12_bag bag, int indx,
   * Returns 0 on success, or a negative value on error.
   *
   **/
-int gnutls_pkcs12_bag_get_key_id(gnutls_pkcs12_bag bag, int indx,
-				 gnutls_datum * id)
+int gnutls_pkcs12_bag_get_key_id(gnutls_pkcs12_bag_t  bag, int indx,
+				 gnutls_datum_t * id)
 {
     if (bag == NULL) {
 	gnutls_assert();
@@ -504,7 +504,7 @@ int gnutls_pkcs12_bag_get_key_id(gnutls_pkcs12_bag bag, int indx,
   * Returns 0 on success, or a negative value on error.
   *
   **/
-int gnutls_pkcs12_bag_get_friendly_name(gnutls_pkcs12_bag bag, int indx,
+int gnutls_pkcs12_bag_get_friendly_name(gnutls_pkcs12_bag_t  bag, int indx,
 					char **name)
 {
     if (bag == NULL) {
@@ -536,7 +536,7 @@ int gnutls_pkcs12_bag_get_friendly_name(gnutls_pkcs12_bag bag, int indx,
   * Returns 0 on success, or a negative value on error.
   *
   **/
-int gnutls_pkcs12_bag_set_friendly_name(gnutls_pkcs12_bag bag, int indx,
+int gnutls_pkcs12_bag_set_friendly_name(gnutls_pkcs12_bag_t  bag, int indx,
 					const char *name)
 {
     if (bag == NULL) {
@@ -568,10 +568,10 @@ int gnutls_pkcs12_bag_set_friendly_name(gnutls_pkcs12_bag bag, int indx,
   * This function will decrypt the given encrypted bag and return 0 on success.
   *
   **/
-int gnutls_pkcs12_bag_decrypt(gnutls_pkcs12_bag bag, const char *pass)
+int gnutls_pkcs12_bag_decrypt(gnutls_pkcs12_bag_t  bag, const char *pass)
 {
     int ret;
-    gnutls_datum dec;
+    gnutls_datum_t dec;
 
     if (bag == NULL) {
 	gnutls_assert();
@@ -612,18 +612,18 @@ int gnutls_pkcs12_bag_decrypt(gnutls_pkcs12_bag bag, const char *pass)
   * gnutls_pkcs12_bag_encrypt - This function will encrypt a bag
   * @bag: The bag
   * @pass: The password used for encryption. This can only be ASCII.
-  * @flags: should be one of gnutls_pkcs_encrypt_flags elements bitwise or'd
+  * @flags: should be one of gnutls_pkcs_encrypt_flags_t elements bitwise or'd
   *
   * This function will encrypt the given bag and return 0 on success.
   *
   **/
-int gnutls_pkcs12_bag_encrypt(gnutls_pkcs12_bag bag, const char *pass,
+int gnutls_pkcs12_bag_encrypt(gnutls_pkcs12_bag_t  bag, const char *pass,
 			      unsigned int flags)
 {
     int ret;
     ASN1_TYPE safe_cont = ASN1_TYPE_EMPTY;
-    gnutls_datum der = { NULL, 0 };
-    gnutls_datum enc = { NULL, 0 };
+    gnutls_datum_t der = { NULL, 0 };
+    gnutls_datum_t enc = { NULL, 0 };
     schema_id id;
 
     if (bag == NULL) {
diff --git a/lib/x509/pkcs7.c b/lib/x509/pkcs7.c
index ce301fda7d..5e8386f075 100644
--- a/lib/x509/pkcs7.c
+++ b/lib/x509/pkcs7.c
@@ -44,7 +44,7 @@
  */
 static
 int _decode_pkcs7_signed_data(ASN1_TYPE pkcs7, ASN1_TYPE * sdata,
-			      gnutls_datum * raw)
+			      gnutls_datum_t * raw)
 {
     char oid[128];
     ASN1_TYPE c2;
@@ -129,7 +129,7 @@ int _decode_pkcs7_signed_data(ASN1_TYPE pkcs7, ASN1_TYPE * sdata,
 }
 
 /**
-  * gnutls_pkcs7_init - This function initializes a gnutls_pkcs7 structure
+  * gnutls_pkcs7_init - This function initializes a gnutls_pkcs7_t structure
   * @pkcs7: The structure to be initialized
   *
   * This function will initialize a PKCS7 structure. PKCS7 structures
@@ -139,7 +139,7 @@ int _decode_pkcs7_signed_data(ASN1_TYPE pkcs7, ASN1_TYPE * sdata,
   * Returns 0 on success.
   *
   **/
-int gnutls_pkcs7_init(gnutls_pkcs7 * pkcs7)
+int gnutls_pkcs7_init(gnutls_pkcs7_t * pkcs7)
 {
     *pkcs7 = gnutls_calloc(1, sizeof(gnutls_pkcs7_int));
 
@@ -158,13 +158,13 @@ int gnutls_pkcs7_init(gnutls_pkcs7 * pkcs7)
 }
 
 /**
-  * gnutls_pkcs7_deinit - This function deinitializes memory used by a gnutls_pkcs7 structure
+  * gnutls_pkcs7_deinit - This function deinitializes memory used by a gnutls_pkcs7_t structure
   * @pkcs7: The structure to be initialized
   *
   * This function will deinitialize a PKCS7 structure. 
   *
   **/
-void gnutls_pkcs7_deinit(gnutls_pkcs7 pkcs7)
+void gnutls_pkcs7_deinit(gnutls_pkcs7_t pkcs7)
 {
     if (!pkcs7)
 	return;
@@ -182,18 +182,18 @@ void gnutls_pkcs7_deinit(gnutls_pkcs7 pkcs7)
   * @format: One of DER or PEM
   *
   * This function will convert the given DER or PEM encoded PKCS7
-  * to the native gnutls_pkcs7 format. The output will be stored in 'pkcs7'.
+  * to the native gnutls_pkcs7_t format. The output will be stored in 'pkcs7'.
   *
   * If the PKCS7 is PEM encoded it should have a header of "PKCS7".
   *
   * Returns 0 on success.
   *
   **/
-int gnutls_pkcs7_import(gnutls_pkcs7 pkcs7, const gnutls_datum * data,
-			gnutls_x509_crt_fmt format)
+int gnutls_pkcs7_import(gnutls_pkcs7_t pkcs7, const gnutls_datum_t * data,
+			gnutls_x509_crt_fmt_t format)
 {
     int result = 0, need_free = 0;
-    gnutls_datum _data;
+    gnutls_datum_t _data;
 
     if (pkcs7 == NULL)
 	return GNUTLS_E_INVALID_REQUEST;
@@ -244,7 +244,7 @@ int gnutls_pkcs7_import(gnutls_pkcs7 pkcs7, const gnutls_datum * data,
 
 /**
   * gnutls_pkcs7_get_crt_raw - This function returns a certificate in a PKCS7 certificate set
-  * @pkcs7_struct: should contain a gnutls_pkcs7 structure
+  * @pkcs7_struct: should contain a gnutls_pkcs7_t structure
   * @indx: contains the index of the certificate to extract
   * @certificate: the contents of the certificate will be copied there (may be null)
   * @certificate_size: should hold the size of the certificate
@@ -257,7 +257,7 @@ int gnutls_pkcs7_import(gnutls_pkcs7 pkcs7, const gnutls_datum * data,
   * will be returned.
   *
   **/
-int gnutls_pkcs7_get_crt_raw(gnutls_pkcs7 pkcs7,
+int gnutls_pkcs7_get_crt_raw(gnutls_pkcs7_t pkcs7,
 			     int indx, void *certificate,
 			     size_t * certificate_size)
 {
@@ -266,7 +266,7 @@ int gnutls_pkcs7_get_crt_raw(gnutls_pkcs7 pkcs7,
     char root2[64];
     char oid[128];
     char counter[MAX_INT_DIGITS];
-    gnutls_datum tmp = { NULL, 0 };
+    gnutls_datum_t tmp = { NULL, 0 };
 
     if (certificate_size == NULL || pkcs7 == NULL)
 	return GNUTLS_E_INVALID_REQUEST;
@@ -343,7 +343,7 @@ int gnutls_pkcs7_get_crt_raw(gnutls_pkcs7 pkcs7,
 
 /**
   * gnutls_pkcs7_get_crt_count - This function returns the number of certificates in a PKCS7 certificate set
-  * @pkcs7_struct: should contain a gnutls_pkcs7 structure
+  * @pkcs7_struct: should contain a gnutls_pkcs7_t structure
   *
   * This function will return the number of certifcates in the PKCS7 or 
   * RFC2630 certificate set.
@@ -351,7 +351,7 @@ int gnutls_pkcs7_get_crt_raw(gnutls_pkcs7 pkcs7,
   * Returns a negative value on failure.
   *
   **/
-int gnutls_pkcs7_get_crt_count(gnutls_pkcs7 pkcs7)
+int gnutls_pkcs7_get_crt_count(gnutls_pkcs7_t pkcs7)
 {
     ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
     int result, count;
@@ -401,8 +401,8 @@ int gnutls_pkcs7_get_crt_count(gnutls_pkcs7 pkcs7)
   * 0 on success.
   *
   **/
-int gnutls_pkcs7_export(gnutls_pkcs7 pkcs7,
-			gnutls_x509_crt_fmt format, void *output_data,
+int gnutls_pkcs7_export(gnutls_pkcs7_t pkcs7,
+			gnutls_x509_crt_fmt_t format, void *output_data,
 			size_t * output_data_size)
 {
     if (pkcs7 == NULL)
@@ -489,14 +489,14 @@ static int create_empty_signed_data(ASN1_TYPE pkcs7, ASN1_TYPE * sdata)
 
 /**
   * gnutls_pkcs7_set_crt_raw - This function adds a certificate in a PKCS7 certificate set
-  * @pkcs7_struct: should contain a gnutls_pkcs7 structure
+  * @pkcs7_struct: should contain a gnutls_pkcs7_t structure
   * @crt: the DER encoded certificate to be added
   *
   * This function will add a certificate to the PKCS7 or RFC2630 certificate set.
   * Returns 0 on success.
   *
   **/
-int gnutls_pkcs7_set_crt_raw(gnutls_pkcs7 pkcs7, const gnutls_datum * crt)
+int gnutls_pkcs7_set_crt_raw(gnutls_pkcs7_t pkcs7, const gnutls_datum_t * crt)
 {
     ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
     int result;
@@ -574,7 +574,7 @@ int gnutls_pkcs7_set_crt_raw(gnutls_pkcs7 pkcs7, const gnutls_datum * crt)
 
 /**
   * gnutls_pkcs7_set_crt - This function adds a parsed certificate in a PKCS7 certificate set
-  * @pkcs7_struct: should contain a gnutls_pkcs7 structure
+  * @pkcs7_struct: should contain a gnutls_pkcs7_t structure
   * @crt: the certificate to be copied.
   *
   * This function will add a parsed certificate to the PKCS7 or RFC2630 certificate set.
@@ -583,10 +583,10 @@ int gnutls_pkcs7_set_crt_raw(gnutls_pkcs7 pkcs7, const gnutls_datum * crt)
   * Returns 0 on success.
   *
   **/
-int gnutls_pkcs7_set_crt(gnutls_pkcs7 pkcs7, gnutls_x509_crt crt)
+int gnutls_pkcs7_set_crt(gnutls_pkcs7_t pkcs7, gnutls_x509_crt_t crt)
 {
     int ret;
-    gnutls_datum data;
+    gnutls_datum_t data;
 
     if (pkcs7 == NULL)
 	return GNUTLS_E_INVALID_REQUEST;
@@ -612,14 +612,14 @@ int gnutls_pkcs7_set_crt(gnutls_pkcs7 pkcs7, gnutls_x509_crt crt)
 
 /**
   * gnutls_pkcs7_delete_crt - This function deletes a certificate from a PKCS7 certificate set
-  * @pkcs7_struct: should contain a gnutls_pkcs7 structure
+  * @pkcs7_struct: should contain a gnutls_pkcs7_t structure
   * @indx: the index of the certificate to delete
   *
   * This function will delete a certificate from a PKCS7 or RFC2630 certificate set.
   * Index starts from 0. Returns 0 on success.
   *
   **/
-int gnutls_pkcs7_delete_crt(gnutls_pkcs7 pkcs7, int indx)
+int gnutls_pkcs7_delete_crt(gnutls_pkcs7_t pkcs7, int indx)
 {
     ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
     int result;
@@ -676,7 +676,7 @@ int gnutls_pkcs7_delete_crt(gnutls_pkcs7 pkcs7, int indx)
 
 /**
   * gnutls_pkcs7_get_crl_raw - This function returns a crl in a PKCS7 crl set
-  * @pkcs7_struct: should contain a gnutls_pkcs7 structure
+  * @pkcs7_struct: should contain a gnutls_pkcs7_t structure
   * @indx: contains the index of the crl to extract
   * @crl: the contents of the crl will be copied there (may be null)
   * @crl_size: should hold the size of the crl
@@ -689,14 +689,14 @@ int gnutls_pkcs7_delete_crt(gnutls_pkcs7 pkcs7, int indx)
   * will be returned.
   *
   **/
-int gnutls_pkcs7_get_crl_raw(gnutls_pkcs7 pkcs7,
+int gnutls_pkcs7_get_crl_raw(gnutls_pkcs7_t pkcs7,
 			     int indx, void *crl, size_t * crl_size)
 {
     ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
     int result;
     char root2[64];
     char counter[MAX_INT_DIGITS];
-    gnutls_datum tmp = { NULL, 0 };
+    gnutls_datum_t tmp = { NULL, 0 };
     int start, end;
 
     if (pkcs7 == NULL || crl_size == NULL)
@@ -753,7 +753,7 @@ int gnutls_pkcs7_get_crl_raw(gnutls_pkcs7 pkcs7,
 
 /**
   * gnutls_pkcs7_get_crl_count - This function returns the number of crls in a PKCS7 crl set
-  * @pkcs7_struct: should contain a gnutls_pkcs7 structure
+  * @pkcs7_struct: should contain a gnutls_pkcs7_t structure
   *
   * This function will return the number of certifcates in the PKCS7 or 
   * RFC2630 crl set.
@@ -761,7 +761,7 @@ int gnutls_pkcs7_get_crl_raw(gnutls_pkcs7 pkcs7,
   * Returns a negative value on failure.
   *
   **/
-int gnutls_pkcs7_get_crl_count(gnutls_pkcs7 pkcs7)
+int gnutls_pkcs7_get_crl_count(gnutls_pkcs7_t pkcs7)
 {
     ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
     int result, count;
@@ -794,14 +794,14 @@ int gnutls_pkcs7_get_crl_count(gnutls_pkcs7 pkcs7)
 
 /**
   * gnutls_pkcs7_set_crl_raw - This function adds a crl in a PKCS7 crl set
-  * @pkcs7_struct: should contain a gnutls_pkcs7 structure
+  * @pkcs7_struct: should contain a gnutls_pkcs7_t structure
   * @crl: the DER encoded crl to be added
   *
   * This function will add a crl to the PKCS7 or RFC2630 crl set.
   * Returns 0 on success.
   *
   **/
-int gnutls_pkcs7_set_crl_raw(gnutls_pkcs7 pkcs7, const gnutls_datum * crl)
+int gnutls_pkcs7_set_crl_raw(gnutls_pkcs7_t pkcs7, const gnutls_datum_t * crl)
 {
     ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
     int result;
@@ -870,17 +870,17 @@ int gnutls_pkcs7_set_crl_raw(gnutls_pkcs7 pkcs7, const gnutls_datum * crl)
 
 /**
   * gnutls_pkcs7_set_crl - This function adds a parsed crl in a PKCS7 crl set
-  * @pkcs7_struct: should contain a gnutls_pkcs7 structure
+  * @pkcs7_struct: should contain a gnutls_pkcs7_t structure
   * @crl: the DER encoded crl to be added
   *
   * This function will add a parsed crl to the PKCS7 or RFC2630 crl set.
   * Returns 0 on success.
   *
   **/
-int gnutls_pkcs7_set_crl(gnutls_pkcs7 pkcs7, gnutls_x509_crl crl)
+int gnutls_pkcs7_set_crl(gnutls_pkcs7_t pkcs7, gnutls_x509_crl_t crl)
 {
     int ret;
-    gnutls_datum data;
+    gnutls_datum_t data;
 
     if (pkcs7 == NULL)
 	return GNUTLS_E_INVALID_REQUEST;
@@ -905,14 +905,14 @@ int gnutls_pkcs7_set_crl(gnutls_pkcs7 pkcs7, gnutls_x509_crl crl)
 
 /**
   * gnutls_pkcs7_delete_crl - This function deletes a crl from a PKCS7 crl set
-  * @pkcs7_struct: should contain a gnutls_pkcs7 structure
+  * @pkcs7_struct: should contain a gnutls_pkcs7_t structure
   * @indx: the index of the crl to delete
   *
   * This function will delete a crl from a PKCS7 or RFC2630 crl set.
   * Index starts from 0. Returns 0 on success.
   *
   **/
-int gnutls_pkcs7_delete_crl(gnutls_pkcs7 pkcs7, int indx)
+int gnutls_pkcs7_delete_crl(gnutls_pkcs7_t pkcs7, int indx)
 {
     ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
     int result;
diff --git a/lib/x509/pkcs7.h b/lib/x509/pkcs7.h
index 64a8f4b7d1..c3d6757ab8 100644
--- a/lib/x509/pkcs7.h
+++ b/lib/x509/pkcs7.h
@@ -3,12 +3,12 @@ typedef struct gnutls_pkcs7_int {
 	ASN1_TYPE pkcs7;
 } gnutls_pkcs7_int;
 
-typedef struct gnutls_pkcs7_int *gnutls_pkcs7;
+typedef struct gnutls_pkcs7_int *gnutls_pkcs7_t;
 
-int gnutls_pkcs7_init(gnutls_pkcs7 * pkcs7);
-void gnutls_pkcs7_deinit(gnutls_pkcs7 pkcs7);
-int gnutls_pkcs7_import(gnutls_pkcs7 pkcs7, const gnutls_datum * data,
-	gnutls_x509_crt_fmt format);
-int gnutls_pkcs7_get_crt_raw(gnutls_pkcs7 pkcs7, 
+int gnutls_pkcs7_init(gnutls_pkcs7_t * pkcs7);
+void gnutls_pkcs7_deinit(gnutls_pkcs7_t pkcs7);
+int gnutls_pkcs7_import(gnutls_pkcs7_t pkcs7, const gnutls_datum_t * data,
+	gnutls_x509_crt_fmt_t format);
+int gnutls_pkcs7_get_crt_raw(gnutls_pkcs7_t pkcs7, 
 	int indx, void* certificate, size_t* certificate_size);
-int gnutls_pkcs7_get_crt_count(gnutls_pkcs7 pkcs7);
+int gnutls_pkcs7_get_crt_count(gnutls_pkcs7_t pkcs7);
diff --git a/lib/x509/privkey.c b/lib/x509/privkey.c
index 73d7d69863..ce0f8a2f56 100644
--- a/lib/x509/privkey.c
+++ b/lib/x509/privkey.c
@@ -48,7 +48,7 @@ static int _encode_dsa(ASN1_TYPE * c2, mpi_t * params);
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_privkey_init(gnutls_x509_privkey * key)
+int gnutls_x509_privkey_init(gnutls_x509_privkey_t * key)
 {
     *key = gnutls_calloc(1, sizeof(gnutls_x509_privkey_int));
 
@@ -62,13 +62,13 @@ int gnutls_x509_privkey_init(gnutls_x509_privkey * key)
 }
 
 /**
-  * gnutls_x509_privkey_deinit - This function deinitializes memory used by a gnutls_x509_privkey structure
+  * gnutls_x509_privkey_deinit - This function deinitializes memory used by a gnutls_x509_privkey_t structure
   * @key: The structure to be initialized
   *
   * This function will deinitialize a private key structure. 
   *
   **/
-void gnutls_x509_privkey_deinit(gnutls_x509_privkey key)
+void gnutls_x509_privkey_deinit(gnutls_x509_privkey_t key)
 {
     int i;
 
@@ -91,8 +91,8 @@ void gnutls_x509_privkey_deinit(gnutls_x509_privkey key)
   * This function will copy a private key from source to destination key.
   *
   **/
-int gnutls_x509_privkey_cpy(gnutls_x509_privkey dst,
-			    gnutls_x509_privkey src)
+int gnutls_x509_privkey_cpy(gnutls_x509_privkey_t dst,
+			    gnutls_x509_privkey_t src)
 {
     int i, ret;
 
@@ -137,9 +137,9 @@ int gnutls_x509_privkey_cpy(gnutls_x509_privkey dst,
 /* Converts an RSA PKCS#1 key to
  * an internal structure (gnutls_private_key)
  */
-ASN1_TYPE _gnutls_privkey_decode_pkcs1_rsa_key(const gnutls_datum *
+ASN1_TYPE _gnutls_privkey_decode_pkcs1_rsa_key(const gnutls_datum_t *
 					       raw_key,
-					       gnutls_x509_privkey pkey)
+					       gnutls_x509_privkey_t pkey)
 {
     int result;
     ASN1_TYPE pkey_asn;
@@ -233,8 +233,8 @@ ASN1_TYPE _gnutls_privkey_decode_pkcs1_rsa_key(const gnutls_datum *
 
 }
 
-static ASN1_TYPE decode_dsa_key(const gnutls_datum * raw_key,
-				gnutls_x509_privkey pkey)
+static ASN1_TYPE decode_dsa_key(const gnutls_datum_t * raw_key,
+				gnutls_x509_privkey_t pkey)
 {
     int result;
     ASN1_TYPE dsa_asn;
@@ -315,7 +315,7 @@ static ASN1_TYPE decode_dsa_key(const gnutls_datum * raw_key,
   * @format: One of DER or PEM
   *
   * This function will convert the given DER or PEM encoded key
-  * to the native gnutls_x509_privkey format. The output will be stored in @key .
+  * to the native gnutls_x509_privkey_t format. The output will be stored in @key .
   *
   * If the key is PEM encoded it should have a header of "RSA PRIVATE KEY", or
   * "DSA PRIVATE KEY".
@@ -323,12 +323,12 @@ static ASN1_TYPE decode_dsa_key(const gnutls_datum * raw_key,
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_privkey_import(gnutls_x509_privkey key,
-			       const gnutls_datum * data,
-			       gnutls_x509_crt_fmt format)
+int gnutls_x509_privkey_import(gnutls_x509_privkey_t key,
+			       const gnutls_datum_t * data,
+			       gnutls_x509_crt_fmt_t format)
 {
     int result = 0, need_free = 0;
-    gnutls_datum _data;
+    gnutls_datum_t _data;
 
     if (key == NULL) {
 	gnutls_assert();
@@ -435,16 +435,16 @@ int gnutls_x509_privkey_import(gnutls_x509_privkey key,
   * @u: holds the coefficient
   *
   * This function will convert the given RSA raw parameters
-  * to the native gnutls_x509_privkey format. The output will be stored in @key.
+  * to the native gnutls_x509_privkey_t format. The output will be stored in @key.
   * 
   **/
-int gnutls_x509_privkey_import_rsa_raw(gnutls_x509_privkey key,
-				       const gnutls_datum * m,
-				       const gnutls_datum * e,
-				       const gnutls_datum * d,
-				       const gnutls_datum * p,
-				       const gnutls_datum * q,
-				       const gnutls_datum * u)
+int gnutls_x509_privkey_import_rsa_raw(gnutls_x509_privkey_t key,
+				       const gnutls_datum_t * m,
+				       const gnutls_datum_t * e,
+				       const gnutls_datum_t * d,
+				       const gnutls_datum_t * p,
+				       const gnutls_datum_t * q,
+				       const gnutls_datum_t * u)
 {
     int i = 0, ret;
     size_t siz = 0;
@@ -522,15 +522,15 @@ int gnutls_x509_privkey_import_rsa_raw(gnutls_x509_privkey key,
   * @x: holds the x
   *
   * This function will convert the given DSA raw parameters
-  * to the native gnutls_x509_privkey format. The output will be stored in @key.
+  * to the native gnutls_x509_privkey_t format. The output will be stored in @key.
   * 
   **/
-int gnutls_x509_privkey_import_dsa_raw(gnutls_x509_privkey key,
-				       const gnutls_datum * p,
-				       const gnutls_datum * q,
-				       const gnutls_datum * g,
-				       const gnutls_datum * y,
-				       const gnutls_datum * x)
+int gnutls_x509_privkey_import_dsa_raw(gnutls_x509_privkey_t key,
+				       const gnutls_datum_t * p,
+				       const gnutls_datum_t * q,
+				       const gnutls_datum_t * g,
+				       const gnutls_datum_t * y,
+				       const gnutls_datum_t * x)
 {
     int i = 0, ret;
     size_t siz = 0;
@@ -594,16 +594,16 @@ int gnutls_x509_privkey_import_dsa_raw(gnutls_x509_privkey key,
 
 /**
   * gnutls_x509_privkey_get_pk_algorithm - This function returns the key's PublicKey algorithm
-  * @key: should contain a gnutls_x509_privkey structure
+  * @key: should contain a gnutls_x509_privkey_t structure
   *
   * This function will return the public key algorithm of a private
   * key.
   *
-  * Returns a member of the gnutls_pk_algorithm enumeration on success,
+  * Returns a member of the gnutls_pk_algorithm_t enumeration on success,
   * or a negative value on error.
   *
   **/
-int gnutls_x509_privkey_get_pk_algorithm(gnutls_x509_privkey key)
+int gnutls_x509_privkey_get_pk_algorithm(gnutls_x509_privkey_t key)
 {
     if (key == NULL) {
 	gnutls_assert();
@@ -635,8 +635,8 @@ int gnutls_x509_privkey_get_pk_algorithm(gnutls_x509_privkey key)
   * 0 on success.
   *
   **/
-int gnutls_x509_privkey_export(gnutls_x509_privkey key,
-			       gnutls_x509_crt_fmt format,
+int gnutls_x509_privkey_export(gnutls_x509_privkey_t key,
+			       gnutls_x509_crt_fmt_t format,
 			       void *output_data,
 			       size_t * output_data_size)
 {
@@ -698,10 +698,10 @@ int gnutls_x509_privkey_export(gnutls_x509_privkey key,
   * gnutls_malloc() and will be stored in the appropriate datum.
   * 
   **/
-int gnutls_x509_privkey_export_rsa_raw(gnutls_x509_privkey key,
-				       gnutls_datum * m, gnutls_datum * e,
-				       gnutls_datum * d, gnutls_datum * p,
-				       gnutls_datum * q, gnutls_datum * u)
+int gnutls_x509_privkey_export_rsa_raw(gnutls_x509_privkey_t key,
+				       gnutls_datum_t * m, gnutls_datum_t * e,
+				       gnutls_datum_t * d, gnutls_datum_t * p,
+				       gnutls_datum_t * q, gnutls_datum_t * u)
 {
     int ret;
 
@@ -783,10 +783,10 @@ int gnutls_x509_privkey_export_rsa_raw(gnutls_x509_privkey key,
   * gnutls_malloc() and will be stored in the appropriate datum.
   * 
   **/
-int gnutls_x509_privkey_export_dsa_raw(gnutls_x509_privkey key,
-				       gnutls_datum * p, gnutls_datum * q,
-				       gnutls_datum * g, gnutls_datum * y,
-				       gnutls_datum * x)
+int gnutls_x509_privkey_export_dsa_raw(gnutls_x509_privkey_t key,
+				       gnutls_datum_t * p, gnutls_datum_t * q,
+				       gnutls_datum_t * g, gnutls_datum_t * y,
+				       gnutls_datum_t * x)
 {
     int ret;
 
@@ -1156,7 +1156,7 @@ static int _encode_dsa(ASN1_TYPE * c2, mpi_t * params)
 
 /**
   * gnutls_x509_privkey_generate - This function will generate a private key
-  * @key: should contain a gnutls_x509_privkey structure
+  * @key: should contain a gnutls_x509_privkey_t structure
   * @algo: is one of RSA or DSA.
   * @bits: the size of the modulus
   * @flags: unused for now. Must be 0.
@@ -1167,8 +1167,8 @@ static int _encode_dsa(ASN1_TYPE * c2, mpi_t * params)
   * Returns 0 on success or a negative value on error.
   *
   **/
-int gnutls_x509_privkey_generate(gnutls_x509_privkey key,
-				 gnutls_pk_algorithm algo,
+int gnutls_x509_privkey_generate(gnutls_x509_privkey_t key,
+				 gnutls_pk_algorithm_t algo,
 				 unsigned int bits, unsigned int flags)
 {
     int ret, params_len;
@@ -1252,14 +1252,14 @@ int gnutls_x509_privkey_generate(gnutls_x509_privkey key,
   * 0 on success.
   *
   **/
-int gnutls_x509_privkey_get_key_id(gnutls_x509_privkey key,
+int gnutls_x509_privkey_get_key_id(gnutls_x509_privkey_t key,
 				   unsigned int flags,
 				   unsigned char *output_data,
 				   size_t * output_data_size)
 {
     int result;
     GNUTLS_HASH_HANDLE hd;
-    gnutls_datum der = { NULL, 0 };
+    gnutls_datum_t der = { NULL, 0 };
 
     if (key == NULL || key->crippled) {
 	gnutls_assert();
@@ -1334,14 +1334,14 @@ int gnutls_x509_privkey_get_key_id(gnutls_x509_privkey key,
   * 0 on success.
   *
   **/
-int gnutls_x509_privkey_sign_data(gnutls_x509_privkey key,
-				  gnutls_digest_algorithm digest,
+int gnutls_x509_privkey_sign_data(gnutls_x509_privkey_t key,
+				  gnutls_digest_algorithm_t digest,
 				  unsigned int flags,
-				  const gnutls_datum * data,
+				  const gnutls_datum_t * data,
 				  void *signature, size_t * signature_size)
 {
     int result;
-    gnutls_datum sig = { NULL, 0 };
+    gnutls_datum_t sig = { NULL, 0 };
 
     if (key == NULL) {
 	gnutls_assert();
@@ -1382,10 +1382,10 @@ int gnutls_x509_privkey_sign_data(gnutls_x509_privkey key,
   * 1 on success.
   *
   **/
-int gnutls_x509_privkey_verify_data(gnutls_x509_privkey key,
+int gnutls_x509_privkey_verify_data(gnutls_x509_privkey_t key,
 				    unsigned int flags,
-				    const gnutls_datum * data,
-				    const gnutls_datum * signature)
+				    const gnutls_datum_t * data,
+				    const gnutls_datum_t * signature)
 {
     int result;
 
diff --git a/lib/x509/privkey.h b/lib/x509/privkey.h
index b667326047..a0f0939a05 100644
--- a/lib/x509/privkey.h
+++ b/lib/x509/privkey.h
@@ -1,4 +1,4 @@
-typedef enum gnutls_pkcs_encrypt_flags {
+typedef enum gnutls_pkcs_encrypt_flags_t {
 	GNUTLS_PKCS_PLAIN=1,  /* if set the private key will not
 			        * be encrypted.
 				*/
@@ -6,10 +6,10 @@ typedef enum gnutls_pkcs_encrypt_flags {
 	GNUTLS_PKCS_USE_PKCS12_ARCFOUR=4,
 	GNUTLS_PKCS_USE_PKCS12_RC2_40=8,
 	GNUTLS_PKCS_USE_PBES2_3DES=16
-} gnutls_pkcs_encrypt_flags;
+} gnutls_pkcs_encrypt_flags_t;
 
-int gnutls_x509_privkey_import(gnutls_x509_privkey key, const gnutls_datum * data,
-	gnutls_x509_crt_fmt format);
-ASN1_TYPE _gnutls_privkey_decode_pkcs1_rsa_key( const gnutls_datum *raw_key,
-        gnutls_x509_privkey pkey);
-int gnutls_x509_privkey_cpy(gnutls_x509_privkey dst, gnutls_x509_privkey src);
+int gnutls_x509_privkey_import(gnutls_x509_privkey_t key, const gnutls_datum_t * data,
+	gnutls_x509_crt_fmt_t format);
+ASN1_TYPE _gnutls_privkey_decode_pkcs1_rsa_key( const gnutls_datum_t *raw_key,
+        gnutls_x509_privkey_t pkey);
+int gnutls_x509_privkey_cpy(gnutls_x509_privkey_t dst, gnutls_x509_privkey_t src);
diff --git a/lib/x509/privkey_pkcs8.c b/lib/x509/privkey_pkcs8.c
index c0fe3fd663..c83054a4de 100644
--- a/lib/x509/privkey_pkcs8.c
+++ b/lib/x509/privkey_pkcs8.c
@@ -61,7 +61,7 @@ struct pbkdf2_params {
 };
 
 struct pbe_enc_params {
-    gnutls_cipher_algorithm cipher;
+    gnutls_cipher_algorithm_t cipher;
     opaque iv[8];
     int iv_size;
 };
@@ -69,28 +69,28 @@ struct pbe_enc_params {
 static int generate_key(schema_id schema, const char *password,
 			struct pbkdf2_params *kdf_params,
 			struct pbe_enc_params *enc_params,
-			gnutls_datum * key);
+			gnutls_datum_t * key);
 static int read_pbkdf2_params(ASN1_TYPE pbes2_asn,
-			      const gnutls_datum * der,
+			      const gnutls_datum_t * der,
 			      struct pbkdf2_params *params);
 static int read_pbe_enc_params(ASN1_TYPE pbes2_asn,
-			       const gnutls_datum * der,
+			       const gnutls_datum_t * der,
 			       struct pbe_enc_params *params);
 static int decrypt_data(schema_id, ASN1_TYPE pkcs8_asn, const char *root,
 			const char *password,
 			const struct pbkdf2_params *kdf_params,
 			const struct pbe_enc_params *enc_params,
-			gnutls_datum * decrypted_data);
-static int decode_private_key_info(const gnutls_datum * der,
-				   gnutls_x509_privkey pkey,
+			gnutls_datum_t * decrypted_data);
+static int decode_private_key_info(const gnutls_datum_t * der,
+				   gnutls_x509_privkey_t pkey,
 				   ASN1_TYPE * out);
 static int write_schema_params(schema_id schema, ASN1_TYPE pkcs8_asn,
 			       const char *where,
 			       const struct pbkdf2_params *kdf_params,
 			       const struct pbe_enc_params *enc_params);
-static int encrypt_data(const gnutls_datum * plain,
+static int encrypt_data(const gnutls_datum_t * plain,
 			const struct pbe_enc_params *enc_params,
-			gnutls_datum * key, gnutls_datum * encrypted);
+			gnutls_datum_t * key, gnutls_datum_t * encrypted);
 
 static int read_pkcs12_kdf_params(ASN1_TYPE pbes2_asn,
 				  struct pbkdf2_params *params);
@@ -129,8 +129,8 @@ inline static int check_schema(const char *oid)
  * info. The output will be allocated and stored into der. Also
  * the ASN1_TYPE of private key info will be returned.
  */
-static int encode_to_private_key_info(gnutls_x509_privkey pkey,
-				      gnutls_datum * der,
+static int encode_to_private_key_info(gnutls_x509_privkey_t pkey,
+				      gnutls_datum_t * der,
 				      ASN1_TYPE * pkey_info)
 {
     int result;
@@ -268,12 +268,12 @@ static int encode_to_private_key_info(gnutls_x509_privkey pkey,
  * a PKCS #8 EncryptedPrivateKeyInfo.
  */
 static
-int encode_to_pkcs8_key(schema_id schema, const gnutls_datum * der_key,
+int encode_to_pkcs8_key(schema_id schema, const gnutls_datum_t * der_key,
 			const char *password, ASN1_TYPE * out)
 {
     int result;
-    gnutls_datum key = { NULL, 0 };
-    gnutls_datum tmp = { NULL, 0 };
+    gnutls_datum_t key = { NULL, 0 };
+    gnutls_datum_t tmp = { NULL, 0 };
     ASN1_TYPE pkcs8_asn = ASN1_TYPE_EMPTY;
     struct pbkdf2_params kdf_params;
     struct pbe_enc_params enc_params;
@@ -378,7 +378,7 @@ int encode_to_pkcs8_key(schema_id schema, const gnutls_datum * der_key,
   * @key: Holds the key
   * @format: the format of output params. One of PEM or DER.
   * @password: the password that will be used to encrypt the key. 
-  * @flags: an ORed sequence of gnutls_pkcs_encrypt_flags
+  * @flags: an ORed sequence of gnutls_pkcs_encrypt_flags_t
   * @output_data: will contain a private key PEM or DER encoded
   * @output_data_size: holds the size of output_data (and will be replaced by the actual size of parameters)
   *
@@ -401,8 +401,8 @@ int encode_to_pkcs8_key(schema_id schema, const gnutls_datum * der_key,
   * 0 on success.
   *
   **/
-int gnutls_x509_privkey_export_pkcs8(gnutls_x509_privkey key,
-				     gnutls_x509_crt_fmt format,
+int gnutls_x509_privkey_export_pkcs8(gnutls_x509_privkey_t key,
+				     gnutls_x509_crt_fmt_t format,
 				     const char *password,
 				     unsigned int flags,
 				     void *output_data,
@@ -410,7 +410,7 @@ int gnutls_x509_privkey_export_pkcs8(gnutls_x509_privkey key,
 {
     ASN1_TYPE pkcs8_asn, pkey_info;
     int ret;
-    gnutls_datum tmp;
+    gnutls_datum_t tmp;
     schema_id schema;
 
     if (key == NULL) {
@@ -481,7 +481,7 @@ int read_pkcs_schema_params(schema_id schema, const char *password,
 {
     ASN1_TYPE pbes2_asn = ASN1_TYPE_EMPTY;
     int result;
-    gnutls_datum tmp;
+    gnutls_datum_t tmp;
 
     switch (schema) {
 
@@ -601,13 +601,13 @@ int read_pkcs_schema_params(schema_id schema, const char *password,
  * (normally a PKCS #1 encoded RSA key)
  */
 static
-int decode_pkcs8_key(const gnutls_datum * raw_key,
+int decode_pkcs8_key(const gnutls_datum_t * raw_key,
 		     const char *password,
-		     gnutls_x509_privkey pkey, ASN1_TYPE * out)
+		     gnutls_x509_privkey_t pkey, ASN1_TYPE * out)
 {
     int result, len;
     char enc_oid[64];
-    gnutls_datum tmp;
+    gnutls_datum_t tmp;
     ASN1_TYPE pbes2_asn = ASN1_TYPE_EMPTY, pkcs8_asn = ASN1_TYPE_EMPTY;
     ASN1_TYPE ret_asn;
     int params_start, params_end, params_len;
@@ -702,12 +702,12 @@ int decode_pkcs8_key(const gnutls_datum * raw_key,
 }
 
 static
-int decode_private_key_info(const gnutls_datum * der,
-			    gnutls_x509_privkey pkey, ASN1_TYPE * out)
+int decode_private_key_info(const gnutls_datum_t * der,
+			    gnutls_x509_privkey_t pkey, ASN1_TYPE * out)
 {
     int result, len;
     opaque oid[64], *data = NULL;
-    gnutls_datum tmp;
+    gnutls_datum_t tmp;
     ASN1_TYPE pkcs8_asn = ASN1_TYPE_EMPTY;
     ASN1_TYPE ret_asn;
     int data_size;
@@ -809,7 +809,7 @@ int decode_private_key_info(const gnutls_datum * der,
   * @flags: use 0.
   *
   * This function will convert the given DER or PEM encoded PKCS8 2.0 encrypted key
-  * to the native gnutls_x509_privkey format. The output will be stored in @key.
+  * to the native gnutls_x509_privkey_t format. The output will be stored in @key.
   * Currently only RSA keys can be imported, and flags can only be used to indicate
   * an unencrypted key.
   *
@@ -822,14 +822,14 @@ int decode_private_key_info(const gnutls_datum * der,
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_privkey_import_pkcs8(gnutls_x509_privkey key,
-				     const gnutls_datum * data,
-				     gnutls_x509_crt_fmt format,
+int gnutls_x509_privkey_import_pkcs8(gnutls_x509_privkey_t key,
+				     const gnutls_datum_t * data,
+				     gnutls_x509_crt_fmt_t format,
 				     const char *password,
 				     unsigned int flags)
 {
     int result = 0, need_free = 0;
-    gnutls_datum _data;
+    gnutls_datum_t _data;
     int encrypted;
 
     if (key == NULL) {
@@ -905,7 +905,7 @@ int gnutls_x509_privkey_import_pkcs8(gnutls_x509_privkey key,
 /* Reads the PBKDF2 parameters.
  */
 static int read_pbkdf2_params(ASN1_TYPE pbes2_asn,
-			      const gnutls_datum * der,
+			      const gnutls_datum_t * der,
 			      struct pbkdf2_params *params)
 {
     int params_start, params_end;
@@ -1089,7 +1089,7 @@ static int write_pkcs12_kdf_params(ASN1_TYPE pbes2_asn,
 /* Converts an OID to a gnutls cipher type.
  */
 inline
-    static int oid2cipher(const char *oid, gnutls_cipher_algorithm * algo)
+    static int oid2cipher(const char *oid, gnutls_cipher_algorithm_t * algo)
 {
 
     *algo = 0;
@@ -1110,7 +1110,7 @@ inline
 
 
 static int read_pbe_enc_params(ASN1_TYPE pbes2_asn,
-			       const gnutls_datum * der,
+			       const gnutls_datum_t * der,
 			       struct pbe_enc_params *params)
 {
     int params_start, params_end;
@@ -1188,12 +1188,12 @@ static int decrypt_data(schema_id schema, ASN1_TYPE pkcs8_asn,
 			const char *root, const char *password,
 			const struct pbkdf2_params *kdf_params,
 			const struct pbe_enc_params *enc_params,
-			gnutls_datum * decrypted_data)
+			gnutls_datum_t * decrypted_data)
 {
     int result;
     int data_size;
     opaque *data = NULL, *key = NULL;
-    gnutls_datum dkey, div;
+    gnutls_datum_t dkey, div;
     cipher_hd_t ch = NULL;
     int key_size;
 
@@ -1461,7 +1461,7 @@ static int generate_key(schema_id schema,
 			const char *password,
 			struct pbkdf2_params *kdf_params,
 			struct pbe_enc_params *enc_params,
-			gnutls_datum * key)
+			gnutls_datum_t * key)
 {
     opaque rnd[2];
     int ret;
@@ -1628,14 +1628,14 @@ static int write_schema_params(schema_id schema, ASN1_TYPE pkcs8_asn,
 
 }
 
-static int encrypt_data(const gnutls_datum * plain,
+static int encrypt_data(const gnutls_datum_t * plain,
 			const struct pbe_enc_params *enc_params,
-			gnutls_datum * key, gnutls_datum * encrypted)
+			gnutls_datum_t * key, gnutls_datum_t * encrypted)
 {
     int result;
     int data_size;
     opaque *data = NULL;
-    gnutls_datum div;
+    gnutls_datum_t div;
     cipher_hd_t ch = NULL;
     opaque pad, pad_size;
 
@@ -1695,12 +1695,12 @@ static int encrypt_data(const gnutls_datum * plain,
 /* Decrypts a PKCS #7 encryptedData. The output is allocated
  * and stored in dec.
  */
-int _gnutls_pkcs7_decrypt_data(const gnutls_datum * data,
-			       const char *password, gnutls_datum * dec)
+int _gnutls_pkcs7_decrypt_data(const gnutls_datum_t * data,
+			       const char *password, gnutls_datum_t * dec)
 {
     int result, len;
     char enc_oid[64];
-    gnutls_datum tmp;
+    gnutls_datum_t tmp;
     ASN1_TYPE pbes2_asn = ASN1_TYPE_EMPTY, pkcs7_asn = ASN1_TYPE_EMPTY;
     int params_start, params_end, params_len;
     struct pbkdf2_params kdf_params;
@@ -1793,12 +1793,12 @@ int _gnutls_pkcs7_decrypt_data(const gnutls_datum * data,
 /* Encrypts to a PKCS #7 encryptedData. The output is allocated
  * and stored in enc.
  */
-int _gnutls_pkcs7_encrypt_data(schema_id schema, const gnutls_datum * data,
-			       const char *password, gnutls_datum * enc)
+int _gnutls_pkcs7_encrypt_data(schema_id schema, const gnutls_datum_t * data,
+			       const char *password, gnutls_datum_t * enc)
 {
     int result;
-    gnutls_datum key = { NULL, 0 };
-    gnutls_datum tmp = { NULL, 0 };
+    gnutls_datum_t key = { NULL, 0 };
+    gnutls_datum_t tmp = { NULL, 0 };
     ASN1_TYPE pkcs7_asn = ASN1_TYPE_EMPTY;
     struct pbkdf2_params kdf_params;
     struct pbe_enc_params enc_params;
diff --git a/lib/x509/rfc2818_hostname.c b/lib/x509/rfc2818_hostname.c
index a1a7e1b82d..d5aa73bdec 100644
--- a/lib/x509/rfc2818_hostname.c
+++ b/lib/x509/rfc2818_hostname.c
@@ -68,7 +68,7 @@ int _gnutls_hostname_compare(const char *certname, const char *hostname)
 
 /**
   * gnutls_x509_crt_check_hostname - This function compares the given hostname with the hostname in the certificate
-  * @cert: should contain an gnutls_x509_crt structure
+  * @cert: should contain an gnutls_x509_crt_t structure
   * @hostname: A null terminated string that contains a DNS name
   *
   * This function will check if the given certificate's subject matches
@@ -79,7 +79,7 @@ int _gnutls_hostname_compare(const char *certname, const char *hostname)
   * Returns non zero on success, and zero on failure.
   *
   **/
-int gnutls_x509_crt_check_hostname(gnutls_x509_crt cert,
+int gnutls_x509_crt_check_hostname(gnutls_x509_crt_t cert,
 				   const char *hostname)
 {
 
diff --git a/lib/x509/sign.c b/lib/x509/sign.c
index 8586bd86b7..2cce692920 100644
--- a/lib/x509/sign.c
+++ b/lib/x509/sign.c
@@ -46,9 +46,9 @@
 /* Writes the digest information and the digest in a DER encoded
  * structure. The digest info is allocated and stored into the info structure.
  */
-static int encode_ber_digest_info(gnutls_mac_algorithm hash,
-				  const gnutls_datum * digest,
-				  gnutls_datum * info)
+static int encode_ber_digest_info(gnutls_mac_algorithm_t hash,
+				  const gnutls_datum_t * digest,
+				  gnutls_datum_t * info)
 {
     ASN1_TYPE dinfo = ASN1_TYPE_EMPTY;
     int result;
@@ -117,13 +117,13 @@ static int encode_ber_digest_info(gnutls_mac_algorithm hash,
  * params[1] is public key
  */
 static int
-pkcs1_rsa_sign(gnutls_mac_algorithm hash, const gnutls_datum * text,
-	       mpi_t * params, int params_len, gnutls_datum * signature)
+pkcs1_rsa_sign(gnutls_mac_algorithm_t hash, const gnutls_datum_t * text,
+	       mpi_t * params, int params_len, gnutls_datum_t * signature)
 {
     int ret;
     opaque _digest[MAX_HASH_SIZE];
     GNUTLS_HASH_HANDLE hd;
-    gnutls_datum digest, info;
+    gnutls_datum_t digest, info;
 
     hd = _gnutls_hash_init(hash);
     if (hd == NULL) {
@@ -158,13 +158,13 @@ pkcs1_rsa_sign(gnutls_mac_algorithm hash, const gnutls_datum * text,
 }
 
 static int
-dsa_sign(const gnutls_datum * text,
-	 mpi_t * params, int params_len, gnutls_datum * signature)
+dsa_sign(const gnutls_datum_t * text,
+	 mpi_t * params, int params_len, gnutls_datum_t * signature)
 {
     int ret;
     opaque _digest[MAX_HASH_SIZE];
     GNUTLS_HASH_HANDLE hd;
-    gnutls_datum digest;
+    gnutls_datum_t digest;
 
     hd = _gnutls_hash_init(GNUTLS_MAC_SHA);
     if (hd == NULL) {
@@ -197,8 +197,8 @@ dsa_sign(const gnutls_datum * text,
  * 'signature' will hold the signature!
  * 'hash' is only used in PKCS1 RSA signing.
  */
-int _gnutls_x509_sign(const gnutls_datum * tbs, gnutls_mac_algorithm hash,
-		      gnutls_x509_privkey signer, gnutls_datum * signature)
+int _gnutls_x509_sign(const gnutls_datum_t * tbs, gnutls_mac_algorithm_t hash,
+		      gnutls_x509_privkey_t signer, gnutls_datum_t * signature)
 {
     int ret;
 
@@ -235,14 +235,14 @@ int _gnutls_x509_sign(const gnutls_datum * tbs, gnutls_mac_algorithm hash,
  * of the TBS and sign it on the fly.
  */
 int _gnutls_x509_sign_tbs(ASN1_TYPE cert, const char *tbs_name,
-			  gnutls_mac_algorithm hash,
-			  gnutls_x509_privkey signer,
-			  gnutls_datum * signature)
+			  gnutls_mac_algorithm_t hash,
+			  gnutls_x509_privkey_t signer,
+			  gnutls_datum_t * signature)
 {
     int result;
     opaque *buf;
     int buf_size;
-    gnutls_datum tbs;
+    gnutls_datum_t tbs;
 
     buf_size = 0;
     asn1_der_coding(cert, tbs_name, NULL, &buf_size, NULL);
@@ -283,11 +283,11 @@ int _gnutls_x509_sign_tbs(ASN1_TYPE cert, const char *tbs_name,
   *
   -*/
 int _gnutls_x509_pkix_sign(ASN1_TYPE src, const char *src_name,
-			   gnutls_x509_crt issuer,
-			   gnutls_x509_privkey issuer_key)
+			   gnutls_x509_crt_t issuer,
+			   gnutls_x509_privkey_t issuer_key)
 {
     int result;
-    gnutls_datum signature;
+    gnutls_datum_t signature;
     char name[128];
 
     /* Step 1. Copy the issuer's name into the certificate.
diff --git a/lib/x509/sign.h b/lib/x509/sign.h
index 08e0475f72..6a9a385c78 100644
--- a/lib/x509/sign.h
+++ b/lib/x509/sign.h
@@ -1,6 +1,6 @@
-int _gnutls_x509_sign( const gnutls_datum* tbs, gnutls_mac_algorithm hash,
-	gnutls_x509_privkey signer, gnutls_datum* signature);
+int _gnutls_x509_sign( const gnutls_datum_t* tbs, gnutls_mac_algorithm_t hash,
+	gnutls_x509_privkey_t signer, gnutls_datum_t* signature);
 int _gnutls_x509_sign_tbs( ASN1_TYPE cert, const char* tbs_name,
-	gnutls_mac_algorithm hash, gnutls_x509_privkey signer, gnutls_datum* signature);
+	gnutls_mac_algorithm_t hash, gnutls_x509_privkey_t signer, gnutls_datum_t* signature);
 int _gnutls_x509_pkix_sign(ASN1_TYPE src, const char* src_name, 
-	gnutls_x509_crt issuer, gnutls_x509_privkey issuer_key);
+	gnutls_x509_crt_t issuer, gnutls_x509_privkey_t issuer_key);
diff --git a/lib/x509/verify.c b/lib/x509/verify.c
index 3eac6b2d91..daa301ada0 100644
--- a/lib/x509/verify.c
+++ b/lib/x509/verify.c
@@ -39,16 +39,16 @@
 #include <common.h>
 #include <verify.h>
 
-static int _gnutls_verify_certificate2(gnutls_x509_crt cert,
-    const gnutls_x509_crt * trusted_cas, int tcas_size, unsigned int flags,
+static int _gnutls_verify_certificate2(gnutls_x509_crt_t cert,
+    const gnutls_x509_crt_t * trusted_cas, int tcas_size, unsigned int flags,
     unsigned int *output);
-int _gnutls_x509_verify_signature(const gnutls_datum * signed_data,
-    const gnutls_datum * signature, gnutls_x509_crt issuer);
+int _gnutls_x509_verify_signature(const gnutls_datum_t * signed_data,
+    const gnutls_datum_t * signature, gnutls_x509_crt_t issuer);
 
 static
-int is_crl_issuer(gnutls_x509_crl crl, gnutls_x509_crt issuer_cert);
-static int _gnutls_verify_crl2(gnutls_x509_crl crl,
-    const gnutls_x509_crt * trusted_cas, int tcas_size, unsigned int flags,
+int is_crl_issuer(gnutls_x509_crl_t crl, gnutls_x509_crt_t issuer_cert);
+static int _gnutls_verify_crl2(gnutls_x509_crl_t crl,
+    const gnutls_x509_crt_t * trusted_cas, int tcas_size, unsigned int flags,
     unsigned int *output);
 
 
@@ -59,12 +59,12 @@ static int _gnutls_verify_crl2(gnutls_x509_crl crl,
  * Returns true or false, if the issuer is a CA,
  * or not.
  */
-static int check_if_ca(gnutls_x509_crt cert, gnutls_x509_crt issuer)
+static int check_if_ca(gnutls_x509_crt_t cert, gnutls_x509_crt_t issuer)
 {
-    gnutls_datum cert_signed_data = { NULL, 0 };
-    gnutls_datum issuer_signed_data = { NULL, 0 };
-    gnutls_datum cert_signature = { NULL, 0 };
-    gnutls_datum issuer_signature = { NULL, 0 };
+    gnutls_datum_t cert_signed_data = { NULL, 0 };
+    gnutls_datum_t issuer_signed_data = { NULL, 0 };
+    gnutls_datum_t cert_signature = { NULL, 0 };
+    gnutls_datum_t issuer_signature = { NULL, 0 };
     int result;
 
     /* Check if the issuer is the same with the
@@ -140,9 +140,9 @@ static int check_if_ca(gnutls_x509_crt cert, gnutls_x509_crt issuer)
  * a negative value is returned to indicate error.
  */
 static
-int is_issuer(gnutls_x509_crt cert, gnutls_x509_crt issuer_cert)
+int is_issuer(gnutls_x509_crt_t cert, gnutls_x509_crt_t issuer_cert)
 {
-    gnutls_datum dn1 = { NULL, 0 }, dn2 = {
+    gnutls_datum_t dn1 = { NULL, 0 }, dn2 = {
     NULL, 0};
     int ret;
 
@@ -169,8 +169,8 @@ int is_issuer(gnutls_x509_crt cert, gnutls_x509_crt issuer_cert)
 
 
 static inline
-    gnutls_x509_crt find_issuer(gnutls_x509_crt cert,
-				const gnutls_x509_crt * trusted_cas,
+    gnutls_x509_crt_t find_issuer(gnutls_x509_crt_t cert,
+				const gnutls_x509_crt_t * trusted_cas,
 				int tcas_size)
 {
     int i;
@@ -198,13 +198,13 @@ static inline
  * Output will hold some extra information about the verification
  * procedure.
  */
-static int _gnutls_verify_certificate2(gnutls_x509_crt cert,
-    const gnutls_x509_crt * trusted_cas,
+static int _gnutls_verify_certificate2(gnutls_x509_crt_t cert,
+    const gnutls_x509_crt_t * trusted_cas,
     int tcas_size, unsigned int flags, unsigned int *output)
 {
-    gnutls_datum cert_signed_data = { NULL, 0 };
-    gnutls_datum cert_signature = { NULL, 0 };
-    gnutls_x509_crt issuer;
+    gnutls_datum_t cert_signed_data = { NULL, 0 };
+    gnutls_datum_t cert_signature = { NULL, 0 };
+    gnutls_x509_crt_t issuer;
     int ret, issuer_version, result;
 
     if (output)
@@ -301,9 +301,9 @@ static int _gnutls_verify_certificate2(gnutls_x509_crt cert,
  */
 static
 unsigned int _gnutls_x509_verify_certificate(
-    const gnutls_x509_crt * certificate_list, int clist_size,
-    const gnutls_x509_crt * trusted_cas, int tcas_size,
-    const gnutls_x509_crl * CRLs, int crls_size,
+    const gnutls_x509_crt_t * certificate_list, int clist_size,
+    const gnutls_x509_crt_t * trusted_cas, int tcas_size,
+    const gnutls_x509_crl_t * CRLs, int crls_size,
     unsigned int flags)
 {
     int i = 0, ret;
@@ -373,8 +373,8 @@ unsigned int _gnutls_x509_verify_certificate(
  * we use DER here, although we should use BER. It works fine
  * anyway.
  */
-static int decode_ber_digest_info(const gnutls_datum * info,
-				  gnutls_mac_algorithm * hash,
+static int decode_ber_digest_info(const gnutls_datum_t * info,
+				  gnutls_mac_algorithm_t * hash,
 				  opaque * digest, int *digest_size)
 {
     ASN1_TYPE dinfo = ASN1_TYPE_EMPTY;
@@ -434,16 +434,16 @@ static int decode_ber_digest_info(const gnutls_datum * info,
  * params[1] is public key
  */
 static int
-_pkcs1_rsa_verify_sig(const gnutls_datum * text,
-		      const gnutls_datum * signature, mpi_t * params,
+_pkcs1_rsa_verify_sig(const gnutls_datum_t * text,
+		      const gnutls_datum_t * signature, mpi_t * params,
 		      int params_len)
 {
-    gnutls_mac_algorithm hash;
+    gnutls_mac_algorithm_t hash;
     int ret;
     opaque digest[MAX_HASH_SIZE], md[MAX_HASH_SIZE];
     int digest_size;
     GNUTLS_HASH_HANDLE hd;
-    gnutls_datum decrypted;
+    gnutls_datum_t decrypted;
 
     ret =
 	_gnutls_pkcs1_rsa_decrypt(&decrypted, signature, params,
@@ -492,12 +492,12 @@ _pkcs1_rsa_verify_sig(const gnutls_datum * text,
 /* Hashes input data and verifies a DSA signature.
  */
 static int
-dsa_verify_sig(const gnutls_datum * text, const gnutls_datum * signature,
+dsa_verify_sig(const gnutls_datum_t * text, const gnutls_datum_t * signature,
 	       mpi_t * params, int params_len)
 {
     int ret;
     opaque _digest[MAX_HASH_SIZE];
-    gnutls_datum digest;
+    gnutls_datum_t digest;
     GNUTLS_HASH_HANDLE hd;
 
     hd = _gnutls_hash_init(GNUTLS_MAC_SHA);
@@ -520,9 +520,9 @@ dsa_verify_sig(const gnutls_datum * text, const gnutls_datum * signature,
 /* Verifies the signature data, and returns 0 if not verified,
  * or 1 otherwise.
  */
-static int verify_sig(const gnutls_datum * tbs,
-    const gnutls_datum * signature,
-    gnutls_pk_algorithm pk, mpi_t * issuer_params, int issuer_params_size)
+static int verify_sig(const gnutls_datum_t * tbs,
+    const gnutls_datum_t * signature,
+    gnutls_pk_algorithm_t pk, mpi_t * issuer_params, int issuer_params_size)
 {
 
     switch (pk) {
@@ -559,8 +559,8 @@ static int verify_sig(const gnutls_datum * tbs,
  * 'tbs' is the signed data
  * 'signature' is the signature!
  */
-int _gnutls_x509_verify_signature(const gnutls_datum * tbs,
-    const gnutls_datum * signature, gnutls_x509_crt issuer)
+int _gnutls_x509_verify_signature(const gnutls_datum_t * tbs,
+    const gnutls_datum_t * signature, gnutls_x509_crt_t issuer)
 {
     mpi_t issuer_params[MAX_PUBLIC_PARAMS_SIZE];
     int ret, issuer_params_size, i;
@@ -599,8 +599,8 @@ int _gnutls_x509_verify_signature(const gnutls_datum * tbs,
  * 'tbs' is the signed data
  * 'signature' is the signature!
  */
-int _gnutls_x509_privkey_verify_signature(const gnutls_datum * tbs,
-    const gnutls_datum * signature, gnutls_x509_privkey issuer)
+int _gnutls_x509_privkey_verify_signature(const gnutls_datum_t * tbs,
+    const gnutls_datum_t * signature, gnutls_x509_privkey_t issuer)
 {
     int ret;
 
@@ -636,7 +636,7 @@ int _gnutls_x509_privkey_verify_signature(const gnutls_datum * tbs,
   * certificate belongs to the actual peer. 
   *
   * The certificate verification output will be put in @verify and will be
-  * one or more of the gnutls_certificate_status enumerated elements bitwise or'd.
+  * one or more of the gnutls_certificate_status_t enumerated elements bitwise or'd.
   * For a more detailed verification status use gnutls_x509_crt_verify() per list
   * element.
   *
@@ -648,9 +648,9 @@ int _gnutls_x509_privkey_verify_signature(const gnutls_datum * tbs,
   *
   **/
 int gnutls_x509_crt_list_verify(
-    const gnutls_x509_crt * cert_list, int cert_list_length,
-    const gnutls_x509_crt * CA_list, int CA_list_length,
-    const gnutls_x509_crl * CRL_list, int CRL_list_length, 
+    const gnutls_x509_crt_t * cert_list, int cert_list_length,
+    const gnutls_x509_crt_t * CA_list, int CA_list_length,
+    const gnutls_x509_crl_t * CRL_list, int CRL_list_length, 
     unsigned int flags,	unsigned int *verify)
 {
     if (cert_list == NULL || cert_list_length == 0)
@@ -680,8 +680,8 @@ int gnutls_x509_crt_list_verify(
   * Returns 0 on success and a negative value in case of an error.
   *
   **/
-int gnutls_x509_crt_verify(gnutls_x509_crt cert,
-    const gnutls_x509_crt * CA_list, int CA_list_length,
+int gnutls_x509_crt_verify(gnutls_x509_crt_t cert,
+    const gnutls_x509_crt_t * CA_list, int CA_list_length,
     unsigned int flags, unsigned int *verify)
 {
     int ret;
@@ -710,8 +710,8 @@ int gnutls_x509_crt_verify(gnutls_x509_crt cert,
   * A negative value is returned in case of an error.
   *
   **/
-int gnutls_x509_crt_check_issuer(gnutls_x509_crt cert,
-				 gnutls_x509_crt issuer)
+int gnutls_x509_crt_check_issuer(gnutls_x509_crt_t cert,
+				 gnutls_x509_crt_t issuer)
 {
     return is_issuer(cert, issuer);
 }
@@ -731,8 +731,8 @@ int gnutls_x509_crt_check_issuer(gnutls_x509_crt cert,
   * A negative value is returned in case of an error.
   *
   **/
-int gnutls_x509_crl_check_issuer(gnutls_x509_crl cert,
-				 gnutls_x509_crt issuer)
+int gnutls_x509_crl_check_issuer(gnutls_x509_crl_t cert,
+				 gnutls_x509_crt_t issuer)
 {
     return is_crl_issuer(cert, issuer);
 }
@@ -752,8 +752,8 @@ int gnutls_x509_crl_check_issuer(gnutls_x509_crl cert,
   * Returns 0 on success and a negative value in case of an error.
   *
   **/
-int gnutls_x509_crl_verify(gnutls_x509_crl crl,
-    const gnutls_x509_crt * CA_list, int CA_list_length,
+int gnutls_x509_crl_verify(gnutls_x509_crl_t crl,
+    const gnutls_x509_crt_t * CA_list, int CA_list_length,
     unsigned int flags, unsigned int *verify)
 {
     int ret;
@@ -772,9 +772,9 @@ int gnutls_x509_crl_verify(gnutls_x509_crl crl,
 /* The same as above, but here we've got a CRL.
  */
 static
-int is_crl_issuer(gnutls_x509_crl crl, gnutls_x509_crt issuer_cert)
+int is_crl_issuer(gnutls_x509_crl_t crl, gnutls_x509_crt_t issuer_cert)
 {
-    gnutls_datum dn1 = { NULL, 0 }, dn2 = {
+    gnutls_datum_t dn1 = { NULL, 0 }, dn2 = {
     NULL, 0};
     int ret;
 
@@ -800,8 +800,8 @@ int is_crl_issuer(gnutls_x509_crl crl, gnutls_x509_crt issuer_cert)
 }
 
 static inline
-gnutls_x509_crt find_crl_issuer(gnutls_x509_crl crl,
-    const gnutls_x509_crt * trusted_cas, int tcas_size)
+gnutls_x509_crt_t find_crl_issuer(gnutls_x509_crl_t crl,
+    const gnutls_x509_crt_t * trusted_cas, int tcas_size)
 {
     int i;
 
@@ -826,14 +826,14 @@ gnutls_x509_crt find_crl_issuer(gnutls_x509_crl crl,
  * Output will hold information about the verification
  * procedure. 
  */
-static int _gnutls_verify_crl2(gnutls_x509_crl crl,
-    const gnutls_x509_crt * trusted_cas, int tcas_size, 
+static int _gnutls_verify_crl2(gnutls_x509_crl_t crl,
+    const gnutls_x509_crt_t * trusted_cas, int tcas_size, 
     unsigned int flags, unsigned int *output)
 {
 /* CRL is ignored for now */
-    gnutls_datum crl_signed_data = { NULL, 0 };
-    gnutls_datum crl_signature = { NULL, 0 };
-    gnutls_x509_crt issuer;
+    gnutls_datum_t crl_signed_data = { NULL, 0 };
+    gnutls_datum_t crl_signature = { NULL, 0 };
+    gnutls_x509_crt_t issuer;
     int ret, result;
 
     if (output)
diff --git a/lib/x509/verify.h b/lib/x509/verify.h
index e2f96dbf46..d98dbb4390 100644
--- a/lib/x509/verify.h
+++ b/lib/x509/verify.h
@@ -5,22 +5,22 @@ typedef enum gnutls_certificate_verify_flags {
 	GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT=2
 } gnutls_certificate_verify_flags;
 
-int gnutls_x509_crt_is_issuer( gnutls_x509_crt cert,
-    gnutls_x509_crt issuer);
-int gnutls_x509_crt_verify( gnutls_x509_crt cert,
-    const gnutls_x509_crt *CA_list, int CA_list_length,
+int gnutls_x509_crt_is_issuer( gnutls_x509_crt_t cert,
+    gnutls_x509_crt_t issuer);
+int gnutls_x509_crt_verify( gnutls_x509_crt_t cert,
+    const gnutls_x509_crt_t *CA_list, int CA_list_length,
     unsigned int flags, unsigned int *verify);
-int gnutls_x509_crl_verify( gnutls_x509_crl crl,
-    const gnutls_x509_crt *CA_list, int CA_list_length,
+int gnutls_x509_crl_verify( gnutls_x509_crl_t crl,
+    const gnutls_x509_crt_t *CA_list, int CA_list_length,
     unsigned int flags, unsigned int *verify);
 
 int gnutls_x509_crt_list_verify( 
-    const gnutls_x509_crt* cert_list, int cert_list_length, 
-    const gnutls_x509_crt * CA_list, int CA_list_length, 
-    const gnutls_x509_crl* CRL_list, int CRL_list_length, 
+    const gnutls_x509_crt_t* cert_list, int cert_list_length, 
+    const gnutls_x509_crt_t * CA_list, int CA_list_length, 
+    const gnutls_x509_crl_t* CRL_list, int CRL_list_length, 
     unsigned int flags, unsigned int *verify);
 
-int _gnutls_x509_verify_signature( const gnutls_datum* tbs,
-    const gnutls_datum* signature, gnutls_x509_crt issuer);
-int _gnutls_x509_privkey_verify_signature( const gnutls_datum* tbs,
-    const gnutls_datum* signature, gnutls_x509_privkey issuer);
+int _gnutls_x509_verify_signature( const gnutls_datum_t* tbs,
+    const gnutls_datum_t* signature, gnutls_x509_crt_t issuer);
+int _gnutls_x509_privkey_verify_signature( const gnutls_datum_t* tbs,
+    const gnutls_datum_t* signature, gnutls_x509_privkey_t issuer);
diff --git a/lib/x509/x509.c b/lib/x509/x509.c
index c36e6a426d..4b9d275b31 100644
--- a/lib/x509/x509.c
+++ b/lib/x509/x509.c
@@ -40,7 +40,7 @@
 #include <verify.h>
 
 /**
-  * gnutls_x509_crt_init - This function initializes a gnutls_x509_crt structure
+  * gnutls_x509_crt_init - This function initializes a gnutls_x509_crt_t structure
   * @cert: The structure to be initialized
   *
   * This function will initialize an X.509 certificate structure. 
@@ -48,7 +48,7 @@
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_crt_init(gnutls_x509_crt * cert)
+int gnutls_x509_crt_init(gnutls_x509_crt_t * cert)
 {
     *cert = gnutls_calloc(1, sizeof(gnutls_x509_crt_int));
 
@@ -67,7 +67,7 @@ int gnutls_x509_crt_init(gnutls_x509_crt * cert)
 }
 
 /*-
-  * _gnutls_x509_crt_cpy - This function copies a gnutls_x509_crt structure
+  * _gnutls_x509_crt_cpy - This function copies a gnutls_x509_crt_t structure
   * @dest: The structure where to copy
   * @src: The structure to be copied
   *
@@ -76,12 +76,12 @@ int gnutls_x509_crt_init(gnutls_x509_crt * cert)
   * Returns 0 on success.
   *
   -*/
-int _gnutls_x509_crt_cpy(gnutls_x509_crt dest, gnutls_x509_crt src)
+int _gnutls_x509_crt_cpy(gnutls_x509_crt_t dest, gnutls_x509_crt_t src)
 {
     int ret;
     size_t der_size;
     opaque *der;
-    gnutls_datum tmp;
+    gnutls_datum_t tmp;
 
     ret =
 	gnutls_x509_crt_export(src, GNUTLS_X509_FMT_DER, NULL, &der_size);
@@ -119,13 +119,13 @@ int _gnutls_x509_crt_cpy(gnutls_x509_crt dest, gnutls_x509_crt src)
 }
 
 /**
-  * gnutls_x509_crt_deinit - This function deinitializes memory used by a gnutls_x509_crt structure
+  * gnutls_x509_crt_deinit - This function deinitializes memory used by a gnutls_x509_crt_t structure
   * @cert: The structure to be initialized
   *
   * This function will deinitialize a CRL structure. 
   *
   **/
-void gnutls_x509_crt_deinit(gnutls_x509_crt cert)
+void gnutls_x509_crt_deinit(gnutls_x509_crt_t cert)
 {
     if (!cert)
 	return;
@@ -143,7 +143,7 @@ void gnutls_x509_crt_deinit(gnutls_x509_crt cert)
   * @format: One of DER or PEM
   *
   * This function will convert the given DER or PEM encoded Certificate
-  * to the native gnutls_x509_crt format. The output will be stored in @cert.
+  * to the native gnutls_x509_crt_t format. The output will be stored in @cert.
   *
   * If the Certificate is PEM encoded it should have a header of "X509 CERTIFICATE", or
   * "CERTIFICATE".
@@ -151,11 +151,11 @@ void gnutls_x509_crt_deinit(gnutls_x509_crt cert)
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_crt_import(gnutls_x509_crt cert, const gnutls_datum * data,
-			   gnutls_x509_crt_fmt format)
+int gnutls_x509_crt_import(gnutls_x509_crt_t cert, const gnutls_datum_t * data,
+			   gnutls_x509_crt_fmt_t format)
 {
     int result = 0, need_free = 0;
-    gnutls_datum _data;
+    gnutls_datum_t _data;
     opaque *signature = NULL;
 
     if (cert == NULL) {
@@ -221,7 +221,7 @@ int gnutls_x509_crt_import(gnutls_x509_crt cert, const gnutls_datum * data,
 
 /**
   * gnutls_x509_crt_get_issuer_dn - This function returns the Certificate's issuer distinguished name
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @buf: a pointer to a structure to hold the name (may be null)
   * @sizeof_buf: initially holds the size of @buf
   *
@@ -236,7 +236,7 @@ int gnutls_x509_crt_import(gnutls_x509_crt cert, const gnutls_datum * data,
   * On success 0 is returned.
   *
   **/
-int gnutls_x509_crt_get_issuer_dn(gnutls_x509_crt cert, char *buf,
+int gnutls_x509_crt_get_issuer_dn(gnutls_x509_crt_t cert, char *buf,
 				  size_t * sizeof_buf)
 {
     if (cert == NULL) {
@@ -251,7 +251,7 @@ int gnutls_x509_crt_get_issuer_dn(gnutls_x509_crt cert, char *buf,
 
 /**
   * gnutls_x509_crt_get_issuer_dn_by_oid - This function returns the Certificate's issuer distinguished name
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @oid: holds an Object Identified in null terminated string
   * @indx: In case multiple same OIDs exist in the RDN, this specifies which to send. Use zero to get the first one.
   * @raw_flag: If non zero returns the raw DER data of the DN part.
@@ -274,7 +274,7 @@ int gnutls_x509_crt_get_issuer_dn(gnutls_x509_crt cert, char *buf,
   * On success 0 is returned.
   *
   **/
-int gnutls_x509_crt_get_issuer_dn_by_oid(gnutls_x509_crt cert,
+int gnutls_x509_crt_get_issuer_dn_by_oid(gnutls_x509_crt_t cert,
 					 const char *oid, int indx,
 					 unsigned int raw_flag, void *buf,
 					 size_t * sizeof_buf)
@@ -291,7 +291,7 @@ int gnutls_x509_crt_get_issuer_dn_by_oid(gnutls_x509_crt cert,
 
 /**
   * gnutls_x509_crt_get_issuer_dn_oid - This function returns the Certificate's issuer distinguished name OIDs
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @indx: This specifies which OID to return. Use zero to get the first one.
   * @oid: a pointer to a buffer to hold the OID (may be null)
   * @sizeof_oid: initially holds the size of @oid
@@ -306,7 +306,7 @@ int gnutls_x509_crt_get_issuer_dn_by_oid(gnutls_x509_crt cert,
   * On success 0 is returned.
   *
   **/
-int gnutls_x509_crt_get_issuer_dn_oid(gnutls_x509_crt cert,
+int gnutls_x509_crt_get_issuer_dn_oid(gnutls_x509_crt_t cert,
 				      int indx, void *oid,
 				      size_t * sizeof_oid)
 {
@@ -322,7 +322,7 @@ int gnutls_x509_crt_get_issuer_dn_oid(gnutls_x509_crt cert,
 
 /**
   * gnutls_x509_crt_get_dn - This function returns the Certificate's distinguished name
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @buf: a pointer to a structure to hold the name (may be null)
   * @sizeof_buf: initially holds the size of @buf
   *
@@ -337,7 +337,7 @@ int gnutls_x509_crt_get_issuer_dn_oid(gnutls_x509_crt cert,
   * On success 0 is returned.
   *
   **/
-int gnutls_x509_crt_get_dn(gnutls_x509_crt cert, char *buf,
+int gnutls_x509_crt_get_dn(gnutls_x509_crt_t cert, char *buf,
 			   size_t * sizeof_buf)
 {
     if (cert == NULL) {
@@ -352,7 +352,7 @@ int gnutls_x509_crt_get_dn(gnutls_x509_crt cert, char *buf,
 
 /**
   * gnutls_x509_crt_get_dn_by_oid - This function returns the Certificate's distinguished name
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @oid: holds an Object Identified in null terminated string
   * @indx: In case multiple same OIDs exist in the RDN, this specifies which to send. Use zero to get the first one.
   * @raw_flag: If non zero returns the raw DER data of the DN part.
@@ -375,7 +375,7 @@ int gnutls_x509_crt_get_dn(gnutls_x509_crt cert, char *buf,
   * On success 0 is returned.
   *
   **/
-int gnutls_x509_crt_get_dn_by_oid(gnutls_x509_crt cert, const char *oid,
+int gnutls_x509_crt_get_dn_by_oid(gnutls_x509_crt_t cert, const char *oid,
 				  int indx, unsigned int raw_flag,
 				  void *buf, size_t * sizeof_buf)
 {
@@ -391,7 +391,7 @@ int gnutls_x509_crt_get_dn_by_oid(gnutls_x509_crt cert, const char *oid,
 
 /**
   * gnutls_x509_crt_get_dn_oid - This function returns the Certificate's subject distinguished name OIDs
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @indx: This specifies which OID to return. Use zero to get the first one.
   * @oid: a pointer to a buffer to hold the OID (may be null)
   * @sizeof_oid: initially holds the size of @oid
@@ -406,7 +406,7 @@ int gnutls_x509_crt_get_dn_by_oid(gnutls_x509_crt cert, const char *oid,
   * On success 0 is returned.
   *
   **/
-int gnutls_x509_crt_get_dn_oid(gnutls_x509_crt cert,
+int gnutls_x509_crt_get_dn_oid(gnutls_x509_crt_t cert,
 			       int indx, void *oid, size_t * sizeof_oid)
 {
     if (cert == NULL) {
@@ -421,18 +421,18 @@ int gnutls_x509_crt_get_dn_oid(gnutls_x509_crt cert,
 
 /**
   * gnutls_x509_crt_get_signature_algorithm - This function returns the Certificate's signature algorithm
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   *
-  * This function will return a value of the gnutls_sign_algorithm enumeration that 
+  * This function will return a value of the gnutls_sign_algorithm_t enumeration that 
   * is the signature algorithm. 
   *
   * Returns a negative value on error.
   *
   **/
-int gnutls_x509_crt_get_signature_algorithm(gnutls_x509_crt cert)
+int gnutls_x509_crt_get_signature_algorithm(gnutls_x509_crt_t cert)
 {
     int result;
-    gnutls_datum sa;
+    gnutls_datum_t sa;
 
     if (cert == NULL) {
 	gnutls_assert();
@@ -460,14 +460,14 @@ int gnutls_x509_crt_get_signature_algorithm(gnutls_x509_crt cert)
 
 /**
   * gnutls_x509_crt_get_version - This function returns the Certificate's version number
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   *
   * This function will return the version of the specified Certificate.
   *
   * Returns a negative value on error.
   *
   **/
-int gnutls_x509_crt_get_version(gnutls_x509_crt cert)
+int gnutls_x509_crt_get_version(gnutls_x509_crt_t cert)
 {
     opaque version[5];
     int len, result;
@@ -493,14 +493,14 @@ int gnutls_x509_crt_get_version(gnutls_x509_crt cert)
 
 /**
   * gnutls_x509_crt_get_activation_time - This function returns the Certificate's activation time
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   *
   * This function will return the time this Certificate was or will be activated.
   *
   * Returns (time_t)-1 on error.
   *
   **/
-time_t gnutls_x509_crt_get_activation_time(gnutls_x509_crt cert)
+time_t gnutls_x509_crt_get_activation_time(gnutls_x509_crt_t cert)
 {
     if (cert == NULL) {
 	gnutls_assert();
@@ -513,14 +513,14 @@ time_t gnutls_x509_crt_get_activation_time(gnutls_x509_crt cert)
 
 /**
   * gnutls_x509_crt_get_expiration_time - This function returns the Certificate's expiration time
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   *
   * This function will return the time this Certificate was or will be expired.
   *
   * Returns (time_t)-1 on error.
   *
   **/
-time_t gnutls_x509_crt_get_expiration_time(gnutls_x509_crt cert)
+time_t gnutls_x509_crt_get_expiration_time(gnutls_x509_crt_t cert)
 {
     if (cert == NULL) {
 	gnutls_assert();
@@ -533,7 +533,7 @@ time_t gnutls_x509_crt_get_expiration_time(gnutls_x509_crt cert)
 
 /**
   * gnutls_x509_crt_get_serial - This function returns the certificate's serial number
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @result: The place where the serial number will be copied
   * @result_size: Holds the size of the result field.
   *
@@ -546,7 +546,7 @@ time_t gnutls_x509_crt_get_expiration_time(gnutls_x509_crt cert)
   * Returns 0 on success and a negative value in case of an error.
   *
   **/
-int gnutls_x509_crt_get_serial(gnutls_x509_crt cert, void *result,
+int gnutls_x509_crt_get_serial(gnutls_x509_crt_t cert, void *result,
 			       size_t * result_size)
 {
     int ret;
@@ -568,7 +568,7 @@ int gnutls_x509_crt_get_serial(gnutls_x509_crt cert, void *result,
 
 /**
   * gnutls_x509_crt_get_subject_key_id - This function returns the certificate's key identifier
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @result: The place where the identifier will be copied
   * @result_size: Holds the size of the result field.
   * @critical: will be non zero if the extension is marked as critical (may be null)
@@ -580,12 +580,12 @@ int gnutls_x509_crt_get_serial(gnutls_x509_crt cert, void *result,
   * Returns 0 on success and a negative value in case of an error.
   *
   **/
-int gnutls_x509_crt_get_subject_key_id(gnutls_x509_crt cert, void *ret,
+int gnutls_x509_crt_get_subject_key_id(gnutls_x509_crt_t cert, void *ret,
 				       size_t * ret_size,
 				       unsigned int *critical)
 {
     int result, len;
-    gnutls_datum id;
+    gnutls_datum_t id;
     ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
 
     if (cert == NULL) {
@@ -647,7 +647,7 @@ int gnutls_x509_crt_get_subject_key_id(gnutls_x509_crt cert, void *ret,
 
 /**
   * gnutls_x509_crt_get_authority_key_id - This function returns the certificate authority's identifier
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @result: The place where the identifier will be copied
   * @result_size: Holds the size of the result field.
   * @critical: will be non zero if the extension is marked as critical (may be null)
@@ -660,12 +660,12 @@ int gnutls_x509_crt_get_subject_key_id(gnutls_x509_crt cert, void *ret,
   * Returns 0 on success and a negative value in case of an error.
   *
   **/
-int gnutls_x509_crt_get_authority_key_id(gnutls_x509_crt cert, void *ret,
+int gnutls_x509_crt_get_authority_key_id(gnutls_x509_crt_t cert, void *ret,
 					 size_t * ret_size,
 					 unsigned int *critical)
 {
     int result, len;
-    gnutls_datum id;
+    gnutls_datum_t id;
     ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
 
     if (cert == NULL) {
@@ -727,7 +727,7 @@ int gnutls_x509_crt_get_authority_key_id(gnutls_x509_crt cert, void *ret,
 
 /**
   * gnutls_x509_crt_get_pk_algorithm - This function returns the certificate's PublicKey algorithm
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @bits: if bits is non null it will hold the size of the parameters' in bits
   *
   * This function will return the public key algorithm of an X.509 
@@ -738,11 +738,11 @@ int gnutls_x509_crt_get_authority_key_id(gnutls_x509_crt cert, void *ret,
   * For DSA the bits returned are of the public
   * exponent.
   *
-  * Returns a member of the gnutls_pk_algorithm enumeration on success,
+  * Returns a member of the gnutls_pk_algorithm_t enumeration on success,
   * or a negative value on error.
   *
   **/
-int gnutls_x509_crt_get_pk_algorithm(gnutls_x509_crt cert,
+int gnutls_x509_crt_get_pk_algorithm(gnutls_x509_crt_t cert,
 				     unsigned int *bits)
 {
     int result;
@@ -776,7 +776,7 @@ static int parse_general_name(ASN1_TYPE src, const char *src_name,
     char nptr[128];
     int result;
     opaque choice_type[128];
-    gnutls_x509_subject_alt_name type;
+    gnutls_x509_subject_alt_name_t type;
 
     seq++;			/* 0->1, 1->2 etc */
     _gnutls_int2str(seq, num);
@@ -802,7 +802,7 @@ static int parse_general_name(ASN1_TYPE src, const char *src_name,
 
 
     type = _gnutls_x509_san_find_type(choice_type);
-    if (type == (gnutls_x509_subject_alt_name) - 1) {
+    if (type == (gnutls_x509_subject_alt_name_t) - 1) {
 	gnutls_assert();
 	return GNUTLS_E_X509_UNKNOWN_SAN;
     }
@@ -827,7 +827,7 @@ static int parse_general_name(ASN1_TYPE src, const char *src_name,
 
 /**
   * gnutls_x509_crt_get_subject_alt_name - This function returns the certificate's alternative name, if any
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @seq: specifies the sequence number of the alt name (0 for the first one, 1 for the second etc.)
   * @ret: is the place where the alternative name will be copied to
   * @ret_size: holds the size of ret.
@@ -842,21 +842,21 @@ static int parse_general_name(ASN1_TYPE src, const char *src_name,
   *
   * Returns GNUTLS_E_SHORT_MEMORY_BUFFER if ret_size is not enough to hold the alternative 
   * name, or the type of alternative name if everything was ok. The type is 
-  * one of the enumerated gnutls_x509_subject_alt_name.
+  * one of the enumerated gnutls_x509_subject_alt_name_t.
   *
   * If the certificate does not have an Alternative name with the specified 
   * sequence number then returns GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE;
   *
   **/
-int gnutls_x509_crt_get_subject_alt_name(gnutls_x509_crt cert,
+int gnutls_x509_crt_get_subject_alt_name(gnutls_x509_crt_t cert,
 					 unsigned int seq, void *ret,
 					 size_t * ret_size,
 					 unsigned int *critical)
 {
     int result;
-    gnutls_datum dnsname;
+    gnutls_datum_t dnsname;
     ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
-    gnutls_x509_subject_alt_name type;
+    gnutls_x509_subject_alt_name_t type;
 
     if (cert == NULL) {
 	gnutls_assert();
@@ -911,7 +911,7 @@ int gnutls_x509_crt_get_subject_alt_name(gnutls_x509_crt cert,
 
 /**
   * gnutls_x509_crt_get_ca_status - This function returns the certificate CA status
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @critical: will be non zero if the extension is marked as critical
   *
   * This function will return certificates CA status, by reading the
@@ -924,11 +924,11 @@ int gnutls_x509_crt_get_subject_alt_name(gnutls_x509_crt cert,
   * GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE will be returned.
   *
   **/
-int gnutls_x509_crt_get_ca_status(gnutls_x509_crt cert,
+int gnutls_x509_crt_get_ca_status(gnutls_x509_crt_t cert,
 				  unsigned int *critical)
 {
     int result;
-    gnutls_datum basicConstraints;
+    gnutls_datum_t basicConstraints;
     int ca;
 
     if (cert == NULL) {
@@ -965,7 +965,7 @@ int gnutls_x509_crt_get_ca_status(gnutls_x509_crt cert,
 
 /**
   * gnutls_x509_crt_get_key_usage - This function returns the certificate's key usage
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @key_usage: where the key usage bits will be stored
   * @critical: will be non zero if the extension is marked as critical
   *
@@ -982,12 +982,12 @@ int gnutls_x509_crt_get_ca_status(gnutls_x509_crt cert,
   * GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE will be returned.
   *
   **/
-int gnutls_x509_crt_get_key_usage(gnutls_x509_crt cert,
+int gnutls_x509_crt_get_key_usage(gnutls_x509_crt_t cert,
 				  unsigned int *key_usage,
 				  unsigned int *critical)
 {
     int result;
-    gnutls_datum keyUsage;
+    gnutls_datum_t keyUsage;
     uint16 _usage;
 
     if (cert == NULL) {
@@ -1022,7 +1022,7 @@ int gnutls_x509_crt_get_key_usage(gnutls_x509_crt cert,
 
 /**
   * gnutls_x509_crt_get_extension_by_oid - This function returns the specified extension
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @oid: holds an Object Identified in null terminated string
   * @indx: In case multiple same OIDs exist in the extensions, this specifies which to send. Use zero to get the first one.
   * @buf: a pointer to a structure to hold the name (may be null)
@@ -1038,13 +1038,13 @@ int gnutls_x509_crt_get_key_usage(gnutls_x509_crt cert,
   * GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE will be returned.
   *
   **/
-int gnutls_x509_crt_get_extension_by_oid(gnutls_x509_crt cert,
+int gnutls_x509_crt_get_extension_by_oid(gnutls_x509_crt_t cert,
 					 const char *oid, int indx,
 					 void *buf, size_t * sizeof_buf,
 					 unsigned int *critical)
 {
     int result;
-    gnutls_datum output;
+    gnutls_datum_t output;
 
     if (cert == NULL) {
 	gnutls_assert();
@@ -1082,7 +1082,7 @@ int gnutls_x509_crt_get_extension_by_oid(gnutls_x509_crt cert,
 
 /**
   * gnutls_x509_crt_get_extension_oid - This function returns the specified extension OID
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @indx: Specifies which extension OID to send. Use zero to get the first one.
   * @oid: a pointer to a structure to hold the OID (may be null)
   * @sizeof_oid: initially holds the size of @oid
@@ -1095,7 +1095,7 @@ int gnutls_x509_crt_get_extension_by_oid(gnutls_x509_crt cert,
   * GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE will be returned.
   *
   **/
-int gnutls_x509_crt_get_extension_oid(gnutls_x509_crt cert, int indx,
+int gnutls_x509_crt_get_extension_oid(gnutls_x509_crt_t cert, int indx,
 				      void *oid, size_t * sizeof_oid)
 {
     int result;
@@ -1117,13 +1117,13 @@ int gnutls_x509_crt_get_extension_oid(gnutls_x509_crt cert, int indx,
 
 
 static
-int _gnutls_x509_crt_get_raw_dn2(gnutls_x509_crt cert,
-				 const char *whom, gnutls_datum * start)
+int _gnutls_x509_crt_get_raw_dn2(gnutls_x509_crt_t cert,
+				 const char *whom, gnutls_datum_t * start)
 {
     ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
     int result, len1;
     int start1, end1;
-    gnutls_datum signed_data;
+    gnutls_datum_t signed_data;
 
     /* get the issuer of 'cert'
      */
@@ -1175,7 +1175,7 @@ int _gnutls_x509_crt_get_raw_dn2(gnutls_x509_crt cert,
 
 /*-
   * _gnutls_x509_crt_get_raw_issuer_dn - This function returns the issuer's DN DER encoded
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @start: will hold the starting point of the DN
   *
   * This function will return a pointer to the DER encoded DN structure and
@@ -1184,15 +1184,15 @@ int _gnutls_x509_crt_get_raw_dn2(gnutls_x509_crt cert,
   * Returns 0 on success or a negative value on error.
   *
   -*/
-int _gnutls_x509_crt_get_raw_issuer_dn(gnutls_x509_crt cert,
-				       gnutls_datum * start)
+int _gnutls_x509_crt_get_raw_issuer_dn(gnutls_x509_crt_t cert,
+				       gnutls_datum_t * start)
 {
     return _gnutls_x509_crt_get_raw_dn2(cert, "issuer", start);
 }
 
 /*-
   * _gnutls_x509_crt_get_raw_dn - This function returns the subject's DN DER encoded
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @start: will hold the starting point of the DN
   *
   * This function will return a pointer to the DER encoded DN structure and
@@ -1201,7 +1201,7 @@ int _gnutls_x509_crt_get_raw_issuer_dn(gnutls_x509_crt cert,
   * Returns 0 on success, or a negative value on error.
   *
   -*/
-int _gnutls_x509_crt_get_raw_dn(gnutls_x509_crt cert, gnutls_datum * start)
+int _gnutls_x509_crt_get_raw_dn(gnutls_x509_crt_t cert, gnutls_datum_t * start)
 {
     return _gnutls_x509_crt_get_raw_dn2(cert, "subject", start);
 }
@@ -1209,7 +1209,7 @@ int _gnutls_x509_crt_get_raw_dn(gnutls_x509_crt cert, gnutls_datum * start)
 
 /**
   * gnutls_x509_crt_get_fingerprint - This function returns the Certificate's fingerprint
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @algo: is a digest algorithm
   * @buf: a pointer to a structure to hold the fingerprint (may be null)
   * @sizeof_buf: initially holds the size of @buf
@@ -1224,14 +1224,14 @@ int _gnutls_x509_crt_get_raw_dn(gnutls_x509_crt cert, gnutls_datum * start)
   * On success 0 is returned.
   *
   **/
-int gnutls_x509_crt_get_fingerprint(gnutls_x509_crt cert,
-				    gnutls_digest_algorithm algo,
+int gnutls_x509_crt_get_fingerprint(gnutls_x509_crt_t cert,
+				    gnutls_digest_algorithm_t algo,
 				    void *buf, size_t * sizeof_buf)
 {
     opaque *cert_buf;
     int cert_buf_size;
     int result;
-    gnutls_datum tmp;
+    gnutls_datum_t tmp;
 
     if (sizeof_buf == 0 || cert == NULL) {
 	return GNUTLS_E_INVALID_REQUEST;
@@ -1283,8 +1283,8 @@ int gnutls_x509_crt_get_fingerprint(gnutls_x509_crt cert,
   * 0 on success.
   *
   **/
-int gnutls_x509_crt_export(gnutls_x509_crt cert,
-			   gnutls_x509_crt_fmt format, void *output_data,
+int gnutls_x509_crt_export(gnutls_x509_crt_t cert,
+			   gnutls_x509_crt_fmt_t format, void *output_data,
 			   size_t * output_data_size)
 {
     if (cert == NULL) {
@@ -1317,14 +1317,14 @@ int gnutls_x509_crt_export(gnutls_x509_crt cert,
   * 0 on success.
   *
   **/
-int gnutls_x509_crt_get_key_id(gnutls_x509_crt crt, unsigned int flags,
+int gnutls_x509_crt_get_key_id(gnutls_x509_crt_t crt, unsigned int flags,
 			       unsigned char *output_data,
 			       size_t * output_data_size)
 {
     mpi_t params[MAX_PUBLIC_PARAMS_SIZE];
     int params_size = MAX_PUBLIC_PARAMS_SIZE;
     int i, pk, result = 0;
-    gnutls_datum der = { NULL, 0 };
+    gnutls_datum_t der = { NULL, 0 };
     GNUTLS_HASH_HANDLE hd;
 
     if (crt == NULL) {
@@ -1399,8 +1399,8 @@ int gnutls_x509_crt_get_key_id(gnutls_x509_crt crt, unsigned int flags,
 
 /**
   * gnutls_x509_crt_check_revocation - This function checks if the given certificate is revoked
-  * @cert: should contain a gnutls_x509_crt structure
-  * @crl_list: should contain a list of gnutls_x509_crl structures
+  * @cert: should contain a gnutls_x509_crt_t structure
+  * @crl_list: should contain a list of gnutls_x509_crl_t structures
   * @crl_list_length: the length of the crl_list
   *
   * This function will return check if the given certificate is revoked.
@@ -1410,14 +1410,14 @@ int gnutls_x509_crt_get_key_id(gnutls_x509_crt crt, unsigned int flags,
   * A negative value is returned on error. 
   *
   **/
-int gnutls_x509_crt_check_revocation(gnutls_x509_crt cert,
-   const gnutls_x509_crl * crl_list, int crl_list_length)
+int gnutls_x509_crt_check_revocation(gnutls_x509_crt_t cert,
+   const gnutls_x509_crl_t * crl_list, int crl_list_length)
 {
     opaque serial[64];
     opaque cert_serial[64];
     size_t serial_size, cert_serial_size;
     int ncerts, ret, i, j;
-    gnutls_datum dn1, dn2;
+    gnutls_datum_t dn1, dn2;
 
     if (cert == NULL) {
 	gnutls_assert();
@@ -1506,9 +1506,9 @@ int gnutls_x509_crt_check_revocation(gnutls_x509_crt cert,
   * 1 on success.
   *
   **/
-int gnutls_x509_crt_verify_data(gnutls_x509_crt crt, unsigned int flags,
-				const gnutls_datum * data,
-				const gnutls_datum * signature)
+int gnutls_x509_crt_verify_data(gnutls_x509_crt_t crt, unsigned int flags,
+				const gnutls_datum_t * data,
+				const gnutls_datum_t * signature)
 {
     int result;
 
@@ -1528,7 +1528,7 @@ int gnutls_x509_crt_verify_data(gnutls_x509_crt crt, unsigned int flags,
 
 /**
   * gnutls_x509_crt_get_crl_dist_points - This function returns the CRL distribution points
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @seq: specifies the sequence number of the distribution point (0 for the first one, 1 for the second etc.)
   * @ret: is the place where the distribution point will be copied to
   * @ret_size: holds the size of ret.
@@ -1550,25 +1550,25 @@ int gnutls_x509_crt_verify_data(gnutls_x509_crt crt, unsigned int flags,
   *
   * Returns GNUTLS_E_SHORT_MEMORY_BUFFER if ret_size is not enough to hold the distribution
   * point, or the type of the distribution point if everything was ok. The type is 
-  * one of the enumerated gnutls_x509_subject_alt_name.
+  * one of the enumerated gnutls_x509_subject_alt_name_t.
   *
   * If the certificate does not have an Alternative name with the specified 
   * sequence number then returns GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE;
   *
   **/
-int gnutls_x509_crt_get_crl_dist_points(gnutls_x509_crt cert,
+int gnutls_x509_crt_get_crl_dist_points(gnutls_x509_crt_t cert,
 					unsigned int seq, void *ret,
 					size_t * ret_size,
 					unsigned int *reason_flags,
 					unsigned int *critical)
 {
     int result;
-    gnutls_datum dist_points = { NULL, 0 };
+    gnutls_datum_t dist_points = { NULL, 0 };
     ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
     char name[128];
     int len;
     char num[MAX_INT_DIGITS];
-    gnutls_x509_subject_alt_name type;
+    gnutls_x509_subject_alt_name_t type;
     uint8 reasons[2];
 
     if (cert == NULL) {
@@ -1652,7 +1652,7 @@ int gnutls_x509_crt_get_crl_dist_points(gnutls_x509_crt cert,
 
 /**
   * gnutls_x509_crt_get_key_purpose_oid - This function returns the Certificate's key purpose OIDs
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @indx: This specifies which OID to return. Use zero to get the first one.
   * @oid: a pointer to a buffer to hold the OID (may be null)
   * @sizeof_oid: initially holds the size of @oid
@@ -1668,7 +1668,7 @@ int gnutls_x509_crt_get_crl_dist_points(gnutls_x509_crt cert,
   * On success 0 is returned.
   *
   **/
-int gnutls_x509_crt_get_key_purpose_oid(gnutls_x509_crt cert,
+int gnutls_x509_crt_get_key_purpose_oid(gnutls_x509_crt_t cert,
 					int indx, void *oid,
 					size_t * sizeof_oid,
 					unsigned int *critical)
@@ -1676,7 +1676,7 @@ int gnutls_x509_crt_get_key_purpose_oid(gnutls_x509_crt cert,
     char counter[MAX_INT_DIGITS];
     char tmpstr[64];
     int result, len;
-    gnutls_datum id;
+    gnutls_datum_t id;
     ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
 
     if (cert == NULL) {
@@ -1754,8 +1754,8 @@ int gnutls_x509_crt_get_key_purpose_oid(gnutls_x509_crt cert,
   * gnutls_malloc() and will be stored in the appropriate datum.
   * 
   **/
-int gnutls_x509_crt_get_pk_rsa_raw(gnutls_x509_crt crt,
-				   gnutls_datum * m, gnutls_datum * e)
+int gnutls_x509_crt_get_pk_rsa_raw(gnutls_x509_crt_t crt,
+				   gnutls_datum_t * m, gnutls_datum_t * e)
 {
     int ret;
     mpi_t params[MAX_PUBLIC_PARAMS_SIZE];
@@ -1814,9 +1814,9 @@ int gnutls_x509_crt_get_pk_rsa_raw(gnutls_x509_crt crt,
   * gnutls_malloc() and will be stored in the appropriate datum.
   * 
   **/
-int gnutls_x509_crt_get_pk_dsa_raw(gnutls_x509_crt crt,
-				   gnutls_datum * p, gnutls_datum * q,
-				   gnutls_datum * g, gnutls_datum * y)
+int gnutls_x509_crt_get_pk_dsa_raw(gnutls_x509_crt_t crt,
+				   gnutls_datum_t * p, gnutls_datum_t * q,
+				   gnutls_datum_t * g, gnutls_datum_t * y)
 {
     int ret;
     mpi_t params[MAX_PUBLIC_PARAMS_SIZE];
diff --git a/lib/x509/x509.h b/lib/x509/x509.h
index 52e74667bd..d6bd75c2f7 100644
--- a/lib/x509/x509.h
+++ b/lib/x509/x509.h
@@ -49,7 +49,7 @@ typedef struct gnutls_x509_privkey_int {
 				 */
 	int params_size; /* holds the number of params */
 
-	gnutls_pk_algorithm pk_algorithm;
+	gnutls_pk_algorithm_t pk_algorithm;
 
 	int crippled; /* The crippled keys will not use the ASN1_TYPE key.
 		       * The encoding will only be performed at the export
@@ -59,79 +59,79 @@ typedef struct gnutls_x509_privkey_int {
 	ASN1_TYPE key;
 } gnutls_x509_privkey_int;
 
-typedef struct gnutls_x509_crt_int *gnutls_x509_crt;
-typedef struct gnutls_x509_crl_int *gnutls_x509_crl;
-typedef struct gnutls_x509_privkey_int *gnutls_x509_privkey;
+typedef struct gnutls_x509_crt_int *gnutls_x509_crt_t;
+typedef struct gnutls_x509_crl_int *gnutls_x509_crl_t;
+typedef struct gnutls_x509_privkey_int *gnutls_x509_privkey_t;
 
-int gnutls_x509_crt_get_issuer_dn_by_oid(gnutls_x509_crt cert, const char* oid, 
+int gnutls_x509_crt_get_issuer_dn_by_oid(gnutls_x509_crt_t cert, const char* oid, 
 	int indx, unsigned int raw_flag, void *buf, size_t *sizeof_buf);
-int gnutls_x509_crt_get_subject_alt_name(gnutls_x509_crt cert, 
+int gnutls_x509_crt_get_subject_alt_name(gnutls_x509_crt_t cert, 
 	unsigned int seq, void *ret, size_t *ret_size, unsigned int* critical);
-int gnutls_x509_crt_get_dn_by_oid(gnutls_x509_crt cert, const char* oid, 
+int gnutls_x509_crt_get_dn_by_oid(gnutls_x509_crt_t cert, const char* oid, 
 	int indx, unsigned int raw_flag, void *buf, size_t *sizeof_buf);
-int gnutls_x509_crt_get_ca_status(gnutls_x509_crt cert, unsigned int* critical);
-int gnutls_x509_crt_get_pk_algorithm( gnutls_x509_crt cert, unsigned int* bits);
+int gnutls_x509_crt_get_ca_status(gnutls_x509_crt_t cert, unsigned int* critical);
+int gnutls_x509_crt_get_pk_algorithm( gnutls_x509_crt_t cert, unsigned int* bits);
 
-int _gnutls_x509_crt_cpy(gnutls_x509_crt dest, gnutls_x509_crt src);
-int _gnutls_x509_crt_get_raw_issuer_dn( gnutls_x509_crt cert,
-    gnutls_datum* start);
-int _gnutls_x509_crt_get_raw_dn( gnutls_x509_crt cert,
-    gnutls_datum* start);
+int _gnutls_x509_crt_cpy(gnutls_x509_crt_t dest, gnutls_x509_crt_t src);
+int _gnutls_x509_crt_get_raw_issuer_dn( gnutls_x509_crt_t cert,
+    gnutls_datum_t* start);
+int _gnutls_x509_crt_get_raw_dn( gnutls_x509_crt_t cert,
+    gnutls_datum_t* start);
 
-int gnutls_x509_crt_get_serial(gnutls_x509_crt cert, void* result, size_t* result_size);
+int gnutls_x509_crt_get_serial(gnutls_x509_crt_t cert, void* result, size_t* result_size);
 
-int _gnutls_x509_compare_raw_dn(const gnutls_datum * dn1,
-    const gnutls_datum * dn2);
+int _gnutls_x509_compare_raw_dn(const gnutls_datum_t * dn1,
+    const gnutls_datum_t * dn2);
 
-int gnutls_x509_crt_check_revocation(gnutls_x509_crt cert, 
-    const gnutls_x509_crl * crl_list, int crl_list_length);
+int gnutls_x509_crt_check_revocation(gnutls_x509_crt_t cert, 
+    const gnutls_x509_crl_t * crl_list, int crl_list_length);
 
 
-int _gnutls_x509_crl_cpy(gnutls_x509_crl dest, gnutls_x509_crl src);
-int _gnutls_x509_crl_get_raw_issuer_dn( gnutls_x509_crl crl,
-    gnutls_datum* dn);
-int gnutls_x509_crl_get_crt_count(gnutls_x509_crl crl);
-int gnutls_x509_crl_get_crt_serial(gnutls_x509_crl crl, int index,
+int _gnutls_x509_crl_cpy(gnutls_x509_crl_t dest, gnutls_x509_crl_t src);
+int _gnutls_x509_crl_get_raw_issuer_dn( gnutls_x509_crl_t crl,
+    gnutls_datum_t* dn);
+int gnutls_x509_crl_get_crt_count(gnutls_x509_crl_t crl);
+int gnutls_x509_crl_get_crt_serial(gnutls_x509_crl_t crl, int index,
     unsigned char *serial,
     size_t *serial_size, time_t * time);
 
-void gnutls_x509_crl_deinit(gnutls_x509_crl crl);
-int gnutls_x509_crl_init(gnutls_x509_crl * crl);
-int gnutls_x509_crl_import(gnutls_x509_crl crl, const gnutls_datum * data,
-			   gnutls_x509_crt_fmt format);
-int gnutls_x509_crl_export( gnutls_x509_crl crl,
-    gnutls_x509_crt_fmt format, void* output_data, size_t* output_data_size);
-
-int gnutls_x509_crt_init(gnutls_x509_crt * cert);
-void gnutls_x509_crt_deinit(gnutls_x509_crt cert);
-int gnutls_x509_crt_import(gnutls_x509_crt cert, const gnutls_datum * data,
-	gnutls_x509_crt_fmt format);
-int gnutls_x509_crt_export( gnutls_x509_crt cert,
-	gnutls_x509_crt_fmt format, void* output_data, size_t* output_data_size);
-
-int gnutls_x509_crt_get_key_usage(gnutls_x509_crt cert, unsigned int *key_usage,
+void gnutls_x509_crl_deinit(gnutls_x509_crl_t crl);
+int gnutls_x509_crl_init(gnutls_x509_crl_t * crl);
+int gnutls_x509_crl_import(gnutls_x509_crl_t crl, const gnutls_datum_t * data,
+			   gnutls_x509_crt_fmt_t format);
+int gnutls_x509_crl_export( gnutls_x509_crl_t crl,
+    gnutls_x509_crt_fmt_t format, void* output_data, size_t* output_data_size);
+
+int gnutls_x509_crt_init(gnutls_x509_crt_t * cert);
+void gnutls_x509_crt_deinit(gnutls_x509_crt_t cert);
+int gnutls_x509_crt_import(gnutls_x509_crt_t cert, const gnutls_datum_t * data,
+	gnutls_x509_crt_fmt_t format);
+int gnutls_x509_crt_export( gnutls_x509_crt_t cert,
+	gnutls_x509_crt_fmt_t format, void* output_data, size_t* output_data_size);
+
+int gnutls_x509_crt_get_key_usage(gnutls_x509_crt_t cert, unsigned int *key_usage,
 	unsigned int *critical);
-int gnutls_x509_crt_get_version(gnutls_x509_crt cert);
+int gnutls_x509_crt_get_version(gnutls_x509_crt_t cert);
 
-int gnutls_x509_privkey_init(gnutls_x509_privkey * key);
-void gnutls_x509_privkey_deinit(gnutls_x509_privkey key);
+int gnutls_x509_privkey_init(gnutls_x509_privkey_t * key);
+void gnutls_x509_privkey_deinit(gnutls_x509_privkey_t key);
 
-int gnutls_x509_privkey_generate( gnutls_x509_privkey key, gnutls_pk_algorithm algo,
+int gnutls_x509_privkey_generate( gnutls_x509_privkey_t key, gnutls_pk_algorithm_t algo,
 	unsigned int bits, unsigned int flags);
 
-int gnutls_x509_privkey_import(gnutls_x509_privkey key, const gnutls_datum * data,
-	gnutls_x509_crt_fmt format);
-int gnutls_x509_privkey_get_pk_algorithm( gnutls_x509_privkey key);
-int gnutls_x509_privkey_import_rsa_raw(gnutls_x509_privkey key, 
-	const gnutls_datum* m, const gnutls_datum* e,
-	const gnutls_datum* d, const gnutls_datum* p, 
-	const gnutls_datum* q, const gnutls_datum* u);
-int gnutls_x509_privkey_export_rsa_raw(gnutls_x509_privkey key,
-	gnutls_datum * m, gnutls_datum *e,
-	gnutls_datum *d, gnutls_datum *p, gnutls_datum* q, 
-	gnutls_datum* u);
-int gnutls_x509_privkey_export( gnutls_x509_privkey key,
-	gnutls_x509_crt_fmt format, void* output_data, size_t* output_data_size);
+int gnutls_x509_privkey_import(gnutls_x509_privkey_t key, const gnutls_datum_t * data,
+	gnutls_x509_crt_fmt_t format);
+int gnutls_x509_privkey_get_pk_algorithm( gnutls_x509_privkey_t key);
+int gnutls_x509_privkey_import_rsa_raw(gnutls_x509_privkey_t key, 
+	const gnutls_datum_t* m, const gnutls_datum_t* e,
+	const gnutls_datum_t* d, const gnutls_datum_t* p, 
+	const gnutls_datum_t* q, const gnutls_datum_t* u);
+int gnutls_x509_privkey_export_rsa_raw(gnutls_x509_privkey_t key,
+	gnutls_datum_t * m, gnutls_datum_t *e,
+	gnutls_datum_t *d, gnutls_datum_t *p, gnutls_datum_t* q, 
+	gnutls_datum_t* u);
+int gnutls_x509_privkey_export( gnutls_x509_privkey_t key,
+	gnutls_x509_crt_fmt_t format, void* output_data, size_t* output_data_size);
 
 #define GNUTLS_CRL_REASON_UNUSED 128
 #define GNUTLS_CRL_REASON_KEY_COMPROMISE 64
diff --git a/lib/x509/x509_write.c b/lib/x509/x509_write.c
index 0fbe906c19..d7229b48ea 100644
--- a/lib/x509/x509_write.c
+++ b/lib/x509/x509_write.c
@@ -41,11 +41,11 @@
 #include <libtasn1.h>
 #include <gnutls_ui.h>
 
-static void disable_optional_stuff(gnutls_x509_crt cert);
+static void disable_optional_stuff(gnutls_x509_crt_t cert);
 
 /**
   * gnutls_x509_crt_set_dn_by_oid - This function will set the Certificate request subject's distinguished name
-  * @crt: should contain a gnutls_x509_crt structure
+  * @crt: should contain a gnutls_x509_crt_t structure
   * @oid: holds an Object Identifier in a null terminated string
   * @raw_flag: must be 0, or 1 if the data are DER encoded
   * @name: a pointer to the name
@@ -63,7 +63,7 @@ static void disable_optional_stuff(gnutls_x509_crt cert);
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_crt_set_dn_by_oid(gnutls_x509_crt crt, const char *oid,
+int gnutls_x509_crt_set_dn_by_oid(gnutls_x509_crt_t crt, const char *oid,
 				  unsigned int raw_flag, const void *name,
 				  unsigned int sizeof_name)
 {
@@ -77,7 +77,7 @@ int gnutls_x509_crt_set_dn_by_oid(gnutls_x509_crt crt, const char *oid,
 
 /**
   * gnutls_x509_crt_set_issuer_dn_by_oid - This function will set the Certificate request issuer's distinguished name
-  * @crt: should contain a gnutls_x509_crt structure
+  * @crt: should contain a gnutls_x509_crt_t structure
   * @oid: holds an Object Identifier in a null terminated string
   * @raw_flag: must be 0, or 1 if the data are DER encoded
   * @name: a pointer to the name
@@ -98,7 +98,7 @@ int gnutls_x509_crt_set_dn_by_oid(gnutls_x509_crt crt, const char *oid,
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_crt_set_issuer_dn_by_oid(gnutls_x509_crt crt,
+int gnutls_x509_crt_set_issuer_dn_by_oid(gnutls_x509_crt_t crt,
 					 const char *oid,
 					 unsigned int raw_flag,
 					 const void *name,
@@ -114,7 +114,7 @@ int gnutls_x509_crt_set_issuer_dn_by_oid(gnutls_x509_crt crt,
 
 /**
   * gnutls_x509_crt_set_version - This function will set the Certificate request version
-  * @crt: should contain a gnutls_x509_crt structure
+  * @crt: should contain a gnutls_x509_crt_t structure
   * @version: holds the version number. For X.509v1 certificates must be 1.
   *
   * This function will set the version of the certificate. This
@@ -124,7 +124,7 @@ int gnutls_x509_crt_set_issuer_dn_by_oid(gnutls_x509_crt crt,
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_crt_set_version(gnutls_x509_crt crt, unsigned int version)
+int gnutls_x509_crt_set_version(gnutls_x509_crt_t crt, unsigned int version)
 {
     int result;
     unsigned char null = version;
@@ -149,7 +149,7 @@ int gnutls_x509_crt_set_version(gnutls_x509_crt crt, unsigned int version)
 
 /**
   * gnutls_x509_crt_set_key - This function will associate the Certificate with a key
-  * @crt: should contain a gnutls_x509_crt structure
+  * @crt: should contain a gnutls_x509_crt_t structure
   * @key: holds a private key
   *
   * This function will set the public parameters from the given private key to the
@@ -158,7 +158,7 @@ int gnutls_x509_crt_set_version(gnutls_x509_crt crt, unsigned int version)
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_crt_set_key(gnutls_x509_crt crt, gnutls_x509_privkey key)
+int gnutls_x509_crt_set_key(gnutls_x509_crt_t crt, gnutls_x509_privkey_t key)
 {
     int result;
 
@@ -183,7 +183,7 @@ int gnutls_x509_crt_set_key(gnutls_x509_crt crt, gnutls_x509_privkey key)
 
 /**
   * gnutls_x509_crt_set_crq - This function will associate the Certificate with a request
-  * @crt: should contain a gnutls_x509_crt structure
+  * @crt: should contain a gnutls_x509_crt_t structure
   * @crq: holds a certificate request
   *
   * This function will set the name and public parameters from the given certificate request to the
@@ -192,7 +192,7 @@ int gnutls_x509_crt_set_key(gnutls_x509_crt crt, gnutls_x509_privkey key)
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_crt_set_crq(gnutls_x509_crt crt, gnutls_x509_crq crq)
+int gnutls_x509_crt_set_crq(gnutls_x509_crt_t crt, gnutls_x509_crq_t crq)
 {
     int result;
     int pk_algorithm;
@@ -228,7 +228,7 @@ int gnutls_x509_crt_set_crq(gnutls_x509_crt crt, gnutls_x509_crq crq)
 
 /**
   * gnutls_x509_crt_set_ca_status - This function will set the basicConstraints extension
-  * @crt: should contain a gnutls_x509_crt structure
+  * @crt: should contain a gnutls_x509_crt_t structure
   * @ca: true(1) or false(0). Depending on the Certificate authority status.
   *
   * This function will set the basicConstraints certificate extension. 
@@ -236,10 +236,10 @@ int gnutls_x509_crt_set_crq(gnutls_x509_crt crt, gnutls_x509_crq crq)
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_crt_set_ca_status(gnutls_x509_crt crt, unsigned int ca)
+int gnutls_x509_crt_set_ca_status(gnutls_x509_crt_t crt, unsigned int ca)
 {
     int result;
-    gnutls_datum der_data;
+    gnutls_datum_t der_data;
 
     if (crt == NULL) {
 	gnutls_assert();
@@ -271,7 +271,7 @@ int gnutls_x509_crt_set_ca_status(gnutls_x509_crt crt, unsigned int ca)
 
 /**
   * gnutls_x509_crt_set_key_usage - This function will set the keyUsage extension
-  * @crt: should contain a gnutls_x509_crt structure
+  * @crt: should contain a gnutls_x509_crt_t structure
   * @usage: an ORed sequence of the GNUTLS_KEY_* elements.
   *
   * This function will set the keyUsage certificate extension. 
@@ -279,10 +279,10 @@ int gnutls_x509_crt_set_ca_status(gnutls_x509_crt crt, unsigned int ca)
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_crt_set_key_usage(gnutls_x509_crt crt, unsigned int usage)
+int gnutls_x509_crt_set_key_usage(gnutls_x509_crt_t crt, unsigned int usage)
 {
     int result;
-    gnutls_datum der_data;
+    gnutls_datum_t der_data;
 
     if (crt == NULL) {
 	gnutls_assert();
@@ -314,8 +314,8 @@ int gnutls_x509_crt_set_key_usage(gnutls_x509_crt crt, unsigned int usage)
 
 /**
   * gnutls_x509_crt_set_subject_alt_name - This function will set the subject Alternative Name
-  * @crt: should contain a gnutls_x509_crt structure
-  * @type: is one of the gnutls_x509_subject_alt_name enumerations
+  * @crt: should contain a gnutls_x509_crt_t structure
+  * @type: is one of the gnutls_x509_subject_alt_name_t enumerations
   * @data_string: The data to be set
   *
   * This function will set the subject alternative name certificate extension. 
@@ -323,14 +323,14 @@ int gnutls_x509_crt_set_key_usage(gnutls_x509_crt crt, unsigned int usage)
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_crt_set_subject_alternative_name(gnutls_x509_crt crt,
-						 gnutls_x509_subject_alt_name
+int gnutls_x509_crt_set_subject_alternative_name(gnutls_x509_crt_t crt,
+						 gnutls_x509_subject_alt_name_t
 						 type,
 						 const char *data_string)
 {
     int result;
-    gnutls_datum der_data;
-    gnutls_datum dnsname;
+    gnutls_datum_t der_data;
+    gnutls_datum_t dnsname;
     unsigned int critical;
 
     if (crt == NULL) {
@@ -378,7 +378,7 @@ int gnutls_x509_crt_set_subject_alternative_name(gnutls_x509_crt crt,
 
 /**
   * gnutls_x509_crt_sign - This function will sign a Certificate request with a key
-  * @crt: should contain a gnutls_x509_crt structure
+  * @crt: should contain a gnutls_x509_crt_t structure
   * @issuer: is the certificate of the certificate issuer
   * @issuer_key: holds the issuer's private key
   *
@@ -391,8 +391,8 @@ int gnutls_x509_crt_set_subject_alternative_name(gnutls_x509_crt crt,
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_crt_sign(gnutls_x509_crt crt, gnutls_x509_crt issuer,
-			 gnutls_x509_privkey issuer_key)
+int gnutls_x509_crt_sign(gnutls_x509_crt_t crt, gnutls_x509_crt_t issuer,
+			 gnutls_x509_privkey_t issuer_key)
 {
     int result;
 
@@ -417,7 +417,7 @@ int gnutls_x509_crt_sign(gnutls_x509_crt crt, gnutls_x509_crt issuer,
 
 /**
   * gnutls_x509_crt_set_activation_time - This function will set the Certificate's activation time
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @act_time: The actual time
   *
   * This function will set the time this Certificate was or will be activated.
@@ -425,7 +425,7 @@ int gnutls_x509_crt_sign(gnutls_x509_crt crt, gnutls_x509_crt issuer,
   * Returns 0 on success, or a negative value in case of an error.
   *
   **/
-int gnutls_x509_crt_set_activation_time(gnutls_x509_crt cert,
+int gnutls_x509_crt_set_activation_time(gnutls_x509_crt_t cert,
 					time_t act_time)
 {
     if (cert == NULL) {
@@ -440,7 +440,7 @@ int gnutls_x509_crt_set_activation_time(gnutls_x509_crt cert,
 
 /**
   * gnutls_x509_crt_set_expiration_time - This function will set the Certificate's expiration time
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @exp_time: The actual time
   *
   * This function will set the time this Certificate will expire.
@@ -448,7 +448,7 @@ int gnutls_x509_crt_set_activation_time(gnutls_x509_crt cert,
   * Returns 0 on success, or a negative value in case of an error.
   *
   **/
-int gnutls_x509_crt_set_expiration_time(gnutls_x509_crt cert,
+int gnutls_x509_crt_set_expiration_time(gnutls_x509_crt_t cert,
 					time_t exp_time)
 {
     if (cert == NULL) {
@@ -462,7 +462,7 @@ int gnutls_x509_crt_set_expiration_time(gnutls_x509_crt cert,
 
 /**
   * gnutls_x509_crt_set_serial - This function will set the certificate's serial number
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @serial: The serial number
   * @serial_size: Holds the size of the serial field.
   *
@@ -474,7 +474,7 @@ int gnutls_x509_crt_set_expiration_time(gnutls_x509_crt cert,
   * Returns 0 on success, or a negative value in case of an error.
   *
   **/
-int gnutls_x509_crt_set_serial(gnutls_x509_crt cert, const void *serial,
+int gnutls_x509_crt_set_serial(gnutls_x509_crt_t cert, const void *serial,
 			       size_t serial_size)
 {
     int ret;
@@ -499,7 +499,7 @@ int gnutls_x509_crt_set_serial(gnutls_x509_crt cert, const void *serial,
 /* If OPTIONAL fields have not been initialized then
  * disable them.
  */
-static void disable_optional_stuff(gnutls_x509_crt cert)
+static void disable_optional_stuff(gnutls_x509_crt_t cert)
 {
 
     asn1_write_value(cert->cert, "tbsCertificate.issuerUniqueID", NULL, 0);
@@ -517,8 +517,8 @@ static void disable_optional_stuff(gnutls_x509_crt cert)
 
 /**
   * gnutls_x509_crt_set_crl_dist_points - This function will set the CRL dist points
-  * @crt: should contain a gnutls_x509_crt structure
-  * @type: is one of the gnutls_x509_subject_alt_name enumerations
+  * @crt: should contain a gnutls_x509_crt_t structure
+  * @type: is one of the gnutls_x509_subject_alt_name_t enumerations
   * @data_string: The data to be set
   * @reason_flags: revocation reasons
   *
@@ -527,14 +527,14 @@ static void disable_optional_stuff(gnutls_x509_crt cert)
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_crt_set_crl_dist_points(gnutls_x509_crt crt,
-					gnutls_x509_subject_alt_name type,
+int gnutls_x509_crt_set_crl_dist_points(gnutls_x509_crt_t crt,
+					gnutls_x509_subject_alt_name_t type,
 					const void *data_string,
 					unsigned int reason_flags)
 {
     int result;
-    gnutls_datum der_data;
-    gnutls_datum oldname;
+    gnutls_datum_t der_data;
+    gnutls_datum_t oldname;
     unsigned int critical;
 
     if (crt == NULL) {
@@ -582,7 +582,7 @@ int gnutls_x509_crt_set_crl_dist_points(gnutls_x509_crt crt,
 
 /**
   * gnutls_x509_crt_cpy_crl_dist_points - This function will copy the CRL dist points
-  * @dst: should contain a gnutls_x509_crt structure
+  * @dst: should contain a gnutls_x509_crt_t structure
   * @src: the certificate where the dist points will be copied from
   *
   * This function will copy the CRL distribution points certificate 
@@ -592,11 +592,11 @@ int gnutls_x509_crt_set_crl_dist_points(gnutls_x509_crt crt,
   * Returns 0 on success.
   *
   **/
-int gnutls_x509_crt_cpy_crl_dist_points(gnutls_x509_crt dst,
-					gnutls_x509_crt src)
+int gnutls_x509_crt_cpy_crl_dist_points(gnutls_x509_crt_t dst,
+					gnutls_x509_crt_t src)
 {
     int result;
-    gnutls_datum der_data;
+    gnutls_datum_t der_data;
     unsigned int critical;
 
     if (dst == NULL || src == NULL) {
@@ -631,7 +631,7 @@ int gnutls_x509_crt_cpy_crl_dist_points(gnutls_x509_crt dst,
 
 /**
   * gnutls_x509_crt_set_subject_key_id - This function will set the certificate's subject key id
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @id: The key ID
   * @id_size: Holds the size of the serial field.
   *
@@ -640,11 +640,11 @@ int gnutls_x509_crt_cpy_crl_dist_points(gnutls_x509_crt dst,
   * Returns 0 on success, or a negative value in case of an error.
   *
   **/
-int gnutls_x509_crt_set_subject_key_id(gnutls_x509_crt cert,
+int gnutls_x509_crt_set_subject_key_id(gnutls_x509_crt_t cert,
 				       const void *id, size_t id_size)
 {
     int result;
-    gnutls_datum old_id, der_data;
+    gnutls_datum_t old_id, der_data;
     unsigned int critical;
 
     if (cert == NULL) {
@@ -690,7 +690,7 @@ int gnutls_x509_crt_set_subject_key_id(gnutls_x509_crt cert,
 
 /**
   * gnutls_x509_crt_set_authority_key_id - This function will set the certificate authority's key id
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @id: The key ID
   * @id_size: Holds the size of the serial field.
   *
@@ -700,11 +700,11 @@ int gnutls_x509_crt_set_subject_key_id(gnutls_x509_crt cert,
   * Returns 0 on success, or a negative value in case of an error.
   *
   **/
-int gnutls_x509_crt_set_authority_key_id(gnutls_x509_crt cert,
+int gnutls_x509_crt_set_authority_key_id(gnutls_x509_crt_t cert,
 					 const void *id, size_t id_size)
 {
     int result;
-    gnutls_datum old_id, der_data;
+    gnutls_datum_t old_id, der_data;
     unsigned int critical;
 
     if (cert == NULL) {
@@ -750,7 +750,7 @@ int gnutls_x509_crt_set_authority_key_id(gnutls_x509_crt cert,
 
 /**
   * gnutls_x509_crt_set_key_purpose_oid - This function sets the Certificate's key purpose OIDs
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @oid: a pointer to a null terminated string that holds the OID
   * @critical: Whether this extension will be critical or not
   *
@@ -763,12 +763,12 @@ int gnutls_x509_crt_set_authority_key_id(gnutls_x509_crt cert,
   * On success 0 is returned.
   *
   **/
-int gnutls_x509_crt_set_key_purpose_oid(gnutls_x509_crt cert,
+int gnutls_x509_crt_set_key_purpose_oid(gnutls_x509_crt_t cert,
 					const void *oid,
 					unsigned int critical)
 {
     int result;
-    gnutls_datum old_id, der_data;
+    gnutls_datum_t old_id, der_data;
     ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
 
     if (cert == NULL) {
diff --git a/lib/x509/xml.c b/lib/x509/xml.c
index e5b1350f34..874c91825c 100644
--- a/lib/x509/xml.c
+++ b/lib/x509/xml.c
@@ -201,7 +201,7 @@ static int normalize_name(ASN1_TYPE p, char *output, int output_size)
 
 static int
 _gnutls_asn1_get_structure_xml(ASN1_TYPE structure,
-			       gnutls_datum * res, int detail)
+			       gnutls_datum_t * res, int detail)
 {
     node_asn *p, *root;
     int k, indent = 0, len, len2, len3;
@@ -586,7 +586,7 @@ _gnutls_asn1_get_structure_xml(ASN1_TYPE structure,
 
 /**
   * gnutls_x509_crt_to_xml - This function parses an RDN sequence
-  * @cert: should contain a gnutls_x509_crt structure
+  * @cert: should contain a gnutls_x509_crt_t structure
   * @res: The datum that will hold the result
   * @detail: The detail level (must be GNUTLS_XML_SHOW_ALL or GNUTLS_XML_NORMAL)
   *
@@ -595,7 +595,7 @@ _gnutls_asn1_get_structure_xml(ASN1_TYPE structure,
   * Returns a negative error code in case of an error.
   *
   **/
-int gnutls_x509_crt_to_xml(gnutls_x509_crt cert, gnutls_datum * res,
+int gnutls_x509_crt_to_xml(gnutls_x509_crt_t cert, gnutls_datum_t * res,
 			   int detail)
 {
     int result;
diff --git a/lib/x509_b64.c b/lib/x509_b64.c
index dcdb9dbade..61b8fdfe51 100644
--- a/lib/x509_b64.c
+++ b/lib/x509_b64.c
@@ -284,7 +284,7 @@ int _gnutls_fbase64_encode(const char *msg, const uint8 * data,
   * the terminating null.
   * 
   **/
-int gnutls_pem_base64_encode(const char *msg, const gnutls_datum * data,
+int gnutls_pem_base64_encode(const char *msg, const gnutls_datum_t * data,
 			     char *result, size_t * result_size)
 {
     opaque *ret;
@@ -321,8 +321,8 @@ int gnutls_pem_base64_encode(const char *msg, const gnutls_datum * data,
   * 
   **/
 int gnutls_pem_base64_encode_alloc(const char *msg,
-				   const gnutls_datum * data,
-				   gnutls_datum * result)
+				   const gnutls_datum_t * data,
+				   gnutls_datum_t * result)
 {
     opaque *ret;
     int size;
@@ -499,7 +499,7 @@ int _gnutls_fbase64_decode(const char *header, const opaque * data,
   * or 0 on success.
   **/
 int gnutls_pem_base64_decode(const char *header,
-			     const gnutls_datum * b64_data,
+			     const gnutls_datum_t * b64_data,
 			     unsigned char *result, size_t * result_size)
 {
     opaque *ret;
@@ -540,8 +540,8 @@ int gnutls_pem_base64_decode(const char *header,
   *
   **/
 int gnutls_pem_base64_decode_alloc(const char *header,
-				   const gnutls_datum * b64_data,
-				   gnutls_datum * result)
+				   const gnutls_datum_t * b64_data,
+				   gnutls_datum_t * result)
 {
     opaque *ret;
     int size;
diff --git a/libextra/auth_srp.c b/libextra/auth_srp.c
index 306d49a5b2..750e25bcb4 100644
--- a/libextra/auth_srp.c
+++ b/libextra/auth_srp.c
@@ -35,11 +35,11 @@
 #include <gnutls_datum.h>
 #include <gnutls_alert.h>
 
-int _gnutls_gen_srp_server_kx(gnutls_session, opaque **);
-int _gnutls_gen_srp_client_kx(gnutls_session, opaque **);
+int _gnutls_gen_srp_server_kx(gnutls_session_t, opaque **);
+int _gnutls_gen_srp_client_kx(gnutls_session_t, opaque **);
 
-int _gnutls_proc_srp_server_kx(gnutls_session, opaque *, size_t);
-int _gnutls_proc_srp_client_kx(gnutls_session, opaque *, size_t);
+int _gnutls_proc_srp_server_kx(gnutls_session_t, opaque *, size_t);
+int _gnutls_proc_srp_client_kx(gnutls_session_t, opaque *, size_t);
 
 const mod_auth_st srp_auth_struct = {
     "SRP",
@@ -72,10 +72,10 @@ const mod_auth_st srp_auth_struct = {
  * Returns a proper error code in that case, and 0 when
  * all are ok.
  */
-inline static int check_b_mod_n(GNUTLS_MPI b, GNUTLS_MPI n)
+inline static int check_b_mod_n(mpi_t b, mpi_t n)
 {
     int ret;
-    GNUTLS_MPI r = _gnutls_mpi_alloc_like(b);
+    mpi_t r = _gnutls_mpi_alloc_like(b);
 
     if (r == NULL) {
 	gnutls_assert();
@@ -99,10 +99,10 @@ inline static int check_b_mod_n(GNUTLS_MPI b, GNUTLS_MPI n)
  * Returns a proper error code in that case, and 0 when
  * all are ok.
  */
-inline static int check_a_mod_n(GNUTLS_MPI a, GNUTLS_MPI n)
+inline static int check_a_mod_n(mpi_t a, mpi_t n)
 {
     int ret;
-    GNUTLS_MPI r = _gnutls_mpi_alloc_like(a);
+    mpi_t r = _gnutls_mpi_alloc_like(a);
 
     if (r == NULL) {
 	gnutls_assert();
@@ -126,7 +126,7 @@ inline static int check_a_mod_n(GNUTLS_MPI a, GNUTLS_MPI n)
 /* Send the first key exchange message ( g, n, s) and append the verifier algorithm number 
  * Data is allocated by the caller, and should have data_size size.
  */
-int _gnutls_gen_srp_server_kx(gnutls_session session, opaque ** data)
+int _gnutls_gen_srp_server_kx(gnutls_session_t session, opaque ** data)
 {
     int ret;
     uint8 *data_n, *data_s;
@@ -238,7 +238,7 @@ int _gnutls_gen_srp_server_kx(gnutls_session session, opaque ** data)
 }
 
 /* return A = g^a % N */
-int _gnutls_gen_srp_client_kx(gnutls_session session, opaque ** data)
+int _gnutls_gen_srp_client_kx(gnutls_session_t session, opaque ** data)
 {
     size_t n_a;
     int ret;
@@ -246,7 +246,7 @@ int _gnutls_gen_srp_client_kx(gnutls_session session, opaque ** data)
     char *username;
     char buf[64];
     char *password;
-    const gnutls_srp_client_credentials cred =
+    const gnutls_srp_client_credentials_t cred =
 	_gnutls_get_cred(session->key, GNUTLS_CRD_SRP, NULL);
 
     if (cred == NULL) {
@@ -341,7 +341,7 @@ int _gnutls_gen_srp_client_kx(gnutls_session session, opaque ** data)
 
 
 /* just read A and put it to session */
-int _gnutls_proc_srp_client_kx(gnutls_session session, opaque * data,
+int _gnutls_proc_srp_client_kx(gnutls_session_t session, opaque * data,
 			       size_t _data_size)
 {
     size_t _n_A;
@@ -430,10 +430,10 @@ static const unsigned char srp_params_1024[] = {
 
 static const unsigned char srp_generator = 0x02;
 
-const gnutls_datum gnutls_srp_1024_group_prime = {
+const gnutls_datum_t gnutls_srp_1024_group_prime = {
     (void *) srp_params_1024, sizeof(srp_params_1024)
 };
-const gnutls_datum gnutls_srp_1024_group_generator = {
+const gnutls_datum_t gnutls_srp_1024_group_generator = {
     (void *) &srp_generator, sizeof(srp_generator)
 };
 
@@ -462,10 +462,10 @@ static const unsigned char srp_params_1536[] = {
     0x35, 0xF9, 0xBB
 };
 
-const gnutls_datum gnutls_srp_1536_group_prime = {
+const gnutls_datum_t gnutls_srp_1536_group_prime = {
     (void *) srp_params_1536, sizeof(srp_params_1536)
 };
-const gnutls_datum gnutls_srp_1536_group_generator = {
+const gnutls_datum_t gnutls_srp_1536_group_generator = {
     (void *) &srp_generator, sizeof(srp_generator)
 };
 
@@ -501,10 +501,10 @@ static const unsigned char srp_params_2048[] = {
     0x9E, 0x4A, 0xFF, 0x73
 };
 
-const gnutls_datum gnutls_srp_2048_group_prime = {
+const gnutls_datum_t gnutls_srp_2048_group_prime = {
     (void *) srp_params_2048, sizeof(srp_params_2048)
 };
-const gnutls_datum gnutls_srp_2048_group_generator = {
+const gnutls_datum_t gnutls_srp_2048_group_generator = {
     (void *) &srp_generator, sizeof(srp_generator)
 };
 
@@ -539,9 +539,9 @@ static int check_g_n(const opaque * g, size_t n_g,
 /* Check if N is a prime and G a generator of the
  * group.
  */
-static int group_check_g_n(GNUTLS_MPI g, GNUTLS_MPI n)
+static int group_check_g_n(mpi_t g, mpi_t n)
 {
-    GNUTLS_MPI q = NULL, two = NULL, w = NULL;
+    mpi_t q = NULL, two = NULL, w = NULL;
     int ret;
 
     /* N must be of the form N=2q+1
@@ -629,7 +629,7 @@ static int group_check_g_n(GNUTLS_MPI g, GNUTLS_MPI n)
 
 /* receive the key exchange message ( n, g, s, B) 
  */
-int _gnutls_proc_srp_server_kx(gnutls_session session, opaque * data,
+int _gnutls_proc_srp_server_kx(gnutls_session_t session, opaque * data,
 			       size_t _data_size)
 {
     uint8 n_s;
@@ -644,7 +644,7 @@ int _gnutls_proc_srp_server_kx(gnutls_session session, opaque * data,
     char *username, *password;
     ssize_t data_size = _data_size;
 
-    const gnutls_srp_client_credentials cred =
+    const gnutls_srp_client_credentials_t cred =
 	_gnutls_get_cred(session->key, GNUTLS_CRD_SRP, NULL);
 
     if (cred == NULL) {
diff --git a/libextra/auth_srp.h b/libextra/auth_srp.h
index bd1a9bfd7f..7060277204 100644
--- a/libextra/auth_srp.h
+++ b/libextra/auth_srp.h
@@ -4,11 +4,11 @@
 #include <gnutls_auth.h>
 
 
-typedef int gnutls_srp_server_credentials_function(gnutls_session,
-   const char *username, gnutls_datum * salt, gnutls_datum * verifier,
-   gnutls_datum * generator, gnutls_datum * prime);
+typedef int gnutls_srp_server_credentials_function(gnutls_session_t,
+   const char *username, gnutls_datum_t * salt, gnutls_datum_t * verifier,
+   gnutls_datum_t * generator, gnutls_datum_t * prime);
 
-typedef int gnutls_srp_client_credentials_function(gnutls_session,
+typedef int gnutls_srp_client_credentials_function(gnutls_session_t,
    unsigned int times, char **username, char** password);
 
 
@@ -18,7 +18,7 @@ typedef struct {
    gnutls_srp_client_credentials_function *get_function;
 } srp_client_credentials_st;
 
-#define gnutls_srp_client_credentials srp_client_credentials_st*
+#define gnutls_srp_client_credentials_t srp_client_credentials_st*
 
 typedef struct {
    char *password_file;
@@ -29,7 +29,7 @@ typedef struct {
    gnutls_srp_server_credentials_function *pwd_callback;
 } srp_server_cred_st;
 
-#define gnutls_srp_server_credentials srp_server_cred_st*
+#define gnutls_srp_server_credentials_t srp_server_cred_st*
 
 /* these structures should not use allocated data */
 typedef struct srp_server_auth_info_st {
@@ -38,16 +38,16 @@ typedef struct srp_server_auth_info_st {
 
 #ifdef ENABLE_SRP
 
-int _gnutls_proc_srp_server_hello(gnutls_session state,
+int _gnutls_proc_srp_server_hello(gnutls_session_t state,
 				  const opaque * data, size_t data_size);
-int _gnutls_gen_srp_server_hello(gnutls_session state, opaque * data,
+int _gnutls_gen_srp_server_hello(gnutls_session_t state, opaque * data,
 				 size_t data_size);
 
-int _gnutls_gen_srp_server_kx(gnutls_session, opaque **);
-int _gnutls_gen_srp_client_kx(gnutls_session, opaque **);
+int _gnutls_gen_srp_server_kx(gnutls_session_t, opaque **);
+int _gnutls_gen_srp_client_kx(gnutls_session_t, opaque **);
 
-int _gnutls_proc_srp_server_kx(gnutls_session, opaque *, size_t);
-int _gnutls_proc_srp_client_kx(gnutls_session, opaque *, size_t);
+int _gnutls_proc_srp_server_kx(gnutls_session_t, opaque *, size_t);
+int _gnutls_proc_srp_client_kx(gnutls_session_t, opaque *, size_t);
 
 typedef struct srp_server_auth_info_st srp_server_auth_info_st;
 
diff --git a/libextra/auth_srp_passwd.c b/libextra/auth_srp_passwd.c
index 981dd8e4f6..037b1cb232 100644
--- a/libextra/auth_srp_passwd.c
+++ b/libextra/auth_srp_passwd.c
@@ -221,10 +221,10 @@ static int pwd_read_conf(const char *pconf_file, SRP_PWD_ENTRY * entry,
 
 }
 
-int _gnutls_srp_pwd_read_entry(gnutls_session state, char *username,
+int _gnutls_srp_pwd_read_entry(gnutls_session_t state, char *username,
 			       SRP_PWD_ENTRY ** _entry)
 {
-    const gnutls_srp_server_credentials cred;
+    const gnutls_srp_server_credentials_t cred;
     FILE *fd;
     char line[2 * 1024];
     uint i, len;
diff --git a/libextra/auth_srp_passwd.h b/libextra/auth_srp_passwd.h
index a6adf875b8..a9ff502536 100644
--- a/libextra/auth_srp_passwd.h
+++ b/libextra/auth_srp_passwd.h
@@ -3,14 +3,14 @@
 typedef struct {
 	char* username;
 	
-	gnutls_datum salt;
-	gnutls_datum v;
-	gnutls_datum g;
-	gnutls_datum n;
+	gnutls_datum_t salt;
+	gnutls_datum_t v;
+	gnutls_datum_t g;
+	gnutls_datum_t n;
 } SRP_PWD_ENTRY;
 
 /* this is locally allocated. It should be freed using the provided function */
-int _gnutls_srp_pwd_read_entry( gnutls_session state, char* username, SRP_PWD_ENTRY**);
+int _gnutls_srp_pwd_read_entry( gnutls_session_t state, char* username, SRP_PWD_ENTRY**);
 void _gnutls_srp_entry_free( SRP_PWD_ENTRY * entry);
 int _gnutls_sbase64_encode(uint8 * data, size_t data_size, uint8 ** result);
 int _gnutls_sbase64_decode(uint8 * data, size_t data_size, uint8 ** result);
diff --git a/libextra/auth_srp_rsa.c b/libextra/auth_srp_rsa.c
index aec03b17c6..5bccdb268e 100644
--- a/libextra/auth_srp_rsa.c
+++ b/libextra/auth_srp_rsa.c
@@ -39,8 +39,8 @@
 #include <gnutls_x509.h>
 #include <gnutls_extra.h>
 
-static int gen_srp_cert_server_kx(gnutls_session, opaque **);
-static int proc_srp_cert_server_kx(gnutls_session, opaque *, size_t);
+static int gen_srp_cert_server_kx(gnutls_session_t, opaque **);
+static int proc_srp_cert_server_kx(gnutls_session_t, opaque *, size_t);
 
 const mod_auth_st srp_rsa_auth_struct = {
     "SRP",
@@ -76,11 +76,11 @@ const mod_auth_st srp_dss_auth_struct = {
     NULL
 };
 
-static int gen_srp_cert_server_kx(gnutls_session session, opaque ** data)
+static int gen_srp_cert_server_kx(gnutls_session_t session, opaque ** data)
 {
     ssize_t ret, data_size;
-    gnutls_datum signature, ddata;
-    const gnutls_certificate_credentials cred;
+    gnutls_datum_t signature, ddata;
+    const gnutls_certificate_credentials_t cred;
     gnutls_cert *apr_cert_list;
     gnutls_privkey *apr_pkey;
     int apr_cert_list_length;
@@ -133,12 +133,12 @@ static int gen_srp_cert_server_kx(gnutls_session session, opaque ** data)
 
 }
 
-static int proc_srp_cert_server_kx(gnutls_session session, opaque * data,
+static int proc_srp_cert_server_kx(gnutls_session_t session, opaque * data,
 				   size_t _data_size)
 {
     ssize_t ret;
     int sigsize;
-    gnutls_datum vparams, signature;
+    gnutls_datum_t vparams, signature;
     ssize_t data_size;
     cert_auth_info_t info;
     gnutls_cert peer_cert;
diff --git a/libextra/auth_srp_sb64.c b/libextra/auth_srp_sb64.c
index 9b0eb65979..975ebf5ca1 100644
--- a/libextra/auth_srp_sb64.c
+++ b/libextra/auth_srp_sb64.c
@@ -296,7 +296,7 @@ int _gnutls_sbase64_decode(uint8 * data, size_t idata_size,
   * If the provided buffer is not long enough GNUTLS_E_SHORT_MEMORY_BUFFER is returned.
   * 
   **/
-int gnutls_srp_base64_encode(const gnutls_datum * data, char *result,
+int gnutls_srp_base64_encode(const gnutls_datum_t * data, char *result,
 			     int *result_size)
 {
     opaque *ret;
@@ -331,8 +331,8 @@ int gnutls_srp_base64_encode(const gnutls_datum * data, char *result,
   * You should use gnutls_free() to free the returned data.
   * 
   **/
-int gnutls_srp_base64_encode_alloc(const gnutls_datum * data,
-				   gnutls_datum * result)
+int gnutls_srp_base64_encode_alloc(const gnutls_datum_t * data,
+				   gnutls_datum_t * result)
 {
     opaque *ret;
     int size;
@@ -366,7 +366,7 @@ int gnutls_srp_base64_encode_alloc(const gnutls_datum * data,
   * Returns GNUTLS_E_SHORT_MEMORY_BUFFER if the buffer given is not long enough,
   * or 0 on success.
   **/
-int gnutls_srp_base64_decode(const gnutls_datum * b64_data, char *result,
+int gnutls_srp_base64_decode(const gnutls_datum_t * b64_data, char *result,
 			     int *result_size)
 {
     opaque *ret;
@@ -401,8 +401,8 @@ int gnutls_srp_base64_decode(const gnutls_datum * b64_data, char *result,
   * You should use gnutls_free() to free the returned data.
   * 
   **/
-int gnutls_srp_base64_decode_alloc(const gnutls_datum * b64_data,
-				   gnutls_datum * result)
+int gnutls_srp_base64_decode_alloc(const gnutls_datum_t * b64_data,
+				   gnutls_datum_t * result)
 {
     opaque *ret;
     int size;
diff --git a/libextra/ext_srp.c b/libextra/ext_srp.c
index d148094d40..990c810847 100644
--- a/libextra/ext_srp.c
+++ b/libextra/ext_srp.c
@@ -30,7 +30,7 @@
 #include "gnutls_algorithms.h"
 #include <gnutls_num.h>
 
-int _gnutls_srp_recv_params(gnutls_session session, const opaque * data,
+int _gnutls_srp_recv_params(gnutls_session_t session, const opaque * data,
 			    size_t _data_size)
 {
     uint8 len;
@@ -77,7 +77,7 @@ inline static int is_srp(cipher_suite_st suite)
 /* returns data_size or a negative number on failure
  * data is allocated locally
  */
-int _gnutls_srp_send_params(gnutls_session session, opaque * data,
+int _gnutls_srp_send_params(gnutls_session_t session, opaque * data,
 			    size_t data_size)
 {
     uint len;
@@ -92,7 +92,7 @@ int _gnutls_srp_send_params(gnutls_session session, opaque * data,
 
     /* this function sends the client extension data (username) */
     if (session->security_parameters.entity == GNUTLS_CLIENT) {
-	const gnutls_srp_client_credentials cred =
+	const gnutls_srp_client_credentials_t cred =
 	    _gnutls_get_cred(session->key, GNUTLS_CRD_SRP, NULL);
 
 	if (cred == NULL)
diff --git a/libextra/ext_srp.h b/libextra/ext_srp.h
index 7e231be3dc..8f69518be9 100644
--- a/libextra/ext_srp.h
+++ b/libextra/ext_srp.h
@@ -3,7 +3,7 @@
 #define IS_SRP_KX(kx) ((kx == GNUTLS_KX_SRP || (kx == GNUTLS_KX_SRP_RSA) || \
           kx == GNUTLS_KX_SRP_DSS)?1:0)
           
-int _gnutls_srp_recv_params( gnutls_session state, const opaque* data, size_t data_size);
-int _gnutls_srp_send_params( gnutls_session state, opaque* data, size_t);
+int _gnutls_srp_recv_params( gnutls_session_t state, const opaque* data, size_t data_size);
+int _gnutls_srp_send_params( gnutls_session_t state, opaque* data, size_t);
 
 #endif
diff --git a/libextra/gnutls_extra.h b/libextra/gnutls_extra.h
index 40aef209d2..4d6e24479f 100644
--- a/libextra/gnutls_extra.h
+++ b/libextra/gnutls_extra.h
@@ -1,18 +1,18 @@
 #include <auth_cert.h>
 
 typedef int (*OPENPGP_VERIFY_KEY_FUNC)( const char *,
-	const gnutls_datum *, const gnutls_datum*, int);
-typedef time_t (*OPENPGP_KEY_CREATION_TIME_FUNC)( const gnutls_datum*);
-typedef time_t (*OPENPGP_KEY_EXPIRATION_TIME_FUNC)( const gnutls_datum*);
-typedef int (*OPENPGP_KEY_REQUEST)(gnutls_session, gnutls_datum*, 
-	const gnutls_certificate_credentials, opaque*,int);
-typedef int (*OPENPGP_FINGERPRINT)(const gnutls_datum*, unsigned char*, size_t*);
+	const gnutls_datum_t *, const gnutls_datum_t*, int);
+typedef time_t (*OPENPGP_KEY_CREATION_TIME_FUNC)( const gnutls_datum_t*);
+typedef time_t (*OPENPGP_KEY_EXPIRATION_TIME_FUNC)( const gnutls_datum_t*);
+typedef int (*OPENPGP_KEY_REQUEST)(gnutls_session_t, gnutls_datum_t*, 
+	const gnutls_certificate_credentials_t, opaque*,int);
+typedef int (*OPENPGP_FINGERPRINT)(const gnutls_datum_t*, unsigned char*, size_t*);
 
-typedef int (*OPENPGP_RAW_KEY_TO_GCERT)(gnutls_cert*, const gnutls_datum*);
-typedef int (*OPENPGP_RAW_PRIVKEY_TO_GKEY)(gnutls_privkey*, const gnutls_datum*);
+typedef int (*OPENPGP_RAW_KEY_TO_GCERT)(gnutls_cert*, const gnutls_datum_t*);
+typedef int (*OPENPGP_RAW_PRIVKEY_TO_GKEY)(gnutls_privkey*, const gnutls_datum_t*);
 
-typedef int (*OPENPGP_KEY_TO_GCERT)(gnutls_cert*, gnutls_openpgp_key);
-typedef int (*OPENPGP_PRIVKEY_TO_GKEY)(gnutls_privkey*, gnutls_openpgp_privkey);
+typedef int (*OPENPGP_KEY_TO_GCERT)(gnutls_cert*, gnutls_openpgp_key_t);
+typedef int (*OPENPGP_PRIVKEY_TO_GKEY)(gnutls_privkey*, gnutls_openpgp_privkey_t);
 
-typedef void (*OPENPGP_KEY_DEINIT)(gnutls_openpgp_key);
-typedef void (*OPENPGP_PRIVKEY_DEINIT)(gnutls_openpgp_privkey);
+typedef void (*OPENPGP_KEY_DEINIT)(gnutls_openpgp_key_t);
+typedef void (*OPENPGP_PRIVKEY_DEINIT)(gnutls_openpgp_privkey_t);
diff --git a/libextra/gnutls_openpgp.c b/libextra/gnutls_openpgp.c
index c861e4dd48..71430a4db6 100644
--- a/libextra/gnutls_openpgp.c
+++ b/libextra/gnutls_openpgp.c
@@ -40,9 +40,9 @@
 
 
 
-static void release_mpi_array(GNUTLS_MPI * arr, size_t n)
+static void release_mpi_array(mpi_t * arr, size_t n)
 {
-    GNUTLS_MPI x;
+    mpi_t x;
 
     while (arr && n--) {
 	x = *arr;
@@ -152,7 +152,7 @@ cdk_keydb_hd_t kbx_to_keydb(keybox_blob * blob)
 
 
 /* Extract a keybox blob from the given position. */
-keybox_blob *kbx_read_blob(const gnutls_datum * keyring, size_t pos)
+keybox_blob *kbx_read_blob(const gnutls_datum_t * keyring, size_t pos)
 {
     keybox_blob *blob = NULL;
     int rc;
@@ -219,7 +219,7 @@ static uint8 *kbx_data_to_keyring(int type, int enc, const char *data,
 }
 
 
-cdk_packet_t search_packet(const gnutls_datum * buf, int pkttype)
+cdk_packet_t search_packet(const gnutls_datum_t * buf, int pkttype)
 {
     static cdk_kbnode_t knode = NULL;
     cdk_packet_t pkt;
@@ -293,7 +293,7 @@ openpgp_pk_to_gnutls_cert(gnutls_cert * cert, cdk_pkt_pubkey_t pk)
  -*/
 int
 _gnutls_openpgp_raw_privkey_to_gkey(gnutls_privkey * pkey,
-				    const gnutls_datum * raw_key)
+				    const gnutls_datum_t * raw_key)
 {
     cdk_kbnode_t snode;
     cdk_packet_t pkt;
@@ -376,7 +376,7 @@ _gnutls_openpgp_raw_privkey_to_gkey(gnutls_privkey * pkey,
  -*/
 int
 _gnutls_openpgp_raw_key_to_gcert(gnutls_cert * cert,
-				 const gnutls_datum * raw)
+				 const gnutls_datum_t * raw)
 {
     cdk_kbnode_t knode = NULL;
     cdk_packet_t pkt = NULL;
@@ -417,7 +417,7 @@ _gnutls_openpgp_raw_key_to_gcert(gnutls_cert * cert,
  * from a binary or a file keyring.
  -*/
 int
-gnutls_openpgp_get_key(gnutls_datum * key, const gnutls_datum * keyring,
+gnutls_openpgp_get_key(gnutls_datum_t * key, const gnutls_datum_t * keyring,
 		       key_attr_t by, opaque * pattern)
 {
     keybox_blob *blob = NULL;
@@ -480,7 +480,7 @@ gnutls_openpgp_get_key(gnutls_datum * key, const gnutls_datum * keyring,
     return rc;
 }
 
-static int stream_to_datum(cdk_stream_t inp, gnutls_datum * raw)
+static int stream_to_datum(cdk_stream_t inp, gnutls_datum_t * raw)
 {
     uint8 buf[4096];
     int rc = 0, nread, nbytes = 0;
@@ -518,11 +518,11 @@ static int stream_to_datum(cdk_stream_t inp, gnutls_datum * raw)
  * should only contain one key which should not be encrypted.
  **/
 int
-gnutls_certificate_set_openpgp_key_mem(gnutls_certificate_credentials res,
-				       const gnutls_datum * cert,
-				       const gnutls_datum * key)
+gnutls_certificate_set_openpgp_key_mem(gnutls_certificate_credentials_t res,
+				       const gnutls_datum_t * cert,
+				       const gnutls_datum_t * key)
 {
-    gnutls_datum raw;
+    gnutls_datum_t raw;
     cdk_kbnode_t knode = NULL, ctx = NULL, p;
     cdk_packet_t pkt;
     int i = 0;
@@ -658,13 +658,13 @@ gnutls_certificate_set_openpgp_key_mem(gnutls_certificate_credentials res,
  * should only contain one key which should not be encrypted.
  **/
 int
-gnutls_certificate_set_openpgp_key_file(gnutls_certificate_credentials res,
+gnutls_certificate_set_openpgp_key_file(gnutls_certificate_credentials_t res,
 					const char *certfile,
 					const char *keyfile)
 {
     struct stat statbuf;
     int rc = 0;
-    gnutls_datum key, cert;
+    gnutls_datum_t key, cert;
     strfile xcert, xkey;
 
     if (!res || !keyfile || !certfile) {
@@ -710,7 +710,7 @@ gnutls_certificate_set_openpgp_key_file(gnutls_certificate_credentials res,
 }
 
 
-int gnutls_openpgp_count_key_names(const gnutls_datum * cert)
+int gnutls_openpgp_count_key_names(const gnutls_datum_t * cert)
 {
     cdk_kbnode_t knode, p, ctx = NULL;
     cdk_packet_t pkt;
@@ -747,7 +747,7 @@ int gnutls_openpgp_count_key_names(const gnutls_datum * cert)
  * is needed for an operations.
  -*/
 int
-gnutls_openpgp_add_keyring_file(gnutls_datum * keyring, const char *name)
+gnutls_openpgp_add_keyring_file(gnutls_datum_t * keyring, const char *name)
 {
     cdk_stream_t inp = NULL;
     uint8 *blob;
@@ -789,7 +789,7 @@ gnutls_openpgp_add_keyring_file(gnutls_datum * keyring, const char *name)
  * data instead of the filename.
  -*/
 int
-gnutls_openpgp_add_keyring_mem(gnutls_datum * keyring,
+gnutls_openpgp_add_keyring_mem(gnutls_datum_t * keyring,
 			       const void *data, size_t len)
 {
     uint8 *blob;
@@ -824,7 +824,7 @@ gnutls_openpgp_add_keyring_mem(gnutls_datum * keyring,
  *
  **/
 int
-gnutls_certificate_set_openpgp_keyring_file(gnutls_certificate_credentials
+gnutls_certificate_set_openpgp_keyring_file(gnutls_certificate_credentials_t
 					    c, const char *file)
 {
     struct stat statbuf;
@@ -842,7 +842,7 @@ gnutls_certificate_set_openpgp_keyring_file(gnutls_certificate_credentials
 
 
 int
-gnutls_certificate_set_openpgp_keyring_mem(gnutls_certificate_credentials
+gnutls_certificate_set_openpgp_keyring_mem(gnutls_certificate_credentials_t
 					   c, const opaque * data,
 					   size_t dlen)
 {
@@ -885,8 +885,8 @@ gnutls_certificate_set_openpgp_keyring_mem(gnutls_certificate_credentials
 
 /*-
  * _gnutls_openpgp_request_key - Receives a key from a database, key server etc
- * @ret - a pointer to gnutls_datum structure.
- * @cred - a gnutls_certificate_credentials structure.
+ * @ret - a pointer to gnutls_datum_t structure.
+ * @cred - a gnutls_certificate_credentials_t structure.
  * @key_fingerprint - The keyFingerprint
  * @key_fingerprint_size - the size of the fingerprint
  *
@@ -895,8 +895,8 @@ gnutls_certificate_set_openpgp_keyring_mem(gnutls_certificate_credentials
  *
  -*/
 int
-_gnutls_openpgp_request_key(gnutls_session session, gnutls_datum * ret,
-			    const gnutls_certificate_credentials cred,
+_gnutls_openpgp_request_key(gnutls_session_t session, gnutls_datum_t * ret,
+			    const gnutls_certificate_credentials_t cred,
 			    opaque * key_fpr, int key_fpr_size)
 {
     int rc = 0;
@@ -945,7 +945,7 @@ _gnutls_openpgp_request_key(gnutls_session session, gnutls_datum * ret,
  *
  **/
 int
-gnutls_certificate_set_openpgp_keyserver(gnutls_certificate_credentials
+gnutls_certificate_set_openpgp_keyserver(gnutls_certificate_credentials_t
 					 res, const char *keyserver,
 					 int port)
 {
@@ -977,7 +977,7 @@ gnutls_certificate_set_openpgp_keyserver(gnutls_certificate_credentials
  *
  **/
 int
-gnutls_certificate_set_openpgp_trustdb(gnutls_certificate_credentials res,
+gnutls_certificate_set_openpgp_trustdb(gnutls_certificate_credentials_t res,
 				       const char *trustdb)
 {
     if (!res || !trustdb) {
@@ -1006,17 +1006,17 @@ gnutls_certificate_set_openpgp_trustdb(gnutls_certificate_credentials res,
  * sent a key fingerprint instead of a full key.
  *
  **/
-void gnutls_openpgp_set_recv_key_function(gnutls_session session,
+void gnutls_openpgp_set_recv_key_function(gnutls_session_t session,
 					  gnutls_openpgp_recv_key_func
 					  func)
 {
     session->internals.openpgp_recv_key_func = func;
 }
 
-/* Copies a gnutls_openpgp_privkey to a gnutls_privkey structure.
+/* Copies a gnutls_openpgp_privkey_t to a gnutls_privkey structure.
  */
 int _gnutls_openpgp_privkey_to_gkey(gnutls_privkey * dest,
-				    gnutls_openpgp_privkey src)
+				    gnutls_openpgp_privkey_t src)
 {
     int i, ret;
 
@@ -1043,15 +1043,15 @@ int _gnutls_openpgp_privkey_to_gkey(gnutls_privkey * dest,
     return ret;
 }
 
-/* Converts a parsed gnutls_openpgp_key to a gnutls_cert structure.
+/* Converts a parsed gnutls_openpgp_key_t to a gnutls_cert structure.
  */
 int _gnutls_openpgp_key_to_gcert(gnutls_cert * gcert,
-				 gnutls_openpgp_key cert)
+				 gnutls_openpgp_key_t cert)
 {
     int ret = 0;
     opaque *der;
     size_t der_size = 0;
-    gnutls_datum raw;
+    gnutls_datum_t raw;
 
     memset(gcert, 0, sizeof(gnutls_cert));
     gcert->cert_type = GNUTLS_CRT_OPENPGP;
@@ -1092,20 +1092,20 @@ int _gnutls_openpgp_key_to_gcert(gnutls_cert * gcert,
 }
 
 /**
-  * gnutls_certificate_set_openpgp_key - Used to set keys in a gnutls_certificate_credentials structure
-  * @res: is an &gnutls_certificate_credentials structure.
+  * gnutls_certificate_set_openpgp_key - Used to set keys in a gnutls_certificate_credentials_t structure
+  * @res: is an &gnutls_certificate_credentials_t structure.
   * @key: contains an openpgp public key
   * @pkey: is an openpgp private key
   *
   * This function sets a certificate/private key pair in the 
-  * gnutls_certificate_credentials structure. This function may be called
+  * gnutls_certificate_credentials_t structure. This function may be called
   * more than once (in case multiple keys/certificates exist for the
   * server).
   *
   **/
-int gnutls_certificate_set_openpgp_key(gnutls_certificate_credentials res,
-				       gnutls_openpgp_key key,
-				       gnutls_openpgp_privkey pkey)
+int gnutls_certificate_set_openpgp_key(gnutls_certificate_credentials_t res,
+				       gnutls_openpgp_key_t key,
+				       gnutls_openpgp_privkey_t pkey)
 {
     int ret;
 
diff --git a/libextra/gnutls_openssl.c b/libextra/gnutls_openssl.c
index 2270b95b93..439634e964 100644
--- a/libextra/gnutls_openssl.c
+++ b/libextra/gnutls_openssl.c
@@ -224,8 +224,8 @@ SSL *SSL_new(SSL_CTX * ctx)
 
     ssl->options = ctx->options;
 
-    ssl->rfd = (gnutls_transport_ptr) - 1;
-    ssl->wfd = (gnutls_transport_ptr) - 1;
+    ssl->rfd = (gnutls_transport_ptr_t) - 1;
+    ssl->wfd = (gnutls_transport_ptr_t) - 1;
 
     return ssl;
 }
@@ -251,15 +251,15 @@ int SSL_get_error(SSL * ssl, int ret)
 
 int SSL_set_fd(SSL * ssl, int fd)
 {
-    gnutls_transport_set_ptr(ssl->gnutls_state, (gnutls_transport_ptr) fd);
+    gnutls_transport_set_ptr(ssl->gnutls_state, (gnutls_transport_ptr_t) fd);
     return 1;
 }
 
 int SSL_set_rfd(SSL * ssl, int fd)
 {
-    ssl->rfd = (gnutls_transport_ptr) fd;
+    ssl->rfd = (gnutls_transport_ptr_t) fd;
 
-    if (ssl->wfd != (gnutls_transport_ptr) - 1)
+    if (ssl->wfd != (gnutls_transport_ptr_t) - 1)
 	gnutls_transport_set_ptr2(ssl->gnutls_state, ssl->rfd, ssl->wfd);
 
     return 1;
@@ -267,9 +267,9 @@ int SSL_set_rfd(SSL * ssl, int fd)
 
 int SSL_set_wfd(SSL * ssl, int fd)
 {
-    ssl->wfd = (gnutls_transport_ptr) fd;
+    ssl->wfd = (gnutls_transport_ptr_t) fd;
 
-    if (ssl->rfd != (gnutls_transport_ptr) - 1)
+    if (ssl->rfd != (gnutls_transport_ptr_t) - 1)
 	gnutls_transport_set_ptr2(ssl->gnutls_state, ssl->rfd, ssl->wfd);
 
     return 1;
@@ -299,7 +299,7 @@ void SSL_set_verify(SSL * ssl, int verify_mode,
 
 const X509 *SSL_get_peer_certificate(SSL * ssl)
 {
-    const gnutls_datum *cert_list;
+    const gnutls_datum_t *cert_list;
     int cert_list_size = 0;
 
     cert_list = gnutls_certificate_get_peers(ssl->gnutls_state,
@@ -801,7 +801,7 @@ void X509_free(const X509 * cert)
 
 /* BIO functions */
 
-void BIO_get_fd(gnutls_session gnutls_state, int *fd)
+void BIO_get_fd(gnutls_session_t gnutls_state, int *fd)
 {
     *fd = (int) gnutls_transport_get_ptr(gnutls_state);
 }
@@ -814,7 +814,7 @@ BIO *BIO_new_socket(int sock, int close_flag)
     if (!bio)
 	return NULL;
 
-    bio->fd = (gnutls_transport_ptr) sock;
+    bio->fd = (gnutls_transport_ptr_t) sock;
 
     return bio;
 }
diff --git a/libextra/gnutls_srp.c b/libextra/gnutls_srp.c
index 3439da1c2f..196b047c50 100644
--- a/libextra/gnutls_srp.c
+++ b/libextra/gnutls_srp.c
@@ -37,10 +37,10 @@
  */
 
 int _gnutls_srp_gx(opaque * text, size_t textsize, opaque ** result,
-		   GNUTLS_MPI g, GNUTLS_MPI prime,
+		   mpi_t g, mpi_t prime,
 		   gnutls_alloc_function galloc_func)
 {
-    GNUTLS_MPI x, e;
+    mpi_t x, e;
     size_t result_size;
 
     if (_gnutls_mpi_scan(&x, text, &textsize)) {
@@ -80,11 +80,11 @@ int _gnutls_srp_gx(opaque * text, size_t textsize, opaque ** result,
  * where k == SHA1(N|g)
  * Return: B and if ret_b is not NULL b.
  */
-GNUTLS_MPI _gnutls_calc_srp_B(GNUTLS_MPI * ret_b, GNUTLS_MPI g,
-			      GNUTLS_MPI n, GNUTLS_MPI v)
+mpi_t _gnutls_calc_srp_B(mpi_t * ret_b, mpi_t g,
+			      mpi_t n, mpi_t v)
 {
-    GNUTLS_MPI tmpB = NULL, tmpV = NULL;
-    GNUTLS_MPI b = NULL, B = NULL, k = NULL;
+    mpi_t tmpB = NULL, tmpV = NULL;
+    mpi_t b = NULL, B = NULL, k = NULL;
     int bits;
 
     /* calculate:  B = (k*v + g^b) % N 
@@ -151,14 +151,14 @@ GNUTLS_MPI _gnutls_calc_srp_B(GNUTLS_MPI * ret_b, GNUTLS_MPI g,
 
 /* This calculates the SHA1(A | B)
  */
-GNUTLS_MPI _gnutls_calc_srp_u(GNUTLS_MPI A, GNUTLS_MPI B)
+mpi_t _gnutls_calc_srp_u(mpi_t A, mpi_t B)
 {
     size_t b_size, a_size;
     opaque *holder, hd[MAX_HASH_SIZE];
     size_t holder_size, hash_size;
     GNUTLS_HASH_HANDLE td;
     int ret;
-    GNUTLS_MPI res;
+    mpi_t res;
 
     _gnutls_mpi_print(NULL, &a_size, A);
     _gnutls_mpi_print(NULL, &b_size, B);
@@ -198,11 +198,11 @@ GNUTLS_MPI _gnutls_calc_srp_u(GNUTLS_MPI A, GNUTLS_MPI B)
 /* S = (A * v^u) ^ b % N 
  * this is our shared key (server premaster secret)
  */
-GNUTLS_MPI _gnutls_calc_srp_S1(GNUTLS_MPI A, GNUTLS_MPI b, GNUTLS_MPI u,
-			       GNUTLS_MPI v, GNUTLS_MPI n)
+mpi_t _gnutls_calc_srp_S1(mpi_t A, mpi_t b, mpi_t u,
+			       mpi_t v, mpi_t n)
 {
-    GNUTLS_MPI tmp1 = NULL, tmp2 = NULL;
-    GNUTLS_MPI S = NULL;
+    mpi_t tmp1 = NULL, tmp2 = NULL;
+    mpi_t S = NULL;
 
     S = _gnutls_mpi_alloc_like(n);
     if (S == NULL)
@@ -232,10 +232,10 @@ GNUTLS_MPI _gnutls_calc_srp_S1(GNUTLS_MPI A, GNUTLS_MPI b, GNUTLS_MPI u,
 /* A = g^a % N 
  * returns A and a (which is random)
  */
-GNUTLS_MPI _gnutls_calc_srp_A(GNUTLS_MPI * a, GNUTLS_MPI g, GNUTLS_MPI n)
+mpi_t _gnutls_calc_srp_A(mpi_t * a, mpi_t g, mpi_t n)
 {
-    GNUTLS_MPI tmpa;
-    GNUTLS_MPI A;
+    mpi_t tmpa;
+    mpi_t A;
     int bits;
 
     bits = _gnutls_mpi_get_nbits(n);
@@ -310,11 +310,11 @@ int _gnutls_calc_srp_x(char *username, char *password, opaque * salt,
 /* S = (B - k*g^x) ^ (a + u * x) % N
  * this is our shared key (client premaster secret)
  */
-GNUTLS_MPI _gnutls_calc_srp_S2(GNUTLS_MPI B, GNUTLS_MPI g, GNUTLS_MPI x,
-			       GNUTLS_MPI a, GNUTLS_MPI u, GNUTLS_MPI n)
+mpi_t _gnutls_calc_srp_S2(mpi_t B, mpi_t g, mpi_t x,
+			       mpi_t a, mpi_t u, mpi_t n)
 {
-    GNUTLS_MPI S = NULL, tmp1 = NULL, tmp2 = NULL;
-    GNUTLS_MPI tmp4 = NULL, tmp3 = NULL, k = NULL;
+    mpi_t S = NULL, tmp1 = NULL, tmp2 = NULL;
+    mpi_t tmp4 = NULL, tmp3 = NULL, k = NULL;
 
     S = _gnutls_mpi_alloc_like(n);
     if (S == NULL)
@@ -364,14 +364,14 @@ GNUTLS_MPI _gnutls_calc_srp_S2(GNUTLS_MPI B, GNUTLS_MPI g, GNUTLS_MPI x,
 }
 
 /**
-  * gnutls_srp_free_server_credentials - Used to free an allocated gnutls_srp_client_credentials structure
-  * @sc: is an &gnutls_srp_client_credentials structure.
+  * gnutls_srp_free_server_credentials - Used to free an allocated gnutls_srp_client_credentials_t structure
+  * @sc: is an &gnutls_srp_client_credentials_t structure.
   *
   * This structure is complex enough to manipulate directly thus
   * this helper function is provided in order to free (deallocate) it.
   *
   **/
-void gnutls_srp_free_client_credentials(gnutls_srp_client_credentials sc)
+void gnutls_srp_free_client_credentials(gnutls_srp_client_credentials_t sc)
 {
     gnutls_free(sc->username);
     gnutls_free(sc->password);
@@ -379,15 +379,15 @@ void gnutls_srp_free_client_credentials(gnutls_srp_client_credentials sc)
 }
 
 /**
-  * gnutls_srp_allocate_server_credentials - Used to allocate an gnutls_srp_server_credentials structure
-  * @sc: is a pointer to an &gnutls_srp_server_credentials structure.
+  * gnutls_srp_allocate_server_credentials - Used to allocate an gnutls_srp_server_credentials_t structure
+  * @sc: is a pointer to an &gnutls_srp_server_credentials_t structure.
   *
   * This structure is complex enough to manipulate directly thus
   * this helper function is provided in order to allocate it.
   *
   * Returns 0 on success.
   **/
-int gnutls_srp_allocate_client_credentials(gnutls_srp_client_credentials *
+int gnutls_srp_allocate_client_credentials(gnutls_srp_client_credentials_t *
 					   sc)
 {
     *sc = gnutls_calloc(1, sizeof(srp_client_credentials_st));
@@ -399,18 +399,18 @@ int gnutls_srp_allocate_client_credentials(gnutls_srp_client_credentials *
 }
 
 /**
-  * gnutls_srp_set_client_credentials - Used to set the username/password, in a gnutls_srp_client_credentials structure
-  * @res: is an &gnutls_srp_client_credentials structure.
+  * gnutls_srp_set_client_credentials - Used to set the username/password, in a gnutls_srp_client_credentials_t structure
+  * @res: is an &gnutls_srp_client_credentials_t structure.
   * @username: is the user's userid
   * @password: is the user's password
   *
-  * This function sets the username and password, in a gnutls_srp_client_credentials structure.
+  * This function sets the username and password, in a gnutls_srp_client_credentials_t structure.
   * Those will be used in SRP authentication. @username and @password should be ASCII
   * strings or UTF-8 strings prepared using the "SASLprep" profile of "stringprep".
   *
   * Returns 0 on success.
   **/
-int gnutls_srp_set_client_credentials(gnutls_srp_client_credentials res,
+int gnutls_srp_set_client_credentials(gnutls_srp_client_credentials_t res,
 				      char *username, char *password)
 {
 
@@ -433,14 +433,14 @@ int gnutls_srp_set_client_credentials(gnutls_srp_client_credentials res,
 }
 
 /**
-  * gnutls_srp_free_server_credentials - Used to free an allocated gnutls_srp_server_credentials structure
-  * @sc: is an &gnutls_srp_server_credentials structure.
+  * gnutls_srp_free_server_credentials - Used to free an allocated gnutls_srp_server_credentials_t structure
+  * @sc: is an &gnutls_srp_server_credentials_t structure.
   *
   * This structure is complex enough to manipulate directly thus
   * this helper function is provided in order to free (deallocate) it.
   *
   **/
-void gnutls_srp_free_server_credentials(gnutls_srp_server_credentials sc)
+void gnutls_srp_free_server_credentials(gnutls_srp_server_credentials_t sc)
 {
     gnutls_free(sc->password_file);
     gnutls_free(sc->password_conf_file);
@@ -449,15 +449,15 @@ void gnutls_srp_free_server_credentials(gnutls_srp_server_credentials sc)
 }
 
 /**
-  * gnutls_srp_allocate_server_credentials - Used to allocate an gnutls_srp_server_credentials structure
-  * @sc: is a pointer to an &gnutls_srp_server_credentials structure.
+  * gnutls_srp_allocate_server_credentials - Used to allocate an gnutls_srp_server_credentials_t structure
+  * @sc: is a pointer to an &gnutls_srp_server_credentials_t structure.
   *
   * This structure is complex enough to manipulate directly thus
   * this helper function is provided in order to allocate it.
   * 
   * Returns 0 on success.
   **/
-int gnutls_srp_allocate_server_credentials(gnutls_srp_server_credentials *
+int gnutls_srp_allocate_server_credentials(gnutls_srp_server_credentials_t *
 					   sc)
 {
     *sc = gnutls_calloc(1, sizeof(srp_server_cred_st));
@@ -481,18 +481,18 @@ inline static int file_exists(const char *file)
 }
 
 /**
-  * gnutls_srp_set_server_credentials_file - Used to set the password files, in a gnutls_srp_server_credentials structure
-  * @res: is an &gnutls_srp_server_credentials structure.
+  * gnutls_srp_set_server_credentials_file - Used to set the password files, in a gnutls_srp_server_credentials_t structure
+  * @res: is an &gnutls_srp_server_credentials_t structure.
   * @password_file: is the SRP password file (tpasswd)
   * @password_conf_file: is the SRP password conf file (tpasswd.conf)
   *
-  * This function sets the password files, in a gnutls_srp_server_credentials structure.
+  * This function sets the password files, in a gnutls_srp_server_credentials_t structure.
   * Those password files hold usernames and verifiers and will be used for SRP authentication.
   *
   * Returns 0 on success.
   *
   **/
-int gnutls_srp_set_server_credentials_file(gnutls_srp_server_credentials
+int gnutls_srp_set_server_credentials_file(gnutls_srp_server_credentials_t
 					   res, const char *password_file,
 					   const char *password_conf_file)
 {
@@ -533,14 +533,14 @@ int gnutls_srp_set_server_credentials_file(gnutls_srp_server_credentials
 
 /**
   * gnutls_srp_set_server_credentials_function - Used to set a callback to retrieve the user's SRP credentials
-  * @cred: is a &gnutls_srp_server_credentials structure.
+  * @cred: is a &gnutls_srp_server_credentials_t structure.
   * @func: is the callback function
   *
   * This function can be used to set a callback to retrieve the user's SRP credentials.
   * The callback's function form is:
-  * int (*callback)(gnutls_session, const char* username,
-  *  gnutls_datum* salt, gnutls_datum *verifier, gnutls_datum* g,
-  *  gnutls_datum* n);
+  * int (*callback)(gnutls_session_t, const char* username,
+  *  gnutls_datum_t* salt, gnutls_datum_t *verifier, gnutls_datum_t* g,
+  *  gnutls_datum_t* n);
   *
   * @username contains the actual username. 
   * The @salt, @verifier, @generator and @prime must be filled
@@ -560,7 +560,7 @@ int gnutls_srp_set_server_credentials_file(gnutls_srp_server_credentials
   *
   **/
 void
-gnutls_srp_set_server_credentials_function(gnutls_srp_server_credentials
+gnutls_srp_set_server_credentials_function(gnutls_srp_server_credentials_t
 					   cred,
 					   gnutls_srp_server_credentials_function
 					   * func)
@@ -570,13 +570,13 @@ gnutls_srp_set_server_credentials_function(gnutls_srp_server_credentials
 
 /**
   * gnutls_srp_set_client_credentials_function - Used to set a callback to retrieve the username and password
-  * @cred: is a &gnutls_srp_server_credentials structure.
+  * @cred: is a &gnutls_srp_server_credentials_t structure.
   * @func: is the callback function
   *
   * This function can be used to set a callback to retrieve the username and
   * password for client SRP authentication.
   * The callback's function form is:
-  * int (*callback)(gnutls_session, unsigned int times, char** username,
+  * int (*callback)(gnutls_session_t, unsigned int times, char** username,
   *  char** password);
   *
   * The @username and @password must be allocated using gnutls_malloc().
@@ -600,7 +600,7 @@ gnutls_srp_set_server_credentials_function(gnutls_srp_server_credentials
   *
   **/
 void
-gnutls_srp_set_client_credentials_function(gnutls_srp_client_credentials
+gnutls_srp_set_client_credentials_function(gnutls_srp_client_credentials_t
 					   cred,
 					   gnutls_srp_client_credentials_function
 					   * func)
@@ -618,7 +618,7 @@ gnutls_srp_set_client_credentials_function(gnutls_srp_client_credentials
   * Returns NULL in case of an error.
   *
   **/
-const char *gnutls_srp_server_get_username(gnutls_session session)
+const char *gnutls_srp_server_get_username(gnutls_session_t session)
 {
     srp_server_auth_info_t info;
 
@@ -648,11 +648,11 @@ const char *gnutls_srp_server_get_username(gnutls_session session)
   *
   **/
 int gnutls_srp_verifier(const char *username, const char *password,
-			const gnutls_datum * salt,
-			const gnutls_datum * generator,
-			const gnutls_datum * prime, gnutls_datum * res)
+			const gnutls_datum_t * salt,
+			const gnutls_datum_t * generator,
+			const gnutls_datum_t * prime, gnutls_datum_t * res)
 {
-    GNUTLS_MPI _n, _g;
+    mpi_t _n, _g;
     int ret;
     size_t digest_size = 20, size;
     opaque digest[20];
diff --git a/libextra/gnutls_srp.h b/libextra/gnutls_srp.h
index 4990ec09ef..d9c9bcb90d 100644
--- a/libextra/gnutls_srp.h
+++ b/libextra/gnutls_srp.h
@@ -1,11 +1,11 @@
 #ifdef ENABLE_SRP
 
-int _gnutls_srp_gx(opaque *text, size_t textsize, opaque** result, GNUTLS_MPI g, GNUTLS_MPI prime, gnutls_alloc_function);
-GNUTLS_MPI _gnutls_calc_srp_B(GNUTLS_MPI * ret_b, GNUTLS_MPI g, GNUTLS_MPI n, GNUTLS_MPI v);
-GNUTLS_MPI _gnutls_calc_srp_u( GNUTLS_MPI A, GNUTLS_MPI B);
-GNUTLS_MPI _gnutls_calc_srp_S1(GNUTLS_MPI A, GNUTLS_MPI b, GNUTLS_MPI u, GNUTLS_MPI v, GNUTLS_MPI n);
-GNUTLS_MPI _gnutls_calc_srp_A(GNUTLS_MPI *a, GNUTLS_MPI g, GNUTLS_MPI n);
-GNUTLS_MPI _gnutls_calc_srp_S2(GNUTLS_MPI B, GNUTLS_MPI g, GNUTLS_MPI x, GNUTLS_MPI a, GNUTLS_MPI u, GNUTLS_MPI n);
+int _gnutls_srp_gx(opaque *text, size_t textsize, opaque** result, mpi_t g, mpi_t prime, gnutls_alloc_function);
+mpi_t _gnutls_calc_srp_B(mpi_t * ret_b, mpi_t g, mpi_t n, mpi_t v);
+mpi_t _gnutls_calc_srp_u( mpi_t A, mpi_t B);
+mpi_t _gnutls_calc_srp_S1(mpi_t A, mpi_t b, mpi_t u, mpi_t v, mpi_t n);
+mpi_t _gnutls_calc_srp_A(mpi_t *a, mpi_t g, mpi_t n);
+mpi_t _gnutls_calc_srp_S2(mpi_t B, mpi_t g, mpi_t x, mpi_t a, mpi_t u, mpi_t n);
 int _gnutls_calc_srp_x( char* username, char* password, opaque* salt, size_t salt_size, size_t* size, void* digest);
 int _gnutls_srp_gn( opaque** ret_g, opaque** ret_n, int bits);
 
diff --git a/libextra/openpgp/compat.c b/libextra/openpgp/compat.c
index c54a1972a5..bfde758871 100644
--- a/libextra/openpgp/compat.c
+++ b/libextra/openpgp/compat.c
@@ -48,14 +48,14 @@
  * may use GnuPG for that purpose, or any other external PGP application.
  -*/
 int _gnutls_openpgp_verify_key(const char *trustdb,
-			       const gnutls_datum * keyring,
-			       const gnutls_datum * cert_list,
+			       const gnutls_datum_t * keyring,
+			       const gnutls_datum_t * cert_list,
 			       int cert_list_length)
 {
     int ret = 0;
-    gnutls_openpgp_key key = NULL;
-    gnutls_openpgp_keyring ring = NULL;
-    gnutls_openpgp_trustdb tdb = NULL;
+    gnutls_openpgp_key_t key = NULL;
+    gnutls_openpgp_keyring_t ring = NULL;
+    gnutls_openpgp_trustdb_t tdb = NULL;
     unsigned int verify_ring = 0, verify_db = 0, verify_self = 0;
 
     if (!cert_list || cert_list_length != 1) {
@@ -146,10 +146,10 @@ int _gnutls_openpgp_verify_key(const char *trustdb,
  * Returns the fingerprint of the OpenPGP key. Depence on the algorithm,
  * the fingerprint can be 16 or 20 bytes.
  -*/
-int _gnutls_openpgp_fingerprint(const gnutls_datum * cert,
+int _gnutls_openpgp_fingerprint(const gnutls_datum_t * cert,
 				unsigned char *fpr, size_t * fprlen)
 {
-    gnutls_openpgp_key key;
+    gnutls_openpgp_key_t key;
     int ret;
 
     ret = gnutls_openpgp_key_init(&key);
@@ -181,9 +181,9 @@ int _gnutls_openpgp_fingerprint(const gnutls_datum * cert,
  *
  * Returns the timestamp when the OpenPGP key was created.
  -*/
-time_t _gnutls_openpgp_get_raw_key_creation_time(const gnutls_datum * cert)
+time_t _gnutls_openpgp_get_raw_key_creation_time(const gnutls_datum_t * cert)
 {
-    gnutls_openpgp_key key;
+    gnutls_openpgp_key_t key;
     int ret;
     time_t tim;
 
@@ -214,10 +214,10 @@ time_t _gnutls_openpgp_get_raw_key_creation_time(const gnutls_datum * cert)
  * Returns the time when the OpenPGP key expires. A value of '0' means
  * that the key doesn't expire at all.
  -*/
-time_t _gnutls_openpgp_get_raw_key_expiration_time(const gnutls_datum *
+time_t _gnutls_openpgp_get_raw_key_expiration_time(const gnutls_datum_t *
 						   cert)
 {
-    gnutls_openpgp_key key;
+    gnutls_openpgp_key_t key;
     int ret;
     time_t tim;
 
diff --git a/libextra/openpgp/extras.c b/libextra/openpgp/extras.c
index c45dea88b6..19e3a27376 100644
--- a/libextra/openpgp/extras.c
+++ b/libextra/openpgp/extras.c
@@ -35,7 +35,7 @@
  */
 
 /**
-  * gnutls_openpgp_keyring_init - This function initializes a gnutls_openpgp_keyring structure
+  * gnutls_openpgp_keyring_init - This function initializes a gnutls_openpgp_keyring_t structure
   * @keyring: The structure to be initialized
   *
   * This function will initialize an OpenPGP keyring structure. 
@@ -43,7 +43,7 @@
   * Returns 0 on success.
   *
   **/
-int gnutls_openpgp_keyring_init(gnutls_openpgp_keyring * keyring)
+int gnutls_openpgp_keyring_init(gnutls_openpgp_keyring_t * keyring)
 {
     *keyring = gnutls_calloc(1, sizeof(gnutls_openpgp_keyring_int));
 
@@ -54,13 +54,13 @@ int gnutls_openpgp_keyring_init(gnutls_openpgp_keyring * keyring)
 }
 
 /**
-  * gnutls_openpgp_keyring_deinit - This function deinitializes memory used by a gnutls_openpgp_keyring structure
+  * gnutls_openpgp_keyring_deinit - This function deinitializes memory used by a gnutls_openpgp_keyring_t structure
   * @keyring: The structure to be initialized
   *
   * This function will deinitialize a CRL structure. 
   *
   **/
-void gnutls_openpgp_keyring_deinit(gnutls_openpgp_keyring keyring)
+void gnutls_openpgp_keyring_deinit(gnutls_openpgp_keyring_t keyring)
 {
     if (!keyring)
 	return;
@@ -84,7 +84,7 @@ void gnutls_openpgp_keyring_deinit(gnutls_openpgp_keyring keyring)
  * Returns 0 on success (if keyid exists) and a negative error code
  * on failure.
  */
-int gnutls_openpgp_keyring_check_id( gnutls_openpgp_keyring ring, 
+int gnutls_openpgp_keyring_check_id( gnutls_openpgp_keyring_t ring, 
     const unsigned char keyid[8], unsigned int flags)
 {
 int rc;
@@ -108,14 +108,14 @@ uint32 id[2];
   * @format: One of gnutls_openpgp_keyring_fmt elements.
   *
   * This function will convert the given RAW or Base64 encoded keyring
-  * to the native gnutls_openpgp_keyring format. The output will be stored in 'keyring'.
+  * to the native gnutls_openpgp_keyring_t format. The output will be stored in 'keyring'.
   *
   * Returns 0 on success.
   *
   **/
-int gnutls_openpgp_keyring_import(gnutls_openpgp_keyring keyring,
-				  const gnutls_datum * data,
-				  gnutls_openpgp_key_fmt format)
+int gnutls_openpgp_keyring_import(gnutls_openpgp_keyring_t keyring,
+				  const gnutls_datum_t * data,
+				  gnutls_openpgp_key_fmt_t format)
 {
     int rc;
     keybox_blob *blob = NULL;
@@ -146,7 +146,7 @@ int gnutls_openpgp_keyring_import(gnutls_openpgp_keyring keyring,
  */
 
 /**
-  * gnutls_openpgp_trustdb_init - This function initializes a gnutls_openpgp_trustdb structure
+  * gnutls_openpgp_trustdb_init - This function initializes a gnutls_openpgp_trustdb_t structure
   * @trustdb: The structure to be initialized
   *
   * This function will initialize an OpenPGP trustdb structure. 
@@ -154,7 +154,7 @@ int gnutls_openpgp_keyring_import(gnutls_openpgp_keyring keyring,
   * Returns 0 on success.
   *
   **/
-int gnutls_openpgp_trustdb_init(gnutls_openpgp_trustdb * trustdb)
+int gnutls_openpgp_trustdb_init(gnutls_openpgp_trustdb_t * trustdb)
 {
     *trustdb = gnutls_calloc(1, sizeof(gnutls_openpgp_trustdb_int));
 
@@ -165,13 +165,13 @@ int gnutls_openpgp_trustdb_init(gnutls_openpgp_trustdb * trustdb)
 }
 
 /**
-  * gnutls_openpgp_trustdb_deinit - This function deinitializes memory used by a gnutls_openpgp_trustdb structure
+  * gnutls_openpgp_trustdb_deinit - This function deinitializes memory used by a gnutls_openpgp_trustdb_t structure
   * @trustdb: The structure to be initialized
   *
   * This function will deinitialize a CRL structure. 
   *
   **/
-void gnutls_openpgp_trustdb_deinit(gnutls_openpgp_trustdb trustdb)
+void gnutls_openpgp_trustdb_deinit(gnutls_openpgp_trustdb_t trustdb)
 {
     if (!trustdb)
 	return;
@@ -190,12 +190,12 @@ void gnutls_openpgp_trustdb_deinit(gnutls_openpgp_trustdb trustdb)
   * @file: The file that holds the trustdb.
   *
   * This function will convert the given RAW or Base64 encoded trustdb
-  * to the native gnutls_openpgp_trustdb format. The output will be stored in 'trustdb'.
+  * to the native gnutls_openpgp_trustdb_t format. The output will be stored in 'trustdb'.
   *
   * Returns 0 on success.
   *
   **/
-int gnutls_openpgp_trustdb_import_file(gnutls_openpgp_trustdb trustdb,
+int gnutls_openpgp_trustdb_import_file(gnutls_openpgp_trustdb_t trustdb,
 				       const char *file)
 {
     int rc;
diff --git a/libextra/openpgp/gnutls_openpgp.h b/libextra/openpgp/gnutls_openpgp.h
index 5989a1b256..ca54289070 100644
--- a/libextra/openpgp/gnutls_openpgp.h
+++ b/libextra/openpgp/gnutls_openpgp.h
@@ -29,34 +29,34 @@ typedef enum {
 } key_attr_t;
 
 int gnutls_certificate_set_openpgp_key_file(
-    gnutls_certificate_credentials res,
+    gnutls_certificate_credentials_t res,
     const char* CERTFILE,
     const char* KEYFILE);
 
 int gnutls_openpgp_count_key_names(
-    const gnutls_datum *cert );
+    const gnutls_datum_t *cert );
      
 int gnutls_openpgp_add_keyring_mem(
-    gnutls_datum *keyring,
+    gnutls_datum_t *keyring,
     const void *data,
     size_t len );
 
 int gnutls_openpgp_add_keyring_file(
-    gnutls_datum *keyring,
+    gnutls_datum_t *keyring,
     const char *name );
 
 int gnutls_certificate_set_openpgp_keyring_file( 
-    gnutls_certificate_credentials c,
+    gnutls_certificate_credentials_t c,
     const char *file );
 
 int gnutls_certificate_set_openpgp_keyring_mem(
-    gnutls_certificate_credentials c,
+    gnutls_certificate_credentials_t c,
     const opaque *data,
     size_t dlen );    
 
 int gnutls_openpgp_get_key(
-    gnutls_datum *key,
-    const gnutls_datum *keyring,
+    gnutls_datum_t *key,
+    const gnutls_datum_t *keyring,
     key_attr_t by,
     opaque *pattern );
 
@@ -64,37 +64,37 @@ int gnutls_openpgp_recv_key(
     const char *host,
     short port,
     uint32 keyid,
-    gnutls_datum *key );
+    gnutls_datum_t *key );
 
 /* internal */
 int _gnutls_openpgp_raw_key_to_gcert(
     gnutls_cert *cert,
-    const gnutls_datum *raw );
+    const gnutls_datum_t *raw );
 
 int
 _gnutls_openpgp_raw_privkey_to_gkey( gnutls_privkey *pkey,
-                                const gnutls_datum *raw_key);
+                                const gnutls_datum_t *raw_key);
 
 int
 _gnutls_openpgp_request_key(
-    gnutls_session,
-    gnutls_datum* ret, 
-    const gnutls_certificate_credentials cred,
+    gnutls_session_t,
+    gnutls_datum_t* ret, 
+    const gnutls_certificate_credentials_t cred,
     opaque* key_fpr,
     int key_fpr_size );
 
-keybox_blob* kbx_read_blob( const gnutls_datum* keyring, size_t pos );
+keybox_blob* kbx_read_blob( const gnutls_datum_t* keyring, size_t pos );
 cdk_keydb_hd_t kbx_to_keydb( keybox_blob *blob );
 void kbx_blob_release( keybox_blob *ctx );
 
 int _gnutls_openpgp_verify_key(const char *trustdb,
-			  const gnutls_datum * keyring,
-			  const gnutls_datum * cert_list,
+			  const gnutls_datum_t * keyring,
+			  const gnutls_datum_t * cert_list,
 			  int cert_list_length);
-int _gnutls_openpgp_fingerprint(const gnutls_datum * cert,
+int _gnutls_openpgp_fingerprint(const gnutls_datum_t * cert,
 			   unsigned char *fpr, size_t * fprlen);
-time_t _gnutls_openpgp_get_raw_key_creation_time(const gnutls_datum * cert);
-time_t _gnutls_openpgp_get_raw_key_expiration_time(const gnutls_datum * cert);
+time_t _gnutls_openpgp_get_raw_key_creation_time(const gnutls_datum_t * cert);
+time_t _gnutls_openpgp_get_raw_key_expiration_time(const gnutls_datum_t * cert);
 
 #endif /*GNUTLS_OPENPGP_H*/
 
diff --git a/libextra/openpgp/openpgp.c b/libextra/openpgp/openpgp.c
index 51fe89b2a1..6a169fec81 100644
--- a/libextra/openpgp/openpgp.c
+++ b/libextra/openpgp/openpgp.c
@@ -32,7 +32,7 @@
 #include <x509/rfc2818.h>
 
 /**
-  * gnutls_openpgp_key_init - This function initializes a gnutls_openpgp_key structure
+  * gnutls_openpgp_key_init - This function initializes a gnutls_openpgp_key_t structure
   * @key: The structure to be initialized
   *
   * This function will initialize an OpenPGP key structure. 
@@ -40,7 +40,7 @@
   * Returns 0 on success.
   *
   **/
-int gnutls_openpgp_key_init(gnutls_openpgp_key * key)
+int gnutls_openpgp_key_init(gnutls_openpgp_key_t * key)
 {
     *key = gnutls_calloc(1, sizeof(gnutls_openpgp_key_int));
 
@@ -51,13 +51,13 @@ int gnutls_openpgp_key_init(gnutls_openpgp_key * key)
 }
 
 /**
-  * gnutls_openpgp_key_deinit - This function deinitializes memory used by a gnutls_openpgp_key structure
+  * gnutls_openpgp_key_deinit - This function deinitializes memory used by a gnutls_openpgp_key_t structure
   * @key: The structure to be initialized
   *
   * This function will deinitialize a key structure. 
   *
   **/
-void gnutls_openpgp_key_deinit(gnutls_openpgp_key key)
+void gnutls_openpgp_key_deinit(gnutls_openpgp_key_t key)
 {
     if (!key)
 	return;
@@ -76,17 +76,17 @@ void gnutls_openpgp_key_deinit(gnutls_openpgp_key key)
   * gnutls_openpgp_key_import - This function will import a RAW or BASE64 encoded key
   * @key: The structure to store the parsed key.
   * @data: The RAW or BASE64 encoded key.
-  * @format: One of gnutls_openpgp_key_fmt elements.
+  * @format: One of gnutls_openpgp_key_fmt_t elements.
   *
   * This function will convert the given RAW or Base64 encoded key
-  * to the native gnutls_openpgp_key format. The output will be stored in 'key'.
+  * to the native gnutls_openpgp_key_t format. The output will be stored in 'key'.
   *
   * Returns 0 on success.
   *
   **/
-int gnutls_openpgp_key_import(gnutls_openpgp_key key,
-			      const gnutls_datum * data,
-			      gnutls_openpgp_key_fmt format)
+int gnutls_openpgp_key_import(gnutls_openpgp_key_t key,
+			      const gnutls_datum_t * data,
+			      gnutls_openpgp_key_fmt_t format)
 {
     int rc;
 
@@ -125,7 +125,7 @@ int gnutls_openpgp_key_import(gnutls_openpgp_key key,
 /**
   * gnutls_openpgp_key_export - This function will export a RAW or BASE64 encoded key
   * @key: Holds the key.
-  * @format: One of gnutls_openpgp_key_fmt elements.
+  * @format: One of gnutls_openpgp_key_fmt_t elements.
   * @output_data: will contain the key base64 encoded or raw
   * @output_data_size: holds the size of output_data (and will be replaced by the actual size of parameters)
   *
@@ -136,8 +136,8 @@ int gnutls_openpgp_key_import(gnutls_openpgp_key key,
   * Returns 0 on success.
   *
   **/
-int gnutls_openpgp_key_export(gnutls_openpgp_key key,
-			      gnutls_openpgp_key_fmt format,
+int gnutls_openpgp_key_export(gnutls_openpgp_key_t key,
+			      gnutls_openpgp_key_fmt_t format,
 			      void *output_data, size_t * output_data_size)
 {
     int rc;
@@ -204,7 +204,7 @@ int gnutls_openpgp_key_export(gnutls_openpgp_key key,
  * the fingerprint can be 16 or 20 bytes.
  **/
 int
-gnutls_openpgp_key_get_fingerprint(gnutls_openpgp_key key,
+gnutls_openpgp_key_get_fingerprint(gnutls_openpgp_key_t key,
 				   void *fpr, size_t * fprlen)
 {
     cdk_packet_t pkt;
@@ -231,7 +231,7 @@ gnutls_openpgp_key_get_fingerprint(gnutls_openpgp_key key,
     return 0;
 }
 
-int _gnutls_openpgp_count_key_names(gnutls_openpgp_key key)
+int _gnutls_openpgp_count_key_names(gnutls_openpgp_key_t key)
 {
     cdk_kbnode_t p, ctx = NULL;
     cdk_packet_t pkt;
@@ -265,7 +265,7 @@ int _gnutls_openpgp_count_key_names(gnutls_openpgp_key key)
  *
  **/
 int
-gnutls_openpgp_key_get_name(gnutls_openpgp_key key,
+gnutls_openpgp_key_get_name(gnutls_openpgp_key_t key,
 			    int idx, char *buf, size_t * sizeof_buf)
 {
     cdk_kbnode_t ctx = NULL, p;
@@ -340,7 +340,7 @@ gnutls_openpgp_key_get_name(gnutls_openpgp_key key,
   *
   **/
 int
-gnutls_openpgp_key_get_pk_algorithm(gnutls_openpgp_key key,
+gnutls_openpgp_key_get_pk_algorithm(gnutls_openpgp_key_t key,
 				    unsigned int *bits)
 {
     cdk_packet_t pkt;
@@ -372,7 +372,7 @@ gnutls_openpgp_key_get_pk_algorithm(gnutls_openpgp_key key,
  *
  * Extract the version of the OpenPGP key.
  **/
-int gnutls_openpgp_key_get_version(gnutls_openpgp_key key)
+int gnutls_openpgp_key_get_version(gnutls_openpgp_key_t key)
 {
     cdk_packet_t pkt;
     int version = 0;
@@ -394,7 +394,7 @@ int gnutls_openpgp_key_get_version(gnutls_openpgp_key key)
  *
  * Returns the timestamp when the OpenPGP key was created.
  **/
-time_t gnutls_openpgp_key_get_creation_time(gnutls_openpgp_key key)
+time_t gnutls_openpgp_key_get_creation_time(gnutls_openpgp_key_t key)
 {
     cdk_packet_t pkt;
     time_t timestamp = 0;
@@ -417,7 +417,7 @@ time_t gnutls_openpgp_key_get_creation_time(gnutls_openpgp_key key)
  * Returns the time when the OpenPGP key expires. A value of '0' means
  * that the key doesn't expire at all.
  **/
-time_t gnutls_openpgp_key_get_expiration_time(gnutls_openpgp_key key)
+time_t gnutls_openpgp_key_get_expiration_time(gnutls_openpgp_key_t key)
 {
     cdk_packet_t pkt;
     time_t expiredate = 0;
@@ -440,7 +440,7 @@ time_t gnutls_openpgp_key_get_expiration_time(gnutls_openpgp_key key)
  * Returns the 64-bit keyID of the OpenPGP key.
  **/
 int
-gnutls_openpgp_key_get_id(gnutls_openpgp_key key, unsigned char keyid[8])
+gnutls_openpgp_key_get_id(gnutls_openpgp_key_t key, unsigned char keyid[8])
 {
     cdk_packet_t pkt;
     cdk_pkt_pubkey_t pk = NULL;
@@ -471,7 +471,7 @@ gnutls_openpgp_key_get_id(gnutls_openpgp_key key, unsigned char keyid[8])
 
 /**
   * gnutls_openpgp_key_check_hostname - This function compares the given hostname with the hostname in the key
-  * @key: should contain an gnutls_openpgp_key structure
+  * @key: should contain an gnutls_openpgp_key_t structure
   * @hostname: A null terminated string that contains a DNS name
   *
   * This function will check if the given key's owner matches
@@ -481,7 +481,7 @@ gnutls_openpgp_key_get_id(gnutls_openpgp_key key, unsigned char keyid[8])
   * Returns non zero on success, and zero on failure.
   *
   **/
-int gnutls_openpgp_key_check_hostname(gnutls_openpgp_key key,
+int gnutls_openpgp_key_check_hostname(gnutls_openpgp_key_t key,
 				      const char *hostname)
 {
 
@@ -509,7 +509,7 @@ int gnutls_openpgp_key_check_hostname(gnutls_openpgp_key key,
 
 /**
   * gnutls_openpgp_key_get_key_usage - This function returns the key's usage
-  * @key: should contain a gnutls_openpgp_key structure
+  * @key: should contain a gnutls_openpgp_key_t structure
   * @key_usage: where the key usage bits will be stored
   *
   * This function will return certificate's key usage, by checking the
@@ -519,7 +519,7 @@ int gnutls_openpgp_key_check_hostname(gnutls_openpgp_key key,
   * A negative value may be returned in case of parsing error.
   *
   **/
-int gnutls_openpgp_key_get_key_usage(gnutls_openpgp_key key,
+int gnutls_openpgp_key_get_key_usage(gnutls_openpgp_key_t key,
 				     unsigned int *key_usage)
 {
     cdk_packet_t pkt;
diff --git a/libextra/openpgp/openpgp.h b/libextra/openpgp/openpgp.h
index d4711d68c2..e2c8d6cbd7 100644
--- a/libextra/openpgp/openpgp.h
+++ b/libextra/openpgp/openpgp.h
@@ -3,9 +3,9 @@
 
 #include <config.h>
 
-typedef enum gnutls_openpgp_key_fmt { 
+typedef enum gnutls_openpgp_key_fmt_t { 
     GNUTLS_OPENPGP_FMT_RAW, GNUTLS_OPENPGP_FMT_BASE64
-} gnutls_openpgp_key_fmt;
+} gnutls_openpgp_key_fmt_t;
 
 #ifdef USE_OPENPGP
 
@@ -29,63 +29,63 @@ typedef struct gnutls_openpgp_trustdb_int {
     cdk_stream_t st;
 } gnutls_openpgp_trustdb_int;
 
-typedef struct gnutls_openpgp_key_int *gnutls_openpgp_key;
-typedef struct gnutls_openpgp_privkey_int *gnutls_openpgp_privkey;
-typedef struct gnutls_openpgp_keyring_int *gnutls_openpgp_keyring;
-typedef struct gnutls_openpgp_trustdb_int *gnutls_openpgp_trustdb;
+typedef struct gnutls_openpgp_key_int *gnutls_openpgp_key_t;
+typedef struct gnutls_openpgp_privkey_int *gnutls_openpgp_privkey_t;
+typedef struct gnutls_openpgp_keyring_int *gnutls_openpgp_keyring_t;
+typedef struct gnutls_openpgp_trustdb_int *gnutls_openpgp_trustdb_t;
 
 int _gnutls_map_cdk_rc(int rc);
 int
-gnutls_openpgp_key_get_name(gnutls_openpgp_key key,
+gnutls_openpgp_key_get_name(gnutls_openpgp_key_t key,
     int idx, char *buf, size_t * sizeof_buf);
-int gnutls_openpgp_key_get_fingerprint(gnutls_openpgp_key key,
+int gnutls_openpgp_key_get_fingerprint(gnutls_openpgp_key_t key,
     void *fpr, size_t * fprlen);
-int gnutls_openpgp_key_get_pk_algorithm(gnutls_openpgp_key key,
+int gnutls_openpgp_key_get_pk_algorithm(gnutls_openpgp_key_t key,
     unsigned int *bits);
-int gnutls_openpgp_key_get_version(gnutls_openpgp_key key);
-time_t gnutls_openpgp_key_get_creation_time(gnutls_openpgp_key key);
-time_t gnutls_openpgp_key_get_expiration_time(gnutls_openpgp_key key);
-int gnutls_openpgp_key_get_id(gnutls_openpgp_key key,
+int gnutls_openpgp_key_get_version(gnutls_openpgp_key_t key);
+time_t gnutls_openpgp_key_get_creation_time(gnutls_openpgp_key_t key);
+time_t gnutls_openpgp_key_get_expiration_time(gnutls_openpgp_key_t key);
+int gnutls_openpgp_key_get_id(gnutls_openpgp_key_t key,
     unsigned char keyid[8]);
 
-int gnutls_openpgp_key_init(gnutls_openpgp_key * key);
-void gnutls_openpgp_key_deinit(gnutls_openpgp_key key);
-int gnutls_openpgp_key_import(gnutls_openpgp_key key,
-    const gnutls_datum * data,
-    gnutls_openpgp_key_fmt format);
-int gnutls_openpgp_key_export(gnutls_openpgp_key key,
-    gnutls_openpgp_key_fmt format, void *output_data,
+int gnutls_openpgp_key_init(gnutls_openpgp_key_t * key);
+void gnutls_openpgp_key_deinit(gnutls_openpgp_key_t key);
+int gnutls_openpgp_key_import(gnutls_openpgp_key_t key,
+    const gnutls_datum_t * data,
+    gnutls_openpgp_key_fmt_t format);
+int gnutls_openpgp_key_export(gnutls_openpgp_key_t key,
+    gnutls_openpgp_key_fmt_t format, void *output_data,
     size_t * output_data_size);
 
-void gnutls_openpgp_keyring_deinit(gnutls_openpgp_keyring keyring);
-int gnutls_openpgp_keyring_init(gnutls_openpgp_keyring * keyring);
-int gnutls_openpgp_keyring_import(gnutls_openpgp_keyring keyring,
-    const gnutls_datum * data, gnutls_openpgp_key_fmt format);
-int gnutls_openpgp_keyring_check_id( gnutls_openpgp_keyring ring,
+void gnutls_openpgp_keyring_deinit(gnutls_openpgp_keyring_t keyring);
+int gnutls_openpgp_keyring_init(gnutls_openpgp_keyring_t * keyring);
+int gnutls_openpgp_keyring_import(gnutls_openpgp_keyring_t keyring,
+    const gnutls_datum_t * data, gnutls_openpgp_key_fmt_t format);
+int gnutls_openpgp_keyring_check_id( gnutls_openpgp_keyring_t ring,
     const unsigned char keyid[8], unsigned int flags);
 
-void gnutls_openpgp_trustdb_deinit(gnutls_openpgp_trustdb trustdb);
-int gnutls_openpgp_trustdb_init(gnutls_openpgp_trustdb * trustdb);
-int gnutls_openpgp_trustdb_import_file(gnutls_openpgp_trustdb trustdb,
+void gnutls_openpgp_trustdb_deinit(gnutls_openpgp_trustdb_t trustdb);
+int gnutls_openpgp_trustdb_init(gnutls_openpgp_trustdb_t * trustdb);
+int gnutls_openpgp_trustdb_import_file(gnutls_openpgp_trustdb_t trustdb,
     const char *file);
 
-int gnutls_openpgp_key_verify_ring(gnutls_openpgp_key key,
-    gnutls_openpgp_keyring keyring, unsigned int flags,
+int gnutls_openpgp_key_verify_ring(gnutls_openpgp_key_t key,
+    gnutls_openpgp_keyring_t keyring, unsigned int flags,
     unsigned int *verify);
 
-int gnutls_openpgp_key_verify_trustdb(gnutls_openpgp_key key,
-    gnutls_openpgp_trustdb trustdb, unsigned int flags,
+int gnutls_openpgp_key_verify_trustdb(gnutls_openpgp_key_t key,
+    gnutls_openpgp_trustdb_t trustdb, unsigned int flags,
     unsigned int *verify);
 
-int gnutls_openpgp_key_verify_self(gnutls_openpgp_key key,
+int gnutls_openpgp_key_verify_self(gnutls_openpgp_key_t key,
     unsigned int flags, unsigned int *verify);
 
 int _gnutls_openpgp_key_to_gcert(gnutls_cert * gcert,
-    gnutls_openpgp_key cert);
+    gnutls_openpgp_key_t cert);
 int _gnutls_openpgp_privkey_to_gkey(gnutls_privkey * dest,
-    gnutls_openpgp_privkey src);
+    gnutls_openpgp_privkey_t src);
 
-void gnutls_openpgp_privkey_deinit(gnutls_openpgp_privkey key);
+void gnutls_openpgp_privkey_deinit(gnutls_openpgp_privkey_t key);
 
 #else				/* no opencdk */
 
diff --git a/libextra/openpgp/privkey.c b/libextra/openpgp/privkey.c
index 4dba0e043d..8c59097e0b 100644
--- a/libextra/openpgp/privkey.c
+++ b/libextra/openpgp/privkey.c
@@ -33,7 +33,7 @@
 #include <gnutls_cert.h>
 
 /**
-  * gnutls_openpgp_privkey_init - This function initializes a gnutls_openpgp_privkey structure
+  * gnutls_openpgp_privkey_init - This function initializes a gnutls_openpgp_privkey_t structure
   * @key: The structure to be initialized
   *
   * This function will initialize an OpenPGP key structure. 
@@ -41,7 +41,7 @@
   * Returns 0 on success.
   *
   **/
-int gnutls_openpgp_privkey_init(gnutls_openpgp_privkey * key)
+int gnutls_openpgp_privkey_init(gnutls_openpgp_privkey_t * key)
 {
     *key = gnutls_calloc(1, sizeof(gnutls_openpgp_privkey_int));
 
@@ -52,13 +52,13 @@ int gnutls_openpgp_privkey_init(gnutls_openpgp_privkey * key)
 }
 
 /**
-  * gnutls_openpgp_privkey_deinit - This function deinitializes memory used by a gnutls_openpgp_privkey structure
+  * gnutls_openpgp_privkey_deinit - This function deinitializes memory used by a gnutls_openpgp_privkey_t structure
   * @key: The structure to be initialized
   *
   * This function will deinitialize a key structure. 
   *
   **/
-void gnutls_openpgp_privkey_deinit(gnutls_openpgp_privkey key)
+void gnutls_openpgp_privkey_deinit(gnutls_openpgp_privkey_t key)
 {
     if (!key)
 	return;
@@ -71,19 +71,19 @@ void gnutls_openpgp_privkey_deinit(gnutls_openpgp_privkey key)
   * gnutls_openpgp_privkey_import - This function will import a RAW or BASE64 encoded key
   * @key: The structure to store the parsed key.
   * @data: The RAW or BASE64 encoded key.
-  * @format: One of gnutls_openpgp_key_fmt elements.
+  * @format: One of gnutls_openpgp_key_fmt_t elements.
   * @pass: Unused for now
   * @flags: should be zero
   *
   * This function will convert the given RAW or Base64 encoded key
-  * to the native gnutls_openpgp_privkey format. The output will be stored in 'key'.
+  * to the native gnutls_openpgp_privkey_t format. The output will be stored in 'key'.
   *
   * Returns 0 on success.
   *
   **/
-int gnutls_openpgp_privkey_import(gnutls_openpgp_privkey key,
-				  const gnutls_datum * data,
-				  gnutls_openpgp_key_fmt format,
+int gnutls_openpgp_privkey_import(gnutls_openpgp_privkey_t key,
+				  const gnutls_datum_t * data,
+				  gnutls_openpgp_key_fmt_t format,
 				  const char *pass, unsigned int flags)
 {
     int rc;
@@ -114,7 +114,7 @@ int gnutls_openpgp_privkey_import(gnutls_openpgp_privkey key,
   *
   **/
 int
-gnutls_openpgp_privkey_get_pk_algorithm(gnutls_openpgp_privkey key,
+gnutls_openpgp_privkey_get_pk_algorithm(gnutls_openpgp_privkey_t key,
 					unsigned int *bits)
 {
     int pk = key->pkey.pk_algorithm;
diff --git a/libextra/openpgp/verify.c b/libextra/openpgp/verify.c
index 5b1d3420d7..7112bbf428 100644
--- a/libextra/openpgp/verify.c
+++ b/libextra/openpgp/verify.c
@@ -31,8 +31,8 @@
 #include <openpgp.h>
 
 static int
-openpgp_get_key_trust(gnutls_openpgp_trustdb trustdb,
-		      gnutls_openpgp_key key, unsigned int *r_trustval)
+openpgp_get_key_trust(gnutls_openpgp_trustdb_t trustdb,
+		      gnutls_openpgp_key_t key, unsigned int *r_trustval)
 {
     cdk_packet_t pkt;
     cdk_pkt_pubkey_t pk = NULL;
@@ -85,7 +85,7 @@ openpgp_get_key_trust(gnutls_openpgp_trustdb trustdb,
  * Verify all signatures in the key, using the given set of keys (keyring). 
  *
  * The key verification output will be put in @verify and will be
- * one or more of the gnutls_certificate_status enumerated elements bitwise or'd.
+ * one or more of the gnutls_certificate_status_t enumerated elements bitwise or'd.
  *
  * GNUTLS_CERT_INVALID\: A signature on the key is invalid.
  *
@@ -96,8 +96,8 @@ openpgp_get_key_trust(gnutls_openpgp_trustdb trustdb,
  *
  * Returns 0 on success.
  **/
-int gnutls_openpgp_key_verify_ring(gnutls_openpgp_key key,
-     gnutls_openpgp_keyring keyring,
+int gnutls_openpgp_key_verify_ring(gnutls_openpgp_key_t key,
+     gnutls_openpgp_keyring_t keyring,
      unsigned int flags, unsigned int *verify)
 {
     int rc = 0;
@@ -165,13 +165,13 @@ void cdk_md_close(cdk_md_hd_t hd);
  *
  * Verifies the self signature in the key.
  * The key verification output will be put in @verify and will be
- * one or more of the gnutls_certificate_status enumerated elements bitwise or'd.
+ * one or more of the gnutls_certificate_status_t enumerated elements bitwise or'd.
  *
  * GNUTLS_CERT_INVALID\: The self signature on the key is invalid.
  *
  * Returns 0 on success.
  **/
-int gnutls_openpgp_key_verify_self(gnutls_openpgp_key key,
+int gnutls_openpgp_key_verify_self(gnutls_openpgp_key_t key,
 				   unsigned int flags,
 				   unsigned int *verify)
 {
@@ -252,7 +252,7 @@ int gnutls_openpgp_key_verify_self(gnutls_openpgp_key key,
  *
  * Checks if the key is revoked or disabled, in the trustdb.
  * The verification output will be put in @verify and will be
- * one or more of the gnutls_certificate_status enumerated elements bitwise or'd.
+ * one or more of the gnutls_certificate_status_t enumerated elements bitwise or'd.
  *
  * GNUTLS_CERT_INVALID\: A signature on the key is invalid.
  *
@@ -263,8 +263,8 @@ int gnutls_openpgp_key_verify_self(gnutls_openpgp_key key,
  *
  * Returns 0 on success.
  **/
-int gnutls_openpgp_key_verify_trustdb(gnutls_openpgp_key key,
-				      gnutls_openpgp_trustdb trustdb,
+int gnutls_openpgp_key_verify_trustdb(gnutls_openpgp_key_t key,
+				      gnutls_openpgp_trustdb_t trustdb,
 				      unsigned int flags,
 				      unsigned int *verify)
 {
diff --git a/libextra/openpgp/xml.c b/libextra/openpgp/xml.c
index f726acd7ea..2f5dbe72d5 100644
--- a/libextra/openpgp/xml.c
+++ b/libextra/openpgp/xml.c
@@ -343,8 +343,8 @@ xml_add_sig(gnutls_string * xmlkey, int ext, cdk_pkt_signature_t sig)
  * a XML string.
  **/
 int
-gnutls_openpgp_key_to_xml(gnutls_openpgp_key key,
-			  gnutls_datum * xmlkey, int ext)
+gnutls_openpgp_key_to_xml(gnutls_openpgp_key_t key,
+			  gnutls_datum_t * xmlkey, int ext)
 {
     cdk_kbnode_t node, ctx = NULL;
     cdk_packet_t pkt;
diff --git a/libextra/openssl_compat.c b/libextra/openssl_compat.c
index 2752d5cb84..77a0d7bd30 100644
--- a/libextra/openssl_compat.c
+++ b/libextra/openssl_compat.c
@@ -43,7 +43,7 @@
   * Returns a negative error code in case of an error.
   *
   **/
-int gnutls_x509_extract_dn(const gnutls_datum * idn, gnutls_x509_dn * rdn)
+int gnutls_x509_extract_dn(const gnutls_datum_t * idn, gnutls_x509_dn * rdn)
 {
     ASN1_TYPE dn = ASN1_TYPE_EMPTY;
     int result;
@@ -110,10 +110,10 @@ int gnutls_x509_extract_dn(const gnutls_datum * idn, gnutls_x509_dn * rdn)
   * Returns a negative error code in case of an error.
   *
   **/
-int gnutls_x509_extract_certificate_dn(const gnutls_datum * cert,
+int gnutls_x509_extract_certificate_dn(const gnutls_datum_t * cert,
 				       gnutls_x509_dn * ret)
 {
-    gnutls_x509_crt xcert;
+    gnutls_x509_crt_t xcert;
     int result;
     size_t len;
 
@@ -174,10 +174,10 @@ int gnutls_x509_extract_certificate_dn(const gnutls_datum * cert,
   * Returns a negative error code in case of an error.
   *
   **/
-int gnutls_x509_extract_certificate_issuer_dn(const gnutls_datum * cert,
+int gnutls_x509_extract_certificate_issuer_dn(const gnutls_datum_t * cert,
 					      gnutls_x509_dn * ret)
 {
-    gnutls_x509_crt xcert;
+    gnutls_x509_crt_t xcert;
     int result;
     size_t len;
 
@@ -255,12 +255,12 @@ int gnutls_x509_extract_certificate_issuer_dn(const gnutls_datum * cert,
   * sequence number then returns GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE;
   *
   **/
-int gnutls_x509_extract_certificate_subject_alt_name(const gnutls_datum *
+int gnutls_x509_extract_certificate_subject_alt_name(const gnutls_datum_t *
 						     cert, int seq,
 						     char *ret,
 						     int *ret_size)
 {
-    gnutls_x509_crt xcert;
+    gnutls_x509_crt_t xcert;
     int result;
     size_t size = *ret_size;
 
@@ -297,9 +297,9 @@ int gnutls_x509_extract_certificate_subject_alt_name(const gnutls_datum *
   * GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE will be returned.
   *
   **/
-int gnutls_x509_extract_certificate_ca_status(const gnutls_datum * cert)
+int gnutls_x509_extract_certificate_ca_status(const gnutls_datum_t * cert)
 {
-    gnutls_x509_crt xcert;
+    gnutls_x509_crt_t xcert;
     int result;
 
     result = gnutls_x509_crt_init(&xcert);
@@ -329,9 +329,9 @@ int gnutls_x509_extract_certificate_ca_status(const gnutls_datum * cert)
   *
   **/
 time_t gnutls_x509_extract_certificate_activation_time(const
-						       gnutls_datum * cert)
+						       gnutls_datum_t * cert)
 {
-    gnutls_x509_crt xcert;
+    gnutls_x509_crt_t xcert;
     time_t result;
 
     result = gnutls_x509_crt_init(&xcert);
@@ -361,9 +361,9 @@ time_t gnutls_x509_extract_certificate_activation_time(const
   *
   **/
 time_t gnutls_x509_extract_certificate_expiration_time(const
-						       gnutls_datum * cert)
+						       gnutls_datum_t * cert)
 {
-    gnutls_x509_crt xcert;
+    gnutls_x509_crt_t xcert;
     time_t result;
 
     result = gnutls_x509_crt_init(&xcert);
@@ -391,9 +391,9 @@ time_t gnutls_x509_extract_certificate_expiration_time(const
   * Version field. Returns a negative value in case of an error.
   *
   **/
-int gnutls_x509_extract_certificate_version(const gnutls_datum * cert)
+int gnutls_x509_extract_certificate_version(const gnutls_datum_t * cert)
 {
-    gnutls_x509_crt xcert;
+    gnutls_x509_crt_t xcert;
     int result;
 
     result = gnutls_x509_crt_init(&xcert);
@@ -428,10 +428,10 @@ int gnutls_x509_extract_certificate_version(const gnutls_datum * cert)
   * Returns a negative value in case of an error.
   *
   **/
-int gnutls_x509_extract_certificate_serial(const gnutls_datum * cert,
+int gnutls_x509_extract_certificate_serial(const gnutls_datum_t * cert,
 					   char *result, int *result_size)
 {
-    gnutls_x509_crt xcert;
+    gnutls_x509_crt_t xcert;
     size_t size = *result_size;
     int ret;
 
@@ -467,14 +467,14 @@ int gnutls_x509_extract_certificate_serial(const gnutls_datum * cert,
   * For DSA the bits returned are of the public
   * exponent.
   *
-  * Returns a member of the gnutls_pk_algorithm enumeration on success,
+  * Returns a member of the gnutls_pk_algorithm_t enumeration on success,
   * or a negative value on error.
   *
   **/
-int gnutls_x509_extract_certificate_pk_algorithm(const gnutls_datum * cert,
+int gnutls_x509_extract_certificate_pk_algorithm(const gnutls_datum_t * cert,
 						 int *bits)
 {
-    gnutls_x509_crt xcert;
+    gnutls_x509_crt_t xcert;
     int result;
 
     result = gnutls_x509_crt_init(&xcert);
@@ -511,10 +511,10 @@ int gnutls_x509_extract_certificate_pk_algorithm(const gnutls_datum * cert,
   **/
 int gnutls_x509_extract_certificate_dn_string(char *buf,
 					      unsigned int sizeof_buf,
-					      const gnutls_datum * cert,
+					      const gnutls_datum_t * cert,
 					      int issuer)
 {
-    gnutls_x509_crt xcert;
+    gnutls_x509_crt_t xcert;
     int result;
 
     result = gnutls_x509_crt_init(&xcert);
@@ -547,7 +547,7 @@ int gnutls_x509_extract_certificate_dn_string(char *buf,
   * @CRL_list_length: not used
   *
   * This function will try to verify the given certificate list and return its status (TRUSTED, EXPIRED etc.). 
-  * The return value (status) should be one or more of the gnutls_certificate_status 
+  * The return value (status) should be one or more of the gnutls_certificate_status_t 
   * enumerated elements bitwise or'd. Note that expiration and activation dates are not checked 
   * by this function, you should check them using the appropriate functions.
   *
@@ -557,7 +557,7 @@ int gnutls_x509_extract_certificate_dn_string(char *buf,
   * However you must also check the peer's name in order to check if the verified certificate belongs to the 
   * actual peer. 
   *
-  * The return value (status) should be one or more of the gnutls_certificate_status 
+  * The return value (status) should be one or more of the gnutls_certificate_status_t 
   * enumerated elements bitwise or'd.
   *
   * GNUTLS_CERT_INVALID\: the peer's certificate is not valid.
@@ -570,17 +570,17 @@ int gnutls_x509_extract_certificate_dn_string(char *buf,
   *  
   *
   **/
-int gnutls_x509_verify_certificate(const gnutls_datum * cert_list,
+int gnutls_x509_verify_certificate(const gnutls_datum_t * cert_list,
 				   int cert_list_length,
-				   const gnutls_datum * CA_list,
+				   const gnutls_datum_t * CA_list,
 				   int CA_list_length,
-				   const gnutls_datum * CRL_list,
+				   const gnutls_datum_t * CRL_list,
 				   int CRL_list_length)
 {
     unsigned int verify;
-    gnutls_x509_crt *peer_certificate_list = NULL;
-    gnutls_x509_crt *ca_certificate_list = NULL;
-    gnutls_x509_crl *crl_list = NULL;
+    gnutls_x509_crt_t *peer_certificate_list = NULL;
+    gnutls_x509_crt_t *ca_certificate_list = NULL;
+    gnutls_x509_crl_t *crl_list = NULL;
     int peer_certificate_list_size = 0, i, x, ret;
     int ca_certificate_list_size = 0, crl_list_size = 0;
 
@@ -594,7 +594,7 @@ int gnutls_x509_verify_certificate(const gnutls_datum * cert_list,
     peer_certificate_list =
 	gnutls_calloc(1,
 		      peer_certificate_list_size *
-		      sizeof(gnutls_x509_crt));
+		      sizeof(gnutls_x509_crt_t));
     if (peer_certificate_list == NULL) {
 	gnutls_assert();
 	ret = GNUTLS_E_MEMORY_ERROR;
@@ -604,7 +604,7 @@ int gnutls_x509_verify_certificate(const gnutls_datum * cert_list,
     ca_certificate_list_size = CA_list_length;
     ca_certificate_list =
 	gnutls_calloc(1,
-		      ca_certificate_list_size * sizeof(gnutls_x509_crt));
+		      ca_certificate_list_size * sizeof(gnutls_x509_crt_t));
     if (ca_certificate_list == NULL) {
 	gnutls_assert();
 	ret = GNUTLS_E_MEMORY_ERROR;
@@ -614,7 +614,7 @@ int gnutls_x509_verify_certificate(const gnutls_datum * cert_list,
     /* allocate memory for CRL
      */
     crl_list_size = CRL_list_length;
-    crl_list = gnutls_calloc(1, crl_list_size * sizeof(gnutls_x509_crl));
+    crl_list = gnutls_calloc(1, crl_list_size * sizeof(gnutls_x509_crl_t));
     if (crl_list == NULL) {
 	gnutls_assert();
 	ret = GNUTLS_E_MEMORY_ERROR;
@@ -729,13 +729,13 @@ int gnutls_x509_verify_certificate(const gnutls_datum * cert_list,
   * This function will return the public key algorithm of a DER encoded private
   * key.
   *
-  * Returns a member of the gnutls_pk_algorithm enumeration on success,
+  * Returns a member of the gnutls_pk_algorithm_t enumeration on success,
   * or GNUTLS_E_UNKNOWN_PK_ALGORITHM on error.
   *
   **/
-int gnutls_x509_extract_key_pk_algorithm(const gnutls_datum * key)
+int gnutls_x509_extract_key_pk_algorithm(const gnutls_datum_t * key)
 {
-    gnutls_x509_privkey pkey;
+    gnutls_x509_privkey_t pkey;
     int ret, pk;
 
     ret = gnutls_x509_privkey_init(&pkey);
@@ -773,12 +773,12 @@ int gnutls_x509_extract_key_pk_algorithm(const gnutls_datum * key)
   * will be returned.
   *
   **/
-int gnutls_x509_pkcs7_extract_certificate(const gnutls_datum *
+int gnutls_x509_pkcs7_extract_certificate(const gnutls_datum_t *
 					  pkcs7_struct, int indx,
 					  char *certificate,
 					  int *certificate_size)
 {
-    gnutls_pkcs7 pkcs7;
+    gnutls_pkcs7_t pkcs7;
     int result;
     size_t size = *certificate_size;
 
@@ -811,10 +811,10 @@ int gnutls_x509_pkcs7_extract_certificate(const gnutls_datum *
   * Returns a negative value on failure.
   *
   **/
-int gnutls_x509_pkcs7_extract_certificate_count(const gnutls_datum *
+int gnutls_x509_pkcs7_extract_certificate_count(const gnutls_datum_t *
 						pkcs7_struct)
 {
-    gnutls_pkcs7 pkcs7;
+    gnutls_pkcs7_t pkcs7;
     int result;
 
     result = gnutls_pkcs7_init(&pkcs7);
diff --git a/libextra/openssl_compat.h b/libextra/openssl_compat.h
index aa9f931c54..b91c20fada 100644
--- a/libextra/openssl_compat.h
+++ b/libextra/openssl_compat.h
@@ -4,29 +4,29 @@
 /* Extra definitions */
 #include <gnutls/openssl.h>
 
-int gnutls_x509_extract_dn( const gnutls_datum*, gnutls_x509_dn*);
-int gnutls_x509_extract_dn_string(const gnutls_datum * idn,
+int gnutls_x509_extract_dn( const gnutls_datum_t*, gnutls_x509_dn*);
+int gnutls_x509_extract_dn_string(const gnutls_datum_t * idn,
         char *buf, unsigned int sizeof_buf);
-int gnutls_x509_extract_certificate_dn( const gnutls_datum*, gnutls_x509_dn*);
+int gnutls_x509_extract_certificate_dn( const gnutls_datum_t*, gnutls_x509_dn*);
 int gnutls_x509_extract_certificate_dn_string(char *buf, unsigned int sizeof_buf,
-   const gnutls_datum * cert, int issuer);
-int gnutls_x509_extract_certificate_issuer_dn(  const gnutls_datum*, gnutls_x509_dn *);
-int gnutls_x509_extract_certificate_version( const gnutls_datum*);
-int gnutls_x509_extract_certificate_serial(const gnutls_datum * cert, char* result, int* result_size);
-time_t gnutls_x509_extract_certificate_activation_time( const gnutls_datum*);
-time_t gnutls_x509_extract_certificate_expiration_time( const gnutls_datum*);
-int gnutls_x509_extract_certificate_subject_alt_name( const gnutls_datum*, int seq, char*, int*);
-int gnutls_x509_pkcs7_extract_certificate(const gnutls_datum * pkcs7_struct, int indx, char* certificate, int* certificate_size);
-int gnutls_x509_extract_certificate_pk_algorithm( const gnutls_datum * cert, int* bits);
-int gnutls_x509_extract_certificate_ca_status(const gnutls_datum * cert);
-int gnutls_x509_extract_key_pk_algorithm( const gnutls_datum * key);
+   const gnutls_datum_t * cert, int issuer);
+int gnutls_x509_extract_certificate_issuer_dn(  const gnutls_datum_t*, gnutls_x509_dn *);
+int gnutls_x509_extract_certificate_version( const gnutls_datum_t*);
+int gnutls_x509_extract_certificate_serial(const gnutls_datum_t * cert, char* result, int* result_size);
+time_t gnutls_x509_extract_certificate_activation_time( const gnutls_datum_t*);
+time_t gnutls_x509_extract_certificate_expiration_time( const gnutls_datum_t*);
+int gnutls_x509_extract_certificate_subject_alt_name( const gnutls_datum_t*, int seq, char*, int*);
+int gnutls_x509_pkcs7_extract_certificate(const gnutls_datum_t * pkcs7_struct, int indx, char* certificate, int* certificate_size);
+int gnutls_x509_extract_certificate_pk_algorithm( const gnutls_datum_t * cert, int* bits);
+int gnutls_x509_extract_certificate_ca_status(const gnutls_datum_t * cert);
+int gnutls_x509_extract_key_pk_algorithm( const gnutls_datum_t * key);
 
-int gnutls_x509_verify_certificate( const gnutls_datum* cert_list, int cert_list_length, const gnutls_datum * CA_list, int CA_list_length, const gnutls_datum* CRL_list, int CRL_list_length);
+int gnutls_x509_verify_certificate( const gnutls_datum_t* cert_list, int cert_list_length, const gnutls_datum_t * CA_list, int CA_list_length, const gnutls_datum_t* CRL_list, int CRL_list_length);
 
 #define gnutls_x509_fingerprint gnutls_fingerprint
-#define gnutls_x509_certificate_format gnutls_x509_crt_fmt
+#define gnutls_x509_certificate_format gnutls_x509_crt_fmt_t
 
-int gnutls_x509_extract_key_pk_algorithm( const gnutls_datum * key);
+int gnutls_x509_extract_key_pk_algorithm( const gnutls_datum_t * key);
 
 #define gnutls_certificate_set_rsa_params gnutls_certificate_set_rsa_export_params