1 files changed, 114 insertions, 114 deletions

diff --git a/src/daemon/https/tls/gnutls_kx.c b/src/daemon/https/tls/gnutls_kx.c
index 45717b4f..5f0966f8 100644
--- a/src/daemon/https/tls/gnutls_kx.c
+++ b/src/daemon/https/tls/gnutls_kx.c
@@ -23,7 +23,7 @@
  */
 
 /* This file contains functions which are wrappers for the key exchange
- * part of TLS. They are called by the handshake functions (MHD_gnutls_handshake)
+ * part of TLS. They are called by the handshake functions (MHD__gnutls_handshake)
  */
 
 #include "gnutls_int.h"
@@ -42,10 +42,10 @@
  */
 
 #define MASTER_SECRET "master secret"
-static int generate_normal_master (mhd_gtls_session_t session, int);
+static int generate_normal_master (MHD_gtls_session_t session, int);
 
 int
-mhd_gtls_generate_master (mhd_gtls_session_t session, int keep_premaster)
+MHD_gtls_generate_master (MHD_gtls_session_t session, int keep_premaster)
 {
   if (session->internals.resumed == RESUME_FALSE)
     return generate_normal_master (session, keep_premaster);
@@ -56,22 +56,22 @@ mhd_gtls_generate_master (mhd_gtls_session_t session, int keep_premaster)
  */
 #define PREMASTER session->key->key
 static int
-generate_normal_master (mhd_gtls_session_t session, int keep_premaster)
+generate_normal_master (MHD_gtls_session_t session, int keep_premaster)
 {
   int ret = 0;
   char buf[512];
 
-  _gnutls_hard_log ("INT: PREMASTER SECRET[%d]: %s\n", PREMASTER.size,
-                    mhd_gtls_bin2hex (PREMASTER.data, PREMASTER.size, buf,
+  MHD__gnutls_hard_log ("INT: PREMASTER SECRET[%d]: %s\n", PREMASTER.size,
+                    MHD_gtls_bin2hex (PREMASTER.data, PREMASTER.size, buf,
                                       sizeof (buf)));
-  _gnutls_hard_log ("INT: CLIENT RANDOM[%d]: %s\n", 32,
-                    mhd_gtls_bin2hex (session->security_parameters.
+  MHD__gnutls_hard_log ("INT: CLIENT RANDOM[%d]: %s\n", 32,
+                    MHD_gtls_bin2hex (session->security_parameters.
                                       client_random, 32, buf, sizeof (buf)));
-  _gnutls_hard_log ("INT: SERVER RANDOM[%d]: %s\n", 32,
-                    mhd_gtls_bin2hex (session->security_parameters.
+  MHD__gnutls_hard_log ("INT: SERVER RANDOM[%d]: %s\n", 32,
+                    MHD_gtls_bin2hex (session->security_parameters.
                                       server_random, 32, buf, sizeof (buf)));
 
-  if (MHD_gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3)
+  if (MHD__gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3)
     {
       opaque rnd[2 * TLS_RANDOM_SIZE + 1];
 
@@ -81,7 +81,7 @@ generate_normal_master (mhd_gtls_session_t session, int keep_premaster)
               session->security_parameters.server_random, TLS_RANDOM_SIZE);
 
       ret =
-        mhd_gnutls_ssl3_generate_random (PREMASTER.data, PREMASTER.size,
+        MHD_gnutls_ssl3_generate_random (PREMASTER.data, PREMASTER.size,
                                          rnd, 2 * TLS_RANDOM_SIZE,
                                          TLS_MASTER_SIZE,
                                          session->security_parameters.
@@ -97,25 +97,25 @@ generate_normal_master (mhd_gtls_session_t session, int keep_premaster)
       rndlen += session->security_parameters.extensions.oprfi_client_len;
       rndlen += session->security_parameters.extensions.oprfi_server_len;
 
-      rnd = gnutls_malloc (rndlen + 1);
+      rnd = MHD_gnutls_malloc (rndlen + 1);
       if (!rnd)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_MEMORY_ERROR;
         }
 
-      _gnutls_hard_log ("INT: CLIENT OPRFI[%d]: %s\n",
+      MHD__gnutls_hard_log ("INT: CLIENT OPRFI[%d]: %s\n",
                         session->security_parameters.
                         extensions.oprfi_server_len,
-                        mhd_gtls_bin2hex (session->security_parameters.
+                        MHD_gtls_bin2hex (session->security_parameters.
                                           extensions.oprfi_client,
                                           session->security_parameters.
                                           extensions.oprfi_client_len, buf,
                                           sizeof (buf)));
-      _gnutls_hard_log ("INT: SERVER OPRFI[%d]: %s\n",
+      MHD__gnutls_hard_log ("INT: SERVER OPRFI[%d]: %s\n",
                         session->security_parameters.
                         extensions.oprfi_server_len,
-                        mhd_gtls_bin2hex (session->security_parameters.
+                        MHD_gtls_bin2hex (session->security_parameters.
                                           extensions.oprfi_server,
                                           session->security_parameters.
                                           extensions.oprfi_server_len, buf,
@@ -135,12 +135,12 @@ generate_normal_master (mhd_gtls_session_t session, int keep_premaster)
               session->security_parameters.extensions.oprfi_server,
               session->security_parameters.extensions.oprfi_server_len);
 
-      ret = mhd_gtls_PRF (session, PREMASTER.data, PREMASTER.size,
+      ret = MHD_gtls_PRF (session, PREMASTER.data, PREMASTER.size,
                           MASTER_SECRET, strlen (MASTER_SECRET),
                           rnd, rndlen, TLS_MASTER_SIZE,
                           session->security_parameters.master_secret);
 
-      gnutls_free (rnd);
+      MHD_gnutls_free (rnd);
     }
   else
     {
@@ -152,7 +152,7 @@ generate_normal_master (mhd_gtls_session_t session, int keep_premaster)
               session->security_parameters.server_random, TLS_RANDOM_SIZE);
 
       ret =
-        mhd_gtls_PRF (session, PREMASTER.data, PREMASTER.size,
+        MHD_gtls_PRF (session, PREMASTER.data, PREMASTER.size,
                       MASTER_SECRET, strlen (MASTER_SECRET),
                       rnd, 2 * TLS_RANDOM_SIZE, TLS_MASTER_SIZE,
                       session->security_parameters.master_secret);
@@ -163,13 +163,13 @@ generate_normal_master (mhd_gtls_session_t session, int keep_premaster)
           session->security_parameters.master_secret, TLS_MASTER_SIZE);
 
   if (!keep_premaster)
-    _gnutls_free_datum (&PREMASTER);
+    MHD__gnutls_free_datum (&PREMASTER);
 
   if (ret < 0)
     return ret;
 
-  _gnutls_hard_log ("INT: MASTER SECRET: %s\n",
-                    mhd_gtls_bin2hex (session->security_parameters.
+  MHD__gnutls_hard_log ("INT: MASTER SECRET: %s\n",
+                    MHD_gtls_bin2hex (session->security_parameters.
                                       master_secret, TLS_MASTER_SIZE, buf,
                                       sizeof (buf)));
 
@@ -182,13 +182,13 @@ generate_normal_master (mhd_gtls_session_t session, int keep_premaster)
  * by the selected ciphersuite.
  */
 int
-mhd_gtls_send_server_kx_message (mhd_gtls_session_t session, int again)
+MHD_gtls_send_server_kx_message (MHD_gtls_session_t session, int again)
 {
   uint8_t *data = NULL;
   int data_size = 0;
   int ret = 0;
 
-  if (session->internals.auth_struct->mhd_gtls_gen_server_kx == NULL)
+  if (session->internals.auth_struct->MHD_gtls_gen_server_kx == NULL)
     return 0;
 
   data = NULL;
@@ -197,30 +197,30 @@ mhd_gtls_send_server_kx_message (mhd_gtls_session_t session, int again)
   if (again == 0)
     {
       data_size =
-        session->internals.auth_struct->mhd_gtls_gen_server_kx (session,
+        session->internals.auth_struct->MHD_gtls_gen_server_kx (session,
                                                                 &data);
 
       if (data_size == GNUTLS_E_INT_RET_0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return 0;
         }
 
       if (data_size < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return data_size;
         }
     }
 
   ret =
-    mhd_gtls_send_handshake (session, data, data_size,
+    MHD_gtls_send_handshake (session, data, data_size,
                              GNUTLS_HANDSHAKE_SERVER_KEY_EXCHANGE);
-  gnutls_free (data);
+  MHD_gnutls_free (data);
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
   return data_size;
@@ -230,7 +230,7 @@ mhd_gtls_send_server_kx_message (mhd_gtls_session_t session, int again)
  * client.
  */
 int
-mhd_gtls_send_server_certificate_request (mhd_gtls_session_t session,
+MHD_gtls_send_server_certificate_request (MHD_gtls_session_t session,
                                           int again)
 {
   uint8_t *data = NULL;
@@ -238,7 +238,7 @@ mhd_gtls_send_server_certificate_request (mhd_gtls_session_t session,
   int ret = 0;
 
   if (session->internals.auth_struct->
-      mhd_gtls_gen_server_certificate_request == NULL)
+      MHD_gtls_gen_server_certificate_request == NULL)
     return 0;
 
   if (session->internals.send_cert_req <= 0)
@@ -251,22 +251,22 @@ mhd_gtls_send_server_certificate_request (mhd_gtls_session_t session,
     {
       data_size =
         session->internals.auth_struct->
-        mhd_gtls_gen_server_certificate_request (session, &data);
+        MHD_gtls_gen_server_certificate_request (session, &data);
 
       if (data_size < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return data_size;
         }
     }
   ret =
-    mhd_gtls_send_handshake (session, data, data_size,
+    MHD_gtls_send_handshake (session, data, data_size,
                              GNUTLS_HANDSHAKE_CERTIFICATE_REQUEST);
-  gnutls_free (data);
+  MHD_gnutls_free (data);
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
   return data_size;
@@ -277,13 +277,13 @@ mhd_gtls_send_server_certificate_request (mhd_gtls_session_t session,
  * exchange message
  */
 int
-mhd_gtls_send_client_kx_message (mhd_gtls_session_t session, int again)
+MHD_gtls_send_client_kx_message (MHD_gtls_session_t session, int again)
 {
   uint8_t *data;
   int data_size;
   int ret = 0;
 
-  if (session->internals.auth_struct->mhd_gtls_gen_client_kx == NULL)
+  if (session->internals.auth_struct->MHD_gtls_gen_client_kx == NULL)
     return 0;
 
 
@@ -293,22 +293,22 @@ mhd_gtls_send_client_kx_message (mhd_gtls_session_t session, int again)
   if (again == 0)
     {
       data_size =
-        session->internals.auth_struct->mhd_gtls_gen_client_kx (session,
+        session->internals.auth_struct->MHD_gtls_gen_client_kx (session,
                                                                 &data);
       if (data_size < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return data_size;
         }
     }
   ret =
-    mhd_gtls_send_handshake (session, data, data_size,
+    MHD_gtls_send_handshake (session, data, data_size,
                              GNUTLS_HANDSHAKE_CLIENT_KEY_EXCHANGE);
-  gnutls_free (data);
+  MHD_gnutls_free (data);
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -320,7 +320,7 @@ mhd_gtls_send_client_kx_message (mhd_gtls_session_t session, int again)
  * verify message
  */
 int
-mhd_gtls_send_client_certificate_verify (mhd_gtls_session_t session,
+MHD_gtls_send_client_certificate_verify (MHD_gtls_session_t session,
                                          int again)
 {
   uint8_t *data;
@@ -337,9 +337,9 @@ mhd_gtls_send_client_certificate_verify (mhd_gtls_session_t session,
   if (session->key->certificate_requested == 0)
     return 0;
 
-  if (session->internals.auth_struct->mhd_gtls_gen_client_cert_vrfy == NULL)
+  if (session->internals.auth_struct->MHD_gtls_gen_client_cert_vrfy == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return 0;                 /* this algorithm does not support cli_cert_vrfy
                                  */
     }
@@ -351,10 +351,10 @@ mhd_gtls_send_client_certificate_verify (mhd_gtls_session_t session,
     {
       data_size =
         session->internals.auth_struct->
-        mhd_gtls_gen_client_cert_vrfy (session, &data);
+        MHD_gtls_gen_client_cert_vrfy (session, &data);
       if (data_size < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return data_size;
         }
       if (data_size == 0)
@@ -362,53 +362,53 @@ mhd_gtls_send_client_certificate_verify (mhd_gtls_session_t session,
 
     }
   ret =
-    mhd_gtls_send_handshake (session, data,
+    MHD_gtls_send_handshake (session, data,
                              data_size, GNUTLS_HANDSHAKE_CERTIFICATE_VERIFY);
-  gnutls_free (data);
+  MHD_gnutls_free (data);
 
   return ret;
 }
 
 
 int
-mhd_gtls_recv_server_kx_message (mhd_gtls_session_t session)
+MHD_gtls_recv_server_kx_message (MHD_gtls_session_t session)
 {
   uint8_t *data = NULL;
   int datasize;
   int ret = 0;
 
-  if (session->internals.auth_struct->mhd_gtls_process_server_kx != NULL)
+  if (session->internals.auth_struct->MHD_gtls_process_server_kx != NULL)
     {
 
       /* EXCEPTION FOR RSA_EXPORT cipher suite
        */
-      if (mhd_gtls_session_is_export (session) != 0 &&
-          _gnutls_peers_cert_less_512 (session) != 0)
+      if (MHD_gtls_session_is_export (session) != 0 &&
+          MHD__gnutls_peers_cert_less_512 (session) != 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return 0;
         }
 
       ret =
-        mhd_gtls_recv_handshake (session, &data,
+        MHD_gtls_recv_handshake (session, &data,
                                  &datasize,
                                  GNUTLS_HANDSHAKE_SERVER_KEY_EXCHANGE,
                                  MANDATORY_PACKET);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
       ret =
-        session->internals.auth_struct->mhd_gtls_process_server_kx (session,
+        session->internals.auth_struct->MHD_gtls_process_server_kx (session,
                                                                     data,
                                                                     datasize);
-      gnutls_free (data);
+      MHD_gnutls_free (data);
 
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
@@ -417,18 +417,18 @@ mhd_gtls_recv_server_kx_message (mhd_gtls_session_t session)
 }
 
 int
-mhd_gtls_recv_server_certificate_request (mhd_gtls_session_t session)
+MHD_gtls_recv_server_certificate_request (MHD_gtls_session_t session)
 {
   uint8_t *data;
   int datasize;
   int ret = 0;
 
   if (session->internals.auth_struct->
-      mhd_gtls_process_server_certificate_request != NULL)
+      MHD_gtls_process_server_certificate_request != NULL)
     {
 
       ret =
-        mhd_gtls_recv_handshake (session, &data,
+        MHD_gtls_recv_handshake (session, &data,
                                  &datasize,
                                  GNUTLS_HANDSHAKE_CERTIFICATE_REQUEST,
                                  OPTIONAL_PACKET);
@@ -440,8 +440,8 @@ mhd_gtls_recv_server_certificate_request (mhd_gtls_session_t session)
 
       ret =
         session->internals.auth_struct->
-        mhd_gtls_process_server_certificate_request (session, data, datasize);
-      gnutls_free (data);
+        MHD_gtls_process_server_certificate_request (session, data, datasize);
+      MHD_gnutls_free (data);
       if (ret < 0)
         return ret;
 
@@ -450,7 +450,7 @@ mhd_gtls_recv_server_certificate_request (mhd_gtls_session_t session)
 }
 
 int
-mhd_gtls_recv_client_kx_message (mhd_gtls_session_t session)
+MHD_gtls_recv_client_kx_message (MHD_gtls_session_t session)
 {
   uint8_t *data;
   int datasize;
@@ -458,11 +458,11 @@ mhd_gtls_recv_client_kx_message (mhd_gtls_session_t session)
 
 
   /* Do key exchange only if the algorithm permits it */
-  if (session->internals.auth_struct->mhd_gtls_process_client_kx != NULL)
+  if (session->internals.auth_struct->MHD_gtls_process_client_kx != NULL)
     {
 
       ret =
-        mhd_gtls_recv_handshake (session, &data,
+        MHD_gtls_recv_handshake (session, &data,
                                  &datasize,
                                  GNUTLS_HANDSHAKE_CLIENT_KEY_EXCHANGE,
                                  MANDATORY_PACKET);
@@ -470,10 +470,10 @@ mhd_gtls_recv_client_kx_message (mhd_gtls_session_t session)
         return ret;
 
       ret =
-        session->internals.auth_struct->mhd_gtls_process_client_kx (session,
+        session->internals.auth_struct->MHD_gtls_process_client_kx (session,
                                                                     data,
                                                                     datasize);
-      gnutls_free (data);
+      MHD_gnutls_free (data);
       if (ret < 0)
         return ret;
 
@@ -486,7 +486,7 @@ mhd_gtls_recv_client_kx_message (mhd_gtls_session_t session)
 /* This is called when we want send our certificate
  */
 int
-mhd_gtls_send_client_certificate (mhd_gtls_session_t session, int again)
+MHD_gtls_send_client_certificate (MHD_gtls_session_t session, int again)
 {
   uint8_t *data = NULL;
   int data_size = 0;
@@ -496,7 +496,7 @@ mhd_gtls_send_client_certificate (mhd_gtls_session_t session, int again)
   if (session->key->certificate_requested == 0)
     return 0;
 
-  if (session->internals.auth_struct->mhd_gtls_gen_client_certificate == NULL)
+  if (session->internals.auth_struct->MHD_gtls_gen_client_certificate == NULL)
     return 0;
 
   data = NULL;
@@ -504,18 +504,18 @@ mhd_gtls_send_client_certificate (mhd_gtls_session_t session, int again)
 
   if (again == 0)
     {
-      if (MHD_gnutls_protocol_get_version (session) != MHD_GNUTLS_PROTOCOL_SSL3 ||
+      if (MHD__gnutls_protocol_get_version (session) != MHD_GNUTLS_PROTOCOL_SSL3 ||
           session->internals.selected_cert_list_length > 0)
         {
           /* TLS 1.0 or SSL 3.0 with a valid certificate
            */
           data_size =
             session->internals.auth_struct->
-            mhd_gtls_gen_client_certificate (session, &data);
+            MHD_gtls_gen_client_certificate (session, &data);
 
           if (data_size < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return data_size;
             }
         }
@@ -525,11 +525,11 @@ mhd_gtls_send_client_certificate (mhd_gtls_session_t session, int again)
    * no certificate alert instead of an
    * empty certificate.
    */
-  if (MHD_gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3 &&
+  if (MHD__gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3 &&
       session->internals.selected_cert_list_length == 0)
     {
       ret =
-        MHD_gnutls_alert_send (session, GNUTLS_AL_WARNING,
+        MHD__gnutls_alert_send (session, GNUTLS_AL_WARNING,
                                GNUTLS_A_SSL3_NO_CERTIFICATE);
 
     }
@@ -537,14 +537,14 @@ mhd_gtls_send_client_certificate (mhd_gtls_session_t session, int again)
     {                           /* TLS 1.0 or SSL 3.0 with a valid certificate
                                  */
       ret =
-        mhd_gtls_send_handshake (session, data, data_size,
+        MHD_gtls_send_handshake (session, data, data_size,
                                  GNUTLS_HANDSHAKE_CERTIFICATE_PKT);
-      gnutls_free (data);
+      MHD_gnutls_free (data);
     }
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -555,14 +555,14 @@ mhd_gtls_send_client_certificate (mhd_gtls_session_t session, int again)
 /* This is called when we want send our certificate
  */
 int
-mhd_gtls_send_server_certificate (mhd_gtls_session_t session, int again)
+MHD_gtls_send_server_certificate (MHD_gtls_session_t session, int again)
 {
   uint8_t *data = NULL;
   int data_size = 0;
   int ret = 0;
 
 
-  if (session->internals.auth_struct->mhd_gtls_gen_server_certificate == NULL)
+  if (session->internals.auth_struct->MHD_gtls_gen_server_certificate == NULL)
     return 0;
 
   data = NULL;
@@ -572,22 +572,22 @@ mhd_gtls_send_server_certificate (mhd_gtls_session_t session, int again)
     {
       data_size =
         session->internals.auth_struct->
-        mhd_gtls_gen_server_certificate (session, &data);
+        MHD_gtls_gen_server_certificate (session, &data);
 
       if (data_size < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return data_size;
         }
     }
   ret =
-    mhd_gtls_send_handshake (session, data, data_size,
+    MHD_gtls_send_handshake (session, data, data_size,
                              GNUTLS_HANDSHAKE_CERTIFICATE_PKT);
-  gnutls_free (data);
+  MHD_gnutls_free (data);
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -596,14 +596,14 @@ mhd_gtls_send_server_certificate (mhd_gtls_session_t session, int again)
 
 
 int
-mhd_gtls_recv_client_certificate (mhd_gtls_session_t session)
+MHD_gtls_recv_client_certificate (MHD_gtls_session_t session)
 {
   int datasize;
   opaque *data;
   int ret = 0;
   int optional;
 
-  if (session->internals.auth_struct->mhd_gtls_process_client_certificate !=
+  if (session->internals.auth_struct->MHD_gtls_process_client_certificate !=
       NULL)
     {
 
@@ -620,7 +620,7 @@ mhd_gtls_recv_client_certificate (mhd_gtls_session_t session)
         optional = OPTIONAL_PACKET;
 
       ret =
-        mhd_gtls_recv_handshake (session, &data,
+        MHD_gtls_recv_handshake (session, &data,
                                  &datasize,
                                  GNUTLS_HANDSHAKE_CERTIFICATE_PKT, optional);
 
@@ -632,14 +632,14 @@ mhd_gtls_recv_client_certificate (mhd_gtls_session_t session)
            */
           if (optional == OPTIONAL_PACKET &&
               ret == GNUTLS_E_WARNING_ALERT_RECEIVED &&
-              MHD_gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3 &&
-              gnutls_alert_get (session) == GNUTLS_A_SSL3_NO_CERTIFICATE)
+              MHD__gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3 &&
+              MHD_gnutls_alert_get (session) == GNUTLS_A_SSL3_NO_CERTIFICATE)
             {
 
               /* SSL3 does not send an empty certificate,
                * but this alert. So we just ignore it.
                */
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return 0;
             }
 
@@ -649,7 +649,7 @@ mhd_gtls_recv_client_certificate (mhd_gtls_session_t session)
                || ret == GNUTLS_E_FATAL_ALERT_RECEIVED)
               && optional == MANDATORY_PACKET)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return GNUTLS_E_NO_CERTIFICATE_FOUND;
             }
 
@@ -662,17 +662,17 @@ mhd_gtls_recv_client_certificate (mhd_gtls_session_t session)
            * well I'm not sure we should accept this
            * behaviour.
            */
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return 0;
         }
       ret =
         session->internals.auth_struct->
-        mhd_gtls_process_client_certificate (session, data, datasize);
+        MHD_gtls_process_client_certificate (session, data, datasize);
 
-      gnutls_free (data);
+      MHD_gnutls_free (data);
       if (ret < 0 && ret != GNUTLS_E_NO_CERTIFICATE_FOUND)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
@@ -689,34 +689,34 @@ mhd_gtls_recv_client_certificate (mhd_gtls_session_t session)
 }
 
 int
-mhd_gtls_recv_server_certificate (mhd_gtls_session_t session)
+MHD_gtls_recv_server_certificate (MHD_gtls_session_t session)
 {
   int datasize;
   opaque *data;
   int ret = 0;
 
-  if (session->internals.auth_struct->mhd_gtls_process_server_certificate !=
+  if (session->internals.auth_struct->MHD_gtls_process_server_certificate !=
       NULL)
     {
 
       ret =
-        mhd_gtls_recv_handshake (session, &data,
+        MHD_gtls_recv_handshake (session, &data,
                                  &datasize,
                                  GNUTLS_HANDSHAKE_CERTIFICATE_PKT,
                                  MANDATORY_PACKET);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
       ret =
         session->internals.auth_struct->
-        mhd_gtls_process_server_certificate (session, data, datasize);
-      gnutls_free (data);
+        MHD_gtls_process_server_certificate (session, data, datasize);
+      MHD_gnutls_free (data);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
     }
@@ -729,14 +729,14 @@ mhd_gtls_recv_server_certificate (mhd_gtls_session_t session)
  * arrive if the peer did not send us a certificate.
  */
 int
-mhd_gtls_recv_client_certificate_verify_message (mhd_gtls_session_t session)
+MHD_gtls_recv_client_certificate_verify_message (MHD_gtls_session_t session)
 {
   uint8_t *data;
   int datasize;
   int ret = 0;
 
 
-  if (session->internals.auth_struct->mhd_gtls_process_client_cert_vrfy !=
+  if (session->internals.auth_struct->MHD_gtls_process_client_cert_vrfy !=
       NULL)
     {
 
@@ -747,7 +747,7 @@ mhd_gtls_recv_client_certificate_verify_message (mhd_gtls_session_t session)
         }
 
       ret =
-        mhd_gtls_recv_handshake (session, &data,
+        MHD_gtls_recv_handshake (session, &data,
                                  &datasize,
                                  GNUTLS_HANDSHAKE_CERTIFICATE_VERIFY,
                                  OPTIONAL_PACKET);
@@ -758,14 +758,14 @@ mhd_gtls_recv_client_certificate_verify_message (mhd_gtls_session_t session)
           && session->internals.send_cert_req == GNUTLS_CERT_REQUIRE)
         {
           /* certificate was required */
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_NO_CERTIFICATE_FOUND;
         }
 
       ret =
         session->internals.auth_struct->
-        mhd_gtls_process_client_cert_vrfy (session, data, datasize);
-      gnutls_free (data);
+        MHD_gtls_process_client_cert_vrfy (session, data, datasize);
+      MHD_gnutls_free (data);
       if (ret < 0)
         return ret;