cert_type abreviation was expanded to certificate_type.

17 files changed, 167 insertions, 108 deletions

diff --git a/doc/tex/ex3.tex b/doc/tex/ex3.tex
index 85dfe7afa6..6c71a7bab5 100644
--- a/doc/tex/ex3.tex
+++ b/doc/tex/ex3.tex
@@ -9,6 +9,8 @@
         PRINTX( "C:", X.country); \
         PRINTX( "E:", X.email)
 
+static void print_x509_certificate_info(gnutls_session);
+
 /* This function will print some details of the
  * given session.
  */
@@ -17,12 +19,8 @@ int print_info(gnutls_session session)
    const char *tmp;
    gnutls_credentials_type cred;
    gnutls_x509_dn dn;
-   const gnutls_datum *cert_list;
    int status;
-   int cert_list_size = 0;
    gnutls_kx_algorithm kx;
-   time_t expiret = gnutls_certificate_expiration_time_peers(session);
-   time_t activet = gnutls_certificate_activation_time_peers(session);
 
    /* print the key exchange's algorithm name
     */
@@ -30,33 +28,37 @@ int print_info(gnutls_session session)
    tmp = gnutls_kx_get_name(kx);
    printf("- Key Exchange: %s\n", tmp);
 
+   /* Check the authentication type used and switch
+    * to the appropriate.
+    */
    cred = gnutls_auth_get_type(session);
    switch (cred) {
-   case GNUTLS_CRD_ANON:
+   case GNUTLS_CRD_ANON:       /* anonymous authentication */
+
       printf("- Anonymous DH using prime of %d bits\n",
              gnutls_dh_get_bits(session));
       break;
-   case GNUTLS_CRD_CERTIFICATE:
-      /* in case of certificate authentication
+
+   case GNUTLS_CRD_CERTIFICATE:        /* certificate authentication */
+
+      /* try to verify the peer's certificate (if any)
        */
-      cert_list = gnutls_certificate_get_peers(session, &cert_list_size);
       status = gnutls_certificate_verify_peers(session);
-      
-      if ( status < 0) {
-         if ( status == GNUTLS_E_NO_CERTIFICATE_FOUND)
+
+      if (status < 0) {
+         if (status == GNUTLS_E_NO_CERTIFICATE_FOUND)
             printf("- Peer did not send any X509 Certificate.\n");
          else
             printf("- Could not verify certificate\n");
       } else {
 
-         if ( status & GNUTLS_CERT_INVALID)
+         if (status & GNUTLS_CERT_INVALID)
             printf("- Peer's certificate is invalid\n");
-         if ( status & GNUTLS_CERT_CORRUPTED)
+         if (status & GNUTLS_CERT_CORRUPTED)
             printf("- Peer's certificate is corrupted.\n");
-         if ( status & GNUTLS_CERT_REVOKED)
+         if (status & GNUTLS_CERT_REVOKED)
             printf("- Peer's certificate is revoked\n");
-
-         if ( status & GNUTLS_CERT_NOT_TRUSTED)
+         if (status & GNUTLS_CERT_NOT_TRUSTED)
             printf("- Peer's certificate is not trusted\n");
          else
             printf("- Peer's certificate is trusted\n");
@@ -72,88 +74,125 @@ int print_info(gnutls_session session)
       /* if the certificate list is available, then
        * print some information about it.
        */
-      if (cert_list_size > 0 && gnutls_cert_type_get(session) == GNUTLS_CRT_X509) {
-         char digest[20];
-         char serial[40];
-         int digest_size = sizeof(digest), i;
-         int serial_size = sizeof(serial);
-         char printable[120];
-         char *print;
-         int algo, bits;
-
-         printf(" - Certificate info:\n");
-
-         printf(" - Certificate is valid since: %s", ctime( &activet));
-         printf(" - Certificate expires: %s", ctime( &expiret));
-
-         /* Print the fingerprint of the certificate
-          */
-         if (gnutls_x509_fingerprint(GNUTLS_DIG_MD5, &cert_list[0], digest, &digest_size) >= 0) {
-            print = printable;
-            for (i = 0; i < digest_size; i++) {
-               sprintf(print, "%.2x ", (unsigned char) digest[i]);
-               print += 3;
-            }
-            printf(" - Certificate fingerprint: %s\n", printable);
-         }
+      print_x509_certificate_info(session)
 
-         /* Print the serial number of the certificate.
-          */
-         if (gnutls_x509_extract_certificate_serial(&cert_list[0], serial, &serial_size) >= 0) {
-            print = printable;
-            for (i = 0; i < serial_size; i++) {
-               sprintf(print, "%.2x ", (unsigned char) serial[i]);
-               print += 3;
-            }
-            printf(" - Certificate serial number: %s\n", printable);
-         }
-
-         /* Extract some of the public key algorithm's parameters
-          */
-         algo = gnutls_x509_extract_certificate_pk_algorithm( &cert_list[0], &bits);
-         printf("Certificate public key: ");
-
-         if (algo==GNUTLS_PK_RSA) {
-            printf("RSA\n");
-            printf(" Modulus: %d bits\n", bits);
-         } else if (algo==GNUTLS_PK_DSA) {
-            printf("DSA\n");
-            printf(" Exponent: %d bits\n", bits);
-         } else {
-            printf("UNKNOWN\n");
-         }
-
-         /* Print the version of the X.509 
-          * certificate.
-          */
-         printf(" - Certificate version: #%d\n", gnutls_x509_extract_certificate_version(&cert_list[0]));
-
-         gnutls_x509_extract_certificate_dn(&cert_list[0], &dn);
-         PRINT_DN(dn);
-
-         gnutls_x509_extract_certificate_issuer_dn(&cert_list[0], &dn);
-         printf(" - Certificate Issuer's info:\n");
-         PRINT_DN(dn);
-
-      }
-   }
+   }                            /* switch */
 
+   /* print the protocol's name (ie TLS 1.0) 
+    */
    tmp = gnutls_protocol_get_name(gnutls_protocol_get_version(session));
    printf("- Protocol: %s\n", tmp);
 
-   tmp = gnutls_cert_type_get_name( gnutls_cert_type_get(session));
+   /* print the certificate type of the peer.
+    * ie X.509
+    */
+   tmp = gnutls_certificate_type_get_name(
+      gnutls_certificate_type_get(session));
+
    printf("- Certificate Type: %s\n", tmp);
 
-   tmp = gnutls_compression_get_name(gnutls_compression_get(session));
+   /* print the compression algorithm (if any)
+    */
+   tmp = gnutls_compression_get_name( gnutls_compression_get(session));
    printf("- Compression: %s\n", tmp);
 
+   /* print the name of the cipher used.
+    * ie 3DES.
+    */
    tmp = gnutls_cipher_get_name(gnutls_cipher_get(session));
    printf("- Cipher: %s\n", tmp);
 
+   /* Print the MAC algorithms name.
+    * ie SHA1
+    */
    tmp = gnutls_mac_get_name(gnutls_mac_get(session));
    printf("- MAC: %s\n", tmp);
 
    return 0;
 }
 
+/* This function will print information about this session's peer
+ * certificate. 
+ */
+static void print_x509_certificate_info(gnutls_session session)
+{
+   char digest[20];
+   char serial[40];
+   int digest_size = sizeof(digest), i;
+   int serial_size = sizeof(serial);
+   char printable[120];
+   char *print;
+   int algo, bits;
+   time_t expiret = gnutls_certificate_expiration_time_peers(session);
+   time_t activet = gnutls_certificate_activation_time_peers(session);
+   const gnutls_datum *cert_list;
+   int cert_list_size = 0;
+
+   cert_list = gnutls_certificate_get_peers(session, &cert_list_size);
+
+   if (cert_list_size > 0
+       && gnutls_certificate_type_get(session) == GNUTLS_CRT_X509) {
+
+      printf(" - Certificate info:\n");
+
+      printf(" - Certificate is valid since: %s", ctime(&activet));
+      printf(" - Certificate expires: %s", ctime(&expiret));
+
+      /* Print the fingerprint of the certificate
+       */
+      if (gnutls_x509_fingerprint
+          (GNUTLS_DIG_MD5, &cert_list[0], digest, &digest_size) >= 0) {
+         print = printable;
+         for (i = 0; i < digest_size; i++) {
+            sprintf(print, "%.2x ", (unsigned char) digest[i]);
+            print += 3;
+         }
+         printf(" - Certificate fingerprint: %s\n", printable);
+      }
+
+      /* Print the serial number of the certificate.
+       */
+      if (gnutls_x509_extract_certificate_serial
+          (&cert_list[0], serial, &serial_size) >= 0) {
+         print = printable;
+         for (i = 0; i < serial_size; i++) {
+            sprintf(print, "%.2x ", (unsigned char) serial[i]);
+            print += 3;
+         }
+         printf(" - Certificate serial number: %s\n", printable);
+      }
+
+      /* Extract some of the public key algorithm's parameters
+       */
+      algo =
+          gnutls_x509_extract_certificate_pk_algorithm(&cert_list[0],
+                                                       &bits);
+      printf("Certificate public key: ");
+
+      if (algo == GNUTLS_PK_RSA) {
+         printf("RSA\n");
+         printf(" Modulus: %d bits\n", bits);
+      } else if (algo == GNUTLS_PK_DSA) {
+         printf("DSA\n");
+         printf(" Exponent: %d bits\n", bits);
+      } else {
+         printf("UNKNOWN\n");
+      }
+
+      /* Print the version of the X.509 
+       * certificate.
+       */
+      printf(" - Certificate version: #%d\n",
+             gnutls_x509_extract_certificate_version(&cert_list[0]));
+
+      gnutls_x509_extract_certificate_dn(&cert_list[0], &dn);
+      PRINT_DN(dn);
+
+      gnutls_x509_extract_certificate_issuer_dn(&cert_list[0], &dn);
+      printf(" - Certificate Issuer's info:\n");
+      PRINT_DN(dn);
+
+   }
+}
+
 \end{verbatim}
diff --git a/doc/tex/handshake.tex b/doc/tex/handshake.tex
index e144664988..c4f16557c7 100644
--- a/doc/tex/handshake.tex
+++ b/doc/tex/handshake.tex
@@ -15,7 +15,7 @@ to set the priority of MAC algorithms.
 to set the priority of key exchange algorithms.
 \item \printfunc{gnutls_compression_set_priority}{gnutls\_compression\_set\_priority}:
 to set the priority of compression methods.
-\item \printfunc{gnutls_cert_type_set_priority}{gnutls\_cert\_type\_set\_priority}:
+\item \printfunc{gnutls_certificate_type_set_priority}{gnutls\_certificate\_type\_set\_priority}:
 to set the priority of certificate types (ie. OpenPGP, X.509).
 \item \printfunc{gnutls_protocol_set_priority}{gnutls\_protocol\_set\_priority}:
 to set the priority of protocol versions (ie. \sslIII{}, \tlsI).
diff --git a/lib/auth_cert.c b/lib/auth_cert.c
index 9a79a978a1..2ab3f2e243 100644
--- a/lib/auth_cert.c
+++ b/lib/auth_cert.c
@@ -370,7 +370,7 @@ static int _gnutls_find_acceptable_client_cert(gnutls_session session,
 		/* put the requested DNs to req_dn, only in case
 		 * of X509 certificates.
 		 */
-		if (gnutls_cert_type_get(session) == GNUTLS_CRT_X509) {
+		if (gnutls_certificate_type_get(session) == GNUTLS_CRT_X509) {
 			data = _data;
 			data_size = _data_size;
 
@@ -416,7 +416,7 @@ static int _gnutls_find_acceptable_client_cert(gnutls_session session,
 		 */
 		for (j = i = 0; i < cred->ncerts; i++) {
 			if ((cred->cert_list[i][0].cert_type ==
-			     gnutls_cert_type_get(session)) &&
+			     gnutls_certificate_type_get(session)) &&
 			    (_gnutls_check_pk_algo_in_list(pk_algos,
 							   pk_algos_length,
 							   cred->
diff --git a/lib/ext_cert_type.c b/lib/ext_cert_type.c
index 78ee239a31..c2084f61b5 100644
--- a/lib/ext_cert_type.c
+++ b/lib/ext_cert_type.c
@@ -31,7 +31,7 @@
 
 /* 
  * In case of a server: if a CERT_TYPE extension type is received then it stores
- * into the session security parameters the new value. The server may use gnutls_session_cert_type_get(),
+ * into the session security parameters the new value. The server may use gnutls_session_certificate_type_get(),
  * to access it.
  *
  * In case of a client: If a cert_types have been specified then we send the extension.
diff --git a/lib/gnutls.h.in.in b/lib/gnutls.h.in.in
index e5bbe1c2fe..1c38dfd5df 100644
--- a/lib/gnutls.h.in.in
+++ b/lib/gnutls.h.in.in
@@ -142,7 +142,7 @@ 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_cert_type_get( gnutls_session session);
+gnutls_certificate_type		gnutls_certificate_type_get( gnutls_session session);
 
 size_t gnutls_cipher_get_key_size( gnutls_cipher_algorithm algorithm);
 
@@ -151,7 +151,7 @@ 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_cert_type_get_name( gnutls_certificate_type type);
+const char *gnutls_certificate_type_get_name( gnutls_certificate_type type);
 
 
 /* error functions */
@@ -185,7 +185,7 @@ 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_cert_type_set_priority( gnutls_session session, const int*);
+int gnutls_certificate_type_set_priority( gnutls_session session, const int*);
 
 /* Returns the name of a cipher suite */
 const char *gnutls_cipher_suite_get_name(gnutls_kx_algorithm kx_algorithm,
@@ -385,3 +385,7 @@ int gnutls_x509_fingerprint(gnutls_digest_algorithm algo, const gnutls_datum* da
 #define gnutls_deinit gnutls_session_deinit
 #define _gnutls_deinit _gnutls_session_deinit
 #define gnutls_handshake_set_exportable_detection(x,y) 0
+#define gnutls_cert_type_get gnutls_certificate_type_get
+#define gnutls_cert_type_set_priority gnutls_certificate_type_set_priority
+#define gnutls_cert_type_get_name gnutls_certificate_type_get_name
+
diff --git a/lib/gnutls_algorithms.c b/lib/gnutls_algorithms.c
index 563da79ae9..54588f8d15 100644
--- a/lib/gnutls_algorithms.c
+++ b/lib/gnutls_algorithms.c
@@ -1187,13 +1187,13 @@ _gnutls_supported_compression_methods(gnutls_session session, uint8 ** comp)
 }
 
 /**
-  * gnutls_cert_type_get_name - Returns a string with the name of the specified certificate type
+  * gnutls_certificate_type_get_name - Returns a string with the name of the specified certificate type
   * @type: is a certificate type
   *
   * Returns a string that contains the name 
   * of the specified MAC algorithm.
   **/
-const char *gnutls_cert_type_get_name( gnutls_certificate_type type)
+const char *gnutls_certificate_type_get_name( gnutls_certificate_type type)
 {
 	const char *ret = NULL;
 
diff --git a/lib/gnutls_cert.c b/lib/gnutls_cert.c
index abff0dacc7..01cf5cdbbf 100644
--- a/lib/gnutls_cert.c
+++ b/lib/gnutls_cert.c
@@ -399,7 +399,7 @@ int gnutls_certificate_verify_peers(gnutls_session session)
 	if (info->raw_certificate_list == NULL || info->ncerts == 0)
 		return GNUTLS_E_NO_CERTIFICATE_FOUND;
 
-	switch( gnutls_cert_type_get( session)) {
+	switch( gnutls_certificate_type_get( session)) {
 		case GNUTLS_CRT_X509:
 			return _gnutls_x509_cert_verify_peers( session);
 		case GNUTLS_CRT_OPENPGP:
@@ -435,7 +435,7 @@ time_t gnutls_certificate_expiration_time_peers(gnutls_session session)
 		return (time_t) -1;
 	}
 
-	switch( gnutls_cert_type_get( session)) {
+	switch( gnutls_certificate_type_get( session)) {
 		case GNUTLS_CRT_X509:
 			return gnutls_x509_extract_certificate_expiration_time(
 				&info->raw_certificate_list[0]);
@@ -476,7 +476,7 @@ time_t gnutls_certificate_activation_time_peers(gnutls_session session)
 		return (time_t) -1;
 	}
 
-	switch( gnutls_cert_type_get( session)) {
+	switch( gnutls_certificate_type_get( session)) {
 		case GNUTLS_CRT_X509:
 			return gnutls_x509_extract_certificate_activation_time(
 				&info->raw_certificate_list[0]);
diff --git a/lib/gnutls_int_compat.c b/lib/gnutls_int_compat.c
index 818a0b1e03..c60a0f6848 100644
--- a/lib/gnutls_int_compat.c
+++ b/lib/gnutls_int_compat.c
@@ -43,6 +43,22 @@ void gnutls_deinit(gnutls_session session)
 	gnutls_session_deinit( session);
 }
 
+#undef gnutls_cert_type_get
+gnutls_certificate_type gnutls_cert_type_get( gnutls_session session) {
+	return gnutls_certificate_type_get( session);
+}
+
+#undef gnutls_cert_type_set_priority
+int gnutls_cert_type_set_priority( gnutls_session session, const int* list) {
+	return gnutls_certificate_type_set_priority( session, list);
+}
+
+#undef gnutls_cert_type_get_name
+const char *gnutls_cert_type_get_name( gnutls_certificate_type type)
+{
+	return gnutls_certificate_type_get_name( type);
+}
+
 /* nothing here */
 
 #endif /* GNUTLS_BACKWARDS_COMPATIBLE */
diff --git a/lib/gnutls_priority.c b/lib/gnutls_priority.c
index 0aad4ddeaa..cfa26dacf4 100644
--- a/lib/gnutls_priority.c
+++ b/lib/gnutls_priority.c
@@ -194,7 +194,7 @@ int num=0, i;
 }
 
 /**
-  * gnutls_cert_type_set_priority - Sets the priority on the certificate types supported by gnutls.
+  * 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.
   *
@@ -205,7 +205,7 @@ int num=0, i;
   * The server does not use the cert type priority except for disabling
   * types that were not specified.
   **/
-int gnutls_cert_type_set_priority( gnutls_session session, gnutls_list list) {
+int gnutls_certificate_type_set_priority( gnutls_session session, gnutls_list list) {
 #ifdef HAVE_LIBOPENCDK
 gnutls_list _list = list;
 int num=0, i;
diff --git a/lib/gnutls_priority.h b/lib/gnutls_priority.h
index 3caf224ed4..d70cb5eedd 100644
--- a/lib/gnutls_priority.h
+++ b/lib/gnutls_priority.h
@@ -23,4 +23,4 @@ int gnutls_kx_set_priority( gnutls_session session, gnutls_list);
 int gnutls_mac_set_priority( gnutls_session session, gnutls_list);
 int gnutls_compression_set_priority( gnutls_session session, gnutls_list);
 int gnutls_protocol_set_priority( gnutls_session session, gnutls_list);
-int gnutls_cert_type_set_priority( gnutls_session session, gnutls_list);
+int gnutls_certificate_type_set_priority( gnutls_session session, gnutls_list);
diff --git a/lib/gnutls_state.c b/lib/gnutls_state.c
index 221a4b05df..6bb815413d 100644
--- a/lib/gnutls_state.c
+++ b/lib/gnutls_state.c
@@ -60,14 +60,14 @@ gnutls_cipher_algorithm gnutls_cipher_get( gnutls_session session) {
 }
 
 /**
-  * gnutls_cert_type_get - Returns the currently used certificate type.
+  * gnutls_certificate_type_get - Returns the currently used certificate type.
   * @session: is a &gnutls_session 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_cert_type_get( gnutls_session session) {
+gnutls_certificate_type gnutls_certificate_type_get( gnutls_session session) {
 	return session->security_parameters.cert_type;
 }
 
diff --git a/lib/gnutls_state.h b/lib/gnutls_state.h
index c5eba45527..ae34e02bec 100644
--- a/lib/gnutls_state.h
+++ b/lib/gnutls_state.h
@@ -8,7 +8,7 @@ void _gnutls_record_set_default_version(gnutls_session session, gnutls_protocol_
 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_cert_type_get( gnutls_session session);
+gnutls_certificate_type gnutls_certificate_type_get( gnutls_session session);
 
 #include <gnutls_auth_int.h>
 
diff --git a/libextra/gnutls_openssl.c b/libextra/gnutls_openssl.c
index 32807e90e5..0fbcc9a7c3 100644
--- a/libextra/gnutls_openssl.c
+++ b/libextra/gnutls_openssl.c
@@ -684,7 +684,7 @@ SSL_CIPHER *SSL_get_current_cipher(SSL *ssl)
     ssl->ciphersuite.kx = gnutls_kx_get(ssl->gnutls_state);
     ssl->ciphersuite.mac = gnutls_mac_get(ssl->gnutls_state);
     ssl->ciphersuite.compression = gnutls_compression_get(ssl->gnutls_state);
-    ssl->ciphersuite.cert = gnutls_cert_type_get(ssl->gnutls_state);
+    ssl->ciphersuite.cert = gnutls_certificate_type_get(ssl->gnutls_state);
 
     return &(ssl->ciphersuite);
 }
diff --git a/src/cli.c b/src/cli.c
index 59e3441e19..dafd147d76 100644
--- a/src/cli.c
+++ b/src/cli.c
@@ -246,7 +246,7 @@ int main(int argc, char **argv)
       gnutls_kx_set_priority(session, kx_priority);
       gnutls_protocol_set_priority(session, protocol_priority);
       gnutls_mac_set_priority(session, mac_priority);
-      gnutls_cert_type_set_priority(session, cert_type_priority);
+      gnutls_certificate_type_set_priority(session, cert_type_priority);
 
       gnutls_dh_set_prime_bits(session, 512);
 
diff --git a/src/common.c b/src/common.c
index 47615bbe24..0fa2c4fb3b 100644
--- a/src/common.c
+++ b/src/common.c
@@ -261,7 +261,7 @@ void print_cert_info(gnutls_session session)
 {
 
 	printf( " - Certificate type: ");
-	switch (gnutls_cert_type_get(session)) {
+	switch (gnutls_certificate_type_get(session)) {
 	case GNUTLS_CRT_X509:
 		printf("X.509\n");
 		print_x509_info(session);
diff --git a/src/serv.c b/src/serv.c
index 87662a7a8b..f7f1d9c32d 100644
--- a/src/serv.c
+++ b/src/serv.c
@@ -275,7 +275,7 @@ gnutls_session initialize_session (void)
     gnutls_kx_set_priority(session, kx_priority);
     gnutls_protocol_set_priority( session, protocol_priority);
     gnutls_mac_set_priority(session, mac_priority);
-    gnutls_cert_type_set_priority(session, cert_type_priority);
+    gnutls_certificate_type_set_priority(session, cert_type_priority);
 
     gnutls_cred_set(session, GNUTLS_CRD_ANON, dh_cred);
     gnutls_cred_set(session, GNUTLS_CRD_SRP, srp_cred);
@@ -351,7 +351,7 @@ char* peer_print_info(gnutls_session session, int *ret_length, const char* heade
    sprintf(tmp2, "<TABLE border=1><TR><TD>Protocol version:</TD><TD>%s</TD></TR>\n", tmp);
 
    if (gnutls_auth_get_type(session) == GNUTLS_CRD_CERTIFICATE) {
-      tmp = gnutls_cert_type_get_name(gnutls_cert_type_get(session));
+      tmp = gnutls_certificate_type_get_name(gnutls_certificate_type_get(session));
       sprintf(tmp2, "<TR><TD>Certificate Type:</TD><TD>%s</TD></TR>\n", tmp);
    }
 
diff --git a/src/tests.c b/src/tests.c
index 00a77e8d6a..88291d18d3 100644
--- a/src/tests.c
+++ b/src/tests.c
@@ -96,7 +96,7 @@ const static int cert_type_priority[16] = { GNUTLS_CRT_X509, 0 };
 #define ADD_ALL_MACS(session) gnutls_mac_set_priority(session, mac_priority)
 #define ADD_ALL_KX(session) gnutls_kx_set_priority(session, kx_priority)
 #define ADD_ALL_PROTOCOLS(session) gnutls_protocol_set_priority(session, protocol_priority)
-#define ADD_ALL_CERTTYPES(session) gnutls_cert_type_set_priority(session, cert_type_priority)
+#define ADD_ALL_CERTTYPES(session) gnutls_certificate_type_set_priority(session, cert_type_priority)
 
 static void ADD_KX(gnutls_session session, int kx) {
 	static int _kx_priority[] = { 0, 0 };
@@ -140,7 +140,7 @@ static void ADD_CERTTYPE(gnutls_session session, int ctype) {
 	static int _ct_priority[] = { 0, 0 };
 	_ct_priority[0] = ctype;
 
-	gnutls_cert_type_set_priority(session, _ct_priority);
+	gnutls_certificate_type_set_priority(session, _ct_priority);
 }
 
 static void ADD_PROTOCOL(gnutls_session session, int protocol) {
@@ -274,7 +274,7 @@ int ret;
 	ret = do_handshake( session);
 	if (ret==FAILED) return ret;
 
-	if ( gnutls_cert_type_get(session) == GNUTLS_CRT_OPENPGP)
+	if ( gnutls_certificate_type_get(session) == GNUTLS_CRT_OPENPGP)
 		return SUCCEED;
 
 	return FAILED;