89 files changed, 4435 insertions, 4428 deletions

diff --git a/src/daemon/https/tls/auth_anon.c b/src/daemon/https/tls/auth_anon.c
index d20e55cf..1d6922cc 100644
--- a/src/daemon/https/tls/auth_anon.c
+++ b/src/daemon/https/tls/auth_anon.c
@@ -40,52 +40,52 @@
 #include <gnutls_state.h>
 #include <auth_dh_common.h>
 
-static int mhd_gtls_gen_anon_server_kx (mhd_gtls_session_t, opaque **);
-static int mhd_gtls_proc_anon_client_kx (mhd_gtls_session_t, opaque *,
+static int MHD_gtls_gen_anon_server_kx (MHD_gtls_session_t, opaque **);
+static int MHD_gtls_proc_anon_client_kx (MHD_gtls_session_t, opaque *,
                                          size_t);
-static int mhd_gtls_proc_anon_server_kx (mhd_gtls_session_t, opaque *,
+static int MHD_gtls_proc_anon_server_kx (MHD_gtls_session_t, opaque *,
                                          size_t);
 
-const mhd_gtls_mod_auth_st mhd_gtls_anon_auth_struct = {
+const MHD_gtls_mod_auth_st MHD_gtls_anon_auth_struct = {
   "ANON",
   NULL,
   NULL,
-  mhd_gtls_gen_anon_server_kx,
-  mhd_gtls_gen_dh_common_client_kx,     /* this can be shared */
+  MHD_gtls_gen_anon_server_kx,
+  MHD_gtls_gen_dh_common_client_kx,     /* this can be shared */
   NULL,
   NULL,
 
   NULL,
   NULL,                         /* certificate */
-  mhd_gtls_proc_anon_server_kx,
-  mhd_gtls_proc_anon_client_kx,
+  MHD_gtls_proc_anon_server_kx,
+  MHD_gtls_proc_anon_client_kx,
   NULL,
   NULL
 };
 
 static int
-mhd_gtls_gen_anon_server_kx (mhd_gtls_session_t session, opaque ** data)
+MHD_gtls_gen_anon_server_kx (MHD_gtls_session_t session, opaque ** data)
 {
   mpi_t g, p;
   const mpi_t *mpis;
   int ret;
-  mhd_gtls_dh_params_t dh_params;
-  mhd_gtls_anon_server_credentials_t cred;
+  MHD_gtls_dh_params_t dh_params;
+  MHD_gtls_anon_server_credentials_t cred;
 
-  cred = (mhd_gtls_anon_server_credentials_t)
-    mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_ANON, NULL);
+  cred = (MHD_gtls_anon_server_credentials_t)
+    MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_ANON, NULL);
   if (cred == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
     }
 
   dh_params =
-    mhd_gtls_get_dh_params (cred->dh_params, cred->params_func, session);
-  mpis = mhd_gtls_dh_params_to_mpi (dh_params);
+    MHD_gtls_get_dh_params (cred->dh_params, cred->params_func, session);
+  mpis = MHD_gtls_dh_params_to_mpi (dh_params);
   if (mpis == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_NO_TEMPORARY_DH_PARAMS;
     }
 
@@ -93,19 +93,19 @@ mhd_gtls_gen_anon_server_kx (mhd_gtls_session_t session, opaque ** data)
   g = mpis[1];
 
   if ((ret =
-       mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_ANON,
+       MHD_gtls_auth_info_set (session, MHD_GNUTLS_CRD_ANON,
                                sizeof (anon_auth_info_st), 1)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  mhd_gtls_dh_set_group (session, g, p);
+  MHD_gtls_dh_set_group (session, g, p);
 
-  ret = mhd_gtls_dh_common_print_server_kx (session, g, p, data, 0);
+  ret = MHD_gtls_dh_common_print_server_kx (session, g, p, data, 0);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
     }
 
   return ret;
@@ -113,46 +113,46 @@ mhd_gtls_gen_anon_server_kx (mhd_gtls_session_t session, opaque ** data)
 
 
 static int
-mhd_gtls_proc_anon_client_kx (mhd_gtls_session_t session, opaque * data,
+MHD_gtls_proc_anon_client_kx (MHD_gtls_session_t session, opaque * data,
                               size_t _data_size)
 {
-  mhd_gtls_anon_server_credentials_t cred;
+  MHD_gtls_anon_server_credentials_t cred;
   int bits;
   int ret;
   mpi_t p, g;
-  mhd_gtls_dh_params_t dh_params;
+  MHD_gtls_dh_params_t dh_params;
   const mpi_t *mpis;
 
-  bits = mhd_gtls_dh_get_allowed_prime_bits (session);
+  bits = MHD_gtls_dh_get_allowed_prime_bits (session);
 
-  cred = (mhd_gtls_anon_server_credentials_t)
-    mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_ANON, NULL);
+  cred = (MHD_gtls_anon_server_credentials_t)
+    MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_ANON, NULL);
   if (cred == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
     }
 
   dh_params =
-    mhd_gtls_get_dh_params (cred->dh_params, cred->params_func, session);
-  mpis = mhd_gtls_dh_params_to_mpi (dh_params);
+    MHD_gtls_get_dh_params (cred->dh_params, cred->params_func, session);
+  mpis = MHD_gtls_dh_params_to_mpi (dh_params);
   if (mpis == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_NO_TEMPORARY_DH_PARAMS;
     }
 
   p = mpis[0];
   g = mpis[1];
 
-  ret = mhd_gtls_proc_dh_common_client_kx (session, data, _data_size, g, p);
+  ret = MHD_gtls_proc_dh_common_client_kx (session, data, _data_size, g, p);
 
   return ret;
 
 }
 
 int
-mhd_gtls_proc_anon_server_kx (mhd_gtls_session_t session, opaque * data,
+MHD_gtls_proc_anon_server_kx (MHD_gtls_session_t session, opaque * data,
                               size_t _data_size)
 {
 
@@ -160,17 +160,17 @@ mhd_gtls_proc_anon_server_kx (mhd_gtls_session_t session, opaque * data,
 
   /* set auth_info */
   if ((ret =
-       mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_ANON,
+       MHD_gtls_auth_info_set (session, MHD_GNUTLS_CRD_ANON,
                                sizeof (anon_auth_info_st), 1)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  ret = mhd_gtls_proc_dh_common_server_kx (session, data, _data_size, 0);
+  ret = MHD_gtls_proc_dh_common_server_kx (session, data, _data_size, 0);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
diff --git a/src/daemon/https/tls/auth_anon.h b/src/daemon/https/tls/auth_anon.h
index ca5f3bfb..4602ab23 100644
--- a/src/daemon/https/tls/auth_anon.h
+++ b/src/daemon/https/tls/auth_anon.h
@@ -22,27 +22,27 @@
  *
  */
 
-/* this is not to be included by gnutls_anon.c */
+/* this is not to be included by MHD_gnutls_anon.c */
 #include <gnutls_auth.h>
 #include <auth_dh_common.h>
 
-typedef struct mhd_gtls_anon_server_credentials_st
+typedef struct MHD_gtls_anon_server_credentials_st
 {
-  mhd_gtls_dh_params_t dh_params;
+  MHD_gtls_dh_params_t dh_params;
   /* this callback is used to retrieve the DH or RSA
    * parameters.
    */
-  gnutls_params_function *params_func;
+  MHD_gnutls_params_function *params_func;
 } mhd_anon_server_credentials_st;
 
-typedef struct mhd_gtls_anon_client_credentials_st
+typedef struct MHD_gtls_anon_client_credentials_st
 {
   int dummy;
 } mhd_anon_client_credentials_st;
 
-typedef struct mhd_gtls_anon_auth_info_st
+typedef struct MHD_gtls_anon_auth_info_st
 {
-  mhd_gtls_dh_info_st dh;
+  MHD_gtls_dh_info_st dh;
 } *mhd_anon_auth_info_t;
 
-typedef struct mhd_gtls_anon_auth_info_st anon_auth_info_st;
+typedef struct MHD_gtls_anon_auth_info_st anon_auth_info_st;
diff --git a/src/daemon/https/tls/auth_cert.c b/src/daemon/https/tls/auth_cert.c
index 7f0369ca..f3bbeba9 100644
--- a/src/daemon/https/tls/auth_cert.c
+++ b/src/daemon/https/tls/auth_cert.c
@@ -45,17 +45,17 @@
 #include <gnutls_x509.h>
 #include "debug.h"
 
-static gnutls_cert *alloc_and_load_x509_certs (gnutls_x509_crt_t * certs,
+static MHD_gnutls_cert *alloc_and_load_x509_certs (MHD_gnutls_x509_crt_t * certs,
                                                unsigned);
-static gnutls_privkey *alloc_and_load_x509_key (gnutls_x509_privkey_t key);
+static MHD_gnutls_privkey *alloc_and_load_x509_key (MHD_gnutls_x509_privkey_t key);
 
 
-/* Copies data from a internal certificate struct (gnutls_cert) to
+/* Copies data from a internal certificate struct (MHD_gnutls_cert) to
  * exported certificate struct (cert_auth_info_t)
  */
 static int
-_gnutls_copy_certificate_auth_info (cert_auth_info_t info,
-                                    gnutls_cert * cert, int ncerts)
+MHD__gnutls_copy_certificate_auth_info (cert_auth_info_t info,
+                                    MHD_gnutls_cert * cert, int ncerts)
 {
   /* Copy peer's information to auth_info_t
    */
@@ -69,10 +69,10 @@ _gnutls_copy_certificate_auth_info (cert_auth_info_t info,
     }
 
   info->raw_certificate_list =
-    gnutls_calloc (1, sizeof (gnutls_datum_t) * ncerts);
+    MHD_gnutls_calloc (1, sizeof (MHD_gnutls_datum_t) * ncerts);
   if (info->raw_certificate_list == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
@@ -81,11 +81,11 @@ _gnutls_copy_certificate_auth_info (cert_auth_info_t info,
       if (cert->raw.size > 0)
         {
           ret =
-            _gnutls_set_datum (&info->raw_certificate_list[i],
+            MHD__gnutls_set_datum (&info->raw_certificate_list[i],
                                cert[i].raw.data, cert[i].raw.size);
           if (ret < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               goto clear;
             }
         }
@@ -97,9 +97,9 @@ _gnutls_copy_certificate_auth_info (cert_auth_info_t info,
 clear:
 
   for (j = 0; j < i; j++)
-    _gnutls_free_datum (&info->raw_certificate_list[j]);
+    MHD__gnutls_free_datum (&info->raw_certificate_list[j]);
 
-  gnutls_free (info->raw_certificate_list);
+  MHD_gnutls_free (info->raw_certificate_list);
   info->raw_certificate_list = NULL;
 
   return ret;
@@ -112,7 +112,7 @@ clear:
  * -1 otherwise.
  */
 inline static int
-_gnutls_check_pk_algo_in_list (const enum MHD_GNUTLS_PublicKeyAlgorithm
+MHD__gnutls_check_pk_algo_in_list (const enum MHD_GNUTLS_PublicKeyAlgorithm
                                *pk_algos, int pk_algos_length,
                                enum MHD_GNUTLS_PublicKeyAlgorithm
                                algo_to_check)
@@ -133,39 +133,39 @@ _gnutls_check_pk_algo_in_list (const enum MHD_GNUTLS_PublicKeyAlgorithm
  * specified in cert.
  */
 static int
-_gnutls_cert_get_issuer_dn (gnutls_cert * cert, gnutls_datum_t * odn)
+MHD__gnutls_cert_get_issuer_dn (MHD_gnutls_cert * cert, MHD_gnutls_datum_t * odn)
 {
   ASN1_TYPE dn;
   int len, result;
   int start, end;
 
-  if ((result = asn1_create_element
-       (_gnutls_get_pkix (), "PKIX1.Certificate", &dn)) != ASN1_SUCCESS)
+  if ((result = MHD__asn1_create_element
+       (MHD__gnutls_get_pkix (), "PKIX1.Certificate", &dn)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  result = asn1_der_decoding (&dn, cert->raw.data, cert->raw.size, NULL);
+  result = MHD__asn1_der_decoding (&dn, cert->raw.data, cert->raw.size, NULL);
   if (result != ASN1_SUCCESS)
     {
       /* couldn't decode DER */
-      gnutls_assert ();
-      asn1_delete_structure (&dn);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&dn);
+      return MHD_gtls_asn2err (result);
     }
 
-  result = asn1_der_decoding_startEnd (dn, cert->raw.data, cert->raw.size,
+  result = MHD__asn1_der_decoding_startEnd (dn, cert->raw.data, cert->raw.size,
                                        "tbsCertificate.issuer", &start, &end);
 
   if (result != ASN1_SUCCESS)
     {
       /* couldn't decode DER */
-      gnutls_assert ();
-      asn1_delete_structure (&dn);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&dn);
+      return MHD_gtls_asn2err (result);
     }
-  asn1_delete_structure (&dn);
+  MHD__asn1_delete_structure (&dn);
 
   len = end - start + 1;
 
@@ -183,13 +183,13 @@ _gnutls_cert_get_issuer_dn (gnutls_cert * cert, gnutls_datum_t * odn)
  * CAs and sign algorithms supported by the peer server.
  */
 static int
-_find_x509_cert (const mhd_gtls_cert_credentials_t cred,
+_find_x509_cert (const MHD_gtls_cert_credentials_t cred,
                  opaque * _data, size_t _data_size,
                  const enum MHD_GNUTLS_PublicKeyAlgorithm *pk_algos,
                  int pk_algos_length, int *indx)
 {
   unsigned size;
-  gnutls_datum_t odn;
+  MHD_gnutls_datum_t odn;
   opaque *data = _data;
   ssize_t data_size = _data_size;
   unsigned i, j;
@@ -201,7 +201,7 @@ _find_x509_cert (const mhd_gtls_cert_credentials_t cred,
     {
 
       DECR_LENGTH_RET (data_size, 2, 0);
-      size = mhd_gtls_read_uint16 (data);
+      size = MHD_gtls_read_uint16 (data);
       DECR_LENGTH_RET (data_size, size, 0);
       data += 2;
 
@@ -210,10 +210,10 @@ _find_x509_cert (const mhd_gtls_cert_credentials_t cred,
           for (j = 0; j < cred->cert_list_length[i]; j++)
             {
               if ((result =
-                   _gnutls_cert_get_issuer_dn (&cred->cert_list[i][j],
+                   MHD__gnutls_cert_get_issuer_dn (&cred->cert_list[i][j],
                                                &odn)) < 0)
                 {
-                  gnutls_assert ();
+                  MHD_gnutls_assert ();
                   return result;
                 }
 
@@ -227,7 +227,7 @@ _find_x509_cert (const mhd_gtls_cert_credentials_t cred,
               cert_pk = cred->cert_list[i][0].subject_pk_algorithm;
 
               if ((memcmp (odn.data, data, size) == 0) &&
-                  (_gnutls_check_pk_algo_in_list
+                  (MHD__gnutls_check_pk_algo_in_list
                    (pk_algos, pk_algos_length, cert_pk) == 0))
                 {
                   *indx = i;
@@ -255,7 +255,7 @@ _find_x509_cert (const mhd_gtls_cert_credentials_t cred,
  * certificate request packet.
  */
 static int
-get_issuers_num (mhd_gtls_session_t session, opaque * data, ssize_t data_size)
+get_issuers_num (MHD_gtls_session_t session, opaque * data, ssize_t data_size)
 {
   int issuers_dn_len = 0, result;
   unsigned size;
@@ -275,7 +275,7 @@ get_issuers_num (mhd_gtls_session_t session, opaque * data, ssize_t data_size)
          */
         result = GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
         DECR_LENGTH_COM (data_size, 2, goto error);
-        size = mhd_gtls_read_uint16 (data);
+        size = MHD_gtls_read_uint16 (data);
 
         result = GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
         DECR_LENGTH_COM (data_size, size, goto error);
@@ -304,14 +304,14 @@ error:
  * packet.
  */
 static int
-get_issuers (mhd_gtls_session_t session,
-             gnutls_datum_t * issuers_dn, int issuers_len,
+get_issuers (MHD_gtls_session_t session,
+             MHD_gnutls_datum_t * issuers_dn, int issuers_len,
              opaque * data, size_t data_size)
 {
   int i;
   unsigned size;
 
-  if (gnutls_certificate_type_get (session) != MHD_GNUTLS_CRT_X509)
+  if (MHD_gnutls_certificate_type_get (session) != MHD_GNUTLS_CRT_X509)
     return 0;
 
   /* put the requested DNs to req_dn, only in case
@@ -328,7 +328,7 @@ get_issuers (mhd_gtls_session_t session,
            */
           data_size -= 2;
 
-          size = mhd_gtls_read_uint16 (data);
+          size = MHD_gtls_read_uint16 (data);
 
           data += 2;
 
@@ -345,26 +345,26 @@ get_issuers (mhd_gtls_session_t session,
 /* Calls the client get callback.
  */
 static int
-call_get_cert_callback (mhd_gtls_session_t session,
-                        gnutls_datum_t * issuers_dn,
+call_get_cert_callback (MHD_gtls_session_t session,
+                        MHD_gnutls_datum_t * issuers_dn,
                         int issuers_dn_length,
                         enum MHD_GNUTLS_PublicKeyAlgorithm *pk_algos,
                         int pk_algos_length)
 {
   unsigned i;
-  gnutls_cert *local_certs = NULL;
-  gnutls_privkey *local_key = NULL;
-  gnutls_retr_st st;
+  MHD_gnutls_cert *local_certs = NULL;
+  MHD_gnutls_privkey *local_key = NULL;
+  MHD_gnutls_retr_st st;
   int ret;
   enum MHD_GNUTLS_CertificateType type =
-    gnutls_certificate_type_get (session);
-  mhd_gtls_cert_credentials_t cred;
+    MHD_gnutls_certificate_type_get (session);
+  MHD_gtls_cert_credentials_t cred;
 
-  cred = (mhd_gtls_cert_credentials_t)
-    mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
+  cred = (MHD_gtls_cert_credentials_t)
+    MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
   if (cred == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
     }
 
@@ -384,7 +384,7 @@ call_get_cert_callback (mhd_gtls_session_t session,
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
@@ -393,7 +393,7 @@ call_get_cert_callback (mhd_gtls_session_t session,
 
   if (type != st.type)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       ret = GNUTLS_E_INVALID_REQUEST;
       goto cleanup;
     }
@@ -407,12 +407,12 @@ call_get_cert_callback (mhd_gtls_session_t session,
     }
   else
     {                           /* PGP */
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       ret = GNUTLS_E_INVALID_REQUEST;
       goto cleanup;
     }
 
-  mhd_gtls_selected_certs_set (session, local_certs,
+  MHD_gtls_selected_certs_set (session, local_certs,
                                (local_certs != NULL) ? st.ncerts : 0,
                                local_key, 1);
 
@@ -426,10 +426,10 @@ cleanup:
         {
           for (i = 0; i < st.ncerts; i++)
             {
-              gnutls_x509_crt_deinit (st.cert.x509[i]);
+              MHD_gnutls_x509_crt_deinit (st.cert.x509[i]);
             }
-          gnutls_free (st.cert.x509);
-          gnutls_x509_privkey_deinit (st.key.x509);
+          MHD_gnutls_free (st.cert.x509);
+          MHD_gnutls_x509_privkey_deinit (st.key.x509);
         }
     }
   return ret;
@@ -443,24 +443,24 @@ cleanup:
  * algorithm (only in automatic mode).
  */
 static int
-_select_client_cert (mhd_gtls_session_t session,
+_select_client_cert (MHD_gtls_session_t session,
                      opaque * _data, size_t _data_size,
                      enum MHD_GNUTLS_PublicKeyAlgorithm *pk_algos,
                      int pk_algos_length)
 {
   int result;
   int indx = -1;
-  mhd_gtls_cert_credentials_t cred;
+  MHD_gtls_cert_credentials_t cred;
   opaque *data = _data;
   ssize_t data_size = _data_size;
   int issuers_dn_length;
-  gnutls_datum_t *issuers_dn = NULL;
+  MHD_gnutls_datum_t *issuers_dn = NULL;
 
-  cred = (mhd_gtls_cert_credentials_t)
-    mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
+  cred = (MHD_gtls_cert_credentials_t)
+    MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
   if (cred == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
     }
 
@@ -476,17 +476,17 @@ _select_client_cert (mhd_gtls_session_t session,
           issuers_dn_length = get_issuers_num (session, data, data_size);
           if (issuers_dn_length < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return issuers_dn_length;
             }
 
           if (issuers_dn_length > 0)
             {
               issuers_dn =
-                gnutls_malloc (sizeof (gnutls_datum_t) * issuers_dn_length);
+                MHD_gnutls_malloc (sizeof (MHD_gnutls_datum_t) * issuers_dn_length);
               if (issuers_dn == NULL)
                 {
-                  gnutls_assert ();
+                  MHD_gnutls_assert ();
                   return GNUTLS_E_MEMORY_ERROR;
                 }
 
@@ -495,7 +495,7 @@ _select_client_cert (mhd_gtls_session_t session,
                              data, data_size);
               if (result < 0)
                 {
-                  gnutls_assert ();
+                  MHD_gnutls_assert ();
                   goto cleanup;
                 }
             }
@@ -519,27 +519,27 @@ _select_client_cert (mhd_gtls_session_t session,
                            pk_algos, pk_algos_length, &indx);
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return result;
         }
 
       if (indx >= 0)
         {
-          mhd_gtls_selected_certs_set (session,
+          MHD_gtls_selected_certs_set (session,
                                        &cred->cert_list[indx][0],
                                        cred->cert_list_length[indx],
                                        &cred->pkey[indx], 0);
         }
       else
         {
-          mhd_gtls_selected_certs_set (session, NULL, 0, NULL, 0);
+          MHD_gtls_selected_certs_set (session, NULL, 0, NULL, 0);
         }
 
       result = 0;
     }
 
 cleanup:
-  gnutls_free (issuers_dn);
+  MHD_gnutls_free (issuers_dn);
   return result;
 
 }
@@ -548,21 +548,21 @@ cleanup:
  */
 
 int
-mhd_gtls_gen_x509_crt (mhd_gtls_session_t session, opaque ** data)
+MHD_gtls_gen_x509_crt (MHD_gtls_session_t session, opaque ** data)
 {
   int ret, i;
   opaque *pdata;
-  gnutls_cert *apr_cert_list;
-  gnutls_privkey *apr_pkey;
+  MHD_gnutls_cert *apr_cert_list;
+  MHD_gnutls_privkey *apr_pkey;
   int apr_cert_list_length;
 
   /* find the appropriate certificate
    */
   if ((ret =
-       mhd_gtls_get_selected_cert (session, &apr_cert_list,
+       MHD_gtls_get_selected_cert (session, &apr_cert_list,
                                    &apr_cert_list_length, &apr_pkey)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -583,19 +583,19 @@ mhd_gtls_gen_x509_crt (mhd_gtls_session_t session, opaque ** data)
    * the one produced here )
    */
 
-  (*data) = gnutls_malloc (ret);
+  (*data) = MHD_gnutls_malloc (ret);
   pdata = (*data);
 
   if (pdata == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
-  mhd_gtls_write_uint24 (ret - 3, pdata);
+  MHD_gtls_write_uint24 (ret - 3, pdata);
   pdata += 3;
   for (i = 0; i < apr_cert_list_length; i++)
     {
-      mhd_gtls_write_datum24 (pdata, apr_cert_list[i].raw);
+      MHD_gtls_write_datum24 (pdata, apr_cert_list[i].raw);
       pdata += (3 + apr_cert_list[i].raw.size);
     }
 
@@ -603,30 +603,30 @@ mhd_gtls_gen_x509_crt (mhd_gtls_session_t session, opaque ** data)
 }
 
 int
-mhd_gtls_gen_cert_client_certificate (mhd_gtls_session_t session,
+MHD_gtls_gen_cert_client_certificate (MHD_gtls_session_t session,
                                       opaque ** data)
 {
   switch (session->security_parameters.cert_type)
     {
     case MHD_GNUTLS_CRT_X509:
-      return mhd_gtls_gen_x509_crt (session, data);
+      return MHD_gtls_gen_x509_crt (session, data);
 
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 }
 
 int
-mhd_gtls_gen_cert_server_certificate (mhd_gtls_session_t session,
+MHD_gtls_gen_cert_server_certificate (MHD_gtls_session_t session,
                                       opaque ** data)
 {
   switch (session->security_parameters.cert_type)
     {
     case MHD_GNUTLS_CRT_X509:
-      return mhd_gtls_gen_x509_crt (session, data);
+      return MHD_gtls_gen_x509_crt (session, data);
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 }
@@ -634,49 +634,49 @@ mhd_gtls_gen_cert_server_certificate (mhd_gtls_session_t session,
 /* Process server certificate
  */
 
-#define CLEAR_CERTS for(x=0;x<peer_certificate_list_size;x++) mhd_gtls_gcert_deinit(&peer_certificate_list[x])
+#define CLEAR_CERTS for(x=0;x<peer_certificate_list_size;x++) MHD_gtls_gcert_deinit(&peer_certificate_list[x])
 int
-mhd_gtls_proc_x509_server_certificate (mhd_gtls_session_t session,
+MHD_gtls_proc_x509_server_certificate (MHD_gtls_session_t session,
                                        opaque * data, size_t data_size)
 {
   int size, len, ret;
   opaque *p = data;
   cert_auth_info_t info;
-  mhd_gtls_cert_credentials_t cred;
+  MHD_gtls_cert_credentials_t cred;
   ssize_t dsize = data_size;
   int i, j, x;
-  gnutls_cert *peer_certificate_list;
+  MHD_gnutls_cert *peer_certificate_list;
   int peer_certificate_list_size = 0;
-  gnutls_datum_t tmp;
+  MHD_gnutls_datum_t tmp;
 
-  cred = (mhd_gtls_cert_credentials_t)
-    mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
+  cred = (MHD_gtls_cert_credentials_t)
+    MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
   if (cred == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
     }
 
 
   if ((ret =
-       mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
+       MHD_gtls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
                                sizeof (cert_auth_info_st), 1)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  info = mhd_gtls_get_auth_info (session);
+  info = MHD_gtls_get_auth_info (session);
 
   if (data == NULL || data_size == 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       /* no certificate was sent */
       return GNUTLS_E_NO_CERTIFICATE_FOUND;
     }
 
   DECR_LEN (dsize, 3);
-  size = mhd_gtls_read_uint24 (p);
+  size = MHD_gtls_read_uint24 (p);
   p += 3;
 
   /* some implementations send 0B 00 00 06 00 00 03 00 00 00
@@ -684,7 +684,7 @@ mhd_gtls_proc_x509_server_certificate (mhd_gtls_session_t session,
    */
   if (size == 0 || size == 3)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       /* no certificate was sent */
       return GNUTLS_E_NO_CERTIFICATE_FOUND;
     }
@@ -693,7 +693,7 @@ mhd_gtls_proc_x509_server_certificate (mhd_gtls_session_t session,
   while (i > 0)
     {
       DECR_LEN (dsize, 3);
-      len = mhd_gtls_read_uint24 (p);
+      len = MHD_gtls_read_uint24 (p);
       p += 3;
       DECR_LEN (dsize, len);
       peer_certificate_list_size++;
@@ -703,7 +703,7 @@ mhd_gtls_proc_x509_server_certificate (mhd_gtls_session_t session,
 
   if (peer_certificate_list_size == 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_NO_CERTIFICATE_FOUND;
     }
 
@@ -712,14 +712,14 @@ mhd_gtls_proc_x509_server_certificate (mhd_gtls_session_t session,
    */
 
   peer_certificate_list =
-    gnutls_malloc (sizeof (gnutls_cert) * (peer_certificate_list_size));
+    MHD_gnutls_malloc (sizeof (MHD_gnutls_cert) * (peer_certificate_list_size));
 
   if (peer_certificate_list == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
-  memset (peer_certificate_list, 0, sizeof (gnutls_cert) *
+  memset (peer_certificate_list, 0, sizeof (MHD_gnutls_cert) *
           peer_certificate_list_size);
 
   p = data + 3;
@@ -731,18 +731,18 @@ mhd_gtls_proc_x509_server_certificate (mhd_gtls_session_t session,
 
   for (j = 0; j < peer_certificate_list_size; j++)
     {
-      len = mhd_gtls_read_uint24 (p);
+      len = MHD_gtls_read_uint24 (p);
       p += 3;
 
       tmp.size = len;
       tmp.data = p;
 
       if ((ret =
-           mhd_gtls_x509_raw_cert_to_gcert (&peer_certificate_list
+           MHD_gtls_x509_raw_cert_to_gcert (&peer_certificate_list
                                             [j], &tmp,
                                             CERT_ONLY_EXTENSIONS)) < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           goto cleanup;
         }
 
@@ -751,19 +751,19 @@ mhd_gtls_proc_x509_server_certificate (mhd_gtls_session_t session,
 
 
   if ((ret =
-       _gnutls_copy_certificate_auth_info (info,
+       MHD__gnutls_copy_certificate_auth_info (info,
                                            peer_certificate_list,
                                            peer_certificate_list_size)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
   if ((ret =
-       _gnutls_check_key_usage (&peer_certificate_list[0],
-                                gnutls_kx_get (session))) < 0)
+       MHD__gnutls_check_key_usage (&peer_certificate_list[0],
+                                MHD_gnutls_kx_get (session))) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
@@ -771,23 +771,23 @@ mhd_gtls_proc_x509_server_certificate (mhd_gtls_session_t session,
 
 cleanup:
   CLEAR_CERTS;
-  gnutls_free (peer_certificate_list);
+  MHD_gnutls_free (peer_certificate_list);
   return ret;
 
 }
 
-#define CLEAR_CERTS for(x=0;x<peer_certificate_list_size;x++) mhd_gtls_gcert_deinit(&peer_certificate_list[x])
+#define CLEAR_CERTS for(x=0;x<peer_certificate_list_size;x++) MHD_gtls_gcert_deinit(&peer_certificate_list[x])
 
 int
-mhd_gtls_proc_cert_server_certificate (mhd_gtls_session_t session,
+MHD_gtls_proc_cert_server_certificate (MHD_gtls_session_t session,
                                        opaque * data, size_t data_size)
 {
   switch (session->security_parameters.cert_type)
     {
     case MHD_GNUTLS_CRT_X509:
-      return mhd_gtls_proc_x509_server_certificate (session, data, data_size);
+      return MHD_gtls_proc_x509_server_certificate (session, data, data_size);
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 }
@@ -802,7 +802,7 @@ typedef enum CertificateSigType
  * if true;
  */
 inline static int
-_gnutls_check_supported_sign_algo (CertificateSigType algo)
+MHD__gnutls_check_supported_sign_algo (CertificateSigType algo)
 {
   switch (algo)
     {
@@ -814,31 +814,31 @@ _gnutls_check_supported_sign_algo (CertificateSigType algo)
 }
 
 int
-mhd_gtls_proc_cert_cert_req (mhd_gtls_session_t session, opaque * data,
+MHD_gtls_proc_cert_cert_req (MHD_gtls_session_t session, opaque * data,
                              size_t data_size)
 {
   int size, ret;
   opaque *p;
-  mhd_gtls_cert_credentials_t cred;
+  MHD_gtls_cert_credentials_t cred;
   ssize_t dsize;
   int i, j;
   enum MHD_GNUTLS_PublicKeyAlgorithm pk_algos[MAX_SIGN_ALGOS];
   int pk_algos_length;
-  enum MHD_GNUTLS_Protocol ver = MHD_gnutls_protocol_get_version (session);
+  enum MHD_GNUTLS_Protocol ver = MHD__gnutls_protocol_get_version (session);
 
-  cred = (mhd_gtls_cert_credentials_t)
-    mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
+  cred = (MHD_gtls_cert_credentials_t)
+    MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
   if (cred == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
     }
 
   if ((ret =
-       mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
+       MHD_gtls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
                                sizeof (cert_auth_info_st), 0)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -854,7 +854,7 @@ mhd_gtls_proc_cert_cert_req (mhd_gtls_session_t session, opaque * data,
   for (i = 0; i < size; i++, p++)
     {
       DECR_LEN (dsize, 1);
-      if ((ret = _gnutls_check_supported_sign_algo (*p)) > 0)
+      if ((ret = MHD__gnutls_check_supported_sign_algo (*p)) > 0)
         {
           if (j < MAX_SIGN_ALGOS)
             {
@@ -866,7 +866,7 @@ mhd_gtls_proc_cert_cert_req (mhd_gtls_session_t session, opaque * data,
 
   if (pk_algos_length == 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
     }
 
@@ -885,7 +885,7 @@ mhd_gtls_proc_cert_cert_req (mhd_gtls_session_t session, opaque * data,
 
   /* read the certificate authorities */
   DECR_LEN (dsize, 2);
-  size = mhd_gtls_read_uint16 (p);
+  size = MHD_gtls_read_uint16 (p);
   p += 2;
 
   DECR_LEN (dsize, size);
@@ -896,7 +896,7 @@ mhd_gtls_proc_cert_cert_req (mhd_gtls_session_t session, opaque * data,
   if ((ret =
        _select_client_cert (session, p, size, pk_algos, pk_algos_length)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -909,34 +909,34 @@ mhd_gtls_proc_cert_cert_req (mhd_gtls_session_t session, opaque * data,
 }
 
 int
-mhd_gtls_gen_cert_client_cert_vrfy (mhd_gtls_session_t session,
+MHD_gtls_gen_cert_client_cert_vrfy (MHD_gtls_session_t session,
                                     opaque ** data)
 {
   int ret;
-  gnutls_cert *apr_cert_list;
-  gnutls_privkey *apr_pkey;
+  MHD_gnutls_cert *apr_cert_list;
+  MHD_gnutls_privkey *apr_pkey;
   int apr_cert_list_length, size;
-  gnutls_datum_t signature;
+  MHD_gnutls_datum_t signature;
 
   *data = NULL;
 
   /* find the appropriate certificate */
   if ((ret =
-       mhd_gtls_get_selected_cert (session, &apr_cert_list,
+       MHD_gtls_get_selected_cert (session, &apr_cert_list,
                                    &apr_cert_list_length, &apr_pkey)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
   if (apr_cert_list_length > 0)
     {
       if ((ret =
-           mhd_gtls_tls_sign_hdata (session,
+           MHD_gtls_tls_sign_hdata (session,
                                     &apr_cert_list[0],
                                     apr_pkey, &signature)) < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
     }
@@ -945,42 +945,42 @@ mhd_gtls_gen_cert_client_cert_vrfy (mhd_gtls_session_t session,
       return 0;
     }
 
-  *data = gnutls_malloc (signature.size + 2);
+  *data = MHD_gnutls_malloc (signature.size + 2);
   if (*data == NULL)
     {
-      _gnutls_free_datum (&signature);
+      MHD__gnutls_free_datum (&signature);
       return GNUTLS_E_MEMORY_ERROR;
     }
   size = signature.size;
-  mhd_gtls_write_uint16 (size, *data);
+  MHD_gtls_write_uint16 (size, *data);
 
   memcpy (&(*data)[2], signature.data, size);
 
-  _gnutls_free_datum (&signature);
+  MHD__gnutls_free_datum (&signature);
 
   return size + 2;
 }
 
 int
-mhd_gtls_proc_cert_client_cert_vrfy (mhd_gtls_session_t session,
+MHD_gtls_proc_cert_client_cert_vrfy (MHD_gtls_session_t session,
                                      opaque * data, size_t data_size)
 {
   int size, ret;
   ssize_t dsize = data_size;
   opaque *pdata = data;
-  gnutls_datum_t sig;
-  cert_auth_info_t info = mhd_gtls_get_auth_info (session);
-  gnutls_cert peer_cert;
+  MHD_gnutls_datum_t sig;
+  cert_auth_info_t info = MHD_gtls_get_auth_info (session);
+  MHD_gnutls_cert peer_cert;
 
   if (info == NULL || info->ncerts == 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       /* we need this in order to get peer's certificate */
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
   DECR_LEN (dsize, 2);
-  size = mhd_gtls_read_uint16 (pdata);
+  size = MHD_gtls_read_uint16 (pdata);
   pdata += 2;
 
   DECR_LEN (dsize, size);
@@ -988,47 +988,47 @@ mhd_gtls_proc_cert_client_cert_vrfy (mhd_gtls_session_t session,
   sig.data = pdata;
   sig.size = size;
 
-  ret = mhd_gtls_raw_cert_to_gcert (&peer_cert,
+  ret = MHD_gtls_raw_cert_to_gcert (&peer_cert,
                                     session->security_parameters.cert_type,
                                     &info->raw_certificate_list[0],
                                     CERT_NO_COPY);
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  if ((ret = mhd_gtls_verify_sig_hdata (session, &peer_cert, &sig)) < 0)
+  if ((ret = MHD_gtls_verify_sig_hdata (session, &peer_cert, &sig)) < 0)
     {
-      gnutls_assert ();
-      mhd_gtls_gcert_deinit (&peer_cert);
+      MHD_gnutls_assert ();
+      MHD_gtls_gcert_deinit (&peer_cert);
       return ret;
     }
-  mhd_gtls_gcert_deinit (&peer_cert);
+  MHD_gtls_gcert_deinit (&peer_cert);
 
   return 0;
 }
 
 #define CERTTYPE_SIZE 3
 int
-mhd_gtls_gen_cert_server_cert_req (mhd_gtls_session_t session, opaque ** data)
+MHD_gtls_gen_cert_server_cert_req (MHD_gtls_session_t session, opaque ** data)
 {
-  mhd_gtls_cert_credentials_t cred;
+  MHD_gtls_cert_credentials_t cred;
   int size;
   opaque *pdata;
-  enum MHD_GNUTLS_Protocol ver = MHD_gnutls_protocol_get_version (session);
+  enum MHD_GNUTLS_Protocol ver = MHD__gnutls_protocol_get_version (session);
 
   /* Now we need to generate the RDN sequence. This is
    * already in the CERTIFICATE_CRED structure, to improve
    * performance.
    */
 
-  cred = (mhd_gtls_cert_credentials_t)
-    mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
+  cred = (MHD_gtls_cert_credentials_t)
+    MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
   if (cred == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
     }
 
@@ -1044,12 +1044,12 @@ mhd_gtls_gen_cert_server_cert_req (mhd_gtls_session_t session, opaque ** data)
        functions (see below).  */
     size += 1;
 
-  (*data) = gnutls_malloc (size);
+  (*data) = MHD_gnutls_malloc (size);
   pdata = (*data);
 
   if (pdata == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
@@ -1069,12 +1069,12 @@ mhd_gtls_gen_cert_server_cert_req (mhd_gtls_session_t session, opaque ** data)
   if (session->security_parameters.cert_type == MHD_GNUTLS_CRT_X509 &&
       session->internals.ignore_rdn_sequence == 0)
     {
-      mhd_gtls_write_datum16 (pdata, cred->x509_rdn_sequence);
+      MHD_gtls_write_datum16 (pdata, cred->x509_rdn_sequence);
       /* pdata += cred->x509_rdn_sequence.size + 2; */
     }
   else
     {
-      mhd_gtls_write_uint16 (0, pdata);
+      MHD_gtls_write_uint16 (0, pdata);
       /* pdata+=2; */
     }
 
@@ -1090,10 +1090,10 @@ mhd_gtls_gen_cert_server_cert_req (mhd_gtls_session_t session, opaque ** data)
  *
  */
 int
-mhd_gtls_get_selected_cert (mhd_gtls_session_t session,
-                            gnutls_cert ** apr_cert_list,
+MHD_gtls_get_selected_cert (MHD_gtls_session_t session,
+                            MHD_gnutls_cert ** apr_cert_list,
                             int *apr_cert_list_length,
-                            gnutls_privkey ** apr_pkey)
+                            MHD_gnutls_privkey ** apr_pkey)
 {
   if (session->security_parameters.entity == GNUTLS_SERVER)
     {
@@ -1107,7 +1107,7 @@ mhd_gtls_get_selected_cert (mhd_gtls_session_t session,
 
       if (*apr_cert_list_length == 0 || *apr_cert_list == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
         }
 
@@ -1128,70 +1128,70 @@ mhd_gtls_get_selected_cert (mhd_gtls_session_t session,
   return 0;
 }
 
-/* converts the given x509 certificate to gnutls_cert* and allocates
+/* converts the given x509 certificate to MHD_gnutls_cert* and allocates
  * space for them.
  */
-static gnutls_cert *
-alloc_and_load_x509_certs (gnutls_x509_crt_t * certs, unsigned ncerts)
+static MHD_gnutls_cert *
+alloc_and_load_x509_certs (MHD_gnutls_x509_crt_t * certs, unsigned ncerts)
 {
-  gnutls_cert *local_certs;
+  MHD_gnutls_cert *local_certs;
   int ret = 0;
   unsigned i, j;
 
   if (certs == NULL)
     return NULL;
 
-  local_certs = gnutls_malloc (sizeof (gnutls_cert) * ncerts);
+  local_certs = MHD_gnutls_malloc (sizeof (MHD_gnutls_cert) * ncerts);
   if (local_certs == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return NULL;
     }
 
   for (i = 0; i < ncerts; i++)
     {
-      ret = mhd_gtls_x509_crt_to_gcert (&local_certs[i], certs[i], 0);
+      ret = MHD_gtls_x509_crt_to_gcert (&local_certs[i], certs[i], 0);
       if (ret < 0)
         break;
     }
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       for (j = 0; j < i; j++)
         {
-          mhd_gtls_gcert_deinit (&local_certs[j]);
+          MHD_gtls_gcert_deinit (&local_certs[j]);
         }
-      gnutls_free (local_certs);
+      MHD_gnutls_free (local_certs);
       return NULL;
     }
 
   return local_certs;
 }
 
-/* converts the given x509 key to gnutls_privkey* and allocates
+/* converts the given x509 key to MHD_gnutls_privkey* and allocates
  * space for it.
  */
-static gnutls_privkey *
-alloc_and_load_x509_key (gnutls_x509_privkey_t key)
+static MHD_gnutls_privkey *
+alloc_and_load_x509_key (MHD_gnutls_x509_privkey_t key)
 {
-  gnutls_privkey *local_key;
+  MHD_gnutls_privkey *local_key;
   int ret = 0;
 
   if (key == NULL)
     return NULL;
 
-  local_key = gnutls_malloc (sizeof (gnutls_privkey));
+  local_key = MHD_gnutls_malloc (sizeof (MHD_gnutls_privkey));
   if (local_key == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return NULL;
     }
 
-  ret = _gnutls_x509_privkey_to_gkey (local_key, key);
+  ret = MHD__gnutls_x509_privkey_to_gkey (local_key, key);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return NULL;
     }
 
@@ -1199,7 +1199,7 @@ alloc_and_load_x509_key (gnutls_x509_privkey_t key)
 }
 
 void
-mhd_gtls_selected_certs_deinit (mhd_gtls_session_t session)
+MHD_gtls_selected_certs_deinit (MHD_gtls_session_t session)
 {
   if (session->internals.selected_need_free != 0)
     {
@@ -1207,16 +1207,16 @@ mhd_gtls_selected_certs_deinit (mhd_gtls_session_t session)
 
       for (i = 0; i < session->internals.selected_cert_list_length; i++)
         {
-          mhd_gtls_gcert_deinit (&session->internals.selected_cert_list[i]);
+          MHD_gtls_gcert_deinit (&session->internals.selected_cert_list[i]);
         }
-      gnutls_free (session->internals.selected_cert_list);
+      MHD_gnutls_free (session->internals.selected_cert_list);
       session->internals.selected_cert_list = NULL;
       session->internals.selected_cert_list_length = 0;
 
-      mhd_gtls_gkey_deinit (session->internals.selected_key);
+      MHD_gtls_gkey_deinit (session->internals.selected_key);
       if (session->internals.selected_key)
         {
-          gnutls_free (session->internals.selected_key);
+          MHD_gnutls_free (session->internals.selected_key);
           session->internals.selected_key = NULL;
         }
     }
@@ -1225,11 +1225,11 @@ mhd_gtls_selected_certs_deinit (mhd_gtls_session_t session)
 }
 
 void
-mhd_gtls_selected_certs_set (mhd_gtls_session_t session,
-                             gnutls_cert * certs, int ncerts,
-                             gnutls_privkey * key, int need_free)
+MHD_gtls_selected_certs_set (MHD_gtls_session_t session,
+                             MHD_gnutls_cert * certs, int ncerts,
+                             MHD_gnutls_privkey * key, int need_free)
 {
-  mhd_gtls_selected_certs_deinit (session);
+  MHD_gtls_selected_certs_deinit (session);
 
   session->internals.selected_cert_list = certs;
   session->internals.selected_cert_list_length = ncerts;
@@ -1250,19 +1250,19 @@ mhd_gtls_selected_certs_set (mhd_gtls_session_t session,
  *
  */
 int
-mhd_gtls_server_select_cert (mhd_gtls_session_t session,
+MHD_gtls_server_select_cert (MHD_gtls_session_t session,
                              enum MHD_GNUTLS_PublicKeyAlgorithm
                              requested_algo)
 {
   unsigned i;
   int idx, ret;
-  mhd_gtls_cert_credentials_t cred;
+  MHD_gtls_cert_credentials_t cred;
 
-  cred = (mhd_gtls_cert_credentials_t)
-    mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
+  cred = (MHD_gtls_cert_credentials_t)
+    MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
   if (cred == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
     }
 
@@ -1301,7 +1301,7 @@ mhd_gtls_server_select_cert (mhd_gtls_session_t session,
    */
   if (idx >= 0 && ret == 0)
     {
-      mhd_gtls_selected_certs_set (session,
+      MHD_gtls_selected_certs_set (session,
                                    &cred->cert_list[idx][0],
                                    cred->cert_list_length[idx],
                                    &cred->pkey[idx], 0);
@@ -1313,11 +1313,11 @@ mhd_gtls_server_select_cert (mhd_gtls_session_t session,
   return ret;
 }
 
-/* Frees the mhd_gtls_rsa_info_st structure.
+/* Frees the MHD_gtls_rsa_info_st structure.
  */
 void
-mhd_gtls_free_rsa_info (rsa_info_st * rsa)
+MHD_gtls_free_rsa_info (rsa_info_st * rsa)
 {
-  _gnutls_free_datum (&rsa->modulus);
-  _gnutls_free_datum (&rsa->exponent);
+  MHD__gnutls_free_datum (&rsa->modulus);
+  MHD__gnutls_free_datum (&rsa->exponent);
 }
diff --git a/src/daemon/https/tls/auth_cert.h b/src/daemon/https/tls/auth_cert.h
index 9df2bd0d..aabfac76 100644
--- a/src/daemon/https/tls/auth_cert.h
+++ b/src/daemon/https/tls/auth_cert.h
@@ -34,16 +34,16 @@
  * support a server that has multiple certificates
  */
 
-typedef struct mhd_gtls_certificate_credentials_st
+typedef struct MHD_gtls_certificate_credentials_st
 {
-  mhd_gtls_dh_params_t dh_params;
-  mhd_gtls_rsa_params_t rsa_params;
+  MHD_gtls_dh_params_t dh_params;
+  MHD_gtls_rsa_params_t rsa_params;
   /* this callback is used to retrieve the DH or RSA
    * parameters.
    */
-  gnutls_params_function *params_func;
+  MHD_gnutls_params_function *params_func;
 
-  gnutls_cert **cert_list;
+  MHD_gnutls_cert **cert_list;
   /* contains a list of a list of certificates.
    * eg (X509): [0] certificate1, certificate11, certificate111
    * (if more than one, one certificate certifies the one before)
@@ -57,7 +57,7 @@ typedef struct mhd_gtls_certificate_credentials_st
                                  * This is the same with the number of pkeys.
                                  */
 
-  gnutls_privkey *pkey;
+  MHD_gnutls_privkey *pkey;
   /* private keys. It contains ncerts private
    * keys. pkey[i] corresponds to certificate in
    * cert_list[i][0].
@@ -66,19 +66,19 @@ typedef struct mhd_gtls_certificate_credentials_st
   /* OpenPGP specific stuff */
 
 #ifndef KEYRING_HACK
-  gnutls_openpgp_keyring_t keyring;
+  MHD_gnutls_openpgp_keyring_t keyring;
 #else
-  gnutls_datum_t keyring;
+  MHD_gnutls_datum_t keyring;
   int keyring_format;
 #endif
 
   /* X509 specific stuff */
 
-  gnutls_x509_crt_t *x509_ca_list;
+  MHD_gnutls_x509_crt_t *x509_ca_list;
   unsigned x509_ncas;           /* number of CAs in the ca_list
                                  */
 
-  gnutls_x509_crl_t *x509_crl_list;
+  MHD_gnutls_x509_crl_t *x509_crl_list;
   unsigned x509_ncrls;          /* number of CRLs in the crl_list
                                  */
 
@@ -93,19 +93,19 @@ typedef struct mhd_gtls_certificate_credentials_st
    * This is better than
    * generating on every handshake.
    */
-  gnutls_datum_t x509_rdn_sequence;
+  MHD_gnutls_datum_t x509_rdn_sequence;
 
-  gnutls_certificate_client_retrieve_function *client_get_cert_callback;
-  gnutls_certificate_server_retrieve_function *server_get_cert_callback;
-} mhd_gtls_cert_credentials_st;
+  MHD_gnutls_certificate_client_retrieve_function *client_get_cert_callback;
+  MHD_gnutls_certificate_server_retrieve_function *server_get_cert_callback;
+} MHD_gtls_cert_credentials_st;
 
-typedef struct mhd_gtls_rsa_info_st
+typedef struct MHD_gtls_rsa_info_st
 {
-  gnutls_datum_t modulus;
-  gnutls_datum_t exponent;
+  MHD_gnutls_datum_t modulus;
+  MHD_gnutls_datum_t exponent;
 } rsa_info_st;
 
-typedef struct mhd_gtls_cert_auth_info_st
+typedef struct MHD_gtls_cert_auth_info_st
 {
   int certificate_requested;    /* if the peer requested certificate
                                  * this is non zero;
@@ -114,46 +114,46 @@ typedef struct mhd_gtls_cert_auth_info_st
   /* These (dh/rsa) are just copies from the credentials_t structure.
    * They must be freed.
    */
-  mhd_gtls_dh_info_st dh;
+  MHD_gtls_dh_info_st dh;
   rsa_info_st rsa_export;
 
-  gnutls_datum_t *raw_certificate_list; /* holds the raw certificate of the
+  MHD_gnutls_datum_t *raw_certificate_list; /* holds the raw certificate of the
                                          * peer.
                                          */
   unsigned int ncerts;          /* holds the size of the list above */
 } *cert_auth_info_t;
 
-typedef struct mhd_gtls_cert_auth_info_st cert_auth_info_st;
+typedef struct MHD_gtls_cert_auth_info_st cert_auth_info_st;
 
-void mhd_gtls_free_rsa_info (rsa_info_st * rsa);
+void MHD_gtls_free_rsa_info (rsa_info_st * rsa);
 
 /* AUTH X509 functions */
-int mhd_gtls_gen_cert_server_certificate (mhd_gtls_session_t, opaque **);
-int mhd_gtls_gen_cert_client_certificate (mhd_gtls_session_t, opaque **);
-int mhd_gtls_gen_cert_client_cert_vrfy (mhd_gtls_session_t, opaque **);
-int mhd_gtls_gen_cert_server_cert_req (mhd_gtls_session_t, opaque **);
-int mhd_gtls_proc_cert_cert_req (mhd_gtls_session_t, opaque *, size_t);
-int mhd_gtls_proc_cert_client_cert_vrfy (mhd_gtls_session_t, opaque *,
+int MHD_gtls_gen_cert_server_certificate (MHD_gtls_session_t, opaque **);
+int MHD_gtls_gen_cert_client_certificate (MHD_gtls_session_t, opaque **);
+int MHD_gtls_gen_cert_client_cert_vrfy (MHD_gtls_session_t, opaque **);
+int MHD_gtls_gen_cert_server_cert_req (MHD_gtls_session_t, opaque **);
+int MHD_gtls_proc_cert_cert_req (MHD_gtls_session_t, opaque *, size_t);
+int MHD_gtls_proc_cert_client_cert_vrfy (MHD_gtls_session_t, opaque *,
                                          size_t);
-int mhd_gtls_proc_cert_server_certificate (mhd_gtls_session_t, opaque *,
+int MHD_gtls_proc_cert_server_certificate (MHD_gtls_session_t, opaque *,
                                            size_t);
-int mhd_gtls_get_selected_cert (mhd_gtls_session_t session,
-                                gnutls_cert ** apr_cert_list,
+int MHD_gtls_get_selected_cert (MHD_gtls_session_t session,
+                                MHD_gnutls_cert ** apr_cert_list,
                                 int *apr_cert_list_length,
-                                gnutls_privkey ** apr_pkey);
+                                MHD_gnutls_privkey ** apr_pkey);
 
-int mhd_gtls_server_select_cert (struct MHD_gtls_session_int *,
+int MHD_gtls_server_select_cert (struct MHD_gtls_session_int *,
                                  enum MHD_GNUTLS_PublicKeyAlgorithm);
-void mhd_gtls_selected_certs_deinit (mhd_gtls_session_t session);
-void mhd_gtls_selected_certs_set (mhd_gtls_session_t session,
-                                  gnutls_cert * certs, int ncerts,
-                                  gnutls_privkey * key, int need_free);
+void MHD_gtls_selected_certs_deinit (MHD_gtls_session_t session);
+void MHD_gtls_selected_certs_set (MHD_gtls_session_t session,
+                                  MHD_gnutls_cert * certs, int ncerts,
+                                  MHD_gnutls_privkey * key, int need_free);
 
-#define _gnutls_proc_cert_client_certificate mhd_gtls_proc_cert_server_certificate
+#define MHD__gnutls_proc_cert_client_certificate MHD_gtls_proc_cert_server_certificate
 
-mhd_gtls_rsa_params_t
-mhd_gtls_certificate_get_rsa_params (mhd_gtls_rsa_params_t rsa_params,
-                                     gnutls_params_function * func,
-                                     mhd_gtls_session_t);
+MHD_gtls_rsa_params_t
+MHD_gtls_certificate_get_rsa_params (MHD_gtls_rsa_params_t rsa_params,
+                                     MHD_gnutls_params_function * func,
+                                     MHD_gtls_session_t);
 
 #endif
diff --git a/src/daemon/https/tls/auth_dh_common.c b/src/daemon/https/tls/auth_dh_common.c
index 4d471045..8fc6e391 100644
--- a/src/daemon/https/tls/auth_dh_common.c
+++ b/src/daemon/https/tls/auth_dh_common.c
@@ -39,19 +39,19 @@
 #include <auth_dh_common.h>
 #include <gnutls_algorithms.h>
 
-/* Frees the mhd_gtls_dh_info_st structure.
+/* Frees the MHD_gtls_dh_info_st structure.
  */
 void
-mhd_gtls_free_dh_info (mhd_gtls_dh_info_st * dh)
+MHD_gtls_free_dh_info (MHD_gtls_dh_info_st * dh)
 {
   dh->secret_bits = 0;
-  _gnutls_free_datum (&dh->prime);
-  _gnutls_free_datum (&dh->generator);
-  _gnutls_free_datum (&dh->public_key);
+  MHD__gnutls_free_datum (&dh->prime);
+  MHD__gnutls_free_datum (&dh->generator);
+  MHD__gnutls_free_datum (&dh->public_key);
 }
 
 int
-mhd_gtls_proc_dh_common_client_kx (mhd_gtls_session_t session,
+MHD_gtls_proc_dh_common_client_kx (MHD_gtls_session_t session,
                                    opaque * data, size_t _data_size,
                                    mpi_t g, mpi_t p)
 {
@@ -62,33 +62,33 @@ mhd_gtls_proc_dh_common_client_kx (mhd_gtls_session_t session,
 
 
   DECR_LEN (data_size, 2);
-  n_Y = mhd_gtls_read_uint16 (&data[0]);
+  n_Y = MHD_gtls_read_uint16 (&data[0]);
   _n_Y = n_Y;
 
   DECR_LEN (data_size, n_Y);
-  if (mhd_gtls_mpi_scan_nz (&session->key->client_Y, &data[2], &_n_Y))
+  if (MHD_gtls_mpi_scan_nz (&session->key->client_Y, &data[2], &_n_Y))
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MPI_SCAN_FAILED;
     }
 
-  mhd_gtls_dh_set_peer_public (session, session->key->client_Y);
+  MHD_gtls_dh_set_peer_public (session, session->key->client_Y);
 
   session->key->KEY =
-    mhd_gtls_calc_dh_key (session->key->client_Y, session->key->dh_secret, p);
+    MHD_gtls_calc_dh_key (session->key->client_Y, session->key->dh_secret, p);
 
   if (session->key->KEY == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
-  mhd_gtls_mpi_release (&session->key->client_Y);
-  mhd_gtls_mpi_release (&session->key->dh_secret);
+  MHD_gtls_mpi_release (&session->key->client_Y);
+  MHD_gtls_mpi_release (&session->key->dh_secret);
 
-  ret = mhd_gtls_mpi_dprint (&session->key->key, session->key->KEY);
+  ret = MHD_gtls_mpi_dprint (&session->key->key, session->key->KEY);
 
-  mhd_gtls_mpi_release (&session->key->KEY);
+  MHD_gtls_mpi_release (&session->key->KEY);
 
   if (ret < 0)
     {
@@ -99,7 +99,7 @@ mhd_gtls_proc_dh_common_client_kx (mhd_gtls_session_t session,
 }
 
 int
-mhd_gtls_gen_dh_common_client_kx (mhd_gtls_session_t session, opaque ** data)
+MHD_gtls_gen_dh_common_client_kx (MHD_gtls_session_t session, opaque ** data)
 {
   mpi_t x = NULL, X = NULL;
   size_t n_X;
@@ -107,69 +107,69 @@ mhd_gtls_gen_dh_common_client_kx (mhd_gtls_session_t session, opaque ** data)
 
   *data = NULL;
 
-  X = mhd_gtls_calc_dh_secret (&x, session->key->client_g,
+  X = MHD_gtls_calc_dh_secret (&x, session->key->client_g,
                                session->key->client_p);
   if (X == NULL || x == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       ret = GNUTLS_E_MEMORY_ERROR;
       goto error;
     }
 
-  mhd_gtls_dh_set_secret_bits (session, _gnutls_mpi_get_nbits (x));
+  MHD_gtls_dh_set_secret_bits (session, MHD__gnutls_mpi_get_nbits (x));
 
-  mhd_gtls_mpi_print (NULL, &n_X, X);
-  (*data) = gnutls_malloc (n_X + 2);
+  MHD_gtls_mpi_print (NULL, &n_X, X);
+  (*data) = MHD_gnutls_malloc (n_X + 2);
   if (*data == NULL)
     {
       ret = GNUTLS_E_MEMORY_ERROR;
       goto error;
     }
 
-  mhd_gtls_mpi_print (&(*data)[2], &n_X, X);
-  mhd_gtls_mpi_release (&X);
+  MHD_gtls_mpi_print (&(*data)[2], &n_X, X);
+  MHD_gtls_mpi_release (&X);
 
-  mhd_gtls_write_uint16 (n_X, &(*data)[0]);
+  MHD_gtls_write_uint16 (n_X, &(*data)[0]);
 
   /* calculate the key after calculating the message */
   session->key->KEY =
-    mhd_gtls_calc_dh_key (session->key->client_Y, x, session->key->client_p);
+    MHD_gtls_calc_dh_key (session->key->client_Y, x, session->key->client_p);
 
-  mhd_gtls_mpi_release (&x);
+  MHD_gtls_mpi_release (&x);
   if (session->key->KEY == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       ret = GNUTLS_E_MEMORY_ERROR;
       goto error;
     }
 
   /* THESE SHOULD BE DISCARDED */
-  mhd_gtls_mpi_release (&session->key->client_Y);
-  mhd_gtls_mpi_release (&session->key->client_p);
-  mhd_gtls_mpi_release (&session->key->client_g);
+  MHD_gtls_mpi_release (&session->key->client_Y);
+  MHD_gtls_mpi_release (&session->key->client_p);
+  MHD_gtls_mpi_release (&session->key->client_g);
 
-  ret = mhd_gtls_mpi_dprint (&session->key->key, session->key->KEY);
+  ret = MHD_gtls_mpi_dprint (&session->key->key, session->key->KEY);
 
-  mhd_gtls_mpi_release (&session->key->KEY);
+  MHD_gtls_mpi_release (&session->key->KEY);
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
 
   return n_X + 2;
 
 error:
-  mhd_gtls_mpi_release (&x);
-  mhd_gtls_mpi_release (&X);
-  gnutls_free (*data);
+  MHD_gtls_mpi_release (&x);
+  MHD_gtls_mpi_release (&X);
+  MHD_gnutls_free (*data);
   *data = NULL;
   return ret;
 }
 
 int
-mhd_gtls_proc_dh_common_server_kx (mhd_gtls_session_t session,
+MHD_gtls_proc_dh_common_server_kx (MHD_gtls_session_t session,
                                    opaque * data, size_t _data_size, int psk)
 {
   uint16_t n_Y, n_g, n_p;
@@ -185,13 +185,13 @@ mhd_gtls_proc_dh_common_server_kx (mhd_gtls_session_t session,
   if (psk != 0)
     {
       DECR_LEN (data_size, 2);
-      psk_size = mhd_gtls_read_uint16 (&data[i]);
+      psk_size = MHD_gtls_read_uint16 (&data[i]);
       DECR_LEN (data_size, psk_size);
       i += 2 + psk_size;
     }
 
   DECR_LEN (data_size, 2);
-  n_p = mhd_gtls_read_uint16 (&data[i]);
+  n_p = MHD_gtls_read_uint16 (&data[i]);
   i += 2;
 
   DECR_LEN (data_size, n_p);
@@ -199,7 +199,7 @@ mhd_gtls_proc_dh_common_server_kx (mhd_gtls_session_t session,
   i += n_p;
 
   DECR_LEN (data_size, 2);
-  n_g = mhd_gtls_read_uint16 (&data[i]);
+  n_g = MHD_gtls_read_uint16 (&data[i]);
   i += 2;
 
   DECR_LEN (data_size, n_g);
@@ -207,7 +207,7 @@ mhd_gtls_proc_dh_common_server_kx (mhd_gtls_session_t session,
   i += n_g;
 
   DECR_LEN (data_size, 2);
-  n_Y = mhd_gtls_read_uint16 (&data[i]);
+  n_Y = MHD_gtls_read_uint16 (&data[i]);
   i += 2;
 
   DECR_LEN (data_size, n_Y);
@@ -218,41 +218,41 @@ mhd_gtls_proc_dh_common_server_kx (mhd_gtls_session_t session,
   _n_g = n_g;
   _n_p = n_p;
 
-  if (mhd_gtls_mpi_scan_nz (&session->key->client_Y, data_Y, &_n_Y) != 0)
+  if (MHD_gtls_mpi_scan_nz (&session->key->client_Y, data_Y, &_n_Y) != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MPI_SCAN_FAILED;
     }
 
-  if (mhd_gtls_mpi_scan_nz (&session->key->client_g, data_g, &_n_g) != 0)
+  if (MHD_gtls_mpi_scan_nz (&session->key->client_g, data_g, &_n_g) != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MPI_SCAN_FAILED;
     }
-  if (mhd_gtls_mpi_scan_nz (&session->key->client_p, data_p, &_n_p) != 0)
+  if (MHD_gtls_mpi_scan_nz (&session->key->client_p, data_p, &_n_p) != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MPI_SCAN_FAILED;
     }
 
-  bits = mhd_gtls_dh_get_allowed_prime_bits (session);
+  bits = MHD_gtls_dh_get_allowed_prime_bits (session);
   if (bits < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return bits;
     }
 
-  if (_gnutls_mpi_get_nbits (session->key->client_p) < (size_t) bits)
+  if (MHD__gnutls_mpi_get_nbits (session->key->client_p) < (size_t) bits)
     {
       /* the prime used by the peer is not acceptable
        */
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_DH_PRIME_UNACCEPTABLE;
     }
 
-  mhd_gtls_dh_set_group (session, session->key->client_g,
+  MHD_gtls_dh_set_group (session, session->key->client_g,
                          session->key->client_p);
-  mhd_gtls_dh_set_peer_public (session, session->key->client_Y);
+  MHD_gtls_dh_set_peer_public (session, session->key->client_Y);
 
   ret = n_Y + n_p + n_g + 6;
   if (psk != 0)
@@ -264,7 +264,7 @@ mhd_gtls_proc_dh_common_server_kx (mhd_gtls_session_t session,
 /* If the psk flag is set, then an empty psk_identity_hint will
  * be inserted */
 int
-mhd_gtls_dh_common_print_server_kx (mhd_gtls_session_t session,
+MHD_gtls_dh_common_print_server_kx (MHD_gtls_session_t session,
                                     mpi_t g, mpi_t p, opaque ** data, int psk)
 {
   mpi_t x, X;
@@ -272,28 +272,28 @@ mhd_gtls_dh_common_print_server_kx (mhd_gtls_session_t session,
   int ret, data_size, pos;
   uint8_t *pdata;
 
-  X = mhd_gtls_calc_dh_secret (&x, g, p);
+  X = MHD_gtls_calc_dh_secret (&x, g, p);
   if (X == NULL || x == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
   session->key->dh_secret = x;
-  mhd_gtls_dh_set_secret_bits (session, _gnutls_mpi_get_nbits (x));
+  MHD_gtls_dh_set_secret_bits (session, MHD__gnutls_mpi_get_nbits (x));
 
-  mhd_gtls_mpi_print (NULL, &n_g, g);
-  mhd_gtls_mpi_print (NULL, &n_p, p);
-  mhd_gtls_mpi_print (NULL, &n_X, X);
+  MHD_gtls_mpi_print (NULL, &n_g, g);
+  MHD_gtls_mpi_print (NULL, &n_p, p);
+  MHD_gtls_mpi_print (NULL, &n_X, X);
 
   data_size = n_g + n_p + n_X + 6;
   if (psk != 0)
     data_size += 2;
 
-  (*data) = gnutls_malloc (data_size);
+  (*data) = MHD_gnutls_malloc (data_size);
   if (*data == NULL)
     {
-      mhd_gtls_mpi_release (&X);
+      MHD_gtls_mpi_release (&X);
       return GNUTLS_E_MEMORY_ERROR;
     }
 
@@ -302,24 +302,24 @@ mhd_gtls_dh_common_print_server_kx (mhd_gtls_session_t session,
 
   if (psk != 0)
     {
-      mhd_gtls_write_uint16 (0, &pdata[pos]);
+      MHD_gtls_write_uint16 (0, &pdata[pos]);
       pos += 2;
     }
 
-  mhd_gtls_mpi_print (&pdata[pos + 2], &n_p, p);
-  mhd_gtls_write_uint16 (n_p, &pdata[pos]);
+  MHD_gtls_mpi_print (&pdata[pos + 2], &n_p, p);
+  MHD_gtls_write_uint16 (n_p, &pdata[pos]);
 
   pos += n_p + 2;
 
-  mhd_gtls_mpi_print (&pdata[pos + 2], &n_g, g);
-  mhd_gtls_write_uint16 (n_g, &pdata[pos]);
+  MHD_gtls_mpi_print (&pdata[pos + 2], &n_g, g);
+  MHD_gtls_write_uint16 (n_g, &pdata[pos]);
 
   pos += n_g + 2;
 
-  mhd_gtls_mpi_print (&pdata[pos + 2], &n_X, X);
-  mhd_gtls_mpi_release (&X);
+  MHD_gtls_mpi_print (&pdata[pos + 2], &n_X, X);
+  MHD_gtls_mpi_release (&X);
 
-  mhd_gtls_write_uint16 (n_X, &pdata[pos]);
+  MHD_gtls_write_uint16 (n_X, &pdata[pos]);
 
   ret = data_size;
 
diff --git a/src/daemon/https/tls/auth_dh_common.h b/src/daemon/https/tls/auth_dh_common.h
index c6129958..f09ce6dc 100644
--- a/src/daemon/https/tls/auth_dh_common.h
+++ b/src/daemon/https/tls/auth_dh_common.h
@@ -29,19 +29,19 @@ typedef struct
 {
   int secret_bits;
 
-  gnutls_datum_t prime;
-  gnutls_datum_t generator;
-  gnutls_datum_t public_key;
-} mhd_gtls_dh_info_st;
+  MHD_gnutls_datum_t prime;
+  MHD_gnutls_datum_t generator;
+  MHD_gnutls_datum_t public_key;
+} MHD_gtls_dh_info_st;
 
-void mhd_gtls_free_dh_info (mhd_gtls_dh_info_st * dh);
-int mhd_gtls_gen_dh_common_client_kx (mhd_gtls_session_t, opaque **);
-int mhd_gtls_proc_dh_common_client_kx (mhd_gtls_session_t session,
+void MHD_gtls_free_dh_info (MHD_gtls_dh_info_st * dh);
+int MHD_gtls_gen_dh_common_client_kx (MHD_gtls_session_t, opaque **);
+int MHD_gtls_proc_dh_common_client_kx (MHD_gtls_session_t session,
                                        opaque * data, size_t _data_size,
                                        mpi_t p, mpi_t g);
-int mhd_gtls_dh_common_print_server_kx (mhd_gtls_session_t, mpi_t g, mpi_t p,
+int MHD_gtls_dh_common_print_server_kx (MHD_gtls_session_t, mpi_t g, mpi_t p,
                                         opaque ** data, int psk);
-int mhd_gtls_proc_dh_common_server_kx (mhd_gtls_session_t session,
+int MHD_gtls_proc_dh_common_server_kx (MHD_gtls_session_t session,
                                        opaque * data, size_t _data_size,
                                        int psk);
 
diff --git a/src/daemon/https/tls/auth_dhe.c b/src/daemon/https/tls/auth_dhe.c
index 43aedf0b..fa535e55 100644
--- a/src/daemon/https/tls/auth_dhe.c
+++ b/src/daemon/https/tls/auth_dhe.c
@@ -39,103 +39,103 @@
 #include <gnutls_state.h>
 #include <auth_dh_common.h>
 
-static int gen_dhe_server_kx (mhd_gtls_session_t, opaque **);
-static int proc_dhe_server_kx (mhd_gtls_session_t, opaque *, size_t);
-static int proc_dhe_client_kx (mhd_gtls_session_t, opaque *, size_t);
+static int gen_dhe_server_kx (MHD_gtls_session_t, opaque **);
+static int proc_dhe_server_kx (MHD_gtls_session_t, opaque *, size_t);
+static int proc_dhe_client_kx (MHD_gtls_session_t, opaque *, size_t);
 
-const mhd_gtls_mod_auth_st mhd_gtls_dhe_rsa_auth_struct = {
+const MHD_gtls_mod_auth_st MHD_gtls_dhe_rsa_auth_struct = {
   "DHE_RSA",
-  mhd_gtls_gen_cert_server_certificate,
-  mhd_gtls_gen_cert_client_certificate,
+  MHD_gtls_gen_cert_server_certificate,
+  MHD_gtls_gen_cert_client_certificate,
   gen_dhe_server_kx,
-  mhd_gtls_gen_dh_common_client_kx,
-  mhd_gtls_gen_cert_client_cert_vrfy,   /* gen client cert vrfy */
-  mhd_gtls_gen_cert_server_cert_req,    /* server cert request */
+  MHD_gtls_gen_dh_common_client_kx,
+  MHD_gtls_gen_cert_client_cert_vrfy,   /* gen client cert vrfy */
+  MHD_gtls_gen_cert_server_cert_req,    /* server cert request */
 
-  mhd_gtls_proc_cert_server_certificate,
-  _gnutls_proc_cert_client_certificate,
+  MHD_gtls_proc_cert_server_certificate,
+  MHD__gnutls_proc_cert_client_certificate,
   proc_dhe_server_kx,
   proc_dhe_client_kx,
-  mhd_gtls_proc_cert_client_cert_vrfy,  /* proc client cert vrfy */
-  mhd_gtls_proc_cert_cert_req   /* proc server cert request */
+  MHD_gtls_proc_cert_client_cert_vrfy,  /* proc client cert vrfy */
+  MHD_gtls_proc_cert_cert_req   /* proc server cert request */
 };
 
-const mhd_gtls_mod_auth_st mhd_gtls_dhe_dss_auth_struct = {
+const MHD_gtls_mod_auth_st MHD_gtls_dhe_dss_auth_struct = {
   "DHE_DSS",
-  mhd_gtls_gen_cert_server_certificate,
-  mhd_gtls_gen_cert_client_certificate,
+  MHD_gtls_gen_cert_server_certificate,
+  MHD_gtls_gen_cert_client_certificate,
   gen_dhe_server_kx,
-  mhd_gtls_gen_dh_common_client_kx,
-  mhd_gtls_gen_cert_client_cert_vrfy,   /* gen client cert vrfy */
-  mhd_gtls_gen_cert_server_cert_req,    /* server cert request */
+  MHD_gtls_gen_dh_common_client_kx,
+  MHD_gtls_gen_cert_client_cert_vrfy,   /* gen client cert vrfy */
+  MHD_gtls_gen_cert_server_cert_req,    /* server cert request */
 
-  mhd_gtls_proc_cert_server_certificate,
-  _gnutls_proc_cert_client_certificate,
+  MHD_gtls_proc_cert_server_certificate,
+  MHD__gnutls_proc_cert_client_certificate,
   proc_dhe_server_kx,
   proc_dhe_client_kx,
-  mhd_gtls_proc_cert_client_cert_vrfy,  /* proc client cert vrfy */
-  mhd_gtls_proc_cert_cert_req   /* proc server cert request */
+  MHD_gtls_proc_cert_client_cert_vrfy,  /* proc client cert vrfy */
+  MHD_gtls_proc_cert_cert_req   /* proc server cert request */
 };
 
 
 static int
-gen_dhe_server_kx (mhd_gtls_session_t session, opaque ** data)
+gen_dhe_server_kx (MHD_gtls_session_t session, opaque ** data)
 {
   mpi_t g, p;
   const mpi_t *mpis;
   int ret = 0, data_size;
   int bits;
-  gnutls_cert *apr_cert_list;
-  gnutls_privkey *apr_pkey;
+  MHD_gnutls_cert *apr_cert_list;
+  MHD_gnutls_privkey *apr_pkey;
   int apr_cert_list_length;
-  gnutls_datum_t signature, ddata;
-  mhd_gtls_cert_credentials_t cred;
-  mhd_gtls_dh_params_t dh_params;
+  MHD_gnutls_datum_t signature, ddata;
+  MHD_gtls_cert_credentials_t cred;
+  MHD_gtls_dh_params_t dh_params;
 
-  cred = (mhd_gtls_cert_credentials_t)
-    mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
+  cred = (MHD_gtls_cert_credentials_t)
+    MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
   if (cred == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
     }
 
-  bits = mhd_gtls_dh_get_allowed_prime_bits (session);
+  bits = MHD_gtls_dh_get_allowed_prime_bits (session);
 
   /* find the appropriate certificate */
   if ((ret =
-       mhd_gtls_get_selected_cert (session, &apr_cert_list,
+       MHD_gtls_get_selected_cert (session, &apr_cert_list,
                                    &apr_cert_list_length, &apr_pkey)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
   dh_params =
-    mhd_gtls_get_dh_params (cred->dh_params, cred->params_func, session);
-  mpis = mhd_gtls_dh_params_to_mpi (dh_params);
+    MHD_gtls_get_dh_params (cred->dh_params, cred->params_func, session);
+  mpis = MHD_gtls_dh_params_to_mpi (dh_params);
   if (mpis == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_NO_TEMPORARY_DH_PARAMS;
     }
 
   p = mpis[0];
   g = mpis[1];
 
-  if ((ret = mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
+  if ((ret = MHD_gtls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
                                      sizeof (cert_auth_info_st), 0)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  mhd_gtls_dh_set_group (session, g, p);
+  MHD_gtls_dh_set_group (session, g, p);
 
-  ret = mhd_gtls_dh_common_print_server_kx (session, g, p, data, 0);
+  ret = MHD_gtls_dh_common_print_server_kx (session, g, p, data, 0);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
   data_size = ret;
@@ -148,58 +148,58 @@ gen_dhe_server_kx (mhd_gtls_session_t session, opaque ** data)
   if (apr_cert_list_length > 0)
     {
       if ((ret =
-           mhd_gtls_tls_sign_params (session, &apr_cert_list[0],
+           MHD_gtls_tls_sign_params (session, &apr_cert_list[0],
                                      apr_pkey, &ddata, &signature)) < 0)
         {
-          gnutls_assert ();
-          gnutls_free (*data);
+          MHD_gnutls_assert ();
+          MHD_gnutls_free (*data);
           return ret;
         }
     }
   else
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return data_size;         /* do not put a signature - ILLEGAL! */
     }
 
-  *data = mhd_gtls_realloc_fast (*data, data_size + signature.size + 2);
+  *data = MHD_gtls_realloc_fast (*data, data_size + signature.size + 2);
   if (*data == NULL)
     {
-      _gnutls_free_datum (&signature);
-      gnutls_assert ();
+      MHD__gnutls_free_datum (&signature);
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
-  mhd_gtls_write_datum16 (&(*data)[data_size], signature);
+  MHD_gtls_write_datum16 (&(*data)[data_size], signature);
   data_size += signature.size + 2;
 
-  _gnutls_free_datum (&signature);
+  MHD__gnutls_free_datum (&signature);
 
   return data_size;
 }
 
 static int
-proc_dhe_server_kx (mhd_gtls_session_t session, opaque * data,
+proc_dhe_server_kx (MHD_gtls_session_t session, opaque * data,
                     size_t _data_size)
 {
   int sigsize;
-  gnutls_datum_t vparams, signature;
+  MHD_gnutls_datum_t vparams, signature;
   int ret;
-  cert_auth_info_t info = mhd_gtls_get_auth_info (session);
+  cert_auth_info_t info = MHD_gtls_get_auth_info (session);
   ssize_t data_size = _data_size;
-  gnutls_cert peer_cert;
+  MHD_gnutls_cert peer_cert;
 
   if (info == NULL || info->ncerts == 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       /* we need this in order to get peer's certificate */
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
-  ret = mhd_gtls_proc_dh_common_server_kx (session, data, _data_size, 0);
+  ret = MHD_gtls_proc_dh_common_server_kx (session, data, _data_size, 0);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -209,29 +209,29 @@ proc_dhe_server_kx (mhd_gtls_session_t session, opaque * data,
   vparams.data = data;
 
   DECR_LEN (data_size, 2);
-  sigsize = mhd_gtls_read_uint16 (&data[vparams.size]);
+  sigsize = MHD_gtls_read_uint16 (&data[vparams.size]);
 
   DECR_LEN (data_size, sigsize);
   signature.data = &data[vparams.size + 2];
   signature.size = sigsize;
 
   if ((ret =
-       mhd_gtls_raw_cert_to_gcert (&peer_cert,
+       MHD_gtls_raw_cert_to_gcert (&peer_cert,
                                    session->security_parameters.cert_type,
                                    &info->raw_certificate_list[0],
                                    CERT_NO_COPY)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
   ret =
-    mhd_gtls_verify_sig_params (session, &peer_cert, &vparams, &signature);
+    MHD_gtls_verify_sig_params (session, &peer_cert, &vparams, &signature);
 
-  mhd_gtls_gcert_deinit (&peer_cert);
+  MHD_gtls_gcert_deinit (&peer_cert);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -241,36 +241,36 @@ proc_dhe_server_kx (mhd_gtls_session_t session, opaque * data,
 
 
 static int
-proc_dhe_client_kx (mhd_gtls_session_t session, opaque * data,
+proc_dhe_client_kx (MHD_gtls_session_t session, opaque * data,
                     size_t _data_size)
 {
-  mhd_gtls_cert_credentials_t cred;
+  MHD_gtls_cert_credentials_t cred;
   int ret;
   mpi_t p, g;
   const mpi_t *mpis;
-  mhd_gtls_dh_params_t dh_params;
+  MHD_gtls_dh_params_t dh_params;
 
-  cred = (mhd_gtls_cert_credentials_t)
-    mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
+  cred = (MHD_gtls_cert_credentials_t)
+    MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
   if (cred == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
     }
 
   dh_params =
-    mhd_gtls_get_dh_params (cred->dh_params, cred->params_func, session);
-  mpis = mhd_gtls_dh_params_to_mpi (dh_params);
+    MHD_gtls_get_dh_params (cred->dh_params, cred->params_func, session);
+  mpis = MHD_gtls_dh_params_to_mpi (dh_params);
   if (mpis == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_NO_TEMPORARY_DH_PARAMS;
     }
 
   p = mpis[0];
   g = mpis[1];
 
-  ret = mhd_gtls_proc_dh_common_client_kx (session, data, _data_size, g, p);
+  ret = MHD_gtls_proc_dh_common_client_kx (session, data, _data_size, g, p);
 
   return ret;
 
diff --git a/src/daemon/https/tls/auth_rsa.c b/src/daemon/https/tls/auth_rsa.c
index b3833814..7a66eae6 100644
--- a/src/daemon/https/tls/auth_rsa.c
+++ b/src/daemon/https/tls/auth_rsa.c
@@ -42,85 +42,85 @@
 #include <gnutls_x509.h>
 #include <gc.h>
 
-int _gnutls_gen_rsa_client_kx (mhd_gtls_session_t, opaque **);
-int _gnutls_proc_rsa_client_kx (mhd_gtls_session_t, opaque *, size_t);
+int MHD__gnutls_gen_rsa_client_kx (MHD_gtls_session_t, opaque **);
+int MHD__gnutls_proc_rsa_client_kx (MHD_gtls_session_t, opaque *, size_t);
 
-const mhd_gtls_mod_auth_st mhd_gtls_rsa_auth_struct = {
+const MHD_gtls_mod_auth_st MHD_gtls_rsa_auth_struct = {
   "RSA",
-  mhd_gtls_gen_cert_server_certificate,
-  mhd_gtls_gen_cert_client_certificate,
+  MHD_gtls_gen_cert_server_certificate,
+  MHD_gtls_gen_cert_client_certificate,
   NULL,                         /* gen server kx */
-  _gnutls_gen_rsa_client_kx,
-  mhd_gtls_gen_cert_client_cert_vrfy,   /* gen client cert vrfy */
-  mhd_gtls_gen_cert_server_cert_req,    /* server cert request */
+  MHD__gnutls_gen_rsa_client_kx,
+  MHD_gtls_gen_cert_client_cert_vrfy,   /* gen client cert vrfy */
+  MHD_gtls_gen_cert_server_cert_req,    /* server cert request */
 
-  mhd_gtls_proc_cert_server_certificate,
-  _gnutls_proc_cert_client_certificate,
+  MHD_gtls_proc_cert_server_certificate,
+  MHD__gnutls_proc_cert_client_certificate,
   NULL,                         /* proc server kx */
-  _gnutls_proc_rsa_client_kx,   /* proc client kx */
-  mhd_gtls_proc_cert_client_cert_vrfy,  /* proc client cert vrfy */
-  mhd_gtls_proc_cert_cert_req   /* proc server cert request */
+  MHD__gnutls_proc_rsa_client_kx,   /* proc client kx */
+  MHD_gtls_proc_cert_client_cert_vrfy,  /* proc client cert vrfy */
+  MHD_gtls_proc_cert_cert_req   /* proc server cert request */
 };
 
 /* This function reads the RSA parameters from peer's certificate;
  */
 int
-_gnutls_get_public_rsa_params (mhd_gtls_session_t session,
+MHD__gnutls_get_public_rsa_params (MHD_gtls_session_t session,
                                mpi_t params[MAX_PUBLIC_PARAMS_SIZE],
                                int *params_len)
 {
   int ret;
   cert_auth_info_t info;
-  gnutls_cert peer_cert;
+  MHD_gnutls_cert peer_cert;
   int i;
 
   /* normal non export case */
 
-  info = mhd_gtls_get_auth_info (session);
+  info = MHD_gtls_get_auth_info (session);
 
   if (info == NULL || info->ncerts == 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
   ret =
-    mhd_gtls_raw_cert_to_gcert (&peer_cert,
+    MHD_gtls_raw_cert_to_gcert (&peer_cert,
                                 session->security_parameters.cert_type,
                                 &info->raw_certificate_list[0],
                                 CERT_ONLY_PUBKEY | CERT_NO_COPY);
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
 
   /* EXPORT case: */
-  if (mhd_gtls_cipher_suite_get_kx_algo
+  if (MHD_gtls_cipher_suite_get_kx_algo
       (&session->security_parameters.current_cipher_suite)
       == MHD_GNUTLS_KX_RSA_EXPORT
-      && _gnutls_mpi_get_nbits (peer_cert.params[0]) > 512)
+      && MHD__gnutls_mpi_get_nbits (peer_cert.params[0]) > 512)
     {
 
-      mhd_gtls_gcert_deinit (&peer_cert);
+      MHD_gtls_gcert_deinit (&peer_cert);
 
       if (session->key->rsa[0] == NULL || session->key->rsa[1] == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_INTERNAL_ERROR;
         }
 
       if (*params_len < 2)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_INTERNAL_ERROR;
         }
       *params_len = 2;
       for (i = 0; i < *params_len; i++)
         {
-          params[i] = _gnutls_mpi_copy (session->key->rsa[i]);
+          params[i] = MHD__gnutls_mpi_copy (session->key->rsa[i]);
         }
 
       return 0;
@@ -130,16 +130,16 @@ _gnutls_get_public_rsa_params (mhd_gtls_session_t session,
 
   if (*params_len < peer_cert.params_size)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
   *params_len = peer_cert.params_size;
 
   for (i = 0; i < *params_len; i++)
     {
-      params[i] = _gnutls_mpi_copy (peer_cert.params[i]);
+      params[i] = MHD__gnutls_mpi_copy (peer_cert.params[i]);
     }
-  mhd_gtls_gcert_deinit (&peer_cert);
+  MHD_gtls_gcert_deinit (&peer_cert);
 
   return 0;
 }
@@ -147,43 +147,43 @@ _gnutls_get_public_rsa_params (mhd_gtls_session_t session,
 /* This function reads the RSA parameters from the private key
  */
 int
-_gnutls_get_private_rsa_params (mhd_gtls_session_t session,
+MHD__gnutls_get_private_rsa_params (MHD_gtls_session_t session,
                                 mpi_t ** params, int *params_size)
 {
   int bits;
-  mhd_gtls_cert_credentials_t cred;
-  mhd_gtls_rsa_params_t rsa_params;
+  MHD_gtls_cert_credentials_t cred;
+  MHD_gtls_rsa_params_t rsa_params;
 
-  cred = (mhd_gtls_cert_credentials_t)
-    mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
+  cred = (MHD_gtls_cert_credentials_t)
+    MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
   if (cred == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
     }
 
   if (session->internals.selected_cert_list == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
     }
 
   bits =
-    _gnutls_mpi_get_nbits (session->internals.selected_cert_list[0].
+    MHD__gnutls_mpi_get_nbits (session->internals.selected_cert_list[0].
                            params[0]);
 
-  if (mhd_gtls_cipher_suite_get_kx_algo
+  if (MHD_gtls_cipher_suite_get_kx_algo
       (&session->security_parameters.current_cipher_suite)
       == MHD_GNUTLS_KX_RSA_EXPORT && bits > 512)
     {
 
       rsa_params =
-        mhd_gtls_certificate_get_rsa_params (cred->rsa_params,
+        MHD_gtls_certificate_get_rsa_params (cred->rsa_params,
                                              cred->params_func, session);
       /* EXPORT case: */
       if (rsa_params == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_NO_TEMPORARY_RSA_PARAMS;
         }
 
@@ -206,18 +206,18 @@ _gnutls_get_private_rsa_params (mhd_gtls_session_t session,
 }
 
 int
-_gnutls_proc_rsa_client_kx (mhd_gtls_session_t session, opaque * data,
+MHD__gnutls_proc_rsa_client_kx (MHD_gtls_session_t session, opaque * data,
                             size_t _data_size)
 {
-  gnutls_datum_t plaintext;
-  gnutls_datum_t ciphertext;
+  MHD_gnutls_datum_t plaintext;
+  MHD_gnutls_datum_t ciphertext;
   int ret, dsize;
   mpi_t *params;
   int params_len;
   int randomize_key = 0;
   ssize_t data_size = _data_size;
 
-  if (MHD_gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3)
+  if (MHD__gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3)
     {
       /* SSL 3.0
        */
@@ -230,24 +230,24 @@ _gnutls_proc_rsa_client_kx (mhd_gtls_session_t session, opaque * data,
        */
       DECR_LEN (data_size, 2);
       ciphertext.data = &data[2];
-      dsize = mhd_gtls_read_uint16 (data);
+      dsize = MHD_gtls_read_uint16 (data);
 
       if (dsize != data_size)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
         }
       ciphertext.size = dsize;
     }
 
-  ret = _gnutls_get_private_rsa_params (session, &params, &params_len);
+  ret = MHD__gnutls_get_private_rsa_params (session, &params, &params_len);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  ret = mhd_gtls_pkcs1_rsa_decrypt (&plaintext, &ciphertext, params, params_len, 2);    /* btype==2 */
+  ret = MHD_gtls_pkcs1_rsa_decrypt (&plaintext, &ciphertext, params, params_len, 2);    /* btype==2 */
 
   if (ret < 0 || plaintext.size != TLS_MASTER_SIZE)
     {
@@ -255,8 +255,8 @@ _gnutls_proc_rsa_client_kx (mhd_gtls_session_t session, opaque * data,
        * the peer. Just use a random key. (in order to avoid
        * attack against pkcs-1 formating).
        */
-      gnutls_assert ();
-      _gnutls_x509_log ("auth_rsa: Possible PKCS #1 format attack\n");
+      MHD_gnutls_assert ();
+      MHD__gnutls_x509_log ("auth_rsa: Possible PKCS #1 format attack\n");
       randomize_key = 1;
     }
   else
@@ -264,8 +264,8 @@ _gnutls_proc_rsa_client_kx (mhd_gtls_session_t session, opaque * data,
       /* If the secret was properly formatted, then
        * check the version number.
        */
-      if (_gnutls_get_adv_version_major (session) != plaintext.data[0]
-          || _gnutls_get_adv_version_minor (session) != plaintext.data[1])
+      if (MHD__gnutls_get_adv_version_major (session) != plaintext.data[0]
+          || MHD__gnutls_get_adv_version_minor (session) != plaintext.data[1])
         {
           /* No error is returned here, if the version number check
            * fails. We proceed normally.
@@ -273,8 +273,8 @@ _gnutls_proc_rsa_client_kx (mhd_gtls_session_t session, opaque * data,
            * "Attacking RSA-based sessions in SSL/TLS" by Vlastimil Klima,
            * Ondej Pokorny and Tomas Rosa.
            */
-          gnutls_assert ();
-          _gnutls_x509_log
+          MHD_gnutls_assert ();
+          MHD__gnutls_x509_log
             ("auth_rsa: Possible PKCS #1 version check format attack\n");
         }
     }
@@ -282,18 +282,18 @@ _gnutls_proc_rsa_client_kx (mhd_gtls_session_t session, opaque * data,
   if (randomize_key != 0)
     {
       session->key->key.size = TLS_MASTER_SIZE;
-      session->key->key.data = gnutls_malloc (session->key->key.size);
+      session->key->key.data = MHD_gnutls_malloc (session->key->key.size);
       if (session->key->key.data == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_MEMORY_ERROR;
         }
 
       /* we do not need strong random numbers here.
        */
-      if (gc_nonce (session->key->key.data, session->key->key.size) != GC_OK)
+      if (MHD_gc_nonce (session->key->key.data, session->key->key.size) != GC_OK)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_RANDOM_FAILED;
         }
 
@@ -307,8 +307,8 @@ _gnutls_proc_rsa_client_kx (mhd_gtls_session_t session, opaque * data,
   /* This is here to avoid the version check attack
    * discussed above.
    */
-  session->key->key.data[0] = _gnutls_get_adv_version_major (session);
-  session->key->key.data[1] = _gnutls_get_adv_version_minor (session);
+  session->key->key.data[0] = MHD__gnutls_get_adv_version_major (session);
+  session->key->key.data[1] = MHD__gnutls_get_adv_version_minor (session);
 
   return 0;
 }
@@ -318,46 +318,53 @@ _gnutls_proc_rsa_client_kx (mhd_gtls_session_t session, opaque * data,
 /* return RSA(random) using the peers public key
  */
 int
-_gnutls_gen_rsa_client_kx (mhd_gtls_session_t session, opaque ** data)
+MHD__gnutls_gen_rsa_client_kx (MHD_gtls_session_t session, opaque ** data)
 {
-  cert_auth_info_t auth = session->key->auth_info;
-  gnutls_datum_t sdata;         /* data to send */
+  cert_auth_info_t auth;
+  MHD_gnutls_datum_t sdata;         /* data to send */
   mpi_t params[MAX_PUBLIC_PARAMS_SIZE];
   int params_len = MAX_PUBLIC_PARAMS_SIZE;
   int ret, i;
   enum MHD_GNUTLS_Protocol ver;
 
+  if (session->key == NULL)
+    {
+      MHD_gnutls_assert ();
+      return GNUTLS_E_INSUFFICIENT_CREDENTIALS;  
+    }
+
+  auth = session->key->auth_info;
   if (auth == NULL)
     {
       /* this shouldn't have happened. The proc_certificate
        * function should have detected that.
        */
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
     }
 
   session->key->key.size = TLS_MASTER_SIZE;
-  session->key->key.data = gnutls_secure_malloc (session->key->key.size);
+  session->key->key.data = MHD_gnutls_secure_malloc (session->key->key.size);
 
   if (session->key->key.data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
-  if (gc_pseudo_random (session->key->key.data,
+  if (MHD_gc_pseudo_random (session->key->key.data,
                         session->key->key.size) != GC_OK)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_RANDOM_FAILED;
     }
 
-  ver = mhd_gtls_get_adv_version (session);
+  ver = MHD_gtls_get_adv_version (session);
 
   if (session->internals.rsa_pms_version[0] == 0)
     {
-      session->key->key.data[0] = mhd_gtls_version_get_major (ver);
-      session->key->key.data[1] = mhd_gtls_version_get_minor (ver);
+      session->key->key.data[0] = MHD_gtls_version_get_major (ver);
+      session->key->key.data[1] = MHD_gtls_version_get_minor (ver);
     }
   else
     {                           /* use the version provided */
@@ -368,24 +375,24 @@ _gnutls_gen_rsa_client_kx (mhd_gtls_session_t session, opaque ** data)
   /* move RSA parameters to key (session).
    */
   if ((ret =
-       _gnutls_get_public_rsa_params (session, params, &params_len)) < 0)
+       MHD__gnutls_get_public_rsa_params (session, params, &params_len)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
   if ((ret =
-       mhd_gtls_pkcs1_rsa_encrypt (&sdata, &session->key->key,
+       MHD_gtls_pkcs1_rsa_encrypt (&sdata, &session->key->key,
                                    params, params_len, 2)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
   for (i = 0; i < params_len; i++)
-    mhd_gtls_mpi_release (&params[i]);
+    MHD_gtls_mpi_release (&params[i]);
 
-  if (MHD_gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3)
+  if (MHD__gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3)
     {
       /* SSL 3.0 */
       *data = sdata.data;
@@ -393,15 +400,15 @@ _gnutls_gen_rsa_client_kx (mhd_gtls_session_t session, opaque ** data)
     }
   else
     {                           /* TLS 1 */
-      *data = gnutls_malloc (sdata.size + 2);
+      *data = MHD_gnutls_malloc (sdata.size + 2);
       if (*data == NULL)
         {
-          _gnutls_free_datum (&sdata);
+          MHD__gnutls_free_datum (&sdata);
           return GNUTLS_E_MEMORY_ERROR;
         }
-      mhd_gtls_write_datum16 (*data, sdata);
+      MHD_gtls_write_datum16 (*data, sdata);
       ret = sdata.size + 2;
-      _gnutls_free_datum (&sdata);
+      MHD__gnutls_free_datum (&sdata);
       return ret;
     }
 
diff --git a/src/daemon/https/tls/auth_rsa_export.c b/src/daemon/https/tls/auth_rsa_export.c
index 5442c8ba..9269f704 100644
--- a/src/daemon/https/tls/auth_rsa_export.c
+++ b/src/daemon/https/tls/auth_rsa_export.c
@@ -43,105 +43,105 @@
 #include <gnutls_rsa_export.h>
 #include <gnutls_state.h>
 
-int _gnutls_gen_rsa_client_kx (mhd_gtls_session_t, opaque **);
-int _gnutls_proc_rsa_client_kx (mhd_gtls_session_t, opaque *, size_t);
-static int gen_rsa_export_server_kx (mhd_gtls_session_t, opaque **);
-static int proc_rsa_export_server_kx (mhd_gtls_session_t, opaque *, size_t);
+int MHD__gnutls_gen_rsa_client_kx (MHD_gtls_session_t, opaque **);
+int MHD__gnutls_proc_rsa_client_kx (MHD_gtls_session_t, opaque *, size_t);
+static int gen_rsa_export_server_kx (MHD_gtls_session_t, opaque **);
+static int proc_rsa_export_server_kx (MHD_gtls_session_t, opaque *, size_t);
 
-const mhd_gtls_mod_auth_st rsa_export_auth_struct = {
+const MHD_gtls_mod_auth_st rsa_export_auth_struct = {
   "RSA EXPORT",
-  mhd_gtls_gen_cert_server_certificate,
-  mhd_gtls_gen_cert_client_certificate,
+  MHD_gtls_gen_cert_server_certificate,
+  MHD_gtls_gen_cert_client_certificate,
   gen_rsa_export_server_kx,
-  _gnutls_gen_rsa_client_kx,
-  mhd_gtls_gen_cert_client_cert_vrfy,   /* gen client cert vrfy */
-  mhd_gtls_gen_cert_server_cert_req,    /* server cert request */
+  MHD__gnutls_gen_rsa_client_kx,
+  MHD_gtls_gen_cert_client_cert_vrfy,   /* gen client cert vrfy */
+  MHD_gtls_gen_cert_server_cert_req,    /* server cert request */
 
-  mhd_gtls_proc_cert_server_certificate,
-  _gnutls_proc_cert_client_certificate,
+  MHD_gtls_proc_cert_server_certificate,
+  MHD__gnutls_proc_cert_client_certificate,
   proc_rsa_export_server_kx,
-  _gnutls_proc_rsa_client_kx,   /* proc client kx */
-  mhd_gtls_proc_cert_client_cert_vrfy,  /* proc client cert vrfy */
-  mhd_gtls_proc_cert_cert_req   /* proc server cert request */
+  MHD__gnutls_proc_rsa_client_kx,   /* proc client kx */
+  MHD_gtls_proc_cert_client_cert_vrfy,  /* proc client cert vrfy */
+  MHD_gtls_proc_cert_cert_req   /* proc server cert request */
 };
 
 static int
-gen_rsa_export_server_kx (mhd_gtls_session_t session, opaque ** data)
+gen_rsa_export_server_kx (MHD_gtls_session_t session, opaque ** data)
 {
-  mhd_gtls_rsa_params_t rsa_params;
+  MHD_gtls_rsa_params_t rsa_params;
   const mpi_t *rsa_mpis;
   size_t n_e, n_m;
   uint8_t *data_e, *data_m;
   int ret = 0, data_size;
-  gnutls_cert *apr_cert_list;
-  gnutls_privkey *apr_pkey;
+  MHD_gnutls_cert *apr_cert_list;
+  MHD_gnutls_privkey *apr_pkey;
   int apr_cert_list_length;
-  gnutls_datum_t signature, ddata;
-  mhd_gtls_cert_credentials_t cred;
+  MHD_gnutls_datum_t signature, ddata;
+  MHD_gtls_cert_credentials_t cred;
 
-  cred = (mhd_gtls_cert_credentials_t)
-    mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
+  cred = (MHD_gtls_cert_credentials_t)
+    MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
   if (cred == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
     }
 
   /* find the appropriate certificate */
   if ((ret =
-       mhd_gtls_get_selected_cert (session, &apr_cert_list,
+       MHD_gtls_get_selected_cert (session, &apr_cert_list,
                                    &apr_cert_list_length, &apr_pkey)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
   /* abort sending this message if we have a certificate
    * of 512 bits or less.
    */
-  if (apr_pkey && _gnutls_mpi_get_nbits (apr_pkey->params[0]) <= 512)
+  if (apr_pkey && MHD__gnutls_mpi_get_nbits (apr_pkey->params[0]) <= 512)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INT_RET_0;
     }
 
   rsa_params =
-    mhd_gtls_certificate_get_rsa_params (cred->rsa_params, cred->params_func,
+    MHD_gtls_certificate_get_rsa_params (cred->rsa_params, cred->params_func,
                                          session);
-  rsa_mpis = _gnutls_rsa_params_to_mpi (rsa_params);
+  rsa_mpis = MHD__gnutls_rsa_params_to_mpi (rsa_params);
   if (rsa_mpis == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_NO_TEMPORARY_RSA_PARAMS;
     }
 
-  if ((ret = mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
+  if ((ret = MHD_gtls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
                                      sizeof (cert_auth_info_st), 0)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  mhd_gtls_rsa_export_set_pubkey (session, rsa_mpis[1], rsa_mpis[0]);
+  MHD_gtls_rsa_export_set_pubkey (session, rsa_mpis[1], rsa_mpis[0]);
 
-  mhd_gtls_mpi_print (NULL, &n_m, rsa_mpis[0]);
-  mhd_gtls_mpi_print (NULL, &n_e, rsa_mpis[1]);
+  MHD_gtls_mpi_print (NULL, &n_m, rsa_mpis[0]);
+  MHD_gtls_mpi_print (NULL, &n_e, rsa_mpis[1]);
 
-  (*data) = gnutls_malloc (n_e + n_m + 4);
+  (*data) = MHD_gnutls_malloc (n_e + n_m + 4);
   if (*data == NULL)
     {
       return GNUTLS_E_MEMORY_ERROR;
     }
 
   data_m = &(*data)[0];
-  mhd_gtls_mpi_print (&data_m[2], &n_m, rsa_mpis[0]);
+  MHD_gtls_mpi_print (&data_m[2], &n_m, rsa_mpis[0]);
 
-  mhd_gtls_write_uint16 (n_m, data_m);
+  MHD_gtls_write_uint16 (n_m, data_m);
 
   data_e = &data_m[2 + n_m];
-  mhd_gtls_mpi_print (&data_e[2], &n_e, rsa_mpis[1]);
+  MHD_gtls_mpi_print (&data_e[2], &n_e, rsa_mpis[1]);
 
-  mhd_gtls_write_uint16 (n_e, data_e);
+  MHD_gtls_write_uint16 (n_e, data_e);
 
   data_size = n_m + n_e + 4;
 
@@ -154,33 +154,33 @@ gen_rsa_export_server_kx (mhd_gtls_session_t session, opaque ** data)
   if (apr_cert_list_length > 0)
     {
       if ((ret =
-           mhd_gtls_tls_sign_params (session, &apr_cert_list[0],
+           MHD_gtls_tls_sign_params (session, &apr_cert_list[0],
                                      apr_pkey, &ddata, &signature)) < 0)
         {
-          gnutls_assert ();
-          gnutls_free (*data);
+          MHD_gnutls_assert ();
+          MHD_gnutls_free (*data);
           *data = NULL;
           return ret;
         }
     }
   else
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return data_size;         /* do not put a signature - ILLEGAL! */
     }
 
-  *data = mhd_gtls_realloc_fast (*data, data_size + signature.size + 2);
+  *data = MHD_gtls_realloc_fast (*data, data_size + signature.size + 2);
   if (*data == NULL)
     {
-      _gnutls_free_datum (&signature);
-      gnutls_assert ();
+      MHD__gnutls_free_datum (&signature);
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
-  mhd_gtls_write_datum16 (&((*data)[data_size]), signature);
+  MHD_gtls_write_datum16 (&((*data)[data_size]), signature);
   data_size += signature.size + 2;
 
-  _gnutls_free_datum (&signature);
+  MHD__gnutls_free_datum (&signature);
 
   return data_size;
 }
@@ -188,49 +188,49 @@ gen_rsa_export_server_kx (mhd_gtls_session_t session, opaque ** data)
 /* if the peer's certificate is of 512 bits or less, returns non zero.
  */
 int
-_gnutls_peers_cert_less_512 (mhd_gtls_session_t session)
+MHD__gnutls_peers_cert_less_512 (MHD_gtls_session_t session)
 {
-  gnutls_cert peer_cert;
+  MHD_gnutls_cert peer_cert;
   int ret;
-  cert_auth_info_t info = mhd_gtls_get_auth_info (session);
+  cert_auth_info_t info = MHD_gtls_get_auth_info (session);
 
   if (info == NULL || info->ncerts == 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       /* we need this in order to get peer's certificate */
       return 0;
     }
 
   if ((ret =
-       mhd_gtls_raw_cert_to_gcert (&peer_cert,
+       MHD_gtls_raw_cert_to_gcert (&peer_cert,
                                    session->security_parameters.cert_type,
                                    &info->raw_certificate_list[0],
                                    CERT_NO_COPY)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return 0;
     }
 
   if (peer_cert.subject_pk_algorithm != MHD_GNUTLS_PK_RSA)
     {
-      gnutls_assert ();
-      mhd_gtls_gcert_deinit (&peer_cert);
+      MHD_gnutls_assert ();
+      MHD_gtls_gcert_deinit (&peer_cert);
       return 0;
     }
 
-  if (_gnutls_mpi_get_nbits (peer_cert.params[0]) <= 512)
+  if (MHD__gnutls_mpi_get_nbits (peer_cert.params[0]) <= 512)
     {
-      mhd_gtls_gcert_deinit (&peer_cert);
+      MHD_gtls_gcert_deinit (&peer_cert);
       return 1;
     }
 
-  mhd_gtls_gcert_deinit (&peer_cert);
+  MHD_gtls_gcert_deinit (&peer_cert);
 
   return 0;
 }
 
 static int
-proc_rsa_export_server_kx (mhd_gtls_session_t session,
+proc_rsa_export_server_kx (MHD_gtls_session_t session,
                            opaque * data, size_t _data_size)
 {
   uint16_t n_m, n_e;
@@ -238,16 +238,16 @@ proc_rsa_export_server_kx (mhd_gtls_session_t session,
   uint8_t *data_m;
   uint8_t *data_e;
   int i, sigsize;
-  gnutls_datum_t vparams, signature;
+  MHD_gnutls_datum_t vparams, signature;
   int ret;
   ssize_t data_size = _data_size;
   cert_auth_info_t info;
-  gnutls_cert peer_cert;
+  MHD_gnutls_cert peer_cert;
 
-  info = mhd_gtls_get_auth_info (session);
+  info = MHD_gtls_get_auth_info (session);
   if (info == NULL || info->ncerts == 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       /* we need this in order to get peer's certificate */
       return GNUTLS_E_INTERNAL_ERROR;
     }
@@ -256,7 +256,7 @@ proc_rsa_export_server_kx (mhd_gtls_session_t session,
   i = 0;
 
   DECR_LEN (data_size, 2);
-  n_m = mhd_gtls_read_uint16 (&data[i]);
+  n_m = MHD_gtls_read_uint16 (&data[i]);
   i += 2;
 
   DECR_LEN (data_size, n_m);
@@ -264,7 +264,7 @@ proc_rsa_export_server_kx (mhd_gtls_session_t session,
   i += n_m;
 
   DECR_LEN (data_size, 2);
-  n_e = mhd_gtls_read_uint16 (&data[i]);
+  n_e = MHD_gtls_read_uint16 (&data[i]);
   i += 2;
 
   DECR_LEN (data_size, n_e);
@@ -274,19 +274,19 @@ proc_rsa_export_server_kx (mhd_gtls_session_t session,
   _n_e = n_e;
   _n_m = n_m;
 
-  if (mhd_gtls_mpi_scan_nz (&session->key->rsa[0], data_m, &_n_m) != 0)
+  if (MHD_gtls_mpi_scan_nz (&session->key->rsa[0], data_m, &_n_m) != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MPI_SCAN_FAILED;
     }
 
-  if (mhd_gtls_mpi_scan_nz (&session->key->rsa[1], data_e, &_n_e) != 0)
+  if (MHD_gtls_mpi_scan_nz (&session->key->rsa[1], data_e, &_n_e) != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MPI_SCAN_FAILED;
     }
 
-  mhd_gtls_rsa_export_set_pubkey (session, session->key->rsa[1],
+  MHD_gtls_rsa_export_set_pubkey (session, session->key->rsa[1],
                                   session->key->rsa[0]);
 
   /* VERIFY SIGNATURE */
@@ -295,29 +295,29 @@ proc_rsa_export_server_kx (mhd_gtls_session_t session,
   vparams.data = data;
 
   DECR_LEN (data_size, 2);
-  sigsize = mhd_gtls_read_uint16 (&data[vparams.size]);
+  sigsize = MHD_gtls_read_uint16 (&data[vparams.size]);
 
   DECR_LEN (data_size, sigsize);
   signature.data = &data[vparams.size + 2];
   signature.size = sigsize;
 
   if ((ret =
-       mhd_gtls_raw_cert_to_gcert (&peer_cert,
+       MHD_gtls_raw_cert_to_gcert (&peer_cert,
                                    session->security_parameters.cert_type,
                                    &info->raw_certificate_list[0],
                                    CERT_NO_COPY)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
   ret =
-    mhd_gtls_verify_sig_params (session, &peer_cert, &vparams, &signature);
+    MHD_gtls_verify_sig_params (session, &peer_cert, &vparams, &signature);
 
-  mhd_gtls_gcert_deinit (&peer_cert);
+  MHD_gtls_gcert_deinit (&peer_cert);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
     }
 
   return ret;
diff --git a/src/daemon/https/tls/debug.c b/src/daemon/https/tls/debug.c
index 14c7b494..21cd945f 100644
--- a/src/daemon/https/tls/debug.c
+++ b/src/daemon/https/tls/debug.c
@@ -32,26 +32,26 @@
 
 
 void
-_gnutls_print_state (mhd_gtls_session_t session)
+MHD__gnutls_print_state (MHD_gtls_session_t session)
 {
 
-  _gnutls_debug_log ("GNUTLS State:\n");
-  _gnutls_debug_log ("Connection End: %d\n",
+  MHD__gnutls_debug_log ("GNUTLS State:\n");
+  MHD__gnutls_debug_log ("Connection End: %d\n",
                      session->security_parameters.entity);
-  _gnutls_debug_log ("Cipher Algorithm: %d\n",
+  MHD__gnutls_debug_log ("Cipher Algorithm: %d\n",
                      session->security_parameters.read_bulk_cipher_algorithm);
-  _gnutls_debug_log ("MAC algorithm: %d\n",
+  MHD__gnutls_debug_log ("MAC algorithm: %d\n",
                      session->security_parameters.read_mac_algorithm);
-  _gnutls_debug_log ("Compression Algorithm: %d\n",
+  MHD__gnutls_debug_log ("Compression Algorithm: %d\n",
                      session->security_parameters.read_compression_algorithm);
-  _gnutls_debug_log ("\n");
+  MHD__gnutls_debug_log ("\n");
 
 }
 
 #endif
 
 const char *
-_gnutls_packet2str (content_type_t packet)
+MHD__gnutls_packet2str (content_type_t packet)
 {
   switch (packet)
     {
@@ -72,7 +72,7 @@ _gnutls_packet2str (content_type_t packet)
 }
 
 const char *
-_gnutls_handshake2str (gnutls_handshake_description_t handshake)
+MHD__gnutls_handshake2str (MHD_gnutls_handshake_description_t handshake)
 {
 
   switch (handshake)
@@ -117,12 +117,12 @@ _gnutls_handshake2str (gnutls_handshake_description_t handshake)
 }
 
 void
-_gnutls_dump_mpi (const char *prefix, mpi_t a)
+MHD__gnutls_dump_mpi (const char *prefix, mpi_t a)
 {
   opaque buf[1024];
   size_t n = sizeof buf;
 
   if (gcry_mpi_print (GCRYMPI_FMT_HEX, buf, n, &n, a))
     strcpy (buf, "[can't print value]");        /* Flawfinder: ignore */
-  _gnutls_hard_log ("MPI: length: %d\n\t%s%s\n", (n - 1) / 2, prefix, buf);
+  MHD__gnutls_hard_log ("MPI: length: %d\n\t%s%s\n", (n - 1) / 2, prefix, buf);
 }
diff --git a/src/daemon/https/tls/debug.h b/src/daemon/https/tls/debug.h
index ccaf0f17..637beca8 100644
--- a/src/daemon/https/tls/debug.h
+++ b/src/daemon/https/tls/debug.h
@@ -23,8 +23,8 @@
  */
 
 #ifdef DEBUG
-void _gnutls_print_state (mhd_gtls_session_t session);
+void MHD__gnutls_print_state (MHD_gtls_session_t session);
 #endif
-const char *_gnutls_packet2str (content_type_t packet);
-const char *_gnutls_handshake2str (gnutls_handshake_description_t handshake);
-void _gnutls_dump_mpi (const char *prefix, mpi_t a);
+const char *MHD__gnutls_packet2str (content_type_t packet);
+const char *MHD__gnutls_handshake2str (MHD_gnutls_handshake_description_t handshake);
+void MHD__gnutls_dump_mpi (const char *prefix, mpi_t a);
diff --git a/src/daemon/https/tls/ext_cert_type.c b/src/daemon/https/tls/ext_cert_type.c
index 9e00120c..4feeb18f 100644
--- a/src/daemon/https/tls/ext_cert_type.c
+++ b/src/daemon/https/tls/ext_cert_type.c
@@ -33,12 +33,12 @@
 #include "gnutls_state.h"
 #include "gnutls_num.h"
 
-inline static int _gnutls_num2cert_type (int num);
-inline static int _gnutls_cert_type2num (int record_size);
+inline static int MHD__gnutls_num2cert_type (int num);
+inline static int MHD__gnutls_cert_type2num (int record_size);
 
 /*
  * 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_certificate_type_get(),
+ * into the session security parameters the new value. The server may use MHD_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.
@@ -46,7 +46,7 @@ inline static int _gnutls_cert_type2num (int record_size);
  */
 
 int
-mhd_gtls_cert_type_recv_params (mhd_gtls_session_t session,
+MHD_gtls_cert_type_recv_params (MHD_gtls_session_t session,
                                 const opaque * data, size_t _data_size)
 {
   int new_type = -1, ret, i;
@@ -59,27 +59,27 @@ mhd_gtls_cert_type_recv_params (mhd_gtls_session_t session,
         {
           if (data_size != 1)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
             }
 
-          new_type = _gnutls_num2cert_type (data[0]);
+          new_type = MHD__gnutls_num2cert_type (data[0]);
 
           if (new_type < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return new_type;
             }
 
           /* Check if we support this cert_type */
           if ((ret =
-               mhd_gtls_session_cert_type_supported (session, new_type)) < 0)
+               MHD_gtls_session_cert_type_supported (session, new_type)) < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return ret;
             }
 
-          _gnutls_session_cert_type_set (session, new_type);
+          MHD__gnutls_session_cert_type_set (session, new_type);
         }
     }
   else
@@ -96,17 +96,17 @@ mhd_gtls_cert_type_recv_params (mhd_gtls_session_t session,
 
           for (i = 0; i < len; i++)
             {
-              new_type = _gnutls_num2cert_type (data[i + 1]);
+              new_type = MHD__gnutls_num2cert_type (data[i + 1]);
 
               if (new_type < 0)
                 continue;
 
               /* Check if we support this cert_type */
               if ((ret =
-                   mhd_gtls_session_cert_type_supported (session,
+                   MHD_gtls_session_cert_type_supported (session,
                                                          new_type)) < 0)
                 {
-                  gnutls_assert ();
+                  MHD_gnutls_assert ();
                   continue;
                 }
               else
@@ -116,14 +116,14 @@ mhd_gtls_cert_type_recv_params (mhd_gtls_session_t session,
 
           if (new_type < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER;
             }
 
           if ((ret =
-               mhd_gtls_session_cert_type_supported (session, new_type)) < 0)
+               MHD_gtls_session_cert_type_supported (session, new_type)) < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               /* The peer has requested unsupported certificate
                * types. Instead of failing, procceed normally.
                * (the ciphersuite selection would fail, or a
@@ -132,7 +132,7 @@ mhd_gtls_cert_type_recv_params (mhd_gtls_session_t session,
               return 0;
             }
 
-          _gnutls_session_cert_type_set (session, new_type);
+          MHD__gnutls_session_cert_type_set (session, new_type);
         }
 
 
@@ -144,7 +144,7 @@ mhd_gtls_cert_type_recv_params (mhd_gtls_session_t session,
 /* returns data_size or a negative number on failure
  */
 int
-mhd_gtls_cert_type_send_params (mhd_gtls_session_t session, opaque * data,
+MHD_gtls_cert_type_send_params (MHD_gtls_session_t session, opaque * data,
                                 size_t data_size)
 {
   unsigned len, i;
@@ -171,7 +171,7 @@ mhd_gtls_cert_type_send_params (mhd_gtls_session_t session, opaque * data,
 
           if (data_size < len + 1)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return GNUTLS_E_SHORT_MEMORY_BUFFER;
             }
 
@@ -182,7 +182,7 @@ mhd_gtls_cert_type_send_params (mhd_gtls_session_t session, opaque * data,
           for (i = 0; i < len; i++)
             {
               data[i + 1] =
-                _gnutls_cert_type2num (session->internals.
+                MHD__gnutls_cert_type2num (session->internals.
                                        priorities.cert_type.priority[i]);
             }
           return len + 1;
@@ -197,12 +197,12 @@ mhd_gtls_cert_type_send_params (mhd_gtls_session_t session, opaque * data,
           len = 1;
           if (data_size < len)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return GNUTLS_E_SHORT_MEMORY_BUFFER;
             }
 
           data[0] =
-            _gnutls_cert_type2num (session->security_parameters.cert_type);
+            MHD__gnutls_cert_type2num (session->security_parameters.cert_type);
           return len;
         }
 
@@ -216,7 +216,7 @@ mhd_gtls_cert_type_send_params (mhd_gtls_session_t session, opaque * data,
  * extensions draft.
  */
 inline static int
-_gnutls_num2cert_type (int num)
+MHD__gnutls_num2cert_type (int num)
 {
   switch (num)
     {
@@ -231,7 +231,7 @@ _gnutls_num2cert_type (int num)
  * extensions draft.
  */
 inline static int
-_gnutls_cert_type2num (int cert_type)
+MHD__gnutls_cert_type2num (int cert_type)
 {
   switch (cert_type)
     {
diff --git a/src/daemon/https/tls/ext_cert_type.h b/src/daemon/https/tls/ext_cert_type.h
index cd9b0acc..f80f7ba8 100644
--- a/src/daemon/https/tls/ext_cert_type.h
+++ b/src/daemon/https/tls/ext_cert_type.h
@@ -25,7 +25,7 @@
 /* Maps record size to numbers according to the
  * extensions draft.
  */
-int mhd_gtls_cert_type_recv_params (mhd_gtls_session_t session,
+int MHD_gtls_cert_type_recv_params (MHD_gtls_session_t session,
                                     const opaque * data, size_t data_size);
-int mhd_gtls_cert_type_send_params (mhd_gtls_session_t session, opaque * data,
+int MHD_gtls_cert_type_send_params (MHD_gtls_session_t session, opaque * data,
                                     size_t);
diff --git a/src/daemon/https/tls/ext_max_record.c b/src/daemon/https/tls/ext_max_record.c
index 1b5f2be2..421a1739 100644
--- a/src/daemon/https/tls/ext_max_record.c
+++ b/src/daemon/https/tls/ext_max_record.c
@@ -32,7 +32,7 @@
 
 /*
  * In case of a server: if a MAX_RECORD_SIZE extension type is received then it stores
- * into the session the new value. The server may use gnutls_get_max_record_size(),
+ * into the session the new value. The server may use MHD_gnutls_get_max_record_size(),
  * in order to access it.
  *
  * In case of a client: If a different max record size (than the default) has
@@ -41,7 +41,7 @@
  */
 
 int
-mhd_gtls_max_record_recv_params (mhd_gtls_session_t session,
+MHD_gtls_max_record_recv_params (MHD_gtls_session_t session,
                                  const opaque * data, size_t _data_size)
 {
   ssize_t new_size;
@@ -53,11 +53,11 @@ mhd_gtls_max_record_recv_params (mhd_gtls_session_t session,
         {
           DECR_LEN (data_size, 1);
 
-          new_size = mhd_gtls_mre_num2record (data[0]);
+          new_size = MHD_gtls_mre_num2record (data[0]);
 
           if (new_size < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return new_size;
             }
 
@@ -73,16 +73,16 @@ mhd_gtls_max_record_recv_params (mhd_gtls_session_t session,
 
           if (data_size != 1)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
             }
 
-          new_size = mhd_gtls_mre_num2record (data[0]);
+          new_size = MHD_gtls_mre_num2record (data[0]);
 
           if (new_size < 0
               || new_size != session->internals.proposed_record_size)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER;
             }
           else
@@ -102,7 +102,7 @@ mhd_gtls_max_record_recv_params (mhd_gtls_session_t session,
 /* returns data_size or a negative number on failure
  */
 int
-mhd_gtls_max_record_send_params (mhd_gtls_session_t session, opaque * data,
+MHD_gtls_max_record_send_params (MHD_gtls_session_t session, opaque * data,
                                  size_t data_size)
 {
   uint16_t len;
@@ -116,12 +116,12 @@ mhd_gtls_max_record_send_params (mhd_gtls_session_t session, opaque * data,
           len = 1;
           if (data_size < len)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return GNUTLS_E_SHORT_MEMORY_BUFFER;
             }
 
           data[0] =
-            (uint8_t) mhd_gtls_mre_record2num (session->internals.
+            (uint8_t) MHD_gtls_mre_record2num (session->internals.
                                                proposed_record_size);
           return len;
         }
@@ -137,13 +137,13 @@ mhd_gtls_max_record_send_params (mhd_gtls_session_t session, opaque * data,
           len = 1;
           if (data_size < len)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return GNUTLS_E_SHORT_MEMORY_BUFFER;
             }
 
           data[0] =
             (uint8_t)
-            mhd_gtls_mre_record2num
+            MHD_gtls_mre_record2num
             (session->security_parameters.max_record_recv_size);
           return len;
         }
@@ -158,7 +158,7 @@ mhd_gtls_max_record_send_params (mhd_gtls_session_t session, opaque * data,
  * extensions draft.
  */
 int
-mhd_gtls_mre_num2record (int num)
+MHD_gtls_mre_num2record (int num)
 {
   switch (num)
     {
@@ -179,7 +179,7 @@ mhd_gtls_mre_num2record (int num)
  * extensions draft.
  */
 int
-mhd_gtls_mre_record2num (uint16_t record_size)
+MHD_gtls_mre_record2num (uint16_t record_size)
 {
   switch (record_size)
     {
diff --git a/src/daemon/https/tls/ext_max_record.h b/src/daemon/https/tls/ext_max_record.h
index 361470a9..14686253 100644
--- a/src/daemon/https/tls/ext_max_record.h
+++ b/src/daemon/https/tls/ext_max_record.h
@@ -25,9 +25,9 @@
 /* Maps record size to numbers according to the
  * extensions draft.
  */
-int mhd_gtls_mre_num2record (int num);
-int mhd_gtls_mre_record2num (uint16_t record_size);
-int mhd_gtls_max_record_recv_params (mhd_gtls_session_t session,
+int MHD_gtls_mre_num2record (int num);
+int MHD_gtls_mre_record2num (uint16_t record_size);
+int MHD_gtls_max_record_recv_params (MHD_gtls_session_t session,
                                      const opaque * data, size_t data_size);
-int mhd_gtls_max_record_send_params (mhd_gtls_session_t session,
+int MHD_gtls_max_record_send_params (MHD_gtls_session_t session,
                                      opaque * data, size_t);
diff --git a/src/daemon/https/tls/ext_oprfi.c b/src/daemon/https/tls/ext_oprfi.c
index b2dad0ff..09ef51cd 100644
--- a/src/daemon/https/tls/ext_oprfi.c
+++ b/src/daemon/https/tls/ext_oprfi.c
@@ -34,7 +34,7 @@
 #include <gnutls_num.h>
 
 static int
-oprfi_recv_server (mhd_gtls_session_t session,
+oprfi_recv_server (MHD_gtls_session_t session,
                    const opaque * data, size_t _data_size)
 {
   ssize_t data_size = _data_size;
@@ -42,26 +42,26 @@ oprfi_recv_server (mhd_gtls_session_t session,
 
   if (!session->security_parameters.extensions.oprfi_cb)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return 0;
     }
 
   DECR_LEN (data_size, 2);
-  len = mhd_gtls_read_uint16 (data);
+  len = MHD_gtls_read_uint16 (data);
   data += 2;
 
   if (len != data_size)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
     }
 
   /* Store incoming data. */
   session->security_parameters.extensions.oprfi_client_len = len;
-  session->security_parameters.extensions.oprfi_client = gnutls_malloc (len);
+  session->security_parameters.extensions.oprfi_client = MHD_gnutls_malloc (len);
   if (!session->security_parameters.extensions.oprfi_client)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
   memcpy (session->security_parameters.extensions.oprfi_client, data, len);
@@ -70,7 +70,7 @@ oprfi_recv_server (mhd_gtls_session_t session,
 }
 
 static int
-oprfi_recv_client (mhd_gtls_session_t session,
+oprfi_recv_client (MHD_gtls_session_t session,
                    const opaque * data, size_t _data_size)
 {
   ssize_t data_size = _data_size;
@@ -78,32 +78,32 @@ oprfi_recv_client (mhd_gtls_session_t session,
 
   if (session->security_parameters.extensions.oprfi_client == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return 0;
     }
 
   DECR_LEN (data_size, 2);
-  len = mhd_gtls_read_uint16 (data);
+  len = MHD_gtls_read_uint16 (data);
   data += 2;
 
   if (len != data_size)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
     }
 
   if (len != session->security_parameters.extensions.oprfi_client_len)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER;
     }
 
   /* Store incoming data. */
   session->security_parameters.extensions.oprfi_server_len = len;
-  session->security_parameters.extensions.oprfi_server = gnutls_malloc (len);
+  session->security_parameters.extensions.oprfi_server = MHD_gnutls_malloc (len);
   if (!session->security_parameters.extensions.oprfi_server)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
   memcpy (session->security_parameters.extensions.oprfi_server, data, len);
@@ -112,7 +112,7 @@ oprfi_recv_client (mhd_gtls_session_t session,
 }
 
 int
-mhd_gtls_oprfi_recv_params (mhd_gtls_session_t session,
+MHD_gtls_oprfi_recv_params (MHD_gtls_session_t session,
                             const opaque * data, size_t data_size)
 {
 #if MHD_DEBUG_TLS
@@ -124,7 +124,7 @@ mhd_gtls_oprfi_recv_params (mhd_gtls_session_t session,
 }
 
 static int
-oprfi_send_client (mhd_gtls_session_t session, opaque * data,
+oprfi_send_client (MHD_gtls_session_t session, opaque * data,
                    size_t _data_size)
 {
   opaque *p = data;
@@ -135,7 +135,7 @@ oprfi_send_client (mhd_gtls_session_t session, opaque * data,
     return 0;
 
   DECR_LENGTH_RET (data_size, 2, GNUTLS_E_SHORT_MEMORY_BUFFER);
-  mhd_gtls_write_uint16 (oprf_size, p);
+  MHD_gtls_write_uint16 (oprf_size, p);
   p += 2;
 
   DECR_LENGTH_RET (data_size, oprf_size, GNUTLS_E_SHORT_MEMORY_BUFFER);
@@ -146,7 +146,7 @@ oprfi_send_client (mhd_gtls_session_t session, opaque * data,
 }
 
 static int
-oprfi_send_server (mhd_gtls_session_t session, opaque * data,
+oprfi_send_server (MHD_gtls_session_t session, opaque * data,
                    size_t _data_size)
 {
   opaque *p = data;
@@ -161,10 +161,10 @@ oprfi_send_server (mhd_gtls_session_t session, opaque * data,
   session->security_parameters.extensions.oprfi_server_len =
     session->security_parameters.extensions.oprfi_client_len;
   session->security_parameters.extensions.oprfi_server =
-    gnutls_malloc (session->security_parameters.extensions.oprfi_server_len);
+    MHD_gnutls_malloc (session->security_parameters.extensions.oprfi_server_len);
   if (!session->security_parameters.extensions.oprfi_server)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
@@ -176,13 +176,13 @@ oprfi_send_server (mhd_gtls_session_t session, opaque * data,
      session->security_parameters.extensions.oprfi_server);
   if (ret < 0)
     {
-      gnutls_assert ();
-      gnutls_free (session->security_parameters.extensions.oprfi_server);
+      MHD_gnutls_assert ();
+      MHD_gnutls_free (session->security_parameters.extensions.oprfi_server);
       return ret;
     }
 
   DECR_LENGTH_RET (data_size, 2, GNUTLS_E_SHORT_MEMORY_BUFFER);
-  mhd_gtls_write_uint16 (session->security_parameters.
+  MHD_gtls_write_uint16 (session->security_parameters.
                          extensions.oprfi_server_len, p);
   p += 2;
 
@@ -197,7 +197,7 @@ oprfi_send_server (mhd_gtls_session_t session, opaque * data,
 }
 
 int
-mhd_gtls_oprfi_send_params (mhd_gtls_session_t session,
+MHD_gtls_oprfi_send_params (MHD_gtls_session_t session,
                             opaque * data, size_t data_size)
 {
 #if MHD_DEBUG_TLS
@@ -210,7 +210,7 @@ mhd_gtls_oprfi_send_params (mhd_gtls_session_t session,
 
 /**
  * MHD_gtls_oprfi_enable_client:
- * @session: is a #mhd_gtls_session_t structure.
+ * @session: is a #MHD_gtls_session_t structure.
  * @len: length of Opaque PRF data to use in client.
  * @data: Opaque PRF data to use in client.
  *
@@ -222,7 +222,7 @@ mhd_gtls_oprfi_send_params (mhd_gtls_session_t session,
  * may de-allocate it immediately after calling this function.
  **/
 void
-MHD_gtls_oprfi_enable_client (mhd_gtls_session_t session,
+MHD_gtls_oprfi_enable_client (MHD_gtls_session_t session,
                               size_t len, unsigned char *data)
 {
   session->security_parameters.extensions.oprfi_client_len = len;
@@ -231,7 +231,7 @@ MHD_gtls_oprfi_enable_client (mhd_gtls_session_t session,
 
 /**
  * MHD_gtls_oprfi_enable_server:
- * @session: is a #mhd_gtls_session_t structure.
+ * @session: is a #MHD_gtls_session_t structure.
  * @cb: function pointer to Opaque PRF extension server callback.
  * @userdata: hook passed to callback function for passing application state.
  *
@@ -240,7 +240,7 @@ MHD_gtls_oprfi_enable_client (mhd_gtls_session_t session,
  * provided callback @cb will be invoked.  The callback must have the
  * following prototype:
  *
- * int callback (mhd_gtls_session_t session, void *userdata,
+ * int callback (MHD_gtls_session_t session, void *userdata,
  *               size_t oprfi_len, const unsigned char *in_oprfi,
  *               unsigned char *out_oprfi);
  *
@@ -250,8 +250,8 @@ MHD_gtls_oprfi_enable_client (mhd_gtls_session_t session,
  * handshake will be aborted.
  **/
 void
-MHD_gtls_oprfi_enable_server (mhd_gtls_session_t session,
-                              gnutls_oprfi_callback_func cb, void *userdata)
+MHD_gtls_oprfi_enable_server (MHD_gtls_session_t session,
+                              MHD_gnutls_oprfi_callback_func cb, void *userdata)
 {
   session->security_parameters.extensions.oprfi_cb = cb;
   session->security_parameters.extensions.oprfi_userdata = userdata;
diff --git a/src/daemon/https/tls/ext_oprfi.h b/src/daemon/https/tls/ext_oprfi.h
index defb672b..a3265499 100644
--- a/src/daemon/https/tls/ext_oprfi.h
+++ b/src/daemon/https/tls/ext_oprfi.h
@@ -24,8 +24,8 @@
 
 #include <gnutls_int.h>
 
-int mhd_gtls_oprfi_recv_params (mhd_gtls_session_t state,
+int MHD_gtls_oprfi_recv_params (MHD_gtls_session_t state,
                                 const opaque * data, size_t data_size);
 
-int mhd_gtls_oprfi_send_params (mhd_gtls_session_t state,
+int MHD_gtls_oprfi_send_params (MHD_gtls_session_t state,
                                 opaque * data, size_t data_size);
diff --git a/src/daemon/https/tls/ext_server_name.c b/src/daemon/https/tls/ext_server_name.c
index 64ef0b06..9878fe62 100644
--- a/src/daemon/https/tls/ext_server_name.c
+++ b/src/daemon/https/tls/ext_server_name.c
@@ -30,7 +30,7 @@
 
 /*
  * In case of a server: if a NAME_DNS extension type is received then it stores
- * into the session the value of NAME_DNS. The server may use gnutls_ext_get_server_name(),
+ * into the session the value of NAME_DNS. The server may use MHD_gnutls_ext_get_server_name(),
  * in order to access it.
  *
  * In case of a client: If a proper NAME_DNS extension type is found in the session then
@@ -39,7 +39,7 @@
  */
 
 int
-mhd_gtls_server_name_recv_params (mhd_gtls_session_t session,
+MHD_gtls_server_name_recv_params (MHD_gtls_session_t session,
                                   const opaque * data, size_t _data_size)
 {
   int i;
@@ -51,14 +51,14 @@ mhd_gtls_server_name_recv_params (mhd_gtls_session_t session,
   if (session->security_parameters.entity == GNUTLS_SERVER)
     {
       DECR_LENGTH_RET (data_size, 2, 0);
-      len = mhd_gtls_read_uint16 (data);
+      len = MHD_gtls_read_uint16 (data);
 
       if (len != data_size)
         {
           /* This is unexpected packet length, but
            * just ignore it, for now.
            */
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return 0;
         }
 
@@ -71,7 +71,7 @@ mhd_gtls_server_name_recv_params (mhd_gtls_session_t session,
           p++;
 
           DECR_LEN (data_size, 2);
-          len = mhd_gtls_read_uint16 (p);
+          len = MHD_gtls_read_uint16 (p);
           p += 2;
 
           DECR_LENGTH_RET (data_size, len, 0);
@@ -96,7 +96,7 @@ mhd_gtls_server_name_recv_params (mhd_gtls_session_t session,
           type = *p;
           p++;
 
-          len = mhd_gtls_read_uint16 (p);
+          len = MHD_gtls_read_uint16 (p);
           p += 2;
 
           switch (type)
@@ -124,7 +124,7 @@ mhd_gtls_server_name_recv_params (mhd_gtls_session_t session,
 /* returns data_size or a negative number on failure
  */
 int
-mhd_gtls_server_name_send_params (mhd_gtls_session_t session,
+MHD_gtls_server_name_send_params (MHD_gtls_session_t session,
                                   opaque * data, size_t _data_size)
 {
   int total_size = 0;
@@ -163,7 +163,7 @@ mhd_gtls_server_name_send_params (mhd_gtls_session_t session,
       /* UINT16: write total size of all names
        */
       DECR_LENGTH_RET (data_size, 2, GNUTLS_E_SHORT_MEMORY_BUFFER);
-      mhd_gtls_write_uint16 (total_size - 2, p);
+      MHD_gtls_write_uint16 (total_size - 2, p);
       p += 2;
 
       for (i = 0;
@@ -191,7 +191,7 @@ mhd_gtls_server_name_send_params (mhd_gtls_session_t session,
               *p = 0;           /* NAME_DNS type */
               p++;
 
-              mhd_gtls_write_uint16 (len, p);
+              MHD_gtls_write_uint16 (len, p);
               p += 2;
 
               memcpy (p,
@@ -200,7 +200,7 @@ mhd_gtls_server_name_send_params (mhd_gtls_session_t session,
               p += len;
               break;
             default:
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return GNUTLS_E_INTERNAL_ERROR;
             }
         }
@@ -210,8 +210,8 @@ mhd_gtls_server_name_send_params (mhd_gtls_session_t session,
 }
 
 /**
-  * MHD_gnutls_server_name_get - Used to get the server name indicator send by a client
-  * @session: is a #mhd_gtls_session_t structure.
+  * MHD__gnutls_server_name_get - Used to get the server name indicator send by a client
+  * @session: is a #MHD_gtls_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
@@ -219,7 +219,7 @@ mhd_gtls_server_name_send_params (mhd_gtls_session_t session,
   *
   * 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_t.
+  * MHD_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.
@@ -233,7 +233,7 @@ mhd_gtls_server_name_send_params (mhd_gtls_session_t session,
   *
   **/
 int
-MHD_gnutls_server_name_get (mhd_gtls_session_t session, void *data,
+MHD__gnutls_server_name_get (MHD_gtls_session_t session, void *data,
                             size_t * data_length,
                             unsigned int *type, unsigned int indx)
 {
@@ -241,7 +241,7 @@ MHD_gnutls_server_name_get (mhd_gtls_session_t session, void *data,
 #if MHD_DEBUG_TLS
   if (session->security_parameters.entity == GNUTLS_CLIENT)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 #endif
@@ -278,8 +278,8 @@ MHD_gnutls_server_name_get (mhd_gtls_session_t session, void *data,
 }
 
 /**
-  * MHD_gnutls_server_name_set - Used to set a name indicator to be sent as an extension
-  * @session: is a #mhd_gtls_session_t structure.
+  * MHD__gnutls_server_name_set - Used to set a name indicator to be sent as an extension
+  * @session: is a #MHD_gtls_session_t structure.
   * @type: specifies the indicator type
   * @name: is a string that contains the server name.
   * @name_length: holds the length of name
@@ -295,15 +295,15 @@ MHD_gnutls_server_name_get (mhd_gtls_session_t session, void *data,
   *
   **/
 int
-MHD_gnutls_server_name_set (mhd_gtls_session_t session,
-                            gnutls_server_name_type_t type,
+MHD__gnutls_server_name_set (MHD_gtls_session_t session,
+                            MHD_gnutls_server_name_type_t type,
                             const void *name, size_t name_length)
 {
   int server_names;
 
   if (session->security_parameters.entity == GNUTLS_SERVER)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
diff --git a/src/daemon/https/tls/ext_server_name.h b/src/daemon/https/tls/ext_server_name.h
index 5de9304f..f74ce191 100644
--- a/src/daemon/https/tls/ext_server_name.h
+++ b/src/daemon/https/tls/ext_server_name.h
@@ -22,7 +22,7 @@
  *
  */
 
-int mhd_gtls_server_name_recv_params (mhd_gtls_session_t session,
+int MHD_gtls_server_name_recv_params (MHD_gtls_session_t session,
                                       const opaque * data, size_t data_size);
-int mhd_gtls_server_name_send_params (mhd_gtls_session_t session,
+int MHD_gtls_server_name_send_params (MHD_gtls_session_t session,
                                       opaque * data, size_t);
diff --git a/src/daemon/https/tls/gnutls_alert.c b/src/daemon/https/tls/gnutls_alert.c
index 6a71aee3..b3ad303d 100644
--- a/src/daemon/https/tls/gnutls_alert.c
+++ b/src/daemon/https/tls/gnutls_alert.c
@@ -29,11 +29,11 @@
 
 typedef struct
 {
-  gnutls_alert_description_t alert;
+  MHD_gnutls_alert_description_t alert;
   const char *desc;
-} gnutls_alert_entry;
+} MHD_gnutls_alert_entry;
 
-static const gnutls_alert_entry mhd_gtls_sup_alerts[] = {
+static const MHD_gnutls_alert_entry MHD_gtls_sup_alerts[] = {
   {GNUTLS_A_CLOSE_NOTIFY, "Close notify"},
   {GNUTLS_A_UNEXPECTED_MESSAGE, "Unexpected message"},
   {GNUTLS_A_BAD_RECORD_MAC, "Bad record MAC"},
@@ -67,23 +67,23 @@ static const gnutls_alert_entry mhd_gtls_sup_alerts[] = {
 };
 
 #define GNUTLS_ALERT_LOOP(b) \
-        const gnutls_alert_entry *p; \
-                for(p = mhd_gtls_sup_alerts; p->desc != NULL; p++) { b ; }
+        const MHD_gnutls_alert_entry *p; \
+                for(p = MHD_gtls_sup_alerts; p->desc != NULL; p++) { b ; }
 
 #define GNUTLS_ALERT_ID_LOOP(a) \
                         GNUTLS_ALERT_LOOP( if(p->alert == alert) { a; break; })
 
 
 /**
-  * MHD_gnutls_alert_get_name - Returns a string describing the alert number given
-  * @alert: is an alert number #mhd_gtls_session_t structure.
+  * MHD__gnutls_alert_get_name - Returns a string describing the alert number given
+  * @alert: is an alert number #MHD_gtls_session_t structure.
   *
   * This function will return a string that describes the given alert
-  * number or NULL.  See gnutls_alert_get().
+  * number or NULL.  See MHD_gnutls_alert_get().
   *
   **/
 const char *
-MHD_gnutls_alert_get_name (gnutls_alert_description_t alert)
+MHD__gnutls_alert_get_name (MHD_gnutls_alert_description_t alert)
 {
   const char *ret = NULL;
 
@@ -93,8 +93,8 @@ MHD_gnutls_alert_get_name (gnutls_alert_description_t alert)
 }
 
 /**
-  * MHD_gnutls_alert_send - This function sends an alert message to the peer
-  * @session: is a #mhd_gtls_session_t structure.
+  * MHD__gnutls_alert_send - This function sends an alert message to the peer
+  * @session: is a #MHD_gtls_session_t structure.
   * @level: is the level of the alert
   * @desc: is the alert description
   *
@@ -110,8 +110,8 @@ MHD_gnutls_alert_get_name (gnutls_alert_description_t alert)
   *
   **/
 int
-MHD_gnutls_alert_send (mhd_gtls_session_t session, gnutls_alert_level_t level,
-                       gnutls_alert_description_t desc)
+MHD__gnutls_alert_send (MHD_gtls_session_t session, MHD_gnutls_alert_level_t level,
+                       MHD_gnutls_alert_description_t desc)
 {
   uint8_t data[2];
   int ret;
@@ -120,13 +120,13 @@ MHD_gnutls_alert_send (mhd_gtls_session_t session, gnutls_alert_level_t level,
   data[0] = (uint8_t) level;
   data[1] = (uint8_t) desc;
 
-  name = MHD_gnutls_alert_get_name ((int) data[1]);
+  name = MHD__gnutls_alert_get_name ((int) data[1]);
   if (name == NULL)
     name = "(unknown)";
-  _gnutls_record_log ("REC: Sending Alert[%d|%d] - %s\n", data[0],
+  MHD__gnutls_record_log ("REC: Sending Alert[%d|%d] - %s\n", data[0],
                       data[1], name);
 
-  if ((ret = mhd_gtls_send_int (session, GNUTLS_ALERT, -1, data, 2)) >= 0)
+  if ((ret = MHD_gtls_send_int (session, GNUTLS_ALERT, -1, data, 2)) >= 0)
     return 0;
   else
     return ret;
@@ -245,8 +245,8 @@ MHD_gtls_error_to_alert (int err, int *level)
 
 
 /**
- * MHD_gnutls_alert_send_appropriate - This function sends an alert to the peer depending on the error code
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD__gnutls_alert_send_appropriate - This function sends an alert to the peer depending on the error code
+ * @session: is a #MHD_gtls_session_t structure.
  * @err: is an integer
  *
  * Sends an alert to the peer depending on the error code returned by a gnutls
@@ -261,7 +261,7 @@ MHD_gtls_error_to_alert (int err, int *level)
  * Returns zero on success.
  */
 int
-MHD_gnutls_alert_send_appropriate (mhd_gtls_session_t session, int err)
+MHD__gnutls_alert_send_appropriate (MHD_gtls_session_t session, int err)
 {
   int alert;
   int level;
@@ -272,12 +272,12 @@ MHD_gnutls_alert_send_appropriate (mhd_gtls_session_t session, int err)
       return alert;
     }
 
-  return MHD_gnutls_alert_send (session, level, alert);
+  return MHD__gnutls_alert_send (session, level, alert);
 }
 
 /**
-  * gnutls_alert_get - Returns the last alert number received.
-  * @session: is a #mhd_gtls_session_t structure.
+  * MHD_gnutls_alert_get - Returns the last alert number received.
+  * @session: is a #MHD_gtls_session_t structure.
   *
   * This function will return the last alert number received. This
   * function should be called if GNUTLS_E_WARNING_ALERT_RECEIVED or
@@ -288,8 +288,8 @@ MHD_gnutls_alert_send_appropriate (mhd_gtls_session_t session, int err)
   * If no alert has been received the returned value is undefined.
   *
   **/
-gnutls_alert_description_t
-gnutls_alert_get (mhd_gtls_session_t session)
+MHD_gnutls_alert_description_t
+MHD_gnutls_alert_get (MHD_gtls_session_t session)
 {
   return session->internals.last_alert;
 }
diff --git a/src/daemon/https/tls/gnutls_algorithms.c b/src/daemon/https/tls/gnutls_algorithms.c
index c3daa08b..bef51b19 100644
--- a/src/daemon/https/tls/gnutls_algorithms.c
+++ b/src/daemon/https/tls/gnutls_algorithms.c
@@ -39,9 +39,9 @@ typedef struct
   enum MHD_GNUTLS_CredentialsType client_type;
   enum MHD_GNUTLS_CredentialsType server_type;  /* The type of credentials a server
                                                  * needs to set */
-} gnutls_cred_map;
+} MHD_gnutls_cred_map;
 
-static const gnutls_cred_map mhd_gtls_cred_mappings[] = {
+static const MHD_gnutls_cred_map MHD_gtls_cred_mappings[] = {
   {MHD_GNUTLS_KX_ANON_DH,
    MHD_GNUTLS_CRD_ANON,
    MHD_GNUTLS_CRD_ANON},
@@ -72,8 +72,8 @@ static const gnutls_cred_map mhd_gtls_cred_mappings[] = {
 };
 
 #define GNUTLS_KX_MAP_LOOP(b) \
-        const gnutls_cred_map *p; \
-                for(p = mhd_gtls_cred_mappings; p->algorithm != 0; p++) { b ; }
+        const MHD_gnutls_cred_map *p; \
+                for(p = MHD_gtls_cred_mappings; p->algorithm != 0; p++) { b ; }
 
 #define GNUTLS_KX_MAP_ALG_LOOP_SERVER(a) \
                         GNUTLS_KX_MAP_LOOP( if(p->server_type == type) { a; break; })
@@ -93,14 +93,14 @@ typedef struct
                                          * This is useful to certificate cipher suites, which check
                                          * against the certificate key usage bits.
                                          */
-} gnutls_pk_map;
+} MHD_gnutls_pk_map;
 
 /* This table maps the Key exchange algorithms to
  * the certificate algorithms. Eg. if we have
  * RSA algorithm in the certificate then we can
  * use GNUTLS_KX_RSA or GNUTLS_KX_DHE_RSA.
  */
-static const gnutls_pk_map mhd_gtls_pk_mappings[] = {
+static const MHD_gnutls_pk_map MHD_gtls_pk_mappings[] = {
   {MHD_GNUTLS_KX_RSA,
    MHD_GNUTLS_PK_RSA,
    CIPHER_ENCRYPT},
@@ -119,8 +119,8 @@ static const gnutls_pk_map mhd_gtls_pk_mappings[] = {
 };
 
 #define GNUTLS_PK_MAP_LOOP(b) \
-        const gnutls_pk_map *p; \
-                for(p = mhd_gtls_pk_mappings; p->kx_algorithm != 0; p++) { b }
+        const MHD_gnutls_pk_map *p; \
+                for(p = MHD_gtls_pk_mappings; p->kx_algorithm != 0; p++) { b }
 
 #define GNUTLS_PK_MAP_ALG_LOOP(a) \
                         GNUTLS_PK_MAP_LOOP( if(p->kx_algorithm == kx_algorithm) { a; break; })
@@ -134,9 +134,9 @@ typedef struct
   int major;                    /* defined by the protocol */
   int minor;                    /* defined by the protocol */
   int supported;                /* 0 not supported, > 0 is supported */
-} gnutls_version_entry;
+} MHD_gnutls_version_entry;
 
-static const gnutls_version_entry mhd_gtls_sup_versions[] = {
+static const MHD_gnutls_version_entry MHD_gtls_sup_versions[] = {
   {"SSL3.0",
    MHD_GNUTLS_PROTOCOL_SSL3,
    3,
@@ -165,7 +165,7 @@ static const gnutls_version_entry mhd_gtls_sup_versions[] = {
 };
 
 /* Keep the contents of this struct the same as the previous one. */
-static const enum MHD_GNUTLS_Protocol mhd_gtls_supported_protocols[] =
+static const enum MHD_GNUTLS_Protocol MHD_gtls_supported_protocols[] =
 { MHD_GNUTLS_PROTOCOL_SSL3,
   MHD_GNUTLS_PROTOCOL_TLS1_0,
   MHD_GNUTLS_PROTOCOL_TLS1_1,
@@ -174,13 +174,13 @@ static const enum MHD_GNUTLS_Protocol mhd_gtls_supported_protocols[] =
 };
 
 #define GNUTLS_VERSION_LOOP(b) \
-        const gnutls_version_entry *p; \
-                for(p = mhd_gtls_sup_versions; p->name != NULL; p++) { b ; }
+        const MHD_gnutls_version_entry *p; \
+                for(p = MHD_gtls_sup_versions; p->name != NULL; p++) { b ; }
 
 #define GNUTLS_VERSION_ALG_LOOP(a) \
                         GNUTLS_VERSION_LOOP( if(p->id == version) { a; break; })
 
-struct gnutls_cipher_entry
+struct MHD_gnutls_cipher_entry
 {
   const char *name;
   enum MHD_GNUTLS_CipherAlgorithm id;
@@ -190,14 +190,14 @@ struct gnutls_cipher_entry
   uint16_t iv;
   int export_flag;              /* 0 non export */
 };
-typedef struct gnutls_cipher_entry gnutls_cipher_entry;
+typedef struct MHD_gnutls_cipher_entry MHD_gnutls_cipher_entry;
 
 /* Note that all algorithms are in CBC or STREAM modes.
  * Do not add any algorithms in other modes (avoid modified algorithms).
  * View first: "The order of encryption and authentication for
  * protecting communications" by Hugo Krawczyk - CRYPTO 2001
  */
-static const gnutls_cipher_entry mhd_gtls_algorithms[] = {
+static const MHD_gnutls_cipher_entry MHD_gtls_algorithms[] = {
   {"AES-256-CBC",
    MHD_GNUTLS_CIPHER_AES_256_CBC,
    16,
@@ -272,7 +272,7 @@ static const gnutls_cipher_entry mhd_gtls_algorithms[] = {
 };
 
 /* Keep the contents of this struct the same as the previous one. */
-static const enum MHD_GNUTLS_CipherAlgorithm mhd_gtls_supported_ciphers[] =
+static const enum MHD_GNUTLS_CipherAlgorithm MHD_gtls_supported_ciphers[] =
 { MHD_GNUTLS_CIPHER_AES_256_CBC,
   MHD_GNUTLS_CIPHER_AES_128_CBC,
   MHD_GNUTLS_CIPHER_3DES_CBC,
@@ -289,22 +289,22 @@ static const enum MHD_GNUTLS_CipherAlgorithm mhd_gtls_supported_ciphers[] =
 };
 
 #define GNUTLS_LOOP(b) \
-        const gnutls_cipher_entry *p; \
-                for(p = mhd_gtls_algorithms; p->name != NULL; p++) { b ; }
+        const MHD_gnutls_cipher_entry *p; \
+                for(p = MHD_gtls_algorithms; p->name != NULL; p++) { b ; }
 
 #define GNUTLS_ALG_LOOP(a) \
                         GNUTLS_LOOP( if(p->id == algorithm) { a; break; } )
 
-struct gnutls_hash_entry
+struct MHD_gnutls_hash_entry
 {
   const char *name;
   const char *oid;
   enum MHD_GNUTLS_HashAlgorithm id;
   size_t key_size;              /* in case of mac */
 };
-typedef struct gnutls_hash_entry gnutls_hash_entry;
+typedef struct MHD_gnutls_hash_entry MHD_gnutls_hash_entry;
 
-static const gnutls_hash_entry mhd_gtls_hash_algorithms[] = {
+static const MHD_gnutls_hash_entry MHD_gtls_hash_algorithms[] = {
   {"SHA1",
    HASH_OID_SHA1,
    MHD_GNUTLS_MAC_SHA1,
@@ -328,7 +328,7 @@ static const gnutls_hash_entry mhd_gtls_hash_algorithms[] = {
 };
 
 /* Keep the contents of this struct the same as the previous one. */
-static const enum MHD_GNUTLS_HashAlgorithm mhd_gtls_supported_macs[] =
+static const enum MHD_GNUTLS_HashAlgorithm MHD_gtls_supported_macs[] =
 { MHD_GNUTLS_MAC_SHA1,
   MHD_GNUTLS_MAC_MD5,
   MHD_GNUTLS_MAC_SHA256,
@@ -337,8 +337,8 @@ static const enum MHD_GNUTLS_HashAlgorithm mhd_gtls_supported_macs[] =
 };
 
 #define GNUTLS_HASH_LOOP(b) \
-        const gnutls_hash_entry *p; \
-                for(p = mhd_gtls_hash_algorithms; p->name != NULL; p++) { b ; }
+        const MHD_gnutls_hash_entry *p; \
+                for(p = MHD_gtls_hash_algorithms; p->name != NULL; p++) { b ; }
 
 #define GNUTLS_HASH_ALG_LOOP(a) \
                         GNUTLS_HASH_LOOP( if(p->id == algorithm) { a; break; } )
@@ -348,11 +348,11 @@ static const enum MHD_GNUTLS_HashAlgorithm mhd_gtls_supported_macs[] =
         { #name, name, id, wb, ml, cl}
 
 #define MAX_COMP_METHODS 5
-const int _gnutls_comp_algorithms_size = MAX_COMP_METHODS;
+const int MHD__gnutls_comp_algorithms_size = MAX_COMP_METHODS;
 
-/* the compression entry is defined in gnutls_algorithms.h */
+/* the compression entry is defined in MHD_gnutls_algorithms.h */
 
-gnutls_compression_entry _gnutls_compression_algorithms[MAX_COMP_METHODS] =
+MHD_gnutls_compression_entry MHD__gnutls_compression_algorithms[MAX_COMP_METHODS] =
   { GNUTLS_COMPRESSION_ENTRY (MHD_GNUTLS_COMP_NULL, 0x00, 0, 0, 0),
 #ifdef HAVE_LIBZ
   /* draft-ietf-tls-compression-02 */
@@ -367,7 +367,7 @@ gnutls_compression_entry _gnutls_compression_algorithms[MAX_COMP_METHODS] =
 };
 
 static const enum MHD_GNUTLS_CompressionMethod
-  mhd_gtls_supported_compressions[] =
+  MHD_gtls_supported_compressions[] =
 {
 #ifdef HAVE_LIBZ
   MHD_GNUTLS_COMP_DEFLATE,
@@ -377,41 +377,41 @@ static const enum MHD_GNUTLS_CompressionMethod
 };
 
 #define GNUTLS_COMPRESSION_LOOP(b) \
-        const gnutls_compression_entry *p; \
-                for(p = _gnutls_compression_algorithms; p->name != NULL; p++) { b ; }
+        const MHD_gnutls_compression_entry *p; \
+                for(p = MHD__gnutls_compression_algorithms; p->name != NULL; p++) { b ; }
 #define GNUTLS_COMPRESSION_ALG_LOOP(a) \
                         GNUTLS_COMPRESSION_LOOP( if(p->id == algorithm) { a; break; } )
 #define GNUTLS_COMPRESSION_ALG_LOOP_NUM(a) \
                         GNUTLS_COMPRESSION_LOOP( if(p->num == num) { a; break; } )
 
 /* Key Exchange Section */
-extern mhd_gtls_mod_auth_st mhd_gtls_rsa_auth_struct;
-extern mhd_gtls_mod_auth_st rsa_export_auth_struct;
-extern mhd_gtls_mod_auth_st mhd_gtls_dhe_rsa_auth_struct;
-extern mhd_gtls_mod_auth_st mhd_gtls_dhe_dss_auth_struct;
-extern mhd_gtls_mod_auth_st mhd_gtls_anon_auth_struct;
-extern mhd_gtls_mod_auth_st srp_auth_struct;
-extern mhd_gtls_mod_auth_st psk_auth_struct;
-extern mhd_gtls_mod_auth_st dhe_psk_auth_struct;
-extern mhd_gtls_mod_auth_st srp_rsa_auth_struct;
-extern mhd_gtls_mod_auth_st srp_dss_auth_struct;
-
-typedef struct mhd_gtls_kx_algo_entry
+extern MHD_gtls_mod_auth_st MHD_gtls_rsa_auth_struct;
+extern MHD_gtls_mod_auth_st rsa_export_auth_struct;
+extern MHD_gtls_mod_auth_st MHD_gtls_dhe_rsa_auth_struct;
+extern MHD_gtls_mod_auth_st MHD_gtls_dhe_dss_auth_struct;
+extern MHD_gtls_mod_auth_st MHD_gtls_anon_auth_struct;
+extern MHD_gtls_mod_auth_st srp_auth_struct;
+extern MHD_gtls_mod_auth_st psk_auth_struct;
+extern MHD_gtls_mod_auth_st dhe_psk_auth_struct;
+extern MHD_gtls_mod_auth_st srp_rsa_auth_struct;
+extern MHD_gtls_mod_auth_st srp_dss_auth_struct;
+
+typedef struct MHD_gtls_kx_algo_entry
 {
   const char *name;
   enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm;
-  mhd_gtls_mod_auth_st *auth_struct;
+  MHD_gtls_mod_auth_st *auth_struct;
   int needs_dh_params;
   int needs_rsa_params;
-} mhd_gtls_kx_algo_entry_t;
+} MHD_gtls_kx_algo_entry_t;
 
-static const mhd_gtls_kx_algo_entry_t mhd_gtls_kx_algorithms[] = {
+static const MHD_gtls_kx_algo_entry_t MHD_gtls_kx_algorithms[] = {
 #ifdef ENABLE_ANON
-  {"ANON-DH", MHD_GNUTLS_KX_ANON_DH, &mhd_gtls_anon_auth_struct, 1, 0},
+  {"ANON-DH", MHD_GNUTLS_KX_ANON_DH, &MHD_gtls_anon_auth_struct, 1, 0},
 #endif
   {"RSA",
    MHD_GNUTLS_KX_RSA,
-   &mhd_gtls_rsa_auth_struct,
+   &MHD_gtls_rsa_auth_struct,
    0,
    0},
   {"RSA-EXPORT",
@@ -421,12 +421,12 @@ static const mhd_gtls_kx_algo_entry_t mhd_gtls_kx_algorithms[] = {
    1 /* needs RSA params */ },
   {"DHE-RSA",
    MHD_GNUTLS_KX_DHE_RSA,
-   &mhd_gtls_dhe_rsa_auth_struct,
+   &MHD_gtls_dhe_rsa_auth_struct,
    1,
    0},
   {"DHE-DSS",
    MHD_GNUTLS_KX_DHE_DSS,
-   &mhd_gtls_dhe_dss_auth_struct,
+   &MHD_gtls_dhe_dss_auth_struct,
    1,
    0},
 
@@ -448,7 +448,7 @@ static const mhd_gtls_kx_algo_entry_t mhd_gtls_kx_algorithms[] = {
 };
 
 /* Keep the contents of this struct the same as the previous one. */
-static const enum MHD_GNUTLS_KeyExchangeAlgorithm mhd_gtls_supported_kxs[] =
+static const enum MHD_GNUTLS_KeyExchangeAlgorithm MHD_gtls_supported_kxs[] =
 {
 #ifdef ENABLE_ANON
   MHD_GNUTLS_KX_ANON_DH,
@@ -470,8 +470,8 @@ static const enum MHD_GNUTLS_KeyExchangeAlgorithm mhd_gtls_supported_kxs[] =
 };
 
 #define GNUTLS_KX_LOOP(b) \
-        const mhd_gtls_kx_algo_entry_t *p; \
-                for(p = mhd_gtls_kx_algorithms; p->name != NULL; p++) { b ; }
+        const MHD_gtls_kx_algo_entry_t *p; \
+                for(p = MHD_gtls_kx_algorithms; p->name != NULL; p++) { b ; }
 
 #define GNUTLS_KX_ALG_LOOP(a) \
                         GNUTLS_KX_LOOP( if(p->algorithm == algorithm) { a; break; } )
@@ -490,7 +490,7 @@ typedef struct
   enum MHD_GNUTLS_Protocol version;     /* this cipher suite is supported
                                          * from 'version' and above;
                                          */
-} mhd_gtls_cipher_suite_entry;
+} MHD_gtls_cipher_suite_entry;
 
 /* RSA with NULL cipher and MD5 MAC
  * for test purposes.
@@ -586,9 +586,9 @@ typedef struct
 #define GNUTLS_DHE_RSA_CAMELLIA_128_CBC_SHA1 { 0x00,0x45 }
 #define GNUTLS_DHE_RSA_CAMELLIA_256_CBC_SHA1 { 0x00,0x88 }
 
-#define CIPHER_SUITES_COUNT sizeof(mhd_gtls_cs_algorithms)/sizeof(mhd_gtls_cipher_suite_entry)-1
+#define CIPHER_SUITES_COUNT sizeof(MHD_gtls_cs_algorithms)/sizeof(MHD_gtls_cipher_suite_entry)-1
 
-static const mhd_gtls_cipher_suite_entry mhd_gtls_cs_algorithms[] = {
+static const MHD_gtls_cipher_suite_entry MHD_gtls_cs_algorithms[] = {
   /* ANON_DH */
   GNUTLS_CIPHER_SUITE_ENTRY (GNUTLS_ANON_DH_ARCFOUR_MD5,
                              MHD_GNUTLS_CIPHER_ARCFOUR_128,
@@ -758,8 +758,8 @@ static const mhd_gtls_cipher_suite_entry mhd_gtls_cs_algorithms[] = {
 };
 
 #define GNUTLS_CIPHER_SUITE_LOOP(b) \
-        const mhd_gtls_cipher_suite_entry *p; \
-                for(p = mhd_gtls_cs_algorithms; p->name != NULL; p++) { b ; }
+        const MHD_gtls_cipher_suite_entry *p; \
+                for(p = MHD_gtls_cs_algorithms; p->name != NULL; p++) { b ; }
 
 #define GNUTLS_CIPHER_SUITE_ALG_LOOP(a) \
                         GNUTLS_CIPHER_SUITE_LOOP( if( (p->id.suite[0] == suite->suite[0]) && (p->id.suite[1] == suite->suite[1])) { a; break; } )
@@ -767,7 +767,7 @@ static const mhd_gtls_cipher_suite_entry mhd_gtls_cs_algorithms[] = {
 /* Generic Functions */
 
 int
-mhd_gtls_mac_priority (mhd_gtls_session_t session,
+MHD_gtls_mac_priority (MHD_gtls_session_t session,
                        enum MHD_GNUTLS_HashAlgorithm algorithm)
 {                               /* actually returns the priority */
   unsigned int i;
@@ -780,14 +780,14 @@ mhd_gtls_mac_priority (mhd_gtls_session_t session,
 }
 
 /**
- * MHD_gnutls_mac_get_name - Returns a string with the name of the specified mac algorithm
+ * MHD__gnutls_mac_get_name - Returns a string with the name of the specified mac algorithm
  * @algorithm: is a MAC algorithm
  *
  * Returns: a string that contains the name of the specified MAC
  * algorithm, or %NULL.
  **/
 const char *
-MHD_gnutls_mac_get_name (enum MHD_GNUTLS_HashAlgorithm algorithm)
+MHD__gnutls_mac_get_name (enum MHD_GNUTLS_HashAlgorithm algorithm)
 {
   const char *ret = NULL;
 
@@ -817,7 +817,7 @@ MHD_gtls_mac_get_id (const char *name)
 }
 
 /**
- * MHD_gnutls_mac_get_key_size - Returns the length of the MAC's key size
+ * MHD__gnutls_mac_get_key_size - Returns the length of the MAC's key size
  * @algorithm: is an encryption algorithm
  *
  * Returns: length (in bytes) of the given MAC key size, or 0 if the
@@ -825,7 +825,7 @@ MHD_gtls_mac_get_id (const char *name)
  *
  **/
 size_t
-MHD_gnutls_mac_get_key_size (enum MHD_GNUTLS_HashAlgorithm algorithm)
+MHD__gnutls_mac_get_key_size (enum MHD_GNUTLS_HashAlgorithm algorithm)
 {
   size_t ret = 0;
 
@@ -849,11 +849,11 @@ MHD_gnutls_mac_get_key_size (enum MHD_GNUTLS_HashAlgorithm algorithm)
 const enum MHD_GNUTLS_HashAlgorithm *
 MHD_gtls_mac_list (void)
 {
-  return mhd_gtls_supported_macs;
+  return MHD_gtls_supported_macs;
 }
 
 const char *
-mhd_gtls_x509_mac_to_oid (enum MHD_GNUTLS_HashAlgorithm algorithm)
+MHD_gtls_x509_mac_to_oid (enum MHD_GNUTLS_HashAlgorithm algorithm)
 {
   const char *ret = NULL;
 
@@ -864,7 +864,7 @@ mhd_gtls_x509_mac_to_oid (enum MHD_GNUTLS_HashAlgorithm algorithm)
 }
 
 enum MHD_GNUTLS_HashAlgorithm
-mhd_gtls_x509_oid2mac_algorithm (const char *oid)
+MHD_gtls_x509_oid2mac_algorithm (const char *oid)
 {
   enum MHD_GNUTLS_HashAlgorithm ret = 0;
 
@@ -880,7 +880,7 @@ mhd_gtls_x509_oid2mac_algorithm (const char *oid)
 }
 
 int
-mhd_gnutls_mac_is_ok (enum MHD_GNUTLS_HashAlgorithm algorithm)
+MHD_gnutls_mac_is_ok (enum MHD_GNUTLS_HashAlgorithm algorithm)
 {
   ssize_t ret = -1;
   GNUTLS_HASH_ALG_LOOP (ret = p->id);
@@ -893,7 +893,7 @@ mhd_gnutls_mac_is_ok (enum MHD_GNUTLS_HashAlgorithm algorithm)
 
 /* Compression Functions */
 int
-mhd_gtls_compression_priority (mhd_gtls_session_t session,
+MHD_gtls_compression_priority (MHD_gtls_session_t session,
                                enum MHD_GNUTLS_CompressionMethod algorithm)
 {                               /* actually returns the priority */
   unsigned int i;
@@ -907,7 +907,7 @@ mhd_gtls_compression_priority (mhd_gtls_session_t session,
 }
 
 /**
- * MHD_gnutls_compression_get_name - Returns a string with the name of the specified compression algorithm
+ * MHD__gnutls_compression_get_name - Returns a string with the name of the specified compression algorithm
  * @algorithm: is a Compression algorithm
  *
  * Returns: a pointer to a string that contains the name of the
@@ -953,7 +953,7 @@ MHD_gtls_compression_get_id (const char *name)
  *
  * Get a list of compression methods.  Note that to be able to use LZO
  * compression, you must link to libgnutls-extra and call
- * gnutls_global_init_extra().
+ * MHD_gnutls_global_init_extra().
  *
  * Returns: a zero-terminated list of %enum MHD_GNUTLS_CompressionMethod
  * integers indicating the available compression methods.
@@ -961,12 +961,12 @@ MHD_gtls_compression_get_id (const char *name)
 const enum MHD_GNUTLS_CompressionMethod *
 MHD_gtls_compression_list (void)
 {
-  return mhd_gtls_supported_compressions;
+  return MHD_gtls_supported_compressions;
 }
 
 /* return the tls number of the specified algorithm */
 int
-mhd_gtls_compression_get_num (enum MHD_GNUTLS_CompressionMethod algorithm)
+MHD_gtls_compression_get_num (enum MHD_GNUTLS_CompressionMethod algorithm)
 {
   int ret = -1;
 
@@ -977,7 +977,7 @@ mhd_gtls_compression_get_num (enum MHD_GNUTLS_CompressionMethod algorithm)
 }
 
 int
-mhd_gtls_compression_get_wbits (enum MHD_GNUTLS_CompressionMethod algorithm)
+MHD_gtls_compression_get_wbits (enum MHD_GNUTLS_CompressionMethod algorithm)
 {
   int ret = -1;
   /* avoid prefix */
@@ -986,7 +986,7 @@ mhd_gtls_compression_get_wbits (enum MHD_GNUTLS_CompressionMethod algorithm)
 }
 
 int
-mhd_gtls_compression_get_mem_level (enum MHD_GNUTLS_CompressionMethod
+MHD_gtls_compression_get_mem_level (enum MHD_GNUTLS_CompressionMethod
                                     algorithm)
 {
   int ret = -1;
@@ -996,7 +996,7 @@ mhd_gtls_compression_get_mem_level (enum MHD_GNUTLS_CompressionMethod
 }
 
 int
-mhd_gtls_compression_get_comp_level (enum MHD_GNUTLS_CompressionMethod
+MHD_gtls_compression_get_comp_level (enum MHD_GNUTLS_CompressionMethod
                                      algorithm)
 {
   int ret = -1;
@@ -1009,7 +1009,7 @@ mhd_gtls_compression_get_comp_level (enum MHD_GNUTLS_CompressionMethod
  * method num
  */
 enum MHD_GNUTLS_CompressionMethod
-mhd_gtls_compression_get_id (int num)
+MHD_gtls_compression_get_id_from_int (int num)
 {
   enum MHD_GNUTLS_CompressionMethod ret = -1;
 
@@ -1020,7 +1020,7 @@ mhd_gtls_compression_get_id (int num)
 }
 
 int
-mhd_gtls_compression_is_ok (enum MHD_GNUTLS_CompressionMethod algorithm)
+MHD_gtls_compression_is_ok (enum MHD_GNUTLS_CompressionMethod algorithm)
 {
   ssize_t ret = -1;
   GNUTLS_COMPRESSION_ALG_LOOP (ret = p->id);
@@ -1033,7 +1033,7 @@ mhd_gtls_compression_is_ok (enum MHD_GNUTLS_CompressionMethod algorithm)
 
 /* CIPHER functions */
 int
-mhd_gtls_cipher_get_block_size (enum MHD_GNUTLS_CipherAlgorithm algorithm)
+MHD_gtls_cipher_get_block_size (enum MHD_GNUTLS_CipherAlgorithm algorithm)
 {
   size_t ret = 0;
   GNUTLS_ALG_LOOP (ret = p->blocksize);
@@ -1043,7 +1043,7 @@ mhd_gtls_cipher_get_block_size (enum MHD_GNUTLS_CipherAlgorithm algorithm)
 
 /* returns the priority */
 int
-mhd_gtls_cipher_priority (mhd_gtls_session_t session,
+MHD_gtls_cipher_priority (MHD_gtls_session_t session,
                           enum MHD_GNUTLS_CipherAlgorithm algorithm)
 {
   unsigned int i;
@@ -1056,7 +1056,7 @@ mhd_gtls_cipher_priority (mhd_gtls_session_t session,
 }
 
 int
-mhd_gtls_cipher_is_block (enum MHD_GNUTLS_CipherAlgorithm algorithm)
+MHD_gtls_cipher_is_block (enum MHD_GNUTLS_CipherAlgorithm algorithm)
 {
   size_t ret = 0;
 
@@ -1066,14 +1066,14 @@ mhd_gtls_cipher_is_block (enum MHD_GNUTLS_CipherAlgorithm algorithm)
 }
 
 /**
- * MHD_gnutls_cipher_get_key_size - Returns the length of the cipher's key size
+ * MHD__gnutls_cipher_get_key_size - Returns the length of the cipher's key size
  * @algorithm: is an encryption algorithm
  *
  * Returns: length (in bytes) of the given cipher's key size, o 0 if
  *   the given cipher is invalid.
  **/
 size_t
-MHD_gnutls_cipher_get_key_size (enum MHD_GNUTLS_CipherAlgorithm algorithm)
+MHD__gnutls_cipher_get_key_size (enum MHD_GNUTLS_CipherAlgorithm algorithm)
 {                               /* In bytes */
   size_t ret = 0;
   GNUTLS_ALG_LOOP (ret = p->keysize);
@@ -1082,7 +1082,7 @@ MHD_gnutls_cipher_get_key_size (enum MHD_GNUTLS_CipherAlgorithm algorithm)
 }
 
 int
-mhd_gtls_cipher_get_iv_size (enum MHD_GNUTLS_CipherAlgorithm algorithm)
+MHD_gtls_cipher_get_iv_size (enum MHD_GNUTLS_CipherAlgorithm algorithm)
 {                               /* In bytes */
   size_t ret = 0;
   GNUTLS_ALG_LOOP (ret = p->iv);
@@ -1091,7 +1091,7 @@ mhd_gtls_cipher_get_iv_size (enum MHD_GNUTLS_CipherAlgorithm algorithm)
 }
 
 int
-mhd_gtls_cipher_get_export_flag (enum MHD_GNUTLS_CipherAlgorithm algorithm)
+MHD_gtls_cipher_get_export_flag (enum MHD_GNUTLS_CipherAlgorithm algorithm)
 {                               /* In bytes */
   size_t ret = 0;
   GNUTLS_ALG_LOOP (ret = p->export_flag);
@@ -1100,14 +1100,14 @@ mhd_gtls_cipher_get_export_flag (enum MHD_GNUTLS_CipherAlgorithm algorithm)
 }
 
 /**
- * MHD_gnutls_cipher_get_name - Returns a string with the name of the specified cipher algorithm
+ * MHD__gnutls_cipher_get_name - Returns a string with the name of the specified cipher algorithm
  * @algorithm: is an encryption algorithm
  *
  * Returns: a pointer to a string that contains the name of the
  *   specified cipher, or %NULL.
  **/
 const char *
-MHD_gnutls_cipher_get_name (enum MHD_GNUTLS_CipherAlgorithm algorithm)
+MHD__gnutls_cipher_get_name (enum MHD_GNUTLS_CipherAlgorithm algorithm)
 {
   const char *ret = NULL;
 
@@ -1153,11 +1153,11 @@ MHD_gtls_cipher_get_id (const char *name)
 const enum MHD_GNUTLS_CipherAlgorithm *
 MHD_gtls_cipher_list (void)
 {
-  return mhd_gtls_supported_ciphers;
+  return MHD_gtls_supported_ciphers;
 }
 
 int
-mhd_gtls_cipher_is_ok (enum MHD_GNUTLS_CipherAlgorithm algorithm)
+MHD_gtls_cipher_is_ok (enum MHD_GNUTLS_CipherAlgorithm algorithm)
 {
   ssize_t ret = -1;
   GNUTLS_ALG_LOOP (ret = p->id);
@@ -1169,17 +1169,17 @@ mhd_gtls_cipher_is_ok (enum MHD_GNUTLS_CipherAlgorithm algorithm)
 }
 
 /* Key EXCHANGE functions */
-mhd_gtls_mod_auth_st *
-mhd_gtls_kx_auth_struct (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
+MHD_gtls_mod_auth_st *
+MHD_gtls_kx_auth_struct (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
 {
-  mhd_gtls_mod_auth_st *ret = NULL;
+  MHD_gtls_mod_auth_st *ret = NULL;
   GNUTLS_KX_ALG_LOOP (ret = p->auth_struct);
   return ret;
 
 }
 
 int
-mhd_gtls_kx_priority (mhd_gtls_session_t session,
+MHD_gtls_kx_priority (MHD_gtls_session_t session,
                       enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
 {
   unsigned int i;
@@ -1192,14 +1192,14 @@ mhd_gtls_kx_priority (mhd_gtls_session_t session,
 }
 
 /**
- * MHD_gnutls_kx_get_name - Returns a string with the name of the specified key exchange algorithm
+ * MHD__gnutls_kx_get_name - Returns a string with the name of the specified key exchange algorithm
  * @algorithm: is a key exchange algorithm
  *
  * Returns: a pointer to a string that contains the name of the
  * specified key exchange algorithm, or %NULL.
  **/
 const char *
-MHD_gnutls_kx_get_name (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
+MHD__gnutls_kx_get_name (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
 {
   const char *ret = NULL;
 
@@ -1240,11 +1240,11 @@ MHD_gtls_kx_get_id (const char *name)
 const enum MHD_GNUTLS_KeyExchangeAlgorithm *
 MHD_gtls_kx_list (void)
 {
-  return mhd_gtls_supported_kxs;
+  return MHD_gtls_supported_kxs;
 }
 
 int
-mhd_gtls_kx_is_ok (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
+MHD_gtls_kx_is_ok (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
 {
   ssize_t ret = -1;
   GNUTLS_KX_ALG_LOOP (ret = p->algorithm);
@@ -1256,7 +1256,7 @@ mhd_gtls_kx_is_ok (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
 }
 
 int
-mhd_gtls_kx_needs_rsa_params (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
+MHD_gtls_kx_needs_rsa_params (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
 {
   ssize_t ret = 0;
   GNUTLS_KX_ALG_LOOP (ret = p->needs_rsa_params);
@@ -1264,7 +1264,7 @@ mhd_gtls_kx_needs_rsa_params (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
 }
 
 int
-mhd_gtls_kx_needs_dh_params (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
+MHD_gtls_kx_needs_dh_params (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
 {
   ssize_t ret = 0;
   GNUTLS_KX_ALG_LOOP (ret = p->needs_dh_params);
@@ -1273,14 +1273,14 @@ mhd_gtls_kx_needs_dh_params (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm)
 
 /* Version */
 int
-mhd_gtls_version_priority (mhd_gtls_session_t session,
+MHD_gtls_version_priority (MHD_gtls_session_t session,
                            enum MHD_GNUTLS_Protocol version)
 {                               /* actually returns the priority */
   unsigned int i;
 
   if (session->internals.priorities.protocol.priority == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return -1;
     }
 
@@ -1293,7 +1293,7 @@ mhd_gtls_version_priority (mhd_gtls_session_t session,
 }
 
 enum MHD_GNUTLS_Protocol
-mhd_gtls_version_lowest (mhd_gtls_session_t session)
+MHD_gtls_version_lowest (MHD_gtls_session_t session)
 {                               /* returns the lowest version supported */
   unsigned int i, min = 0xff;
 
@@ -1316,7 +1316,7 @@ mhd_gtls_version_lowest (mhd_gtls_session_t session)
 }
 
 enum MHD_GNUTLS_Protocol
-mhd_gtls_version_max (mhd_gtls_session_t session)
+MHD_gtls_version_max (MHD_gtls_session_t session)
 {                               /* returns the maximum version supported */
   unsigned int i, max = 0x00;
 
@@ -1339,14 +1339,14 @@ mhd_gtls_version_max (mhd_gtls_session_t session)
 }
 
 /**
- * MHD_gnutls_protocol_get_name - Returns a string with the name of the specified SSL/TLS version
+ * MHD__gnutls_protocol_get_name - Returns a string with the name of the specified SSL/TLS version
  * @version: is a (gnutls) version number
  *
  * Returns: a string that contains the name of the specified TLS
  * version (e.g., "TLS 1.0"), or %NULL.
  **/
 const char *
-MHD_gnutls_protocol_get_name (enum MHD_GNUTLS_Protocol version)
+MHD__gnutls_protocol_get_name (enum MHD_GNUTLS_Protocol version)
 {
   const char *ret = NULL;
 
@@ -1387,11 +1387,11 @@ MHD_gtls_protocol_get_id (const char *name)
 const enum MHD_GNUTLS_Protocol *
 MHD_gtls_protocol_list (void)
 {
-  return mhd_gtls_supported_protocols;
+  return MHD_gtls_supported_protocols;
 }
 
 int
-mhd_gtls_version_get_minor (enum MHD_GNUTLS_Protocol version)
+MHD_gtls_version_get_minor (enum MHD_GNUTLS_Protocol version)
 {
   int ret = -1;
 
@@ -1400,7 +1400,7 @@ mhd_gtls_version_get_minor (enum MHD_GNUTLS_Protocol version)
 }
 
 enum MHD_GNUTLS_Protocol
-mhd_gtls_version_get (int major, int minor)
+MHD_gtls_version_get (int major, int minor)
 {
   int ret = -1;
 
@@ -1411,7 +1411,7 @@ mhd_gtls_version_get (int major, int minor)
 }
 
 int
-mhd_gtls_version_get_major (enum MHD_GNUTLS_Protocol version)
+MHD_gtls_version_get_major (enum MHD_GNUTLS_Protocol version)
 {
   int ret = -1;
 
@@ -1422,7 +1422,7 @@ mhd_gtls_version_get_major (enum MHD_GNUTLS_Protocol version)
 /* Version Functions */
 
 int
-mhd_gtls_version_is_supported (mhd_gtls_session_t session,
+MHD_gtls_version_is_supported (MHD_gtls_session_t session,
                                const enum MHD_GNUTLS_Protocol version)
 {
   int ret = 0;
@@ -1431,7 +1431,7 @@ mhd_gtls_version_is_supported (mhd_gtls_session_t session,
   if (ret == 0)
     return 0;
 
-  if (mhd_gtls_version_priority (session, version) < 0)
+  if (MHD_gtls_version_priority (session, version) < 0)
     return 0;                   /* disabled by the user */
   else
     return 1;
@@ -1439,7 +1439,7 @@ mhd_gtls_version_is_supported (mhd_gtls_session_t session,
 
 /* Type to KX mappings */
 enum MHD_GNUTLS_KeyExchangeAlgorithm
-mhd_gtls_map_kx_get_kx (enum MHD_GNUTLS_CredentialsType type, int server)
+MHD_gtls_map_kx_get_kx (enum MHD_GNUTLS_CredentialsType type, int server)
 {
   enum MHD_GNUTLS_KeyExchangeAlgorithm ret = -1;
 
@@ -1455,7 +1455,7 @@ mhd_gtls_map_kx_get_kx (enum MHD_GNUTLS_CredentialsType type, int server)
 }
 
 enum MHD_GNUTLS_CredentialsType
-mhd_gtls_map_kx_get_cred (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm,
+MHD_gtls_map_kx_get_cred (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm,
                           int server)
 {
   enum MHD_GNUTLS_CredentialsType ret = -1;
@@ -1475,7 +1475,7 @@ mhd_gtls_map_kx_get_cred (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm,
 
 /* Cipher Suite's functions */
 enum MHD_GNUTLS_CipherAlgorithm
-mhd_gtls_cipher_suite_get_cipher_algo (const cipher_suite_st * suite)
+MHD_gtls_cipher_suite_get_cipher_algo (const cipher_suite_st * suite)
 {
   int ret = 0;
   GNUTLS_CIPHER_SUITE_ALG_LOOP (ret = p->block_algorithm);
@@ -1483,7 +1483,7 @@ mhd_gtls_cipher_suite_get_cipher_algo (const cipher_suite_st * suite)
 }
 
 enum MHD_GNUTLS_Protocol
-mhd_gtls_cipher_suite_get_version (const cipher_suite_st * suite)
+MHD_gtls_cipher_suite_get_version (const cipher_suite_st * suite)
 {
   int ret = 0;
   GNUTLS_CIPHER_SUITE_ALG_LOOP (ret = p->version);
@@ -1491,7 +1491,7 @@ mhd_gtls_cipher_suite_get_version (const cipher_suite_st * suite)
 }
 
 enum MHD_GNUTLS_KeyExchangeAlgorithm
-mhd_gtls_cipher_suite_get_kx_algo (const cipher_suite_st * suite)
+MHD_gtls_cipher_suite_get_kx_algo (const cipher_suite_st * suite)
 {
   int ret = 0;
 
@@ -1501,7 +1501,7 @@ mhd_gtls_cipher_suite_get_kx_algo (const cipher_suite_st * suite)
 }
 
 enum MHD_GNUTLS_HashAlgorithm
-mhd_gtls_cipher_suite_get_mac_algo (const cipher_suite_st * suite)
+MHD_gtls_cipher_suite_get_mac_algo (const cipher_suite_st * suite)
 {                               /* In bytes */
   int ret = 0;
   GNUTLS_CIPHER_SUITE_ALG_LOOP (ret = p->mac_algorithm);
@@ -1510,7 +1510,7 @@ mhd_gtls_cipher_suite_get_mac_algo (const cipher_suite_st * suite)
 }
 
 const char *
-mhd_gtls_cipher_suite_get_name (cipher_suite_st * suite)
+MHD_gtls_cipher_suite_get_name (cipher_suite_st * suite)
 {
   const char *ret = NULL;
 
@@ -1521,7 +1521,7 @@ mhd_gtls_cipher_suite_get_name (cipher_suite_st * suite)
 }
 
 static inline int
-_gnutls_cipher_suite_is_ok (cipher_suite_st * suite)
+MHD__gnutls_cipher_suite_is_ok (cipher_suite_st * suite)
 {
   size_t ret;
   const char *name = NULL;
@@ -1541,11 +1541,11 @@ _gnutls_cipher_suite_is_ok (cipher_suite_st * suite)
 
 #define MAX_ELEM_SIZE 4
 static inline int
-_gnutls_partition (mhd_gtls_session_t session,
+MHD__gnutls_partition (MHD_gtls_session_t session,
                    void *_base,
                    size_t nmemb,
                    size_t size,
-                   int (*compar) (mhd_gtls_session_t,
+                   int (*compar) (MHD_gtls_session_t,
                                   const void *, const void *))
 {
   uint8_t *base = _base;
@@ -1589,11 +1589,11 @@ _gnutls_partition (mhd_gtls_session_t session,
 }
 
 static void
-_gnutls_qsort (mhd_gtls_session_t session,
+MHD__gnutls_qsort (MHD_gtls_session_t session,
                void *_base,
                size_t nmemb,
                size_t size,
-               int (*compar) (mhd_gtls_session_t, const void *, const void *))
+               int (*compar) (MHD_gtls_session_t, const void *, const void *))
 {
   unsigned int pivot;
   char *base = _base;
@@ -1602,19 +1602,19 @@ _gnutls_qsort (mhd_gtls_session_t session,
 #ifdef DEBUG
   if (size > MAX_ELEM_SIZE)
     {
-      gnutls_assert ();
-      _gnutls_debug_log ("QSORT BUG\n");
+      MHD_gnutls_assert ();
+      MHD__gnutls_debug_log ("QSORT BUG\n");
       exit (1);
     }
 #endif
 
   if (snmemb <= 1)
     return;
-  pivot = _gnutls_partition (session, _base, nmemb, size, compar);
+  pivot = MHD__gnutls_partition (session, _base, nmemb, size, compar);
 
-  _gnutls_qsort (session, base, pivot < nmemb ? pivot + 1
+  MHD__gnutls_qsort (session, base, pivot < nmemb ? pivot + 1
                  : pivot, size, compar);
-  _gnutls_qsort (session, &base[(pivot + 1) * size], nmemb - pivot - 1, size,
+  MHD__gnutls_qsort (session, &base[(pivot + 1) * size], nmemb - pivot - 1, size,
                  compar);
 }
 
@@ -1622,28 +1622,28 @@ _gnutls_qsort (mhd_gtls_session_t session,
  * For use with qsort
  */
 static int
-_gnutls_compare_algo (mhd_gtls_session_t session,
+MHD__gnutls_compare_algo (MHD_gtls_session_t session,
                       const void *i_A1, const void *i_A2)
 {
   enum MHD_GNUTLS_KeyExchangeAlgorithm kA1 =
-    mhd_gtls_cipher_suite_get_kx_algo ((const cipher_suite_st *) i_A1);
+    MHD_gtls_cipher_suite_get_kx_algo ((const cipher_suite_st *) i_A1);
   enum MHD_GNUTLS_KeyExchangeAlgorithm kA2 =
-    mhd_gtls_cipher_suite_get_kx_algo ((const cipher_suite_st *) i_A2);
+    MHD_gtls_cipher_suite_get_kx_algo ((const cipher_suite_st *) i_A2);
   enum MHD_GNUTLS_CipherAlgorithm cA1 =
-    mhd_gtls_cipher_suite_get_cipher_algo ((const cipher_suite_st *) i_A1);
+    MHD_gtls_cipher_suite_get_cipher_algo ((const cipher_suite_st *) i_A1);
   enum MHD_GNUTLS_CipherAlgorithm cA2 =
-    mhd_gtls_cipher_suite_get_cipher_algo ((const cipher_suite_st *) i_A2);
+    MHD_gtls_cipher_suite_get_cipher_algo ((const cipher_suite_st *) i_A2);
   enum MHD_GNUTLS_HashAlgorithm mA1 =
-    mhd_gtls_cipher_suite_get_mac_algo ((const cipher_suite_st *) i_A1);
+    MHD_gtls_cipher_suite_get_mac_algo ((const cipher_suite_st *) i_A1);
   enum MHD_GNUTLS_HashAlgorithm mA2 =
-    mhd_gtls_cipher_suite_get_mac_algo ((const cipher_suite_st *) i_A2);
+    MHD_gtls_cipher_suite_get_mac_algo ((const cipher_suite_st *) i_A2);
 
-  int p1 = (mhd_gtls_kx_priority (session, kA1) + 1) * 64;
-  int p2 = (mhd_gtls_kx_priority (session, kA2) + 1) * 64;
-  p1 += (mhd_gtls_cipher_priority (session, cA1) + 1) * 8;
-  p2 += (mhd_gtls_cipher_priority (session, cA2) + 1) * 8;
-  p1 += mhd_gtls_mac_priority (session, mA1);
-  p2 += mhd_gtls_mac_priority (session, mA2);
+  int p1 = (MHD_gtls_kx_priority (session, kA1) + 1) * 64;
+  int p2 = (MHD_gtls_kx_priority (session, kA2) + 1) * 64;
+  p1 += (MHD_gtls_cipher_priority (session, cA1) + 1) * 8;
+  p2 += (MHD_gtls_cipher_priority (session, cA2) + 1) * 8;
+  p1 += MHD_gtls_mac_priority (session, mA1);
+  p2 += MHD_gtls_mac_priority (session, mA2);
 
   if (p1 > p2)
     {
@@ -1661,8 +1661,8 @@ _gnutls_compare_algo (mhd_gtls_session_t session,
 
 #ifdef SORT_DEBUG
 static void
-_gnutls_bsort (mhd_gtls_session_t session, void *_base, size_t nmemb,
-               size_t size, int (*compar) (mhd_gtls_session_t, const void *,
+MHD__gnutls_bsort (MHD_gtls_session_t session, void *_base, size_t nmemb,
+               size_t size, int (*compar) (MHD_gtls_session_t, const void *,
                                            const void *))
 {
   unsigned int i, j;
@@ -1685,7 +1685,7 @@ _gnutls_bsort (mhd_gtls_session_t session, void *_base, size_t nmemb,
 #endif
 
 int
-mhd_gtls_supported_ciphersuites_sorted (mhd_gtls_session_t session,
+MHD_gtls_supported_ciphersuites_sorted (MHD_gtls_session_t session,
                                         cipher_suite_st ** ciphers)
 {
 
@@ -1694,34 +1694,34 @@ mhd_gtls_supported_ciphersuites_sorted (mhd_gtls_session_t session,
 #endif
   int count;
 
-  count = mhd_gtls_supported_ciphersuites (session, ciphers);
+  count = MHD_gtls_supported_ciphersuites (session, ciphers);
   if (count <= 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return count;
     }
 #ifdef SORT_DEBUG
-  _gnutls_debug_log ("Unsorted: \n");
+  MHD__gnutls_debug_log ("Unsorted: \n");
   for (i = 0; i < count; i++)
-    _gnutls_debug_log ("\t%d: %s\n", i,
-                       mhd_gtls_cipher_suite_get_name ((*ciphers)[i]));
+    MHD__gnutls_debug_log ("\t%d: %s\n", i,
+                       MHD_gtls_cipher_suite_get_name ((*ciphers)[i]));
 #endif
 
-  _gnutls_qsort (session, *ciphers, count, sizeof (cipher_suite_st),
-                 _gnutls_compare_algo);
+  MHD__gnutls_qsort (session, *ciphers, count, sizeof (cipher_suite_st),
+                 MHD__gnutls_compare_algo);
 
 #ifdef SORT_DEBUG
-  _gnutls_debug_log ("Sorted: \n");
+  MHD__gnutls_debug_log ("Sorted: \n");
   for (i = 0; i < count; i++)
-    _gnutls_debug_log ("\t%d: %s\n", i,
-                       mhd_gtls_cipher_suite_get_name ((*ciphers)[i]));
+    MHD__gnutls_debug_log ("\t%d: %s\n", i,
+                       MHD_gtls_cipher_suite_get_name ((*ciphers)[i]));
 #endif
 
   return count;
 }
 
 int
-mhd_gtls_supported_ciphersuites (mhd_gtls_session_t session,
+MHD_gtls_supported_ciphersuites (MHD_gtls_session_t session,
                                  cipher_suite_st ** _ciphers)
 {
 
@@ -1736,22 +1736,22 @@ mhd_gtls_supported_ciphersuites (mhd_gtls_session_t session,
       return 0;
     }
 
-  tmp_ciphers = gnutls_alloca (count * sizeof (cipher_suite_st));
+  tmp_ciphers = MHD_gnutls_alloca (count * sizeof (cipher_suite_st));
   if (tmp_ciphers == NULL)
     return GNUTLS_E_MEMORY_ERROR;
 
-  ciphers = gnutls_malloc (count * sizeof (cipher_suite_st));
+  ciphers = MHD_gnutls_malloc (count * sizeof (cipher_suite_st));
   if (ciphers == NULL)
     {
-      gnutls_afree (tmp_ciphers);
+      MHD_gnutls_afree (tmp_ciphers);
       return GNUTLS_E_MEMORY_ERROR;
     }
 
-  version = MHD_gnutls_protocol_get_version (session);
+  version = MHD__gnutls_protocol_get_version (session);
 
   for (i = 0; i < count; i++)
     {
-      memcpy (&tmp_ciphers[i], &mhd_gtls_cs_algorithms[i].id,
+      memcpy (&tmp_ciphers[i], &MHD_gtls_cs_algorithms[i].id,
               sizeof (cipher_suite_st));
     }
 
@@ -1766,19 +1766,19 @@ mhd_gtls_supported_ciphersuites (mhd_gtls_session_t session,
       /* remove cipher suites which do not support the
        * protocol version used.
        */
-      if (mhd_gtls_cipher_suite_get_version (&tmp_ciphers[i]) > version)
+      if (MHD_gtls_cipher_suite_get_version (&tmp_ciphers[i]) > version)
         continue;
 
-      if (mhd_gtls_kx_priority (session,
-                                mhd_gtls_cipher_suite_get_kx_algo
+      if (MHD_gtls_kx_priority (session,
+                                MHD_gtls_cipher_suite_get_kx_algo
                                 (&tmp_ciphers[i])) < 0)
         continue;
-      if (mhd_gtls_mac_priority (session,
-                                 mhd_gtls_cipher_suite_get_mac_algo
+      if (MHD_gtls_mac_priority (session,
+                                 MHD_gtls_cipher_suite_get_mac_algo
                                  (&tmp_ciphers[i])) < 0)
         continue;
-      if (mhd_gtls_cipher_priority (session,
-                                    mhd_gtls_cipher_suite_get_cipher_algo
+      if (MHD_gtls_cipher_priority (session,
+                                    MHD_gtls_cipher_suite_get_cipher_algo
                                     (&tmp_ciphers[i])) < 0)
         continue;
 
@@ -1792,27 +1792,27 @@ mhd_gtls_supported_ciphersuites (mhd_gtls_session_t session,
   if (ret_count > 0 && ret_count != count)
     {
       ciphers =
-        mhd_gtls_realloc_fast (ciphers, ret_count * sizeof (cipher_suite_st));
+        MHD_gtls_realloc_fast (ciphers, ret_count * sizeof (cipher_suite_st));
     }
   else
     {
       if (ret_count != count)
         {
-          gnutls_free (ciphers);
+          MHD_gnutls_free (ciphers);
           ciphers = NULL;
         }
     }
 #endif
 
-  gnutls_afree (tmp_ciphers);
+  MHD_gnutls_afree (tmp_ciphers);
 
   /* This function can no longer return 0 cipher suites.
    * It returns an error code instead.
    */
   if (ret_count == 0)
     {
-      gnutls_assert ();
-      gnutls_free (ciphers);
+      MHD_gnutls_assert ();
+      MHD_gnutls_free (ciphers);
       return GNUTLS_E_NO_CIPHER_SUITES;
     }
   *_ciphers = ciphers;
@@ -1827,19 +1827,19 @@ mhd_gtls_supported_ciphersuites (mhd_gtls_session_t session,
  */
 #define SUPPORTED_COMPRESSION_METHODS session->internals.priorities.compression.num_algorithms
 int
-mhd_gtls_supported_compression_methods (mhd_gtls_session_t session,
+MHD_gtls_supported_compression_methods (MHD_gtls_session_t session,
                                         uint8_t ** comp)
 {
   unsigned int i, j;
 
-  *comp = gnutls_malloc (sizeof (uint8_t) * SUPPORTED_COMPRESSION_METHODS);
+  *comp = MHD_gnutls_malloc (sizeof (uint8_t) * SUPPORTED_COMPRESSION_METHODS);
   if (*comp == NULL)
     return GNUTLS_E_MEMORY_ERROR;
 
   for (i = j = 0; i < SUPPORTED_COMPRESSION_METHODS; i++)
     {
       int tmp =
-        mhd_gtls_compression_get_num (session->internals.priorities.
+        MHD_gtls_compression_get_num (session->internals.priorities.
                                       compression.priority[i]);
 
       /* remove private compression algorithms, if requested.
@@ -1847,7 +1847,7 @@ mhd_gtls_supported_compression_methods (mhd_gtls_session_t session,
       if (tmp == -1 || (tmp >= MIN_PRIVATE_COMP_ALGO
                         && session->internals.enable_private == 0))
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           continue;
         }
 
@@ -1857,8 +1857,8 @@ mhd_gtls_supported_compression_methods (mhd_gtls_session_t session,
 
   if (j == 0)
     {
-      gnutls_assert ();
-      gnutls_free (*comp);
+      MHD_gnutls_assert ();
+      MHD_gnutls_free (*comp);
       *comp = NULL;
       return GNUTLS_E_NO_COMPRESSION_ALGORITHMS;
     }
@@ -1866,14 +1866,14 @@ mhd_gtls_supported_compression_methods (mhd_gtls_session_t session,
 }
 
 /**
- * MHD_gnutls_certificate_type_get_name - Returns a string with the name of the specified certificate type
+ * MHD__gnutls_certificate_type_get_name - Returns a string with the name of the specified certificate type
  * @type: is a certificate type
  *
  * Returns: a string (or %NULL) that contains the name of the
  * specified certificate type.
  **/
 const char *
-MHD_gnutls_certificate_type_get_name (enum MHD_GNUTLS_CertificateType type)
+MHD__gnutls_certificate_type_get_name (enum MHD_GNUTLS_CertificateType type)
 {
   const char *ret = NULL;
 
@@ -1902,7 +1902,7 @@ MHD_gtls_certificate_type_get_id (const char *name)
 }
 
 static const enum MHD_GNUTLS_CertificateType
-  mhd_gtls_supported_certificate_types[] =
+  MHD_gtls_supported_certificate_types[] =
 { MHD_GNUTLS_CRT_X509,
   0
 };
@@ -1919,14 +1919,14 @@ static const enum MHD_GNUTLS_CertificateType
 const enum MHD_GNUTLS_CertificateType *
 MHD_gtls_certificate_type_list (void)
 {
-  return mhd_gtls_supported_certificate_types;
+  return MHD_gtls_supported_certificate_types;
 }
 
 /* returns the enum MHD_GNUTLS_PublicKeyAlgorithm which is compatible with
  * the given enum MHD_GNUTLS_KeyExchangeAlgorithm.
  */
 enum MHD_GNUTLS_PublicKeyAlgorithm
-mhd_gtls_map_pk_get_pk (enum MHD_GNUTLS_KeyExchangeAlgorithm kx_algorithm)
+MHD_gtls_map_pk_get_pk (enum MHD_GNUTLS_KeyExchangeAlgorithm kx_algorithm)
 {
   enum MHD_GNUTLS_PublicKeyAlgorithm ret = -1;
 
@@ -1939,7 +1939,7 @@ mhd_gtls_map_pk_get_pk (enum MHD_GNUTLS_KeyExchangeAlgorithm kx_algorithm)
  * ex. GNUTLS_KX_RSA requires a certificate able to encrypt... so returns CIPHER_ENCRYPT.
  */
 enum encipher_type
-mhd_gtls_kx_encipher_type (enum MHD_GNUTLS_KeyExchangeAlgorithm kx_algorithm)
+MHD_gtls_kx_encipher_type (enum MHD_GNUTLS_KeyExchangeAlgorithm kx_algorithm)
 {
   int ret = CIPHER_IGN;
   GNUTLS_PK_MAP_ALG_LOOP (ret = p->encipher_type) return ret;
@@ -1948,17 +1948,17 @@ mhd_gtls_kx_encipher_type (enum MHD_GNUTLS_KeyExchangeAlgorithm kx_algorithm)
 
 /* signature algorithms;
  */
-struct gnutls_sign_entry
+struct MHD_gnutls_sign_entry
 {
   const char *name;
   const char *oid;
-  gnutls_sign_algorithm_t id;
+  MHD_gnutls_sign_algorithm_t id;
   enum MHD_GNUTLS_PublicKeyAlgorithm pk;
   enum MHD_GNUTLS_HashAlgorithm mac;
 };
-typedef struct gnutls_sign_entry gnutls_sign_entry;
+typedef struct MHD_gnutls_sign_entry MHD_gnutls_sign_entry;
 
-static const gnutls_sign_entry mhd_gtls_sign_algorithms[] = {
+static const MHD_gnutls_sign_entry MHD_gtls_sign_algorithms[] = {
   {"RSA-SHA",
    SIG_RSA_SHA1_OID,
    GNUTLS_SIGN_RSA_SHA1,
@@ -1993,17 +1993,17 @@ static const gnutls_sign_entry mhd_gtls_sign_algorithms[] = {
 
 #define GNUTLS_SIGN_LOOP(b) \
   do {                                                                 \
-    const gnutls_sign_entry *p;                                        \
-    for(p = mhd_gtls_sign_algorithms; p->name != NULL; p++) { b ; }            \
+    const MHD_gnutls_sign_entry *p;                                            \
+    for(p = MHD_gtls_sign_algorithms; p->name != NULL; p++) { b ; }            \
   } while (0)
 
 #define GNUTLS_SIGN_ALG_LOOP(a) \
   GNUTLS_SIGN_LOOP( if(p->id && p->id == sign) { a; break; } )
 
-gnutls_sign_algorithm_t
-mhd_gtls_x509_oid2sign_algorithm (const char *oid)
+MHD_gnutls_sign_algorithm_t
+MHD_gtls_x509_oid2sign_algorithm (const char *oid)
 {
-  gnutls_sign_algorithm_t ret = 0;
+  MHD_gnutls_sign_algorithm_t ret = 0;
 
   GNUTLS_SIGN_LOOP (if (strcmp (oid, p->oid) == 0)
                     {
@@ -2012,17 +2012,17 @@ mhd_gtls_x509_oid2sign_algorithm (const char *oid)
 
   if (ret == 0)
     {
-      _gnutls_x509_log ("Unknown SIGN OID: '%s'\n", oid);
+      MHD__gnutls_x509_log ("Unknown SIGN OID: '%s'\n", oid);
       return GNUTLS_SIGN_UNKNOWN;
     }
   return ret;
 }
 
-gnutls_sign_algorithm_t
-mhd_gtls_x509_pk_to_sign (enum MHD_GNUTLS_PublicKeyAlgorithm pk,
+MHD_gnutls_sign_algorithm_t
+MHD_gtls_x509_pk_to_sign (enum MHD_GNUTLS_PublicKeyAlgorithm pk,
                           enum MHD_GNUTLS_HashAlgorithm mac)
 {
-  gnutls_sign_algorithm_t ret = 0;
+  MHD_gnutls_sign_algorithm_t ret = 0;
 
   GNUTLS_SIGN_LOOP (if (pk == p->pk && mac == p->mac)
                     {
@@ -2035,13 +2035,13 @@ mhd_gtls_x509_pk_to_sign (enum MHD_GNUTLS_PublicKeyAlgorithm pk,
 }
 
 const char *
-mhd_gtls_x509_sign_to_oid (enum MHD_GNUTLS_PublicKeyAlgorithm pk,
+MHD_gtls_x509_sign_to_oid (enum MHD_GNUTLS_PublicKeyAlgorithm pk,
                            enum MHD_GNUTLS_HashAlgorithm mac)
 {
-  gnutls_sign_algorithm_t sign;
+  MHD_gnutls_sign_algorithm_t sign;
   const char *ret = NULL;
 
-  sign = mhd_gtls_x509_pk_to_sign (pk, mac);
+  sign = MHD_gtls_x509_pk_to_sign (pk, mac);
   if (sign == GNUTLS_SIGN_UNKNOWN)
     return NULL;
 
@@ -2051,15 +2051,15 @@ mhd_gtls_x509_sign_to_oid (enum MHD_GNUTLS_PublicKeyAlgorithm pk,
 
 /* pk algorithms;
  */
-struct gnutls_pk_entry
+struct MHD_gnutls_pk_entry
 {
   const char *name;
   const char *oid;
   enum MHD_GNUTLS_PublicKeyAlgorithm id;
 };
-typedef struct gnutls_pk_entry gnutls_pk_entry;
+typedef struct MHD_gnutls_pk_entry MHD_gnutls_pk_entry;
 
-static const gnutls_pk_entry mhd_gtls_pk_algorithms[] = {
+static const MHD_gnutls_pk_entry MHD_gtls_pk_algorithms[] = {
   {"RSA",
    PK_PKIX1_RSA_OID,
    MHD_GNUTLS_PK_RSA},
@@ -2075,12 +2075,12 @@ static const gnutls_pk_entry mhd_gtls_pk_algorithms[] = {
 };
 
 enum MHD_GNUTLS_PublicKeyAlgorithm
-mhd_gtls_x509_oid2pk_algorithm (const char *oid)
+MHD_gtls_x509_oid2pk_algorithm (const char *oid)
 {
   enum MHD_GNUTLS_PublicKeyAlgorithm ret = MHD_GNUTLS_PK_UNKNOWN;
-  const gnutls_pk_entry *p;
+  const MHD_gnutls_pk_entry *p;
 
-  for (p = mhd_gtls_pk_algorithms; p->name != NULL; p++)
+  for (p = MHD_gtls_pk_algorithms; p->name != NULL; p++)
     if (strcmp (p->oid, oid) == 0)
       {
         ret = p->id;
@@ -2091,12 +2091,12 @@ mhd_gtls_x509_oid2pk_algorithm (const char *oid)
 }
 
 const char *
-mhd_gtls_x509_pk_to_oid (enum MHD_GNUTLS_PublicKeyAlgorithm algorithm)
+MHD_gtls_x509_pk_to_oid (enum MHD_GNUTLS_PublicKeyAlgorithm algorithm)
 {
   const char *ret = NULL;
-  const gnutls_pk_entry *p;
+  const MHD_gnutls_pk_entry *p;
 
-  for (p = mhd_gtls_pk_algorithms; p->name != NULL; p++)
+  for (p = MHD_gtls_pk_algorithms; p->name != NULL; p++)
     if (p->id == algorithm)
       {
         ret = p->oid;
diff --git a/src/daemon/https/tls/gnutls_algorithms.h b/src/daemon/https/tls/gnutls_algorithms.h
index c98e3c41..c0cb2332 100644
--- a/src/daemon/https/tls/gnutls_algorithms.h
+++ b/src/daemon/https/tls/gnutls_algorithms.h
@@ -28,105 +28,105 @@
 #include "gnutls_auth.h"
 
 /* Functions for version handling. */
-enum MHD_GNUTLS_Protocol mhd_gtls_version_lowest (mhd_gtls_session_t session);
-enum MHD_GNUTLS_Protocol mhd_gtls_version_max (mhd_gtls_session_t session);
-int mhd_gtls_version_priority (mhd_gtls_session_t session,
+enum MHD_GNUTLS_Protocol MHD_gtls_version_lowest (MHD_gtls_session_t session);
+enum MHD_GNUTLS_Protocol MHD_gtls_version_max (MHD_gtls_session_t session);
+int MHD_gtls_version_priority (MHD_gtls_session_t session,
                                enum MHD_GNUTLS_Protocol version);
-int mhd_gtls_version_is_supported (mhd_gtls_session_t session,
+int MHD_gtls_version_is_supported (MHD_gtls_session_t session,
                                    const enum MHD_GNUTLS_Protocol version);
-int mhd_gtls_version_get_major (enum MHD_GNUTLS_Protocol ver);
-int mhd_gtls_version_get_minor (enum MHD_GNUTLS_Protocol ver);
-enum MHD_GNUTLS_Protocol mhd_gtls_version_get (int major, int minor);
+int MHD_gtls_version_get_major (enum MHD_GNUTLS_Protocol ver);
+int MHD_gtls_version_get_minor (enum MHD_GNUTLS_Protocol ver);
+enum MHD_GNUTLS_Protocol MHD_gtls_version_get (int major, int minor);
 
 /* Functions for MACs. */
-int mhd_gnutls_mac_is_ok (enum MHD_GNUTLS_HashAlgorithm algorithm);
-enum MHD_GNUTLS_HashAlgorithm mhd_gtls_x509_oid2mac_algorithm (const char
+int MHD_gnutls_mac_is_ok (enum MHD_GNUTLS_HashAlgorithm algorithm);
+enum MHD_GNUTLS_HashAlgorithm MHD_gtls_x509_oid2mac_algorithm (const char
                                                                *oid);
-const char *mhd_gtls_x509_mac_to_oid (enum MHD_GNUTLS_HashAlgorithm mac);
+const char *MHD_gtls_x509_mac_to_oid (enum MHD_GNUTLS_HashAlgorithm mac);
 
 /* Functions for cipher suites. */
-int mhd_gtls_supported_ciphersuites (mhd_gtls_session_t session,
+int MHD_gtls_supported_ciphersuites (MHD_gtls_session_t session,
                                      cipher_suite_st ** ciphers);
-int mhd_gtls_supported_ciphersuites_sorted (mhd_gtls_session_t session,
+int MHD_gtls_supported_ciphersuites_sorted (MHD_gtls_session_t session,
                                             cipher_suite_st ** ciphers);
-int mhd_gtls_supported_compression_methods (mhd_gtls_session_t session,
+int MHD_gtls_supported_compression_methods (MHD_gtls_session_t session,
                                             uint8_t ** comp);
-const char *mhd_gtls_cipher_suite_get_name (cipher_suite_st * algorithm);
-enum MHD_GNUTLS_CipherAlgorithm mhd_gtls_cipher_suite_get_cipher_algo (const
+const char *MHD_gtls_cipher_suite_get_name (cipher_suite_st * algorithm);
+enum MHD_GNUTLS_CipherAlgorithm MHD_gtls_cipher_suite_get_cipher_algo (const
                                                                        cipher_suite_st
                                                                        *
                                                                        algorithm);
-enum MHD_GNUTLS_KeyExchangeAlgorithm mhd_gtls_cipher_suite_get_kx_algo (const
+enum MHD_GNUTLS_KeyExchangeAlgorithm MHD_gtls_cipher_suite_get_kx_algo (const
                                                                         cipher_suite_st
                                                                         *
                                                                         algorithm);
-enum MHD_GNUTLS_HashAlgorithm mhd_gtls_cipher_suite_get_mac_algo (const
+enum MHD_GNUTLS_HashAlgorithm MHD_gtls_cipher_suite_get_mac_algo (const
                                                                   cipher_suite_st
                                                                   *
                                                                   algorithm);
-enum MHD_GNUTLS_Protocol mhd_gtls_cipher_suite_get_version (const
+enum MHD_GNUTLS_Protocol MHD_gtls_cipher_suite_get_version (const
                                                             cipher_suite_st *
                                                             algorithm);
-cipher_suite_st mhd_gtls_cipher_suite_get_suite_name (cipher_suite_st *
+cipher_suite_st MHD_gtls_cipher_suite_get_suite_name (cipher_suite_st *
                                                       algorithm);
 
 /* Functions for ciphers. */
-int mhd_gtls_cipher_get_block_size (enum MHD_GNUTLS_CipherAlgorithm
+int MHD_gtls_cipher_get_block_size (enum MHD_GNUTLS_CipherAlgorithm
                                     algorithm);
-int mhd_gtls_cipher_is_block (enum MHD_GNUTLS_CipherAlgorithm algorithm);
-int mhd_gtls_cipher_is_ok (enum MHD_GNUTLS_CipherAlgorithm algorithm);
-int mhd_gtls_cipher_get_iv_size (enum MHD_GNUTLS_CipherAlgorithm algorithm);
-int mhd_gtls_cipher_get_export_flag (enum MHD_GNUTLS_CipherAlgorithm
+int MHD_gtls_cipher_is_block (enum MHD_GNUTLS_CipherAlgorithm algorithm);
+int MHD_gtls_cipher_is_ok (enum MHD_GNUTLS_CipherAlgorithm algorithm);
+int MHD_gtls_cipher_get_iv_size (enum MHD_GNUTLS_CipherAlgorithm algorithm);
+int MHD_gtls_cipher_get_export_flag (enum MHD_GNUTLS_CipherAlgorithm
                                      algorithm);
 
 /* Functions for key exchange. */
-int mhd_gtls_kx_needs_dh_params (enum MHD_GNUTLS_KeyExchangeAlgorithm
+int MHD_gtls_kx_needs_dh_params (enum MHD_GNUTLS_KeyExchangeAlgorithm
                                  algorithm);
-int mhd_gtls_kx_needs_rsa_params (enum MHD_GNUTLS_KeyExchangeAlgorithm
+int MHD_gtls_kx_needs_rsa_params (enum MHD_GNUTLS_KeyExchangeAlgorithm
                                   algorithm);
-mhd_gtls_mod_auth_st *mhd_gtls_kx_auth_struct (enum
+MHD_gtls_mod_auth_st *MHD_gtls_kx_auth_struct (enum
                                                MHD_GNUTLS_KeyExchangeAlgorithm
                                                algorithm);
-int mhd_gtls_kx_is_ok (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm);
+int MHD_gtls_kx_is_ok (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm);
 
 /* Functions for compression. */
-int mhd_gtls_compression_is_ok (enum MHD_GNUTLS_CompressionMethod algorithm);
-int mhd_gtls_compression_get_num (enum MHD_GNUTLS_CompressionMethod
+int MHD_gtls_compression_is_ok (enum MHD_GNUTLS_CompressionMethod algorithm);
+int MHD_gtls_compression_get_num (enum MHD_GNUTLS_CompressionMethod
                                   algorithm);
-enum MHD_GNUTLS_CompressionMethod mhd_gtls_compression_get_id (int num);
-int mhd_gtls_compression_get_mem_level (enum MHD_GNUTLS_CompressionMethod
+enum MHD_GNUTLS_CompressionMethod MHD_gtls_compression_get_id_from_int (int num);
+int MHD_gtls_compression_get_mem_level (enum MHD_GNUTLS_CompressionMethod
                                         algorithm);
-int mhd_gtls_compression_get_comp_level (enum MHD_GNUTLS_CompressionMethod
+int MHD_gtls_compression_get_comp_level (enum MHD_GNUTLS_CompressionMethod
                                          algorithm);
-int mhd_gtls_compression_get_wbits (enum MHD_GNUTLS_CompressionMethod
+int MHD_gtls_compression_get_wbits (enum MHD_GNUTLS_CompressionMethod
                                     algorithm);
 
 /* Type to KX mappings. */
-enum MHD_GNUTLS_KeyExchangeAlgorithm mhd_gtls_map_kx_get_kx (enum
+enum MHD_GNUTLS_KeyExchangeAlgorithm MHD_gtls_map_kx_get_kx (enum
                                                              MHD_GNUTLS_CredentialsType
                                                              type,
                                                              int server);
-enum MHD_GNUTLS_CredentialsType mhd_gtls_map_kx_get_cred (enum
+enum MHD_GNUTLS_CredentialsType MHD_gtls_map_kx_get_cred (enum
                                                           MHD_GNUTLS_KeyExchangeAlgorithm
                                                           algorithm,
                                                           int server);
 
 /* KX to PK mapping. */
-enum MHD_GNUTLS_PublicKeyAlgorithm mhd_gtls_map_pk_get_pk (enum
+enum MHD_GNUTLS_PublicKeyAlgorithm MHD_gtls_map_pk_get_pk (enum
                                                            MHD_GNUTLS_KeyExchangeAlgorithm
                                                            kx_algorithm);
-enum MHD_GNUTLS_PublicKeyAlgorithm mhd_gtls_x509_oid2pk_algorithm (const char
+enum MHD_GNUTLS_PublicKeyAlgorithm MHD_gtls_x509_oid2pk_algorithm (const char
                                                                    *oid);
-const char *mhd_gtls_x509_pk_to_oid (enum MHD_GNUTLS_PublicKeyAlgorithm pk);
+const char *MHD_gtls_x509_pk_to_oid (enum MHD_GNUTLS_PublicKeyAlgorithm pk);
 
 enum encipher_type
 { CIPHER_ENCRYPT = 0, CIPHER_SIGN = 1, CIPHER_IGN };
 
-enum encipher_type mhd_gtls_kx_encipher_type (enum
+enum encipher_type MHD_gtls_kx_encipher_type (enum
                                               MHD_GNUTLS_KeyExchangeAlgorithm
                                               algorithm);
 
-struct mhd_gtls_compression_entry
+struct MHD_gtls_compression_entry
 {
   const char *name;
   enum MHD_GNUTLS_CompressionMethod id;
@@ -137,26 +137,26 @@ struct mhd_gtls_compression_entry
   int mem_level;
   int comp_level;
 };
-typedef struct mhd_gtls_compression_entry gnutls_compression_entry;
+typedef struct MHD_gtls_compression_entry MHD_gnutls_compression_entry;
 
 /* Functions for sign algorithms. */
-gnutls_sign_algorithm_t mhd_gtls_x509_oid2sign_algorithm (const char *oid);
-gnutls_sign_algorithm_t mhd_gtls_x509_pk_to_sign (enum
+MHD_gnutls_sign_algorithm_t MHD_gtls_x509_oid2sign_algorithm (const char *oid);
+MHD_gnutls_sign_algorithm_t MHD_gtls_x509_pk_to_sign (enum
                                                   MHD_GNUTLS_PublicKeyAlgorithm
                                                   pk,
                                                   enum
                                                   MHD_GNUTLS_HashAlgorithm
                                                   mac);
-const char *mhd_gtls_x509_sign_to_oid (enum MHD_GNUTLS_PublicKeyAlgorithm,
+const char *MHD_gtls_x509_sign_to_oid (enum MHD_GNUTLS_PublicKeyAlgorithm,
                                        enum MHD_GNUTLS_HashAlgorithm mac);
 
-int mhd_gtls_mac_priority (mhd_gtls_session_t session,
+int MHD_gtls_mac_priority (MHD_gtls_session_t session,
                            enum MHD_GNUTLS_HashAlgorithm algorithm);
-int mhd_gtls_cipher_priority (mhd_gtls_session_t session,
+int MHD_gtls_cipher_priority (MHD_gtls_session_t session,
                               enum MHD_GNUTLS_CipherAlgorithm algorithm);
-int mhd_gtls_kx_priority (mhd_gtls_session_t session,
+int MHD_gtls_kx_priority (MHD_gtls_session_t session,
                           enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm);
-int mhd_gtls_compression_priority (mhd_gtls_session_t session,
+int MHD_gtls_compression_priority (MHD_gtls_session_t session,
                                    enum MHD_GNUTLS_CompressionMethod
                                    algorithm);
 
diff --git a/src/daemon/https/tls/gnutls_anon_cred.c b/src/daemon/https/tls/gnutls_anon_cred.c
index 3ea9768d..665a0758 100644
--- a/src/daemon/https/tls/gnutls_anon_cred.c
+++ b/src/daemon/https/tls/gnutls_anon_cred.c
@@ -36,23 +36,23 @@
 static const int anon_dummy;
 
 /**
-  * MHD_gnutls_anon_free_server_credentials - Used to free an allocated mhd_gtls_anon_server_credentials_t structure
-  * @sc: is an #mhd_gtls_anon_server_credentials_t structure.
+  * MHD__gnutls_anon_free_server_credentials - Used to free an allocated MHD_gtls_anon_server_credentials_t structure
+  * @sc: is an #MHD_gtls_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
-MHD_gnutls_anon_free_server_credentials (mhd_gtls_anon_server_credentials_t
+MHD__gnutls_anon_free_server_credentials (MHD_gtls_anon_server_credentials_t
                                          sc)
 {
 
-  gnutls_free (sc);
+  MHD_gnutls_free (sc);
 }
 
 /**
-  * MHD_gnutls_anon_allocate_server_credentials - Used to allocate an mhd_gtls_anon_server_credentials_t structure
-  * @sc: is a pointer to an #mhd_gtls_anon_server_credentials_t structure.
+  * MHD__gnutls_anon_allocate_server_credentials - Used to allocate an MHD_gtls_anon_server_credentials_t structure
+  * @sc: is a pointer to an #MHD_gtls_anon_server_credentials_t structure.
   *
   * This structure is complex enough to manipulate directly thus this
   * helper function is provided in order to allocate it.
@@ -60,10 +60,10 @@ MHD_gnutls_anon_free_server_credentials (mhd_gtls_anon_server_credentials_t
   * Returns: %GNUTLS_E_SUCCESS on success, or an error code.
   **/
 int
-  MHD_gnutls_anon_allocate_server_credentials
-  (mhd_gtls_anon_server_credentials_t * sc)
+  MHD__gnutls_anon_allocate_server_credentials
+  (MHD_gtls_anon_server_credentials_t * sc)
 {
-  *sc = gnutls_calloc (1, sizeof (mhd_anon_server_credentials_st));
+  *sc = MHD_gnutls_calloc (1, sizeof (mhd_anon_server_credentials_st));
   if (*sc == NULL)
     return GNUTLS_E_MEMORY_ERROR;
 
@@ -72,21 +72,21 @@ int
 
 
 /**
-  * MHD_gnutls_anon_free_client_credentials - Used to free an allocated mhd_gtls_anon_client_credentials_t structure
-  * @sc: is an #mhd_gtls_anon_client_credentials_t structure.
+  * MHD__gnutls_anon_free_client_credentials - Used to free an allocated MHD_gtls_anon_client_credentials_t structure
+  * @sc: is an #MHD_gtls_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
-MHD_gnutls_anon_free_client_credentials (mhd_gtls_anon_client_credentials_t
+MHD__gnutls_anon_free_client_credentials (MHD_gtls_anon_client_credentials_t
                                          sc)
 {
 }
 
 /**
- * MHD_gnutls_anon_allocate_client_credentials - Used to allocate a credentials structure
- * @sc: is a pointer to an #mhd_gtls_anon_client_credentials_t structure.
+ * MHD__gnutls_anon_allocate_client_credentials - Used to allocate a credentials structure
+ * @sc: is a pointer to an #MHD_gtls_anon_client_credentials_t structure.
  *
  * This structure is complex enough to manipulate directly thus
  * this helper function is provided in order to allocate it.
@@ -94,8 +94,8 @@ MHD_gnutls_anon_free_client_credentials (mhd_gtls_anon_client_credentials_t
  * Returns: %GNUTLS_E_SUCCESS on success, or an error code.
  **/
 int
-  MHD_gnutls_anon_allocate_client_credentials
-  (mhd_gtls_anon_client_credentials_t * sc)
+  MHD__gnutls_anon_allocate_client_credentials
+  (MHD_gtls_anon_client_credentials_t * sc)
 {
   /* anon_dummy is only there for *sc not to be null.
    * it is not used at all;
@@ -106,8 +106,8 @@ int
 }
 
 /**
-  * MHD_gnutls_anon_set_server_dh_params - This function will set the DH parameters for a server to use
-  * @res: is a mhd_gtls_anon_server_credentials_t structure
+  * MHD__gnutls_anon_set_server_dh_params - This function will set the DH parameters for a server to use
+  * @res: is a MHD_gtls_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
@@ -115,15 +115,15 @@ int
   * Anonymous Diffie Hellman cipher suites.
   **/
 void
-MHD_gnutls_anon_set_server_dh_params (mhd_gtls_anon_server_credentials_t res,
-                                      mhd_gtls_dh_params_t dh_params)
+MHD__gnutls_anon_set_server_dh_params (MHD_gtls_anon_server_credentials_t res,
+                                      MHD_gtls_dh_params_t dh_params)
 {
   res->dh_params = dh_params;
 }
 
 /**
-  * MHD_gnutls_anon_set_server_params_function - This function will set the DH parameters callback
-  * @res: is a mhd_gtls_cert_credentials_t structure
+  * MHD__gnutls_anon_set_server_params_function - This function will set the DH parameters callback
+  * @res: is a MHD_gtls_cert_credentials_t structure
   * @func: is the function to be called
   *
   * This function will set a callback in order for the server to get
@@ -131,9 +131,9 @@ MHD_gnutls_anon_set_server_dh_params (mhd_gtls_anon_server_credentials_t res,
   * callback should return zero on success.
   **/
 void
-MHD_gnutls_anon_set_server_params_function (mhd_gtls_anon_server_credentials_t
+MHD__gnutls_anon_set_server_params_function (MHD_gtls_anon_server_credentials_t
                                             res,
-                                            gnutls_params_function * func)
+                                            MHD_gnutls_params_function * func)
 {
   res->params_func = func;
 }
diff --git a/src/daemon/https/tls/gnutls_asn1_tab.c b/src/daemon/https/tls/gnutls_asn1_tab.c
index b2139578..9b511521 100644
--- a/src/daemon/https/tls/gnutls_asn1_tab.c
+++ b/src/daemon/https/tls/gnutls_asn1_tab.c
@@ -4,7 +4,7 @@
 
 #include <libtasn1.h>
 
-const ASN1_ARRAY_TYPE gnutls_asn1_tab[] = {
+const ASN1_ARRAY_TYPE MHD_gnutlsMHD__asn1_tab[] = {
   {"GNUTLS", 536872976, 0},
   {0, 1073741836, 0},
   {"RSAPublicKey", 1610612741, 0},
diff --git a/src/daemon/https/tls/gnutls_auth.c b/src/daemon/https/tls/gnutls_auth.c
index 1b805c10..b1e1abe7 100644
--- a/src/daemon/https/tls/gnutls_auth.c
+++ b/src/daemon/https/tls/gnutls_auth.c
@@ -37,14 +37,14 @@
  */
 
 /**
-  * MHD_gnutls_credentials_clear - Clears all the credentials previously set
-  * @session: is a #mhd_gtls_session_t structure.
+  * MHD__gnutls_credentials_clear - Clears all the credentials previously set
+  * @session: is a #MHD_gtls_session_t structure.
   *
   * Clears all the credentials previously set in this session.
   *
   **/
 void
-MHD_gnutls_credentials_clear (mhd_gtls_session_t session)
+MHD__gnutls_credentials_clear (MHD_gtls_session_t session)
 {
   if (session->key && session->key->cred)
     {                           /* beginning of the list */
@@ -53,7 +53,7 @@ MHD_gnutls_credentials_clear (mhd_gtls_session_t session)
       while (ccred != NULL)
         {
           ncred = ccred->next;
-          gnutls_free (ccred);
+          MHD_gnutls_free (ccred);
           ccred = ncred;
         }
       session->key->cred = NULL;
@@ -65,8 +65,8 @@ MHD_gnutls_credentials_clear (mhd_gtls_session_t session)
  * { algorithm, credentials, pointer to next }
  */
 /**
-  * MHD_gnutls_credentials_set - Sets the needed credentials for the specified authentication algorithm.
-  * @session: is a #mhd_gtls_session_t structure.
+  * MHD__gnutls_credentials_set - Sets the needed credentials for the specified authentication algorithm.
+  * @session: is a #MHD_gtls_session_t structure.
   * @type: is the type of the credentials
   * @cred: is a pointer to a structure.
   *
@@ -77,20 +77,20 @@ MHD_gnutls_credentials_clear (mhd_gtls_session_t session)
   * [ In order to minimize memory usage, and share credentials between
   * several threads gnutls keeps a pointer to cred, and not the whole cred
   * structure. Thus you will have to keep the structure allocated until
-  * you call MHD_gnutls_deinit(). ]
+  * you call MHD__gnutls_deinit(). ]
   *
-  * For GNUTLS_CRD_ANON cred should be mhd_gtls_anon_client_credentials_t in case of a client.
-  * In case of a server it should be mhd_gtls_anon_server_credentials_t.
+  * For GNUTLS_CRD_ANON cred should be MHD_gtls_anon_client_credentials_t in case of a client.
+  * In case of a server it should be MHD_gtls_anon_server_credentials_t.
   *
-  * 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
+  * For GNUTLS_CRD_SRP cred should be MHD_gnutls_srp_client_credentials_t
+  * in case of a client, and MHD_gnutls_srp_server_credentials_t, in case
   * of a server.
   *
-  * For GNUTLS_CRD_CERTIFICATE cred should be mhd_gtls_cert_credentials_t.
+  * For GNUTLS_CRD_CERTIFICATE cred should be MHD_gtls_cert_credentials_t.
   *
   **/
 int
-MHD_gnutls_credentials_set (mhd_gtls_session_t session,
+MHD__gnutls_credentials_set (MHD_gtls_session_t session,
                             enum MHD_GNUTLS_CredentialsType type, void *cred)
 {
   auth_cred_st *ccred = NULL, *pcred = NULL;
@@ -99,7 +99,7 @@ MHD_gnutls_credentials_set (mhd_gtls_session_t session,
   if (session->key->cred == NULL)
     {                           /* beginning of the list */
 
-      session->key->cred = gnutls_malloc (sizeof (auth_cred_st));
+      session->key->cred = MHD_gnutls_malloc (sizeof (auth_cred_st));
       if (session->key->cred == NULL)
         return GNUTLS_E_MEMORY_ERROR;
 
@@ -127,7 +127,7 @@ MHD_gnutls_credentials_set (mhd_gtls_session_t session,
 
       if (exists == 0)
         {                       /* new entry */
-          pcred->next = gnutls_malloc (sizeof (auth_cred_st));
+          pcred->next = MHD_gnutls_malloc (sizeof (auth_cred_st));
           if (pcred->next == NULL)
             return GNUTLS_E_MEMORY_ERROR;
 
@@ -141,7 +141,7 @@ MHD_gnutls_credentials_set (mhd_gtls_session_t session,
         }
       else
         {                       /* modify existing entry */
-          gnutls_free (ccred->credentials);
+          MHD_gnutls_free (ccred->credentials);
           ccred->credentials = cred;
         }
     }
@@ -151,7 +151,7 @@ MHD_gnutls_credentials_set (mhd_gtls_session_t session,
 
 /**
   * MHD_gtls_auth_get_type - Returns the type of credentials for the current authentication schema.
-  * @session: is a #mhd_gtls_session_t structure.
+  * @session: is a #MHD_gtls_session_t structure.
   *
   * Returns type of credentials for the current authentication schema.
   * The returned information is to be used to distinguish the function used
@@ -161,7 +161,7 @@ MHD_gnutls_credentials_set (mhd_gtls_session_t session,
   * the same function are to be used to access the authentication data.
   **/
 enum MHD_GNUTLS_CredentialsType
-MHD_gtls_auth_get_type (mhd_gtls_session_t session)
+MHD_gtls_auth_get_type (MHD_gtls_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.
@@ -169,14 +169,14 @@ MHD_gtls_auth_get_type (mhd_gtls_session_t session)
   int server = session->security_parameters.entity == GNUTLS_SERVER ? 0 : 1;
 
   return
-    mhd_gtls_map_kx_get_cred (mhd_gtls_cipher_suite_get_kx_algo
+    MHD_gtls_map_kx_get_cred (MHD_gtls_cipher_suite_get_kx_algo
                               (&session->security_parameters.
                                current_cipher_suite), server);
 }
 
 /**
   * MHD_gtls_auth_server_get_type - Returns the type of credentials for the server authentication schema.
-  * @session: is a #mhd_gtls_session_t structure.
+  * @session: is a #MHD_gtls_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
@@ -184,17 +184,17 @@ MHD_gtls_auth_get_type (mhd_gtls_session_t session)
   *
   **/
 enum MHD_GNUTLS_CredentialsType
-MHD_gtls_auth_server_get_type (mhd_gtls_session_t session)
+MHD_gtls_auth_server_get_type (MHD_gtls_session_t session)
 {
   return
-    mhd_gtls_map_kx_get_cred (mhd_gtls_cipher_suite_get_kx_algo
+    MHD_gtls_map_kx_get_cred (MHD_gtls_cipher_suite_get_kx_algo
                               (&session->security_parameters.
                                current_cipher_suite), 1);
 }
 
 /**
   * MHD_gtls_auth_client_get_type - Returns the type of credentials for the client authentication schema.
-  * @session: is a #mhd_gtls_session_t structure.
+  * @session: is a #MHD_gtls_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
@@ -202,10 +202,10 @@ MHD_gtls_auth_server_get_type (mhd_gtls_session_t session)
   *
   **/
 enum MHD_GNUTLS_CredentialsType
-MHD_gtls_auth_client_get_type (mhd_gtls_session_t session)
+MHD_gtls_auth_client_get_type (MHD_gtls_session_t session)
 {
   return
-    mhd_gtls_map_kx_get_cred (mhd_gtls_cipher_suite_get_kx_algo
+    MHD_gtls_map_kx_get_cred (MHD_gtls_cipher_suite_get_kx_algo
                               (&session->security_parameters.
                                current_cipher_suite), 0);
 }
@@ -216,17 +216,17 @@ MHD_gtls_auth_client_get_type (mhd_gtls_session_t session)
  * free that!!!
  */
 const void *
-mhd_gtls_get_kx_cred (mhd_gtls_session_t session,
+MHD_gtls_get_kx_cred (MHD_gtls_session_t session,
                       enum MHD_GNUTLS_KeyExchangeAlgorithm algo, int *err)
 {
   int server = session->security_parameters.entity == GNUTLS_SERVER ? 1 : 0;
 
-  return mhd_gtls_get_cred (session->key,
-                            mhd_gtls_map_kx_get_cred (algo, server), err);
+  return MHD_gtls_get_cred (session->key,
+                            MHD_gtls_map_kx_get_cred (algo, server), err);
 }
 
 const void *
-mhd_gtls_get_cred (mhd_gtls_key_st key, enum MHD_GNUTLS_CredentialsType type,
+MHD_gtls_get_cred (MHD_gtls_key_st key, enum MHD_GNUTLS_CredentialsType type,
                    int *err)
 {
   const void *retval = NULL;
@@ -258,10 +258,10 @@ out:
 }
 
 /*-
-  * mhd_gtls_get_auth_info - Returns a pointer to authentication information.
-  * @session: is a #mhd_gtls_session_t structure.
+  * MHD_gtls_get_auth_info - Returns a pointer to authentication information.
+  * @session: is a #MHD_gtls_session_t structure.
   *
-  * This function must be called after a succesful MHD_gnutls_handshake().
+  * This function must be called after a succesful MHD__gnutls_handshake().
   * Returns a pointer to authentication information. That information
   * is data obtained by the handshake protocol, the key exchange algorithm,
   * and the TLS extensions messages.
@@ -271,28 +271,28 @@ out:
   * In case of GNUTLS_CRD_SRP returns a type of &srp_(server/client)_auth_info_t;
   -*/
 void *
-mhd_gtls_get_auth_info (mhd_gtls_session_t session)
+MHD_gtls_get_auth_info (MHD_gtls_session_t session)
 {
   return session->key->auth_info;
 }
 
 /*-
-  * mhd_gtls_free_auth_info - Frees the auth info structure
-  * @session: is a #mhd_gtls_session_t structure.
+  * MHD_gtls_free_auth_info - Frees the auth info structure
+  * @session: is a #MHD_gtls_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
-mhd_gtls_free_auth_info (mhd_gtls_session_t session)
+MHD_gtls_free_auth_info (MHD_gtls_session_t session)
 {
-  mhd_gtls_dh_info_st *dh_info;
+  MHD_gtls_dh_info_st *dh_info;
   rsa_info_st *rsa_info;
 
   if (session == NULL || session->key == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return;
     }
 
@@ -302,19 +302,19 @@ mhd_gtls_free_auth_info (mhd_gtls_session_t session)
       break;
     case MHD_GNUTLS_CRD_ANON:
       {
-        mhd_anon_auth_info_t info = mhd_gtls_get_auth_info (session);
+        mhd_anon_auth_info_t info = MHD_gtls_get_auth_info (session);
 
         if (info == NULL)
           break;
 
         dh_info = &info->dh;
-        mhd_gtls_free_dh_info (dh_info);
+        MHD_gtls_free_dh_info (dh_info);
       }
       break;
     case MHD_GNUTLS_CRD_CERTIFICATE:
       {
         unsigned int i;
-        cert_auth_info_t info = mhd_gtls_get_auth_info (session);
+        cert_auth_info_t info = MHD_gtls_get_auth_info (session);
 
         if (info == NULL)
           break;
@@ -323,15 +323,15 @@ mhd_gtls_free_auth_info (mhd_gtls_session_t session)
         rsa_info = &info->rsa_export;
         for (i = 0; i < info->ncerts; i++)
           {
-            _gnutls_free_datum (&info->raw_certificate_list[i]);
+            MHD__gnutls_free_datum (&info->raw_certificate_list[i]);
           }
 
-        gnutls_free (info->raw_certificate_list);
+        MHD_gnutls_free (info->raw_certificate_list);
         info->raw_certificate_list = NULL;
         info->ncerts = 0;
 
-        mhd_gtls_free_dh_info (dh_info);
-        mhd_gtls_free_rsa_info (rsa_info);
+        MHD_gtls_free_dh_info (dh_info);
+        MHD_gtls_free_rsa_info (rsa_info);
       }
 
 
@@ -341,7 +341,7 @@ mhd_gtls_free_auth_info (mhd_gtls_session_t session)
 
     }
 
-  gnutls_free (session->key->auth_info);
+  MHD_gnutls_free (session->key->auth_info);
   session->key->auth_info = NULL;
   session->key->auth_info_size = 0;
   session->key->auth_info_type = 0;
@@ -354,16 +354,16 @@ mhd_gtls_free_auth_info (mhd_gtls_session_t session)
  * info structure to a different type.
  */
 int
-mhd_gtls_auth_info_set (mhd_gtls_session_t session,
+MHD_gtls_auth_info_set (MHD_gtls_session_t session,
                         enum MHD_GNUTLS_CredentialsType type, int size,
                         int allow_change)
 {
   if (session->key->auth_info == NULL)
     {
-      session->key->auth_info = gnutls_calloc (1, size);
+      session->key->auth_info = MHD_gnutls_calloc (1, size);
       if (session->key->auth_info == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_MEMORY_ERROR;
         }
       session->key->auth_info_type = type;
@@ -382,7 +382,7 @@ mhd_gtls_auth_info_set (mhd_gtls_session_t session,
           if (MHD_gtls_auth_get_type (session) !=
               session->key->auth_info_type)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return GNUTLS_E_INVALID_REQUEST;
             }
         }
@@ -398,12 +398,12 @@ mhd_gtls_auth_info_set (mhd_gtls_session_t session,
               session->key->auth_info_type)
             {
 
-              mhd_gtls_free_auth_info (session);
+              MHD_gtls_free_auth_info (session);
 
               session->key->auth_info = calloc (1, size);
               if (session->key->auth_info == NULL)
                 {
-                  gnutls_assert ();
+                  MHD_gnutls_assert ();
                   return GNUTLS_E_MEMORY_ERROR;
                 }
 
diff --git a/src/daemon/https/tls/gnutls_auth.h b/src/daemon/https/tls/gnutls_auth.h
index a29a1faa..4956268c 100644
--- a/src/daemon/https/tls/gnutls_auth.h
+++ b/src/daemon/https/tls/gnutls_auth.h
@@ -25,27 +25,27 @@
 #ifndef GNUTLS_AUTH_H
 #define GNUTLS_AUTH_H
 
-typedef struct mhd_gtls_mod_auth_st_int
+typedef struct MHD_gtls_mod_auth_st_int
 {
   const char *name;             /* null terminated */
-  int (*mhd_gtls_gen_server_certificate) (mhd_gtls_session_t, opaque **);
-  int (*mhd_gtls_gen_client_certificate) (mhd_gtls_session_t, opaque **);
-  int (*mhd_gtls_gen_server_kx) (mhd_gtls_session_t, opaque **);
-  int (*mhd_gtls_gen_client_kx) (mhd_gtls_session_t, opaque **);        /* used in SRP */
-  int (*mhd_gtls_gen_client_cert_vrfy) (mhd_gtls_session_t, opaque **);
-  int (*mhd_gtls_gen_server_certificate_request) (mhd_gtls_session_t,
+  int (*MHD_gtls_gen_server_certificate) (MHD_gtls_session_t, opaque **);
+  int (*MHD_gtls_gen_client_certificate) (MHD_gtls_session_t, opaque **);
+  int (*MHD_gtls_gen_server_kx) (MHD_gtls_session_t, opaque **);
+  int (*MHD_gtls_gen_client_kx) (MHD_gtls_session_t, opaque **);        /* used in SRP */
+  int (*MHD_gtls_gen_client_cert_vrfy) (MHD_gtls_session_t, opaque **);
+  int (*MHD_gtls_gen_server_certificate_request) (MHD_gtls_session_t,
                                                   opaque **);
 
-  int (*mhd_gtls_process_server_certificate) (mhd_gtls_session_t, opaque *,
+  int (*MHD_gtls_process_server_certificate) (MHD_gtls_session_t, opaque *,
                                               size_t);
-  int (*mhd_gtls_process_client_certificate) (mhd_gtls_session_t, opaque *,
+  int (*MHD_gtls_process_client_certificate) (MHD_gtls_session_t, opaque *,
                                               size_t);
-  int (*mhd_gtls_process_server_kx) (mhd_gtls_session_t, opaque *, size_t);
-  int (*mhd_gtls_process_client_kx) (mhd_gtls_session_t, opaque *, size_t);
-  int (*mhd_gtls_process_client_cert_vrfy) (mhd_gtls_session_t, opaque *,
+  int (*MHD_gtls_process_server_kx) (MHD_gtls_session_t, opaque *, size_t);
+  int (*MHD_gtls_process_client_kx) (MHD_gtls_session_t, opaque *, size_t);
+  int (*MHD_gtls_process_client_cert_vrfy) (MHD_gtls_session_t, opaque *,
                                             size_t);
-  int (*mhd_gtls_process_server_certificate_request) (mhd_gtls_session_t,
+  int (*MHD_gtls_process_server_certificate_request) (MHD_gtls_session_t,
                                                       opaque *, size_t);
-} mhd_gtls_mod_auth_st;
+} MHD_gtls_mod_auth_st;
 
 #endif
diff --git a/src/daemon/https/tls/gnutls_auth_int.h b/src/daemon/https/tls/gnutls_auth_int.h
index ac821277..425dc8a3 100644
--- a/src/daemon/https/tls/gnutls_auth_int.h
+++ b/src/daemon/https/tls/gnutls_auth_int.h
@@ -22,12 +22,12 @@
  *
  */
 
-const void *mhd_gtls_get_cred (mhd_gtls_key_st key,
+const void *MHD_gtls_get_cred (MHD_gtls_key_st key,
                                enum MHD_GNUTLS_CredentialsType kx, int *err);
-const void *mhd_gtls_get_kx_cred (mhd_gtls_session_t session,
+const void *MHD_gtls_get_kx_cred (MHD_gtls_session_t session,
                                   enum MHD_GNUTLS_KeyExchangeAlgorithm algo,
                                   int *err);
-void *mhd_gtls_get_auth_info (mhd_gtls_session_t session);
-int mhd_gtls_auth_info_set (mhd_gtls_session_t session,
+void *MHD_gtls_get_auth_info (MHD_gtls_session_t session);
+int MHD_gtls_auth_info_set (MHD_gtls_session_t session,
                             enum MHD_GNUTLS_CredentialsType type, int size,
                             int allow_change);
diff --git a/src/daemon/https/tls/gnutls_buffers.c b/src/daemon/https/tls/gnutls_buffers.c
index 5ea95e5f..0a0f367b 100644
--- a/src/daemon/https/tls/gnutls_buffers.c
+++ b/src/daemon/https/tls/gnutls_buffers.c
@@ -30,20 +30,20 @@
  * RECORD LAYER:
  *  1. uses a buffer to hold data (application/handshake),
  *    we got but they were not requested, yet.
- *  (see gnutls_record_buffer_put(), gnutls_record_buffer_get_size() etc.)
+ *  (see MHD_gnutls_record_buffer_put(), MHD_gnutls_record_buffer_get_size() etc.)
  *
  *  2. uses a buffer to hold data that were incomplete (ie the read/write
  *    was interrupted)
- *  (see mhd_gtls_io_read_buffered(), mhd_gtls_io_write_buffered() etc.)
+ *  (see MHD_gtls_io_read_buffered(), MHD_gtls_io_write_buffered() etc.)
  *
  * HANDSHAKE LAYER:
  *  1. Uses a buffer to hold data that was not sent or received
  *  complete. (E.g. sent 10 bytes of a handshake packet that is 20 bytes
  *  long).
- * (see _gnutls_handshake_send_int(), _gnutls_handshake_recv_int())
+ * (see MHD__gnutls_handshake_send_int(), MHD__gnutls_handshake_recv_int())
  *
  *  2. Uses buffer to hold the last received handshake message.
- *  (see mhd_gtls_handshake_buffer_put() etc.)
+ *  (see MHD_gtls_handshake_buffer_put() etc.)
  *
  */
 
@@ -68,8 +68,8 @@
 #endif
 
 /**
- * MHD_gnutls_transport_set_errno:
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD__gnutls_transport_set_errno:
+ * @session: is a #MHD_gtls_session_t structure.
  * @err: error value to store in session-specific errno variable.
  *
  * Store @err in the session-specific errno variable.  Useful values
@@ -77,24 +77,24 @@
  * treated as real errors in the push/pull function.
  *
  * This function is useful in replacement push/pull functions set by
- * MHD_gnutls_transport_set_push_function and
- * gnutls_transport_set_pullpush_function under Windows, where the
+ * MHD__gnutls_transport_set_push_function and
+ * MHD_gnutls_transport_set_pullpush_function under Windows, where the
  * replacement push/pull may not have access to the same @errno
  * variable that is used by GnuTLS (e.g., the application is linked to
  * msvcr71.dll and gnutls is linked to msvcrt.dll).
  *
  * If you don't have the @session variable easily accessible from the
  * push/pull function, and don't worry about thread conflicts, you can
- * also use MHD_gnutls_transport_set_global_errno().
+ * also use MHD__gnutls_transport_set_global_errno().
  **/
 void
-MHD_gnutls_transport_set_errno (mhd_gtls_session_t session, int err)
+MHD__gnutls_transport_set_errno (MHD_gtls_session_t session, int err)
 {
   session->internals.errnum = err;
 }
 
 /**
- * MHD_gnutls_transport_set_global_errno:
+ * MHD__gnutls_transport_set_global_errno:
  * @err: error value to store in global errno variable.
  *
  * Store @err in the global errno variable.  Useful values for @err is
@@ -102,8 +102,8 @@ MHD_gnutls_transport_set_errno (mhd_gtls_session_t session, int err)
  * errors in the push/pull function.
  *
  * This function is useful in replacement push/pull functions set by
- * MHD_gnutls_transport_set_push_function and
- * gnutls_transport_set_pullpush_function under Windows, where the
+ * MHD__gnutls_transport_set_push_function and
+ * MHD_gnutls_transport_set_pullpush_function under Windows, where the
  * replacement push/pull may not have access to the same @errno
  * variable that is used by GnuTLS (e.g., the application is linked to
  * msvcr71.dll and gnutls is linked to msvcrt.dll).
@@ -111,10 +111,10 @@ MHD_gnutls_transport_set_errno (mhd_gtls_session_t session, int err)
  * Whether this function is thread safe or not depends on whether the
  * global variable errno is thread safe, some system libraries make it
  * a thread-local variable.  When feasible, using the guaranteed
- * thread-safe MHD_gnutls_transport_set_errno() may be better.
+ * thread-safe MHD__gnutls_transport_set_errno() may be better.
  **/
 void
-MHD_gnutls_transport_set_global_errno (int err)
+MHD__gnutls_transport_set_global_errno (int err)
 {
   errno = err;
 }
@@ -123,11 +123,11 @@ MHD_gnutls_transport_set_global_errno (int err)
  * HANDSHAKE DATA.
  */
 int
-mhd_gnutls_record_buffer_put (content_type_t type,
-                              mhd_gtls_session_t session, opaque * data,
+MHD_gnutls_record_buffer_put (content_type_t type,
+                              MHD_gtls_session_t session, opaque * data,
                               size_t length)
 {
-  mhd_gtls_buffer *buf;
+  MHD_gtls_buffer *buf;
 
   if (length == 0)
     return 0;
@@ -136,30 +136,30 @@ mhd_gnutls_record_buffer_put (content_type_t type,
     {
     case GNUTLS_APPLICATION_DATA:
       buf = &session->internals.application_data_buffer;
-      _gnutls_buffers_log ("BUF[REC]: Inserted %d bytes of Data(%d)\n",
+      MHD__gnutls_buffers_log ("BUF[REC]: Inserted %d bytes of Data(%d)\n",
                            length, type);
       break;
 
     case GNUTLS_HANDSHAKE:
       buf = &session->internals.handshake_data_buffer;
-      _gnutls_buffers_log ("BUF[HSK]: Inserted %d bytes of Data(%d)\n",
+      MHD__gnutls_buffers_log ("BUF[HSK]: Inserted %d bytes of Data(%d)\n",
                            length, type);
       break;
 
     case GNUTLS_INNER_APPLICATION:
       buf = &session->internals.ia_data_buffer;
-      _gnutls_buffers_log ("BUF[IA]: Inserted %d bytes of Data(%d)\n", length,
+      MHD__gnutls_buffers_log ("BUF[IA]: Inserted %d bytes of Data(%d)\n", length,
                            type);
       break;
 
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  if (mhd_gtls_buffer_append (buf, data, length) < 0)
+  if (MHD_gtls_buffer_append (buf, data, length) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
@@ -167,8 +167,8 @@ mhd_gnutls_record_buffer_put (content_type_t type,
 }
 
 int
-mhd_gnutls_record_buffer_get_size (content_type_t type,
-                                   mhd_gtls_session_t session)
+MHD_gnutls_record_buffer_get_size (content_type_t type,
+                                   MHD_gtls_session_t session)
 {
   switch (type)
     {
@@ -188,7 +188,7 @@ mhd_gnutls_record_buffer_get_size (content_type_t type,
 
 /**
  * MHD_gtls_record_check_pending - checks if there are any data to receive in gnutls buffers.
- * @session: is a #mhd_gtls_session_t structure.
+ * @session: is a #MHD_gtls_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.
@@ -198,18 +198,18 @@ mhd_gnutls_record_buffer_get_size (content_type_t type,
  * to work).
  **/
 size_t
-MHD_gtls_record_check_pending (mhd_gtls_session_t session)
+MHD_gtls_record_check_pending (MHD_gtls_session_t session)
 {
-  return mhd_gnutls_record_buffer_get_size (GNUTLS_APPLICATION_DATA, session);
+  return MHD_gnutls_record_buffer_get_size (GNUTLS_APPLICATION_DATA, session);
 }
 
 int
-mhd_gtls_record_buffer_get (content_type_t type, mhd_gtls_session_t session,
+MHD_gtls_record_buffer_get (content_type_t type, MHD_gtls_session_t session,
                             opaque * data, size_t length)
 {
   if (length == 0 || data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -222,7 +222,7 @@ mhd_gtls_record_buffer_get (content_type_t type, mhd_gtls_session_t session,
           length = session->internals.application_data_buffer.length;
         }
 
-      _gnutls_buffers_log ("BUFFER[REC][AD]: Read %d bytes of Data(%d)\n",
+      MHD__gnutls_buffers_log ("BUFFER[REC][AD]: Read %d bytes of Data(%d)\n",
                            length, type);
 
       session->internals.application_data_buffer.length -= length;
@@ -245,7 +245,7 @@ mhd_gtls_record_buffer_get (content_type_t type, mhd_gtls_session_t session,
           length = session->internals.handshake_data_buffer.length;
         }
 
-      _gnutls_buffers_log ("BUF[REC][HD]: Read %d bytes of Data(%d)\n",
+      MHD__gnutls_buffers_log ("BUF[REC][HD]: Read %d bytes of Data(%d)\n",
                            length, type);
 
       session->internals.handshake_data_buffer.length -= length;
@@ -262,7 +262,7 @@ mhd_gtls_record_buffer_get (content_type_t type, mhd_gtls_session_t session,
       if (length > session->internals.ia_data_buffer.length)
         length = session->internals.ia_data_buffer.length;
 
-      _gnutls_buffers_log ("BUF[REC][IA]: Read %d bytes of Data(%d)\n",
+      MHD__gnutls_buffers_log ("BUF[REC][IA]: Read %d bytes of Data(%d)\n",
                            length, type);
 
       session->internals.ia_data_buffer.length -= length;
@@ -276,7 +276,7 @@ mhd_gtls_record_buffer_get (content_type_t type, mhd_gtls_session_t session,
       break;
 
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -284,19 +284,19 @@ mhd_gtls_record_buffer_get (content_type_t type, mhd_gtls_session_t session,
 }
 
 /* This function is like read. But it does not return -1 on error.
- * It does return gnutls_errno instead.
+ * It does return MHD_gnutls_errno instead.
  *
  * Flags are only used if the default recv() function is being used.
  */
 static ssize_t
-_gnutls_read (mhd_gtls_session_t session, void *iptr,
+MHD__gnutls_read (MHD_gtls_session_t session, void *iptr,
               size_t sizeOfPtr, int flags)
 {
   size_t left;
   ssize_t i = 0;
   char *ptr = iptr;
   unsigned j, x, sum = 0;
-  gnutls_transport_ptr_t fd = session->internals.transport_recv_ptr;
+  MHD_gnutls_transport_ptr_t fd = session->internals.transport_recv_ptr;
 
   session->internals.direction = 0;
 
@@ -304,7 +304,7 @@ _gnutls_read (mhd_gtls_session_t session, void *iptr,
   while (left > 0)
     {
       session->internals.errnum = 0;
-      if (session->internals._gnutls_pull_func == NULL)
+      if (session->internals.MHD__gnutls_pull_func == NULL)
         {
           i =
             recv (GNUTLS_POINTER_TO_INT (fd), &ptr[sizeOfPtr - left], left,
@@ -332,7 +332,7 @@ _gnutls_read (mhd_gtls_session_t session, void *iptr,
 #endif
         }
       else
-        i = session->internals._gnutls_pull_func (fd,
+        i = session->internals.MHD__gnutls_pull_func (fd,
                                                   &ptr[sizeOfPtr - left],
                                                   left);
 
@@ -341,7 +341,7 @@ _gnutls_read (mhd_gtls_session_t session, void *iptr,
           int err = session->internals.errnum ? session->internals.errnum
             : errno;
 
-          _gnutls_read_log ("READ: %d returned from %d, errno=%d gerrno=%d\n",
+          MHD__gnutls_read_log ("READ: %d returned from %d, errno=%d gerrno=%d\n",
                             i, fd, errno, session->internals.errnum);
 
           if (err == EAGAIN || err == EINTR)
@@ -349,12 +349,12 @@ _gnutls_read (mhd_gtls_session_t session, void *iptr,
               if (sizeOfPtr - left > 0)
                 {
 
-                  _gnutls_read_log ("READ: returning %d bytes from %d\n",
+                  MHD__gnutls_read_log ("READ: returning %d bytes from %d\n",
                                     sizeOfPtr - left, fd);
 
                   goto finish;
                 }
-              gnutls_assert ();
+              MHD_gnutls_assert ();
 
               if (err == EAGAIN)
                 return GNUTLS_E_AGAIN;
@@ -362,14 +362,14 @@ _gnutls_read (mhd_gtls_session_t session, void *iptr,
             }
           else
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return GNUTLS_E_PULL_ERROR;
             }
         }
       else
         {
 
-          _gnutls_read_log ("READ: Got %d bytes from %d\n", i, fd);
+          MHD__gnutls_read_log ("READ: Got %d bytes from %d\n", i, fd);
 
           if (i == 0)
             break;              /* EOF */
@@ -381,12 +381,12 @@ _gnutls_read (mhd_gtls_session_t session, void *iptr,
 
 finish:
 
-  if (_gnutls_log_level >= 7)
+  if (MHD__gnutls_log_level >= 7)
     {
       char line[128];
       char tmp[16];
 
-      _gnutls_read_log ("READ: read %d bytes from %d\n", (sizeOfPtr - left),
+      MHD__gnutls_read_log ("READ: read %d bytes from %d\n", (sizeOfPtr - left),
                         fd);
 
       for (x = 0; x < ((sizeOfPtr - left) / 16) + 1; x++)
@@ -394,17 +394,17 @@ finish:
           line[0] = 0;
 
           sprintf (tmp, "%.4x - ", x);
-          mhd_gtls_str_cat (line, sizeof (line), tmp);
+          MHD_gtls_str_cat (line, sizeof (line), tmp);
 
           for (j = 0; j < 16; j++)
             {
               if (sum < (sizeOfPtr - left))
                 {
                   sprintf (tmp, "%.2x ", ((unsigned char *) ptr)[sum++]);
-                  mhd_gtls_str_cat (line, sizeof (line), tmp);
+                  MHD_gtls_str_cat (line, sizeof (line), tmp);
                 }
             }
-          _gnutls_read_log ("%s\n", line);
+          MHD__gnutls_read_log ("%s\n", line);
         }
     }
 
@@ -417,7 +417,7 @@ finish:
  * Clears the peeked data (read with MSG_PEEK).
  */
 int
-mhd_gtls_io_clear_peeked_data (mhd_gtls_session_t session)
+MHD_gtls_io_clear_peeked_data (MHD_gtls_session_t session)
 {
   char *peekdata;
   int ret, sum;
@@ -425,10 +425,10 @@ mhd_gtls_io_clear_peeked_data (mhd_gtls_session_t session)
   if (session->internals.have_peeked_data == 0 || RCVLOWAT == 0)
     return 0;
 
-  peekdata = gnutls_alloca (RCVLOWAT);
+  peekdata = MHD_gnutls_alloca (RCVLOWAT);
   if (peekdata == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
@@ -436,18 +436,18 @@ mhd_gtls_io_clear_peeked_data (mhd_gtls_session_t session)
   sum = 0;
   do
     {                           /* we need this to finish now */
-      ret = _gnutls_read (session, peekdata, RCVLOWAT - sum, 0);
+      ret = MHD__gnutls_read (session, peekdata, RCVLOWAT - sum, 0);
       if (ret > 0)
         sum += ret;
     }
   while (ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN || sum
          < RCVLOWAT);
 
-  gnutls_afree (peekdata);
+  MHD_gnutls_afree (peekdata);
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -457,13 +457,13 @@ mhd_gtls_io_clear_peeked_data (mhd_gtls_session_t session)
 }
 
 void
-mhd_gtls_io_clear_read_buffer (mhd_gtls_session_t session)
+MHD_gtls_io_clear_read_buffer (MHD_gtls_session_t session)
 {
   session->internals.record_recv_buffer.length = 0;
 }
 
 /* This function is like recv(with MSG_PEEK). But it does not return -1 on error.
- * It does return gnutls_errno instead.
+ * It does return MHD_gnutls_errno instead.
  * This function reads data from the socket and keeps them in a buffer, of up to
  * MAX_RECV_SIZE.
  *
@@ -472,7 +472,7 @@ mhd_gtls_io_clear_read_buffer (mhd_gtls_session_t session)
  *
  */
 ssize_t
-mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
+MHD_gtls_io_read_buffered (MHD_gtls_session_t session, opaque ** iptr,
                            size_t sizeOfPtr, content_type_t recv_type)
 {
   ssize_t ret = 0, ret2 = 0;
@@ -486,14 +486,14 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
 
   if (sizeOfPtr > MAX_RECV_SIZE || sizeOfPtr == 0)
     {
-      gnutls_assert ();         /* internal error */
+      MHD_gnutls_assert ();         /* internal error */
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   /* If an external pull function is used, then do not leave
    * any data into the kernel buffer.
    */
-  if (session->internals._gnutls_pull_func != NULL)
+  if (session->internals.MHD__gnutls_pull_func != NULL)
     {
       recvlowat = 0;
     }
@@ -536,7 +536,7 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
   if ((session->internals.record_recv_buffer.length + recvdata)
       > MAX_RECV_SIZE)
     {
-      gnutls_assert ();         /* internal error */
+      MHD_gnutls_assert ();         /* internal error */
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -544,11 +544,11 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
    */
   alloc_size = recvdata + session->internals.record_recv_buffer.length;
   session->internals.record_recv_buffer.data =
-    mhd_gtls_realloc_fast (session->internals.record_recv_buffer.data,
+    MHD_gtls_realloc_fast (session->internals.record_recv_buffer.data,
                            alloc_size);
   if (session->internals.record_recv_buffer.data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
@@ -559,7 +559,7 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
   /* READ DATA - but leave RCVLOWAT bytes in the kernel buffer. */
   if (recvdata - recvlowat > 0)
     {
-      ret = _gnutls_read (session, &buf[buf_pos], recvdata - recvlowat, 0);
+      ret = MHD__gnutls_read (session, &buf[buf_pos], recvdata - recvlowat, 0);
 
       /* return immediately if we got an interrupt or eagain
        * error.
@@ -574,9 +574,9 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
    */
   if (ret > 0)
     {
-      _gnutls_read_log ("RB: Have %d bytes into buffer. Adding %d bytes.\n",
+      MHD__gnutls_read_log ("RB: Have %d bytes into buffer. Adding %d bytes.\n",
                         session->internals.record_recv_buffer.length, ret);
-      _gnutls_read_log ("RB: Requested %d bytes\n", sizeOfPtr);
+      MHD__gnutls_read_log ("RB: Requested %d bytes\n", sizeOfPtr);
       session->internals.record_recv_buffer.length += ret;
     }
 
@@ -589,7 +589,7 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
    */
   if (ret == (recvdata - recvlowat) && recvlowat > 0)
     {
-      ret2 = _gnutls_read (session, &buf[buf_pos], recvlowat, MSG_PEEK);
+      ret2 = MHD__gnutls_read (session, &buf[buf_pos], recvlowat, MSG_PEEK);
 
       if (ret2 < 0 && MHD_gtls_error_is_fatal (ret2) == 0)
         {
@@ -598,8 +598,8 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
 
       if (ret2 > 0)
         {
-          _gnutls_read_log ("RB-PEEK: Read %d bytes in PEEK MODE.\n", ret2);
-          _gnutls_read_log
+          MHD__gnutls_read_log ("RB-PEEK: Read %d bytes in PEEK MODE.\n", ret2);
+          MHD__gnutls_read_log
             ("RB-PEEK: Have %d bytes into buffer. Adding %d bytes.\nRB: Requested %d bytes\n",
              session->internals.record_recv_buffer.length, ret2, sizeOfPtr);
           session->internals.have_peeked_data = 1;
@@ -610,7 +610,7 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
 
   if (ret < 0 || ret2 < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       /* that's because they are initialized to 0 */
       return MIN (ret, ret2);
     }
@@ -619,13 +619,13 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
 
   if (ret > 0 && ret < recvlowat)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_AGAIN;
     }
 
   if (ret == 0)
     {                           /* EOF */
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return 0;
     }
 
@@ -634,7 +634,7 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
   if ((ret > 0) && ((size_t) ret < sizeOfPtr))
     {
       /* Short Read */
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_AGAIN;
     }
   else
@@ -651,7 +651,7 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
 #define MEMSUB(x,y) ((ssize_t)((ptrdiff_t)x-(ptrdiff_t)y))
 
 inline static int
-_gnutls_buffer_insert (mhd_gtls_buffer * buffer,
+MHD__gnutls_buffer_insert (MHD_gtls_buffer * buffer,
                        const opaque * _data, size_t data_size)
 {
 
@@ -662,7 +662,7 @@ _gnutls_buffer_insert (mhd_gtls_buffer * buffer,
        */
       if (data_size > buffer->length)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           /* this shouldn't have happened */
           return GNUTLS_E_INTERNAL_ERROR;
         }
@@ -680,9 +680,9 @@ _gnutls_buffer_insert (mhd_gtls_buffer * buffer,
 
     }
 
-  if (mhd_gtls_buffer_append (buffer, _data, data_size) < 0)
+  if (MHD_gtls_buffer_append (buffer, _data, data_size) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
@@ -690,7 +690,7 @@ _gnutls_buffer_insert (mhd_gtls_buffer * buffer,
 }
 
 inline static int
-_gnutls_buffer_get (mhd_gtls_buffer * buffer,
+MHD__gnutls_buffer_get (MHD_gtls_buffer * buffer,
                     const opaque ** ptr, size_t * ptr_size)
 {
   *ptr_size = buffer->length;
@@ -700,9 +700,9 @@ _gnutls_buffer_get (mhd_gtls_buffer * buffer,
 }
 
 /* This function is like write. But it does not return -1 on error.
- * It does return gnutls_errno instead.
+ * It does return MHD_gnutls_errno instead.
  *
- * In case of E_AGAIN and E_INTERRUPTED errors, you must call gnutls_write_flush(),
+ * In case of E_AGAIN and E_INTERRUPTED errors, you must call MHD_gnutls_write_flush(),
  * until it returns ok (0).
  *
  * We need to push exactly the data in n, since we cannot send less
@@ -711,7 +711,7 @@ _gnutls_buffer_get (mhd_gtls_buffer * buffer,
  *
  */
 ssize_t
-mhd_gtls_io_write_buffered (mhd_gtls_session_t session,
+MHD_gtls_io_write_buffered (MHD_gtls_session_t session,
                             const void *iptr, size_t n)
 {
   size_t left;
@@ -719,7 +719,7 @@ mhd_gtls_io_write_buffered (mhd_gtls_session_t session,
   ssize_t retval, i;
   const opaque *ptr;
   int ret;
-  gnutls_transport_ptr_t fd = session->internals.transport_send_ptr;
+  MHD_gnutls_transport_ptr_t fd = session->internals.transport_send_ptr;
 
   /* to know where the procedure was interrupted.
    */
@@ -733,7 +733,7 @@ mhd_gtls_io_write_buffered (mhd_gtls_session_t session,
    */
   if (session->internals.record_send_buffer.length > 0 && iptr != NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -742,19 +742,19 @@ mhd_gtls_io_write_buffered (mhd_gtls_session_t session,
   if (iptr == NULL)
     {
       /* checking is handled above */
-      ret = _gnutls_buffer_get (&session->internals.record_send_buffer, &ptr,
+      ret = MHD__gnutls_buffer_get (&session->internals.record_send_buffer, &ptr,
                                 &n);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
-      _gnutls_write_log ("WRITE: Restoring old write. (%d bytes to send)\n",
+      MHD__gnutls_write_log ("WRITE: Restoring old write. (%d bytes to send)\n",
                          n);
     }
 
-  _gnutls_write_log ("WRITE: Will write %d bytes to %d.\n", n, fd);
+  MHD__gnutls_write_log ("WRITE: Will write %d bytes to %d.\n", n, fd);
 
   i = 0;
   left = n;
@@ -763,7 +763,7 @@ mhd_gtls_io_write_buffered (mhd_gtls_session_t session,
 
       session->internals.errnum = 0;
 
-      if (session->internals._gnutls_push_func == NULL)
+      if (session->internals.MHD__gnutls_push_func == NULL)
         {
           i = send (GNUTLS_POINTER_TO_INT (fd), &ptr[n - left], left, 0);
 #if HAVE_WINSOCK
@@ -789,7 +789,7 @@ mhd_gtls_io_write_buffered (mhd_gtls_session_t session,
 #endif
         }
       else
-        i = session->internals._gnutls_push_func (fd, &ptr[n - left], left);
+        i = session->internals.MHD__gnutls_push_func (fd, &ptr[n - left], left);
 
       if (i == -1)
         {
@@ -801,15 +801,15 @@ mhd_gtls_io_write_buffered (mhd_gtls_session_t session,
               session->internals.record_send_buffer_prev_size += n - left;
 
               retval =
-                _gnutls_buffer_insert (&session->internals.record_send_buffer,
+                MHD__gnutls_buffer_insert (&session->internals.record_send_buffer,
                                        &ptr[n - left], left);
               if (retval < 0)
                 {
-                  gnutls_assert ();
+                  MHD_gnutls_assert ();
                   return retval;
                 }
 
-              _gnutls_write_log
+              MHD__gnutls_write_log
                 ("WRITE: Interrupted. Stored %d bytes to buffer. Already sent %d bytes.\n",
                  left, n - left);
 
@@ -819,18 +819,18 @@ mhd_gtls_io_write_buffered (mhd_gtls_session_t session,
             }
           else
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return GNUTLS_E_PUSH_ERROR;
             }
         }
       left -= i;
 
-      if (_gnutls_log_level >= 7)
+      if (MHD__gnutls_log_level >= 7)
         {
           char line[128];
           char tmp[16];
 
-          _gnutls_write_log
+          MHD__gnutls_write_log
             ("WRITE: wrote %d bytes to %d. Left %d bytes. Total %d bytes.\n",
              i, fd, left, n);
           for (x = 0; x < (unsigned) ((i) / 16) + 1; x++)
@@ -841,19 +841,19 @@ mhd_gtls_io_write_buffered (mhd_gtls_session_t session,
                 break;
 
               sprintf (tmp, "%.4x - ", x);
-              mhd_gtls_str_cat (line, sizeof (line), tmp);
+              MHD_gtls_str_cat (line, sizeof (line), tmp);
 
               for (j = 0; j < 16; j++)
                 {
                   if (sum < n - left)
                     {
                       sprintf (tmp, "%.2x ", ((unsigned char *) ptr)[sum++]);
-                      mhd_gtls_str_cat (line, sizeof (line), tmp);
+                      MHD_gtls_str_cat (line, sizeof (line), tmp);
                     }
                   else
                     break;
                 }
-              _gnutls_write_log ("%s\n", line);
+              MHD__gnutls_write_log ("%s\n", line);
             }
         }
     }
@@ -872,15 +872,15 @@ mhd_gtls_io_write_buffered (mhd_gtls_session_t session,
  * interrupted.
  */
 ssize_t
-mhd_gtls_io_write_flush (mhd_gtls_session_t session)
+MHD_gtls_io_write_flush (MHD_gtls_session_t session)
 {
   ssize_t ret;
 
   if (session->internals.record_send_buffer.length == 0)
     return 0;                   /* done */
 
-  ret = mhd_gtls_io_write_buffered (session, NULL, 0);
-  _gnutls_write_log ("WRITE FLUSH: %d [buffer: %d]\n", ret,
+  ret = MHD_gtls_io_write_buffered (session, NULL, 0);
+  MHD__gnutls_write_log ("WRITE FLUSH: %d [buffer: %d]\n", ret,
                      session->internals.record_send_buffer.length);
 
   return ret;
@@ -891,17 +891,17 @@ mhd_gtls_io_write_flush (mhd_gtls_session_t session)
  * interrupted.
  */
 ssize_t
-mhd_gtls_handshake_io_write_flush (mhd_gtls_session_t session)
+MHD_gtls_handshake_io_write_flush (MHD_gtls_session_t session)
 {
   ssize_t ret;
-  ret = mhd_gtls_handshake_io_send_int (session, 0, 0, NULL, 0);
+  ret = MHD_gtls_handshake_io_send_int (session, 0, 0, NULL, 0);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  _gnutls_write_log ("HANDSHAKE_FLUSH: written[1] %d bytes\n", ret);
+  MHD__gnutls_write_log ("HANDSHAKE_FLUSH: written[1] %d bytes\n", ret);
 
   if (session->internals.handshake_send_buffer.length == 0)
     {
@@ -916,9 +916,9 @@ mhd_gtls_handshake_io_write_flush (mhd_gtls_session_t session)
  * protocol. Just makes sure that all data have been sent.
  */
 ssize_t
-mhd_gtls_handshake_io_send_int (mhd_gtls_session_t session,
+MHD_gtls_handshake_io_send_int (MHD_gtls_session_t session,
                                 content_type_t type,
-                                gnutls_handshake_description_t htype,
+                                MHD_gnutls_handshake_description_t htype,
                                 const void *iptr, size_t n)
 {
   size_t left;
@@ -933,12 +933,12 @@ mhd_gtls_handshake_io_send_int (mhd_gtls_session_t session,
     {
       /* resuming previously interrupted write
        */
-      gnutls_assert ();
-      ret = _gnutls_buffer_get (&session->internals.handshake_send_buffer,
+      MHD_gnutls_assert ();
+      ret = MHD__gnutls_buffer_get (&session->internals.handshake_send_buffer,
                                 &ptr, &n);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return retval;
         }
 
@@ -948,7 +948,7 @@ mhd_gtls_handshake_io_send_int (mhd_gtls_session_t session,
     }
   else if (session->internals.handshake_send_buffer.length > 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 #ifdef WRITE_DEBUG
@@ -956,65 +956,65 @@ mhd_gtls_handshake_io_send_int (mhd_gtls_session_t session,
     {
       size_t sum = 0, x, j;
 
-      _gnutls_write_log ("HWRITE: will write %d bytes to %d.\n", n,
-                         gnutls_transport_get_ptr (session));
+      MHD__gnutls_write_log ("HWRITE: will write %d bytes to %d.\n", n,
+                         MHD_gnutls_transport_get_ptr (session));
       for (x = 0; x < ((n) / 16) + 1; x++)
         {
           if (sum > n)
             break;
 
-          _gnutls_write_log ("%.4x - ", x);
+          MHD__gnutls_write_log ("%.4x - ", x);
           for (j = 0; j < 16; j++)
             {
               if (sum < n)
                 {
-                  _gnutls_write_log ("%.2x ", ((unsigned char *) ptr)[sum++]);
+                  MHD__gnutls_write_log ("%.2x ", ((unsigned char *) ptr)[sum++]);
                 }
               else
                 break;
             }
-          _gnutls_write_log ("\n");
+          MHD__gnutls_write_log ("\n");
         }
-      _gnutls_write_log ("\n");
+      MHD__gnutls_write_log ("\n");
     }
 #endif
 
   if (n == 0)
     {                           /* if we have no data to send */
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return 0;
     }
   else if (ptr == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
   left = n;
   while (left > 0)
     {
-      ret = mhd_gtls_send_int (session, type, htype, &ptr[n - left], left);
+      ret = MHD_gtls_send_int (session, type, htype, &ptr[n - left], left);
 
       if (ret <= 0)
         {
           if (ret == 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               ret = GNUTLS_E_INTERNAL_ERROR;
             }
 
           if (left > 0 && (ret == GNUTLS_E_INTERRUPTED || ret
                            == GNUTLS_E_AGAIN))
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
 
               retval =
-                _gnutls_buffer_insert (&session->internals.
+                MHD__gnutls_buffer_insert (&session->internals.
                                        handshake_send_buffer, &ptr[n - left],
                                        left);
               if (retval < 0)
                 {
-                  gnutls_assert ();
+                  MHD_gnutls_assert ();
                   return retval;
                 }
 
@@ -1030,7 +1030,7 @@ mhd_gtls_handshake_io_send_int (mhd_gtls_session_t session,
               session->internals.handshake_send_buffer.length = 0;
             }
 
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
       left -= ret;
@@ -1049,9 +1049,9 @@ mhd_gtls_handshake_io_send_int (mhd_gtls_session_t session,
  * protocol. Makes sure that we have received all data.
  */
 ssize_t
-mhd_gtls_handshake_io_recv_int (mhd_gtls_session_t session,
+MHD_gtls_handshake_io_recv_int (MHD_gtls_session_t session,
                                 content_type_t type,
-                                gnutls_handshake_description_t htype,
+                                MHD_gnutls_handshake_description_t htype,
                                 void *iptr, size_t sizeOfPtr)
 {
   size_t left;
@@ -1064,7 +1064,7 @@ mhd_gtls_handshake_io_recv_int (mhd_gtls_session_t session,
 
   if (sizeOfPtr == 0 || iptr == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -1075,7 +1075,7 @@ mhd_gtls_handshake_io_recv_int (mhd_gtls_session_t session,
         {
           /* if requested less data then return it.
            */
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           memcpy (iptr, session->internals.handshake_recv_buffer.data,
                   sizeOfPtr);
 
@@ -1087,7 +1087,7 @@ mhd_gtls_handshake_io_recv_int (mhd_gtls_session_t session,
 
           return sizeOfPtr;
         }
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       memcpy (iptr, session->internals.handshake_recv_buffer.data,
               session->internals.handshake_recv_buffer.length);
 
@@ -1102,21 +1102,21 @@ mhd_gtls_handshake_io_recv_int (mhd_gtls_session_t session,
   while (left > 0)
     {
       dsize = sizeOfPtr - left;
-      i = mhd_gtls_recv_int (session, type, htype, &ptr[dsize], left);
+      i = MHD_gtls_recv_int (session, type, htype, &ptr[dsize], left);
       if (i < 0)
         {
 
           if (dsize > 0 && (i == GNUTLS_E_INTERRUPTED || i == GNUTLS_E_AGAIN))
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
 
               session->internals.handshake_recv_buffer.data
                 =
-                mhd_gtls_realloc_fast (session->internals.
+                MHD_gtls_realloc_fast (session->internals.
                                        handshake_recv_buffer.data, dsize);
               if (session->internals.handshake_recv_buffer.data == NULL)
                 {
-                  gnutls_assert ();
+                  MHD_gnutls_assert ();
                   return GNUTLS_E_MEMORY_ERROR;
                 }
 
@@ -1131,7 +1131,7 @@ mhd_gtls_handshake_io_recv_int (mhd_gtls_session_t session,
           else
             session->internals.handshake_recv_buffer.length = 0;
 
-          gnutls_assert ();
+          MHD_gnutls_assert ();
 
           return i;
         }
@@ -1155,7 +1155,7 @@ mhd_gtls_handshake_io_recv_int (mhd_gtls_session_t session,
  * and finished messages.
  */
 int
-mhd_gtls_handshake_buffer_put (mhd_gtls_session_t session, opaque * data,
+MHD_gtls_handshake_buffer_put (MHD_gtls_session_t session, opaque * data,
                                size_t length)
 {
 
@@ -1172,16 +1172,16 @@ mhd_gtls_handshake_buffer_put (mhd_gtls_session_t session, opaque * data,
                                                                   internals.
                                                                   max_handshake_data_buffer_size))
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
-  _gnutls_buffers_log ("BUF[HSK]: Inserted %d bytes of Data\n", length);
+  MHD__gnutls_buffers_log ("BUF[HSK]: Inserted %d bytes of Data\n", length);
 
-  if (mhd_gtls_buffer_append (&session->internals.handshake_hash_buffer, data,
+  if (MHD_gtls_buffer_append (&session->internals.handshake_hash_buffer, data,
                               length) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
@@ -1189,7 +1189,7 @@ mhd_gtls_handshake_buffer_put (mhd_gtls_session_t session, opaque * data,
 }
 
 int
-mhd_gtls_handshake_buffer_get_size (mhd_gtls_session_t session)
+MHD_gtls_handshake_buffer_get_size (MHD_gtls_session_t session)
 {
 
   return session->internals.handshake_hash_buffer.length;
@@ -1199,7 +1199,7 @@ mhd_gtls_handshake_buffer_get_size (mhd_gtls_session_t session)
  * and returns data from it (peek mode!)
  */
 int
-mhd_gtls_handshake_buffer_peek (mhd_gtls_session_t session, opaque * data,
+MHD_gtls_handshake_buffer_peek (MHD_gtls_session_t session, opaque * data,
                                 size_t length)
 {
   if (length > session->internals.handshake_hash_buffer.length)
@@ -1207,7 +1207,7 @@ mhd_gtls_handshake_buffer_peek (mhd_gtls_session_t session, opaque * data,
       length = session->internals.handshake_hash_buffer.length;
     }
 
-  _gnutls_buffers_log ("BUF[HSK]: Peeked %d bytes of Data\n", length);
+  MHD__gnutls_buffers_log ("BUF[HSK]: Peeked %d bytes of Data\n", length);
 
   memcpy (data, session->internals.handshake_hash_buffer.data, length);
   return length;
@@ -1217,13 +1217,13 @@ mhd_gtls_handshake_buffer_peek (mhd_gtls_session_t session, opaque * data,
  * and returns data from it (peek mode!)
  */
 int
-mhd_gtls_handshake_buffer_get_ptr (mhd_gtls_session_t session,
+MHD_gtls_handshake_buffer_get_ptr (MHD_gtls_session_t session,
                                    opaque ** data_ptr, size_t * length)
 {
   if (length != NULL)
     *length = session->internals.handshake_hash_buffer.length;
 
-  _gnutls_buffers_log ("BUF[HSK]: Peeked %d bytes of Data\n",
+  MHD__gnutls_buffers_log ("BUF[HSK]: Peeked %d bytes of Data\n",
                        session->internals.handshake_hash_buffer.length);
 
   if (data_ptr != NULL)
@@ -1235,10 +1235,10 @@ mhd_gtls_handshake_buffer_get_ptr (mhd_gtls_session_t session,
 /* Does not free the buffer
  */
 int
-mhd_gtls_handshake_buffer_empty (mhd_gtls_session_t session)
+MHD_gtls_handshake_buffer_empty (MHD_gtls_session_t session)
 {
 
-  _gnutls_buffers_log ("BUF[HSK]: Emptied buffer\n");
+  MHD__gnutls_buffers_log ("BUF[HSK]: Emptied buffer\n");
 
   session->internals.handshake_hash_buffer.length = 0;
 
@@ -1246,9 +1246,9 @@ mhd_gtls_handshake_buffer_empty (mhd_gtls_session_t session)
 }
 
 int
-mhd_gtls_handshake_buffer_clear (mhd_gtls_session_t session)
+MHD_gtls_handshake_buffer_clear (MHD_gtls_session_t session)
 {
-  _gnutls_buffers_log ("BUF[HSK]: Cleared Data from buffer\n");
-  mhd_gtls_buffer_clear (&session->internals.handshake_hash_buffer);
+  MHD__gnutls_buffers_log ("BUF[HSK]: Cleared Data from buffer\n");
+  MHD_gtls_buffer_clear (&session->internals.handshake_hash_buffer);
   return 0;
 }
diff --git a/src/daemon/https/tls/gnutls_buffers.h b/src/daemon/https/tls/gnutls_buffers.h
index 609c2095..918da673 100644
--- a/src/daemon/https/tls/gnutls_buffers.h
+++ b/src/daemon/https/tls/gnutls_buffers.h
@@ -22,46 +22,46 @@
  *
  */
 
-int mhd_gnutls_record_buffer_put (content_type_t type,
-                                  mhd_gtls_session_t session, opaque * data,
+int MHD_gnutls_record_buffer_put (content_type_t type,
+                                  MHD_gtls_session_t session, opaque * data,
                                   size_t length);
-int mhd_gnutls_record_buffer_get_size (content_type_t type,
-                                       mhd_gtls_session_t session);
-int mhd_gtls_record_buffer_get (content_type_t type,
-                                mhd_gtls_session_t session, opaque * data,
+int MHD_gnutls_record_buffer_get_size (content_type_t type,
+                                       MHD_gtls_session_t session);
+int MHD_gtls_record_buffer_get (content_type_t type,
+                                MHD_gtls_session_t session, opaque * data,
                                 size_t length);
-ssize_t mhd_gtls_io_read_buffered (mhd_gtls_session_t, opaque ** iptr,
+ssize_t MHD_gtls_io_read_buffered (MHD_gtls_session_t, opaque ** iptr,
                                    size_t n, content_type_t);
-void mhd_gtls_io_clear_read_buffer (mhd_gtls_session_t);
-int mhd_gtls_io_clear_peeked_data (mhd_gtls_session_t session);
+void MHD_gtls_io_clear_read_buffer (MHD_gtls_session_t);
+int MHD_gtls_io_clear_peeked_data (MHD_gtls_session_t session);
 
-ssize_t mhd_gtls_io_write_buffered (mhd_gtls_session_t, const void *iptr,
+ssize_t MHD_gtls_io_write_buffered (MHD_gtls_session_t, const void *iptr,
                                     size_t n);
-ssize_t mhd_gtls_io_write_buffered2 (mhd_gtls_session_t, const void *iptr,
+ssize_t MHD_gtls_io_write_buffered2 (MHD_gtls_session_t, const void *iptr,
                                      size_t n, const void *iptr2, size_t n2);
 
-int mhd_gtls_handshake_buffer_get_size (mhd_gtls_session_t session);
-int mhd_gtls_handshake_buffer_peek (mhd_gtls_session_t session, opaque * data,
+int MHD_gtls_handshake_buffer_get_size (MHD_gtls_session_t session);
+int MHD_gtls_handshake_buffer_peek (MHD_gtls_session_t session, opaque * data,
                                     size_t length);
-int mhd_gtls_handshake_buffer_put (mhd_gtls_session_t session, opaque * data,
+int MHD_gtls_handshake_buffer_put (MHD_gtls_session_t session, opaque * data,
                                    size_t length);
-int mhd_gtls_handshake_buffer_clear (mhd_gtls_session_t session);
-int mhd_gtls_handshake_buffer_empty (mhd_gtls_session_t session);
-int mhd_gtls_handshake_buffer_get_ptr (mhd_gtls_session_t session,
+int MHD_gtls_handshake_buffer_clear (MHD_gtls_session_t session);
+int MHD_gtls_handshake_buffer_empty (MHD_gtls_session_t session);
+int MHD_gtls_handshake_buffer_get_ptr (MHD_gtls_session_t session,
                                        opaque ** data_ptr, size_t * length);
 
-#define _gnutls_handshake_io_buffer_clear( session) \
-        mhd_gtls_buffer_clear( &session->internals.handshake_send_buffer); \
-        mhd_gtls_buffer_clear( &session->internals.handshake_recv_buffer); \
+#define MHD__gnutls_handshake_io_buffer_clear( session) \
+        MHD_gtls_buffer_clear( &session->internals.handshake_send_buffer); \
+        MHD_gtls_buffer_clear( &session->internals.handshake_recv_buffer); \
         session->internals.handshake_send_buffer_prev_size = 0
 
-ssize_t mhd_gtls_handshake_io_recv_int (mhd_gtls_session_t, content_type_t,
-                                        gnutls_handshake_description_t,
+ssize_t MHD_gtls_handshake_io_recv_int (MHD_gtls_session_t, content_type_t,
+                                        MHD_gnutls_handshake_description_t,
                                         void *, size_t);
-ssize_t mhd_gtls_handshake_io_send_int (mhd_gtls_session_t, content_type_t,
-                                        gnutls_handshake_description_t,
+ssize_t MHD_gtls_handshake_io_send_int (MHD_gtls_session_t, content_type_t,
+                                        MHD_gnutls_handshake_description_t,
                                         const void *, size_t);
-ssize_t mhd_gtls_io_write_flush (mhd_gtls_session_t session);
-ssize_t mhd_gtls_handshake_io_write_flush (mhd_gtls_session_t session);
+ssize_t MHD_gtls_io_write_flush (MHD_gtls_session_t session);
+ssize_t MHD_gtls_handshake_io_write_flush (MHD_gtls_session_t session);
 
-size_t MHD_gtls_record_check_pending (mhd_gtls_session_t session);
+size_t MHD_gtls_record_check_pending (MHD_gtls_session_t session);
diff --git a/src/daemon/https/tls/gnutls_cert.c b/src/daemon/https/tls/gnutls_cert.c
index 17e95e48..45e001d6 100644
--- a/src/daemon/https/tls/gnutls_cert.c
+++ b/src/daemon/https/tls/gnutls_cert.c
@@ -45,8 +45,8 @@
 #include "mpi.h"
 
 /**
-  * MHD_gnutls_certificate_free_keys - Used to free all the keys from a mhd_gtls_cert_credentials_t structure
-  * @sc: is an #mhd_gtls_cert_credentials_t structure.
+  * MHD__gnutls_certificate_free_keys - Used to free all the keys from a MHD_gtls_cert_credentials_t structure
+  * @sc: is an #MHD_gtls_cert_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
@@ -54,7 +54,7 @@
   *
   **/
 void
-MHD_gnutls_certificate_free_keys (mhd_gtls_cert_credentials_t sc)
+MHD__gnutls_certificate_free_keys (MHD_gtls_cert_credentials_t sc)
 {
   unsigned i, j;
 
@@ -62,23 +62,23 @@ MHD_gnutls_certificate_free_keys (mhd_gtls_cert_credentials_t sc)
     {
       for (j = 0; j < sc->cert_list_length[i]; j++)
         {
-          mhd_gtls_gcert_deinit (&sc->cert_list[i][j]);
+          MHD_gtls_gcert_deinit (&sc->cert_list[i][j]);
         }
-      gnutls_free (sc->cert_list[i]);
+      MHD_gnutls_free (sc->cert_list[i]);
     }
 
-  gnutls_free (sc->cert_list_length);
+  MHD_gnutls_free (sc->cert_list_length);
   sc->cert_list_length = NULL;
 
-  gnutls_free (sc->cert_list);
+  MHD_gnutls_free (sc->cert_list);
   sc->cert_list = NULL;
 
   for (i = 0; i < sc->ncerts; i++)
     {
-      mhd_gtls_gkey_deinit (&sc->pkey[i]);
+      MHD_gtls_gkey_deinit (&sc->pkey[i]);
     }
 
-  gnutls_free (sc->pkey);
+  MHD_gnutls_free (sc->pkey);
   sc->pkey = NULL;
 
   sc->ncerts = 0;
@@ -86,8 +86,8 @@ MHD_gnutls_certificate_free_keys (mhd_gtls_cert_credentials_t sc)
 }
 
 /**
-  * MHD_gnutls_certificate_free_cas - Used to free all the CAs from a mhd_gtls_cert_credentials_t structure
-  * @sc: is an #mhd_gtls_cert_credentials_t structure.
+  * MHD__gnutls_certificate_free_cas - Used to free all the CAs from a MHD_gtls_cert_credentials_t structure
+  * @sc: is an #MHD_gtls_cert_credentials_t structure.
   *
   * This function will delete all the CAs associated
   * with the given credentials. Servers that do not use
@@ -96,25 +96,25 @@ MHD_gnutls_certificate_free_keys (mhd_gtls_cert_credentials_t sc)
   *
   **/
 void
-MHD_gnutls_certificate_free_cas (mhd_gtls_cert_credentials_t sc)
+MHD__gnutls_certificate_free_cas (MHD_gtls_cert_credentials_t sc)
 {
   unsigned j;
 
   for (j = 0; j < sc->x509_ncas; j++)
     {
-      gnutls_x509_crt_deinit (sc->x509_ca_list[j]);
+      MHD_gnutls_x509_crt_deinit (sc->x509_ca_list[j]);
     }
 
   sc->x509_ncas = 0;
 
-  gnutls_free (sc->x509_ca_list);
+  MHD_gnutls_free (sc->x509_ca_list);
   sc->x509_ca_list = NULL;
 
 }
 
 /**
-  * MHD_gnutls_certificate_free_ca_names - Used to free all the CA names from a mhd_gtls_cert_credentials_t structure
-  * @sc: is an #mhd_gtls_cert_credentials_t structure.
+  * MHD__gnutls_certificate_free_ca_names - Used to free all the CA names from a MHD_gtls_cert_credentials_t structure
+  * @sc: is an #MHD_gtls_cert_credentials_t structure.
   *
   * This function will delete all the CA name in the
   * given credentials. Clients may call this to save some memory
@@ -125,13 +125,13 @@ MHD_gnutls_certificate_free_cas (mhd_gtls_cert_credentials_t sc)
   *
   **/
 void
-MHD_gnutls_certificate_free_ca_names (mhd_gtls_cert_credentials_t sc)
+MHD__gnutls_certificate_free_ca_names (MHD_gtls_cert_credentials_t sc)
 {
-  _gnutls_free_datum (&sc->x509_rdn_sequence);
+  MHD__gnutls_free_datum (&sc->x509_rdn_sequence);
 }
 
 /*-
-  * mhd_gtls_certificate_get_rsa_params - Returns the RSA parameters pointer
+  * MHD_gtls_certificate_get_rsa_params - Returns the RSA parameters pointer
   * @rsa_params: holds the RSA parameters or NULL.
   * @func: function to retrieve the parameters or NULL.
   * @session: The session.
@@ -139,12 +139,12 @@ MHD_gnutls_certificate_free_ca_names (mhd_gtls_cert_credentials_t sc)
   * This function will return the rsa parameters pointer.
   *
   -*/
-mhd_gtls_rsa_params_t
-mhd_gtls_certificate_get_rsa_params (mhd_gtls_rsa_params_t rsa_params,
-                                     gnutls_params_function * func,
-                                     mhd_gtls_session_t session)
+MHD_gtls_rsa_params_t
+MHD_gtls_certificate_get_rsa_params (MHD_gtls_rsa_params_t rsa_params,
+                                     MHD_gnutls_params_function * func,
+                                     MHD_gtls_session_t session)
 {
-  gnutls_params_st params;
+  MHD_gnutls_params_st params;
   int ret;
 
   if (session->internals.params.rsa_params)
@@ -171,8 +171,8 @@ mhd_gtls_certificate_get_rsa_params (mhd_gtls_rsa_params_t rsa_params,
 
 
 /**
-  * MHD_gnutls_certificate_free_credentials - Used to free an allocated mhd_gtls_cert_credentials_t structure
-  * @sc: is an #mhd_gtls_cert_credentials_t structure.
+  * MHD__gnutls_certificate_free_credentials - Used to free an allocated MHD_gtls_cert_credentials_t structure
+  * @sc: is an #MHD_gtls_cert_credentials_t structure.
   *
   * This structure is complex enough to manipulate directly thus
   * this helper function is provided in order to free (deallocate) it.
@@ -182,26 +182,26 @@ mhd_gtls_certificate_get_rsa_params (mhd_gtls_rsa_params_t rsa_params,
   * this function).
   **/
 void
-MHD_gnutls_certificate_free_credentials (mhd_gtls_cert_credentials_t sc)
+MHD__gnutls_certificate_free_credentials (MHD_gtls_cert_credentials_t sc)
 {
-  MHD_gnutls_certificate_free_keys (sc);
-  MHD_gnutls_certificate_free_cas (sc);
-  MHD_gnutls_certificate_free_ca_names (sc);
+  MHD__gnutls_certificate_free_keys (sc);
+  MHD__gnutls_certificate_free_cas (sc);
+  MHD__gnutls_certificate_free_ca_names (sc);
 #ifdef ENABLE_PKI
-  MHD_gnutls_certificate_free_crls (sc);
+  MHD__gnutls_certificate_free_crls (sc);
 #endif
 
 #ifdef KEYRING_HACK
-  _gnutls_free_datum (&sc->keyring);
+  MHD__gnutls_free_datum (&sc->keyring);
 #endif
 
-  gnutls_free (sc);
+  MHD_gnutls_free (sc);
 }
 
 
 /**
-  * MHD_gnutls_certificate_allocate_credentials - Used to allocate a mhd_gtls_cert_credentials_t structure
-  * @res: is a pointer to an #mhd_gtls_cert_credentials_t structure.
+  * MHD__gnutls_certificate_allocate_credentials - Used to allocate a MHD_gtls_cert_credentials_t structure
+  * @res: is a pointer to an #MHD_gtls_cert_credentials_t structure.
   *
   * This structure is complex enough to manipulate directly thus this
   * helper function is provided in order to allocate it.
@@ -209,10 +209,10 @@ MHD_gnutls_certificate_free_credentials (mhd_gtls_cert_credentials_t sc)
   * Returns: %GNUTLS_E_SUCCESS on success, or an error code.
   **/
 int
-MHD_gnutls_certificate_allocate_credentials (mhd_gtls_cert_credentials_t *
+MHD__gnutls_certificate_allocate_credentials (MHD_gtls_cert_credentials_t *
                                              res)
 {
-  *res = gnutls_calloc (1, sizeof (mhd_gtls_cert_credentials_st));
+  *res = MHD_gnutls_calloc (1, sizeof (MHD_gtls_cert_credentials_st));
 
   if (*res == NULL)
     return GNUTLS_E_MEMORY_ERROR;
@@ -231,14 +231,14 @@ MHD_gnutls_certificate_allocate_credentials (mhd_gtls_cert_credentials_t *
  * extensions in order to disable unneded algorithms.
  */
 int
-mhd_gtls_selected_cert_supported_kx (mhd_gtls_session_t session,
+MHD_gtls_selected_cert_supported_kx (MHD_gtls_session_t session,
                                      enum MHD_GNUTLS_KeyExchangeAlgorithm
                                      **alg, int *alg_size)
 {
   enum MHD_GNUTLS_KeyExchangeAlgorithm kx;
   enum MHD_GNUTLS_PublicKeyAlgorithm pk;
   enum MHD_GNUTLS_KeyExchangeAlgorithm kxlist[MAX_ALGOS];
-  gnutls_cert *cert;
+  MHD_gnutls_cert *cert;
   int i;
 
   if (session->internals.selected_cert_list_length == 0)
@@ -253,11 +253,11 @@ mhd_gtls_selected_cert_supported_kx (mhd_gtls_session_t session,
 
   for (kx = 0; kx < MAX_ALGOS; kx++)
     {
-      pk = mhd_gtls_map_pk_get_pk (kx);
+      pk = MHD_gtls_map_pk_get_pk (kx);
       if (pk == cert->subject_pk_algorithm)
         {
           /* then check key usage */
-          if (_gnutls_check_key_usage (cert, kx) == 0)
+          if (MHD__gnutls_check_key_usage (cert, kx) == 0)
             {
               kxlist[i] = kx;
               i++;
@@ -267,11 +267,11 @@ mhd_gtls_selected_cert_supported_kx (mhd_gtls_session_t session,
 
   if (i == 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  *alg = gnutls_calloc (1, sizeof (enum MHD_GNUTLS_KeyExchangeAlgorithm) * i);
+  *alg = MHD_gnutls_calloc (1, sizeof (enum MHD_GNUTLS_KeyExchangeAlgorithm) * i);
   if (*alg == NULL)
     return GNUTLS_E_MEMORY_ERROR;
 
@@ -285,7 +285,7 @@ mhd_gtls_selected_cert_supported_kx (mhd_gtls_session_t session,
 
 /**
   * MHD_gtls_certificate_server_set_request - Used to set whether to request a client certificate
-  * @session: is an #mhd_gtls_session_t structure.
+  * @session: is an #MHD_gtls_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
@@ -296,28 +296,28 @@ mhd_gtls_selected_cert_supported_kx (mhd_gtls_session_t session,
   * send a certificate.
   **/
 void
-MHD_gtls_certificate_server_set_request (mhd_gtls_session_t session,
-                                         gnutls_certificate_request_t req)
+MHD_gtls_certificate_server_set_request (MHD_gtls_session_t session,
+                                         MHD_gnutls_certificate_request_t req)
 {
   session->internals.send_cert_req = req;
 }
 
 /**
   * MHD_gtls_certificate_client_set_retrieve_function - Used to set a callback to retrieve the certificate
-  * @cred: is a #mhd_gtls_cert_credentials_t structure.
+  * @cred: is a #MHD_gtls_cert_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)(mhd_gtls_session_t, const gnutls_datum_t* req_ca_dn, int nreqs,
-  * const enum MHD_GNUTLS_PublicKeyAlgorithm* pk_algos, int pk_algos_length, gnutls_retr_st* st);
+  * int (*callback)(MHD_gtls_session_t, const MHD_gnutls_datum_t* req_ca_dn, int nreqs,
+  * const enum MHD_GNUTLS_PublicKeyAlgorithm* pk_algos, int pk_algos_length, MHD_gnutls_retr_st* st);
   *
   * @req_ca_cert is only used in X.509 certificates.
   * Contains a list with the CA names that the server considers trusted.
   * Normally we should send a certificate that is signed
   * by one of these CAs. These names are DER encoded. To get a more
-  * meaningful value use the function gnutls_x509_rdn_get().
+  * meaningful value use the function MHD_gnutls_x509_rdn_get().
   *
   * @pk_algos contains a list with server's acceptable signature algorithms.
   * The certificate returned should support the server's given algorithms.
@@ -333,21 +333,21 @@ MHD_gtls_certificate_server_set_request (mhd_gtls_session_t session,
   * will be terminated.
   **/
 void MHD_gtls_certificate_client_set_retrieve_function
-  (mhd_gtls_cert_credentials_t cred,
-   gnutls_certificate_client_retrieve_function * func)
+  (MHD_gtls_cert_credentials_t cred,
+   MHD_gnutls_certificate_client_retrieve_function * func)
 {
   cred->client_get_cert_callback = func;
 }
 
 /**
   * MHD_gtls_certificate_server_set_retrieve_function - Used to set a callback to retrieve the certificate
-  * @cred: is a #mhd_gtls_cert_credentials_t structure.
+  * @cred: is a #MHD_gtls_cert_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)(mhd_gtls_session_t, gnutls_retr_st* st);
+  * int (*callback)(MHD_gtls_session_t, MHD_gnutls_retr_st* st);
   *
   * @st should contain the certificates and private keys.
   *
@@ -359,14 +359,14 @@ void MHD_gtls_certificate_client_set_retrieve_function
   * will be terminated.
   **/
 void MHD_gtls_certificate_server_set_retrieve_function
-  (mhd_gtls_cert_credentials_t cred,
-   gnutls_certificate_server_retrieve_function * func)
+  (MHD_gtls_cert_credentials_t cred,
+   MHD_gnutls_certificate_server_retrieve_function * func)
 {
   cred->server_get_cert_callback = func;
 }
 
 /*-
- * _gnutls_x509_extract_certificate_activation_time - This function returns the peer's certificate activation time
+ * MHD__gnutls_x509_extract_certificate_activation_time - This function returns the peer's certificate activation time
  * @cert: should contain an X.509 DER encoded certificate
  *
  * This function will return the certificate's activation time in UNIX time
@@ -376,31 +376,31 @@ void MHD_gtls_certificate_server_set_retrieve_function
  *
  -*/
 static time_t
-_gnutls_x509_get_raw_crt_activation_time (const gnutls_datum_t * cert)
+MHD__gnutls_x509_get_raw_crt_activation_time (const MHD_gnutls_datum_t * cert)
 {
-  gnutls_x509_crt_t xcert;
+  MHD_gnutls_x509_crt_t xcert;
   time_t result;
 
-  result = gnutls_x509_crt_init (&xcert);
+  result = MHD_gnutls_x509_crt_init (&xcert);
   if (result < 0)
     return (time_t) - 1;
 
-  result = gnutls_x509_crt_import (xcert, cert, GNUTLS_X509_FMT_DER);
+  result = MHD_gnutls_x509_crt_import (xcert, cert, GNUTLS_X509_FMT_DER);
   if (result < 0)
     {
-      gnutls_x509_crt_deinit (xcert);
+      MHD_gnutls_x509_crt_deinit (xcert);
       return (time_t) - 1;
     }
 
-  result = gnutls_x509_crt_get_activation_time (xcert);
+  result = MHD_gnutls_x509_crt_get_activation_time (xcert);
 
-  gnutls_x509_crt_deinit (xcert);
+  MHD_gnutls_x509_crt_deinit (xcert);
 
   return result;
 }
 
 /*-
- * gnutls_x509_extract_certificate_expiration_time - This function returns the certificate's expiration time
+ * MHD_gnutls_x509_extract_certificate_expiration_time - This function returns the certificate's expiration time
  * @cert: should contain an X.509 DER encoded certificate
  *
  * This function will return the certificate's expiration time in UNIX
@@ -410,25 +410,25 @@ _gnutls_x509_get_raw_crt_activation_time (const gnutls_datum_t * cert)
  *
  -*/
 static time_t
-_gnutls_x509_get_raw_crt_expiration_time (const gnutls_datum_t * cert)
+MHD__gnutls_x509_get_raw_crt_expiration_time (const MHD_gnutls_datum_t * cert)
 {
-  gnutls_x509_crt_t xcert;
+  MHD_gnutls_x509_crt_t xcert;
   time_t result;
 
-  result = gnutls_x509_crt_init (&xcert);
+  result = MHD_gnutls_x509_crt_init (&xcert);
   if (result < 0)
     return (time_t) - 1;
 
-  result = gnutls_x509_crt_import (xcert, cert, GNUTLS_X509_FMT_DER);
+  result = MHD_gnutls_x509_crt_import (xcert, cert, GNUTLS_X509_FMT_DER);
   if (result < 0)
     {
-      gnutls_x509_crt_deinit (xcert);
+      MHD_gnutls_x509_crt_deinit (xcert);
       return (time_t) - 1;
     }
 
-  result = gnutls_x509_crt_get_expiration_time (xcert);
+  result = MHD_gnutls_x509_crt_get_expiration_time (xcert);
 
-  gnutls_x509_crt_deinit (xcert);
+  MHD_gnutls_x509_crt_deinit (xcert);
 
   return result;
 }
@@ -440,34 +440,34 @@ _gnutls_x509_get_raw_crt_expiration_time (const gnutls_datum_t * cert)
   *
   * This function will try to verify the peer's certificate and return
   * its status (trusted, invalid etc.).  The value of @status should
-  * be one or more of the gnutls_certificate_status_t enumerated
+  * be one or more of the MHD_gnutls_certificate_status_t enumerated
   * elements bitwise or'd. To avoid denial of service attacks some
   * default upper limits regarding the certificate key size and chain
   * size are set. To override them use
-  * MHD_gnutls_certificate_set_verify_limits().
+  * MHD__gnutls_certificate_set_verify_limits().
   *
   * Note that you must also check the peer's name in order to check if
   * the verified certificate belongs to the actual peer.
   *
-  * This is the same as gnutls_x509_crt_list_verify() and uses the
+  * This is the same as MHD_gnutls_x509_crt_list_verify() and uses the
   * loaded CAs in the credentials as trusted CAs.
   *
   * Note that some commonly used X.509 Certificate Authorities are
   * still using Version 1 certificates.  If you want to accept them,
-  * you need to call MHD_gnutls_certificate_set_verify_flags() with, e.g.,
+  * you need to call MHD__gnutls_certificate_set_verify_flags() with, e.g.,
   * %GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT parameter.
   *
   * Returns: a negative error code on error and zero on success.
   **/
 int
-MHD_gtls_certificate_verify_peers2 (mhd_gtls_session_t session,
+MHD_gtls_certificate_verify_peers2 (MHD_gtls_session_t session,
                                     unsigned int *status)
 {
   cert_auth_info_t info;
 
   CHECK_AUTH (MHD_GNUTLS_CRD_CERTIFICATE, GNUTLS_E_INVALID_REQUEST);
 
-  info = mhd_gtls_get_auth_info (session);
+  info = MHD_gtls_get_auth_info (session);
   if (info == NULL)
     {
       return GNUTLS_E_NO_CERTIFICATE_FOUND;
@@ -476,10 +476,10 @@ MHD_gtls_certificate_verify_peers2 (mhd_gtls_session_t session,
   if (info->raw_certificate_list == NULL || info->ncerts == 0)
     return GNUTLS_E_NO_CERTIFICATE_FOUND;
 
-  switch (gnutls_certificate_type_get (session))
+  switch (MHD_gnutls_certificate_type_get (session))
     {
     case MHD_GNUTLS_CRT_X509:
-      return _gnutls_x509_cert_verify_peers (session, status);
+      return MHD__gnutls_x509_cert_verify_peers (session, status);
     default:
       return GNUTLS_E_INVALID_REQUEST;
     }
@@ -495,15 +495,15 @@ MHD_gtls_certificate_verify_peers2 (mhd_gtls_session_t session,
   * belongs to the actual peer.
   *
   * The return value should be one or more of the
-  * gnutls_certificate_status_t enumerated elements bitwise or'd, or a
+  * MHD_gnutls_certificate_status_t enumerated elements bitwise or'd, or a
   * negative value on error.
   *
-  * This is the same as gnutls_x509_crt_list_verify().
+  * This is the same as MHD_gnutls_x509_crt_list_verify().
   *
   * Deprecated: Use MHD_gtls_certificate_verify_peers2() instead.
   **/
 int
-MHD_gtls_certificate_verify_peers (mhd_gtls_session_t session)
+MHD_gtls_certificate_verify_peers (MHD_gtls_session_t session)
 {
   unsigned int status;
   int ret;
@@ -512,7 +512,7 @@ MHD_gtls_certificate_verify_peers (mhd_gtls_session_t session)
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -528,13 +528,13 @@ MHD_gtls_certificate_verify_peers (mhd_gtls_session_t session)
   * Returns: (time_t)-1 on error.
   **/
 time_t
-MHD_gtls_certificate_expiration_time_peers (mhd_gtls_session_t session)
+MHD_gtls_certificate_expiration_time_peers (MHD_gtls_session_t session)
 {
   cert_auth_info_t info;
 
   CHECK_AUTH (MHD_GNUTLS_CRD_CERTIFICATE, GNUTLS_E_INVALID_REQUEST);
 
-  info = mhd_gtls_get_auth_info (session);
+  info = MHD_gtls_get_auth_info (session);
   if (info == NULL)
     {
       return (time_t) - 1;
@@ -542,15 +542,15 @@ MHD_gtls_certificate_expiration_time_peers (mhd_gtls_session_t session)
 
   if (info->raw_certificate_list == NULL || info->ncerts == 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return (time_t) - 1;
     }
 
-  switch (gnutls_certificate_type_get (session))
+  switch (MHD_gnutls_certificate_type_get (session))
     {
     case MHD_GNUTLS_CRT_X509:
       return
-        _gnutls_x509_get_raw_crt_expiration_time (&info->raw_certificate_list
+        MHD__gnutls_x509_get_raw_crt_expiration_time (&info->raw_certificate_list
                                                   [0]);
     default:
       return (time_t) - 1;
@@ -567,13 +567,13 @@ MHD_gtls_certificate_expiration_time_peers (mhd_gtls_session_t session)
   * Returns: (time_t)-1 on error.
   **/
 time_t
-MHD_gtls_certificate_activation_time_peers (mhd_gtls_session_t session)
+MHD_gtls_certificate_activation_time_peers (MHD_gtls_session_t session)
 {
   cert_auth_info_t info;
 
   CHECK_AUTH (MHD_GNUTLS_CRD_CERTIFICATE, GNUTLS_E_INVALID_REQUEST);
 
-  info = mhd_gtls_get_auth_info (session);
+  info = MHD_gtls_get_auth_info (session);
   if (info == NULL)
     {
       return (time_t) - 1;
@@ -581,15 +581,15 @@ MHD_gtls_certificate_activation_time_peers (mhd_gtls_session_t session)
 
   if (info->raw_certificate_list == NULL || info->ncerts == 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return (time_t) - 1;
     }
 
-  switch (gnutls_certificate_type_get (session))
+  switch (MHD_gnutls_certificate_type_get (session))
     {
     case MHD_GNUTLS_CRT_X509:
       return
-        _gnutls_x509_get_raw_crt_activation_time (&info->raw_certificate_list
+        MHD__gnutls_x509_get_raw_crt_activation_time (&info->raw_certificate_list
                                                   [0]);
     default:
       return (time_t) - 1;
@@ -597,33 +597,33 @@ MHD_gtls_certificate_activation_time_peers (mhd_gtls_session_t session)
 }
 
 int
-mhd_gtls_raw_cert_to_gcert (gnutls_cert * gcert,
+MHD_gtls_raw_cert_to_gcert (MHD_gnutls_cert * gcert,
                             enum MHD_GNUTLS_CertificateType type,
-                            const gnutls_datum_t * raw_cert,
+                            const MHD_gnutls_datum_t * raw_cert,
                             int flags /* OR of ConvFlags */ )
 {
   switch (type)
     {
     case MHD_GNUTLS_CRT_X509:
-      return mhd_gtls_x509_raw_cert_to_gcert (gcert, raw_cert, flags);
+      return MHD_gtls_x509_raw_cert_to_gcert (gcert, raw_cert, flags);
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 }
 
 int
-mhd_gtls_raw_privkey_to_gkey (gnutls_privkey * key,
+MHD_gtls_raw_privkey_to_gkey (MHD_gnutls_privkey * key,
                               enum MHD_GNUTLS_CertificateType type,
-                              const gnutls_datum_t * raw_key,
+                              const MHD_gnutls_datum_t * raw_key,
                               int key_enc /* DER or PEM */ )
 {
   switch (type)
     {
     case MHD_GNUTLS_CRT_X509:
-      return _gnutls_x509_raw_privkey_to_gkey (key, raw_key, key_enc);
+      return MHD__gnutls_x509_raw_privkey_to_gkey (key, raw_key, key_enc);
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 }
@@ -639,30 +639,30 @@ mhd_gtls_raw_privkey_to_gkey (gnutls_privkey * key,
  * The critical extensions will be catched by the verification functions.
  */
 int
-mhd_gtls_x509_raw_cert_to_gcert (gnutls_cert * gcert,
-                                 const gnutls_datum_t * derCert,
+MHD_gtls_x509_raw_cert_to_gcert (MHD_gnutls_cert * gcert,
+                                 const MHD_gnutls_datum_t * derCert,
                                  int flags /* OR of ConvFlags */ )
 {
   int ret;
-  gnutls_x509_crt_t cert;
+  MHD_gnutls_x509_crt_t cert;
 
-  ret = gnutls_x509_crt_init (&cert);
+  ret = MHD_gnutls_x509_crt_init (&cert);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  ret = gnutls_x509_crt_import (cert, derCert, GNUTLS_X509_FMT_DER);
+  ret = MHD_gnutls_x509_crt_import (cert, derCert, GNUTLS_X509_FMT_DER);
   if (ret < 0)
     {
-      gnutls_assert ();
-      gnutls_x509_crt_deinit (cert);
+      MHD_gnutls_assert ();
+      MHD_gnutls_x509_crt_deinit (cert);
       return ret;
     }
 
-  ret = mhd_gtls_x509_crt_to_gcert (gcert, cert, flags);
-  gnutls_x509_crt_deinit (cert);
+  ret = MHD_gtls_x509_crt_to_gcert (gcert, cert, flags);
+  MHD_gnutls_x509_crt_deinit (cert);
 
   return ret;
 }
@@ -670,12 +670,12 @@ mhd_gtls_x509_raw_cert_to_gcert (gnutls_cert * gcert,
 /* Like above but it accepts a parsed certificate instead.
  */
 int
-mhd_gtls_x509_crt_to_gcert (gnutls_cert * gcert,
-                            gnutls_x509_crt_t cert, unsigned int flags)
+MHD_gtls_x509_crt_to_gcert (MHD_gnutls_cert * gcert,
+                            MHD_gnutls_x509_crt_t cert, unsigned int flags)
 {
   int ret = 0;
 
-  memset (gcert, 0, sizeof (gnutls_cert));
+  memset (gcert, 0, sizeof (MHD_gnutls_cert));
   gcert->cert_type = MHD_GNUTLS_CRT_X509;
 
   if (!(flags & CERT_NO_COPY))
@@ -687,38 +687,38 @@ mhd_gtls_x509_crt_to_gcert (gnutls_cert * gcert,
       /* initially allocate a bogus size, just in case the certificate
        * fits in it. That way we minimize the DER encodings performed.
        */
-      der = gnutls_malloc (SMALL_DER);
+      der = MHD_gnutls_malloc (SMALL_DER);
       if (der == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_MEMORY_ERROR;
         }
 
       ret =
-        gnutls_x509_crt_export (cert, GNUTLS_X509_FMT_DER, der, &der_size);
+        MHD_gnutls_x509_crt_export (cert, GNUTLS_X509_FMT_DER, der, &der_size);
       if (ret < 0 && ret != GNUTLS_E_SHORT_MEMORY_BUFFER)
         {
-          gnutls_assert ();
-          gnutls_free (der);
+          MHD_gnutls_assert ();
+          MHD_gnutls_free (der);
           return ret;
         }
 
       if (ret == GNUTLS_E_SHORT_MEMORY_BUFFER)
         {
-          der = gnutls_realloc (der, der_size);
+          der = MHD_gnutls_realloc (der, der_size);
           if (der == NULL)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return GNUTLS_E_MEMORY_ERROR;
             }
 
           ret =
-            gnutls_x509_crt_export (cert, GNUTLS_X509_FMT_DER, der,
+            MHD_gnutls_x509_crt_export (cert, GNUTLS_X509_FMT_DER, der,
                                     &der_size);
           if (ret < 0)
             {
-              gnutls_assert ();
-              gnutls_free (der);
+              MHD_gnutls_assert ();
+              MHD_gnutls_free (der);
               return ret;
             }
         }
@@ -733,19 +733,19 @@ mhd_gtls_x509_crt_to_gcert (gnutls_cert * gcert,
 
   if (flags & CERT_ONLY_EXTENSIONS || flags == 0)
     {
-      gnutls_x509_crt_get_key_usage (cert, &gcert->key_usage, NULL);
-      gcert->version = gnutls_x509_crt_get_version (cert);
+      MHD_gnutls_x509_crt_get_key_usage (cert, &gcert->key_usage, NULL);
+      gcert->version = MHD_gnutls_x509_crt_get_version (cert);
     }
-  gcert->subject_pk_algorithm = gnutls_x509_crt_get_pk_algorithm (cert, NULL);
+  gcert->subject_pk_algorithm = MHD_gnutls_x509_crt_get_pk_algorithm (cert, NULL);
 
   if (flags & CERT_ONLY_PUBKEY || flags == 0)
     {
       gcert->params_size = MAX_PUBLIC_PARAMS_SIZE;
       ret =
-        _gnutls_x509_crt_get_mpis (cert, gcert->params, &gcert->params_size);
+        MHD__gnutls_x509_crt_get_mpis (cert, gcert->params, &gcert->params_size);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
     }
@@ -755,7 +755,7 @@ mhd_gtls_x509_crt_to_gcert (gnutls_cert * gcert,
 }
 
 void
-mhd_gtls_gcert_deinit (gnutls_cert * cert)
+MHD_gtls_gcert_deinit (MHD_gnutls_cert * cert)
 {
   int i;
 
@@ -764,10 +764,10 @@ mhd_gtls_gcert_deinit (gnutls_cert * cert)
 
   for (i = 0; i < cert->params_size; i++)
     {
-      mhd_gtls_mpi_release (&cert->params[i]);
+      MHD_gtls_mpi_release (&cert->params[i]);
     }
 
-  _gnutls_free_datum (&cert->raw);
+  MHD__gnutls_free_datum (&cert->raw);
 }
 
 /**
@@ -778,20 +778,20 @@ mhd_gtls_gcert_deinit (gnutls_cert * cert)
  *
  * Set the callback function.  The function must have this prototype:
  *
- * typedef int (*gnutls_sign_func) (mhd_gtls_session_t session,
+ * typedef int (*MHD_gnutls_sign_func) (MHD_gtls_session_t session,
  *                                  void *userdata,
  *                                  enum MHD_GNUTLS_CertificateType cert_type,
- *                                  const gnutls_datum_t * cert,
- *                                  const gnutls_datum_t * hash,
- *                                  gnutls_datum_t * signature);
+ *                                  const MHD_gnutls_datum_t * cert,
+ *                                  const MHD_gnutls_datum_t * hash,
+ *                                  MHD_gnutls_datum_t * signature);
  *
  * The @userdata parameter is passed to the @sign_func verbatim, and
  * can be used to store application-specific data needed in the
  * callback function.  See also MHD_gtls_sign_callback_get().
  **/
 void
-MHD_gtls_sign_callback_set (mhd_gtls_session_t session,
-                            gnutls_sign_func sign_func, void *userdata)
+MHD_gtls_sign_callback_set (MHD_gtls_session_t session,
+                            MHD_gnutls_sign_func sign_func, void *userdata)
 {
   session->internals.sign_func = sign_func;
   session->internals.sign_func_userdata = userdata;
@@ -807,8 +807,8 @@ MHD_gtls_sign_callback_set (mhd_gtls_session_t session,
  * Returns: The function pointer set by MHD_gtls_sign_callback_set(), or
  *   if not set, %NULL.
  **/
-gnutls_sign_func
-MHD_gtls_sign_callback_get (mhd_gtls_session_t session, void **userdata)
+MHD_gnutls_sign_func
+MHD_gtls_sign_callback_get (MHD_gtls_session_t session, void **userdata)
 {
   if (userdata)
     *userdata = session->internals.sign_func_userdata;
diff --git a/src/daemon/https/tls/gnutls_cert.h b/src/daemon/https/tls/gnutls_cert.h
index 129e7e16..b759fca5 100644
--- a/src/daemon/https/tls/gnutls_cert.h
+++ b/src/daemon/https/tls/gnutls_cert.h
@@ -48,7 +48,7 @@
 #define KEY_ENCIPHER_ONLY               1
 #define KEY_DECIPHER_ONLY               32768
 
-typedef struct gnutls_cert
+typedef struct MHD_gnutls_cert
 {
   mpi_t params[MAX_PUBLIC_PARAMS_SIZE]; /* the size of params depends on the public
                                          * key algorithm
@@ -71,11 +71,11 @@ typedef struct gnutls_cert
    */
   enum MHD_GNUTLS_CertificateType cert_type;
 
-  gnutls_datum_t raw;
+  MHD_gnutls_datum_t raw;
 
-} gnutls_cert;
+} MHD_gnutls_cert;
 
-typedef struct gnutls_privkey_int
+typedef struct MHD_gnutls_privkey_int
 {
   mpi_t params[MAX_PRIV_PARAMS_SIZE];   /* the size of params depends on the public
                                          * key algorithm
@@ -96,9 +96,9 @@ typedef struct gnutls_privkey_int
   int params_size;              /* holds the number of params */
 
   enum MHD_GNUTLS_PublicKeyAlgorithm pk_algorithm;
-} gnutls_privkey;
+} MHD_gnutls_privkey;
 
-struct MHD_gtls_session_int;    /* because mhd_gtls_session_t is not defined when this file is included */
+struct MHD_gtls_session_int;    /* because MHD_gtls_session_t is not defined when this file is included */
 
 typedef enum ConvFlags
 {
@@ -107,26 +107,26 @@ typedef enum ConvFlags
   CERT_ONLY_EXTENSIONS = 16
 } ConvFlags;
 
-int mhd_gtls_x509_raw_cert_to_gcert (gnutls_cert * gcert,
-                                     const gnutls_datum_t * derCert,
+int MHD_gtls_x509_raw_cert_to_gcert (MHD_gnutls_cert * gcert,
+                                     const MHD_gnutls_datum_t * derCert,
                                      int flags);
-int mhd_gtls_x509_crt_to_gcert (gnutls_cert * gcert, gnutls_x509_crt_t cert,
+int MHD_gtls_x509_crt_to_gcert (MHD_gnutls_cert * gcert, MHD_gnutls_x509_crt_t cert,
                                 unsigned int flags);
 
-void mhd_gtls_gkey_deinit (gnutls_privkey * key);
-void mhd_gtls_gcert_deinit (gnutls_cert * cert);
+void MHD_gtls_gkey_deinit (MHD_gnutls_privkey * key);
+void MHD_gtls_gcert_deinit (MHD_gnutls_cert * cert);
 
-int mhd_gtls_selected_cert_supported_kx (struct MHD_gtls_session_int *session,
+int MHD_gtls_selected_cert_supported_kx (struct MHD_gtls_session_int *session,
                                          enum MHD_GNUTLS_KeyExchangeAlgorithm
                                          **alg, int *alg_size);
 
-int mhd_gtls_raw_cert_to_gcert (gnutls_cert * gcert,
+int MHD_gtls_raw_cert_to_gcert (MHD_gnutls_cert * gcert,
                                 enum MHD_GNUTLS_CertificateType type,
-                                const gnutls_datum_t * raw_cert,
+                                const MHD_gnutls_datum_t * raw_cert,
                                 int flags /* OR of ConvFlags */ );
-int mhd_gtls_raw_privkey_to_gkey (gnutls_privkey * key,
+int MHD_gtls_raw_privkey_to_gkey (MHD_gnutls_privkey * key,
                                   enum MHD_GNUTLS_CertificateType type,
-                                  const gnutls_datum_t * raw_key,
+                                  const MHD_gnutls_datum_t * raw_key,
                                   int key_enc /* DER or PEM */ );
 
 #endif
diff --git a/src/daemon/https/tls/gnutls_cipher.c b/src/daemon/https/tls/gnutls_cipher.c
index 69b62d16..94e87eb3 100644
--- a/src/daemon/https/tls/gnutls_cipher.c
+++ b/src/daemon/https/tls/gnutls_cipher.c
@@ -42,7 +42,7 @@
 #include <gc.h>
 
 inline static int
-is_write_comp_null (mhd_gtls_session_t session)
+is_write_comp_null (MHD_gtls_session_t session)
 {
   if (session->security_parameters.write_compression_algorithm ==
       MHD_GNUTLS_COMP_NULL)
@@ -52,7 +52,7 @@ is_write_comp_null (mhd_gtls_session_t session)
 }
 
 inline static int
-is_read_comp_null (mhd_gtls_session_t session)
+is_read_comp_null (MHD_gtls_session_t session)
 {
   if (session->security_parameters.read_compression_algorithm ==
       MHD_GNUTLS_COMP_NULL)
@@ -68,13 +68,13 @@ is_read_comp_null (mhd_gtls_session_t session)
  * If random pad != 0 then the random pad data will be appended.
  */
 int
-mhd_gtls_encrypt (mhd_gtls_session_t session, const opaque * headers,
+MHD_gtls_encrypt (MHD_gtls_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_t plain;
-  gnutls_datum_t comp;
+  MHD_gnutls_datum_t plain;
+  MHD_gnutls_datum_t comp;
   int ret;
   int free_comp = 1;
 
@@ -91,31 +91,31 @@ mhd_gtls_encrypt (mhd_gtls_session_t session, const opaque * headers,
       /* Here comp is allocated and must be
        * freed.
        */
-      ret = _gnutls_m_plaintext2compressed (session, &comp, &plain);
+      ret = MHD__gnutls_m_plaintext2compressed (session, &comp, &plain);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
     }
 
-  ret = mhd_gtls_compressed2ciphertext (session, &ciphertext[headers_size],
+  ret = MHD_gtls_compressed2ciphertext (session, &ciphertext[headers_size],
                                         ciphertext_size - headers_size,
                                         comp, type, random_pad);
 
   if (free_comp)
-    _gnutls_free_datum (&comp);
+    MHD__gnutls_free_datum (&comp);
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
 
   /* copy the headers */
   memcpy (ciphertext, headers, headers_size);
-  mhd_gtls_write_uint16 (ret, &ciphertext[3]);
+  MHD_gtls_write_uint16 (ret, &ciphertext[3]);
 
   return ret + headers_size;
 }
@@ -124,12 +124,12 @@ mhd_gtls_encrypt (mhd_gtls_session_t session, const opaque * headers,
  * Returns the decrypted data length.
  */
 int
-mhd_gtls_decrypt (mhd_gtls_session_t session, opaque * ciphertext,
+MHD_gtls_decrypt (MHD_gtls_session_t session, opaque * ciphertext,
                   size_t ciphertext_size, uint8_t * data,
                   size_t max_data_size, content_type_t type)
 {
-  gnutls_datum_t gtxt;
-  gnutls_datum_t gcipher;
+  MHD_gnutls_datum_t gtxt;
+  MHD_gnutls_datum_t gcipher;
   int ret;
 
   if (ciphertext_size == 0)
@@ -139,7 +139,7 @@ mhd_gtls_decrypt (mhd_gtls_session_t session, opaque * ciphertext,
   gcipher.data = ciphertext;
 
   ret =
-    mhd_gtls_ciphertext2compressed (session, data, max_data_size,
+    MHD_gtls_ciphertext2compressed (session, data, max_data_size,
                                     gcipher, type);
   if (ret < 0)
     {
@@ -153,14 +153,14 @@ mhd_gtls_decrypt (mhd_gtls_session_t session, opaque * ciphertext,
     }
   else
     {
-      gnutls_datum_t gcomp;
+      MHD_gnutls_datum_t gcomp;
 
       /* compression has this malloc overhead.
        */
 
       gcomp.data = data;
       gcomp.size = ret;
-      ret = _gnutls_m_compressed2plaintext (session, &gtxt, &gcomp);
+      ret = MHD__gnutls_m_compressed2plaintext (session, &gtxt, &gcomp);
       if (ret < 0)
         {
           return ret;
@@ -168,8 +168,8 @@ mhd_gtls_decrypt (mhd_gtls_session_t session, opaque * ciphertext,
 
       if (gtxt.size > MAX_RECORD_RECV_SIZE)
         {
-          gnutls_assert ();
-          _gnutls_free_datum (&gtxt);
+          MHD_gnutls_assert ();
+          MHD__gnutls_free_datum (&gtxt);
           /* This shouldn't have happen and
            * is a TLS fatal error.
            */
@@ -179,15 +179,15 @@ mhd_gtls_decrypt (mhd_gtls_session_t session, opaque * ciphertext,
       /* This check is not really needed */
       if (max_data_size < MAX_RECORD_RECV_SIZE)
         {
-          gnutls_assert ();
-          _gnutls_free_datum (&gtxt);
+          MHD_gnutls_assert ();
+          MHD__gnutls_free_datum (&gtxt);
           return GNUTLS_E_INTERNAL_ERROR;
         }
 
       memcpy (data, gtxt.data, gtxt.size);
       ret = gtxt.size;
 
-      _gnutls_free_datum (&gtxt);
+      MHD__gnutls_free_datum (&gtxt);
     }
 
   return ret;
@@ -204,11 +204,11 @@ mac_init (enum MHD_GNUTLS_HashAlgorithm mac, opaque * secret, int secret_size,
 
   if (ver == MHD_GNUTLS_PROTOCOL_SSL3)
     {                           /* SSL 3.0 */
-      td = mhd_gnutls_mac_init_ssl3 (mac, secret, secret_size);
+      td = MHD_gnutls_mac_init_ssl3 (mac, secret, secret_size);
     }
   else
     {                           /* TLS 1.x */
-      td = mhd_gtls_hmac_init (mac, secret, secret_size);
+      td = MHD_gtls_MHD_hmac_init (mac, secret, secret_size);
     }
 
   return td;
@@ -219,16 +219,16 @@ mac_deinit (mac_hd_t td, opaque * res, int ver)
 {
   if (ver == MHD_GNUTLS_PROTOCOL_SSL3)
     {                           /* SSL 3.0 */
-      mhd_gnutls_mac_deinit_ssl3 (td, res);
+      MHD_gnutls_mac_deinit_ssl3 (td, res);
     }
   else
     {
-      mhd_gnutls_hmac_deinit (td, res);
+      MHD_gnutls_MHD_hmac_deinit (td, res);
     }
 }
 
 inline static int
-calc_enc_length (mhd_gtls_session_t session, int data_size,
+calc_enc_length (MHD_gtls_session_t session, int data_size,
                  int hash_size, uint8_t * pad, int random_pad,
                  cipher_type_t block_algo, uint16_t blocksize)
 {
@@ -244,9 +244,9 @@ calc_enc_length (mhd_gtls_session_t session, int data_size,
 
       break;
     case CIPHER_BLOCK:
-      if (gc_nonce (&rnd, 1) != GC_OK)
+      if (MHD_gc_nonce (&rnd, 1) != GC_OK)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_RANDOM_FAILED;
         }
 
@@ -276,7 +276,7 @@ calc_enc_length (mhd_gtls_session_t session, int data_size,
 
       break;
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
@@ -289,9 +289,9 @@ calc_enc_length (mhd_gtls_session_t session, int data_size,
  * return the actual encrypted data length.
  */
 int
-mhd_gtls_compressed2ciphertext (mhd_gtls_session_t session,
+MHD_gtls_compressed2ciphertext (MHD_gtls_session_t session,
                                 opaque * cipher_data, int cipher_size,
-                                gnutls_datum_t compressed,
+                                MHD_gnutls_datum_t compressed,
                                 content_type_t _type, int random_pad)
 {
   uint8_t MAC[MAX_HASH_SIZE];
@@ -302,21 +302,21 @@ mhd_gtls_compressed2ciphertext (mhd_gtls_session_t session,
   uint8_t type = _type;
   uint8_t major, minor;
   int hash_size =
-    mhd_gnutls_hash_get_algo_len (session->security_parameters.
+    MHD_gnutls_hash_get_algo_len (session->security_parameters.
                                   write_mac_algorithm);
   enum MHD_GNUTLS_Protocol ver;
   int blocksize =
-    mhd_gtls_cipher_get_block_size (session->security_parameters.
+    MHD_gtls_cipher_get_block_size (session->security_parameters.
                                     write_bulk_cipher_algorithm);
   cipher_type_t block_algo =
-    mhd_gtls_cipher_is_block (session->security_parameters.
+    MHD_gtls_cipher_is_block (session->security_parameters.
                               write_bulk_cipher_algorithm);
   opaque *data_ptr;
 
 
-  ver = MHD_gnutls_protocol_get_version (session);
-  minor = mhd_gtls_version_get_minor (ver);
-  major = mhd_gtls_version_get_major (ver);
+  ver = MHD__gnutls_protocol_get_version (session);
+  minor = MHD_gtls_version_get_minor (ver);
+  major = MHD_gtls_version_get_major (ver);
 
 
   /* Initialize MAC */
@@ -328,26 +328,26 @@ mhd_gtls_compressed2ciphertext (mhd_gtls_session_t session,
       && session->security_parameters.write_mac_algorithm !=
       MHD_GNUTLS_MAC_NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
-  c_length = mhd_gtls_conv_uint16 (compressed.size);
+  c_length = MHD_gtls_conv_uint16 (compressed.size);
 
   if (td != GNUTLS_MAC_FAILED)
     {                           /* actually when the algorithm in not the NULL one */
-      mhd_gnutls_hash (td,
+      MHD_gnutls_hash (td,
                        UINT64DATA (session->connection_state.
                                    write_sequence_number), 8);
 
-      mhd_gnutls_hash (td, &type, 1);
+      MHD_gnutls_hash (td, &type, 1);
       if (ver >= MHD_GNUTLS_PROTOCOL_TLS1_0)
         {                       /* TLS 1.0 or higher */
-          mhd_gnutls_hash (td, &major, 1);
-          mhd_gnutls_hash (td, &minor, 1);
+          MHD_gnutls_hash (td, &major, 1);
+          MHD_gnutls_hash (td, &minor, 1);
         }
-      mhd_gnutls_hash (td, &c_length, 2);
-      mhd_gnutls_hash (td, compressed.data, compressed.size);
+      MHD_gnutls_hash (td, &c_length, 2);
+      MHD_gnutls_hash (td, compressed.data, compressed.size);
       mac_deinit (td, MAC, ver);
     }
 
@@ -359,7 +359,7 @@ mhd_gtls_compressed2ciphertext (mhd_gtls_session_t session,
                      random_pad, block_algo, blocksize);
   if (length < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return length;
     }
 
@@ -367,7 +367,7 @@ mhd_gtls_compressed2ciphertext (mhd_gtls_session_t session,
    */
   if (cipher_size < length)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
@@ -377,9 +377,9 @@ mhd_gtls_compressed2ciphertext (mhd_gtls_session_t session,
     {
       /* copy the random IV.
        */
-      if (gc_nonce (data_ptr, blocksize) != GC_OK)
+      if (MHD_gc_nonce (data_ptr, blocksize) != GC_OK)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_RANDOM_FAILED;
         }
       data_ptr += blocksize;
@@ -402,11 +402,11 @@ mhd_gtls_compressed2ciphertext (mhd_gtls_session_t session,
   /* Actual encryption (inplace).
    */
   ret =
-    mhd_gtls_cipher_encrypt (session->connection_state.write_cipher_state,
+    MHD_gtls_cipher_encrypt (session->connection_state.write_cipher_state,
                              cipher_data, length);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -417,10 +417,10 @@ mhd_gtls_compressed2ciphertext (mhd_gtls_session_t session,
  * Returns the actual compressed packet size.
  */
 int
-mhd_gtls_ciphertext2compressed (mhd_gtls_session_t session,
+MHD_gtls_ciphertext2compressed (MHD_gtls_session_t session,
                                 opaque * compress_data,
                                 int compress_size,
-                                gnutls_datum_t ciphertext, uint8_t type)
+                                MHD_gnutls_datum_t ciphertext, uint8_t type)
 {
   uint8_t MAC[MAX_HASH_SIZE];
   uint16_t c_length;
@@ -432,15 +432,15 @@ mhd_gtls_ciphertext2compressed (mhd_gtls_session_t session,
   uint8_t major, minor;
   enum MHD_GNUTLS_Protocol ver;
   int hash_size =
-    mhd_gnutls_hash_get_algo_len (session->security_parameters.
+    MHD_gnutls_hash_get_algo_len (session->security_parameters.
                                   read_mac_algorithm);
 
-  ver = MHD_gnutls_protocol_get_version (session);
-  minor = mhd_gtls_version_get_minor (ver);
-  major = mhd_gtls_version_get_major (ver);
+  ver = MHD__gnutls_protocol_get_version (session);
+  minor = MHD_gtls_version_get_minor (ver);
+  major = MHD_gtls_version_get_major (ver);
 
   blocksize =
-    mhd_gtls_cipher_get_block_size (session->security_parameters.
+    MHD_gtls_cipher_get_block_size (session->security_parameters.
                                     read_bulk_cipher_algorithm);
 
   /* initialize MAC
@@ -453,23 +453,23 @@ mhd_gtls_ciphertext2compressed (mhd_gtls_session_t session,
       && session->security_parameters.read_mac_algorithm !=
       MHD_GNUTLS_MAC_NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
 
   /* actual decryption (inplace)
    */
-  switch (mhd_gtls_cipher_is_block
+  switch (MHD_gtls_cipher_is_block
           (session->security_parameters.read_bulk_cipher_algorithm))
     {
     case CIPHER_STREAM:
       if ((ret =
-           mhd_gtls_cipher_decrypt (session->connection_state.
+           MHD_gtls_cipher_decrypt (session->connection_state.
                                     read_cipher_state, ciphertext.data,
                                     ciphertext.size)) < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
@@ -479,16 +479,16 @@ mhd_gtls_ciphertext2compressed (mhd_gtls_session_t session,
     case CIPHER_BLOCK:
       if ((ciphertext.size < blocksize) || (ciphertext.size % blocksize != 0))
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_DECRYPTION_FAILED;
         }
 
       if ((ret =
-           mhd_gtls_cipher_decrypt (session->connection_state.
+           MHD_gtls_cipher_decrypt (session->connection_state.
                                     read_cipher_state, ciphertext.data,
                                     ciphertext.size)) < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
@@ -501,7 +501,7 @@ mhd_gtls_ciphertext2compressed (mhd_gtls_session_t session,
 
           if (ciphertext.size == 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return GNUTLS_E_DECRYPTION_FAILED;
             }
         }
@@ -512,7 +512,7 @@ mhd_gtls_ciphertext2compressed (mhd_gtls_session_t session,
 
       if (pad > ciphertext.size - hash_size)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           /* We do not fail here. We check below for the
            * the pad_failed. If zero means success.
            */
@@ -530,33 +530,33 @@ mhd_gtls_ciphertext2compressed (mhd_gtls_session_t session,
           }
       break;
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
   if (length < 0)
     length = 0;
-  c_length = mhd_gtls_conv_uint16 ((uint16_t) length);
+  c_length = MHD_gtls_conv_uint16 ((uint16_t) length);
 
   /* Pass the type, version, length and compressed through
    * MAC.
    */
   if (td != GNUTLS_MAC_FAILED)
     {
-      mhd_gnutls_hash (td,
+      MHD_gnutls_hash (td,
                        UINT64DATA (session->connection_state.
                                    read_sequence_number), 8);
 
-      mhd_gnutls_hash (td, &type, 1);
+      MHD_gnutls_hash (td, &type, 1);
       if (ver >= MHD_GNUTLS_PROTOCOL_TLS1_0)
         {                       /* TLS 1.x */
-          mhd_gnutls_hash (td, &major, 1);
-          mhd_gnutls_hash (td, &minor, 1);
+          MHD_gnutls_hash (td, &major, 1);
+          MHD_gnutls_hash (td, &minor, 1);
         }
-      mhd_gnutls_hash (td, &c_length, 2);
+      MHD_gnutls_hash (td, &c_length, 2);
 
       if (length > 0)
-        mhd_gnutls_hash (td, ciphertext.data, length);
+        MHD_gnutls_hash (td, ciphertext.data, length);
 
       mac_deinit (td, MAC, ver);
     }
@@ -571,7 +571,7 @@ mhd_gtls_ciphertext2compressed (mhd_gtls_session_t session,
    */
   if (memcmp (MAC, &ciphertext.data[length], hash_size) != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_DECRYPTION_FAILED;
     }
 
@@ -579,7 +579,7 @@ mhd_gtls_ciphertext2compressed (mhd_gtls_session_t session,
    */
   if (compress_size < length)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_DECOMPRESSION_FAILED;
     }
   memcpy (compress_data, ciphertext.data, length);
diff --git a/src/daemon/https/tls/gnutls_cipher.h b/src/daemon/https/tls/gnutls_cipher.h
index 511ee989..ab86d380 100644
--- a/src/daemon/https/tls/gnutls_cipher.h
+++ b/src/daemon/https/tls/gnutls_cipher.h
@@ -22,19 +22,19 @@
  *
  */
 
-int mhd_gtls_encrypt (mhd_gtls_session_t session, const opaque * headers,
+int MHD_gtls_encrypt (MHD_gtls_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 mhd_gtls_decrypt (mhd_gtls_session_t session, opaque * ciphertext,
+int MHD_gtls_decrypt (MHD_gtls_session_t session, opaque * ciphertext,
                       size_t ciphertext_size, uint8_t * data,
                       size_t data_size, content_type_t type);
-int mhd_gtls_compressed2ciphertext (mhd_gtls_session_t session,
+int MHD_gtls_compressed2ciphertext (MHD_gtls_session_t session,
                                     opaque * cipher_data, int cipher_size,
-                                    gnutls_datum_t compressed,
+                                    MHD_gnutls_datum_t compressed,
                                     content_type_t _type, int random_pad);
-int mhd_gtls_ciphertext2compressed (mhd_gtls_session_t session,
+int MHD_gtls_ciphertext2compressed (MHD_gtls_session_t session,
                                     opaque * compress_data, int compress_size,
-                                    gnutls_datum_t ciphertext, uint8_t type);
+                                    MHD_gnutls_datum_t ciphertext, uint8_t type);
diff --git a/src/daemon/https/tls/gnutls_cipher_int.c b/src/daemon/https/tls/gnutls_cipher_int.c
index 836188aa..fef2c1d9 100644
--- a/src/daemon/https/tls/gnutls_cipher_int.c
+++ b/src/daemon/https/tls/gnutls_cipher_int.c
@@ -28,8 +28,8 @@
 #include <gnutls_datum.h>
 
 cipher_hd_t
-mhd_gtls_cipher_init (enum MHD_GNUTLS_CipherAlgorithm cipher,
-                      const gnutls_datum_t * key, const gnutls_datum_t * iv)
+MHD_gtls_cipher_init (enum MHD_GNUTLS_CipherAlgorithm cipher,
+                      const MHD_gnutls_datum_t * key, const MHD_gnutls_datum_t * iv)
 {
   cipher_hd_t ret = NULL;
   int err = GC_INVALID_CIPHER;  /* doesn't matter */
@@ -37,40 +37,40 @@ mhd_gtls_cipher_init (enum MHD_GNUTLS_CipherAlgorithm cipher,
   switch (cipher)
     {
     case MHD_GNUTLS_CIPHER_AES_128_CBC:
-      err = gc_cipher_open (GC_AES128, GC_CBC, &ret);
+      err = MHD_gc_cipher_open (GC_AES128, GC_CBC, &ret);
       break;
 
     case MHD_GNUTLS_CIPHER_AES_256_CBC:
-      err = gc_cipher_open (GC_AES256, GC_CBC, &ret);
+      err = MHD_gc_cipher_open (GC_AES256, GC_CBC, &ret);
       break;
 
     case MHD_GNUTLS_CIPHER_3DES_CBC:
-      err = gc_cipher_open (GC_3DES, GC_CBC, &ret);
+      err = MHD_gc_cipher_open (GC_3DES, GC_CBC, &ret);
       break;
 
     case MHD_GNUTLS_CIPHER_DES_CBC:
-      err = gc_cipher_open (GC_DES, GC_CBC, &ret);
+      err = MHD_gc_cipher_open (GC_DES, GC_CBC, &ret);
       break;
 
     case MHD_GNUTLS_CIPHER_ARCFOUR_128:
-      err = gc_cipher_open (GC_ARCFOUR128, GC_STREAM, &ret);
+      err = MHD_gc_cipher_open (GC_ARCFOUR128, GC_STREAM, &ret);
       break;
 
     case MHD_GNUTLS_CIPHER_ARCFOUR_40:
-      err = gc_cipher_open (GC_ARCFOUR40, GC_STREAM, &ret);
+      err = MHD_gc_cipher_open (GC_ARCFOUR40, GC_STREAM, &ret);
       break;
 
     case MHD_GNUTLS_CIPHER_RC2_40_CBC:
-      err = gc_cipher_open (GC_ARCTWO40, GC_CBC, &ret);
+      err = MHD_gc_cipher_open (GC_ARCTWO40, GC_CBC, &ret);
       break;
 
 #ifdef  ENABLE_CAMELLIA
     case MHD_GNUTLS_CIPHER_CAMELLIA_128_CBC:
-      err = gc_cipher_open (GC_CAMELLIA128, GC_CBC, &ret);
+      err = MHD_gc_cipher_open (GC_CAMELLIA128, GC_CBC, &ret);
       break;
 
     case MHD_GNUTLS_CIPHER_CAMELLIA_256_CBC:
-      err = gc_cipher_open (GC_CAMELLIA256, GC_CBC, &ret);
+      err = MHD_gc_cipher_open (GC_CAMELLIA256, GC_CBC, &ret);
       break;
 #endif
 
@@ -80,28 +80,28 @@ mhd_gtls_cipher_init (enum MHD_GNUTLS_CipherAlgorithm cipher,
 
   if (err == 0)
     {
-      gc_cipher_setkey (ret, key->size, key->data);
+      MHD_gc_cipher_setkey (ret, key->size, key->data);
       if (iv->data != NULL && iv->size > 0)
-        gc_cipher_setiv (ret, iv->size, iv->data);
+        MHD_gc_cipher_setiv (ret, iv->size, iv->data);
     }
   else if (cipher != MHD_GNUTLS_CIPHER_NULL)
     {
-      gnutls_assert ();
-      _gnutls_x509_log ("Crypto cipher[%d] error: %d\n", cipher, err);
-      /* FIXME: gc_strerror */
+      MHD_gnutls_assert ();
+      MHD__gnutls_x509_log ("Crypto cipher[%d] error: %d\n", cipher, err);
+      /* FIXME: MHD_gc_strerror */
     }
 
   return ret;
 }
 
 int
-mhd_gtls_cipher_encrypt (cipher_hd_t handle, void *text, int textlen)
+MHD_gtls_cipher_encrypt (cipher_hd_t handle, void *text, int textlen)
 {
   if (handle != GNUTLS_CIPHER_FAILED)
     {
-      if (gc_cipher_encrypt_inline (handle, textlen, text) != 0)
+      if (MHD_gc_cipher_encrypt_inline (handle, textlen, text) != 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_INTERNAL_ERROR;
         }
     }
@@ -109,14 +109,14 @@ mhd_gtls_cipher_encrypt (cipher_hd_t handle, void *text, int textlen)
 }
 
 int
-mhd_gtls_cipher_decrypt (cipher_hd_t handle, void *ciphertext,
+MHD_gtls_cipher_decrypt (cipher_hd_t handle, void *ciphertext,
                          int ciphertextlen)
 {
   if (handle != GNUTLS_CIPHER_FAILED)
     {
-      if (gc_cipher_decrypt_inline (handle, ciphertextlen, ciphertext) != 0)
+      if (MHD_gc_cipher_decrypt_inline (handle, ciphertextlen, ciphertext) != 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_INTERNAL_ERROR;
         }
     }
@@ -124,10 +124,10 @@ mhd_gtls_cipher_decrypt (cipher_hd_t handle, void *ciphertext,
 }
 
 void
-mhd_gnutls_cipher_deinit (cipher_hd_t handle)
+MHD_gnutls_cipher_deinit (cipher_hd_t handle)
 {
   if (handle != GNUTLS_CIPHER_FAILED)
     {
-      gc_cipher_close (handle);
+      MHD_gc_cipher_close (handle);
     }
 }
diff --git a/src/daemon/https/tls/gnutls_cipher_int.h b/src/daemon/https/tls/gnutls_cipher_int.h
index 6e2c8269..f00f945f 100644
--- a/src/daemon/https/tls/gnutls_cipher_int.h
+++ b/src/daemon/https/tls/gnutls_cipher_int.h
@@ -25,19 +25,19 @@
 #ifndef GNUTLS_CIPHER_INT
 # define GNUTLS_CIPHER_INT
 
-#define cipher_hd_t gc_cipher_handle
+#define cipher_hd_t MHD_gc_cipher_handle
 #define GNUTLS_CIPHER_FAILED NULL
 
-// TODO gc_cipher_handle -> void * x3
-void *mhd_gtls_cipher_init (enum MHD_GNUTLS_CipherAlgorithm cipher,
-                            const gnutls_datum_t * key,
-                            const gnutls_datum_t * iv);
+// TODO MHD_gc_cipher_handle -> void * x3
+void *MHD_gtls_cipher_init (enum MHD_GNUTLS_CipherAlgorithm cipher,
+                            const MHD_gnutls_datum_t * key,
+                            const MHD_gnutls_datum_t * iv);
 
-int mhd_gtls_cipher_encrypt (void *handle, void *text, int textlen);
+int MHD_gtls_cipher_encrypt (void *handle, void *text, int textlen);
 
-int mhd_gtls_cipher_decrypt (void *handle,
+int MHD_gtls_cipher_decrypt (void *handle,
                              void *ciphertext, int ciphertextlen);
 
-void mhd_gnutls_cipher_deinit (void *handle);
+void MHD_gnutls_cipher_deinit (void *handle);
 
 #endif /* GNUTLS_CIPHER_INT */
diff --git a/src/daemon/https/tls/gnutls_compress.c b/src/daemon/https/tls/gnutls_compress.c
index 9585fcf2..9552a72a 100644
--- a/src/daemon/https/tls/gnutls_compress.c
+++ b/src/daemon/https/tls/gnutls_compress.c
@@ -34,20 +34,20 @@
 /* These functions allocate the return value internally
  */
 int
-_gnutls_m_plaintext2compressed (mhd_gtls_session_t session,
-                                gnutls_datum_t * compressed,
-                                const gnutls_datum_t * plaintext)
+MHD__gnutls_m_plaintext2compressed (MHD_gtls_session_t session,
+                                MHD_gnutls_datum_t * compressed,
+                                const MHD_gnutls_datum_t * plaintext)
 {
   int size;
   opaque *data;
 
   size =
-    mhd_gtls_compress (session->connection_state.write_compression_state,
+    MHD_gtls_compress (session->connection_state.write_compression_state,
                        plaintext->data, plaintext->size, &data,
                        MAX_RECORD_SEND_SIZE + EXTRA_COMP_SIZE);
   if (size < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_COMPRESSION_FAILED;
     }
   compressed->data = data;
@@ -57,20 +57,20 @@ _gnutls_m_plaintext2compressed (mhd_gtls_session_t session,
 }
 
 int
-_gnutls_m_compressed2plaintext (mhd_gtls_session_t session,
-                                gnutls_datum_t * plain,
-                                const gnutls_datum_t * compressed)
+MHD__gnutls_m_compressed2plaintext (MHD_gtls_session_t session,
+                                MHD_gnutls_datum_t * plain,
+                                const MHD_gnutls_datum_t * compressed)
 {
   int size;
   opaque *data;
 
   size =
-    mhd_gtls_decompress (session->connection_state.read_compression_state,
+    MHD_gtls_decompress (session->connection_state.read_compression_state,
                          compressed->data, compressed->size, &data,
                          MAX_RECORD_RECV_SIZE);
   if (size < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_DECOMPRESSION_FAILED;
     }
   plain->data = data;
diff --git a/src/daemon/https/tls/gnutls_compress.h b/src/daemon/https/tls/gnutls_compress.h
index 7ccca5c3..c950e95d 100644
--- a/src/daemon/https/tls/gnutls_compress.h
+++ b/src/daemon/https/tls/gnutls_compress.h
@@ -22,9 +22,9 @@
  *
  */
 
-int _gnutls_m_plaintext2compressed (mhd_gtls_session_t session,
-                                    gnutls_datum_t * compressed,
-                                    const gnutls_datum_t * plaintext);
-int _gnutls_m_compressed2plaintext (mhd_gtls_session_t session,
-                                    gnutls_datum_t * plain,
-                                    const gnutls_datum_t * compressed);
+int MHD__gnutls_m_plaintext2compressed (MHD_gtls_session_t session,
+                                    MHD_gnutls_datum_t * compressed,
+                                    const MHD_gnutls_datum_t * plaintext);
+int MHD__gnutls_m_compressed2plaintext (MHD_gtls_session_t session,
+                                    MHD_gnutls_datum_t * plain,
+                                    const MHD_gnutls_datum_t * compressed);
diff --git a/src/daemon/https/tls/gnutls_compress_int.c b/src/daemon/https/tls/gnutls_compress_int.c
index 1d272bed..6b97fac4 100644
--- a/src/daemon/https/tls/gnutls_compress_int.c
+++ b/src/daemon/https/tls/gnutls_compress_int.c
@@ -31,14 +31,14 @@
  * decompress.
  */
 comp_hd_t
-mhd_gtls_comp_init (enum MHD_GNUTLS_CompressionMethod method, int d)
+MHD_gtls_comp_init (enum MHD_GNUTLS_CompressionMethod method, int d)
 {
   comp_hd_t ret;
 
-  ret = gnutls_malloc (sizeof (struct comp_hd_t_STRUCT));
+  ret = MHD_gnutls_malloc (sizeof (struct comp_hd_t_STRUCT));
   if (ret == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return NULL;
     }
 
@@ -54,14 +54,14 @@ mhd_gtls_comp_init (enum MHD_GNUTLS_CompressionMethod method, int d)
         int comp_level;
         z_stream *zhandle;
 
-        window_bits = mhd_gtls_compression_get_wbits (method);
-        mem_level = mhd_gtls_compression_get_mem_level (method);
-        comp_level = mhd_gtls_compression_get_comp_level (method);
+        window_bits = MHD_gtls_compression_get_wbits (method);
+        mem_level = MHD_gtls_compression_get_mem_level (method);
+        comp_level = MHD_gtls_compression_get_comp_level (method);
 
-        ret->handle = gnutls_malloc (sizeof (z_stream));
+        ret->handle = MHD_gnutls_malloc (sizeof (z_stream));
         if (ret->handle == NULL)
           {
-            gnutls_assert ();
+            MHD_gnutls_assert ();
             goto cleanup_ret;
           }
 
@@ -81,8 +81,8 @@ mhd_gtls_comp_init (enum MHD_GNUTLS_CompressionMethod method, int d)
           }
         if (err != Z_OK)
           {
-            gnutls_assert ();
-            gnutls_free (ret->handle);
+            MHD_gnutls_assert ();
+            MHD_gnutls_free (ret->handle);
             goto cleanup_ret;
           }
         break;
@@ -94,7 +94,7 @@ mhd_gtls_comp_init (enum MHD_GNUTLS_CompressionMethod method, int d)
   return ret;
 
 cleanup_ret:
-  gnutls_free (ret);
+  MHD_gnutls_free (ret);
   return NULL;
 }
 
@@ -102,7 +102,7 @@ cleanup_ret:
  * decompress.
  */
 void
-mhd_gtls_comp_deinit (comp_hd_t handle, int d)
+MHD_gtls_comp_deinit (comp_hd_t handle, int d)
 {
   if (handle != NULL)
     {
@@ -119,8 +119,8 @@ mhd_gtls_comp_deinit (comp_hd_t handle, int d)
         default:
           break;
         }
-      gnutls_free (handle->handle);
-      gnutls_free (handle);
+      MHD_gnutls_free (handle->handle);
+      MHD_gnutls_free (handle);
 
     }
 }
@@ -129,7 +129,7 @@ mhd_gtls_comp_deinit (comp_hd_t handle, int d)
  */
 
 int
-mhd_gtls_compress (comp_hd_t handle, const opaque * plain,
+MHD_gtls_compress (comp_hd_t handle, const opaque * plain,
                    size_t plain_size, opaque ** compressed,
                    size_t max_comp_size)
 {
@@ -139,7 +139,7 @@ mhd_gtls_compress (comp_hd_t handle, const opaque * plain,
    */
   if (handle == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
@@ -153,10 +153,10 @@ mhd_gtls_compress (comp_hd_t handle, const opaque * plain,
         z_stream *zhandle;
 
         size = (plain_size + plain_size) + 10;
-        *compressed = gnutls_malloc (size);
+        *compressed = MHD_gnutls_malloc (size);
         if (*compressed == NULL)
           {
-            gnutls_assert ();
+            MHD_gnutls_assert ();
             return GNUTLS_E_MEMORY_ERROR;
           }
 
@@ -171,8 +171,8 @@ mhd_gtls_compress (comp_hd_t handle, const opaque * plain,
 
         if (err != Z_OK || zhandle->avail_in != 0)
           {
-            gnutls_assert ();
-            gnutls_free (*compressed);
+            MHD_gnutls_assert ();
+            MHD_gnutls_free (*compressed);
             *compressed = NULL;
             return GNUTLS_E_COMPRESSION_FAILED;
           }
@@ -182,18 +182,18 @@ mhd_gtls_compress (comp_hd_t handle, const opaque * plain,
       }
 #endif
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }                           /* switch */
 
 #ifdef COMPRESSION_DEBUG
-  _gnutls_debug_log ("Compression ratio: %f\n",
+  MHD__gnutls_debug_log ("Compression ratio: %f\n",
                      (float) ((float) compressed_size / (float) plain_size));
 #endif
 
   if ((size_t) compressed_size > max_comp_size)
     {
-      gnutls_free (*compressed);
+      MHD_gnutls_free (*compressed);
       *compressed = NULL;
       return GNUTLS_E_COMPRESSION_FAILED;
     }
@@ -204,7 +204,7 @@ mhd_gtls_compress (comp_hd_t handle, const opaque * plain,
 
 
 int
-mhd_gtls_decompress (comp_hd_t handle, opaque * compressed,
+MHD_gtls_decompress (comp_hd_t handle, opaque * compressed,
                      size_t compressed_size, opaque ** plain,
                      size_t max_record_size)
 {
@@ -212,7 +212,7 @@ mhd_gtls_decompress (comp_hd_t handle, opaque * compressed,
 
   if (compressed_size > max_record_size + EXTRA_COMP_SIZE)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_DECOMPRESSION_FAILED;
     }
 
@@ -221,7 +221,7 @@ mhd_gtls_decompress (comp_hd_t handle, opaque * compressed,
 
   if (handle == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
@@ -247,10 +247,10 @@ mhd_gtls_decompress (comp_hd_t handle, opaque * compressed,
         do
           {
             out_size += 512;
-            *plain = mhd_gtls_realloc_fast (*plain, out_size);
+            *plain = MHD_gtls_realloc_fast (*plain, out_size);
             if (*plain == NULL)
               {
-                gnutls_assert ();
+                MHD_gnutls_assert ();
                 return GNUTLS_E_MEMORY_ERROR;
               }
 
@@ -268,8 +268,8 @@ mhd_gtls_decompress (comp_hd_t handle, opaque * compressed,
 
         if (err != Z_OK)
           {
-            gnutls_assert ();
-            gnutls_free (*plain);
+            MHD_gnutls_assert ();
+            MHD_gnutls_free (*plain);
             *plain = NULL;
             return GNUTLS_E_DECOMPRESSION_FAILED;
           }
@@ -279,14 +279,14 @@ mhd_gtls_decompress (comp_hd_t handle, opaque * compressed,
       }
 #endif
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }                           /* switch */
 
   if ((size_t) plain_size > max_record_size)
     {
-      gnutls_assert ();
-      gnutls_free (*plain);
+      MHD_gnutls_assert ();
+      MHD_gnutls_free (*plain);
       *plain = NULL;
       return GNUTLS_E_DECOMPRESSION_FAILED;
     }
diff --git a/src/daemon/https/tls/gnutls_compress_int.h b/src/daemon/https/tls/gnutls_compress_int.h
index 32edae7a..672cb392 100644
--- a/src/daemon/https/tls/gnutls_compress_int.h
+++ b/src/daemon/https/tls/gnutls_compress_int.h
@@ -37,13 +37,13 @@ typedef struct comp_hd_t_STRUCT
   enum MHD_GNUTLS_CompressionMethod algo;
 } *comp_hd_t;
 
-comp_hd_t mhd_gtls_comp_init (enum MHD_GNUTLS_CompressionMethod, int d);
-void mhd_gtls_comp_deinit (comp_hd_t handle, int d);
+comp_hd_t MHD_gtls_comp_init (enum MHD_GNUTLS_CompressionMethod, int d);
+void MHD_gtls_comp_deinit (comp_hd_t handle, int d);
 
-int mhd_gtls_decompress (comp_hd_t handle, opaque * compressed,
+int MHD_gtls_decompress (comp_hd_t handle, opaque * compressed,
                          size_t compressed_size, opaque ** plain,
                          size_t max_record_size);
-int mhd_gtls_compress (comp_hd_t, const opaque * plain, size_t plain_size,
+int MHD_gtls_compress (comp_hd_t, const opaque * plain, size_t plain_size,
                        opaque ** compressed, size_t max_comp_size);
 
 #endif
diff --git a/src/daemon/https/tls/gnutls_constate.c b/src/daemon/https/tls/gnutls_constate.c
index 9ace3533..e38b720f 100644
--- a/src/daemon/https/tls/gnutls_constate.c
+++ b/src/daemon/https/tls/gnutls_constate.c
@@ -56,7 +56,7 @@ static const int servwrite_length = sizeof (servwrite) - 1;
  * (session->cipher_specs)
  */
 int
-_gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
+MHD__gnutls_set_keys (MHD_gtls_session_t session, int hash_size, int IV_size,
                   int key_size, int export_flag)
 {
 
@@ -82,10 +82,10 @@ _gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
   if (export_flag == 0)
     block_size += 2 * IV_size;
 
-  key_block = gnutls_secure_malloc (block_size);
+  key_block = MHD_gnutls_secure_malloc (block_size);
   if (key_block == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
@@ -100,46 +100,46 @@ _gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
   if (session->security_parameters.version == MHD_GNUTLS_PROTOCOL_SSL3)
     {                           /* SSL 3 */
       ret =
-        mhd_gnutls_ssl3_generate_random
+        MHD_gnutls_ssl3_generate_random
         (session->security_parameters.master_secret, TLS_MASTER_SIZE, rnd,
          2 * TLS_RANDOM_SIZE, block_size, key_block);
     }
   else
     {                           /* TLS 1.0 */
       ret =
-        mhd_gtls_PRF (session, session->security_parameters.master_secret,
+        MHD_gtls_PRF (session, session->security_parameters.master_secret,
                       TLS_MASTER_SIZE, keyexp, keyexp_length,
                       rnd, 2 * TLS_RANDOM_SIZE, block_size, key_block);
     }
 
   if (ret < 0)
     {
-      gnutls_assert ();
-      gnutls_free (key_block);
+      MHD_gnutls_assert ();
+      MHD_gnutls_free (key_block);
       return ret;
     }
 
-  _gnutls_hard_log ("INT: KEY BLOCK[%d]: %s\n", block_size,
-                    mhd_gtls_bin2hex (key_block, block_size, buf,
+  MHD__gnutls_hard_log ("INT: KEY BLOCK[%d]: %s\n", block_size,
+                    MHD_gtls_bin2hex (key_block, block_size, buf,
                                       sizeof (buf)));
 
   pos = 0;
   if (hash_size > 0)
     {
-      if (_gnutls_sset_datum
+      if (MHD__gnutls_sset_datum
           (&session->cipher_specs.client_write_mac_secret,
            &key_block[pos], hash_size) < 0)
         {
-          gnutls_free (key_block);
+          MHD_gnutls_free (key_block);
           return GNUTLS_E_MEMORY_ERROR;
         }
       pos += hash_size;
 
-      if (_gnutls_sset_datum
+      if (MHD__gnutls_sset_datum
           (&session->cipher_specs.server_write_mac_secret,
            &key_block[pos], hash_size) < 0)
         {
-          gnutls_free (key_block);
+          MHD_gnutls_free (key_block);
           return GNUTLS_E_MEMORY_ERROR;
         }
       pos += hash_size;
@@ -168,20 +168,20 @@ _gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
         {                       /* export */
           free_keys = 1;
 
-          client_write_key = gnutls_secure_malloc (EXPORT_FINAL_KEY_SIZE);
+          client_write_key = MHD_gnutls_secure_malloc (EXPORT_FINAL_KEY_SIZE);
           if (client_write_key == NULL)
             {
-              gnutls_assert ();
-              gnutls_free (key_block);
+              MHD_gnutls_assert ();
+              MHD_gnutls_free (key_block);
               return GNUTLS_E_MEMORY_ERROR;
             }
 
-          server_write_key = gnutls_secure_malloc (EXPORT_FINAL_KEY_SIZE);
+          server_write_key = MHD_gnutls_secure_malloc (EXPORT_FINAL_KEY_SIZE);
           if (server_write_key == NULL)
             {
-              gnutls_assert ();
-              gnutls_free (key_block);
-              gnutls_free (client_write_key);
+              MHD_gnutls_assert ();
+              MHD_gnutls_free (key_block);
+              MHD_gnutls_free (client_write_key);
               return GNUTLS_E_MEMORY_ERROR;
             }
 
@@ -190,7 +190,7 @@ _gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
           if (session->security_parameters.version == MHD_GNUTLS_PROTOCOL_SSL3)
             {                   /* SSL 3 */
               ret =
-                mhd_gnutls_ssl3_hash_md5 (&key_block[pos],
+                MHD_gnutls_ssl3_hash_md5 (&key_block[pos],
                                           key_size, rrnd,
                                           2 * TLS_RANDOM_SIZE,
                                           EXPORT_FINAL_KEY_SIZE,
@@ -200,7 +200,7 @@ _gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
           else
             {                   /* TLS 1.0 */
               ret =
-                mhd_gtls_PRF (session, &key_block[pos], key_size,
+                MHD_gtls_PRF (session, &key_block[pos], key_size,
                               cliwrite, cliwrite_length,
                               rrnd,
                               2 * TLS_RANDOM_SIZE,
@@ -209,10 +209,10 @@ _gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
 
           if (ret < 0)
             {
-              gnutls_assert ();
-              gnutls_free (key_block);
-              gnutls_free (server_write_key);
-              gnutls_free (client_write_key);
+              MHD_gnutls_assert ();
+              MHD_gnutls_free (key_block);
+              MHD_gnutls_free (server_write_key);
+              MHD_gnutls_free (client_write_key);
               return ret;
             }
 
@@ -222,7 +222,7 @@ _gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
           if (session->security_parameters.version == MHD_GNUTLS_PROTOCOL_SSL3)
             {                   /* SSL 3 */
               ret =
-                mhd_gnutls_ssl3_hash_md5 (&key_block[pos], key_size,
+                MHD_gnutls_ssl3_hash_md5 (&key_block[pos], key_size,
                                           rnd, 2 * TLS_RANDOM_SIZE,
                                           EXPORT_FINAL_KEY_SIZE,
                                           server_write_key);
@@ -230,7 +230,7 @@ _gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
           else
             {                   /* TLS 1.0 */
               ret =
-                mhd_gtls_PRF (session, &key_block[pos], key_size,
+                MHD_gtls_PRF (session, &key_block[pos], key_size,
                               servwrite, servwrite_length,
                               rrnd, 2 * TLS_RANDOM_SIZE,
                               EXPORT_FINAL_KEY_SIZE, server_write_key);
@@ -238,10 +238,10 @@ _gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
 
           if (ret < 0)
             {
-              gnutls_assert ();
-              gnutls_free (key_block);
-              gnutls_free (server_write_key);
-              gnutls_free (client_write_key);
+              MHD_gnutls_assert ();
+              MHD_gnutls_free (key_block);
+              MHD_gnutls_free (server_write_key);
+              MHD_gnutls_free (client_write_key);
               return ret;
             }
 
@@ -249,41 +249,41 @@ _gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
           pos += key_size;
         }
 
-      if (_gnutls_sset_datum
+      if (MHD__gnutls_sset_datum
           (&session->cipher_specs.client_write_key,
            client_write_key, client_write_key_size) < 0)
         {
-          gnutls_free (key_block);
-          gnutls_free (server_write_key);
-          gnutls_free (client_write_key);
+          MHD_gnutls_free (key_block);
+          MHD_gnutls_free (server_write_key);
+          MHD_gnutls_free (client_write_key);
           return GNUTLS_E_MEMORY_ERROR;
         }
-      _gnutls_hard_log ("INT: CLIENT WRITE KEY [%d]: %s\n",
+      MHD__gnutls_hard_log ("INT: CLIENT WRITE KEY [%d]: %s\n",
                         client_write_key_size,
-                        mhd_gtls_bin2hex (client_write_key,
+                        MHD_gtls_bin2hex (client_write_key,
                                           client_write_key_size, buf,
                                           sizeof (buf)));
 
-      if (_gnutls_sset_datum
+      if (MHD__gnutls_sset_datum
           (&session->cipher_specs.server_write_key,
            server_write_key, server_write_key_size) < 0)
         {
-          gnutls_free (key_block);
-          gnutls_free (server_write_key);
-          gnutls_free (client_write_key);
+          MHD_gnutls_free (key_block);
+          MHD_gnutls_free (server_write_key);
+          MHD_gnutls_free (client_write_key);
           return GNUTLS_E_MEMORY_ERROR;
         }
 
-      _gnutls_hard_log ("INT: SERVER WRITE KEY [%d]: %s\n",
+      MHD__gnutls_hard_log ("INT: SERVER WRITE KEY [%d]: %s\n",
                         server_write_key_size,
-                        mhd_gtls_bin2hex (server_write_key,
+                        MHD_gtls_bin2hex (server_write_key,
                                           server_write_key_size, buf,
                                           sizeof (buf)));
 
       if (free_keys != 0)
         {
-          gnutls_free (server_write_key);
-          gnutls_free (client_write_key);
+          MHD_gnutls_free (server_write_key);
+          MHD_gnutls_free (client_write_key);
         }
     }
 
@@ -292,20 +292,20 @@ _gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
    */
   if (IV_size > 0 && export_flag == 0)
     {
-      if (_gnutls_sset_datum
+      if (MHD__gnutls_sset_datum
           (&session->cipher_specs.client_write_IV, &key_block[pos],
            IV_size) < 0)
         {
-          gnutls_free (key_block);
+          MHD_gnutls_free (key_block);
           return GNUTLS_E_MEMORY_ERROR;
         }
       pos += IV_size;
 
-      if (_gnutls_sset_datum
+      if (MHD__gnutls_sset_datum
           (&session->cipher_specs.server_write_IV, &key_block[pos],
            IV_size) < 0)
         {
-          gnutls_free (key_block);
+          MHD_gnutls_free (key_block);
           return GNUTLS_E_MEMORY_ERROR;
         }
       pos += IV_size;
@@ -313,69 +313,69 @@ _gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
     }
   else if (IV_size > 0 && export_flag != 0)
     {
-      opaque *iv_block = gnutls_alloca (IV_size * 2);
+      opaque *iv_block = MHD_gnutls_alloca (IV_size * 2);
       if (iv_block == NULL)
         {
-          gnutls_assert ();
-          gnutls_free (key_block);
+          MHD_gnutls_assert ();
+          MHD_gnutls_free (key_block);
           return GNUTLS_E_MEMORY_ERROR;
         }
 
       if (session->security_parameters.version == MHD_GNUTLS_PROTOCOL_SSL3)
         {                       /* SSL 3 */
-          ret = mhd_gnutls_ssl3_hash_md5 ("", 0,
+          ret = MHD_gnutls_ssl3_hash_md5 ("", 0,
                                           rrnd, TLS_RANDOM_SIZE * 2,
                                           IV_size, iv_block);
 
           if (ret < 0)
             {
-              gnutls_assert ();
-              gnutls_free (key_block);
-              gnutls_afree (iv_block);
+              MHD_gnutls_assert ();
+              MHD_gnutls_free (key_block);
+              MHD_gnutls_afree (iv_block);
               return ret;
             }
 
-          ret = mhd_gnutls_ssl3_hash_md5 ("", 0, rnd,
+          ret = MHD_gnutls_ssl3_hash_md5 ("", 0, rnd,
                                           TLS_RANDOM_SIZE * 2,
                                           IV_size, &iv_block[IV_size]);
 
         }
       else
         {                       /* TLS 1.0 */
-          ret = mhd_gtls_PRF (session, "", 0,
+          ret = MHD_gtls_PRF (session, "", 0,
                               ivblock, ivblock_length, rrnd,
                               2 * TLS_RANDOM_SIZE, IV_size * 2, iv_block);
         }
 
       if (ret < 0)
         {
-          gnutls_assert ();
-          gnutls_afree (iv_block);
-          gnutls_free (key_block);
+          MHD_gnutls_assert ();
+          MHD_gnutls_afree (iv_block);
+          MHD_gnutls_free (key_block);
           return ret;
         }
 
-      if (_gnutls_sset_datum
+      if (MHD__gnutls_sset_datum
           (&session->cipher_specs.client_write_IV, iv_block, IV_size) < 0)
         {
-          gnutls_afree (iv_block);
-          gnutls_free (key_block);
+          MHD_gnutls_afree (iv_block);
+          MHD_gnutls_free (key_block);
           return GNUTLS_E_MEMORY_ERROR;
         }
 
-      if (_gnutls_sset_datum
+      if (MHD__gnutls_sset_datum
           (&session->cipher_specs.server_write_IV,
            &iv_block[IV_size], IV_size) < 0)
         {
-          gnutls_afree (iv_block);
-          gnutls_free (key_block);
+          MHD_gnutls_afree (iv_block);
+          MHD_gnutls_free (key_block);
           return GNUTLS_E_MEMORY_ERROR;
         }
 
-      gnutls_afree (iv_block);
+      MHD_gnutls_afree (iv_block);
     }
 
-  gnutls_free (key_block);
+  MHD_gnutls_free (key_block);
 
   session->cipher_specs.generated_keys = 1;
 
@@ -383,7 +383,7 @@ _gnutls_set_keys (mhd_gtls_session_t session, int hash_size, int IV_size,
 }
 
 int
-_gnutls_set_read_keys (mhd_gtls_session_t session)
+MHD__gnutls_set_read_keys (MHD_gtls_session_t session)
 {
   int hash_size;
   int IV_size;
@@ -394,17 +394,17 @@ _gnutls_set_read_keys (mhd_gtls_session_t session)
   mac_algo = session->security_parameters.read_mac_algorithm;
   algo = session->security_parameters.read_bulk_cipher_algorithm;
 
-  hash_size = mhd_gnutls_hash_get_algo_len (mac_algo);
-  IV_size = mhd_gtls_cipher_get_iv_size (algo);
-  key_size = MHD_gnutls_cipher_get_key_size (algo);
-  export_flag = mhd_gtls_cipher_get_export_flag (algo);
+  hash_size = MHD_gnutls_hash_get_algo_len (mac_algo);
+  IV_size = MHD_gtls_cipher_get_iv_size (algo);
+  key_size = MHD__gnutls_cipher_get_key_size (algo);
+  export_flag = MHD_gtls_cipher_get_export_flag (algo);
 
-  return _gnutls_set_keys (session, hash_size, IV_size, key_size,
+  return MHD__gnutls_set_keys (session, hash_size, IV_size, key_size,
                            export_flag);
 }
 
 int
-_gnutls_set_write_keys (mhd_gtls_session_t session)
+MHD__gnutls_set_write_keys (MHD_gtls_session_t session)
 {
   int hash_size;
   int IV_size;
@@ -415,12 +415,12 @@ _gnutls_set_write_keys (mhd_gtls_session_t session)
   mac_algo = session->security_parameters.write_mac_algorithm;
   algo = session->security_parameters.write_bulk_cipher_algorithm;
 
-  hash_size = mhd_gnutls_hash_get_algo_len (mac_algo);
-  IV_size = mhd_gtls_cipher_get_iv_size (algo);
-  key_size = MHD_gnutls_cipher_get_key_size (algo);
-  export_flag = mhd_gtls_cipher_get_export_flag (algo);
+  hash_size = MHD_gnutls_hash_get_algo_len (mac_algo);
+  IV_size = MHD_gtls_cipher_get_iv_size (algo);
+  key_size = MHD__gnutls_cipher_get_key_size (algo);
+  export_flag = MHD_gtls_cipher_get_export_flag (algo);
 
-  return _gnutls_set_keys (session, hash_size, IV_size, key_size,
+  return MHD__gnutls_set_keys (session, hash_size, IV_size, key_size,
                            export_flag);
 }
 
@@ -437,12 +437,12 @@ _gnutls_set_write_keys (mhd_gtls_session_t session)
         dst->max_record_recv_size = src->max_record_recv_size; \
         dst->max_record_send_size = src->max_record_send_size; \
         dst->version = src->version; \
-        memcpy( &dst->extensions, &src->extensions, sizeof(mhd_gtls_ext_st)); \
+        memcpy( &dst->extensions, &src->extensions, sizeof(MHD_gtls_ext_st)); \
         memcpy( &dst->inner_secret, &src->inner_secret, TLS_MASTER_SIZE);
 
 static void
-_gnutls_cpy_read_security_parameters (mhd_gtls_security_param_st *
-                                      dst, mhd_gtls_security_param_st * src)
+MHD__gnutls_cpy_read_security_parameters (MHD_gtls_security_param_st *
+                                      dst, MHD_gtls_security_param_st * src)
 {
   CPY_COMMON;
 
@@ -452,8 +452,8 @@ _gnutls_cpy_read_security_parameters (mhd_gtls_security_param_st *
 }
 
 static void
-_gnutls_cpy_write_security_parameters (mhd_gtls_security_param_st *
-                                       dst, mhd_gtls_security_param_st * src)
+MHD__gnutls_cpy_write_security_parameters (MHD_gtls_security_param_st *
+                                       dst, MHD_gtls_security_param_st * src)
 {
   CPY_COMMON;
 
@@ -469,15 +469,15 @@ _gnutls_cpy_write_security_parameters (mhd_gtls_security_param_st *
  * This is to be called after sending the Change Cipher Spec packet.
  */
 int
-mhd_gtls_connection_state_init (mhd_gtls_session_t session)
+MHD_gtls_connection_state_init (MHD_gtls_session_t session)
 {
   int ret;
 
 /* Setup the master secret
  */
-  if ((ret = mhd_gtls_generate_master (session, 0), 0) < 0)
+  if ((ret = MHD_gtls_generate_master (session, 0), 0) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -490,39 +490,39 @@ mhd_gtls_connection_state_init (mhd_gtls_session_t session)
  * (read encrypted data)
  */
 int
-mhd_gtls_read_connection_state_init (mhd_gtls_session_t session)
+MHD_gtls_read_connection_state_init (MHD_gtls_session_t session)
 {
   int mac_size;
   int rc;
 
-  _gnutls_uint64zero (session->connection_state.read_sequence_number);
+  MHD__gnutls_uint64zero (session->connection_state.read_sequence_number);
 
 /* Update internals from CipherSuite selected.
  * If we are resuming just copy the connection session
  */
   if (session->internals.resumed == RESUME_FALSE)
     {
-      rc = mhd_gtls_set_read_cipher (session,
-                                     mhd_gtls_cipher_suite_get_cipher_algo
+      rc = MHD_gtls_set_read_cipher (session,
+                                     MHD_gtls_cipher_suite_get_cipher_algo
                                      (&session->security_parameters.
                                       current_cipher_suite));
       if (rc < 0)
         return rc;
-      rc = mhd_gtls_set_read_mac (session,
-                                  mhd_gtls_cipher_suite_get_mac_algo
+      rc = MHD_gtls_set_read_mac (session,
+                                  MHD_gtls_cipher_suite_get_mac_algo
                                   (&session->security_parameters.
                                    current_cipher_suite));
       if (rc < 0)
         return rc;
 
-      rc = mhd_gtls_set_kx (session,
-                            mhd_gtls_cipher_suite_get_kx_algo
+      rc = MHD_gtls_set_kx (session,
+                            MHD_gtls_cipher_suite_get_kx_algo
                             (&session->security_parameters.
                              current_cipher_suite));
       if (rc < 0)
         return rc;
 
-      rc = mhd_gtls_set_read_compression (session,
+      rc = MHD_gtls_set_read_compression (session,
                                           session->internals.
                                           compression_method);
       if (rc < 0)
@@ -530,54 +530,54 @@ mhd_gtls_read_connection_state_init (mhd_gtls_session_t session)
     }
   else
     {                           /* RESUME_TRUE */
-      _gnutls_cpy_read_security_parameters (&session->security_parameters,
+      MHD__gnutls_cpy_read_security_parameters (&session->security_parameters,
                                             &session->internals.
                                             resumed_security_parameters);
     }
 
 
-  rc = _gnutls_set_read_keys (session);
+  rc = MHD__gnutls_set_read_keys (session);
   if (rc < 0)
     return rc;
 
-  _gnutls_handshake_log ("HSK[%x]: Cipher Suite: %s\n",
+  MHD__gnutls_handshake_log ("HSK[%x]: Cipher Suite: %s\n",
                          session,
-                         mhd_gtls_cipher_suite_get_name
+                         MHD_gtls_cipher_suite_get_name
                          (&session->security_parameters.
                           current_cipher_suite));
 
-  if (mhd_gtls_compression_is_ok
+  if (MHD_gtls_compression_is_ok
       (session->security_parameters.read_compression_algorithm) != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM;
     }
 
-  if (mhd_gnutls_mac_is_ok
+  if (MHD_gnutls_mac_is_ok
       (session->security_parameters.read_mac_algorithm) != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
   /* Free all the previous keys/ sessions etc.
    */
   if (session->connection_state.read_mac_secret.data != NULL)
-    _gnutls_free_datum (&session->connection_state.read_mac_secret);
+    MHD__gnutls_free_datum (&session->connection_state.read_mac_secret);
 
   if (session->connection_state.read_cipher_state != NULL)
-    mhd_gnutls_cipher_deinit (session->connection_state.read_cipher_state);
+    MHD_gnutls_cipher_deinit (session->connection_state.read_cipher_state);
 
   if (session->connection_state.read_compression_state != NULL)
-    mhd_gtls_comp_deinit (session->connection_state.read_compression_state,
+    MHD_gtls_comp_deinit (session->connection_state.read_compression_state,
                           1);
 
 
   mac_size =
-    mhd_gnutls_hash_get_algo_len (session->security_parameters.
+    MHD_gnutls_hash_get_algo_len (session->security_parameters.
                                   read_mac_algorithm);
 
-  _gnutls_handshake_log
+  MHD__gnutls_handshake_log
     ("HSK[%x]: Initializing internal [read] cipher sessions\n", session);
 
   switch (session->security_parameters.entity)
@@ -586,7 +586,7 @@ mhd_gtls_read_connection_state_init (mhd_gtls_session_t session)
       /* initialize cipher session
        */
       session->connection_state.read_cipher_state =
-        mhd_gtls_cipher_init (session->security_parameters.
+        MHD_gtls_cipher_init (session->security_parameters.
                               read_bulk_cipher_algorithm,
                               &session->cipher_specs.client_write_key,
                               &session->cipher_specs.client_write_IV);
@@ -594,7 +594,7 @@ mhd_gtls_read_connection_state_init (mhd_gtls_session_t session)
           && session->security_parameters.read_bulk_cipher_algorithm !=
           MHD_GNUTLS_CIPHER_NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_INTERNAL_ERROR;
         }
 
@@ -603,13 +603,13 @@ mhd_gtls_read_connection_state_init (mhd_gtls_session_t session)
        */
       if (mac_size > 0)
         {
-          if (_gnutls_sset_datum (&session->connection_state.read_mac_secret,
+          if (MHD__gnutls_sset_datum (&session->connection_state.read_mac_secret,
                                   session->cipher_specs.
                                   client_write_mac_secret.data,
                                   session->cipher_specs.
                                   client_write_mac_secret.size) < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return GNUTLS_E_MEMORY_ERROR;
             }
 
@@ -619,7 +619,7 @@ mhd_gtls_read_connection_state_init (mhd_gtls_session_t session)
 #if MHD_DEBUG_TLS
     case GNUTLS_CLIENT:
       session->connection_state.read_cipher_state =
-        mhd_gtls_cipher_init (session->security_parameters.
+        MHD_gtls_cipher_init (session->security_parameters.
                               read_bulk_cipher_algorithm,
                               &session->cipher_specs.server_write_key,
                               &session->cipher_specs.server_write_IV);
@@ -629,7 +629,7 @@ mhd_gtls_read_connection_state_init (mhd_gtls_session_t session)
           && session->security_parameters.read_bulk_cipher_algorithm !=
           MHD_GNUTLS_CIPHER_NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_INTERNAL_ERROR;
         }
 
@@ -638,13 +638,13 @@ mhd_gtls_read_connection_state_init (mhd_gtls_session_t session)
        */
       if (mac_size > 0)
         {
-          if (_gnutls_sset_datum (&session->connection_state.read_mac_secret,
+          if (MHD__gnutls_sset_datum (&session->connection_state.read_mac_secret,
                                   session->cipher_specs.
                                   server_write_mac_secret.data,
                                   session->cipher_specs.
                                   server_write_mac_secret.size) < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return GNUTLS_E_MEMORY_ERROR;
             }
         }
@@ -652,17 +652,17 @@ mhd_gtls_read_connection_state_init (mhd_gtls_session_t session)
       break;
 #endif
     default:                   /* this check is useless */
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
   session->connection_state.read_compression_state =
-    mhd_gtls_comp_init (session->security_parameters.
+    MHD_gtls_comp_init (session->security_parameters.
                         read_compression_algorithm, 1);
 
   if (session->connection_state.read_compression_state == GNUTLS_COMP_FAILED)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM;
     }
 
@@ -675,39 +675,39 @@ mhd_gtls_read_connection_state_init (mhd_gtls_session_t session)
  * (write encrypted data)
  */
 int
-mhd_gtls_write_connection_state_init (mhd_gtls_session_t session)
+MHD_gtls_write_connection_state_init (MHD_gtls_session_t session)
 {
   int mac_size;
   int rc;
 
-  _gnutls_uint64zero (session->connection_state.write_sequence_number);
+  MHD__gnutls_uint64zero (session->connection_state.write_sequence_number);
 
 /* Update internals from CipherSuite selected.
  * If we are resuming just copy the connection session
  */
   if (session->internals.resumed == RESUME_FALSE)
     {
-      rc = mhd_gtls_set_write_cipher (session,
-                                      mhd_gtls_cipher_suite_get_cipher_algo
+      rc = MHD_gtls_set_write_cipher (session,
+                                      MHD_gtls_cipher_suite_get_cipher_algo
                                       (&session->security_parameters.
                                        current_cipher_suite));
       if (rc < 0)
         return rc;
-      rc = mhd_gtls_set_write_mac (session,
-                                   mhd_gtls_cipher_suite_get_mac_algo
+      rc = MHD_gtls_set_write_mac (session,
+                                   MHD_gtls_cipher_suite_get_mac_algo
                                    (&session->security_parameters.
                                     current_cipher_suite));
       if (rc < 0)
         return rc;
 
-      rc = mhd_gtls_set_kx (session,
-                            mhd_gtls_cipher_suite_get_kx_algo
+      rc = MHD_gtls_set_kx (session,
+                            MHD_gtls_cipher_suite_get_kx_algo
                             (&session->security_parameters.
                              current_cipher_suite));
       if (rc < 0)
         return rc;
 
-      rc = mhd_gtls_set_write_compression (session,
+      rc = MHD_gtls_set_write_compression (session,
                                            session->internals.
                                            compression_method);
       if (rc < 0)
@@ -715,31 +715,31 @@ mhd_gtls_write_connection_state_init (mhd_gtls_session_t session)
     }
   else
     {                           /* RESUME_TRUE */
-      _gnutls_cpy_write_security_parameters (&session->security_parameters,
+      MHD__gnutls_cpy_write_security_parameters (&session->security_parameters,
                                              &session->internals.
                                              resumed_security_parameters);
     }
 
-  rc = _gnutls_set_write_keys (session);
+  rc = MHD__gnutls_set_write_keys (session);
   if (rc < 0)
     return rc;
 
-  _gnutls_handshake_log ("HSK[%x]: Cipher Suite: %s\n", session,
-                         mhd_gtls_cipher_suite_get_name
+  MHD__gnutls_handshake_log ("HSK[%x]: Cipher Suite: %s\n", session,
+                         MHD_gtls_cipher_suite_get_name
                          (&session->security_parameters.
                           current_cipher_suite));
 
-  if (mhd_gtls_compression_is_ok
+  if (MHD_gtls_compression_is_ok
       (session->security_parameters.write_compression_algorithm) != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM;
     }
 
-  if (mhd_gnutls_mac_is_ok
+  if (MHD_gnutls_mac_is_ok
       (session->security_parameters.write_mac_algorithm) != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
@@ -748,20 +748,20 @@ mhd_gtls_write_connection_state_init (mhd_gtls_session_t session)
   /* Free all the previous keys/ sessions etc.
    */
   if (session->connection_state.write_mac_secret.data != NULL)
-    _gnutls_free_datum (&session->connection_state.write_mac_secret);
+    MHD__gnutls_free_datum (&session->connection_state.write_mac_secret);
 
   if (session->connection_state.write_cipher_state != NULL)
-    mhd_gnutls_cipher_deinit (session->connection_state.write_cipher_state);
+    MHD_gnutls_cipher_deinit (session->connection_state.write_cipher_state);
 
   if (session->connection_state.write_compression_state != NULL)
-    mhd_gtls_comp_deinit (session->connection_state.write_compression_state,
+    MHD_gtls_comp_deinit (session->connection_state.write_compression_state,
                           0);
 
   mac_size =
-    mhd_gnutls_hash_get_algo_len (session->security_parameters.
+    MHD_gnutls_hash_get_algo_len (session->security_parameters.
                                   write_mac_algorithm);
 
-  _gnutls_handshake_log
+  MHD__gnutls_handshake_log
     ("HSK[%x]: Initializing internal [write] cipher sessions\n", session);
 
   switch (session->security_parameters.entity)
@@ -770,7 +770,7 @@ mhd_gtls_write_connection_state_init (mhd_gtls_session_t session)
       /* initialize cipher session
        */
       session->connection_state.write_cipher_state =
-        mhd_gtls_cipher_init (session->security_parameters.
+        MHD_gtls_cipher_init (session->security_parameters.
                               write_bulk_cipher_algorithm,
                               &session->cipher_specs.server_write_key,
                               &session->cipher_specs.server_write_IV);
@@ -780,7 +780,7 @@ mhd_gtls_write_connection_state_init (mhd_gtls_session_t session)
           && session->security_parameters.write_bulk_cipher_algorithm !=
           MHD_GNUTLS_CIPHER_NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_INTERNAL_ERROR;
         }
 
@@ -790,13 +790,13 @@ mhd_gtls_write_connection_state_init (mhd_gtls_session_t session)
        */
       if (mac_size > 0)
         {
-          if (_gnutls_sset_datum (&session->connection_state.write_mac_secret,
+          if (MHD__gnutls_sset_datum (&session->connection_state.write_mac_secret,
                                   session->cipher_specs.
                                   server_write_mac_secret.data,
                                   session->cipher_specs.
                                   server_write_mac_secret.size) < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return GNUTLS_E_MEMORY_ERROR;
             }
 
@@ -807,7 +807,7 @@ mhd_gtls_write_connection_state_init (mhd_gtls_session_t session)
 #if MHD_DEBUG_TLS
     case GNUTLS_CLIENT:
       session->connection_state.write_cipher_state =
-        mhd_gtls_cipher_init (session->security_parameters.
+        MHD_gtls_cipher_init (session->security_parameters.
                               write_bulk_cipher_algorithm,
                               &session->cipher_specs.client_write_key,
                               &session->cipher_specs.client_write_IV);
@@ -817,7 +817,7 @@ mhd_gtls_write_connection_state_init (mhd_gtls_session_t session)
           && session->security_parameters.write_bulk_cipher_algorithm !=
           MHD_GNUTLS_CIPHER_NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_INTERNAL_ERROR;
         }
 
@@ -825,13 +825,13 @@ mhd_gtls_write_connection_state_init (mhd_gtls_session_t session)
        */
       if (mac_size > 0)
         {
-          if (_gnutls_sset_datum (&session->connection_state.write_mac_secret,
+          if (MHD__gnutls_sset_datum (&session->connection_state.write_mac_secret,
                                   session->cipher_specs.
                                   client_write_mac_secret.data,
                                   session->cipher_specs.
                                   client_write_mac_secret.size) < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return GNUTLS_E_MEMORY_ERROR;
             }
         }
@@ -839,18 +839,18 @@ mhd_gtls_write_connection_state_init (mhd_gtls_session_t session)
       break;
 #endif
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
 
   session->connection_state.write_compression_state =
-    mhd_gtls_comp_init (session->security_parameters.
+    MHD_gtls_comp_init (session->security_parameters.
                         write_compression_algorithm, 0);
 
   if (session->connection_state.write_compression_state == GNUTLS_COMP_FAILED)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM;
     }
 
@@ -860,15 +860,15 @@ mhd_gtls_write_connection_state_init (mhd_gtls_session_t session)
 /* Sets the specified cipher into the pending session
  */
 int
-mhd_gtls_set_read_cipher (mhd_gtls_session_t session,
+MHD_gtls_set_read_cipher (MHD_gtls_session_t session,
                           enum MHD_GNUTLS_CipherAlgorithm algo)
 {
 
-  if (mhd_gtls_cipher_is_ok (algo) == 0)
+  if (MHD_gtls_cipher_is_ok (algo) == 0)
     {
-      if (mhd_gtls_cipher_priority (session, algo) < 0)
+      if (MHD_gtls_cipher_priority (session, algo) < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_UNWANTED_ALGORITHM;
         }
 
@@ -877,7 +877,7 @@ mhd_gtls_set_read_cipher (mhd_gtls_session_t session,
     }
   else
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
@@ -886,15 +886,15 @@ mhd_gtls_set_read_cipher (mhd_gtls_session_t session,
 }
 
 int
-mhd_gtls_set_write_cipher (mhd_gtls_session_t session,
+MHD_gtls_set_write_cipher (MHD_gtls_session_t session,
                            enum MHD_GNUTLS_CipherAlgorithm algo)
 {
 
-  if (mhd_gtls_cipher_is_ok (algo) == 0)
+  if (MHD_gtls_cipher_is_ok (algo) == 0)
     {
-      if (mhd_gtls_cipher_priority (session, algo) < 0)
+      if (MHD_gtls_cipher_priority (session, algo) < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_UNWANTED_ALGORITHM;
         }
 
@@ -903,7 +903,7 @@ mhd_gtls_set_write_cipher (mhd_gtls_session_t session,
     }
   else
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
@@ -915,17 +915,17 @@ mhd_gtls_set_write_cipher (mhd_gtls_session_t session,
 /* Sets the specified algorithm into pending compression session
  */
 int
-mhd_gtls_set_read_compression (mhd_gtls_session_t session,
+MHD_gtls_set_read_compression (MHD_gtls_session_t session,
                                enum MHD_GNUTLS_CompressionMethod algo)
 {
 
-  if (mhd_gtls_compression_is_ok (algo) == 0)
+  if (MHD_gtls_compression_is_ok (algo) == 0)
     {
       session->security_parameters.read_compression_algorithm = algo;
     }
   else
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM;
     }
   return 0;
@@ -933,17 +933,17 @@ mhd_gtls_set_read_compression (mhd_gtls_session_t session,
 }
 
 int
-mhd_gtls_set_write_compression (mhd_gtls_session_t session,
+MHD_gtls_set_write_compression (MHD_gtls_session_t session,
                                 enum MHD_GNUTLS_CompressionMethod algo)
 {
 
-  if (mhd_gtls_compression_is_ok (algo) == 0)
+  if (MHD_gtls_compression_is_ok (algo) == 0)
     {
       session->security_parameters.write_compression_algorithm = algo;
     }
   else
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM;
     }
   return 0;
@@ -953,22 +953,22 @@ mhd_gtls_set_write_compression (mhd_gtls_session_t session,
 /* Sets the specified kx algorithm into pending session
  */
 int
-mhd_gtls_set_kx (mhd_gtls_session_t session,
+MHD_gtls_set_kx (MHD_gtls_session_t session,
                  enum MHD_GNUTLS_KeyExchangeAlgorithm algo)
 {
 
-  if (mhd_gtls_kx_is_ok (algo) == 0)
+  if (MHD_gtls_kx_is_ok (algo) == 0)
     {
       session->security_parameters.kx_algorithm = algo;
     }
   else
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
-  if (mhd_gtls_kx_priority (session, algo) < 0)
+  if (MHD_gtls_kx_priority (session, algo) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       /* we shouldn't get here */
       return GNUTLS_E_UNWANTED_ALGORITHM;
     }
@@ -979,22 +979,22 @@ mhd_gtls_set_kx (mhd_gtls_session_t session,
 
 /* Sets the specified mac algorithm into pending session */
 int
-mhd_gtls_set_read_mac (mhd_gtls_session_t session,
+MHD_gtls_set_read_mac (MHD_gtls_session_t session,
                        enum MHD_GNUTLS_HashAlgorithm algo)
 {
 
-  if (mhd_gnutls_mac_is_ok (algo) == 0)
+  if (MHD_gnutls_mac_is_ok (algo) == 0)
     {
       session->security_parameters.read_mac_algorithm = algo;
     }
   else
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
-  if (mhd_gtls_mac_priority (session, algo) < 0)
+  if (MHD_gtls_mac_priority (session, algo) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNWANTED_ALGORITHM;
     }
 
@@ -1004,22 +1004,22 @@ mhd_gtls_set_read_mac (mhd_gtls_session_t session,
 }
 
 int
-mhd_gtls_set_write_mac (mhd_gtls_session_t session,
+MHD_gtls_set_write_mac (MHD_gtls_session_t session,
                         enum MHD_GNUTLS_HashAlgorithm algo)
 {
 
-  if (mhd_gnutls_mac_is_ok (algo) == 0)
+  if (MHD_gnutls_mac_is_ok (algo) == 0)
     {
       session->security_parameters.write_mac_algorithm = algo;
     }
   else
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
-  if (mhd_gtls_mac_priority (session, algo) < 0)
+  if (MHD_gtls_mac_priority (session, algo) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNWANTED_ALGORITHM;
     }
 
diff --git a/src/daemon/https/tls/gnutls_constate.h b/src/daemon/https/tls/gnutls_constate.h
index 184e7873..59b67249 100644
--- a/src/daemon/https/tls/gnutls_constate.h
+++ b/src/daemon/https/tls/gnutls_constate.h
@@ -22,20 +22,20 @@
  *
  */
 
-int mhd_gtls_connection_state_init (mhd_gtls_session_t session);
-int mhd_gtls_read_connection_state_init (mhd_gtls_session_t session);
-int mhd_gtls_write_connection_state_init (mhd_gtls_session_t session);
-int mhd_gtls_set_write_cipher (mhd_gtls_session_t session,
+int MHD_gtls_connection_state_init (MHD_gtls_session_t session);
+int MHD_gtls_read_connection_state_init (MHD_gtls_session_t session);
+int MHD_gtls_write_connection_state_init (MHD_gtls_session_t session);
+int MHD_gtls_set_write_cipher (MHD_gtls_session_t session,
                                enum MHD_GNUTLS_CipherAlgorithm algo);
-int mhd_gtls_set_write_mac (mhd_gtls_session_t session,
+int MHD_gtls_set_write_mac (MHD_gtls_session_t session,
                             enum MHD_GNUTLS_HashAlgorithm algo);
-int mhd_gtls_set_read_cipher (mhd_gtls_session_t session,
+int MHD_gtls_set_read_cipher (MHD_gtls_session_t session,
                               enum MHD_GNUTLS_CipherAlgorithm algo);
-int mhd_gtls_set_read_mac (mhd_gtls_session_t session,
+int MHD_gtls_set_read_mac (MHD_gtls_session_t session,
                            enum MHD_GNUTLS_HashAlgorithm algo);
-int mhd_gtls_set_read_compression (mhd_gtls_session_t session,
+int MHD_gtls_set_read_compression (MHD_gtls_session_t session,
                                    enum MHD_GNUTLS_CompressionMethod algo);
-int mhd_gtls_set_write_compression (mhd_gtls_session_t session,
+int MHD_gtls_set_write_compression (MHD_gtls_session_t session,
                                     enum MHD_GNUTLS_CompressionMethod algo);
-int mhd_gtls_set_kx (mhd_gtls_session_t session,
+int MHD_gtls_set_kx (MHD_gtls_session_t session,
                      enum MHD_GNUTLS_KeyExchangeAlgorithm algo);
diff --git a/src/daemon/https/tls/gnutls_datum.c b/src/daemon/https/tls/gnutls_datum.c
index d437ee2c..e9a660a4 100644
--- a/src/daemon/https/tls/gnutls_datum.c
+++ b/src/daemon/https/tls/gnutls_datum.c
@@ -34,31 +34,31 @@
 
 
 void
-mhd_gtls_write_datum16 (opaque * dest, gnutls_datum_t dat)
+MHD_gtls_write_datum16 (opaque * dest, MHD_gnutls_datum_t dat)
 {
-  mhd_gtls_write_uint16 (dat.size, dest);
+  MHD_gtls_write_uint16 (dat.size, dest);
   if (dat.data != NULL)
     memcpy (&dest[2], dat.data, dat.size);
 }
 
 void
-mhd_gtls_write_datum24 (opaque * dest, gnutls_datum_t dat)
+MHD_gtls_write_datum24 (opaque * dest, MHD_gnutls_datum_t dat)
 {
-  mhd_gtls_write_uint24 (dat.size, dest);
+  MHD_gtls_write_uint24 (dat.size, dest);
   if (dat.data != NULL)
     memcpy (&dest[3], dat.data, dat.size);
 }
 
 void
-mhd_gtls_write_datum32 (opaque * dest, gnutls_datum_t dat)
+MHD_gtls_write_datum32 (opaque * dest, MHD_gnutls_datum_t dat)
 {
-  mhd_gtls_write_uint32 (dat.size, dest);
+  MHD_gtls_write_uint32 (dat.size, dest);
   if (dat.data != NULL)
     memcpy (&dest[4], dat.data, dat.size);
 }
 
 void
-mhd_gtls_write_datum8 (opaque * dest, gnutls_datum_t dat)
+MHD_gtls_write_datum8 (opaque * dest, MHD_gnutls_datum_t dat)
 {
   dest[0] = (uint8_t) dat.size;
   if (dat.data != NULL)
@@ -67,8 +67,8 @@ mhd_gtls_write_datum8 (opaque * dest, gnutls_datum_t dat)
 
 
 int
-mhd_gtls_set_datum_m (gnutls_datum_t * dat, const void *data,
-                      size_t data_size, gnutls_alloc_function galloc_func)
+MHD_gtls_set_datum_m (MHD_gnutls_datum_t * dat, const void *data,
+                      size_t data_size, MHD_gnutls_alloc_function galloc_func)
 {
   if (data_size == 0 || data == NULL)
     {
@@ -88,9 +88,9 @@ mhd_gtls_set_datum_m (gnutls_datum_t * dat, const void *data,
 }
 
 int
-mhd_gtls_datum_append_m (gnutls_datum_t * dst, const void *data,
+MHD_gtls_datum_append_m (MHD_gnutls_datum_t * dst, const void *data,
                          size_t data_size,
-                         gnutls_realloc_function grealloc_func)
+                         MHD_gnutls_realloc_function grealloc_func)
 {
 
   dst->data = grealloc_func (dst->data, data_size + dst->size);
@@ -104,7 +104,7 @@ mhd_gtls_datum_append_m (gnutls_datum_t * dst, const void *data,
 }
 
 void
-mhd_gtls_free_datum_m (gnutls_datum_t * dat, gnutls_free_function gfree_func)
+MHD_gtls_free_datum_m (MHD_gnutls_datum_t * dat, MHD_gnutls_free_function gfree_func)
 {
   if (dat->data != NULL)
     gfree_func (dat->data);
diff --git a/src/daemon/https/tls/gnutls_datum.h b/src/daemon/https/tls/gnutls_datum.h
index f54e300b..634d527e 100644
--- a/src/daemon/https/tls/gnutls_datum.h
+++ b/src/daemon/https/tls/gnutls_datum.h
@@ -22,19 +22,19 @@
  *
  */
 
-void mhd_gtls_write_datum16 (opaque * dest, gnutls_datum_t dat);
-void mhd_gtls_write_datum24 (opaque * dest, gnutls_datum_t dat);
-void mhd_gtls_write_datum32 (opaque * dest, gnutls_datum_t dat);
-void mhd_gtls_write_datum8 (opaque * dest, gnutls_datum_t dat);
+void MHD_gtls_write_datum16 (opaque * dest, MHD_gnutls_datum_t dat);
+void MHD_gtls_write_datum24 (opaque * dest, MHD_gnutls_datum_t dat);
+void MHD_gtls_write_datum32 (opaque * dest, MHD_gnutls_datum_t dat);
+void MHD_gtls_write_datum8 (opaque * dest, MHD_gnutls_datum_t dat);
 
-int mhd_gtls_set_datum_m (gnutls_datum_t * dat, const void *data,
-                          size_t data_size, gnutls_alloc_function);
-#define _gnutls_set_datum( x, y, z) mhd_gtls_set_datum_m(x,y,z, gnutls_malloc)
-#define _gnutls_sset_datum( x, y, z) mhd_gtls_set_datum_m(x,y,z, gnutls_secure_malloc)
+int MHD_gtls_set_datum_m (MHD_gnutls_datum_t * dat, const void *data,
+                          size_t data_size, MHD_gnutls_alloc_function);
+#define MHD__gnutls_set_datum( x, y, z) MHD_gtls_set_datum_m(x,y,z, MHD_gnutls_malloc)
+#define MHD__gnutls_sset_datum( x, y, z) MHD_gtls_set_datum_m(x,y,z, MHD_gnutls_secure_malloc)
 
-int mhd_gtls_datum_append_m (gnutls_datum_t * dat, const void *data,
-                             size_t data_size, gnutls_realloc_function);
-#define _gnutls_datum_append(x,y,z) mhd_gtls_datum_append_m(x,y,z, gnutls_realloc)
+int MHD_gtls_datum_append_m (MHD_gnutls_datum_t * dat, const void *data,
+                             size_t data_size, MHD_gnutls_realloc_function);
+#define MHD__gnutls_datum_append(x,y,z) MHD_gtls_datum_append_m(x,y,z, MHD_gnutls_realloc)
 
-void mhd_gtls_free_datum_m (gnutls_datum_t * dat, gnutls_free_function);
-#define _gnutls_free_datum(x) mhd_gtls_free_datum_m(x, gnutls_free)
+void MHD_gtls_free_datum_m (MHD_gnutls_datum_t * dat, MHD_gnutls_free_function);
+#define MHD__gnutls_free_datum(x) MHD_gtls_free_datum_m(x, MHD_gnutls_free)
diff --git a/src/daemon/https/tls/gnutls_dh.c b/src/daemon/https/tls/gnutls_dh.c
index 8cd5175d..d9dd4344 100644
--- a/src/daemon/https/tls/gnutls_dh.c
+++ b/src/daemon/https/tls/gnutls_dh.c
@@ -35,11 +35,11 @@
         his_key  = X ^ y mod p;
 
 //      generate our secret and the public value (X) for it
-        X = mhd_gtls_calc_dh_secret(&x, g, p);
+        X = MHD_gtls_calc_dh_secret(&x, g, p);
 //      now we can calculate the shared secret
-        key = mhd_gtls_calc_dh_key(Y, x, g, p);
-        mhd_gtls_mpi_release(x);
-        mhd_gtls_mpi_release(g);
+        key = MHD_gtls_calc_dh_key(Y, x, g, p);
+        MHD_gtls_mpi_release(x);
+        MHD_gtls_mpi_release(g);
 */
 
 #define MAX_BITS 18000
@@ -47,24 +47,24 @@
 /* returns the public value (X), and the secret (ret_x).
  */
 mpi_t
-mhd_gtls_calc_dh_secret (mpi_t * ret_x, mpi_t g, mpi_t prime)
+MHD_gtls_calc_dh_secret (mpi_t * ret_x, mpi_t g, mpi_t prime)
 {
   mpi_t e, x;
-  int x_size = _gnutls_mpi_get_nbits (prime) - 1;
+  int x_size = MHD__gnutls_mpi_get_nbits (prime) - 1;
   /* The size of the secret key is less than
    * prime/2
    */
 
   if (x_size > MAX_BITS || x_size <= 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return NULL;
     }
 
-  x = _gnutls_mpi_new (x_size);
+  x = MHD__gnutls_mpi_new (x_size);
   if (x == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       if (ret_x)
         *ret_x = NULL;
 
@@ -76,55 +76,55 @@ mhd_gtls_calc_dh_secret (mpi_t * ret_x, mpi_t g, mpi_t prime)
    */
   do
     {
-      _gnutls_mpi_randomize (x, (x_size / 8) * 8, GCRY_STRONG_RANDOM);
+      MHD__gnutls_mpi_randomize (x, (x_size / 8) * 8, GCRY_STRONG_RANDOM);
       /* Check whether x is zero.
        */
     }
-  while (_gnutls_mpi_cmp_ui (x, 0) == 0);
+  while (MHD__gnutls_mpi_cmp_ui (x, 0) == 0);
 
-  e = _gnutls_mpi_alloc_like (prime);
+  e = MHD__gnutls_mpi_alloc_like (prime);
   if (e == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       if (ret_x)
         *ret_x = NULL;
 
-      mhd_gtls_mpi_release (&x);
+      MHD_gtls_mpi_release (&x);
       return NULL;
     }
 
-  _gnutls_mpi_powm (e, g, x, prime);
+  MHD__gnutls_mpi_powm (e, g, x, prime);
 
   if (ret_x)
     *ret_x = x;
   else
-    mhd_gtls_mpi_release (&x);
+    MHD_gtls_mpi_release (&x);
   return e;
 }
 
 
 mpi_t
-mhd_gtls_calc_dh_key (mpi_t f, mpi_t x, mpi_t prime)
+MHD_gtls_calc_dh_key (mpi_t f, mpi_t x, mpi_t prime)
 {
   mpi_t k;
   int bits;
 
-  bits = _gnutls_mpi_get_nbits (prime);
+  bits = MHD__gnutls_mpi_get_nbits (prime);
   if (bits <= 0 || bits > MAX_BITS)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return NULL;
     }
 
-  k = _gnutls_mpi_alloc_like (prime);
+  k = MHD__gnutls_mpi_alloc_like (prime);
   if (k == NULL)
     return NULL;
-  _gnutls_mpi_powm (k, f, x, prime);
+  MHD__gnutls_mpi_powm (k, f, x, prime);
   return k;
 }
 
 /*-
-  * mhd_gtls_get_dh_params - Returns the DH parameters pointer
+  * MHD_gtls_get_dh_params - Returns the DH parameters pointer
   * @dh_params: is an DH parameters structure, or NULL.
   * @func: is a callback function to receive the parameters or NULL.
   * @session: a gnutls session.
@@ -132,12 +132,12 @@ mhd_gtls_calc_dh_key (mpi_t f, mpi_t x, mpi_t prime)
   * This function will return the dh parameters pointer.
   *
   -*/
-mhd_gtls_dh_params_t
-mhd_gtls_get_dh_params (mhd_gtls_dh_params_t dh_params,
-                        gnutls_params_function * func,
-                        mhd_gtls_session_t session)
+MHD_gtls_dh_params_t
+MHD_gtls_get_dh_params (MHD_gtls_dh_params_t dh_params,
+                        MHD_gnutls_params_function * func,
+                        MHD_gtls_session_t session)
 {
-  gnutls_params_st params;
+  MHD_gnutls_params_st params;
   int ret;
 
   /* if cached return the cached */
diff --git a/src/daemon/https/tls/gnutls_dh.h b/src/daemon/https/tls/gnutls_dh.h
index 6dec6e64..5d7341fc 100644
--- a/src/daemon/https/tls/gnutls_dh.h
+++ b/src/daemon/https/tls/gnutls_dh.h
@@ -25,14 +25,14 @@
 #ifndef GNUTLS_DH_H
 # define GNUTLS_DH_H
 
-const mpi_t *mhd_gtls_dh_params_to_mpi (mhd_gtls_dh_params_t);
-mpi_t mhd_gtls_calc_dh_secret (mpi_t * ret_x, mpi_t g, mpi_t prime);
-mpi_t mhd_gtls_calc_dh_key (mpi_t f, mpi_t x, mpi_t prime);
-int mhd_gtls_dh_generate_prime (mpi_t * ret_g, mpi_t * ret_n, unsigned bits);
+const mpi_t *MHD_gtls_dh_params_to_mpi (MHD_gtls_dh_params_t);
+mpi_t MHD_gtls_calc_dh_secret (mpi_t * ret_x, mpi_t g, mpi_t prime);
+mpi_t MHD_gtls_calc_dh_key (mpi_t f, mpi_t x, mpi_t prime);
+int MHD_gtls_dh_generate_prime (mpi_t * ret_g, mpi_t * ret_n, unsigned bits);
 
-mhd_gtls_dh_params_t
-mhd_gtls_get_dh_params (mhd_gtls_dh_params_t dh_params,
-                        gnutls_params_function * func,
-                        mhd_gtls_session_t session);
+MHD_gtls_dh_params_t
+MHD_gtls_get_dh_params (MHD_gtls_dh_params_t dh_params,
+                        MHD_gnutls_params_function * func,
+                        MHD_gtls_session_t session);
 
 #endif
diff --git a/src/daemon/https/tls/gnutls_dh_primes.c b/src/daemon/https/tls/gnutls_dh_primes.c
index acd08a75..83776c42 100644
--- a/src/daemon/https/tls/gnutls_dh_primes.c
+++ b/src/daemon/https/tls/gnutls_dh_primes.c
@@ -36,7 +36,7 @@
 /* returns the prime and the generator of DH params.
  */
 const mpi_t *
-mhd_gtls_dh_params_to_mpi (mhd_gtls_dh_params_t dh_primes)
+MHD_gtls_dh_params_to_mpi (MHD_gtls_dh_params_t dh_primes)
 {
   if (dh_primes == NULL || dh_primes->params[1] == NULL
       || dh_primes->params[0] == NULL)
@@ -48,7 +48,7 @@ mhd_gtls_dh_params_to_mpi (mhd_gtls_dh_params_t dh_primes)
 }
 
 int
-mhd_gtls_dh_generate_prime (mpi_t * ret_g, mpi_t * ret_n, unsigned int bits)
+MHD_gtls_dh_generate_prime (mpi_t * ret_g, mpi_t * ret_n, unsigned int bits)
 {
   mpi_t g = NULL, prime = NULL;
   gcry_error_t err;
@@ -75,7 +75,7 @@ mhd_gtls_dh_generate_prime (mpi_t * ret_g, mpi_t * ret_n, unsigned int bits)
 
       if (times)
         {
-          mhd_gtls_mpi_release (&prime);
+          MHD_gtls_mpi_release (&prime);
           gcry_prime_release_factors (factors);
         }
 
@@ -85,7 +85,7 @@ mhd_gtls_dh_generate_prime (mpi_t * ret_g, mpi_t * ret_n, unsigned int bits)
 
       if (err != 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           result = GNUTLS_E_INTERNAL_ERROR;
           goto cleanup;
         }
@@ -98,7 +98,7 @@ mhd_gtls_dh_generate_prime (mpi_t * ret_g, mpi_t * ret_n, unsigned int bits)
 
   if (err != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_INTERNAL_ERROR;
       goto cleanup;
     }
@@ -108,7 +108,7 @@ mhd_gtls_dh_generate_prime (mpi_t * ret_g, mpi_t * ret_n, unsigned int bits)
   err = gcry_prime_group_generator (&g, prime, factors, NULL);
   if (err != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_INTERNAL_ERROR;
       goto cleanup;
     }
@@ -119,17 +119,17 @@ mhd_gtls_dh_generate_prime (mpi_t * ret_g, mpi_t * ret_n, unsigned int bits)
   if (ret_g)
     *ret_g = g;
   else
-    mhd_gtls_mpi_release (&g);
+    MHD_gtls_mpi_release (&g);
   if (ret_n)
     *ret_n = prime;
   else
-    mhd_gtls_mpi_release (&prime);
+    MHD_gtls_mpi_release (&prime);
 
   return 0;
 
 cleanup:gcry_prime_release_factors (factors);
-  mhd_gtls_mpi_release (&g);
-  mhd_gtls_mpi_release (&prime);
+  MHD_gtls_mpi_release (&g);
+  MHD_gtls_mpi_release (&prime);
 
   return result;
 
@@ -139,20 +139,20 @@ cleanup:gcry_prime_release_factors (factors);
  * generated one.
  */
 /**
- * MHD_gnutls_dh_params_init - This function will initialize the DH parameters
+ * MHD__gnutls_dh_params_init - This function will initialize the DH parameters
  * @dh_params: Is a structure that will hold the prime numbers
  *
  * This function will initialize the DH parameters structure.
  *
  **/
 int
-MHD_gnutls_dh_params_init (mhd_gtls_dh_params_t * dh_params)
+MHD__gnutls_dh_params_init (MHD_gtls_dh_params_t * dh_params)
 {
 
-  (*dh_params) = gnutls_calloc (1, sizeof (mhd_gtls_dh_params_st));
+  (*dh_params) = MHD_gnutls_calloc (1, sizeof (MHD_gtls_dh_params_st));
   if (*dh_params == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
@@ -161,33 +161,33 @@ MHD_gnutls_dh_params_init (mhd_gtls_dh_params_t * dh_params)
 }
 
 /**
- * MHD_gnutls_dh_params_deinit - This function will deinitialize the DH parameters
+ * MHD__gnutls_dh_params_deinit - This function will deinitialize the DH parameters
  * @dh_params: Is a structure that holds the prime numbers
  *
  * This function will deinitialize the DH parameters structure.
  *
  **/
 void
-MHD_gnutls_dh_params_deinit (mhd_gtls_dh_params_t dh_params)
+MHD__gnutls_dh_params_deinit (MHD_gtls_dh_params_t dh_params)
 {
   if (dh_params == NULL)
     return;
 
-  mhd_gtls_mpi_release (&dh_params->params[0]);
-  mhd_gtls_mpi_release (&dh_params->params[1]);
+  MHD_gtls_mpi_release (&dh_params->params[0]);
+  MHD_gtls_mpi_release (&dh_params->params[1]);
 
-  gnutls_free (dh_params);
+  MHD_gnutls_free (dh_params);
 
 }
 
 /**
- * MHD_gnutls_dh_params_generate2 - This function will generate new DH parameters
+ * MHD__gnutls_dh_params_generate2 - This function will generate new DH parameters
  * @params: Is the structure that the DH parameters will be stored
  * @bits: is the prime's number of bits
  *
  * This function will generate a new pair of prime and generator for use in
  * the Diffie-Hellman key exchange. The new parameters will be allocated using
- * gnutls_malloc() and will be stored in the appropriate datum.
+ * MHD_gnutls_malloc() and will be stored in the appropriate datum.
  * This function is normally slow.
  *
  * Note that the bits value should be one of 768, 1024, 2048, 3072 or 4096.
@@ -197,16 +197,16 @@ MHD_gnutls_dh_params_deinit (mhd_gtls_dh_params_t dh_params)
  *
  **/
 int
-MHD_gnutls_dh_params_generate2 (mhd_gtls_dh_params_t params,
+MHD__gnutls_dh_params_generate2 (MHD_gtls_dh_params_t params,
                                 unsigned int bits)
 {
   int ret;
 
   ret =
-    mhd_gtls_dh_generate_prime (&params->params[1], &params->params[0], bits);
+    MHD_gtls_dh_generate_prime (&params->params[1], &params->params[0], bits);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
diff --git a/src/daemon/https/tls/gnutls_errors.c b/src/daemon/https/tls/gnutls_errors.c
index c0e42872..51fdb707 100644
--- a/src/daemon/https/tls/gnutls_errors.c
+++ b/src/daemon/https/tls/gnutls_errors.c
@@ -33,21 +33,21 @@
 #define _(String) (String)
 #define N_(String) (String)
 
-extern LOG_FUNC _gnutls_log_func;
+extern LOG_FUNC MHD__gnutls_log_func;
 
 #define ERROR_ENTRY(desc, name, fatal) \
         { desc, #name, name, fatal}
 
-struct gnutls_error_entry
+struct MHD_gnutls_error_entry
 {
   const char *desc;
   const char *_name;
   int number;
   int fatal;
 };
-typedef struct gnutls_error_entry gnutls_error_entry;
+typedef struct MHD_gnutls_error_entry MHD_gnutls_error_entry;
 
-static const gnutls_error_entry mhd_gtls_error_algorithms[] = {
+static const MHD_gnutls_error_entry MHD_gtls_error_algorithms[] = {
   /* "Short Description", Error code define, critical (0,1) -- 1 in most cases */
   ERROR_ENTRY (N_("Success."), GNUTLS_E_SUCCESS, 0),
   ERROR_ENTRY (N_("Could not negotiate a supported cipher suite."),
@@ -246,8 +246,8 @@ static const gnutls_error_entry mhd_gtls_error_algorithms[] = {
 };
 
 #define GNUTLS_ERROR_LOOP(b) \
-        const gnutls_error_entry *p; \
-                for(p = mhd_gtls_error_algorithms; p->desc != NULL; p++) { b ; }
+        const MHD_gnutls_error_entry *p; \
+                for(p = MHD_gtls_error_algorithms; p->desc != NULL; p++) { b ; }
 
 #define GNUTLS_ERROR_ALG_LOOP(a) \
                         GNUTLS_ERROR_LOOP( if(p->number == error) { a; break; } )
@@ -329,7 +329,7 @@ MHD_gtls_strerror (int error)
  * given error code.
  */
 const char *
-_gnutls_strerror (int error)
+MHD__gnutls_strerror (int error)
 {
   const char *ret = NULL;
 
@@ -340,7 +340,7 @@ _gnutls_strerror (int error)
 }
 
 int
-mhd_gtls_asn2err (int asn_err)
+MHD_gtls_asn2err (int asn_err)
 {
   switch (asn_err)
     {
@@ -382,13 +382,13 @@ mhd_gtls_asn2err (int asn_err)
  * caller provided function
  */
 void
-mhd_gtls_log (int level, const char *fmt, ...)
+MHD_gtls_log (int level, const char *fmt, ...)
 {
   va_list args;
   char str[MAX_LOG_SIZE];
-  void (*log_func) (int, const char *) = _gnutls_log_func;
+  void (*log_func) (int, const char *) = MHD__gnutls_log_func;
 
-  if (_gnutls_log_func == NULL)
+  if (MHD__gnutls_log_func == NULL)
     return;
 
   va_start (args, fmt);
@@ -405,7 +405,7 @@ mhd_gtls_log (int level, const char *fmt, ...)
  * be called. This may affect performance.
  */
 void
-_gnutls_null_log (void *x, ...)
+MHD__gnutls_null_log (void *x, ...)
 {
   return;
 }
diff --git a/src/daemon/https/tls/gnutls_errors.h b/src/daemon/https/tls/gnutls_errors.h
index fcfc4c63..edc89817 100644
--- a/src/daemon/https/tls/gnutls_errors.h
+++ b/src/daemon/https/tls/gnutls_errors.h
@@ -28,46 +28,46 @@
 
 #ifdef __FILE__
 # ifdef __LINE__
-#  define gnutls_assert() _gnutls_debug_log( "ASSERT: %s:%d\n", __FILE__,__LINE__);
+#  define MHD_gnutls_assert() MHD__gnutls_debug_log( "ASSERT: %s:%d\n", __FILE__,__LINE__);
 # else
-#  define gnutls_assert()
+#  define MHD_gnutls_assert()
 # endif
 #else /* __FILE__ not defined */
-# define gnutls_assert()
+# define MHD_gnutls_assert()
 #endif
 
-int mhd_gtls_asn2err (int asn_err);
-void mhd_gtls_log (int, const char *fmt, ...);
+int MHD_gtls_asn2err (int asn_err);
+void MHD_gtls_log (int, const char *fmt, ...);
 
-extern int _gnutls_log_level;
+extern int MHD__gnutls_log_level;
 
 #ifdef C99_MACROS
-#define LEVEL(l, ...) if (_gnutls_log_level >= l || _gnutls_log_level > 9) \
-        mhd_gtls_log( l, __VA_ARGS__)
+#define LEVEL(l, ...) if (MHD__gnutls_log_level >= l || MHD__gnutls_log_level > 9) \
+        MHD_gtls_log( l, __VA_ARGS__)
 
-#define LEVEL_EQ(l, ...) if (_gnutls_log_level == l || _gnutls_log_level > 9) \
-        mhd_gtls_log( l, __VA_ARGS__)
+#define LEVEL_EQ(l, ...) if (MHD__gnutls_log_level == l || MHD__gnutls_log_level > 9) \
+        MHD_gtls_log( l, __VA_ARGS__)
 
-# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__)
-# define _gnutls_handshake_log(...) LEVEL(3, __VA_ARGS__)
-# define _gnutls_io_log(...) LEVEL_EQ(5, __VA_ARGS__)
-# define _gnutls_buffers_log(...) LEVEL_EQ(6, __VA_ARGS__)
-# define _gnutls_hard_log(...) LEVEL(9, __VA_ARGS__)
-# define _gnutls_record_log(...) LEVEL(4, __VA_ARGS__)
-# define _gnutls_read_log(...) LEVEL_EQ(7, __VA_ARGS__)
-# define _gnutls_write_log(...) LEVEL_EQ(7, __VA_ARGS__)
-# define _gnutls_x509_log(...) LEVEL(1, __VA_ARGS__)
+# define MHD__gnutls_debug_log(...) LEVEL(2, __VA_ARGS__)
+# define MHD__gnutls_handshake_log(...) LEVEL(3, __VA_ARGS__)
+# define MHD__gnutls_io_log(...) LEVEL_EQ(5, __VA_ARGS__)
+# define MHD__gnutls_buffers_log(...) LEVEL_EQ(6, __VA_ARGS__)
+# define MHD__gnutls_hard_log(...) LEVEL(9, __VA_ARGS__)
+# define MHD__gnutls_record_log(...) LEVEL(4, __VA_ARGS__)
+# define MHD__gnutls_read_log(...) LEVEL_EQ(7, __VA_ARGS__)
+# define MHD__gnutls_write_log(...) LEVEL_EQ(7, __VA_ARGS__)
+# define MHD__gnutls_x509_log(...) LEVEL(1, __VA_ARGS__)
 #else
-# define _gnutls_debug_log _gnutls_null_log
-# define _gnutls_handshake_log _gnutls_null_log
-# define _gnutls_io_log _gnutls_null_log
-# define _gnutls_buffers_log _gnutls_null_log
-# define _gnutls_hard_log _gnutls_null_log
-# define _gnutls_record_log _gnutls_null_log
-# define _gnutls_read_log _gnutls_null_log
-# define _gnutls_write_log _gnutls_null_log
-# define _gnutls_x509_log _gnutls_null_log
+# define MHD__gnutls_debug_log MHD__gnutls_null_log
+# define MHD__gnutls_handshake_log MHD__gnutls_null_log
+# define MHD__gnutls_io_log MHD__gnutls_null_log
+# define MHD__gnutls_buffers_log MHD__gnutls_null_log
+# define MHD__gnutls_hard_log MHD__gnutls_null_log
+# define MHD__gnutls_record_log MHD__gnutls_null_log
+# define MHD__gnutls_read_log MHD__gnutls_null_log
+# define MHD__gnutls_write_log MHD__gnutls_null_log
+# define MHD__gnutls_x509_log MHD__gnutls_null_log
 
-void _gnutls_null_log (void *, ...);
+void MHD__gnutls_null_log (void *, ...);
 
 #endif /* C99_MACROS */
diff --git a/src/daemon/https/tls/gnutls_extensions.c b/src/daemon/https/tls/gnutls_extensions.c
index 4c9286d8..1f9cf7d0 100644
--- a/src/daemon/https/tls/gnutls_extensions.c
+++ b/src/daemon/https/tls/gnutls_extensions.c
@@ -43,39 +43,39 @@
 
 
 #define MAX_EXT_SIZE 10
-const int mhd_gtls_extensions_size = MAX_EXT_SIZE;
+const int MHD_gtls_extensions_size = MAX_EXT_SIZE;
 
-mhd_gtls_extension_entry mhd_gtls_extensions[MAX_EXT_SIZE] = {
+MHD_gtls_extension_entry MHD_gtls_extensions[MAX_EXT_SIZE] = {
   GNUTLS_EXTENSION_ENTRY (GNUTLS_EXTENSION_MAX_RECORD_SIZE,
                           EXTENSION_TLS,
-                          mhd_gtls_max_record_recv_params,
-                          mhd_gtls_max_record_send_params),
+                          MHD_gtls_max_record_recv_params,
+                          MHD_gtls_max_record_send_params),
   GNUTLS_EXTENSION_ENTRY (GNUTLS_EXTENSION_CERT_TYPE,
                           EXTENSION_TLS,
-                          mhd_gtls_cert_type_recv_params,
-                          mhd_gtls_cert_type_send_params),
+                          MHD_gtls_cert_type_recv_params,
+                          MHD_gtls_cert_type_send_params),
   GNUTLS_EXTENSION_ENTRY (GNUTLS_EXTENSION_SERVER_NAME,
                           EXTENSION_APPLICATION,
-                          mhd_gtls_server_name_recv_params,
-                          mhd_gtls_server_name_send_params),
+                          MHD_gtls_server_name_recv_params,
+                          MHD_gtls_server_name_send_params),
 #ifdef ENABLE_OPRFI
   GNUTLS_EXTENSION_ENTRY (GNUTLS_EXTENSION_OPAQUE_PRF_INPUT,
                           EXTENSION_TLS,
-                          mhd_gtls_oprfi_recv_params,
-                          mhd_gtls_oprfi_send_params),
+                          MHD_gtls_oprfi_recv_params,
+                          MHD_gtls_oprfi_send_params),
 #endif
 #ifdef ENABLE_SRP
   GNUTLS_EXTENSION_ENTRY (GNUTLS_EXTENSION_SRP,
                           EXTENSION_TLS,
-                          _gnutls_srp_recv_params,
-                          _gnutls_srp_send_params),
+                          MHD__gnutls_srp_recv_params,
+                          MHD__gnutls_srp_send_params),
 #endif
   {0, 0, 0, 0}
 };
 
 #define GNUTLS_EXTENSION_LOOP2(b) \
-        mhd_gtls_extension_entry *p; \
-                for(p = mhd_gtls_extensions; p->name != NULL; p++) { b ; }
+        MHD_gtls_extension_entry *p; \
+                for(p = MHD_gtls_extensions; p->name != NULL; p++) { b ; }
 
 #define GNUTLS_EXTENSION_LOOP(a) \
                         GNUTLS_EXTENSION_LOOP2( if(p->type == type) { a; break; } )
@@ -83,29 +83,29 @@ mhd_gtls_extension_entry mhd_gtls_extensions[MAX_EXT_SIZE] = {
 
 /* EXTENSION functions */
 
-mhd_gtls_ext_recv_func
-mhd_gtls_ext_func_recv (uint16_t type, mhd_gtls_ext_parse_type_t parse_type)
+MHD_gtls_ext_recv_func
+MHD_gtls_ext_func_recv (uint16_t type, MHD_gtls_ext_parse_type_t parse_type)
 {
-  mhd_gtls_ext_recv_func ret = NULL;
+  MHD_gtls_ext_recv_func ret = NULL;
   GNUTLS_EXTENSION_LOOP (if
                          (parse_type == EXTENSION_ANY
                           || p->parse_type == parse_type) ret =
-                         p->gnutls_ext_func_recv);
+                         p->MHD_gnutls_ext_func_recv);
   return ret;
 
 }
 
-mhd_gtls_ext_send_func
-mhd_gtls_ext_func_send (uint16_t type)
+MHD_gtls_ext_send_func
+MHD_gtls_ext_func_send (uint16_t type)
 {
-  mhd_gtls_ext_send_func ret = NULL;
-  GNUTLS_EXTENSION_LOOP (ret = p->gnutls_ext_func_send);
+  MHD_gtls_ext_send_func ret = NULL;
+  GNUTLS_EXTENSION_LOOP (ret = p->MHD_gnutls_ext_func_send);
   return ret;
 
 }
 
 const char *
-mhd_gtls_extension_get_name (uint16_t type)
+MHD_gtls_extension_get_name (uint16_t type)
 {
   const char *ret = NULL;
 
@@ -119,7 +119,7 @@ mhd_gtls_extension_get_name (uint16_t type)
  * requested ones. Otherwise it's a fatal error.
  */
 static int
-_gnutls_extension_list_check (mhd_gtls_session_t session, uint16_t type)
+MHD__gnutls_extension_list_check (MHD_gtls_session_t session, uint16_t type)
 {
 #if MHD_DEBUG_TLS
   if (session->security_parameters.entity == GNUTLS_CLIENT)
@@ -137,15 +137,15 @@ _gnutls_extension_list_check (mhd_gtls_session_t session, uint16_t type)
 }
 
 int
-mhd_gtls_parse_extensions (mhd_gtls_session_t session,
-                           mhd_gtls_ext_parse_type_t parse_type,
+MHD_gtls_parse_extensions (MHD_gtls_session_t session,
+                           MHD_gtls_ext_parse_type_t parse_type,
                            const opaque * data, int data_size)
 {
   int next, ret;
   int pos = 0;
   uint16_t type;
   const opaque *sdata;
-  mhd_gtls_ext_recv_func ext_recv;
+  MHD_gtls_ext_recv_func ext_recv;
   uint16_t size;
 
 #if MHD_DEBUG_TLS
@@ -153,15 +153,15 @@ mhd_gtls_parse_extensions (mhd_gtls_session_t session,
   if (session->security_parameters.entity == GNUTLS_CLIENT)
     for (i = 0; i < session->internals.extensions_sent_size; i++)
       {
-        _gnutls_debug_log ("EXT[%d]: expecting extension '%s'\n",
+        MHD__gnutls_debug_log ("EXT[%d]: expecting extension '%s'\n",
                            session,
-                           mhd_gtls_extension_get_name
+                           MHD_gtls_extension_get_name
                            (session->internals.extensions_sent[i]));
       }
 #endif
 
   DECR_LENGTH_RET (data_size, 2, 0);
-  next = mhd_gtls_read_uint16 (data);
+  next = MHD_gtls_read_uint16 (data);
   pos += 2;
 
   DECR_LENGTH_RET (data_size, next, 0);
@@ -169,32 +169,32 @@ mhd_gtls_parse_extensions (mhd_gtls_session_t session,
   do
     {
       DECR_LENGTH_RET (next, 2, 0);
-      type = mhd_gtls_read_uint16 (&data[pos]);
+      type = MHD_gtls_read_uint16 (&data[pos]);
       pos += 2;
 
-      _gnutls_debug_log ("EXT[%x]: Received extension '%s/%d'\n", session,
-                         mhd_gtls_extension_get_name (type), type);
+      MHD__gnutls_debug_log ("EXT[%x]: Received extension '%s/%d'\n", session,
+                         MHD_gtls_extension_get_name (type), type);
 
-      if ((ret = _gnutls_extension_list_check (session, type)) < 0)
+      if ((ret = MHD__gnutls_extension_list_check (session, type)) < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
       DECR_LENGTH_RET (next, 2, 0);
-      size = mhd_gtls_read_uint16 (&data[pos]);
+      size = MHD_gtls_read_uint16 (&data[pos]);
       pos += 2;
 
       DECR_LENGTH_RET (next, size, 0);
       sdata = &data[pos];
       pos += size;
 
-      ext_recv = mhd_gtls_ext_func_recv (type, parse_type);
+      ext_recv = MHD_gtls_ext_func_recv (type, parse_type);
       if (ext_recv == NULL)
         continue;
       if ((ret = ext_recv (session, sdata, size)) < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
@@ -210,7 +210,7 @@ mhd_gtls_parse_extensions (mhd_gtls_session_t session,
  * extensions are the ones we requested.
  */
 static void
-_gnutls_extension_list_add (mhd_gtls_session_t session, uint16_t type)
+MHD__gnutls_extension_list_add (MHD_gtls_session_t session, uint16_t type)
 {
 #if MHD_DEBUG_TLS
   if (session->security_parameters.entity == GNUTLS_CLIENT)
@@ -223,43 +223,43 @@ _gnutls_extension_list_add (mhd_gtls_session_t session, uint16_t type)
         }
       else
         {
-          _gnutls_debug_log ("extensions: Increase MAX_EXT_TYPES\n");
+          MHD__gnutls_debug_log ("extensions: Increase MAX_EXT_TYPES\n");
         }
     }
 #endif
 }
 
 int
-mhd_gtls_gen_extensions (mhd_gtls_session_t session, opaque * data,
+MHD_gtls_gen_extensions (MHD_gtls_session_t session, opaque * data,
                          size_t data_size)
 {
   int size;
   uint16_t pos = 0;
   opaque *sdata;
   int sdata_size;
-  mhd_gtls_ext_send_func ext_send;
-  mhd_gtls_extension_entry *p;
+  MHD_gtls_ext_send_func ext_send;
+  MHD_gtls_extension_entry *p;
 
   if (data_size < 2)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
   /* allocate enough data for each extension.
    */
   sdata_size = data_size;
-  sdata = gnutls_malloc (sdata_size);
+  sdata = MHD_gnutls_malloc (sdata_size);
   if (sdata == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
   pos += 2;
-  for (p = mhd_gtls_extensions; p->name != NULL; p++)
+  for (p = MHD_gtls_extensions; p->name != NULL; p++)
     {
-      ext_send = mhd_gtls_ext_func_send (p->type);
+      ext_send = MHD_gtls_ext_func_send (p->type);
       if (ext_send == NULL)
         continue;
       size = ext_send (session, sdata, sdata_size);
@@ -267,17 +267,17 @@ mhd_gtls_gen_extensions (mhd_gtls_session_t session, opaque * data,
         {
           if (data_size < pos + (size_t) size + 4)
             {
-              gnutls_assert ();
-              gnutls_free (sdata);
+              MHD_gnutls_assert ();
+              MHD_gnutls_free (sdata);
               return GNUTLS_E_INTERNAL_ERROR;
             }
 
           /* write extension type */
-          mhd_gtls_write_uint16 (p->type, &data[pos]);
+          MHD_gtls_write_uint16 (p->type, &data[pos]);
           pos += 2;
 
           /* write size */
-          mhd_gtls_write_uint16 (size, &data[pos]);
+          MHD_gtls_write_uint16 (size, &data[pos]);
           pos += 2;
 
           memcpy (&data[pos], sdata, size);
@@ -285,15 +285,15 @@ mhd_gtls_gen_extensions (mhd_gtls_session_t session, opaque * data,
 
           /* add this extension to the extension list
            */
-          _gnutls_extension_list_add (session, p->type);
+          MHD__gnutls_extension_list_add (session, p->type);
 
-          _gnutls_debug_log ("EXT[%x]: Sending extension %s\n", session,
-                             mhd_gtls_extension_get_name (p->type));
+          MHD__gnutls_debug_log ("EXT[%x]: Sending extension %s\n", session,
+                             MHD_gtls_extension_get_name (p->type));
         }
       else if (size < 0)
         {
-          gnutls_assert ();
-          gnutls_free (sdata);
+          MHD_gnutls_assert ();
+          MHD_gnutls_free (sdata);
           return size;
         }
     }
@@ -301,14 +301,14 @@ mhd_gtls_gen_extensions (mhd_gtls_session_t session, opaque * data,
   size = pos;
   pos -= 2;                     /* remove the size of the size header! */
 
-  mhd_gtls_write_uint16 (pos, data);
+  MHD_gtls_write_uint16 (pos, data);
 
   if (size == 2)
     {                           /* empty */
       size = 0;
     }
 
-  gnutls_free (sdata);
+  MHD_gnutls_free (sdata);
   return size;
 
 }
diff --git a/src/daemon/https/tls/gnutls_extensions.h b/src/daemon/https/tls/gnutls_extensions.h
index 52604067..9623b39b 100644
--- a/src/daemon/https/tls/gnutls_extensions.h
+++ b/src/daemon/https/tls/gnutls_extensions.h
@@ -24,24 +24,24 @@
 
 #include <gnutls_int.h>
 
-const char *mhd_gtls_extension_get_name (uint16_t type);
-int mhd_gtls_parse_extensions (mhd_gtls_session_t, mhd_gtls_ext_parse_type_t,
+const char *MHD_gtls_extension_get_name (uint16_t type);
+int MHD_gtls_parse_extensions (MHD_gtls_session_t, MHD_gtls_ext_parse_type_t,
                                const opaque *, int);
-int mhd_gtls_gen_extensions (mhd_gtls_session_t session, opaque * data,
+int MHD_gtls_gen_extensions (MHD_gtls_session_t session, opaque * data,
                              size_t data_size);
 
-typedef int (*mhd_gtls_ext_recv_func) (mhd_gtls_session_t, const opaque *, size_t);     /* recv data */
-typedef int (*mhd_gtls_ext_send_func) (mhd_gtls_session_t, opaque *, size_t);   /* send data */
+typedef int (*MHD_gtls_ext_recv_func) (MHD_gtls_session_t, const opaque *, size_t);     /* recv data */
+typedef int (*MHD_gtls_ext_send_func) (MHD_gtls_session_t, opaque *, size_t);   /* send data */
 
-mhd_gtls_ext_send_func mhd_gtls_ext_func_send (uint16_t type);
-mhd_gtls_ext_recv_func mhd_gtls_ext_func_recv (uint16_t type,
-                                               mhd_gtls_ext_parse_type_t);
+MHD_gtls_ext_send_func MHD_gtls_ext_func_send (uint16_t type);
+MHD_gtls_ext_recv_func MHD_gtls_ext_func_recv (uint16_t type,
+                                               MHD_gtls_ext_parse_type_t);
 
 typedef struct
 {
   const char *name;
   uint16_t type;
-  mhd_gtls_ext_parse_type_t parse_type;
-  mhd_gtls_ext_recv_func gnutls_ext_func_recv;
-  mhd_gtls_ext_send_func gnutls_ext_func_send;
-} mhd_gtls_extension_entry;
+  MHD_gtls_ext_parse_type_t parse_type;
+  MHD_gtls_ext_recv_func MHD_gnutls_ext_func_recv;
+  MHD_gtls_ext_send_func MHD_gnutls_ext_func_send;
+} MHD_gtls_extension_entry;
diff --git a/src/daemon/https/tls/gnutls_global.c b/src/daemon/https/tls/gnutls_global.c
index b252b127..781d12fa 100644
--- a/src/daemon/https/tls/gnutls_global.c
+++ b/src/daemon/https/tls/gnutls_global.c
@@ -44,17 +44,17 @@
 
 GCRY_THREAD_OPTION_PTHREAD_IMPL;
 
-#define gnutls_log_func LOG_FUNC
+#define MHD_gnutls_log_func LOG_FUNC
 
 /* created by asn1c */
-extern const ASN1_ARRAY_TYPE gnutls_asn1_tab[];
-extern const ASN1_ARRAY_TYPE pkix_asn1_tab[];
+extern const ASN1_ARRAY_TYPE MHD_gnutlsMHD__asn1_tab[];
+extern const ASN1_ARRAY_TYPE MHD_pkix_asn1_tab[];
 
-LOG_FUNC _gnutls_log_func;
-int _gnutls_log_level = 0;      /* default log level */
+LOG_FUNC MHD__gnutls_log_func;
+int MHD__gnutls_log_level = 0;      /* default log level */
 
-ASN1_TYPE _gnutls_pkix1_asn;
-ASN1_TYPE _gnutls_gnutls_asn;
+ASN1_TYPE MHD__gnutls_pkix1_asn;
+ASN1_TYPE MHD__gnutlsMHD__gnutls_asn;
 
 /**
  * MHD_gtls_global_set_log_function - This function sets the logging function
@@ -65,13 +65,13 @@ ASN1_TYPE _gnutls_gnutls_asn;
  * Normally you may not use this function since it is only used
  * for debugging purposes.
  *
- * gnutls_log_func is of the form,
- * void (*gnutls_log_func)( int level, const char*);
+ * MHD_gnutls_log_func is of the form,
+ * void (*MHD_gnutls_log_func)( int level, const char*);
  **/
 void
-MHD_gtls_global_set_log_function (gnutls_log_func log_func)
+MHD_gtls_global_set_log_function (MHD_gnutls_log_func log_func)
 {
-  _gnutls_log_func = log_func;
+  MHD__gnutls_log_func = log_func;
 }
 
 /**
@@ -89,10 +89,10 @@ MHD_gtls_global_set_log_function (gnutls_log_func log_func)
 void
 MHD_gtls_global_set_log_level (int level)
 {
-  _gnutls_log_level = level;
+  MHD__gnutls_log_level = level;
 }
 
-int _gnutls_is_secure_mem_null (const void *);
+int MHD__gnutls_is_secure_mem_null (const void *);
 
 /**
  * MHD_gtls_global_set_mem_functions - This function sets the memory allocation functions
@@ -108,61 +108,61 @@ int _gnutls_is_secure_mem_null (const void *);
  * This function is provided to set the memory allocation functions to
  * something other than the defaults (ie the gcrypt allocation functions).
  *
- * This function must be called before MHD_gnutls_global_init() is called.
+ * This function must be called before MHD__gnutls_global_init() is called.
  *
  **/
 void
-MHD_gtls_global_set_mem_functions (gnutls_alloc_function alloc_func,
-                                   gnutls_alloc_function
+MHD_gtls_global_set_mem_functions (MHD_gnutls_alloc_function alloc_func,
+                                   MHD_gnutls_alloc_function
                                    secure_alloc_func,
-                                   gnutls_is_secure_function
+                                   MHD_gnutls_is_secure_function
                                    is_secure_func,
-                                   gnutls_realloc_function realloc_func,
-                                   gnutls_free_function free_func)
+                                   MHD_gnutls_realloc_function realloc_func,
+                                   MHD_gnutls_free_function free_func)
 {
-  gnutls_secure_malloc = secure_alloc_func;
-  gnutls_malloc = alloc_func;
-  gnutls_realloc = realloc_func;
-  gnutls_free = free_func;
+  MHD_gnutls_secure_malloc = secure_alloc_func;
+  MHD_gnutls_malloc = alloc_func;
+  MHD_gnutls_realloc = realloc_func;
+  MHD_gnutls_free = free_func;
 
   if (is_secure_func != NULL)
-    _gnutls_is_secure_memory = is_secure_func;
+    MHD__gnutls_is_secure_memory = is_secure_func;
   else
-    _gnutls_is_secure_memory = _gnutls_is_secure_mem_null;
+    MHD__gnutls_is_secure_memory = MHD__gnutls_is_secure_mem_null;
 
   /* if using the libc's default malloc
    * use libc's calloc as well.
    */
-  if (gnutls_malloc == malloc)
+  if (MHD_gnutls_malloc == malloc)
     {
-      gnutls_calloc = calloc;
+      MHD_gnutls_calloc = calloc;
     }
   else
     {                           /* use the included ones */
-      gnutls_calloc = mhd_gtls_calloc;
+      MHD_gnutls_calloc = MHD_gtls_calloc;
     }
-  gnutls_strdup = mhd_gtls_strdup;
+  MHD_gnutls_strdup = MHD_gtls_strdup;
 
 }
 
 #ifdef DEBUG
 static void
-_gnutls_gcry_log_handler (void *dummy, int level,
+MHD__gnutls_gcry_log_handler (void *dummy, int level,
                           const char *fmt, va_list list)
 {
-  mhd_gtls_log (level, fmt, list);
+  MHD_gtls_log (level, fmt, list);
 }
 #endif
 
-static int _gnutls_init = 0;
+static int MHD__gnutls_init_level = 0;
 
 /**
- * MHD_gnutls_global_init - This function initializes the global data to defaults.
+ * MHD__gnutls_global_init - This function initializes the global data to defaults.
  *
  * This function initializes the global data to defaults.
  * Every gnutls application has a global data which holds common parameters
  * shared by gnutls session structures.
- * You must call MHD_gnutls_global_deinit() when gnutls usage is no longer needed
+ * You must call MHD__gnutls_global_deinit() when gnutls usage is no longer needed
  * Returns zero on success.
  *
  * Note that this function will also initialize libgcrypt, if it has not
@@ -171,8 +171,8 @@ static int _gnutls_init = 0;
  * want to disable libgcrypt's internal lockings etc.
  *
  * This function increment a global counter, so that
- * MHD_gnutls_global_deinit() only releases resources when it has been
- * called as many times as MHD_gnutls_global_init().  This is useful when
+ * MHD__gnutls_global_deinit() only releases resources when it has been
+ * called as many times as MHD__gnutls_global_init().  This is useful when
  * GnuTLS is used by more than one library in an application.  This
  * function can be called many times, but will only do something the
  * first time.
@@ -187,13 +187,13 @@ static int _gnutls_init = 0;
  *
  **/
 int
-MHD_gnutls_global_init (void)
+MHD__gnutls_global_init (void)
 {
   int result = 0;
   int res;
   char c;
 
-  if (_gnutls_init++)
+  if (MHD__gnutls_init_level++)
     return 0;
 
 #if HAVE_WINSOCK
@@ -206,13 +206,13 @@ MHD_gnutls_global_init (void)
     err = WSAStartup (requested, &data);
     if (err != 0)
       {
-        _gnutls_debug_log ("WSAStartup failed: %d.\n", err);
+        MHD__gnutls_debug_log ("WSAStartup failed: %d.\n", err);
         return GNUTLS_E_LIBRARY_VERSION_MISMATCH;
       }
 
     if (data.wVersion < requested)
       {
-        _gnutls_debug_log ("WSAStartup version check failed (%d < %d).\n",
+        MHD__gnutls_debug_log ("WSAStartup version check failed (%d < %d).\n",
                            data.wVersion, requested);
         WSACleanup ();
         return GNUTLS_E_LIBRARY_VERSION_MISMATCH;
@@ -239,15 +239,15 @@ MHD_gnutls_global_init (void)
       /* this call initializes libgcrypt */
       if (gcry_check_version (p) == NULL)
         {
-          gnutls_assert ();
-          _gnutls_debug_log ("Checking for libgcrypt failed '%s'\n", p);
+          MHD_gnutls_assert ();
+          MHD__gnutls_debug_log ("Checking for libgcrypt failed '%s'\n", p);
           return GNUTLS_E_INCOMPATIBLE_GCRYPT_LIBRARY;
         }
 
       /* for gcrypt in order to be able to allocate memory */
-      gcry_set_allocation_handler (gnutls_malloc, gnutls_secure_malloc,
-                                   _gnutls_is_secure_memory, gnutls_realloc,
-                                   gnutls_free);
+      gcry_set_allocation_handler (MHD_gnutls_malloc, MHD_gnutls_secure_malloc,
+                                   MHD__gnutls_is_secure_memory, MHD_gnutls_realloc,
+                                   MHD_gnutls_free);
 
       /* gcry_control (GCRYCTL_DISABLE_INTERNAL_LOCKING, NULL, 0); */
 
@@ -257,14 +257,14 @@ MHD_gnutls_global_init (void)
       /* applications may want to override that, so we only use
        * it in debugging mode.
        */
-      gcry_set_log_handler (_gnutls_gcry_log_handler, NULL);
+      gcry_set_log_handler (MHD__gnutls_gcry_log_handler, NULL);
 #endif
     }
 
-  if (gc_init () != GC_OK)
+  if (MHD_gc_init () != GC_OK)
     {
-      gnutls_assert ();
-      _gnutls_debug_log ("Initializing crypto backend failed\n");
+      MHD_gnutls_assert ();
+      MHD__gnutls_debug_log ("Initializing crypto backend failed\n");
       return GNUTLS_E_INCOMPATIBLE_CRYPTO_LIBRARY;
     }
 
@@ -276,50 +276,50 @@ MHD_gnutls_global_init (void)
    * This should not deal with files in the final
    * version.
    */
-  res = asn1_array2tree (pkix_asn1_tab, &_gnutls_pkix1_asn, NULL);
+  res = MHD__asn1_array2tree (MHD_pkix_asn1_tab, &MHD__gnutls_pkix1_asn, NULL);
   if (res != ASN1_SUCCESS)
     {
-      result = mhd_gtls_asn2err (res);
+      result = MHD_gtls_asn2err (res);
       return result;
     }
 
-  res = asn1_array2tree (gnutls_asn1_tab, &_gnutls_gnutls_asn, NULL);
+  res = MHD__asn1_array2tree (MHD_gnutlsMHD__asn1_tab, &MHD__gnutlsMHD__gnutls_asn, NULL);
   if (res != ASN1_SUCCESS)
     {
-      asn1_delete_structure (&_gnutls_pkix1_asn);
-      result = mhd_gtls_asn2err (res);
+      MHD__asn1_delete_structure (&MHD__gnutls_pkix1_asn);
+      result = MHD_gtls_asn2err (res);
       return result;
     }
 
   /* Initialize the gcrypt (if used random generator) */
-  gc_pseudo_random (&c, 1);
+  MHD_gc_pseudo_random (&c, 1);
 
   return result;
 }
 
 /**
- * MHD_gnutls_global_deinit - This function deinitializes the global data
+ * MHD__gnutls_global_deinit - This function deinitializes the global data
  *
  * This function deinitializes the global data, that were initialized
- * using MHD_gnutls_global_init().
+ * using MHD__gnutls_global_init().
  *
  * Note!  This function is not thread safe.  See the discussion for
- * MHD_gnutls_global_init() for more information.
+ * MHD__gnutls_global_init() for more information.
  *
  **/
 void
-MHD_gnutls_global_deinit (void)
+MHD__gnutls_global_deinit (void)
 {
-  if (_gnutls_init == 1)
+  if (MHD__gnutls_init_level == 1)
     {
 #if HAVE_WINSOCK
       WSACleanup ();
 #endif
-      asn1_delete_structure (&_gnutls_gnutls_asn);
-      asn1_delete_structure (&_gnutls_pkix1_asn);
-      gc_done ();
+      MHD__asn1_delete_structure (&MHD__gnutlsMHD__gnutls_asn);
+      MHD__asn1_delete_structure (&MHD__gnutls_pkix1_asn);
+      MHD_gc_done ();
     }
-  _gnutls_init--;
+  MHD__gnutls_init_level--;
 }
 
 /* These functions should be elsewere. Kept here for
@@ -327,7 +327,7 @@ MHD_gnutls_global_deinit (void)
  */
 
 /**
- * MHD_gnutls_transport_set_pull_function - This function sets a read like function
+ * MHD__gnutls_transport_set_pull_function - This function sets a read like function
  * @pull_func: a callback function similar to read()
  * @session: gnutls session
  *
@@ -337,17 +337,17 @@ MHD_gnutls_global_deinit (void)
  * probably be ok.
  *
  * PULL_FUNC is of the form,
- * ssize_t (*mhd_gtls_pull_func)(gnutls_transport_ptr_t, void*, size_t);
+ * ssize_t (*MHD_gtls_pull_func)(MHD_gnutls_transport_ptr_t, void*, size_t);
  **/
 void
-MHD_gnutls_transport_set_pull_function (mhd_gtls_session_t session,
-                                        mhd_gtls_pull_func pull_func)
+MHD__gnutls_transport_set_pull_function (MHD_gtls_session_t session,
+                                        MHD_gtls_pull_func pull_func)
 {
-  session->internals._gnutls_pull_func = pull_func;
+  session->internals.MHD__gnutls_pull_func = pull_func;
 }
 
 /**
- * MHD_gnutls_transport_set_push_function - This function sets the function to send data
+ * MHD__gnutls_transport_set_push_function - This function sets the function to send data
  * @push_func: a callback function similar to write()
  * @session: gnutls session
  *
@@ -358,11 +358,11 @@ MHD_gnutls_transport_set_pull_function (mhd_gtls_session_t session,
  * specify this function for gnutls to be able to send data.
  *
  * PUSH_FUNC is of the form,
- * ssize_t (*mhd_gtls_push_func)(gnutls_transport_ptr_t, const void*, size_t);
+ * ssize_t (*MHD_gtls_push_func)(MHD_gnutls_transport_ptr_t, const void*, size_t);
  **/
 void
-MHD_gnutls_transport_set_push_function (mhd_gtls_session_t session,
-                                        mhd_gtls_push_func push_func)
+MHD__gnutls_transport_set_push_function (MHD_gtls_session_t session,
+                                        MHD_gtls_push_func push_func)
 {
-  session->internals._gnutls_push_func = push_func;
+  session->internals.MHD__gnutls_push_func = push_func;
 }
diff --git a/src/daemon/https/tls/gnutls_global.h b/src/daemon/https/tls/gnutls_global.h
index 7ec40882..8cfaf0ca 100644
--- a/src/daemon/https/tls/gnutls_global.h
+++ b/src/daemon/https/tls/gnutls_global.h
@@ -27,19 +27,19 @@
 
 #include <libtasn1.h>
 
-/* this mutex is used to synchronize threads attemting call MHD_gnutls_global_init / MHD_gnutls_global_deinit */
-pthread_mutex_t gnutls_init_mutex;
+/* this mutex is used to synchronize threads attemting call MHD__gnutls_global_init / MHD__gnutls_global_deinit */
+pthread_mutex_t MHD_gnutls_init_mutex;
 
-int gnutls_is_secure_memory (const void *mem);
+int MHD_gnutls_is_secure_memory (const void *mem);
 
-extern ASN1_TYPE _gnutls_pkix1_asn;
-extern ASN1_TYPE _gnutls_gnutls_asn;
+extern ASN1_TYPE MHD__gnutls_pkix1_asn;
+extern ASN1_TYPE MHD__gnutlsMHD__gnutls_asn;
 
 /* removed const from node_asn* to
  * prevent warnings, since libtasn1 doesn't
  * use the const keywork in its functions.
  */
-#define _gnutls_get_gnutls_asn() ((node_asn*) _gnutls_gnutls_asn)
-#define _gnutls_get_pkix() ((node_asn*) _gnutls_pkix1_asn)
+#define MHD__gnutls_getMHD__gnutls_asn() ((node_asn*) MHD__gnutlsMHD__gnutls_asn)
+#define MHD__gnutls_get_pkix() ((node_asn*) MHD__gnutls_pkix1_asn)
 
 #endif
diff --git a/src/daemon/https/tls/gnutls_handshake.c b/src/daemon/https/tls/gnutls_handshake.c
index e53d6985..31826448 100644
--- a/src/daemon/https/tls/gnutls_handshake.c
+++ b/src/daemon/https/tls/gnutls_handshake.c
@@ -46,12 +46,12 @@
 #include "gnutls_constate.h"
 #include "gnutls_record.h"
 #include "gnutls_state.h"
-#include "gnutls_rsa_export.h"  /* for gnutls_get_rsa_params() */
-#include "auth_anon.h"          /* for mhd_gtls_anon_server_credentials_t */
+#include "gnutls_rsa_export.h"  /* for MHD_gnutls_get_rsa_params() */
+#include "auth_anon.h"          /* for MHD_gtls_anon_server_credentials_t */
 #include "gc.h"
 
 #ifdef HANDSHAKE_DEBUG
-#define ERR(x, y) _gnutls_handshake_log( "HSK[%x]: %s (%d)\n", session, x,y)
+#define ERR(x, y) MHD__gnutls_handshake_log( "HSK[%x]: %s (%d)\n", session, x,y)
 #else
 #define ERR(x, y)
 #endif
@@ -59,20 +59,20 @@
 #define TRUE 1
 #define FALSE 0
 
-static int _gnutls_server_select_comp_method (mhd_gtls_session_t session,
+static int MHD__gnutls_server_select_comp_method (MHD_gtls_session_t session,
                                               opaque * data, int datalen);
 
 
 /* Clears the handshake hash buffers and handles.
  */
 inline static void
-_gnutls_handshake_hash_buffers_clear (mhd_gtls_session_t session)
+MHD__gnutls_handshake_hash_buffers_clear (MHD_gtls_session_t session)
 {
-  mhd_gnutls_hash_deinit (session->internals.handshake_mac_handle_md5, NULL);
-  mhd_gnutls_hash_deinit (session->internals.handshake_mac_handle_sha, NULL);
+  MHD_gnutls_hash_deinit (session->internals.handshake_mac_handle_md5, NULL);
+  MHD_gnutls_hash_deinit (session->internals.handshake_mac_handle_sha, NULL);
   session->internals.handshake_mac_handle_md5 = NULL;
   session->internals.handshake_mac_handle_sha = NULL;
-  mhd_gtls_handshake_buffer_clear (session);
+  MHD_gtls_handshake_buffer_clear (session);
 }
 
 /* this will copy the required values for resuming to
@@ -80,7 +80,7 @@ _gnutls_handshake_hash_buffers_clear (mhd_gtls_session_t session)
  * this will keep as less data to security_parameters.
  */
 static void
-resume_copy_required_values (mhd_gtls_session_t session)
+resume_copy_required_values (MHD_gtls_session_t session)
 {
   /* get the new random values */
   memcpy (session->internals.resumed_security_parameters.server_random,
@@ -105,7 +105,7 @@ resume_copy_required_values (mhd_gtls_session_t session)
   session->security_parameters.entity =
     session->internals.resumed_security_parameters.entity;
 
-  mhd_gtls_set_current_version (session,
+  MHD_gtls_set_current_version (session,
                                 session->internals.
                                 resumed_security_parameters.version);
 
@@ -120,13 +120,13 @@ resume_copy_required_values (mhd_gtls_session_t session)
 }
 
 void
-mhd_gtls_set_server_random (mhd_gtls_session_t session, uint8_t * rnd)
+MHD_gtls_set_server_random (MHD_gtls_session_t session, uint8_t * rnd)
 {
   memcpy (session->security_parameters.server_random, rnd, TLS_RANDOM_SIZE);
 }
 
 void
-mhd_gtls_set_client_random (mhd_gtls_session_t session, uint8_t * rnd)
+MHD_gtls_set_client_random (MHD_gtls_session_t session, uint8_t * rnd)
 {
   memcpy (session->security_parameters.client_random, rnd, TLS_RANDOM_SIZE);
 }
@@ -136,25 +136,25 @@ mhd_gtls_set_client_random (mhd_gtls_session_t session, uint8_t * rnd)
 #define SSL3_SERVER_MSG "SRVR"
 #define SSL_MSG_LEN 4
 static int
-_gnutls_ssl3_finished (mhd_gtls_session_t session, int type, opaque * ret)
+MHD__gnutls_ssl3_finished (MHD_gtls_session_t session, int type, opaque * ret)
 {
   const int siz = SSL_MSG_LEN;
   mac_hd_t td_md5;
   mac_hd_t td_sha;
   const char *mesg;
 
-  td_md5 = mhd_gnutls_hash_copy (session->internals.handshake_mac_handle_md5);
+  td_md5 = MHD_gnutls_hash_copy (session->internals.handshake_mac_handle_md5);
   if (td_md5 == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_HASH_FAILED;
     }
 
-  td_sha = mhd_gnutls_hash_copy (session->internals.handshake_mac_handle_sha);
+  td_sha = MHD_gnutls_hash_copy (session->internals.handshake_mac_handle_sha);
   if (td_sha == NULL)
     {
-      gnutls_assert ();
-      mhd_gnutls_hash_deinit (td_md5, NULL);
+      MHD_gnutls_assert ();
+      MHD_gnutls_hash_deinit (td_md5, NULL);
       return GNUTLS_E_HASH_FAILED;
     }
 
@@ -167,13 +167,13 @@ _gnutls_ssl3_finished (mhd_gtls_session_t session, int type, opaque * ret)
       mesg = SSL3_CLIENT_MSG;
     }
 
-  mhd_gnutls_hash (td_md5, mesg, siz);
-  mhd_gnutls_hash (td_sha, mesg, siz);
+  MHD_gnutls_hash (td_md5, mesg, siz);
+  MHD_gnutls_hash (td_sha, mesg, siz);
 
-  mhd_gnutls_mac_deinit_ssl3_handshake (td_md5, ret,
+  MHD_gnutls_mac_deinit_ssl3_handshake (td_md5, ret,
                                         session->security_parameters.
                                         master_secret, TLS_MASTER_SIZE);
-  mhd_gnutls_mac_deinit_ssl3_handshake (td_sha, &ret[16],
+  MHD_gnutls_mac_deinit_ssl3_handshake (td_sha, &ret[16],
                                         session->security_parameters.
                                         master_secret, TLS_MASTER_SIZE);
 
@@ -185,7 +185,7 @@ _gnutls_ssl3_finished (mhd_gtls_session_t session, int type, opaque * ret)
 #define CLIENT_MSG "client finished"
 #define TLS_MSG_LEN 15
 static int
-_gnutls_finished (mhd_gtls_session_t session, int type, void *ret)
+MHD__gnutls_finished (MHD_gtls_session_t session, int type, void *ret)
 {
   const int siz = TLS_MSG_LEN;
   opaque concat[36];
@@ -193,37 +193,37 @@ _gnutls_finished (mhd_gtls_session_t session, int type, void *ret)
   const char *mesg;
   mac_hd_t td_md5 = NULL;
   mac_hd_t td_sha;
-  enum MHD_GNUTLS_Protocol ver = MHD_gnutls_protocol_get_version (session);
+  enum MHD_GNUTLS_Protocol ver = MHD__gnutls_protocol_get_version (session);
 
   if (ver < MHD_GNUTLS_PROTOCOL_TLS1_2)
     {
       td_md5 =
-        mhd_gnutls_hash_copy (session->internals.handshake_mac_handle_md5);
+        MHD_gnutls_hash_copy (session->internals.handshake_mac_handle_md5);
       if (td_md5 == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_HASH_FAILED;
         }
     }
 
-  td_sha = mhd_gnutls_hash_copy (session->internals.handshake_mac_handle_sha);
+  td_sha = MHD_gnutls_hash_copy (session->internals.handshake_mac_handle_sha);
   if (td_sha == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       if (td_md5 != NULL)
-        mhd_gnutls_hash_deinit (td_md5, NULL);
+        MHD_gnutls_hash_deinit (td_md5, NULL);
       return GNUTLS_E_HASH_FAILED;
     }
 
   if (ver < MHD_GNUTLS_PROTOCOL_TLS1_2)
     {
-      mhd_gnutls_hash_deinit (td_md5, concat);
-      mhd_gnutls_hash_deinit (td_sha, &concat[16]);
+      MHD_gnutls_hash_deinit (td_md5, concat);
+      MHD_gnutls_hash_deinit (td_sha, &concat[16]);
       len = 20 + 16;
     }
   else
     {
-      mhd_gnutls_hash_deinit (td_sha, concat);
+      MHD_gnutls_hash_deinit (td_sha, concat);
       len = 20;
     }
 
@@ -236,7 +236,7 @@ _gnutls_finished (mhd_gtls_session_t session, int type, void *ret)
       mesg = CLIENT_MSG;
     }
 
-  return mhd_gtls_PRF (session, session->security_parameters.master_secret,
+  return MHD_gtls_PRF (session, session->security_parameters.master_secret,
                        TLS_MASTER_SIZE, mesg, siz, concat, len, 12, ret);
 }
 
@@ -244,7 +244,7 @@ _gnutls_finished (mhd_gtls_session_t session, int type, void *ret)
  * and put it to dst.
  */
 int
-mhd_gtls_tls_create_random (opaque * dst)
+MHD_gtls_tls_create_random (opaque * dst)
 {
   uint32_t tim;
 
@@ -255,11 +255,11 @@ mhd_gtls_tls_create_random (opaque * dst)
 
   tim = time (NULL);
   /* generate server random value */
-  mhd_gtls_write_uint32 (tim, dst);
+  MHD_gtls_write_uint32 (tim, dst);
 
-  if (gc_nonce (&dst[4], TLS_RANDOM_SIZE - 4) != GC_OK)
+  if (MHD_gc_nonce (&dst[4], TLS_RANDOM_SIZE - 4) != GC_OK)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_RANDOM_FAILED;
     }
 
@@ -269,23 +269,23 @@ mhd_gtls_tls_create_random (opaque * dst)
 /* returns the 0 on success or a negative value.
  */
 int
-mhd_gtls_negotiate_version (mhd_gtls_session_t session,
+MHD_gtls_negotiate_version (MHD_gtls_session_t session,
                             enum MHD_GNUTLS_Protocol adv_version)
 {
   int ret;
 
   /* if we do not support that version  */
-  if (mhd_gtls_version_is_supported (session, adv_version) == 0)
+  if (MHD_gtls_version_is_supported (session, adv_version) == 0)
     {
       /* If he requested something we do not support
        * then we send him the highest we support.
        */
-      ret = mhd_gtls_version_max (session);
+      ret = MHD_gtls_version_max (session);
       if (ret == MHD_GNUTLS_PROTOCOL_VERSION_UNKNOWN)
         {
           /* this check is not really needed.
            */
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_UNKNOWN_CIPHER_SUITE;
         }
     }
@@ -294,13 +294,13 @@ mhd_gtls_negotiate_version (mhd_gtls_session_t session,
       ret = adv_version;
     }
 
-  mhd_gtls_set_current_version (session, ret);
+  MHD_gtls_set_current_version (session, ret);
 
   return ret;
 }
 
 int
-mhd_gtls_user_hello_func (mhd_gtls_session_t session,
+MHD_gtls_user_hello_func (MHD_gtls_session_t session,
                           enum MHD_GNUTLS_Protocol adv_version)
 {
   int ret;
@@ -310,16 +310,16 @@ mhd_gtls_user_hello_func (mhd_gtls_session_t session,
       ret = session->internals.user_hello_func (session);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
       /* Here we need to renegotiate the version since the callee might
        * have disabled some TLS versions.
        */
-      ret = mhd_gtls_negotiate_version (session, adv_version);
+      ret = MHD_gtls_negotiate_version (session, adv_version);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
     }
@@ -332,7 +332,7 @@ mhd_gtls_user_hello_func (mhd_gtls_session_t session,
  * since SSL version 2.0 is not supported).
  */
 static int
-_gnutls_read_client_hello (mhd_gtls_session_t session, opaque * data,
+MHD__gnutls_read_client_hello (MHD_gtls_session_t session, opaque * data,
                            int datalen)
 {
   uint8_t session_id_len;
@@ -345,28 +345,28 @@ _gnutls_read_client_hello (mhd_gtls_session_t session, opaque * data,
 
   DECR_LEN (len, 2);
 
-  _gnutls_handshake_log ("HSK[%x]: Client's version: %d.%d\n", session,
+  MHD__gnutls_handshake_log ("HSK[%x]: Client's version: %d.%d\n", session,
                          data[pos], data[pos + 1]);
 
-  adv_version = mhd_gtls_version_get (data[pos], data[pos + 1]);
+  adv_version = MHD_gtls_version_get (data[pos], data[pos + 1]);
   set_adv_version (session, data[pos], data[pos + 1]);
   pos += 2;
 
-  neg_version = mhd_gtls_negotiate_version (session, adv_version);
+  neg_version = MHD_gtls_negotiate_version (session, adv_version);
   if (neg_version < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
   /* Read client random value.
    */
   DECR_LEN (len, TLS_RANDOM_SIZE);
-  mhd_gtls_set_client_random (session, &data[pos]);
+  MHD_gtls_set_client_random (session, &data[pos]);
   pos += TLS_RANDOM_SIZE;
 
-  mhd_gtls_tls_create_random (rnd);
-  mhd_gtls_set_server_random (session, rnd);
+  MHD_gtls_tls_create_random (rnd);
+  MHD_gtls_set_server_random (session, rnd);
 
   session->security_parameters.timestamp = time (NULL);
 
@@ -376,7 +376,7 @@ _gnutls_read_client_hello (mhd_gtls_session_t session, opaque * data,
   /* RESUME SESSION */
   if (session_id_len > TLS_MAX_SESSION_ID_SIZE)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
     }
   DECR_LEN (len, session_id_len);
@@ -388,11 +388,11 @@ _gnutls_read_client_hello (mhd_gtls_session_t session, opaque * data,
     {                           /* resumed! */
       resume_copy_required_values (session);
       session->internals.resumed = RESUME_TRUE;
-      return mhd_gtls_user_hello_func (session, adv_version);
+      return MHD_gtls_user_hello_func (session, adv_version);
     }
   else
     {
-      mhd_gtls_generate_session_id (session->security_parameters.session_id,
+      MHD_gtls_generate_session_id (session->security_parameters.session_id,
                                     &session->security_parameters.
                                     session_id_size);
 
@@ -402,7 +402,7 @@ _gnutls_read_client_hello (mhd_gtls_session_t session, opaque * data,
   /* Remember ciphersuites for later
    */
   DECR_LEN (len, 2);
-  suite_size = mhd_gtls_read_uint16 (&data[pos]);
+  suite_size = MHD_gtls_read_uint16 (&data[pos]);
   pos += 2;
 
   DECR_LEN (len, suite_size);
@@ -422,45 +422,45 @@ _gnutls_read_client_hello (mhd_gtls_session_t session, opaque * data,
    */
   if (neg_version >= MHD_GNUTLS_PROTOCOL_TLS1_0)
     {
-      ret = mhd_gtls_parse_extensions (session, EXTENSION_APPLICATION, &data[pos], len);        /* len is the rest of the parsed length */
+      ret = MHD_gtls_parse_extensions (session, EXTENSION_APPLICATION, &data[pos], len);        /* len is the rest of the parsed length */
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
     }
 
-  ret = mhd_gtls_user_hello_func (session, adv_version);
+  ret = MHD_gtls_user_hello_func (session, adv_version);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
   if (neg_version >= MHD_GNUTLS_PROTOCOL_TLS1_0)
     {
-      ret = mhd_gtls_parse_extensions (session, EXTENSION_TLS, &data[pos], len);        /* len is the rest of the parsed length */
+      ret = MHD_gtls_parse_extensions (session, EXTENSION_TLS, &data[pos], len);        /* len is the rest of the parsed length */
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
     }
 
   /* select an appropriate cipher suite
    */
-  ret = mhd_gtls_server_select_suite (session, suite_ptr, suite_size);
+  ret = MHD_gtls_server_select_suite (session, suite_ptr, suite_size);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
   /* select appropriate compression method */
-  ret = _gnutls_server_select_comp_method (session, comp_ptr, comp_size);
+  ret = MHD__gnutls_server_select_comp_method (session, comp_ptr, comp_size);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -470,7 +470,7 @@ _gnutls_read_client_hello (mhd_gtls_session_t session, opaque * data,
 /* here we hash all pending data.
  */
 inline static int
-_gnutls_handshake_hash_pending (mhd_gtls_session_t session)
+MHD__gnutls_handshake_hash_pending (MHD_gtls_session_t session)
 {
   size_t siz;
   int ret;
@@ -479,27 +479,27 @@ _gnutls_handshake_hash_pending (mhd_gtls_session_t session)
   if (session->internals.handshake_mac_handle_sha == NULL ||
       session->internals.handshake_mac_handle_md5 == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
   /* We check if there are pending data to hash.
    */
-  if ((ret = mhd_gtls_handshake_buffer_get_ptr (session, &data, &siz)) < 0)
+  if ((ret = MHD_gtls_handshake_buffer_get_ptr (session, &data, &siz)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
   if (siz > 0)
     {
-      mhd_gnutls_hash (session->internals.handshake_mac_handle_sha, data,
+      MHD_gnutls_hash (session->internals.handshake_mac_handle_sha, data,
                        siz);
-      mhd_gnutls_hash (session->internals.handshake_mac_handle_md5, data,
+      MHD_gnutls_hash (session->internals.handshake_mac_handle_md5, data,
                        siz);
     }
 
-  mhd_gtls_handshake_buffer_empty (session);
+  MHD_gtls_handshake_buffer_empty (session);
 
   return 0;
 }
@@ -510,7 +510,7 @@ _gnutls_handshake_hash_pending (mhd_gtls_session_t session)
  * we send.
  */
 static int
-_gnutls_send_finished (mhd_gtls_session_t session, int again)
+MHD__gnutls_send_finished (MHD_gtls_session_t session, int again)
 {
   uint8_t data[36];
   int ret;
@@ -523,37 +523,37 @@ _gnutls_send_finished (mhd_gtls_session_t session, int again)
       /* This is needed in order to hash all the required
        * messages.
        */
-      if ((ret = _gnutls_handshake_hash_pending (session)) < 0)
+      if ((ret = MHD__gnutls_handshake_hash_pending (session)) < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
-      if (MHD_gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3)
+      if (MHD__gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3)
         {
           ret =
-            _gnutls_ssl3_finished (session,
+            MHD__gnutls_ssl3_finished (session,
                                    session->security_parameters.entity, data);
           data_size = 36;
         }
       else
         {                       /* TLS 1.0 */
           ret =
-            _gnutls_finished (session,
+            MHD__gnutls_finished (session,
                               session->security_parameters.entity, data);
           data_size = 12;
         }
 
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
     }
 
   ret =
-    mhd_gtls_send_handshake (session, data, data_size,
+    MHD_gtls_send_handshake (session, data, data_size,
                              GNUTLS_HANDSHAKE_FINISHED);
 
   return ret;
@@ -563,7 +563,7 @@ _gnutls_send_finished (mhd_gtls_session_t session, int again)
  * went fine we have negotiated a secure connection
  */
 static int
-_gnutls_recv_finished (mhd_gtls_session_t session)
+MHD__gnutls_recv_finished (MHD_gtls_session_t session)
 {
   uint8_t data[36], *vrfy;
   int data_size;
@@ -571,17 +571,17 @@ _gnutls_recv_finished (mhd_gtls_session_t session)
   int vrfysize;
 
   ret =
-    mhd_gtls_recv_handshake (session, &vrfy, &vrfysize,
+    MHD_gtls_recv_handshake (session, &vrfy, &vrfysize,
                              GNUTLS_HANDSHAKE_FINISHED, MANDATORY_PACKET);
   if (ret < 0)
     {
       ERR ("recv finished int", ret);
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
 
-  if (MHD_gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3)
+  if (MHD__gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3)
     {
       data_size = 36;
     }
@@ -592,39 +592,39 @@ _gnutls_recv_finished (mhd_gtls_session_t session)
 
   if (vrfysize != data_size)
     {
-      gnutls_assert ();
-      gnutls_free (vrfy);
+      MHD_gnutls_assert ();
+      MHD_gnutls_free (vrfy);
       return GNUTLS_E_ERROR_IN_FINISHED_PACKET;
     }
 
-  if (MHD_gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3)
+  if (MHD__gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3)
     {
       ret =
-        _gnutls_ssl3_finished (session,
+        MHD__gnutls_ssl3_finished (session,
                                (session->security_parameters.entity + 1) % 2,
                                data);
     }
   else
     {                           /* TLS 1.0 */
       ret =
-        _gnutls_finished (session,
+        MHD__gnutls_finished (session,
                           (session->security_parameters.entity +
                            1) % 2, data);
     }
 
   if (ret < 0)
     {
-      gnutls_assert ();
-      gnutls_free (vrfy);
+      MHD_gnutls_assert ();
+      MHD_gnutls_free (vrfy);
       return ret;
     }
 
   if (memcmp (vrfy, data, data_size) != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       ret = GNUTLS_E_ERROR_IN_FINISHED_PACKET;
     }
-  gnutls_free (vrfy);
+  MHD_gnutls_free (vrfy);
 
   return ret;
 }
@@ -633,7 +633,7 @@ _gnutls_recv_finished (mhd_gtls_session_t session)
  * RSA algorithms, PK_DSA if DSS, and PK_ANY for both or PK_NONE for none.
  */
 static int
-_gnutls_server_find_pk_algos_in_ciphersuites (const opaque *
+MHD__gnutls_server_find_pk_algos_in_ciphersuites (const opaque *
                                               data, int datalen)
 {
   int j;
@@ -643,18 +643,18 @@ _gnutls_server_find_pk_algos_in_ciphersuites (const opaque *
 
   if (datalen % 2 != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
     }
 
   for (j = 0; j < datalen; j += 2)
     {
       memcpy (&cs.suite, &data[j], 2);
-      kx = mhd_gtls_cipher_suite_get_kx_algo (&cs);
+      kx = MHD_gtls_cipher_suite_get_kx_algo (&cs);
 
-      if (mhd_gtls_map_kx_get_cred (kx, 1) == MHD_GNUTLS_CRD_CERTIFICATE)
+      if (MHD_gtls_map_kx_get_cred (kx, 1) == MHD_GNUTLS_CRD_CERTIFICATE)
         {
-          algo = mhd_gtls_map_pk_get_pk (kx);
+          algo = MHD_gtls_map_pk_get_pk (kx);
 
           if (algo != prev_algo && prev_algo != 0)
             return GNUTLS_PK_ANY;
@@ -670,7 +670,7 @@ _gnutls_server_find_pk_algos_in_ciphersuites (const opaque *
  * it adds the suite to the session and performs some checks.
  */
 int
-mhd_gtls_server_select_suite (mhd_gtls_session_t session, opaque * data,
+MHD_gtls_server_select_suite (MHD_gtls_session_t session, opaque * data,
                               int datalen)
 {
   int x, i, j;
@@ -680,12 +680,12 @@ mhd_gtls_server_select_suite (mhd_gtls_session_t session, opaque * data,
                                                  * supported by the peer.
                                                  */
 
-  pk_algo = _gnutls_server_find_pk_algos_in_ciphersuites (data, datalen);
+  pk_algo = MHD__gnutls_server_find_pk_algos_in_ciphersuites (data, datalen);
 
-  x = mhd_gtls_supported_ciphersuites (session, &ciphers);
+  x = MHD_gtls_supported_ciphersuites (session, &ciphers);
   if (x < 0)
     {                           /* the case x==0 is handled within the function. */
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return x;
     }
 
@@ -693,11 +693,11 @@ mhd_gtls_server_select_suite (mhd_gtls_session_t session, opaque * data,
    * the certificate requested, or to the
    * authentication requested (e.g. SRP).
    */
-  x = mhd_gtls_remove_unwanted_ciphersuites (session, &ciphers, x, pk_algo);
+  x = MHD_gtls_remove_unwanted_ciphersuites (session, &ciphers, x, pk_algo);
   if (x <= 0)
     {
-      gnutls_assert ();
-      gnutls_free (ciphers);
+      MHD_gnutls_assert ();
+      MHD_gnutls_free (ciphers);
       if (x < 0)
         return x;
       else
@@ -710,21 +710,21 @@ mhd_gtls_server_select_suite (mhd_gtls_session_t session, opaque * data,
    */
   if (datalen % 2 != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
     }
 #ifdef HANDSHAKE_DEBUG
 
-  _gnutls_handshake_log ("HSK[%x]: Requested cipher suites: \n", session);
+  MHD__gnutls_handshake_log ("HSK[%x]: Requested cipher suites: \n", session);
   for (j = 0; j < datalen; j += 2)
     {
       memcpy (&cs.suite, &data[j], 2);
-      _gnutls_handshake_log ("\t%s\n", mhd_gtls_cipher_suite_get_name (&cs));
+      MHD__gnutls_handshake_log ("\t%s\n", MHD_gtls_cipher_suite_get_name (&cs));
     }
-  _gnutls_handshake_log ("HSK[%x]: Supported cipher suites: \n", session);
+  MHD__gnutls_handshake_log ("HSK[%x]: Supported cipher suites: \n", session);
   for (j = 0; j < x; j++)
-    _gnutls_handshake_log ("\t%s\n",
-                           mhd_gtls_cipher_suite_get_name (&ciphers[j]));
+    MHD__gnutls_handshake_log ("\t%s\n",
+                           MHD_gtls_cipher_suite_get_name (&ciphers[j]));
 #endif
   memset (session->security_parameters.current_cipher_suite.suite, '\0', 2);
 
@@ -738,9 +738,9 @@ mhd_gtls_server_select_suite (mhd_gtls_session_t session, opaque * data,
             {
               memcpy (&cs.suite, &data[j], 2);
 
-              _gnutls_handshake_log
+              MHD__gnutls_handshake_log
                 ("HSK[%x]: Selected cipher suite: %s\n", session,
-                 mhd_gtls_cipher_suite_get_name (&cs));
+                 MHD_gtls_cipher_suite_get_name (&cs));
               memcpy (session->security_parameters.current_cipher_suite.suite,
                       ciphers[i].suite, 2);
               retval = 0;
@@ -750,42 +750,42 @@ mhd_gtls_server_select_suite (mhd_gtls_session_t session, opaque * data,
     }
 
 finish:
-  gnutls_free (ciphers);
+  MHD_gnutls_free (ciphers);
 
   if (retval != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return retval;
     }
 
   /* check if the credentials (username, public key etc.) are ok
    */
-  if (mhd_gtls_get_kx_cred
+  if (MHD_gtls_get_kx_cred
       (session,
-       mhd_gtls_cipher_suite_get_kx_algo (&session->security_parameters.
+       MHD_gtls_cipher_suite_get_kx_algo (&session->security_parameters.
                                           current_cipher_suite), &err) == NULL
       && err != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
     }
 
 
-  /* set the mhd_gtls_mod_auth_st to the appropriate struct
+  /* set the MHD_gtls_mod_auth_st to the appropriate struct
    * according to the KX algorithm. This is needed since all the
    * handshake functions are read from there;
    */
   session->internals.auth_struct =
-    mhd_gtls_kx_auth_struct (mhd_gtls_cipher_suite_get_kx_algo
+    MHD_gtls_kx_auth_struct (MHD_gtls_cipher_suite_get_kx_algo
                              (&session->security_parameters.
                               current_cipher_suite));
   if (session->internals.auth_struct == NULL)
     {
 
-      _gnutls_handshake_log
+      MHD__gnutls_handshake_log
         ("HSK[%x]: Cannot find the appropriate handler for the KX algorithm\n",
          session);
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
@@ -797,16 +797,16 @@ finish:
 /* This selects the best supported compression method from the ones provided
  */
 static int
-_gnutls_server_select_comp_method (mhd_gtls_session_t session,
+MHD__gnutls_server_select_comp_method (MHD_gtls_session_t session,
                                    opaque * data, int datalen)
 {
   int x, i, j;
   uint8_t *comps;
 
-  x = mhd_gtls_supported_compression_methods (session, &comps);
+  x = MHD_gtls_supported_compression_methods (session, &comps);
   if (x < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return x;
     }
 
@@ -820,12 +820,12 @@ _gnutls_server_select_comp_method (mhd_gtls_session_t session,
           if (comps[i] == data[j])
             {
               enum MHD_GNUTLS_CompressionMethod method =
-                mhd_gtls_compression_get_id (comps[i]);
+                MHD_gtls_compression_get_id_from_int (comps[i]);
 
               session->internals.compression_method = method;
-              gnutls_free (comps);
+              MHD_gnutls_free (comps);
 
-              _gnutls_handshake_log
+              MHD__gnutls_handshake_log
                 ("HSK[%x]: Selected Compression Method: %s\n", session,
                  MHD_gtls_compression_get_name (session->internals.
                                                   compression_method));
@@ -839,20 +839,20 @@ _gnutls_server_select_comp_method (mhd_gtls_session_t session,
   /* we were not able to find a compatible compression
    * algorithm
    */
-  gnutls_free (comps);
-  gnutls_assert ();
+  MHD_gnutls_free (comps);
+  MHD_gnutls_assert ();
   return GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM;
 
 }
 
 /* This function sends an empty handshake packet. (like hello request).
- * If the previous _gnutls_send_empty_handshake() returned
+ * If the previous MHD__gnutls_send_empty_handshake() returned
  * GNUTLS_E_AGAIN or GNUTLS_E_INTERRUPTED, then it must be called again
  * (until it returns ok), with NULL parameters.
  */
 static int
-_gnutls_send_empty_handshake (mhd_gtls_session_t session,
-                              gnutls_handshake_description_t type, int again)
+MHD__gnutls_send_empty_handshake (MHD_gtls_session_t session,
+                              MHD_gnutls_handshake_description_t type, int again)
 {
   opaque data = 0;
   opaque *ptr;
@@ -862,29 +862,29 @@ _gnutls_send_empty_handshake (mhd_gtls_session_t session,
   else
     ptr = NULL;
 
-  return mhd_gtls_send_handshake (session, ptr, 0, type);
+  return MHD_gtls_send_handshake (session, ptr, 0, type);
 }
 
 
 /* This function will hash the handshake message we sent. */
 static int
-_gnutls_handshake_hash_add_sent (mhd_gtls_session_t session,
-                                 gnutls_handshake_description_t type,
+MHD__gnutls_handshake_hash_add_sent (MHD_gtls_session_t session,
+                                 MHD_gnutls_handshake_description_t type,
                                  opaque * dataptr, uint32_t datalen)
 {
   int ret;
 
-  if ((ret = _gnutls_handshake_hash_pending (session)) < 0)
+  if ((ret = MHD__gnutls_handshake_hash_pending (session)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
   if (type != GNUTLS_HANDSHAKE_HELLO_REQUEST)
     {
-      mhd_gnutls_hash (session->internals.handshake_mac_handle_sha, dataptr,
+      MHD_gnutls_hash (session->internals.handshake_mac_handle_sha, dataptr,
                        datalen);
-      mhd_gnutls_hash (session->internals.handshake_mac_handle_md5, dataptr,
+      MHD_gnutls_hash (session->internals.handshake_mac_handle_md5, dataptr,
                        datalen);
     }
 
@@ -893,14 +893,14 @@ _gnutls_handshake_hash_add_sent (mhd_gtls_session_t session,
 
 
 /* This function sends a handshake message of type 'type' containing the
- * data specified here. If the previous mhd_gtls_send_handshake() returned
+ * data specified here. If the previous MHD_gtls_send_handshake() returned
  * GNUTLS_E_AGAIN or GNUTLS_E_INTERRUPTED, then it must be called again
  * (until it returns ok), with NULL parameters.
  */
 int
-mhd_gtls_send_handshake (mhd_gtls_session_t session, void *i_data,
+MHD_gtls_send_handshake (MHD_gtls_session_t session, void *i_data,
                          uint32_t i_datasize,
-                         gnutls_handshake_description_t type)
+                         MHD_gnutls_handshake_description_t type)
 {
   int ret;
   uint8_t *data;
@@ -912,28 +912,28 @@ mhd_gtls_send_handshake (mhd_gtls_session_t session, void *i_data,
       /* we are resuming a previously interrupted
        * send.
        */
-      ret = mhd_gtls_handshake_io_write_flush (session);
+      ret = MHD_gtls_handshake_io_write_flush (session);
       return ret;
 
     }
 
   if (i_data == NULL && i_datasize > 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   /* first run */
   datasize = i_datasize + HANDSHAKE_HEADER_SIZE;
-  data = gnutls_alloca (datasize);
+  data = MHD_gnutls_alloca (datasize);
   if (data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
   data[pos++] = (uint8_t) type;
-  mhd_gtls_write_uint24 (i_datasize, &data[pos]);
+  MHD_gtls_write_uint24 (i_datasize, &data[pos]);
   pos += 3;
 
   if (i_datasize > 0)
@@ -943,23 +943,23 @@ mhd_gtls_send_handshake (mhd_gtls_session_t session, void *i_data,
    */
   if (type != GNUTLS_HANDSHAKE_HELLO_REQUEST)
     if ((ret =
-         _gnutls_handshake_hash_add_sent (session, type, data, datasize)) < 0)
+         MHD__gnutls_handshake_hash_add_sent (session, type, data, datasize)) < 0)
       {
-        gnutls_assert ();
-        gnutls_afree (data);
+        MHD_gnutls_assert ();
+        MHD_gnutls_afree (data);
         return ret;
       }
 
   session->internals.last_handshake_out = type;
 
   ret =
-    mhd_gtls_handshake_io_send_int (session, GNUTLS_HANDSHAKE, type,
+    MHD_gtls_handshake_io_send_int (session, GNUTLS_HANDSHAKE, type,
                                     data, datasize);
 
-  _gnutls_handshake_log ("HSK[%x]: %s was sent [%ld bytes]\n",
-                         session, _gnutls_handshake2str (type), datasize);
+  MHD__gnutls_handshake_log ("HSK[%x]: %s was sent [%ld bytes]\n",
+                         session, MHD__gnutls_handshake2str (type), datasize);
 
-  gnutls_afree (data);
+  MHD_gnutls_afree (data);
 
   return ret;
 }
@@ -972,9 +972,9 @@ mhd_gtls_send_handshake (mhd_gtls_session_t session, void *i_data,
  */
 #define SSL2_HEADERS 1
 static int
-_gnutls_recv_handshake_header (mhd_gtls_session_t session,
-                               gnutls_handshake_description_t type,
-                               gnutls_handshake_description_t * recv_type)
+MHD__gnutls_recv_handshake_header (MHD_gtls_session_t session,
+                               MHD_gnutls_handshake_description_t type,
+                               MHD_gnutls_handshake_description_t * recv_type)
 {
   int ret;
   uint32_t length32 = 0;
@@ -1006,12 +1006,12 @@ _gnutls_recv_handshake_header (mhd_gtls_session_t session,
   if (session->internals.handshake_header_buffer.header_size < SSL2_HEADERS)
     {
       ret =
-        mhd_gtls_handshake_io_recv_int (session, GNUTLS_HANDSHAKE,
+        MHD_gtls_handshake_io_recv_int (session, GNUTLS_HANDSHAKE,
                                         type, dataptr, SSL2_HEADERS);
 
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
@@ -1019,7 +1019,7 @@ _gnutls_recv_handshake_header (mhd_gtls_session_t session,
        */
       if (ret != SSL2_HEADERS)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
         }
       session->internals.handshake_header_buffer.header_size = SSL2_HEADERS;
@@ -1029,7 +1029,7 @@ _gnutls_recv_handshake_header (mhd_gtls_session_t session,
       || type != GNUTLS_HANDSHAKE_CLIENT_HELLO)
     {
       ret =
-        mhd_gtls_handshake_io_recv_int (session, GNUTLS_HANDSHAKE,
+        MHD_gtls_handshake_io_recv_int (session, GNUTLS_HANDSHAKE,
                                         type,
                                         &dataptr
                                         [session->internals.
@@ -1039,14 +1039,14 @@ _gnutls_recv_handshake_header (mhd_gtls_session_t session,
                                         handshake_header_buffer.header_size);
       if (ret <= 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return (ret < 0) ? ret : GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
         }
       if ((size_t) ret !=
           HANDSHAKE_HEADER_SIZE -
           session->internals.handshake_header_buffer.header_size)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
         }
       *recv_type = dataptr[0];
@@ -1054,11 +1054,11 @@ _gnutls_recv_handshake_header (mhd_gtls_session_t session,
       /* we do not use DECR_LEN because we know
        * that the packet has enough data.
        */
-      length32 = mhd_gtls_read_uint24 (&dataptr[1]);
+      length32 = MHD_gtls_read_uint24 (&dataptr[1]);
       handshake_header_size = HANDSHAKE_HEADER_SIZE;
 
-      _gnutls_handshake_log ("HSK[%x]: %s was received [%ld bytes]\n",
-                             session, _gnutls_handshake2str (dataptr[0]),
+      MHD__gnutls_handshake_log ("HSK[%x]: %s was received [%ld bytes]\n",
+                             session, MHD__gnutls_handshake2str (dataptr[0]),
                              length32 + HANDSHAKE_HEADER_SIZE);
 
     }
@@ -1070,13 +1070,13 @@ _gnutls_recv_handshake_header (mhd_gtls_session_t session,
 
       *recv_type = dataptr[0];
 
-      _gnutls_handshake_log ("HSK[%x]: %s(v2) was received [%ld bytes]\n",
-                             session, _gnutls_handshake2str (*recv_type),
+      MHD__gnutls_handshake_log ("HSK[%x]: %s(v2) was received [%ld bytes]\n",
+                             session, MHD__gnutls_handshake2str (*recv_type),
                              length32 + handshake_header_size);
 
       if (*recv_type != GNUTLS_HANDSHAKE_CLIENT_HELLO)
         {                       /* it should be one or nothing */
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_UNEXPECTED_HANDSHAKE_PACKET;
         }
     }
@@ -1089,21 +1089,21 @@ _gnutls_recv_handshake_header (mhd_gtls_session_t session,
 
   if (*recv_type != type)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNEXPECTED_HANDSHAKE_PACKET;
     }
 
   return length32;
 }
 
-#define _gnutls_handshake_header_buffer_clear( session) session->internals.handshake_header_buffer.header_size = 0
+#define MHD__gnutls_handshake_header_buffer_clear( session) session->internals.handshake_header_buffer.header_size = 0
 
 /* This function will hash the handshake headers and the
  * handshake data.
  */
 static int
-_gnutls_handshake_hash_add_recvd (mhd_gtls_session_t session,
-                                  gnutls_handshake_description_t recv_type,
+MHD__gnutls_handshake_hash_add_recvd (MHD_gtls_session_t session,
+                                  MHD_gnutls_handshake_description_t recv_type,
                                   opaque * header, uint16_t header_size,
                                   opaque * dataptr, uint32_t datalen)
 {
@@ -1113,9 +1113,9 @@ _gnutls_handshake_hash_add_recvd (mhd_gtls_session_t session,
    * and add the one we just received into the handshake_hash_buffer.
    */
 
-  if ((ret = _gnutls_handshake_hash_pending (session)) < 0)
+  if ((ret = MHD__gnutls_handshake_hash_pending (session)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -1124,18 +1124,18 @@ _gnutls_handshake_hash_add_recvd (mhd_gtls_session_t session,
     {
 
       if ((ret =
-           mhd_gtls_handshake_buffer_put (session, header, header_size)) < 0)
+           MHD_gtls_handshake_buffer_put (session, header, header_size)) < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
       if (datalen > 0)
         {
           if ((ret =
-               mhd_gtls_handshake_buffer_put (session, dataptr, datalen)) < 0)
+               MHD_gtls_handshake_buffer_put (session, dataptr, datalen)) < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return ret;
             }
         }
@@ -1147,19 +1147,19 @@ _gnutls_handshake_hash_add_recvd (mhd_gtls_session_t session,
 /* This function will receive handshake messages of the given types,
  * and will pass the message to the right place in order to be processed.
  * E.g. for the SERVER_HELLO message (if it is expected), it will be
- * passed to mhd_gtls_recv_hello().
+ * passed to MHD_gtls_recv_hello().
  */
 int
-mhd_gtls_recv_handshake (mhd_gtls_session_t session, uint8_t ** data,
-                         int *datalen, gnutls_handshake_description_t type,
+MHD_gtls_recv_handshake (MHD_gtls_session_t session, uint8_t ** data,
+                         int *datalen, MHD_gnutls_handshake_description_t type,
                          Optional optional)
 {
   int ret;
   uint32_t length32 = 0;
   opaque *dataptr = NULL;
-  gnutls_handshake_description_t recv_type;
+  MHD_gnutls_handshake_description_t recv_type;
 
-  ret = _gnutls_recv_handshake_header (session, type, &recv_type);
+  ret = MHD__gnutls_recv_handshake_header (session, type, &recv_type);
   if (ret < 0)
     {
 
@@ -1181,16 +1181,16 @@ mhd_gtls_recv_handshake (mhd_gtls_session_t session, uint8_t ** data,
   length32 = ret;
 
   if (length32 > 0)
-    dataptr = gnutls_malloc (length32);
+    dataptr = MHD_gnutls_malloc (length32);
   else if (recv_type != GNUTLS_HANDSHAKE_SERVER_HELLO_DONE)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
     }
 
   if (dataptr == NULL && length32 > 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
@@ -1200,12 +1200,12 @@ mhd_gtls_recv_handshake (mhd_gtls_session_t session, uint8_t ** data,
   if (length32 > 0)
     {
       ret =
-        mhd_gtls_handshake_io_recv_int (session, GNUTLS_HANDSHAKE,
+        MHD_gtls_handshake_io_recv_int (session, GNUTLS_HANDSHAKE,
                                         type, dataptr, length32);
       if (ret <= 0)
         {
-          gnutls_assert ();
-          gnutls_free (dataptr);
+          MHD_gnutls_assert ();
+          MHD_gnutls_free (dataptr);
           return (ret == 0) ? GNUTLS_E_UNEXPECTED_PACKET_LENGTH : ret;
         }
     }
@@ -1214,7 +1214,7 @@ mhd_gtls_recv_handshake (mhd_gtls_session_t session, uint8_t ** data,
     *data = dataptr;
 
 
-  ret = _gnutls_handshake_hash_add_recvd (session, recv_type,
+  ret = MHD__gnutls_handshake_hash_add_recvd (session, recv_type,
                                           session->internals.
                                           handshake_header_buffer.header,
                                           session->internals.
@@ -1222,8 +1222,8 @@ mhd_gtls_recv_handshake (mhd_gtls_session_t session, uint8_t ** data,
                                           dataptr, length32);
   if (ret < 0)
     {
-      gnutls_assert ();
-      _gnutls_handshake_header_buffer_clear (session);
+      MHD_gnutls_assert ();
+      MHD__gnutls_handshake_header_buffer_clear (session);
       return ret;
     }
 
@@ -1231,16 +1231,16 @@ mhd_gtls_recv_handshake (mhd_gtls_session_t session, uint8_t ** data,
    * have have received above. if we get here the we clear the handshake
    * header we received.
    */
-  _gnutls_handshake_header_buffer_clear (session);
+  MHD__gnutls_handshake_header_buffer_clear (session);
 
   switch (recv_type)
     {
     case GNUTLS_HANDSHAKE_CLIENT_HELLO:
     case GNUTLS_HANDSHAKE_SERVER_HELLO:
-      ret = mhd_gtls_recv_hello (session, dataptr, length32);
+      ret = MHD_gtls_recv_hello (session, dataptr, length32);
       /* dataptr is freed because the caller does not
        * need it */
-      gnutls_free (dataptr);
+      MHD_gnutls_free (dataptr);
       if (data != NULL)
         *data = NULL;
       break;
@@ -1260,8 +1260,8 @@ mhd_gtls_recv_handshake (mhd_gtls_session_t session, uint8_t ** data,
       ret = length32;
       break;
     default:
-      gnutls_assert ();
-      gnutls_free (dataptr);
+      MHD_gnutls_assert ();
+      MHD_gnutls_free (dataptr);
       if (data != NULL)
         *data = NULL;
       ret = GNUTLS_E_UNEXPECTED_HANDSHAKE_PACKET;
@@ -1274,7 +1274,7 @@ mhd_gtls_recv_handshake (mhd_gtls_session_t session, uint8_t ** data,
  * to the session;
  */
 static int
-_gnutls_client_set_ciphersuite (mhd_gtls_session_t session, opaque suite[2])
+MHD__gnutls_client_set_ciphersuite (MHD_gtls_session_t session, opaque suite[2])
 {
   uint8_t z;
   cipher_suite_st *cipher_suites;
@@ -1283,10 +1283,10 @@ _gnutls_client_set_ciphersuite (mhd_gtls_session_t session, opaque suite[2])
 
   z = 1;
   cipher_suite_num =
-    mhd_gtls_supported_ciphersuites (session, &cipher_suites);
+    MHD_gtls_supported_ciphersuites (session, &cipher_suites);
   if (cipher_suite_num < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return cipher_suite_num;
     }
 
@@ -1299,18 +1299,18 @@ _gnutls_client_set_ciphersuite (mhd_gtls_session_t session, opaque suite[2])
         }
     }
 
-  gnutls_free (cipher_suites);
+  MHD_gnutls_free (cipher_suites);
 
   if (z != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNKNOWN_CIPHER_SUITE;
     }
 
   memcpy (session->security_parameters.current_cipher_suite.suite, suite, 2);
 
-  _gnutls_handshake_log ("HSK[%x]: Selected cipher suite: %s\n", session,
-                         mhd_gtls_cipher_suite_get_name
+  MHD__gnutls_handshake_log ("HSK[%x]: Selected cipher suite: %s\n", session,
+                         MHD_gtls_cipher_suite_get_name
                          (&session->security_parameters.
                           current_cipher_suite));
 
@@ -1318,33 +1318,33 @@ _gnutls_client_set_ciphersuite (mhd_gtls_session_t session, opaque suite[2])
   /* check if the credentials (username, public key etc.) are ok.
    * Actually checks if they exist.
    */
-  if (mhd_gtls_get_kx_cred
+  if (MHD_gtls_get_kx_cred
       (session,
-       mhd_gtls_cipher_suite_get_kx_algo
+       MHD_gtls_cipher_suite_get_kx_algo
        (&session->security_parameters.current_cipher_suite), &err) == NULL
       && err != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
     }
 
 
-  /* set the mhd_gtls_mod_auth_st to the appropriate struct
+  /* set the MHD_gtls_mod_auth_st to the appropriate struct
    * according to the KX algorithm. This is needed since all the
    * handshake functions are read from there;
    */
   session->internals.auth_struct =
-    mhd_gtls_kx_auth_struct (mhd_gtls_cipher_suite_get_kx_algo
+    MHD_gtls_kx_auth_struct (MHD_gtls_cipher_suite_get_kx_algo
                              (&session->security_parameters.
                               current_cipher_suite));
 
   if (session->internals.auth_struct == NULL)
     {
 
-      _gnutls_handshake_log
+      MHD__gnutls_handshake_log
         ("HSK[%x]: Cannot find the appropriate handler for the KX algorithm\n",
          session);
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
@@ -1355,18 +1355,18 @@ _gnutls_client_set_ciphersuite (mhd_gtls_session_t session, opaque suite[2])
 /* This function sets the given comp method to the session.
  */
 static int
-_gnutls_client_set_comp_method (mhd_gtls_session_t session,
+MHD__gnutls_client_set_comp_method (MHD_gtls_session_t session,
                                 opaque comp_method)
 {
   int comp_methods_num;
   uint8_t *compression_methods;
   int i;
 
-  comp_methods_num = mhd_gtls_supported_compression_methods (session,
+  comp_methods_num = MHD_gtls_supported_compression_methods (session,
                                                              &compression_methods);
   if (comp_methods_num < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return comp_methods_num;
     }
 
@@ -1379,16 +1379,16 @@ _gnutls_client_set_comp_method (mhd_gtls_session_t session,
         }
     }
 
-  gnutls_free (compression_methods);
+  MHD_gnutls_free (compression_methods);
 
   if (comp_methods_num != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM;
     }
 
   session->internals.compression_method =
-    mhd_gtls_compression_get_id (comp_method);
+    MHD_gtls_compression_get_id_from_int (comp_method);
 
 
   return 0;
@@ -1399,15 +1399,15 @@ _gnutls_client_set_comp_method (mhd_gtls_session_t session,
  * hello.
  */
 static int
-_gnutls_client_check_if_resuming (mhd_gtls_session_t session,
+MHD__gnutls_client_check_if_resuming (MHD_gtls_session_t session,
                                   opaque * session_id, int session_id_len)
 {
   opaque buf[2 * TLS_MAX_SESSION_ID_SIZE + 1];
 
-  _gnutls_handshake_log ("HSK[%x]: SessionID length: %d\n", session,
+  MHD__gnutls_handshake_log ("HSK[%x]: SessionID length: %d\n", session,
                          session_id_len);
-  _gnutls_handshake_log ("HSK[%x]: SessionID: %s\n", session,
-                         mhd_gtls_bin2hex (session_id, session_id_len, buf,
+  MHD__gnutls_handshake_log ("HSK[%x]: SessionID: %s\n", session,
+                         MHD_gtls_bin2hex (session_id, session_id_len, buf,
                                            sizeof (buf)));
 
   if (session_id_len > 0 &&
@@ -1444,7 +1444,7 @@ _gnutls_client_check_if_resuming (mhd_gtls_session_t session,
  * session.
  */
 static int
-_gnutls_read_server_hello (mhd_gtls_session_t session,
+MHD__gnutls_read_server_hello (MHD_gtls_session_t session,
                            opaque * data, int datalen)
 {
   uint8_t session_id_len = 0;
@@ -1455,29 +1455,29 @@ _gnutls_read_server_hello (mhd_gtls_session_t session,
 
   if (datalen < 38)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
     }
 
-  _gnutls_handshake_log ("HSK[%x]: Server's version: %d.%d\n",
+  MHD__gnutls_handshake_log ("HSK[%x]: Server's version: %d.%d\n",
                          session, data[pos], data[pos + 1]);
 
   DECR_LEN (len, 2);
-  version = mhd_gtls_version_get (data[pos], data[pos + 1]);
-  if (mhd_gtls_version_is_supported (session, version) == 0)
+  version = MHD_gtls_version_get (data[pos], data[pos + 1]);
+  if (MHD_gtls_version_is_supported (session, version) == 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNSUPPORTED_VERSION_PACKET;
     }
   else
     {
-      mhd_gtls_set_current_version (session, version);
+      MHD_gtls_set_current_version (session, version);
     }
 
   pos += 2;
 
   DECR_LEN (len, TLS_RANDOM_SIZE);
-  mhd_gtls_set_server_random (session, &data[pos]);
+  MHD_gtls_set_server_random (session, &data[pos]);
   pos += TLS_RANDOM_SIZE;
 
 
@@ -1488,7 +1488,7 @@ _gnutls_read_server_hello (mhd_gtls_session_t session,
 
   if (len < session_id_len)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNSUPPORTED_VERSION_PACKET;
     }
   DECR_LEN (len, session_id_len);
@@ -1497,7 +1497,7 @@ _gnutls_read_server_hello (mhd_gtls_session_t session,
   /* check if we are resuming and set the appropriate
    * values;
    */
-  if (_gnutls_client_check_if_resuming
+  if (MHD__gnutls_client_check_if_resuming
       (session, &data[pos], session_id_len) == 0)
     return 0;
   pos += session_id_len;
@@ -1508,10 +1508,10 @@ _gnutls_read_server_hello (mhd_gtls_session_t session,
    */
 
   DECR_LEN (len, 2);
-  ret = _gnutls_client_set_ciphersuite (session, &data[pos]);
+  ret = MHD__gnutls_client_set_ciphersuite (session, &data[pos]);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
   pos += 2;
@@ -1521,10 +1521,10 @@ _gnutls_read_server_hello (mhd_gtls_session_t session,
   /* move to compression   */
   DECR_LEN (len, 1);
 
-  ret = _gnutls_client_set_comp_method (session, data[pos++]);
+  ret = MHD__gnutls_client_set_comp_method (session, data[pos++]);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNKNOWN_COMPRESSION_ALGORITHM;
     }
 
@@ -1532,10 +1532,10 @@ _gnutls_read_server_hello (mhd_gtls_session_t session,
    */
   if (version >= MHD_GNUTLS_PROTOCOL_TLS1_0)
     {
-      ret = mhd_gtls_parse_extensions (session, EXTENSION_ANY, &data[pos], len);        /* len is the rest of the parsed length */
+      ret = MHD_gtls_parse_extensions (session, EXTENSION_ANY, &data[pos], len);        /* len is the rest of the parsed length */
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
     }
@@ -1547,7 +1547,7 @@ _gnutls_read_server_hello (mhd_gtls_session_t session,
  * Needed in client hello messages. Returns the new data length.
  */
 static int
-_gnutls_copy_ciphersuites (mhd_gtls_session_t session,
+MHD__gnutls_copy_ciphersuites (MHD_gtls_session_t session,
                            opaque * ret_data, size_t ret_data_size)
 {
   int ret, i;
@@ -1555,10 +1555,10 @@ _gnutls_copy_ciphersuites (mhd_gtls_session_t session,
   uint16_t cipher_num;
   int datalen, pos;
 
-  ret = mhd_gtls_supported_ciphersuites_sorted (session, &cipher_suites);
+  ret = MHD_gtls_supported_ciphersuites_sorted (session, &cipher_suites);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -1567,11 +1567,11 @@ _gnutls_copy_ciphersuites (mhd_gtls_session_t session,
    * authentication requested (eg SRP).
    */
   ret =
-    mhd_gtls_remove_unwanted_ciphersuites (session, &cipher_suites, ret, -1);
+    MHD_gtls_remove_unwanted_ciphersuites (session, &cipher_suites, ret, -1);
   if (ret < 0)
     {
-      gnutls_assert ();
-      gnutls_free (cipher_suites);
+      MHD_gnutls_assert ();
+      MHD_gnutls_free (cipher_suites);
       return ret;
     }
 
@@ -1579,8 +1579,8 @@ _gnutls_copy_ciphersuites (mhd_gtls_session_t session,
    */
   if (ret == 0)
     {
-      gnutls_assert ();
-      gnutls_free (cipher_suites);
+      MHD_gnutls_assert ();
+      MHD_gnutls_free (cipher_suites);
       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
     }
 
@@ -1594,11 +1594,11 @@ _gnutls_copy_ciphersuites (mhd_gtls_session_t session,
 
   if ((size_t) datalen > ret_data_size)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
-  mhd_gtls_write_uint16 (cipher_num, ret_data);
+  MHD_gtls_write_uint16 (cipher_num, ret_data);
   pos += 2;
 
   for (i = 0; i < (cipher_num / 2); i++)
@@ -1606,7 +1606,7 @@ _gnutls_copy_ciphersuites (mhd_gtls_session_t session,
       memcpy (&ret_data[pos], cipher_suites[i].suite, 2);
       pos += 2;
     }
-  gnutls_free (cipher_suites);
+  MHD_gnutls_free (cipher_suites);
 
   return datalen;
 }
@@ -1615,7 +1615,7 @@ _gnutls_copy_ciphersuites (mhd_gtls_session_t session,
  * Needed in hello messages. Returns the new data length.
  */
 static int
-_gnutls_copy_comp_methods (mhd_gtls_session_t session,
+MHD__gnutls_copy_comp_methods (MHD_gtls_session_t session,
                            opaque * ret_data, size_t ret_data_size)
 {
   int ret, i;
@@ -1623,10 +1623,10 @@ _gnutls_copy_comp_methods (mhd_gtls_session_t session,
   int datalen, pos;
 
   ret =
-    mhd_gtls_supported_compression_methods (session, &compression_methods);
+    MHD_gtls_supported_compression_methods (session, &compression_methods);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -1637,7 +1637,7 @@ _gnutls_copy_comp_methods (mhd_gtls_session_t session,
 
   if ((size_t) datalen > ret_data_size)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
@@ -1648,7 +1648,7 @@ _gnutls_copy_comp_methods (mhd_gtls_session_t session,
       ret_data[pos++] = compression_methods[i];
     }
 
-  gnutls_free (compression_methods);
+  MHD_gnutls_free (compression_methods);
 
   return datalen;
 }
@@ -1662,7 +1662,7 @@ _gnutls_copy_comp_methods (mhd_gtls_session_t session,
 /* This function sends the client hello handshake message.
  */
 static int
-_gnutls_send_client_hello (mhd_gtls_session_t session, int again)
+MHD__gnutls_send_client_hello (MHD_gtls_session_t session, int again)
 {
   opaque *data = NULL;
   int extdatalen;
@@ -1689,10 +1689,10 @@ _gnutls_send_client_hello (mhd_gtls_session_t session, int again)
       /* 2 for version, (4 for unix time + 28 for random bytes==TLS_RANDOM_SIZE)
        */
 
-      data = gnutls_malloc (datalen);
+      data = MHD_gnutls_malloc (datalen);
       if (data == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_MEMORY_ERROR;
         }
 
@@ -1700,7 +1700,7 @@ _gnutls_send_client_hello (mhd_gtls_session_t session, int again)
        * version number to the previously established.
        */
       if (SessionID == NULL)
-        hver = mhd_gtls_version_max (session);
+        hver = MHD_gtls_version_max (session);
       else
         {                       /* we are resuming a session */
           hver = session->internals.resumed_security_parameters.version;
@@ -1708,18 +1708,18 @@ _gnutls_send_client_hello (mhd_gtls_session_t session, int again)
 
       if (hver == MHD_GNUTLS_PROTOCOL_VERSION_UNKNOWN || hver == 0)
         {
-          gnutls_assert ();
-          gnutls_free (data);
+          MHD_gnutls_assert ();
+          MHD_gnutls_free (data);
           return GNUTLS_E_INTERNAL_ERROR;
         }
 
-      data[pos++] = mhd_gtls_version_get_major (hver);
-      data[pos++] = mhd_gtls_version_get_minor (hver);
+      data[pos++] = MHD_gtls_version_get_major (hver);
+      data[pos++] = MHD_gtls_version_get_minor (hver);
 
       /* Set the version we advertized as maximum
        * (RSA uses it).
        */
-      mhd_gtls_set_adv_version (session, hver);
+      MHD_gtls_set_adv_version (session, hver);
 
       /* Some old implementations do not interoperate if we send a
        * different version in the record layer.
@@ -1729,7 +1729,7 @@ _gnutls_send_client_hello (mhd_gtls_session_t session, int again)
        * handshake packet and ignore the one in the packet's record
        * header.
        */
-      mhd_gtls_set_current_version (session, hver);
+      MHD_gtls_set_current_version (session, hver);
 
       /* In order to know when this session was initiated.
        */
@@ -1737,8 +1737,8 @@ _gnutls_send_client_hello (mhd_gtls_session_t session, int again)
 
       /* Generate random data
        */
-      mhd_gtls_tls_create_random (rnd);
-      mhd_gtls_set_client_random (session, rnd);
+      MHD_gtls_tls_create_random (rnd);
+      MHD_gtls_set_client_random (session, rnd);
 
       memcpy (&data[pos], rnd, TLS_RANDOM_SIZE);
       pos += TLS_RANDOM_SIZE;
@@ -1756,14 +1756,14 @@ _gnutls_send_client_hello (mhd_gtls_session_t session, int again)
       /* Copy the ciphersuites.
        */
       extdatalen =
-        _gnutls_copy_ciphersuites (session, extdata, sizeof (extdata));
+        MHD__gnutls_copy_ciphersuites (session, extdata, sizeof (extdata));
       if (extdatalen > 0)
         {
           datalen += extdatalen;
-          data = mhd_gtls_realloc_fast (data, datalen);
+          data = MHD_gtls_realloc_fast (data, datalen);
           if (data == NULL)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return GNUTLS_E_MEMORY_ERROR;
             }
 
@@ -1775,8 +1775,8 @@ _gnutls_send_client_hello (mhd_gtls_session_t session, int again)
         {
           if (extdatalen == 0)
             extdatalen = GNUTLS_E_INTERNAL_ERROR;
-          gnutls_free (data);
-          gnutls_assert ();
+          MHD_gnutls_free (data);
+          MHD_gnutls_assert ();
           return extdatalen;
         }
 
@@ -1784,14 +1784,14 @@ _gnutls_send_client_hello (mhd_gtls_session_t session, int again)
       /* Copy the compression methods.
        */
       extdatalen =
-        _gnutls_copy_comp_methods (session, extdata, sizeof (extdata));
+        MHD__gnutls_copy_comp_methods (session, extdata, sizeof (extdata));
       if (extdatalen > 0)
         {
           datalen += extdatalen;
-          data = mhd_gtls_realloc_fast (data, datalen);
+          data = MHD_gtls_realloc_fast (data, datalen);
           if (data == NULL)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return GNUTLS_E_MEMORY_ERROR;
             }
 
@@ -1803,8 +1803,8 @@ _gnutls_send_client_hello (mhd_gtls_session_t session, int again)
         {
           if (extdatalen == 0)
             extdatalen = GNUTLS_E_INTERNAL_ERROR;
-          gnutls_free (data);
-          gnutls_assert ();
+          MHD_gnutls_free (data);
+          MHD_gnutls_assert ();
           return extdatalen;
         }
 
@@ -1813,15 +1813,15 @@ _gnutls_send_client_hello (mhd_gtls_session_t session, int again)
       if (hver >= MHD_GNUTLS_PROTOCOL_TLS1_0)
         {
           extdatalen =
-            mhd_gtls_gen_extensions (session, extdata, sizeof (extdata));
+            MHD_gtls_gen_extensions (session, extdata, sizeof (extdata));
 
           if (extdatalen > 0)
             {
               datalen += extdatalen;
-              data = mhd_gtls_realloc_fast (data, datalen);
+              data = MHD_gtls_realloc_fast (data, datalen);
               if (data == NULL)
                 {
-                  gnutls_assert ();
+                  MHD_gnutls_assert ();
                   return GNUTLS_E_MEMORY_ERROR;
                 }
 
@@ -1829,24 +1829,24 @@ _gnutls_send_client_hello (mhd_gtls_session_t session, int again)
             }
           else if (extdatalen < 0)
             {
-              gnutls_assert ();
-              gnutls_free (data);
+              MHD_gnutls_assert ();
+              MHD_gnutls_free (data);
               return extdatalen;
             }
         }
     }
 
   ret =
-    mhd_gtls_send_handshake (session, data, datalen,
+    MHD_gtls_send_handshake (session, data, datalen,
                              GNUTLS_HANDSHAKE_CLIENT_HELLO);
-  gnutls_free (data);
+  MHD_gnutls_free (data);
 
   return ret;
 }
 #endif
 
 static int
-_gnutls_send_server_hello (mhd_gtls_session_t session, int again)
+MHD__gnutls_send_server_hello (MHD_gtls_session_t session, int again)
 {
   opaque *data = NULL;
   opaque extdata[MAX_EXT_DATA_LENGTH];
@@ -1865,7 +1865,7 @@ _gnutls_send_server_hello (mhd_gtls_session_t session, int again)
 
 #ifdef ENABLE_SRP
   if (IS_SRP_KX
-      (mhd_gtls_cipher_suite_get_kx_algo
+      (MHD_gtls_cipher_suite_get_kx_algo
        (&session->security_parameters.current_cipher_suite)))
     {
       /* While resuming we cannot check the username extension since it is
@@ -1879,12 +1879,12 @@ _gnutls_send_server_hello (mhd_gtls_session_t session, int again)
            * SRP username. The draft requires that we send a fatal
            * alert and abort.
            */
-          gnutls_assert ();
-          ret = MHD_gnutls_alert_send (session, GNUTLS_AL_FATAL,
+          MHD_gnutls_assert ();
+          ret = MHD__gnutls_alert_send (session, GNUTLS_AL_FATAL,
                                        GNUTLS_A_UNKNOWN_PSK_IDENTITY);
           if (ret < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return ret;
             }
 
@@ -1897,25 +1897,25 @@ _gnutls_send_server_hello (mhd_gtls_session_t session, int again)
     {
       datalen = 2 + session_id_len + 1 + TLS_RANDOM_SIZE + 3;
       extdatalen =
-        mhd_gtls_gen_extensions (session, extdata, sizeof (extdata));
+        MHD_gtls_gen_extensions (session, extdata, sizeof (extdata));
 
       if (extdatalen < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return extdatalen;
         }
 
-      data = gnutls_alloca (datalen + extdatalen);
+      data = MHD_gnutls_alloca (datalen + extdatalen);
       if (data == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_MEMORY_ERROR;
         }
 
       data[pos++] =
-        mhd_gtls_version_get_major (session->security_parameters.version);
+        MHD_gtls_version_get_major (session->security_parameters.version);
       data[pos++] =
-        mhd_gtls_version_get_minor (session->security_parameters.version);
+        MHD_gtls_version_get_minor (session->security_parameters.version);
 
       memcpy (&data[pos],
               session->security_parameters.server_random, TLS_RANDOM_SIZE);
@@ -1928,8 +1928,8 @@ _gnutls_send_server_hello (mhd_gtls_session_t session, int again)
         }
       pos += session_id_len;
 
-      _gnutls_handshake_log ("HSK[%x]: SessionID: %s\n", session,
-                             mhd_gtls_bin2hex (SessionID, session_id_len,
+      MHD__gnutls_handshake_log ("HSK[%x]: SessionID: %s\n", session,
+                             MHD_gtls_bin2hex (SessionID, session_id_len,
                                                buf, sizeof (buf)));
 
       memcpy (&data[pos],
@@ -1937,7 +1937,7 @@ _gnutls_send_server_hello (mhd_gtls_session_t session, int again)
       pos += 2;
 
       comp =
-        (uint8_t) mhd_gtls_compression_get_num (session->
+        (uint8_t) MHD_gtls_compression_get_num (session->
                                                 internals.compression_method);
       data[pos++] = comp;
 
@@ -1951,47 +1951,47 @@ _gnutls_send_server_hello (mhd_gtls_session_t session, int again)
     }
 
   ret =
-    mhd_gtls_send_handshake (session, data, datalen,
+    MHD_gtls_send_handshake (session, data, datalen,
                              GNUTLS_HANDSHAKE_SERVER_HELLO);
-  gnutls_afree (data);
+  MHD_gnutls_afree (data);
 
   return ret;
 }
 
 int
-mhd_gtls_send_hello (mhd_gtls_session_t session, int again)
+MHD_gtls_send_hello (MHD_gtls_session_t session, int again)
 {
   int ret;
 #if MHD_DEBUG_TLS
   if (session->security_parameters.entity == GNUTLS_CLIENT)
     {
-      ret = _gnutls_send_client_hello (session, again);
+      ret = MHD__gnutls_send_client_hello (session, again);
 
     }
   else
 #endif
     {                           /* SERVER */
-      ret = _gnutls_send_server_hello (session, again);
+      ret = MHD__gnutls_send_server_hello (session, again);
     }
 
   return ret;
 }
 
-/* RECEIVE A HELLO MESSAGE. This should be called from gnutls_recv_handshake_int only if a
+/* RECEIVE A HELLO MESSAGE. This should be called from MHD_gnutls_recv_handshake_int only if a
  * hello message is expected. It uses the security_parameters.current_cipher_suite
  * and internals.compression_method.
  */
 int
-mhd_gtls_recv_hello (mhd_gtls_session_t session, opaque * data, int datalen)
+MHD_gtls_recv_hello (MHD_gtls_session_t session, opaque * data, int datalen)
 {
   int ret;
 #if MHD_DEBUG_TLS
   if (session->security_parameters.entity == GNUTLS_CLIENT)
     {
-      ret = _gnutls_read_server_hello (session, data, datalen);
+      ret = MHD__gnutls_read_server_hello (session, data, datalen);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
     }
@@ -1999,10 +1999,10 @@ mhd_gtls_recv_hello (mhd_gtls_session_t session, opaque * data, int datalen)
 #endif
     {                           /* Server side reading a client hello */
 
-      ret = _gnutls_read_client_hello (session, data, datalen);
+      ret = MHD__gnutls_read_client_hello (session, data, datalen);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
     }
@@ -2010,7 +2010,7 @@ mhd_gtls_recv_hello (mhd_gtls_session_t session, opaque * data, int datalen)
   return ret;
 }
 
-/* The packets in MHD_gnutls_handshake (it's more broad than original TLS handshake)
+/* The packets in MHD__gnutls_handshake (it's more broad than original TLS handshake)
  *
  *     Client                                               Server
  *
@@ -2034,8 +2034,8 @@ mhd_gtls_recv_hello (mhd_gtls_session_t session, opaque * data, int datalen)
  */
 
 /**
-  * MHD_gnutls_rehandshake - This function will renegotiate security parameters
-  * @session: is a #mhd_gtls_session_t structure.
+  * MHD__gnutls_rehandshake - This function will renegotiate security parameters
+  * @session: is a #MHD_gtls_session_t structure.
   *
   * This function will renegotiate security parameters with the
   * client.  This should only be called in case of a server.
@@ -2044,7 +2044,7 @@ mhd_gtls_recv_hello (mhd_gtls_session_t session, opaque * data, int datalen)
   * parameters (perform a handshake).
   *
   * If this function succeeds (returns 0), you must call the
-  * MHD_gnutls_handshake() function in order to negotiate the new
+  * MHD__gnutls_handshake() function in order to negotiate the new
   * parameters.
   *
   * If the client does not wish to renegotiate parameters he will
@@ -2057,18 +2057,18 @@ mhd_gtls_recv_hello (mhd_gtls_session_t session, opaque * data, int datalen)
   *
   **/
 int
-MHD_gnutls_rehandshake (mhd_gtls_session_t session)
+MHD__gnutls_rehandshake (MHD_gtls_session_t session)
 {
   int ret;
 
   ret =
-    _gnutls_send_empty_handshake (session, GNUTLS_HANDSHAKE_HELLO_REQUEST,
+    MHD__gnutls_send_empty_handshake (session, GNUTLS_HANDSHAKE_HELLO_REQUEST,
                                   AGAIN (STATE50));
   STATE = STATE50;
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
   STATE = STATE0;
@@ -2077,10 +2077,10 @@ MHD_gnutls_rehandshake (mhd_gtls_session_t session)
 }
 
 inline static int
-_gnutls_abort_handshake (mhd_gtls_session_t session, int ret)
+MHD__gnutls_abort_handshake (MHD_gtls_session_t session, int ret)
 {
   if (((ret == GNUTLS_E_WARNING_ALERT_RECEIVED) &&
-       (gnutls_alert_get (session) == GNUTLS_A_NO_RENEGOTIATION))
+       (MHD_gnutls_alert_get (session) == GNUTLS_A_NO_RENEGOTIATION))
       || ret == GNUTLS_E_GOT_APPLICATION_DATA)
     return 0;
 
@@ -2092,17 +2092,17 @@ _gnutls_abort_handshake (mhd_gtls_session_t session, int ret)
  * required for finished messages.
  */
 inline static int
-_gnutls_handshake_hash_init (mhd_gtls_session_t session)
+MHD__gnutls_handshake_hash_init (MHD_gtls_session_t session)
 {
 
   if (session->internals.handshake_mac_handle_md5 == NULL)
     {
       session->internals.handshake_mac_handle_md5 =
-        mhd_gtls_hash_init (MHD_GNUTLS_MAC_MD5);
+        MHD_gtls_hash_init (MHD_GNUTLS_MAC_MD5);
 
       if (session->internals.handshake_mac_handle_md5 == GNUTLS_HASH_FAILED)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_MEMORY_ERROR;
         }
     }
@@ -2110,10 +2110,10 @@ _gnutls_handshake_hash_init (mhd_gtls_session_t session)
   if (session->internals.handshake_mac_handle_sha == NULL)
     {
       session->internals.handshake_mac_handle_sha =
-        mhd_gtls_hash_init (MHD_GNUTLS_MAC_SHA1);
+        MHD_gtls_hash_init (MHD_GNUTLS_MAC_SHA1);
       if (session->internals.handshake_mac_handle_sha == GNUTLS_HASH_FAILED)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_MEMORY_ERROR;
         }
     }
@@ -2122,68 +2122,68 @@ _gnutls_handshake_hash_init (mhd_gtls_session_t session)
 }
 
 static int
-_gnutls_send_supplemental (mhd_gtls_session_t session, int again)
+MHD__gnutls_send_supplemental (MHD_gtls_session_t session, int again)
 {
   int ret = 0;
 
-  _gnutls_debug_log ("EXT[%x]: Sending supplemental data\n", session);
+  MHD__gnutls_debug_log ("EXT[%x]: Sending supplemental data\n", session);
 
   if (again)
-    ret = mhd_gtls_send_handshake (session, NULL, 0,
+    ret = MHD_gtls_send_handshake (session, NULL, 0,
                                    GNUTLS_HANDSHAKE_SUPPLEMENTAL);
   else
     {
-      mhd_gtls_buffer buf;
-      mhd_gtls_buffer_init (&buf);
+      MHD_gtls_buffer buf;
+      MHD_gtls_buffer_init (&buf);
 
-      ret = _gnutls_gen_supplemental (session, &buf);
+      ret = MHD__gnutls_gen_supplemental (session, &buf);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
-      ret = mhd_gtls_send_handshake (session, buf.data, buf.length,
+      ret = MHD_gtls_send_handshake (session, buf.data, buf.length,
                                      GNUTLS_HANDSHAKE_SUPPLEMENTAL);
-      mhd_gtls_buffer_clear (&buf);
+      MHD_gtls_buffer_clear (&buf);
     }
 
   return ret;
 }
 
 static int
-_gnutls_recv_supplemental (mhd_gtls_session_t session)
+MHD__gnutls_recv_supplemental (MHD_gtls_session_t session)
 {
   uint8_t *data = NULL;
   int datalen = 0;
   int ret;
 
-  _gnutls_debug_log ("EXT[%x]: Expecting supplemental data\n", session);
+  MHD__gnutls_debug_log ("EXT[%x]: Expecting supplemental data\n", session);
 
-  ret = mhd_gtls_recv_handshake (session, &data, &datalen,
+  ret = MHD_gtls_recv_handshake (session, &data, &datalen,
                                  GNUTLS_HANDSHAKE_SUPPLEMENTAL,
                                  OPTIONAL_PACKET);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  ret = _gnutls_parse_supplemental (session, data, datalen);
+  ret = MHD__gnutls_parse_supplemental (session, data, datalen);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  gnutls_free (data);
+  MHD_gnutls_free (data);
 
   return ret;
 }
 
 /**
-  * MHD_gnutls_handshake - This is the main function in the handshake protocol.
-  * @session: is a #mhd_gtls_session_t structure.
+  * MHD__gnutls_handshake - This is the main function in the handshake protocol.
+  * @session: is a #MHD_gtls_session_t structure.
   *
   * This function does the handshake of the TLS/SSL protocol, and
   * initializes the TLS connection.
@@ -2196,7 +2196,7 @@ _gnutls_recv_supplemental (mhd_gtls_session_t session)
   * The non-fatal errors such as %GNUTLS_E_AGAIN and
   * %GNUTLS_E_INTERRUPTED interrupt the handshake procedure, which
   * should be later be resumed.  Call this function again, until it
-  * returns 0; cf.  MHD_gnutls_record_get_direction() and
+  * returns 0; cf.  MHD__gnutls_record_get_direction() and
   * MHD_gtls_error_is_fatal().
   *
   * If this function is called by a server after a rehandshake request
@@ -2209,24 +2209,24 @@ _gnutls_recv_supplemental (mhd_gtls_session_t session)
   *
   **/
 int
-MHD_gnutls_handshake (mhd_gtls_session_t session)
+MHD__gnutls_handshake (MHD_gtls_session_t session)
 {
   int ret;
 
-  if ((ret = _gnutls_handshake_hash_init (session)) < 0)
+  if ((ret = MHD__gnutls_handshake_hash_init (session)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 #if MHD_DEBUG_TLS
   if (session->security_parameters.entity == GNUTLS_CLIENT)
       {
-        ret = mhd_gtls_handshake_client (session);
+        ret = MHD_gtls_handshake_client (session);
       }
     else
 #endif
       {
-        ret = mhd_gtls_handshake_server (session);
+        ret = MHD_gtls_handshake_server (session);
       }
 
   if (ret < 0)
@@ -2234,17 +2234,17 @@ MHD_gnutls_handshake (mhd_gtls_session_t session)
       /* In the case of a rehandshake abort
        * we should reset the handshake's internal state.
        */
-      if (_gnutls_abort_handshake (session, ret) == 0)
+      if (MHD__gnutls_abort_handshake (session, ret) == 0)
         STATE = STATE0;
 
       return ret;
     }
 
-  ret = mhd_gtls_handshake_common (session);
+  ret = MHD_gtls_handshake_common (session);
 
   if (ret < 0)
     {
-      if (_gnutls_abort_handshake (session, ret) == 0)
+      if (MHD__gnutls_abort_handshake (session, ret) == 0)
         STATE = STATE0;
 
       return ret;
@@ -2252,8 +2252,8 @@ MHD_gnutls_handshake (mhd_gtls_session_t session)
 
   STATE = STATE0;
 
-  _gnutls_handshake_io_buffer_clear (session);
-  mhd_gtls_handshake_internal_state_clear (session);
+  MHD__gnutls_handshake_io_buffer_clear (session);
+  MHD_gtls_handshake_internal_state_clear (session);
 
   return 0;
 }
@@ -2261,20 +2261,20 @@ MHD_gnutls_handshake (mhd_gtls_session_t session)
 #define IMED_RET( str, ret) do { \
         if (ret < 0) { \
                 if (MHD_gtls_error_is_fatal(ret)==0) return ret; \
-                gnutls_assert(); \
+                MHD_gnutls_assert(); \
                 ERR( str, ret); \
-                _gnutls_handshake_hash_buffers_clear(session); \
+                MHD__gnutls_handshake_hash_buffers_clear(session); \
                 return ret; \
         } } while (0)
 
 
 #if MHD_DEBUG_TLS
 /*
- * mhd_gtls_handshake_client
+ * MHD_gtls_handshake_client
  * This function performs the client side of the handshake of the TLS/SSL protocol.
  */
 int
-mhd_gtls_handshake_client (mhd_gtls_session_t session)
+MHD_gtls_handshake_client (MHD_gtls_session_t session)
 {
   int ret = 0;
 
@@ -2282,8 +2282,8 @@ mhd_gtls_handshake_client (mhd_gtls_session_t session)
   char buf[64];
 
   if (session->internals.resumed_security_parameters.session_id_size > 0)
-    _gnutls_handshake_log ("HSK[%x]: Ask to resume: %s\n", session,
-                           mhd_gtls_bin2hex (session->internals.
+    MHD__gnutls_handshake_log ("HSK[%x]: Ask to resume: %s\n", session,
+                           MHD_gtls_bin2hex (session->internals.
                                              resumed_security_parameters.
                                              session_id,
                                              session->internals.
@@ -2296,14 +2296,14 @@ mhd_gtls_handshake_client (mhd_gtls_session_t session)
     {
     case STATE0:
     case STATE1:
-      ret = mhd_gtls_send_hello (session, AGAIN (STATE1));
+      ret = MHD_gtls_send_hello (session, AGAIN (STATE1));
       STATE = STATE1;
       IMED_RET ("send hello", ret);
 
     case STATE2:
       /* receive the server hello */
       ret =
-        mhd_gtls_recv_handshake (session, NULL, NULL,
+        MHD_gtls_recv_handshake (session, NULL, NULL,
                                  GNUTLS_HANDSHAKE_SERVER_HELLO,
                                  MANDATORY_PACKET);
       STATE = STATE2;
@@ -2312,7 +2312,7 @@ mhd_gtls_handshake_client (mhd_gtls_session_t session)
     case STATE70:
       if (session->security_parameters.extensions.do_recv_supplemental)
         {
-          ret = _gnutls_recv_supplemental (session);
+          ret = MHD__gnutls_recv_supplemental (session);
           STATE = STATE70;
           IMED_RET ("recv supplemental", ret);
         }
@@ -2320,14 +2320,14 @@ mhd_gtls_handshake_client (mhd_gtls_session_t session)
     case STATE3:
       /* RECV CERTIFICATE */
       if (session->internals.resumed == RESUME_FALSE)   /* if we are not resuming */
-        ret = mhd_gtls_recv_server_certificate (session);
+        ret = MHD_gtls_recv_server_certificate (session);
       STATE = STATE3;
       IMED_RET ("recv server certificate", ret);
 
     case STATE4:
       /* receive the server key exchange */
       if (session->internals.resumed == RESUME_FALSE)   /* if we are not resuming */
-        ret = mhd_gtls_recv_server_kx_message (session);
+        ret = MHD_gtls_recv_server_kx_message (session);
       STATE = STATE4;
       IMED_RET ("recv server kx message", ret);
 
@@ -2336,7 +2336,7 @@ mhd_gtls_handshake_client (mhd_gtls_session_t session)
        */
 
       if (session->internals.resumed == RESUME_FALSE)   /* if we are not resuming */
-        ret = mhd_gtls_recv_server_certificate_request (session);
+        ret = MHD_gtls_recv_server_certificate_request (session);
       STATE = STATE5;
       IMED_RET ("recv server certificate request message", ret);
 
@@ -2344,7 +2344,7 @@ mhd_gtls_handshake_client (mhd_gtls_session_t session)
       /* receive the server hello done */
       if (session->internals.resumed == RESUME_FALSE)   /* if we are not resuming */
         ret =
-          mhd_gtls_recv_handshake (session, NULL, NULL,
+          MHD_gtls_recv_handshake (session, NULL, NULL,
                                    GNUTLS_HANDSHAKE_SERVER_HELLO_DONE,
                                    MANDATORY_PACKET);
       STATE = STATE6;
@@ -2353,7 +2353,7 @@ mhd_gtls_handshake_client (mhd_gtls_session_t session)
     case STATE71:
       if (session->security_parameters.extensions.do_send_supplemental)
         {
-          ret = _gnutls_send_supplemental (session, AGAIN (STATE71));
+          ret = MHD__gnutls_send_supplemental (session, AGAIN (STATE71));
           STATE = STATE71;
           IMED_RET ("send supplemental", ret);
         }
@@ -2362,13 +2362,13 @@ mhd_gtls_handshake_client (mhd_gtls_session_t session)
       /* send our certificate - if any and if requested
        */
       if (session->internals.resumed == RESUME_FALSE)   /* if we are not resuming */
-        ret = mhd_gtls_send_client_certificate (session, AGAIN (STATE7));
+        ret = MHD_gtls_send_client_certificate (session, AGAIN (STATE7));
       STATE = STATE7;
       IMED_RET ("send client certificate", ret);
 
     case STATE8:
       if (session->internals.resumed == RESUME_FALSE)   /* if we are not resuming */
-        ret = mhd_gtls_send_client_kx_message (session, AGAIN (STATE8));
+        ret = MHD_gtls_send_client_kx_message (session, AGAIN (STATE8));
       STATE = STATE8;
       IMED_RET ("send client kx", ret);
 
@@ -2376,7 +2376,7 @@ mhd_gtls_handshake_client (mhd_gtls_session_t session)
       /* send client certificate verify */
       if (session->internals.resumed == RESUME_FALSE)   /* if we are not resuming */
         ret =
-          mhd_gtls_send_client_certificate_verify (session, AGAIN (STATE9));
+          MHD_gtls_send_client_certificate_verify (session, AGAIN (STATE9));
       STATE = STATE9;
       IMED_RET ("send client certificate verify", ret);
 
@@ -2393,7 +2393,7 @@ mhd_gtls_handshake_client (mhd_gtls_session_t session)
 /* This function sends the final handshake packets and initializes connection
  */
 static int
-_gnutls_send_handshake_final (mhd_gtls_session_t session, int init)
+MHD__gnutls_send_handshake_final (MHD_gtls_session_t session, int init)
 {
   int ret = 0;
 
@@ -2403,12 +2403,12 @@ _gnutls_send_handshake_final (mhd_gtls_session_t session, int init)
     {
     case STATE0:
     case STATE20:
-      ret = mhd_gtls_send_change_cipher_spec (session, AGAIN (STATE20));
+      ret = MHD_gtls_send_change_cipher_spec (session, AGAIN (STATE20));
       STATE = STATE20;
       if (ret < 0)
         {
           ERR ("send ChangeCipherSpec", ret);
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
@@ -2416,29 +2416,29 @@ _gnutls_send_handshake_final (mhd_gtls_session_t session, int init)
        */
       if (init == TRUE)
         {
-          ret = mhd_gtls_connection_state_init (session);
+          ret = MHD_gtls_connection_state_init (session);
           if (ret < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return ret;
             }
         }
 
-      ret = mhd_gtls_write_connection_state_init (session);
+      ret = MHD_gtls_write_connection_state_init (session);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
     case STATE21:
       /* send the finished message */
-      ret = _gnutls_send_finished (session, AGAIN (STATE21));
+      ret = MHD__gnutls_send_finished (session, AGAIN (STATE21));
       STATE = STATE21;
       if (ret < 0)
         {
           ERR ("send Finished", ret);
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
@@ -2455,7 +2455,7 @@ _gnutls_send_handshake_final (mhd_gtls_session_t session, int init)
  * read session.
  */
 static int
-_gnutls_recv_handshake_final (mhd_gtls_session_t session, int init)
+MHD__gnutls_recv_handshake_final (MHD_gtls_session_t session, int init)
 {
   int ret = 0;
   uint8_t ch;
@@ -2465,40 +2465,40 @@ _gnutls_recv_handshake_final (mhd_gtls_session_t session, int init)
     case STATE0:
     case STATE30:
       ret =
-        mhd_gtls_recv_int (session, GNUTLS_CHANGE_CIPHER_SPEC, -1, &ch, 1);
+        MHD_gtls_recv_int (session, GNUTLS_CHANGE_CIPHER_SPEC, -1, &ch, 1);
       STATE = STATE30;
       if (ret <= 0)
         {
           ERR ("recv ChangeCipherSpec", ret);
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return (ret < 0) ? ret : GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
         }
 
       /* Initialize the connection session (start encryption) - in case of server */
       if (init == TRUE)
         {
-          ret = mhd_gtls_connection_state_init (session);
+          ret = MHD_gtls_connection_state_init (session);
           if (ret < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return ret;
             }
         }
 
-      ret = mhd_gtls_read_connection_state_init (session);
+      ret = MHD_gtls_read_connection_state_init (session);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
     case STATE31:
-      ret = _gnutls_recv_finished (session);
+      ret = MHD__gnutls_recv_finished (session);
       STATE = STATE31;
       if (ret < 0)
         {
           ERR ("recv finished", ret);
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
       STATE = STATE0;
@@ -2511,12 +2511,12 @@ _gnutls_recv_handshake_final (mhd_gtls_session_t session, int init)
 }
 
  /*
-  * mhd_gtls_handshake_server
+  * MHD_gtls_handshake_server
   * This function does the server stuff of the handshake protocol.
   */
 
 int
-mhd_gtls_handshake_server (mhd_gtls_session_t session)
+MHD_gtls_handshake_server (MHD_gtls_session_t session)
 {
   int ret = 0;
 
@@ -2525,21 +2525,21 @@ mhd_gtls_handshake_server (mhd_gtls_session_t session)
     case STATE0:
     case STATE1:
       ret =
-        mhd_gtls_recv_handshake (session, NULL, NULL,
+        MHD_gtls_recv_handshake (session, NULL, NULL,
                                  GNUTLS_HANDSHAKE_CLIENT_HELLO,
                                  MANDATORY_PACKET);
       STATE = STATE1;
       IMED_RET ("recv hello", ret);
 
     case STATE2:
-      ret = mhd_gtls_send_hello (session, AGAIN (STATE2));
+      ret = MHD_gtls_send_hello (session, AGAIN (STATE2));
       STATE = STATE2;
       IMED_RET ("send hello", ret);
 
     case STATE70:
       if (session->security_parameters.extensions.do_send_supplemental)
         {
-          ret = _gnutls_send_supplemental (session, AGAIN (STATE70));
+          ret = MHD__gnutls_send_supplemental (session, AGAIN (STATE70));
           STATE = STATE70;
           IMED_RET ("send supplemental data", ret);
         }
@@ -2549,14 +2549,14 @@ mhd_gtls_handshake_server (mhd_gtls_session_t session)
       /* NOTE: these should not be send if we are resuming */
 
       if (session->internals.resumed == RESUME_FALSE)
-        ret = mhd_gtls_send_server_certificate (session, AGAIN (STATE3));
+        ret = MHD_gtls_send_server_certificate (session, AGAIN (STATE3));
       STATE = STATE3;
       IMED_RET ("send server certificate", ret);
 
     case STATE4:
       /* send server key exchange (A) */
       if (session->internals.resumed == RESUME_FALSE)
-        ret = mhd_gtls_send_server_kx_message (session, AGAIN (STATE4));
+        ret = MHD_gtls_send_server_kx_message (session, AGAIN (STATE4));
       STATE = STATE4;
       IMED_RET ("send server kx", ret);
 
@@ -2564,7 +2564,7 @@ mhd_gtls_handshake_server (mhd_gtls_session_t session)
       /* Send certificate request - if requested to */
       if (session->internals.resumed == RESUME_FALSE)
         ret =
-          mhd_gtls_send_server_certificate_request (session, AGAIN (STATE5));
+          MHD_gtls_send_server_certificate_request (session, AGAIN (STATE5));
       STATE = STATE5;
       IMED_RET ("send server cert request", ret);
 
@@ -2572,7 +2572,7 @@ mhd_gtls_handshake_server (mhd_gtls_session_t session)
       /* send the server hello done */
       if (session->internals.resumed == RESUME_FALSE)   /* if we are not resuming */
         ret =
-          _gnutls_send_empty_handshake (session,
+          MHD__gnutls_send_empty_handshake (session,
                                         GNUTLS_HANDSHAKE_SERVER_HELLO_DONE,
                                         AGAIN (STATE6));
       STATE = STATE6;
@@ -2581,7 +2581,7 @@ mhd_gtls_handshake_server (mhd_gtls_session_t session)
     case STATE71:
       if (session->security_parameters.extensions.do_recv_supplemental)
         {
-          ret = _gnutls_recv_supplemental (session);
+          ret = MHD__gnutls_recv_supplemental (session);
           STATE = STATE71;
           IMED_RET ("recv client supplemental", ret);
         }
@@ -2590,21 +2590,21 @@ mhd_gtls_handshake_server (mhd_gtls_session_t session)
     case STATE7:
       /* receive the client certificate message */
       if (session->internals.resumed == RESUME_FALSE)   /* if we are not resuming */
-        ret = mhd_gtls_recv_client_certificate (session);
+        ret = MHD_gtls_recv_client_certificate (session);
       STATE = STATE7;
       IMED_RET ("recv client certificate", ret);
 
     case STATE8:
       /* receive the client key exchange message */
       if (session->internals.resumed == RESUME_FALSE)   /* if we are not resuming */
-        ret = mhd_gtls_recv_client_kx_message (session);
+        ret = MHD_gtls_recv_client_kx_message (session);
       STATE = STATE8;
       IMED_RET ("recv client kx", ret);
 
     case STATE9:
       /* receive the client certificate verify message */
       if (session->internals.resumed == RESUME_FALSE)   /* if we are not resuming */
-        ret = mhd_gtls_recv_client_certificate_verify_message (session);
+        ret = MHD_gtls_recv_client_certificate_verify_message (session);
       STATE = STATE9;
       IMED_RET ("recv client certificate verify", ret);
 
@@ -2617,7 +2617,7 @@ mhd_gtls_handshake_server (mhd_gtls_session_t session)
 }
 
 int
-mhd_gtls_handshake_common (mhd_gtls_session_t session)
+MHD_gtls_handshake_common (MHD_gtls_session_t session)
 {
   int ret = 0;
 
@@ -2629,36 +2629,36 @@ mhd_gtls_handshake_common (mhd_gtls_session_t session)
     {
       /* if we are a client resuming - or we are a server not resuming */
 
-      ret = _gnutls_recv_handshake_final (session, TRUE);
+      ret = MHD__gnutls_recv_handshake_final (session, TRUE);
       IMED_RET ("recv handshake final", ret);
 
-      ret = _gnutls_send_handshake_final (session, FALSE);
+      ret = MHD__gnutls_send_handshake_final (session, FALSE);
       IMED_RET ("send handshake final", ret);
     }
   else
     {                           /* if we are a client not resuming - or we are a server resuming */
 
-      ret = _gnutls_send_handshake_final (session, TRUE);
+      ret = MHD__gnutls_send_handshake_final (session, TRUE);
       IMED_RET ("send handshake final 2", ret);
 
-      ret = _gnutls_recv_handshake_final (session, FALSE);
+      ret = MHD__gnutls_recv_handshake_final (session, FALSE);
       IMED_RET ("recv handshake final 2", ret);
     }
 
   /* clear handshake buffer */
-  _gnutls_handshake_hash_buffers_clear (session);
+  MHD__gnutls_handshake_hash_buffers_clear (session);
   return ret;
 
 }
 
 int
-mhd_gtls_generate_session_id (opaque * session_id, uint8_t * len)
+MHD_gtls_generate_session_id (opaque * session_id, uint8_t * len)
 {
   *len = TLS_MAX_SESSION_ID_SIZE;
 
-  if (gc_nonce (session_id, *len) != GC_OK)
+  if (MHD_gc_nonce (session_id, *len) != GC_OK)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_RANDOM_FAILED;
     }
 
@@ -2666,19 +2666,19 @@ mhd_gtls_generate_session_id (opaque * session_id, uint8_t * len)
 }
 
 int
-mhd_gtls_recv_hello_request (mhd_gtls_session_t session, void *data,
+MHD_gtls_recv_hello_request (MHD_gtls_session_t session, void *data,
                              uint32_t data_size)
 {
   uint8_t type;
 
   if (session->security_parameters.entity == GNUTLS_SERVER)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNEXPECTED_PACKET;
     }
   if (data_size < 1)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
     }
   type = ((uint8_t *) data)[0];
@@ -2686,7 +2686,7 @@ mhd_gtls_recv_hello_request (mhd_gtls_session_t session, void *data,
     return GNUTLS_E_REHANDSHAKE;
   else
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNEXPECTED_PACKET;
     }
 }
@@ -2695,33 +2695,33 @@ mhd_gtls_recv_hello_request (mhd_gtls_session_t session, void *data,
  * (DH or RSA) set up. Otherwise returns 0.
  */
 inline static int
-check_server_params (mhd_gtls_session_t session,
+check_server_params (MHD_gtls_session_t session,
                      enum MHD_GNUTLS_KeyExchangeAlgorithm kx,
                      enum MHD_GNUTLS_KeyExchangeAlgorithm *alg, int alg_size)
 {
   int cred_type;
-  mhd_gtls_dh_params_t dh_params = NULL;
-  mhd_gtls_rsa_params_t rsa_params = NULL;
+  MHD_gtls_dh_params_t dh_params = NULL;
+  MHD_gtls_rsa_params_t rsa_params = NULL;
   int j;
 
-  cred_type = mhd_gtls_map_kx_get_cred (kx, 1);
+  cred_type = MHD_gtls_map_kx_get_cred (kx, 1);
 
   /* Read the Diffie Hellman parameters, if any.
    */
   if (cred_type == MHD_GNUTLS_CRD_CERTIFICATE)
     {
       int delete;
-      mhd_gtls_cert_credentials_t x509_cred =
-        (mhd_gtls_cert_credentials_t) mhd_gtls_get_cred (session->key,
+      MHD_gtls_cert_credentials_t x509_cred =
+        (MHD_gtls_cert_credentials_t) MHD_gtls_get_cred (session->key,
                                                          cred_type, NULL);
 
       if (x509_cred != NULL)
         {
           dh_params =
-            mhd_gtls_get_dh_params (x509_cred->dh_params,
+            MHD_gtls_get_dh_params (x509_cred->dh_params,
                                     x509_cred->params_func, session);
           rsa_params =
-            mhd_gtls_certificate_get_rsa_params (x509_cred->rsa_params,
+            MHD_gtls_certificate_get_rsa_params (x509_cred->rsa_params,
                                                  x509_cred->params_func,
                                                  session);
         }
@@ -2746,15 +2746,15 @@ check_server_params (mhd_gtls_session_t session,
     }
   else if (cred_type == MHD_GNUTLS_CRD_ANON)
     {
-      mhd_gtls_anon_server_credentials_t anon_cred =
-        (mhd_gtls_anon_server_credentials_t) mhd_gtls_get_cred (session->key,
+      MHD_gtls_anon_server_credentials_t anon_cred =
+        (MHD_gtls_anon_server_credentials_t) MHD_gtls_get_cred (session->key,
                                                                 cred_type,
                                                                 NULL);
 
       if (anon_cred != NULL)
         {
           dh_params =
-            mhd_gtls_get_dh_params (anon_cred->dh_params,
+            MHD_gtls_get_dh_params (anon_cred->dh_params,
                                     anon_cred->params_func, session);
         }
 #endif
@@ -2762,14 +2762,14 @@ check_server_params (mhd_gtls_session_t session,
     }
   else if (cred_type == MHD_GNUTLS_CRD_PSK)
     {
-      gnutls_psk_server_credentials_t psk_cred =
-        (gnutls_psk_server_credentials_t) mhd_gtls_get_cred (session->key,
+      MHD_gnutls_psk_server_credentials_t psk_cred =
+        (MHD_gnutls_psk_server_credentials_t) MHD_gtls_get_cred (session->key,
                                                              cred_type, NULL);
 
       if (psk_cred != NULL)
         {
           dh_params =
-            mhd_gtls_get_dh_params (psk_cred->dh_params,
+            MHD_gtls_get_dh_params (psk_cred->dh_params,
                                     psk_cred->params_func, session);
         }
 #endif
@@ -2781,22 +2781,22 @@ check_server_params (mhd_gtls_session_t session,
   /* If the key exchange method needs RSA or DH params,
    * but they are not set then remove it.
    */
-  if (mhd_gtls_kx_needs_rsa_params (kx) != 0)
+  if (MHD_gtls_kx_needs_rsa_params (kx) != 0)
     {
       /* needs rsa params. */
-      if (_gnutls_rsa_params_to_mpi (rsa_params) == NULL)
+      if (MHD__gnutls_rsa_params_to_mpi (rsa_params) == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return 1;
         }
     }
 
-  if (mhd_gtls_kx_needs_dh_params (kx) != 0)
+  if (MHD_gtls_kx_needs_dh_params (kx) != 0)
     {
       /* needs DH params. */
-      if (mhd_gtls_dh_params_to_mpi (dh_params) == NULL)
+      if (MHD_gtls_dh_params_to_mpi (dh_params) == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return 1;
         }
     }
@@ -2808,11 +2808,11 @@ check_server_params (mhd_gtls_session_t session,
  * the requested authentication method. We remove an algorithm if
  * we have a certificate with keyUsage bits set.
  *
- * This does a more high level check than  gnutls_supported_ciphersuites(),
+ * This does a more high level check than  MHD_gnutls_supported_ciphersuites(),
  * by checking certificates etc.
  */
 int
-mhd_gtls_remove_unwanted_ciphersuites (mhd_gtls_session_t session,
+MHD_gtls_remove_unwanted_ciphersuites (MHD_gtls_session_t session,
                                        cipher_suite_st ** cipherSuites,
                                        int numCipherSuites,
                                        enum MHD_GNUTLS_PublicKeyAlgorithm
@@ -2822,7 +2822,7 @@ mhd_gtls_remove_unwanted_ciphersuites (mhd_gtls_session_t session,
   int ret = 0;
   cipher_suite_st *newSuite, cs;
   int newSuiteSize = 0, i;
-  mhd_gtls_cert_credentials_t cert_cred;
+  MHD_gtls_cert_credentials_t cert_cred;
   enum MHD_GNUTLS_KeyExchangeAlgorithm kx;
   int server = session->security_parameters.entity == GNUTLS_SERVER ? 1 : 0;
   enum MHD_GNUTLS_KeyExchangeAlgorithm *alg = NULL;
@@ -2835,7 +2835,7 @@ mhd_gtls_remove_unwanted_ciphersuites (mhd_gtls_session_t session,
    */
 
   cert_cred =
-    (mhd_gtls_cert_credentials_t) mhd_gtls_get_cred (session->key,
+    (MHD_gtls_cert_credentials_t) MHD_gtls_get_cred (session->key,
                                                      MHD_GNUTLS_CRD_CERTIFICATE,
                                                      NULL);
 
@@ -2845,11 +2845,11 @@ mhd_gtls_remove_unwanted_ciphersuites (mhd_gtls_session_t session,
   if (session->security_parameters.entity == GNUTLS_SERVER
       && cert_cred != NULL)
     {
-      ret = mhd_gtls_server_select_cert (session, requested_pk_algo);
+      ret = MHD_gtls_server_select_cert (session, requested_pk_algo);
       if (ret < 0)
         {
-          gnutls_assert ();
-          _gnutls_x509_log ("Could not find an appropriate certificate: %s\n",
+          MHD_gnutls_assert ();
+          MHD__gnutls_x509_log ("Could not find an appropriate certificate: %s\n",
                             MHD_gtls_strerror (ret));
           cert_cred = NULL;
         }
@@ -2859,17 +2859,17 @@ mhd_gtls_remove_unwanted_ciphersuites (mhd_gtls_session_t session,
    * supported by the X509 certificate parameters.
    */
   if ((ret =
-       mhd_gtls_selected_cert_supported_kx (session, &alg, &alg_size)) < 0)
+       MHD_gtls_selected_cert_supported_kx (session, &alg, &alg_size)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  newSuite = gnutls_malloc (numCipherSuites * sizeof (cipher_suite_st));
+  newSuite = MHD_gnutls_malloc (numCipherSuites * sizeof (cipher_suite_st));
   if (newSuite == NULL)
     {
-      gnutls_assert ();
-      gnutls_free (alg);
+      MHD_gnutls_assert ();
+      MHD_gnutls_free (alg);
       return GNUTLS_E_MEMORY_ERROR;
     }
 
@@ -2882,11 +2882,11 @@ mhd_gtls_remove_unwanted_ciphersuites (mhd_gtls_session_t session,
       /* finds the key exchange algorithm in
        * the ciphersuite
        */
-      kx = mhd_gtls_cipher_suite_get_kx_algo (&(*cipherSuites)[i]);
+      kx = MHD_gtls_cipher_suite_get_kx_algo (&(*cipherSuites)[i]);
 
       /* if it is defined but had no credentials
        */
-      if (mhd_gtls_get_kx_cred (session, kx, NULL) == NULL)
+      if (MHD_gtls_get_kx_cred (session, kx, NULL) == NULL)
         {
           delete = 1;
         }
@@ -2899,12 +2899,12 @@ mhd_gtls_remove_unwanted_ciphersuites (mhd_gtls_session_t session,
         }
 
       /* These two SRP kx's are marked to require a CRD_CERTIFICATE,
-         (see cred_mappings in gnutls_algorithms.c), but it also
+         (see cred_mappings in MHD_gnutls_algorithms.c), but it also
          requires a SRP credential.  Don't use SRP kx unless we have a
          SRP credential too.  */
       if (kx == MHD_GNUTLS_KX_SRP_RSA || kx == MHD_GNUTLS_KX_SRP_DSS)
         {
-          if (!mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_SRP, NULL))
+          if (!MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_SRP, NULL))
             delete = 1;
         }
 
@@ -2913,24 +2913,24 @@ mhd_gtls_remove_unwanted_ciphersuites (mhd_gtls_session_t session,
       if (delete == 0)
         {
 
-          _gnutls_handshake_log ("HSK[%x]: Keeping ciphersuite: %s\n",
+          MHD__gnutls_handshake_log ("HSK[%x]: Keeping ciphersuite: %s\n",
                                  session,
-                                 mhd_gtls_cipher_suite_get_name (&cs));
+                                 MHD_gtls_cipher_suite_get_name (&cs));
 
           memcpy (newSuite[newSuiteSize].suite, (*cipherSuites)[i].suite, 2);
           newSuiteSize++;
         }
       else
         {
-          _gnutls_handshake_log ("HSK[%x]: Removing ciphersuite: %s\n",
+          MHD__gnutls_handshake_log ("HSK[%x]: Removing ciphersuite: %s\n",
                                  session,
-                                 mhd_gtls_cipher_suite_get_name (&cs));
+                                 MHD_gtls_cipher_suite_get_name (&cs));
 
         }
     }
 
-  gnutls_free (alg);
-  gnutls_free (*cipherSuites);
+  MHD_gnutls_free (alg);
+  MHD_gnutls_free (*cipherSuites);
   *cipherSuites = newSuite;
 
   ret = newSuiteSize;
@@ -2940,8 +2940,8 @@ mhd_gtls_remove_unwanted_ciphersuites (mhd_gtls_session_t session,
 }
 
 /**
-  * MHD_gnutls_handshake_set_max_packet_length - This function will set the maximum length of a handshake message
-  * @session: is a #mhd_gtls_session_t structure.
+  * MHD__gnutls_handshake_set_max_packet_length - This function will set the maximum length of a handshake message
+  * @session: is a #MHD_gtls_session_t structure.
   * @max: is the maximum number.
   *
   * This function will set the maximum size of a handshake message.
@@ -2951,63 +2951,63 @@ mhd_gtls_remove_unwanted_ciphersuites (mhd_gtls_session_t session,
   *
   **/
 void
-MHD_gnutls_handshake_set_max_packet_length (mhd_gtls_session_t session,
+MHD__gnutls_handshake_set_max_packet_length (MHD_gtls_session_t session,
                                             size_t max)
 {
   session->internals.max_handshake_data_buffer_size = max;
 }
 
 void
-mhd_gtls_set_adv_version (mhd_gtls_session_t session,
+MHD_gtls_set_adv_version (MHD_gtls_session_t session,
                           enum MHD_GNUTLS_Protocol ver)
 {
-  set_adv_version (session, mhd_gtls_version_get_major (ver),
-                   mhd_gtls_version_get_minor (ver));
+  set_adv_version (session, MHD_gtls_version_get_major (ver),
+                   MHD_gtls_version_get_minor (ver));
 }
 
 enum MHD_GNUTLS_Protocol
-mhd_gtls_get_adv_version (mhd_gtls_session_t session)
+MHD_gtls_get_adv_version (MHD_gtls_session_t session)
 {
-  return mhd_gtls_version_get (_gnutls_get_adv_version_major (session),
-                               _gnutls_get_adv_version_minor (session));
+  return MHD_gtls_version_get (MHD__gnutls_get_adv_version_major (session),
+                               MHD__gnutls_get_adv_version_minor (session));
 }
 
 /**
   * MHD_gtls_handshake_get_last_in - Returns the last handshake message received.
-  * @session: is a #mhd_gtls_session_t structure.
+  * @session: is a #MHD_gtls_session_t structure.
   *
   * This function is only useful to check where the last performed
   * handshake failed.  If the previous handshake succeed or was not
   * performed at all then no meaningful value will be returned.
   *
-  * Check %gnutls_handshake_description_t in gnutls.h for the
+  * Check %MHD_gnutls_handshake_description_t in gnutls.h for the
   * available handshake descriptions.
   *
   * Returns: the last handshake message type received, a
-  * %gnutls_handshake_description_t.
+  * %MHD_gnutls_handshake_description_t.
   **/
-gnutls_handshake_description_t
-MHD_gtls_handshake_get_last_in (mhd_gtls_session_t session)
+MHD_gnutls_handshake_description_t
+MHD_gtls_handshake_get_last_in (MHD_gtls_session_t session)
 {
   return session->internals.last_handshake_in;
 }
 
 /**
   * MHD_gtls_handshake_get_last_out - Returns the last handshake message sent.
-  * @session: is a #mhd_gtls_session_t structure.
+  * @session: is a #MHD_gtls_session_t structure.
   *
   * This function is only useful to check where the last performed
   * handshake failed.  If the previous handshake succeed or was not
   * performed at all then no meaningful value will be returned.
   *
-  * Check %gnutls_handshake_description_t in gnutls.h for the
+  * Check %MHD_gnutls_handshake_description_t in gnutls.h for the
   * available handshake descriptions.
   *
   * Returns: the last handshake message type sent, a
-  * %gnutls_handshake_description_t.
+  * %MHD_gnutls_handshake_description_t.
   **/
-gnutls_handshake_description_t
-MHD_gtls_handshake_get_last_out (mhd_gtls_session_t session)
+MHD_gnutls_handshake_description_t
+MHD_gtls_handshake_get_last_out (MHD_gtls_session_t session)
 {
   return session->internals.last_handshake_out;
 }
diff --git a/src/daemon/https/tls/gnutls_handshake.h b/src/daemon/https/tls/gnutls_handshake.h
index 7679653f..6514ffc6 100644
--- a/src/daemon/https/tls/gnutls_handshake.h
+++ b/src/daemon/https/tls/gnutls_handshake.h
@@ -25,39 +25,39 @@
 typedef enum Optional
 { OPTIONAL_PACKET, MANDATORY_PACKET } Optional;
 
-int mhd_gtls_send_handshake (mhd_gtls_session_t session, void *i_data,
+int MHD_gtls_send_handshake (MHD_gtls_session_t session, void *i_data,
                              uint32_t i_datasize,
-                             gnutls_handshake_description_t type);
-int mhd_gtls_recv_hello_request (mhd_gtls_session_t session, void *data,
+                             MHD_gnutls_handshake_description_t type);
+int MHD_gtls_recv_hello_request (MHD_gtls_session_t session, void *data,
                                  uint32_t data_size);
-int mhd_gtls_send_hello (mhd_gtls_session_t session, int again);
-int mhd_gtls_recv_hello (mhd_gtls_session_t session, opaque * data,
+int MHD_gtls_send_hello (MHD_gtls_session_t session, int again);
+int MHD_gtls_recv_hello (MHD_gtls_session_t session, opaque * data,
                          int datalen);
-int mhd_gtls_recv_handshake (mhd_gtls_session_t session, uint8_t **, int *,
-                             gnutls_handshake_description_t,
+int MHD_gtls_recv_handshake (MHD_gtls_session_t session, uint8_t **, int *,
+                             MHD_gnutls_handshake_description_t,
                              Optional optional);
-int mhd_gtls_generate_session_id (opaque * session_id, uint8_t * len);
-int mhd_gtls_handshake_common (mhd_gtls_session_t session);
-int mhd_gtls_handshake_server (mhd_gtls_session_t session);
-void mhd_gtls_set_server_random (mhd_gtls_session_t session, uint8_t * rnd);
-void mhd_gtls_set_client_random (mhd_gtls_session_t session, uint8_t * rnd);
-int mhd_gtls_tls_create_random (opaque * dst);
-int mhd_gtls_remove_unwanted_ciphersuites (mhd_gtls_session_t session,
+int MHD_gtls_generate_session_id (opaque * session_id, uint8_t * len);
+int MHD_gtls_handshake_common (MHD_gtls_session_t session);
+int MHD_gtls_handshake_server (MHD_gtls_session_t session);
+void MHD_gtls_set_server_random (MHD_gtls_session_t session, uint8_t * rnd);
+void MHD_gtls_set_client_random (MHD_gtls_session_t session, uint8_t * rnd);
+int MHD_gtls_tls_create_random (opaque * dst);
+int MHD_gtls_remove_unwanted_ciphersuites (MHD_gtls_session_t session,
                                            cipher_suite_st ** cipherSuites,
                                            int numCipherSuites,
                                            enum
                                            MHD_GNUTLS_PublicKeyAlgorithm);
-int mhd_gtls_find_pk_algos_in_ciphersuites (opaque * data, int datalen);
-int mhd_gtls_server_select_suite (mhd_gtls_session_t session, opaque * data,
+int MHD_gtls_find_pk_algos_in_ciphersuites (opaque * data, int datalen);
+int MHD_gtls_server_select_suite (MHD_gtls_session_t session, opaque * data,
                                   int datalen);
 
-int mhd_gtls_negotiate_version (mhd_gtls_session_t session,
+int MHD_gtls_negotiate_version (MHD_gtls_session_t session,
                                 enum MHD_GNUTLS_Protocol adv_version);
-int mhd_gtls_user_hello_func (mhd_gtls_session_t,
+int MHD_gtls_user_hello_func (MHD_gtls_session_t,
                               enum MHD_GNUTLS_Protocol adv_version);
 
 #if MHD_DEBUG_TLS
-int mhd_gtls_handshake_client (mhd_gtls_session_t session);
+int MHD_gtls_handshake_client (MHD_gtls_session_t session);
 #endif
 
 #define STATE session->internals.handshake_state
diff --git a/src/daemon/https/tls/gnutls_hash_int.c b/src/daemon/https/tls/gnutls_hash_int.c
index da1880f2..158f0843 100644
--- a/src/daemon/https/tls/gnutls_hash_int.c
+++ b/src/daemon/https/tls/gnutls_hash_int.c
@@ -31,7 +31,7 @@
 #include <gnutls_errors.h>
 
 static inline Gc_hash
-_gnutls_mac2gc (enum MHD_GNUTLS_HashAlgorithm mac)
+MHD__gnutls_mac2gc (enum MHD_GNUTLS_HashAlgorithm mac)
 {
   switch (mac)
     {
@@ -48,32 +48,32 @@ _gnutls_mac2gc (enum MHD_GNUTLS_HashAlgorithm mac)
       return GC_MD5;
       break;
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return -1;
     }
   return -1;
 }
 
 GNUTLS_HASH_HANDLE
-mhd_gtls_hash_init (enum MHD_GNUTLS_HashAlgorithm algorithm)
+MHD_gtls_hash_init (enum MHD_GNUTLS_HashAlgorithm algorithm)
 {
   mac_hd_t ret;
   int result;
 
-  ret = gnutls_malloc (sizeof (mac_hd_st));
+  ret = MHD_gnutls_malloc (sizeof (mac_hd_st));
   if (ret == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_HASH_FAILED;
     }
 
   ret->algorithm = algorithm;
 
-  result = gc_hash_open (_gnutls_mac2gc (algorithm), 0, &ret->handle);
+  result = MHD_gc_hash_open (MHD__gnutls_mac2gc (algorithm), 0, &ret->handle);
   if (result)
     {
-      gnutls_assert ();
-      gnutls_free (ret);
+      MHD_gnutls_assert ();
+      MHD_gnutls_free (ret);
       ret = GNUTLS_HASH_FAILED;
     }
 
@@ -81,31 +81,31 @@ mhd_gtls_hash_init (enum MHD_GNUTLS_HashAlgorithm algorithm)
 }
 
 int
-mhd_gnutls_hash_get_algo_len (enum MHD_GNUTLS_HashAlgorithm algorithm)
+MHD_gnutls_hash_get_algo_len (enum MHD_GNUTLS_HashAlgorithm algorithm)
 {
   int ret;
 
-  ret = gc_hash_digest_length (_gnutls_mac2gc (algorithm));
+  ret = MHD_gc_hash_digest_length (MHD__gnutls_mac2gc (algorithm));
 
   return ret;
 
 }
 
 int
-mhd_gnutls_hash (GNUTLS_HASH_HANDLE handle, const void *text, size_t textlen)
+MHD_gnutls_hash (GNUTLS_HASH_HANDLE handle, const void *text, size_t textlen)
 {
   if (textlen > 0)
-    gc_hash_write (handle->handle, textlen, text);
+    MHD_gc_hash_write (handle->handle, textlen, text);
   return 0;
 }
 
 GNUTLS_HASH_HANDLE
-mhd_gnutls_hash_copy (GNUTLS_HASH_HANDLE handle)
+MHD_gnutls_hash_copy (GNUTLS_HASH_HANDLE handle)
 {
   GNUTLS_HASH_HANDLE ret;
   int result;
 
-  ret = gnutls_malloc (sizeof (mac_hd_st));
+  ret = MHD_gnutls_malloc (sizeof (mac_hd_st));
 
   if (ret == NULL)
     return GNUTLS_HASH_FAILED;
@@ -114,11 +114,11 @@ mhd_gnutls_hash_copy (GNUTLS_HASH_HANDLE handle)
   ret->key = NULL;              /* it's a hash anyway */
   ret->keysize = 0;
 
-  result = gc_hash_clone (handle->handle, &ret->handle);
+  result = MHD_gc_hash_clone (handle->handle, &ret->handle);
 
   if (result)
     {
-      gnutls_free (ret);
+      MHD_gnutls_free (ret);
       return GNUTLS_HASH_FAILED;
     }
 
@@ -126,42 +126,42 @@ mhd_gnutls_hash_copy (GNUTLS_HASH_HANDLE handle)
 }
 
 void
-mhd_gnutls_hash_deinit (GNUTLS_HASH_HANDLE handle, void *digest)
+MHD_gnutls_hash_deinit (GNUTLS_HASH_HANDLE handle, void *digest)
 {
   const opaque *mac;
   int maclen;
 
-  maclen = mhd_gnutls_hash_get_algo_len (handle->algorithm);
+  maclen = MHD_gnutls_hash_get_algo_len (handle->algorithm);
 
-  mac = gc_hash_read (handle->handle);
+  mac = MHD_gc_hash_read (handle->handle);
   if (digest != NULL)
     memcpy (digest, mac, maclen);
 
-  gc_hash_close (handle->handle);
+  MHD_gc_hash_close (handle->handle);
 
-  gnutls_free (handle);
+  MHD_gnutls_free (handle);
 }
 
 
 mac_hd_t
-mhd_gtls_hmac_init (enum MHD_GNUTLS_HashAlgorithm algorithm,
+MHD_gtls_MHD_hmac_init (enum MHD_GNUTLS_HashAlgorithm algorithm,
                     const void *key, int keylen)
 {
   mac_hd_t ret;
   int result;
 
-  ret = gnutls_malloc (sizeof (mac_hd_st));
+  ret = MHD_gnutls_malloc (sizeof (mac_hd_st));
   if (ret == NULL)
     return GNUTLS_MAC_FAILED;
 
-  result = gc_hash_open (_gnutls_mac2gc (algorithm), GC_HMAC, &ret->handle);
+  result = MHD_gc_hash_open (MHD__gnutls_mac2gc (algorithm), GC_HMAC, &ret->handle);
   if (result)
     {
-      gnutls_free (ret);
+      MHD_gnutls_free (ret);
       return GNUTLS_MAC_FAILED;
     }
 
-  gc_hash_hmac_setkey (ret->handle, keylen, key);
+  MHD_gc_hash_MHD_hmac_setkey (ret->handle, keylen, key);
 
   ret->algorithm = algorithm;
   ret->key = key;
@@ -171,21 +171,21 @@ mhd_gtls_hmac_init (enum MHD_GNUTLS_HashAlgorithm algorithm,
 }
 
 void
-mhd_gnutls_hmac_deinit (mac_hd_t handle, void *digest)
+MHD_gnutls_MHD_hmac_deinit (mac_hd_t handle, void *digest)
 {
   const opaque *mac;
   int maclen;
 
-  maclen = mhd_gnutls_hash_get_algo_len (handle->algorithm);
+  maclen = MHD_gnutls_hash_get_algo_len (handle->algorithm);
 
-  mac = gc_hash_read (handle->handle);
+  mac = MHD_gc_hash_read (handle->handle);
 
   if (digest != NULL)
     memcpy (digest, mac, maclen);
 
-  gc_hash_close (handle->handle);
+  MHD_gc_hash_close (handle->handle);
 
-  gnutls_free (handle);
+  MHD_gnutls_free (handle);
 }
 
 inline static int
@@ -203,7 +203,7 @@ get_padsize (enum MHD_GNUTLS_HashAlgorithm algorithm)
 }
 
 mac_hd_t
-mhd_gnutls_mac_init_ssl3 (enum MHD_GNUTLS_HashAlgorithm algorithm, void *key,
+MHD_gnutls_mac_init_ssl3 (enum MHD_GNUTLS_HashAlgorithm algorithm, void *key,
                           int keylen)
 {
   mac_hd_t ret;
@@ -213,28 +213,28 @@ mhd_gnutls_mac_init_ssl3 (enum MHD_GNUTLS_HashAlgorithm algorithm, void *key,
   padsize = get_padsize (algorithm);
   if (padsize == 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_MAC_FAILED;
     }
 
   memset (ipad, 0x36, padsize);
 
-  ret = mhd_gtls_hash_init (algorithm);
+  ret = MHD_gtls_hash_init (algorithm);
   if (ret != GNUTLS_HASH_FAILED)
     {
       ret->key = key;
       ret->keysize = keylen;
 
       if (keylen > 0)
-        mhd_gnutls_hash (ret, key, keylen);
-      mhd_gnutls_hash (ret, ipad, padsize);
+        MHD_gnutls_hash (ret, key, keylen);
+      MHD_gnutls_hash (ret, ipad, padsize);
     }
 
   return ret;
 }
 
 void
-mhd_gnutls_mac_deinit_ssl3 (mac_hd_t handle, void *digest)
+MHD_gnutls_mac_deinit_ssl3 (mac_hd_t handle, void *digest)
 {
   opaque ret[MAX_HASH_SIZE];
   mac_hd_t td;
@@ -245,29 +245,29 @@ mhd_gnutls_mac_deinit_ssl3 (mac_hd_t handle, void *digest)
   padsize = get_padsize (handle->algorithm);
   if (padsize == 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return;
     }
 
   memset (opad, 0x5C, padsize);
 
-  td = mhd_gtls_hash_init (handle->algorithm);
+  td = MHD_gtls_hash_init (handle->algorithm);
   if (td != GNUTLS_MAC_FAILED)
     {
       if (handle->keysize > 0)
-        mhd_gnutls_hash (td, handle->key, handle->keysize);
+        MHD_gnutls_hash (td, handle->key, handle->keysize);
 
-      mhd_gnutls_hash (td, opad, padsize);
-      block = mhd_gnutls_hash_get_algo_len (handle->algorithm);
-      mhd_gnutls_hash_deinit (handle, ret);     /* get the previous hash */
-      mhd_gnutls_hash (td, ret, block);
+      MHD_gnutls_hash (td, opad, padsize);
+      block = MHD_gnutls_hash_get_algo_len (handle->algorithm);
+      MHD_gnutls_hash_deinit (handle, ret);     /* get the previous hash */
+      MHD_gnutls_hash (td, ret, block);
 
-      mhd_gnutls_hash_deinit (td, digest);
+      MHD_gnutls_hash_deinit (td, digest);
     }
 }
 
 void
-mhd_gnutls_mac_deinit_ssl3_handshake (mac_hd_t handle,
+MHD_gnutls_mac_deinit_ssl3_handshake (mac_hd_t handle,
                                       void *digest, opaque * key,
                                       uint32_t key_size)
 {
@@ -281,30 +281,30 @@ mhd_gnutls_mac_deinit_ssl3_handshake (mac_hd_t handle,
   padsize = get_padsize (handle->algorithm);
   if (padsize == 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return;
     }
 
   memset (opad, 0x5C, padsize);
   memset (ipad, 0x36, padsize);
 
-  td = mhd_gtls_hash_init (handle->algorithm);
+  td = MHD_gtls_hash_init (handle->algorithm);
   if (td != GNUTLS_HASH_FAILED)
     {
       if (key_size > 0)
-        mhd_gnutls_hash (td, key, key_size);
+        MHD_gnutls_hash (td, key, key_size);
 
-      mhd_gnutls_hash (td, opad, padsize);
-      block = mhd_gnutls_hash_get_algo_len (handle->algorithm);
+      MHD_gnutls_hash (td, opad, padsize);
+      block = MHD_gnutls_hash_get_algo_len (handle->algorithm);
 
       if (key_size > 0)
-        mhd_gnutls_hash (handle, key, key_size);
-      mhd_gnutls_hash (handle, ipad, padsize);
-      mhd_gnutls_hash_deinit (handle, ret);     /* get the previous hash */
+        MHD_gnutls_hash (handle, key, key_size);
+      MHD_gnutls_hash (handle, ipad, padsize);
+      MHD_gnutls_hash_deinit (handle, ret);     /* get the previous hash */
 
-      mhd_gnutls_hash (td, ret, block);
+      MHD_gnutls_hash (td, ret, block);
 
-      mhd_gnutls_hash_deinit (td, digest);
+      MHD_gnutls_hash_deinit (td, digest);
     }
 }
 
@@ -322,18 +322,18 @@ ssl3_sha (int i, opaque * secret, int secret_len,
       text1[j] = 65 + i;        /* A==65 */
     }
 
-  td = mhd_gtls_hash_init (MHD_GNUTLS_MAC_SHA1);
+  td = MHD_gtls_hash_init (MHD_GNUTLS_MAC_SHA1);
   if (td == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_HASH_FAILED;
     }
 
-  mhd_gnutls_hash (td, text1, i + 1);
-  mhd_gnutls_hash (td, secret, secret_len);
-  mhd_gnutls_hash (td, rnd, rnd_len);
+  MHD_gnutls_hash (td, text1, i + 1);
+  MHD_gnutls_hash (td, secret, secret_len);
+  MHD_gnutls_hash (td, rnd, rnd_len);
 
-  mhd_gnutls_hash_deinit (td, digest);
+  MHD_gnutls_hash_deinit (td, digest);
   return 0;
 }
 
@@ -345,54 +345,54 @@ ssl3_md5 (int i, opaque * secret, int secret_len,
   mac_hd_t td;
   int ret;
 
-  td = mhd_gtls_hash_init (MHD_GNUTLS_MAC_MD5);
+  td = MHD_gtls_hash_init (MHD_GNUTLS_MAC_MD5);
   if (td == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_HASH_FAILED;
     }
 
-  mhd_gnutls_hash (td, secret, secret_len);
+  MHD_gnutls_hash (td, secret, secret_len);
 
   ret = ssl3_sha (i, secret, secret_len, rnd, rnd_len, tmp);
   if (ret < 0)
     {
-      gnutls_assert ();
-      mhd_gnutls_hash_deinit (td, digest);
+      MHD_gnutls_assert ();
+      MHD_gnutls_hash_deinit (td, digest);
       return ret;
     }
 
-  mhd_gnutls_hash (td, tmp,
-                   mhd_gnutls_hash_get_algo_len (MHD_GNUTLS_MAC_SHA1));
+  MHD_gnutls_hash (td, tmp,
+                   MHD_gnutls_hash_get_algo_len (MHD_GNUTLS_MAC_SHA1));
 
-  mhd_gnutls_hash_deinit (td, digest);
+  MHD_gnutls_hash_deinit (td, digest);
   return 0;
 }
 
 int
-mhd_gnutls_ssl3_hash_md5 (void *first, int first_len,
+MHD_gnutls_ssl3_hash_md5 (void *first, int first_len,
                           void *second, int second_len, int ret_len,
                           opaque * ret)
 {
   opaque digest[MAX_HASH_SIZE];
   mac_hd_t td;
-  int block = mhd_gnutls_hash_get_algo_len (MHD_GNUTLS_MAC_MD5);
+  int block = MHD_gnutls_hash_get_algo_len (MHD_GNUTLS_MAC_MD5);
 
-  td = mhd_gtls_hash_init (MHD_GNUTLS_MAC_MD5);
+  td = MHD_gtls_hash_init (MHD_GNUTLS_MAC_MD5);
   if (td == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_HASH_FAILED;
     }
 
-  mhd_gnutls_hash (td, first, first_len);
-  mhd_gnutls_hash (td, second, second_len);
+  MHD_gnutls_hash (td, first, first_len);
+  MHD_gnutls_hash (td, second, second_len);
 
-  mhd_gnutls_hash_deinit (td, digest);
+  MHD_gnutls_hash_deinit (td, digest);
 
   if (ret_len > block)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
@@ -403,13 +403,13 @@ mhd_gnutls_ssl3_hash_md5 (void *first, int first_len,
 }
 
 int
-mhd_gnutls_ssl3_generate_random (void *secret, int secret_len,
+MHD_gnutls_ssl3_generate_random (void *secret, int secret_len,
                                  void *rnd, int rnd_len,
                                  int ret_bytes, opaque * ret)
 {
   int i = 0, copy, output_bytes;
   opaque digest[MAX_HASH_SIZE];
-  int block = mhd_gnutls_hash_get_algo_len (MHD_GNUTLS_MAC_MD5);
+  int block = MHD_gnutls_hash_get_algo_len (MHD_GNUTLS_MAC_MD5);
   int result, times;
 
   output_bytes = 0;
@@ -427,7 +427,7 @@ mhd_gnutls_ssl3_generate_random (void *secret, int secret_len,
       result = ssl3_md5 (i, secret, secret_len, rnd, rnd_len, digest);
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return result;
         }
 
diff --git a/src/daemon/https/tls/gnutls_hash_int.h b/src/daemon/https/tls/gnutls_hash_int.h
index 7cd33a03..72f805ee 100644
--- a/src/daemon/https/tls/gnutls_hash_int.h
+++ b/src/daemon/https/tls/gnutls_hash_int.h
@@ -31,7 +31,7 @@
 
 typedef struct
 {
-  gc_hash_handle handle;
+  MHD_gc_hash_handle handle;
   enum MHD_GNUTLS_HashAlgorithm algorithm;
   const void *key;
   int keysize;
@@ -42,31 +42,31 @@ typedef mac_hd_t GNUTLS_HASH_HANDLE;
 #define GNUTLS_HASH_FAILED NULL
 #define GNUTLS_MAC_FAILED NULL
 
-mac_hd_t mhd_gtls_hmac_init (enum MHD_GNUTLS_HashAlgorithm algorithm,
+mac_hd_t MHD_gtls_MHD_hmac_init (enum MHD_GNUTLS_HashAlgorithm algorithm,
                              const void *key, int keylen);
 
-void mhd_gnutls_hmac_deinit (mac_hd_t handle, void *digest);
+void MHD_gnutls_MHD_hmac_deinit (mac_hd_t handle, void *digest);
 
-mac_hd_t mhd_gnutls_mac_init_ssl3 (enum MHD_GNUTLS_HashAlgorithm algorithm,
+mac_hd_t MHD_gnutls_mac_init_ssl3 (enum MHD_GNUTLS_HashAlgorithm algorithm,
                                    void *key, int keylen);
-void mhd_gnutls_mac_deinit_ssl3 (mac_hd_t handle, void *digest);
+void MHD_gnutls_mac_deinit_ssl3 (mac_hd_t handle, void *digest);
 
-GNUTLS_HASH_HANDLE mhd_gtls_hash_init (enum MHD_GNUTLS_HashAlgorithm
+GNUTLS_HASH_HANDLE MHD_gtls_hash_init (enum MHD_GNUTLS_HashAlgorithm
                                        algorithm);
-int mhd_gnutls_hash_get_algo_len (enum MHD_GNUTLS_HashAlgorithm algorithm);
-int mhd_gnutls_hash (GNUTLS_HASH_HANDLE handle, const void *text,
+int MHD_gnutls_hash_get_algo_len (enum MHD_GNUTLS_HashAlgorithm algorithm);
+int MHD_gnutls_hash (GNUTLS_HASH_HANDLE handle, const void *text,
                      size_t textlen);
-void mhd_gnutls_hash_deinit (GNUTLS_HASH_HANDLE handle, void *digest);
+void MHD_gnutls_hash_deinit (GNUTLS_HASH_HANDLE handle, void *digest);
 
-int mhd_gnutls_ssl3_generate_random (void *secret, int secret_len,
+int MHD_gnutls_ssl3_generate_random (void *secret, int secret_len,
                                      void *rnd, int random_len, int bytes,
                                      opaque * ret);
-int mhd_gnutls_ssl3_hash_md5 (void *first, int first_len, void *second,
+int MHD_gnutls_ssl3_hash_md5 (void *first, int first_len, void *second,
                               int second_len, int ret_len, opaque * ret);
 
-void mhd_gnutls_mac_deinit_ssl3_handshake (mac_hd_t handle, void *digest,
+void MHD_gnutls_mac_deinit_ssl3_handshake (mac_hd_t handle, void *digest,
                                            opaque * key, uint32_t key_size);
 
-GNUTLS_HASH_HANDLE mhd_gnutls_hash_copy (GNUTLS_HASH_HANDLE handle);
+GNUTLS_HASH_HANDLE MHD_gnutls_hash_copy (GNUTLS_HASH_HANDLE handle);
 
 #endif /* GNUTLS_HASH_INT_H */
diff --git a/src/daemon/https/tls/gnutls_int.h b/src/daemon/https/tls/gnutls_int.h
index 2ef52933..af2b4499 100644
--- a/src/daemon/https/tls/gnutls_int.h
+++ b/src/daemon/https/tls/gnutls_int.h
@@ -92,9 +92,9 @@
 #define DEFAULT_VERIFY_DEPTH 32
 #define DEFAULT_VERIFY_BITS 16*1024
 
-#define DECR_LEN(len, x) do { len-=x; if (len<0) {gnutls_assert(); return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;} } while (0)
-#define DECR_LENGTH_RET(len, x, RET) do { len-=x; if (len<0) {gnutls_assert(); return RET;} } while (0)
-#define DECR_LENGTH_COM(len, x, COM) do { len-=x; if (len<0) {gnutls_assert(); COM;} } while (0)
+#define DECR_LEN(len, x) do { len-=x; if (len<0) {MHD_gnutls_assert(); return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;} } while (0)
+#define DECR_LENGTH_RET(len, x, RET) do { len-=x; if (len<0) {MHD_gnutls_assert(); return RET;} } while (0)
+#define DECR_LENGTH_COM(len, x, COM) do { len-=x; if (len<0) {MHD_gnutls_assert(); COM;} } while (0)
 
 #define HASH2MAC(x) ((enum MHD_GNUTLS_HashAlgorithm)x)
 
@@ -129,11 +129,11 @@ typedef enum handshake_state_t
 
 #include <gnutls_str.h>
 
-typedef mhd_gtls_string mhd_gtls_buffer;
+typedef MHD_gtls_string MHD_gtls_buffer;
 
-#define mhd_gtls_buffer_init(buf) mhd_gtls_string_init(buf, gnutls_malloc, gnutls_realloc, gnutls_free);
-#define mhd_gtls_buffer_clear mhd_gtls_string_clear
-#define mhd_gtls_buffer_append mhd_gtls_string_append_data
+#define MHD_gtls_buffer_init(buf) MHD_gtls_string_init(buf, MHD_gnutls_malloc, MHD_gnutls_realloc, MHD_gnutls_free);
+#define MHD_gtls_buffer_clear MHD_gtls_string_clear
+#define MHD_gtls_buffer_append MHD_gtls_string_append_data
 
 /* This is the maximum number of algorithms (ciphers or macs etc).
  * keep it synced with GNUTLS_MAX_ALGORITHM_NUM in gnutls.h
@@ -179,20 +179,20 @@ typedef enum content_type_t
 typedef void (*LOG_FUNC) (int, const char *);
 
 /* Store & Retrieve functions defines:  */
-typedef struct mhd_gtls_auth_cred_st
+typedef struct MHD_gtls_auth_cred_st
 {
   enum MHD_GNUTLS_CredentialsType algorithm;
 
   /* the type of credentials depends on algorithm
    */
   void *credentials;
-  struct mhd_gtls_auth_cred_st *next;
+  struct MHD_gtls_auth_cred_st *next;
 } auth_cred_st;
 
-struct mhd_gtls_key
+struct MHD_gtls_key
 {
   /* For DH KX */
-  gnutls_datum_t key;
+  MHD_gnutls_datum_t key;
   mpi_t KEY;
   mpi_t client_Y;
   mpi_t client_g;
@@ -212,7 +212,7 @@ struct mhd_gtls_key
   /* this is used to hold the peers authentication data
    */
   /* auth_info_t structures SHOULD NOT contain malloced
-   * elements. Check gnutls_session_pack.c, and gnutls_auth.c.
+   * elements. Check MHD_gnutls_session_pack.c, and MHD_gnutls_auth.c.
    * Rememember that this should be calloced!
    */
   void *auth_info;
@@ -233,7 +233,7 @@ struct mhd_gtls_key
    * for a client certificate verify
    */
 };
-typedef struct mhd_gtls_key *mhd_gtls_key_st;
+typedef struct MHD_gtls_key *MHD_gtls_key_st;
 
 /* STATE (cont) */
 #include <gnutls_hash_int.h>
@@ -254,7 +254,7 @@ typedef struct
 {
   opaque name[MAX_SERVER_NAME_SIZE];
   unsigned name_length;
-  gnutls_server_name_type_t type;
+  MHD_gnutls_server_name_type_t type;
 } server_name_st;
 
 #define MAX_SERVER_NAME_EXTENSIONS 3
@@ -267,20 +267,20 @@ typedef struct
   opaque srp_username[MAX_SRP_USERNAME + 1];
 
   /* TLS/IA data. */
-  int gnutls_ia_enable, gnutls_ia_peer_enable;
-  int gnutls_ia_allowskip, gnutls_ia_peer_allowskip;
+  int MHD_gnutls_ia_enable, MHD_gnutls_ia_peer_enable;
+  int MHD_gnutls_ia_allowskip, MHD_gnutls_ia_peer_allowskip;
 
   /* Used by extensions that enable supplemental data. */
   int do_recv_supplemental, do_send_supplemental;
 
   /* Opaque PRF input. */
-  gnutls_oprfi_callback_func oprfi_cb;
+  MHD_gnutls_oprfi_callback_func oprfi_cb;
   void *oprfi_userdata;
   opaque *oprfi_client;
   uint16_t oprfi_client_len;
   opaque *oprfi_server;
   uint16_t oprfi_server_len;
-} mhd_gtls_ext_st;
+} MHD_gtls_ext_st;
 
 /* This flag indicates for an extension whether
  * it is useful to application level or TLS level only.
@@ -292,7 +292,7 @@ typedef enum tls_ext_parse_type_t
   EXTENSION_ANY,
   EXTENSION_APPLICATION,
   EXTENSION_TLS
-} mhd_gtls_ext_parse_type_t;
+} MHD_gtls_ext_parse_type_t;
 
 /* auth_info_t structures now MAY contain malloced
  * elements.
@@ -305,7 +305,7 @@ typedef enum tls_ext_parse_type_t
  */
 
 /* if you add anything in Security_Parameters struct, then
- * also modify CPY_COMMON in gnutls_constate.c
+ * also modify CPY_COMMON in MHD_gnutls_constate.c
  */
 
 /* Note that the security parameters structure is set up after the
@@ -314,7 +314,7 @@ typedef enum tls_ext_parse_type_t
  */
 typedef struct
 {
-  gnutls_connection_end_t entity;
+  MHD_gnutls_connection_end_t entity;
   enum MHD_GNUTLS_KeyExchangeAlgorithm kx_algorithm;
   /* we've got separate write/read bulk/macs because
    * there is a time in handshake where the peer has
@@ -339,7 +339,7 @@ typedef struct
   opaque session_id[TLS_MAX_SESSION_ID_SIZE];
   uint8_t session_id_size;
   time_t timestamp;
-  mhd_gtls_ext_st extensions;
+  MHD_gtls_ext_st extensions;
 
   /* The send size is the one requested by the programmer.
    * The recv size is the one negotiated with the peer.
@@ -351,23 +351,23 @@ typedef struct
   enum MHD_GNUTLS_Protocol version;     /* moved here */
   /* For TLS/IA.  XXX: Move to IA credential? */
   opaque inner_secret[TLS_MASTER_SIZE];
-} mhd_gtls_security_param_st;
+} MHD_gtls_security_param_st;
 
 /* This structure holds the generated keys
  */
 typedef struct
 {
-  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;
+  MHD_gnutls_datum_t server_write_mac_secret;
+  MHD_gnutls_datum_t client_write_mac_secret;
+  MHD_gnutls_datum_t server_write_IV;
+  MHD_gnutls_datum_t client_write_IV;
+  MHD_gnutls_datum_t server_write_key;
+  MHD_gnutls_datum_t client_write_key;
   int generated_keys;           /* zero if keys have not
                                  * been generated. Non zero
                                  * otherwise.
                                  */
-} mhd_gtls_cipher_specs_st;
+} MHD_gtls_cipher_specs_st;
 
 typedef struct
 {
@@ -375,29 +375,29 @@ typedef struct
   cipher_hd_t read_cipher_state;
   comp_hd_t read_compression_state;
   comp_hd_t write_compression_state;
-  gnutls_datum_t read_mac_secret;
-  gnutls_datum_t write_mac_secret;
+  MHD_gnutls_datum_t read_mac_secret;
+  MHD_gnutls_datum_t write_mac_secret;
   uint64 read_sequence_number;
   uint64 write_sequence_number;
-} mhd_gtls_conn_stat_st;
+} MHD_gtls_conn_stat_st;
 
 typedef struct
 {
   unsigned int priority[MAX_ALGOS];
   unsigned int num_algorithms;
-} mhd_gtls_priority_st;
+} MHD_gtls_priority_st;
 
 /* For the external api */
 struct MHD_gtls_priority_st
 {
-  mhd_gtls_priority_st cipher;
-  mhd_gtls_priority_st mac;
-  mhd_gtls_priority_st kx;
-  mhd_gtls_priority_st compression;
-  mhd_gtls_priority_st protocol;
+  MHD_gtls_priority_st cipher;
+  MHD_gtls_priority_st mac;
+  MHD_gtls_priority_st kx;
+  MHD_gtls_priority_st compression;
+  MHD_gtls_priority_st protocol;
 
   /* certificate type : x509, OpenPGP, etc. */
-  mhd_gtls_priority_st cert_type;
+  MHD_gtls_priority_st cert_type;
 
   /* to disable record padding */
   int no_padding;
@@ -410,15 +410,15 @@ typedef struct MHD_gtls_dh_params_int
   /* [0] is the prime, [1] is the generator.
    */
   mpi_t params[2];
-} mhd_gtls_dh_params_st;
+} MHD_gtls_dh_params_st;
 
 typedef struct
 {
-  mhd_gtls_dh_params_t dh_params;
+  MHD_gtls_dh_params_t dh_params;
   int free_dh_params;
-  mhd_gtls_rsa_params_t rsa_params;
+  MHD_gtls_rsa_params_t rsa_params;
   int free_rsa_params;
-} mhd_gtls_internal_params_st;
+} MHD_gtls_internal_params_st;
 
 typedef struct
 {
@@ -427,19 +427,19 @@ typedef struct
   size_t header_size;
   /* this holds the length of the handshake packet */
   size_t packet_length;
-  gnutls_handshake_description_t recv_type;
-} mhd_gtls_handshake_header_buffer_st;
+  MHD_gnutls_handshake_description_t recv_type;
+} MHD_gtls_handshake_header_buffer_st;
 
 typedef struct
 {
-  mhd_gtls_buffer application_data_buffer;      /* holds data to be delivered to application layer */
-  mhd_gtls_buffer handshake_hash_buffer;        /* used to keep the last received handshake
+  MHD_gtls_buffer application_data_buffer;      /* holds data to be delivered to application layer */
+  MHD_gtls_buffer handshake_hash_buffer;        /* used to keep the last received handshake
                                                  * message */
   mac_hd_t handshake_mac_handle_sha;    /* hash of the handshake messages */
   mac_hd_t handshake_mac_handle_md5;    /* hash of the handshake messages */
 
-  mhd_gtls_buffer handshake_data_buffer;        /* this is a buffer that holds the current handshake message */
-  mhd_gtls_buffer ia_data_buffer;       /* holds inner application data (TLS/IA) */
+  MHD_gtls_buffer handshake_data_buffer;        /* this is a buffer that holds the current handshake message */
+  MHD_gtls_buffer ia_data_buffer;       /* holds inner application data (TLS/IA) */
   resumable_session_t resumable;        /* TRUE or FALSE - if we can resume that session */
   handshake_state_t handshake_state;    /* holds
                                          * a number which indicates where
@@ -471,28 +471,28 @@ typedef struct
 
   /* resumed session */
   resumable_session_t resumed;  /* RESUME_TRUE or FALSE - if we are resuming a session */
-  mhd_gtls_security_param_st resumed_security_parameters;
+  MHD_gtls_security_param_st resumed_security_parameters;
 
   /* sockets internals */
   int lowat;
 
   /* These buffers are used in the handshake
-   * protocol only. freed using _gnutls_handshake_io_buffer_clear();
+   * protocol only. freed using MHD__gnutls_handshake_io_buffer_clear();
    */
-  mhd_gtls_buffer handshake_send_buffer;
+  MHD_gtls_buffer handshake_send_buffer;
   size_t handshake_send_buffer_prev_size;
   content_type_t handshake_send_buffer_type;
-  gnutls_handshake_description_t handshake_send_buffer_htype;
+  MHD_gnutls_handshake_description_t handshake_send_buffer_htype;
   content_type_t handshake_recv_buffer_type;
-  gnutls_handshake_description_t handshake_recv_buffer_htype;
-  mhd_gtls_buffer handshake_recv_buffer;
+  MHD_gnutls_handshake_description_t handshake_recv_buffer_htype;
+  MHD_gtls_buffer handshake_recv_buffer;
 
   /* this buffer holds a record packet -mostly used for
    * non blocking IO.
    */
-  mhd_gtls_buffer record_recv_buffer;
-  mhd_gtls_buffer record_send_buffer;   /* holds cached data
-                                         * for the gnutls_io_write_buffered()
+  MHD_gtls_buffer record_recv_buffer;
+  MHD_gtls_buffer record_send_buffer;   /* holds cached data
+                                         * for the MHD_gnutls_io_write_buffered()
                                          * function.
                                          */
   size_t record_send_buffer_prev_size;  /* holds the
@@ -508,7 +508,7 @@ typedef struct
   int have_peeked_data;
 
   int expire_time;              /* after expire_time seconds this session will expire */
-  struct mhd_gtls_mod_auth_st_int *auth_struct; /* used in handshake packets and KX algorithms */
+  struct MHD_gtls_mod_auth_st_int *auth_struct; /* used in handshake packets and KX algorithms */
 
   /* TODO rm */
   int v2_hello;                 /* 0 if the client hello is v3+.
@@ -516,7 +516,7 @@ typedef struct
                                  */
   /* keeps the headers of the handshake packet
    */
-  mhd_gtls_handshake_header_buffer_st handshake_header_buffer;
+  MHD_gtls_handshake_header_buffer_st handshake_header_buffer;
 
   /* this is the highest version available
    * to the peer. (advertized version).
@@ -533,7 +533,7 @@ typedef struct
   int send_cert_req;
 
   /* bits to use for DHE and DHA
-   * use _gnutls_dh_get_prime_bits() and MHD_gnutls_dh_set_prime_bits()
+   * use MHD__gnutls_dh_get_prime_bits() and MHD__gnutls_dh_set_prime_bits()
    * to access it.
    */
   uint16_t dh_prime_bits;
@@ -542,17 +542,17 @@ typedef struct
 
   /* PUSH & PULL functions.
    */
-  mhd_gtls_pull_func _gnutls_pull_func;
-  mhd_gtls_push_func _gnutls_push_func;
+  MHD_gtls_pull_func MHD__gnutls_pull_func;
+  MHD_gtls_push_func MHD__gnutls_push_func;
   /* Holds the first argument of PUSH and PULL
    * functions;
    */
-  gnutls_transport_ptr_t transport_recv_ptr;
-  gnutls_transport_ptr_t transport_send_ptr;
+  MHD_gnutls_transport_ptr_t transport_recv_ptr;
+  MHD_gnutls_transport_ptr_t transport_send_ptr;
 
   /* post client hello callback (server side only)
    */
-  gnutls_handshake_post_client_hello_func user_hello_func;
+  MHD_gnutls_handshake_post_client_hello_func user_hello_func;
 
   /* Holds the record size requested by the
    * user.
@@ -560,12 +560,12 @@ typedef struct
   uint16_t proposed_record_size;
 
   /* holds the selected certificate and key.
-   * use mhd_gtls_selected_certs_deinit() and mhd_gtls_selected_certs_set()
+   * use MHD_gtls_selected_certs_deinit() and MHD_gtls_selected_certs_set()
    * to change them.
    */
-  gnutls_cert *selected_cert_list;
+  MHD_gnutls_cert *selected_cert_list;
   int selected_cert_list_length;
-  gnutls_privkey *selected_key;
+  MHD_gnutls_privkey *selected_key;
   int selected_need_free;
 
   /* holds the extensions we sent to the peer
@@ -615,16 +615,16 @@ typedef struct
    * credentials structure, or from a callback. That is to
    * minimize external calls.
    */
-  mhd_gtls_internal_params_st params;
+  MHD_gtls_internal_params_st params;
 
   /* This buffer is used by the record recv functions,
    * as a temporary store buffer.
    */
-  gnutls_datum_t recv_buffer;
+  MHD_gnutls_datum_t recv_buffer;
 
   /* To avoid using global variables, and especially on Windows where
    * the application may use a different errno variable than GnuTLS,
-   * it is possible to use MHD_gnutls_transport_set_errno to set a
+   * it is possible to use MHD__gnutls_transport_set_errno to set a
    * session-specific errno variable in the user-replaceable push/pull
    * functions.  This value is used by the send/recv functions.  (The
    * strange name of this variable is because 'errno' is typically
@@ -633,44 +633,44 @@ typedef struct
   int errnum;
 
   /* Function used to perform public-key signing operation during
-     handshake.  Used by gnutls_sig.c:_gnutls_tls_sign(), see also
+     handshake.  Used by MHD_gnutls_sig.c:MHD__gnutls_tls_sign(), see also
      MHD_gtls_sign_callback_set(). */
-  gnutls_sign_func sign_func;
+  MHD_gnutls_sign_func sign_func;
   void *sign_func_userdata;
 
-  /* If you add anything here, check mhd_gtls_handshake_internal_state_clear().
+  /* If you add anything here, check MHD_gtls_handshake_internal_state_clear().
    */
-} mhd_gtls_internals_st;
+} MHD_gtls_internals_st;
 
 struct MHD_gtls_session_int
 {
-  mhd_gtls_security_param_st security_parameters;
-  mhd_gtls_cipher_specs_st cipher_specs;
-  mhd_gtls_conn_stat_st connection_state;
-  mhd_gtls_internals_st internals;
-  mhd_gtls_key_st key;
+  MHD_gtls_security_param_st security_parameters;
+  MHD_gtls_cipher_specs_st cipher_specs;
+  MHD_gtls_conn_stat_st connection_state;
+  MHD_gtls_internals_st internals;
+  MHD_gtls_key_st key;
 };
 
 /* functions */
-void mhd_gtls_set_current_version (mhd_gtls_session_t session,
+void MHD_gtls_set_current_version (MHD_gtls_session_t session,
                                    enum MHD_GNUTLS_Protocol version);
 
-void mhd_gtls_free_auth_info (mhd_gtls_session_t session);
+void MHD_gtls_free_auth_info (MHD_gtls_session_t session);
 
 /* These two macros return the advertized TLS version of
  * the peer.
  */
-#define _gnutls_get_adv_version_major( session) \
+#define MHD__gnutls_get_adv_version_major( session) \
         session->internals.adv_version_major
 
-#define _gnutls_get_adv_version_minor( session) \
+#define MHD__gnutls_get_adv_version_minor( session) \
         session->internals.adv_version_minor
 
 #define set_adv_version( session, major, minor) \
         session->internals.adv_version_major = major; \
         session->internals.adv_version_minor = minor
 
-void mhd_gtls_set_adv_version (mhd_gtls_session_t, enum MHD_GNUTLS_Protocol);
-enum MHD_GNUTLS_Protocol mhd_gtls_get_adv_version (mhd_gtls_session_t);
+void MHD_gtls_set_adv_version (MHD_gtls_session_t, enum MHD_GNUTLS_Protocol);
+enum MHD_GNUTLS_Protocol MHD_gtls_get_adv_version (MHD_gtls_session_t);
 
 #endif /* GNUTLS_INT_H */
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;
 
diff --git a/src/daemon/https/tls/gnutls_kx.h b/src/daemon/https/tls/gnutls_kx.h
index e8bdf199..92144615 100644
--- a/src/daemon/https/tls/gnutls_kx.h
+++ b/src/daemon/https/tls/gnutls_kx.h
@@ -22,19 +22,19 @@
  *
  */
 
-int mhd_gtls_send_server_kx_message (mhd_gtls_session_t session, int again);
-int mhd_gtls_send_client_kx_message (mhd_gtls_session_t session, int again);
-int mhd_gtls_recv_server_kx_message (mhd_gtls_session_t session);
-int mhd_gtls_recv_client_kx_message (mhd_gtls_session_t session);
-int mhd_gtls_send_client_certificate_verify (mhd_gtls_session_t session,
+int MHD_gtls_send_server_kx_message (MHD_gtls_session_t session, int again);
+int MHD_gtls_send_client_kx_message (MHD_gtls_session_t session, int again);
+int MHD_gtls_recv_server_kx_message (MHD_gtls_session_t session);
+int MHD_gtls_recv_client_kx_message (MHD_gtls_session_t session);
+int MHD_gtls_send_client_certificate_verify (MHD_gtls_session_t session,
                                              int again);
-int mhd_gtls_send_server_certificate (mhd_gtls_session_t session, int again);
-int mhd_gtls_generate_master (mhd_gtls_session_t session, int keep_premaster);
-int mhd_gtls_recv_client_certificate (mhd_gtls_session_t session);
-int mhd_gtls_recv_server_certificate (mhd_gtls_session_t session);
-int mhd_gtls_send_client_certificate (mhd_gtls_session_t session, int again);
-int mhd_gtls_recv_server_certificate_request (mhd_gtls_session_t session);
-int mhd_gtls_send_server_certificate_request (mhd_gtls_session_t session,
+int MHD_gtls_send_server_certificate (MHD_gtls_session_t session, int again);
+int MHD_gtls_generate_master (MHD_gtls_session_t session, int keep_premaster);
+int MHD_gtls_recv_client_certificate (MHD_gtls_session_t session);
+int MHD_gtls_recv_server_certificate (MHD_gtls_session_t session);
+int MHD_gtls_send_client_certificate (MHD_gtls_session_t session, int again);
+int MHD_gtls_recv_server_certificate_request (MHD_gtls_session_t session);
+int MHD_gtls_send_server_certificate_request (MHD_gtls_session_t session,
                                               int again);
-int mhd_gtls_recv_client_certificate_verify_message (mhd_gtls_session_t
+int MHD_gtls_recv_client_certificate_verify_message (MHD_gtls_session_t
                                                      session);
diff --git a/src/daemon/https/tls/gnutls_mem.c b/src/daemon/https/tls/gnutls_mem.c
index 2d7537b8..fda4099b 100644
--- a/src/daemon/https/tls/gnutls_mem.c
+++ b/src/daemon/https/tls/gnutls_mem.c
@@ -26,40 +26,40 @@
 #include <gnutls_errors.h>
 #include <gnutls_num.h>
 
-gnutls_alloc_function gnutls_secure_malloc = malloc;
-gnutls_alloc_function gnutls_malloc = malloc;
-gnutls_free_function gnutls_free = free;
-gnutls_realloc_function gnutls_realloc = realloc;
+MHD_gnutls_alloc_function MHD_gnutls_secure_malloc = malloc;
+MHD_gnutls_alloc_function MHD_gnutls_malloc = malloc;
+MHD_gnutls_free_function MHD_gnutls_free = free;
+MHD_gnutls_realloc_function MHD_gnutls_realloc = realloc;
 
-void *(*gnutls_calloc) (size_t, size_t) = calloc;
-char *(*gnutls_strdup) (const char *) = mhd_gtls_strdup;
+void *(*MHD_gnutls_calloc) (size_t, size_t) = calloc;
+char *(*MHD_gnutls_strdup) (const char *) = MHD_gtls_strdup;
 
 int
-_gnutls_is_secure_mem_null (const void *ign)
+MHD__gnutls_is_secure_mem_null (const void *ign)
 {
   return 0;
 }
 
-int (*_gnutls_is_secure_memory) (const void *) = _gnutls_is_secure_mem_null;
+int (*MHD__gnutls_is_secure_memory) (const void *) = MHD__gnutls_is_secure_mem_null;
 
 
 void *
-mhd_gtls_calloc (size_t nmemb, size_t size)
+MHD_gtls_calloc (size_t nmemb, size_t size)
 {
   void *ret;
   size *= nmemb;
-  ret = gnutls_malloc (size);
+  ret = MHD_gnutls_malloc (size);
   if (ret != NULL)
     memset (ret, 0, size);
   return ret;
 }
 
 svoid *
-mhd_gtls_secure_calloc (size_t nmemb, size_t size)
+MHD_gtls_secure_calloc (size_t nmemb, size_t size)
 {
   svoid *ret;
   size *= nmemb;
-  ret = gnutls_secure_malloc (size);
+  ret = MHD_gnutls_secure_malloc (size);
   if (ret != NULL)
     memset (ret, 0, size);
   return ret;
@@ -69,29 +69,29 @@ mhd_gtls_secure_calloc (size_t nmemb, size_t size)
  * fails.
  */
 void *
-mhd_gtls_realloc_fast (void *ptr, size_t size)
+MHD_gtls_realloc_fast (void *ptr, size_t size)
 {
   void *ret;
 
   if (size == 0)
     return ptr;
 
-  ret = gnutls_realloc (ptr, size);
+  ret = MHD_gnutls_realloc (ptr, size);
   if (ret == NULL)
     {
-      gnutls_free (ptr);
+      MHD_gnutls_free (ptr);
     }
 
   return ret;
 }
 
 char *
-mhd_gtls_strdup (const char *str)
+MHD_gtls_strdup (const char *str)
 {
   size_t siz = strlen (str) + 1;
   char *ret;
 
-  ret = gnutls_malloc (siz);
+  ret = MHD_gnutls_malloc (siz);
   if (ret != NULL)
     memcpy (ret, str, siz);
   return ret;
@@ -103,7 +103,7 @@ mhd_gtls_strdup (const char *str)
  */
 
 /**
-  * gnutls_malloc - Allocates and returns data
+  * MHD_gnutls_malloc - Allocates and returns data
   *
   * This function will allocate 's' bytes data, and
   * return a pointer to memory. This function is supposed
@@ -113,12 +113,12 @@ mhd_gtls_strdup (const char *str)
   *
   **/
 void *
-gnutls_malloc (size_t s)
+MHD_gnutls_malloc (size_t s)
 {
 }
 
 /**
-  * gnutls_free - Returns a free() like function
+  * MHD_gnutls_free - Returns a free() like function
   * @d: pointer to memory
   *
   * This function will free data pointed by ptr.
@@ -127,7 +127,7 @@ gnutls_malloc (size_t s)
   *
   **/
 void
-gnutls_free (void *ptr)
+MHD_gnutls_free (void *ptr)
 {
 }
 
diff --git a/src/daemon/https/tls/gnutls_mem.h b/src/daemon/https/tls/gnutls_mem.h
index 51b37e32..86cd4abb 100644
--- a/src/daemon/https/tls/gnutls_mem.h
+++ b/src/daemon/https/tls/gnutls_mem.h
@@ -29,42 +29,42 @@
 # include <dmalloc.h>
 #endif
 
-typedef void svoid;             /* for functions that allocate using gnutls_secure_malloc */
+typedef void svoid;             /* for functions that allocate using MHD_gnutls_secure_malloc */
 
-/* Use gnutls_afree() when calling alloca, or
+/* Use MHD_gnutls_afree() when calling alloca, or
  * memory leaks may occur in systems which do not
  * support alloca.
  */
 #ifdef USE_EFENCE
-# define gnutls_alloca gnutls_malloc
-# define gnutls_afree gnutls_free
+# define MHD_gnutls_alloca MHD_gnutls_malloc
+# define MHD_gnutls_afree MHD_gnutls_free
 #endif
 
 #ifdef HAVE_ALLOCA
 # ifdef HAVE_ALLOCA_H
 #  include <alloca.h>
 # endif
-# ifndef gnutls_alloca
-#  define gnutls_alloca alloca
-#  define gnutls_afree(x)
+# ifndef MHD_gnutls_alloca
+#  define MHD_gnutls_alloca alloca
+#  define MHD_gnutls_afree(x)
 # endif
 #else
-# ifndef gnutls_alloca
-#  define gnutls_alloca gnutls_malloc
-#  define gnutls_afree gnutls_free
+# ifndef MHD_gnutls_alloca
+#  define MHD_gnutls_alloca MHD_gnutls_malloc
+#  define MHD_gnutls_afree MHD_gnutls_free
 # endif
 #endif /* HAVE_ALLOCA */
 
-extern int (*_gnutls_is_secure_memory) (const void *);
+extern int (*MHD__gnutls_is_secure_memory) (const void *);
 
 /* this realloc function will return ptr if size==0, and
  * will free the ptr if the new allocation failed.
  */
-void *mhd_gtls_realloc_fast (void *ptr, size_t size);
+void *MHD_gtls_realloc_fast (void *ptr, size_t size);
 
-svoid *mhd_gtls_secure_calloc (size_t nmemb, size_t size);
+svoid *MHD_gtls_secure_calloc (size_t nmemb, size_t size);
 
-void *mhd_gtls_calloc (size_t nmemb, size_t size);
-char *mhd_gtls_strdup (const char *);
+void *MHD_gtls_calloc (size_t nmemb, size_t size);
+char *MHD_gtls_strdup (const char *);
 
 #endif /* GNUTLS_MEM_H */
diff --git a/src/daemon/https/tls/gnutls_mpi.c b/src/daemon/https/tls/gnutls_mpi.c
index 10831b71..034b189f 100644
--- a/src/daemon/https/tls/gnutls_mpi.c
+++ b/src/daemon/https/tls/gnutls_mpi.c
@@ -35,7 +35,7 @@
  */
 
 void
-mhd_gtls_mpi_release (mpi_t * x)
+MHD_gtls_mpi_release (mpi_t * x)
 {
   if (*x == NULL)
     return;
@@ -46,7 +46,7 @@ mhd_gtls_mpi_release (mpi_t * x)
 /* returns zero on success
  */
 int
-mhd_gtls_mpi_scan (mpi_t * ret_mpi, const opaque * buffer, size_t * nbytes)
+MHD_gtls_mpi_scan (mpi_t * ret_mpi, const opaque * buffer, size_t * nbytes)
 {
   int ret;
 
@@ -60,7 +60,7 @@ mhd_gtls_mpi_scan (mpi_t * ret_mpi, const opaque * buffer, size_t * nbytes)
 /* returns zero on success. Fails if the number is zero.
  */
 int
-mhd_gtls_mpi_scan_nz (mpi_t * ret_mpi, const opaque * buffer, size_t * nbytes)
+MHD_gtls_mpi_scan_nz (mpi_t * ret_mpi, const opaque * buffer, size_t * nbytes)
 {
   int ret;
 
@@ -70,9 +70,9 @@ mhd_gtls_mpi_scan_nz (mpi_t * ret_mpi, const opaque * buffer, size_t * nbytes)
 
   /* MPIs with 0 bits are illegal
    */
-  if (_gnutls_mpi_get_nbits (*ret_mpi) == 0)
+  if (MHD__gnutls_mpi_get_nbits (*ret_mpi) == 0)
     {
-      mhd_gtls_mpi_release (ret_mpi);
+      MHD_gtls_mpi_release (ret_mpi);
       return GNUTLS_E_MPI_SCAN_FAILED;
     }
 
@@ -80,7 +80,7 @@ mhd_gtls_mpi_scan_nz (mpi_t * ret_mpi, const opaque * buffer, size_t * nbytes)
 }
 
 int
-mhd_gtls_mpi_scan_pgp (mpi_t * ret_mpi, const opaque * buffer,
+MHD_gtls_mpi_scan_pgp (mpi_t * ret_mpi, const opaque * buffer,
                        size_t * nbytes)
 {
   int ret;
@@ -90,9 +90,9 @@ mhd_gtls_mpi_scan_pgp (mpi_t * ret_mpi, const opaque * buffer,
 
   /* MPIs with 0 bits are illegal
    */
-  if (_gnutls_mpi_get_nbits (*ret_mpi) == 0)
+  if (MHD__gnutls_mpi_get_nbits (*ret_mpi) == 0)
     {
-      mhd_gtls_mpi_release (ret_mpi);
+      MHD_gtls_mpi_release (ret_mpi);
       return GNUTLS_E_MPI_SCAN_FAILED;
     }
 
@@ -100,7 +100,7 @@ mhd_gtls_mpi_scan_pgp (mpi_t * ret_mpi, const opaque * buffer,
 }
 
 int
-mhd_gtls_mpi_print (void *buffer, size_t * nbytes, const mpi_t a)
+MHD_gtls_mpi_print (void *buffer, size_t * nbytes, const mpi_t a)
 {
   int ret;
 
@@ -116,7 +116,7 @@ mhd_gtls_mpi_print (void *buffer, size_t * nbytes, const mpi_t a)
 
 /* Always has the first bit zero */
 int
-mhd_gtls_mpi_print_lz (void *buffer, size_t * nbytes, const mpi_t a)
+MHD_gtls_mpi_print_lz (void *buffer, size_t * nbytes, const mpi_t a)
 {
   int ret;
 
@@ -132,7 +132,7 @@ mhd_gtls_mpi_print_lz (void *buffer, size_t * nbytes, const mpi_t a)
 
 /* Always has the first bit zero */
 int
-mhd_gtls_mpi_dprint_lz (gnutls_datum_t * dest, const mpi_t a)
+MHD_gtls_mpi_dprint_lz (MHD_gnutls_datum_t * dest, const mpi_t a)
 {
   int ret;
   opaque *buf = NULL;
@@ -144,7 +144,7 @@ mhd_gtls_mpi_dprint_lz (gnutls_datum_t * dest, const mpi_t a)
   gcry_mpi_print (GCRYMPI_FMT_STD, NULL, 0, &bytes, a);
 
   if (bytes != 0)
-    buf = gnutls_malloc (bytes);
+    buf = MHD_gnutls_malloc (bytes);
   if (buf == NULL)
     return GNUTLS_E_MEMORY_ERROR;
 
@@ -156,12 +156,12 @@ mhd_gtls_mpi_dprint_lz (gnutls_datum_t * dest, const mpi_t a)
       return 0;
     }
 
-  gnutls_free (buf);
+  MHD_gnutls_free (buf);
   return GNUTLS_E_MPI_PRINT_FAILED;
 }
 
 int
-mhd_gtls_mpi_dprint (gnutls_datum_t * dest, const mpi_t a)
+MHD_gtls_mpi_dprint (MHD_gnutls_datum_t * dest, const mpi_t a)
 {
   int ret;
   opaque *buf = NULL;
@@ -173,7 +173,7 @@ mhd_gtls_mpi_dprint (gnutls_datum_t * dest, const mpi_t a)
   gcry_mpi_print (GCRYMPI_FMT_USG, NULL, 0, &bytes, a);
 
   if (bytes != 0)
-    buf = gnutls_malloc (bytes);
+    buf = MHD_gnutls_malloc (bytes);
   if (buf == NULL)
     return GNUTLS_E_MEMORY_ERROR;
 
@@ -185,7 +185,7 @@ mhd_gtls_mpi_dprint (gnutls_datum_t * dest, const mpi_t a)
       return 0;
     }
 
-  gnutls_free (buf);
+  MHD_gnutls_free (buf);
   return GNUTLS_E_MPI_PRINT_FAILED;
 }
 
@@ -195,7 +195,7 @@ mhd_gtls_mpi_dprint (gnutls_datum_t * dest, const mpi_t a)
  * steps.
  */
 int
-_gnutls_x509_read_int (ASN1_TYPE node, const char *value, mpi_t * ret_mpi)
+MHD__gnutls_x509_read_int (ASN1_TYPE node, const char *value, mpi_t * ret_mpi)
 {
   int result;
   size_t s_len;
@@ -203,37 +203,37 @@ _gnutls_x509_read_int (ASN1_TYPE node, const char *value, mpi_t * ret_mpi)
   int tmpstr_size;
 
   tmpstr_size = 0;
-  result = asn1_read_value (node, value, NULL, &tmpstr_size);
+  result = MHD__asn1_read_value (node, value, NULL, &tmpstr_size);
   if (result != ASN1_MEM_ERROR)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  tmpstr = gnutls_alloca (tmpstr_size);
+  tmpstr = MHD_gnutls_alloca (tmpstr_size);
   if (tmpstr == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
-  result = asn1_read_value (node, value, tmpstr, &tmpstr_size);
+  result = MHD__asn1_read_value (node, value, tmpstr, &tmpstr_size);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      gnutls_afree (tmpstr);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD_gnutls_afree (tmpstr);
+      return MHD_gtls_asn2err (result);
     }
 
   s_len = tmpstr_size;
-  if (mhd_gtls_mpi_scan (ret_mpi, tmpstr, &s_len) != 0)
+  if (MHD_gtls_mpi_scan (ret_mpi, tmpstr, &s_len) != 0)
     {
-      gnutls_assert ();
-      gnutls_afree (tmpstr);
+      MHD_gnutls_assert ();
+      MHD_gnutls_afree (tmpstr);
       return GNUTLS_E_MPI_SCAN_FAILED;
     }
 
-  gnutls_afree (tmpstr);
+  MHD_gnutls_afree (tmpstr);
 
   return 0;
 }
@@ -241,7 +241,7 @@ _gnutls_x509_read_int (ASN1_TYPE node, const char *value, mpi_t * ret_mpi)
 /* Writes the specified integer into the specified node.
  */
 int
-_gnutls_x509_write_int (ASN1_TYPE node, const char *value, mpi_t mpi, int lz)
+MHD__gnutls_x509_write_int (ASN1_TYPE node, const char *value, mpi_t mpi, int lz)
 {
   opaque *tmpstr;
   size_t s_len;
@@ -249,37 +249,37 @@ _gnutls_x509_write_int (ASN1_TYPE node, const char *value, mpi_t mpi, int lz)
 
   s_len = 0;
   if (lz)
-    result = mhd_gtls_mpi_print_lz (NULL, &s_len, mpi);
+    result = MHD_gtls_mpi_print_lz (NULL, &s_len, mpi);
   else
-    result = mhd_gtls_mpi_print (NULL, &s_len, mpi);
+    result = MHD_gtls_mpi_print (NULL, &s_len, mpi);
 
-  tmpstr = gnutls_alloca (s_len);
+  tmpstr = MHD_gnutls_alloca (s_len);
   if (tmpstr == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
   if (lz)
-    result = mhd_gtls_mpi_print_lz (tmpstr, &s_len, mpi);
+    result = MHD_gtls_mpi_print_lz (tmpstr, &s_len, mpi);
   else
-    result = mhd_gtls_mpi_print (tmpstr, &s_len, mpi);
+    result = MHD_gtls_mpi_print (tmpstr, &s_len, mpi);
 
   if (result != 0)
     {
-      gnutls_assert ();
-      gnutls_afree (tmpstr);
+      MHD_gnutls_assert ();
+      MHD_gnutls_afree (tmpstr);
       return GNUTLS_E_MPI_PRINT_FAILED;
     }
 
-  result = asn1_write_value (node, value, tmpstr, s_len);
+  result = MHD__asn1_write_value (node, value, tmpstr, s_len);
 
-  gnutls_afree (tmpstr);
+  MHD_gnutls_afree (tmpstr);
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   return 0;
diff --git a/src/daemon/https/tls/gnutls_mpi.h b/src/daemon/https/tls/gnutls_mpi.h
index 24d60c8a..ec633ca0 100644
--- a/src/daemon/https/tls/gnutls_mpi.h
+++ b/src/daemon/https/tls/gnutls_mpi.h
@@ -33,46 +33,46 @@
 
 typedef gcry_mpi_t mpi_t;
 
-#define _gnutls_mpi_cmp gcry_mpi_cmp
-#define _gnutls_mpi_cmp_ui gcry_mpi_cmp_ui
-#define _gnutls_mpi_mod gcry_mpi_mod
-#define _gnutls_mpi_new gcry_mpi_new
-#define _gnutls_mpi_snew gcry_mpi_snew
-#define _gnutls_mpi_copy gcry_mpi_copy
-#define _gnutls_mpi_set_ui gcry_mpi_set_ui
-#define _gnutls_mpi_set gcry_mpi_set
-#define _gnutls_mpi_randomize gcry_mpi_randomize
-#define _gnutls_mpi_get_nbits gcry_mpi_get_nbits
-#define _gnutls_mpi_powm gcry_mpi_powm
-#define _gnutls_mpi_invm gcry_mpi_invm
-#define _gnutls_mpi_addm gcry_mpi_addm
-#define _gnutls_mpi_subm gcry_mpi_subm
-#define _gnutls_mpi_sub_ui gcry_mpi_sub_ui
-#define _gnutls_mpi_mulm gcry_mpi_mulm
-#define _gnutls_mpi_mul gcry_mpi_mul
-#define _gnutls_mpi_add gcry_mpi_add
-#define _gnutls_mpi_add_ui gcry_mpi_add_ui
-#define _gnutls_mpi_sub_ui gcry_mpi_sub_ui
-#define _gnutls_mpi_mul_ui gcry_mpi_mul_ui
-#define _gnutls_prime_check gcry_prime_check
-#define _gnutls_mpi_div gcry_mpi_div
+#define MHD__gnutls_mpi_cmp gcry_mpi_cmp
+#define MHD__gnutls_mpi_cmp_ui gcry_mpi_cmp_ui
+#define MHD__gnutls_mpi_mod gcry_mpi_mod
+#define MHD__gnutls_mpi_new gcry_mpi_new
+#define MHD__gnutls_mpi_snew gcry_mpi_snew
+#define MHD__gnutls_mpi_copy gcry_mpi_copy
+#define MHD__gnutls_mpi_set_ui gcry_mpi_set_ui
+#define MHD__gnutls_mpi_set gcry_mpi_set
+#define MHD__gnutls_mpi_randomize gcry_mpi_randomize
+#define MHD__gnutls_mpi_get_nbits gcry_mpi_get_nbits
+#define MHD__gnutls_mpi_powm gcry_mpi_powm
+#define MHD__gnutls_mpi_invm gcry_mpi_invm
+#define MHD__gnutls_mpi_addm gcry_mpi_addm
+#define MHD__gnutls_mpi_subm gcry_mpi_subm
+#define MHD__gnutls_mpi_sub_ui gcry_mpi_sub_ui
+#define MHD__gnutls_mpi_mulm gcry_mpi_mulm
+#define MHD__gnutls_mpi_mul gcry_mpi_mul
+#define MHD__gnutls_mpi_add gcry_mpi_add
+#define MHD__gnutls_mpi_add_ui gcry_mpi_add_ui
+#define MHD__gnutls_mpi_sub_ui gcry_mpi_sub_ui
+#define MHD__gnutls_mpi_mul_ui gcry_mpi_mul_ui
+#define MHD__gnutls_prime_check gcry_prime_check
+#define MHD__gnutls_mpi_div gcry_mpi_div
 
-#define _gnutls_mpi_alloc_like(x) _gnutls_mpi_new(_gnutls_mpi_get_nbits(x))
-#define _gnutls_mpi_salloc_like(x) _gnutls_mpi_snew(_gnutls_mpi_get_nbits(x))
+#define MHD__gnutls_mpi_alloc_like(x) MHD__gnutls_mpi_new(MHD__gnutls_mpi_get_nbits(x))
+#define MHD__gnutls_mpi_salloc_like(x) MHD__gnutls_mpi_snew(MHD__gnutls_mpi_get_nbits(x))
 
-void mhd_gtls_mpi_release (mpi_t * x);
+void MHD_gtls_mpi_release (mpi_t * x);
 
-int mhd_gtls_mpi_scan_nz (mpi_t * ret_mpi, const opaque * buffer,
+int MHD_gtls_mpi_scan_nz (mpi_t * ret_mpi, const opaque * buffer,
                           size_t * nbytes);
-int mhd_gtls_mpi_scan (mpi_t * ret_mpi, const opaque * buffer,
+int MHD_gtls_mpi_scan (mpi_t * ret_mpi, const opaque * buffer,
                        size_t * nbytes);
-int mhd_gtls_mpi_scan_pgp (mpi_t * ret_mpi, const opaque * buffer,
+int MHD_gtls_mpi_scan_pgp (mpi_t * ret_mpi, const opaque * buffer,
                            size_t * nbytes);
 
-int mhd_gtls_mpi_print (void *buffer, size_t * nbytes, const mpi_t a);
-int mhd_gtls_mpi_print_lz (void *buffer, size_t * nbytes, const mpi_t a);
+int MHD_gtls_mpi_print (void *buffer, size_t * nbytes, const mpi_t a);
+int MHD_gtls_mpi_print_lz (void *buffer, size_t * nbytes, const mpi_t a);
 
-int mhd_gtls_mpi_dprint_lz (gnutls_datum_t * dest, const mpi_t a);
-int mhd_gtls_mpi_dprint (gnutls_datum_t * dest, const mpi_t a);
+int MHD_gtls_mpi_dprint_lz (MHD_gnutls_datum_t * dest, const mpi_t a);
+int MHD_gtls_mpi_dprint (MHD_gnutls_datum_t * dest, const mpi_t a);
 
 #endif
diff --git a/src/daemon/https/tls/gnutls_num.c b/src/daemon/https/tls/gnutls_num.c
index ab5c7196..06d2e4eb 100644
--- a/src/daemon/https/tls/gnutls_num.c
+++ b/src/daemon/https/tls/gnutls_num.c
@@ -35,7 +35,7 @@
  * has been reached.
  */
 int
-mhd_gtls_uint64pp (uint64 * x)
+MHD_gtls_uint64pp (uint64 * x)
 {
   register int i, y = 0;
 
@@ -60,7 +60,7 @@ mhd_gtls_uint64pp (uint64 * x)
 }
 
 uint32_t
-mhd_gtls_uint24touint32 (uint24 num)
+MHD_gtls_uint24touint32 (uint24 num)
 {
   uint32_t ret = 0;
 
@@ -71,7 +71,7 @@ mhd_gtls_uint24touint32 (uint24 num)
 }
 
 uint24
-mhd_gtls_uint32touint24 (uint32_t num)
+MHD_gtls_uint32touint24 (uint32_t num)
 {
   uint24 ret;
 
@@ -84,7 +84,7 @@ mhd_gtls_uint32touint24 (uint32_t num)
 
 /* data should be at least 3 bytes */
 uint32_t
-mhd_gtls_read_uint24 (const opaque * data)
+MHD_gtls_read_uint24 (const opaque * data)
 {
   uint32_t res;
   uint24 num;
@@ -93,7 +93,7 @@ mhd_gtls_read_uint24 (const opaque * data)
   num.pint[1] = data[1];
   num.pint[2] = data[2];
 
-  res = mhd_gtls_uint24touint32 (num);
+  res = MHD_gtls_uint24touint32 (num);
 #ifndef WORDS_BIGENDIAN
   res = byteswap32 (res);
 #endif
@@ -101,14 +101,14 @@ mhd_gtls_read_uint24 (const opaque * data)
 }
 
 void
-mhd_gtls_write_uint24 (uint32_t num, opaque * data)
+MHD_gtls_write_uint24 (uint32_t num, opaque * data)
 {
   uint24 tmp;
 
 #ifndef WORDS_BIGENDIAN
   num = byteswap32 (num);
 #endif
-  tmp = mhd_gtls_uint32touint24 (num);
+  tmp = MHD_gtls_uint32touint24 (num);
 
   data[0] = tmp.pint[0];
   data[1] = tmp.pint[1];
@@ -116,7 +116,7 @@ mhd_gtls_write_uint24 (uint32_t num, opaque * data)
 }
 
 uint32_t
-mhd_gtls_read_uint32 (const opaque * data)
+MHD_gtls_read_uint32 (const opaque * data)
 {
   uint32_t res;
 
@@ -128,7 +128,7 @@ mhd_gtls_read_uint32 (const opaque * data)
 }
 
 void
-mhd_gtls_write_uint32 (uint32_t num, opaque * data)
+MHD_gtls_write_uint32 (uint32_t num, opaque * data)
 {
 
 #ifndef WORDS_BIGENDIAN
@@ -138,7 +138,7 @@ mhd_gtls_write_uint32 (uint32_t num, opaque * data)
 }
 
 uint16_t
-mhd_gtls_read_uint16 (const opaque * data)
+MHD_gtls_read_uint16 (const opaque * data)
 {
   uint16_t res;
   memcpy (&res, data, sizeof (uint16_t));
@@ -149,7 +149,7 @@ mhd_gtls_read_uint16 (const opaque * data)
 }
 
 void
-mhd_gtls_write_uint16 (uint16_t num, opaque * data)
+MHD_gtls_write_uint16 (uint16_t num, opaque * data)
 {
 
 #ifndef WORDS_BIGENDIAN
@@ -159,7 +159,7 @@ mhd_gtls_write_uint16 (uint16_t num, opaque * data)
 }
 
 uint32_t
-mhd_gtls_conv_uint32 (uint32_t data)
+MHD_gtls_conv_uint32 (uint32_t data)
 {
 #ifndef WORDS_BIGENDIAN
   return byteswap32 (data);
@@ -169,7 +169,7 @@ mhd_gtls_conv_uint32 (uint32_t data)
 }
 
 uint16_t
-mhd_gtls_conv_uint16 (uint16_t data)
+MHD_gtls_conv_uint16 (uint16_t data)
 {
 #ifndef WORDS_BIGENDIAN
   return byteswap16 (data);
@@ -179,7 +179,7 @@ mhd_gtls_conv_uint16 (uint16_t data)
 }
 
 uint32_t
-mhd_gtls_uint64touint32 (const uint64 * num)
+MHD_gtls_uint64touint32 (const uint64 * num)
 {
   uint32_t ret;
 
diff --git a/src/daemon/https/tls/gnutls_num.h b/src/daemon/https/tls/gnutls_num.h
index 37ce0c6d..13d1e3ae 100644
--- a/src/daemon/https/tls/gnutls_num.h
+++ b/src/daemon/https/tls/gnutls_num.h
@@ -32,18 +32,18 @@
 #define byteswap16(x)  ((rotl16(x, 8) & 0x00ff) | (rotr16(x, 8) & 0xff00))
 #define byteswap32(x)  ((rotl32(x, 8) & 0x00ff00ffUL) | (rotr32(x, 8) & 0xff00ff00UL))
 
-uint32_t mhd_gtls_uint24touint32 (uint24 num);
-uint24 mhd_gtls_uint32touint24 (uint32_t num);
-uint32_t mhd_gtls_read_uint32 (const opaque * data);
-uint16_t mhd_gtls_read_uint16 (const opaque * data);
-uint32_t mhd_gtls_conv_uint32 (uint32_t data);
-uint16_t mhd_gtls_conv_uint16 (uint16_t data);
-uint32_t mhd_gtls_read_uint24 (const opaque * data);
-void mhd_gtls_write_uint24 (uint32_t num, opaque * data);
-void mhd_gtls_write_uint32 (uint32_t num, opaque * data);
-void mhd_gtls_write_uint16 (uint16_t num, opaque * data);
-uint32_t mhd_gtls_uint64touint32 (const uint64 *);
+uint32_t MHD_gtls_uint24touint32 (uint24 num);
+uint24 MHD_gtls_uint32touint24 (uint32_t num);
+uint32_t MHD_gtls_read_uint32 (const opaque * data);
+uint16_t MHD_gtls_read_uint16 (const opaque * data);
+uint32_t MHD_gtls_conv_uint32 (uint32_t data);
+uint16_t MHD_gtls_conv_uint16 (uint16_t data);
+uint32_t MHD_gtls_read_uint24 (const opaque * data);
+void MHD_gtls_write_uint24 (uint32_t num, opaque * data);
+void MHD_gtls_write_uint32 (uint32_t num, opaque * data);
+void MHD_gtls_write_uint16 (uint16_t num, opaque * data);
+uint32_t MHD_gtls_uint64touint32 (const uint64 *);
 
-int mhd_gtls_uint64pp (uint64 *);
-# define _gnutls_uint64zero(x) x.i[0] = x.i[1] = x.i[2] = x.i[3] = x.i[4] = x.i[5] = x.i[6] = x.i[7] = 0
+int MHD_gtls_uint64pp (uint64 *);
+# define MHD__gnutls_uint64zero(x) x.i[0] = x.i[1] = x.i[2] = x.i[3] = x.i[4] = x.i[5] = x.i[6] = x.i[7] = 0
 # define UINT64DATA(x) x.i
diff --git a/src/daemon/https/tls/gnutls_pk.c b/src/daemon/https/tls/gnutls_pk.c
index 20f17951..53bc6394 100644
--- a/src/daemon/https/tls/gnutls_pk.c
+++ b/src/daemon/https/tls/gnutls_pk.c
@@ -40,13 +40,13 @@
 #include "common.h"
 #include "mpi.h"
 
-static int _gnutls_pk_encrypt (int algo, mpi_t * resarr, mpi_t data,
+static int MHD__gnutls_pk_encrypt (int algo, mpi_t * resarr, mpi_t data,
                                mpi_t * pkey, int pkey_len);
-static int _gnutls_pk_sign (int algo, mpi_t * data, mpi_t hash,
+static int MHD__gnutls_pk_sign (int algo, mpi_t * data, mpi_t hash,
                             mpi_t * pkey, int);
-static int _gnutls_pk_verify (int algo, mpi_t hash, mpi_t * data,
+static int MHD__gnutls_pk_verify (int algo, mpi_t hash, mpi_t * data,
                               mpi_t * pkey, int);
-static int _gnutls_pk_decrypt (int algo, mpi_t * resarr, mpi_t data,
+static int MHD__gnutls_pk_decrypt (int algo, mpi_t * resarr, mpi_t data,
                                mpi_t * pkey, int);
 
 
@@ -54,8 +54,8 @@ static int _gnutls_pk_decrypt (int algo, mpi_t * resarr, mpi_t data,
  * params is modulus, public exp.
  */
 int
-mhd_gtls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
-                            const gnutls_datum_t * plaintext,
+MHD_gtls_pkcs1_rsa_encrypt (MHD_gnutls_datum_t * ciphertext,
+                            const MHD_gnutls_datum_t * plaintext,
                             mpi_t * params, unsigned params_len,
                             unsigned btype)
 {
@@ -66,21 +66,21 @@ mhd_gtls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
   size_t k, psize;
   size_t mod_bits;
 
-  mod_bits = _gnutls_mpi_get_nbits (params[0]);
+  mod_bits = MHD__gnutls_mpi_get_nbits (params[0]);
   k = mod_bits / 8;
   if (mod_bits % 8 != 0)
     k++;
 
   if (plaintext->size > k - 11)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_PK_ENCRYPTION_FAILED;
     }
 
-  edata = gnutls_alloca (k);
+  edata = MHD_gnutls_alloca (k);
   if (edata == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
@@ -99,24 +99,24 @@ mhd_gtls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
       /* using public key */
       if (params_len < RSA_PUBLIC_PARAMS)
         {
-          gnutls_assert ();
-          gnutls_afree (edata);
+          MHD_gnutls_assert ();
+          MHD_gnutls_afree (edata);
           return GNUTLS_E_INTERNAL_ERROR;
         }
 
-      if (gc_pseudo_random (ps, psize) != GC_OK)
+      if (MHD_gc_pseudo_random (ps, psize) != GC_OK)
         {
-          gnutls_assert ();
-          gnutls_afree (edata);
+          MHD_gnutls_assert ();
+          MHD_gnutls_afree (edata);
           return GNUTLS_E_RANDOM_FAILED;
         }
       for (i = 0; i < psize; i++)
         while (ps[i] == 0)
           {
-            if (gc_pseudo_random (&ps[i], 1) != GC_OK)
+            if (MHD_gc_pseudo_random (&ps[i], 1) != GC_OK)
               {
-                gnutls_assert ();
-                gnutls_afree (edata);
+                MHD_gnutls_assert ();
+                MHD_gnutls_afree (edata);
                 return GNUTLS_E_RANDOM_FAILED;
               }
           }
@@ -126,8 +126,8 @@ mhd_gtls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
 
       if (params_len < RSA_PRIVATE_PARAMS)
         {
-          gnutls_assert ();
-          gnutls_afree (edata);
+          MHD_gnutls_assert ();
+          MHD_gnutls_afree (edata);
           return GNUTLS_E_INTERNAL_ERROR;
         }
 
@@ -135,36 +135,36 @@ mhd_gtls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
         ps[i] = 0xff;
       break;
     default:
-      gnutls_assert ();
-      gnutls_afree (edata);
+      MHD_gnutls_assert ();
+      MHD_gnutls_afree (edata);
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
   ps[psize] = 0;
   memcpy (&ps[psize + 1], plaintext->data, plaintext->size);
 
-  if (mhd_gtls_mpi_scan_nz (&m, edata, &k) != 0)
+  if (MHD_gtls_mpi_scan_nz (&m, edata, &k) != 0)
     {
-      gnutls_assert ();
-      gnutls_afree (edata);
+      MHD_gnutls_assert ();
+      MHD_gnutls_afree (edata);
       return GNUTLS_E_MPI_SCAN_FAILED;
     }
-  gnutls_afree (edata);
+  MHD_gnutls_afree (edata);
 
   if (btype == 2)               /* encrypt */
-    ret = _gnutls_pk_encrypt (GCRY_PK_RSA, &res, m, params, params_len);
+    ret = MHD__gnutls_pk_encrypt (GCRY_PK_RSA, &res, m, params, params_len);
   else                          /* sign */
-    ret = _gnutls_pk_sign (GCRY_PK_RSA, &res, m, params, params_len);
+    ret = MHD__gnutls_pk_sign (GCRY_PK_RSA, &res, m, params, params_len);
 
-  mhd_gtls_mpi_release (&m);
+  MHD_gtls_mpi_release (&m);
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  mhd_gtls_mpi_print (NULL, &psize, res);
+  MHD_gtls_mpi_print (NULL, &psize, res);
 
   if (psize < k)
     {
@@ -179,25 +179,25 @@ mhd_gtls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
   else
     {                           /* psize > k !!! */
       /* This is an impossible situation */
-      gnutls_assert ();
-      mhd_gtls_mpi_release (&res);
+      MHD_gnutls_assert ();
+      MHD_gtls_mpi_release (&res);
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
-  ciphertext->data = gnutls_malloc (psize);
+  ciphertext->data = MHD_gnutls_malloc (psize);
   if (ciphertext->data == NULL)
     {
-      gnutls_assert ();
-      mhd_gtls_mpi_release (&res);
+      MHD_gnutls_assert ();
+      MHD_gtls_mpi_release (&res);
       return GNUTLS_E_MEMORY_ERROR;
     }
-  mhd_gtls_mpi_print (&ciphertext->data[pad], &psize, res);
+  MHD_gtls_mpi_print (&ciphertext->data[pad], &psize, res);
   for (i = 0; i < pad; i++)
     ciphertext->data[i] = 0;
 
   ciphertext->size = k;
 
-  mhd_gtls_mpi_release (&res);
+  MHD_gtls_mpi_release (&res);
 
   return 0;
 }
@@ -208,8 +208,8 @@ mhd_gtls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
  * Can decrypt block type 1 and type 2 packets.
  */
 int
-mhd_gtls_pkcs1_rsa_decrypt (gnutls_datum_t * plaintext,
-                            const gnutls_datum_t * ciphertext,
+MHD_gtls_pkcs1_rsa_decrypt (MHD_gnutls_datum_t * plaintext,
+                            const MHD_gnutls_datum_t * ciphertext,
                             mpi_t * params, unsigned params_len,
                             unsigned btype)
 {
@@ -219,7 +219,7 @@ mhd_gtls_pkcs1_rsa_decrypt (gnutls_datum_t * plaintext,
   opaque *edata;
   size_t esize, mod_bits;
 
-  mod_bits = _gnutls_mpi_get_nbits (params[0]);
+  mod_bits = MHD__gnutls_mpi_get_nbits (params[0]);
   k = mod_bits / 8;
   if (mod_bits % 8 != 0)
     k++;
@@ -228,13 +228,13 @@ mhd_gtls_pkcs1_rsa_decrypt (gnutls_datum_t * plaintext,
 
   if (esize != k)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_PK_DECRYPTION_FAILED;
     }
 
-  if (mhd_gtls_mpi_scan_nz (&c, ciphertext->data, &esize) != 0)
+  if (MHD_gtls_mpi_scan_nz (&c, ciphertext->data, &esize) != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MPI_SCAN_FAILED;
     }
 
@@ -242,30 +242,30 @@ mhd_gtls_pkcs1_rsa_decrypt (gnutls_datum_t * plaintext,
    * available.
    */
   if (btype == 2)
-    ret = _gnutls_pk_decrypt (GCRY_PK_RSA, &res, c, params, params_len);
+    ret = MHD__gnutls_pk_decrypt (GCRY_PK_RSA, &res, c, params, params_len);
   else
     {
-      ret = _gnutls_pk_encrypt (GCRY_PK_RSA, &res, c, params, params_len);
+      ret = MHD__gnutls_pk_encrypt (GCRY_PK_RSA, &res, c, params, params_len);
     }
-  mhd_gtls_mpi_release (&c);
+  MHD_gtls_mpi_release (&c);
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  mhd_gtls_mpi_print (NULL, &esize, res);
-  edata = gnutls_alloca (esize + 1);
+  MHD_gtls_mpi_print (NULL, &esize, res);
+  edata = MHD_gnutls_alloca (esize + 1);
   if (edata == NULL)
     {
-      gnutls_assert ();
-      mhd_gtls_mpi_release (&res);
+      MHD_gnutls_assert ();
+      MHD_gtls_mpi_release (&res);
       return GNUTLS_E_MEMORY_ERROR;
     }
-  mhd_gtls_mpi_print (&edata[1], &esize, res);
+  MHD_gtls_mpi_print (&edata[1], &esize, res);
 
-  mhd_gtls_mpi_release (&res);
+  MHD_gtls_mpi_release (&res);
 
   /* EB = 00||BT||PS||00||D
    * (use block type 'btype')
@@ -282,8 +282,8 @@ mhd_gtls_pkcs1_rsa_decrypt (gnutls_datum_t * plaintext,
 
   if (edata[0] != 0 || edata[1] != btype)
     {
-      gnutls_assert ();
-      gnutls_afree (edata);
+      MHD_gnutls_assert ();
+      MHD_gnutls_afree (edata);
       return GNUTLS_E_DECRYPTION_FAILED;
     }
 
@@ -310,7 +310,7 @@ mhd_gtls_pkcs1_rsa_decrypt (gnutls_datum_t * plaintext,
             }
           if (edata[i] != 0xff)
             {
-              _gnutls_handshake_log ("PKCS #1 padding error");
+              MHD__gnutls_handshake_log ("PKCS #1 padding error");
               /* PKCS #1 padding error.  Don't use
                  GNUTLS_E_PKCS1_WRONG_PAD here.  */
               break;
@@ -318,65 +318,65 @@ mhd_gtls_pkcs1_rsa_decrypt (gnutls_datum_t * plaintext,
         }
       break;
     default:
-      gnutls_assert ();
-      gnutls_afree (edata);
+      MHD_gnutls_assert ();
+      MHD_gnutls_afree (edata);
       return GNUTLS_E_DECRYPTION_FAILED;
     }
   i++;
 
   if (ret < 0)
     {
-      gnutls_assert ();
-      gnutls_afree (edata);
+      MHD_gnutls_assert ();
+      MHD_gnutls_afree (edata);
       return GNUTLS_E_DECRYPTION_FAILED;
     }
 
-  if (_gnutls_sset_datum (plaintext, &edata[i], esize - i) < 0)
+  if (MHD__gnutls_sset_datum (plaintext, &edata[i], esize - i) < 0)
     {
-      gnutls_assert ();
-      gnutls_afree (edata);
+      MHD_gnutls_assert ();
+      MHD_gnutls_afree (edata);
       return GNUTLS_E_MEMORY_ERROR;
     }
 
-  gnutls_afree (edata);
+  MHD_gnutls_afree (edata);
 
   return 0;
 }
 
 
 int
-mhd_gtls_rsa_verify (const gnutls_datum_t * vdata,
-                     const gnutls_datum_t * ciphertext, mpi_t * params,
+MHD_gtls_rsa_verify (const MHD_gnutls_datum_t * vdata,
+                     const MHD_gnutls_datum_t * ciphertext, mpi_t * params,
                      int params_len, int btype)
 {
 
-  gnutls_datum_t plain;
+  MHD_gnutls_datum_t plain;
   int ret;
 
   /* decrypt signature */
   if ((ret =
-       mhd_gtls_pkcs1_rsa_decrypt (&plain, ciphertext, params, params_len,
+       MHD_gtls_pkcs1_rsa_decrypt (&plain, ciphertext, params, params_len,
                                    btype)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
   if (plain.size != vdata->size)
     {
-      gnutls_assert ();
-      _gnutls_free_datum (&plain);
+      MHD_gnutls_assert ();
+      MHD__gnutls_free_datum (&plain);
       return GNUTLS_E_PK_SIG_VERIFY_FAILED;
     }
 
   if (memcmp (plain.data, vdata->data, plain.size) != 0)
     {
-      gnutls_assert ();
-      _gnutls_free_datum (&plain);
+      MHD_gnutls_assert ();
+      MHD__gnutls_free_datum (&plain);
       return GNUTLS_E_PK_SIG_VERIFY_FAILED;
     }
 
-  _gnutls_free_datum (&plain);
+  MHD__gnutls_free_datum (&plain);
 
   return 0;                     /* ok */
 }
@@ -384,45 +384,45 @@ mhd_gtls_rsa_verify (const gnutls_datum_t * vdata,
 /* encodes the Dss-Sig-Value structure
  */
 static int
-encode_ber_rs (gnutls_datum_t * sig_value, mpi_t r, mpi_t s)
+encode_ber_rs (MHD_gnutls_datum_t * sig_value, mpi_t r, mpi_t s)
 {
   ASN1_TYPE sig;
   int result, tot_len;
 
   if ((result =
-       asn1_create_element (_gnutls_get_gnutls_asn (),
+       MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (),
                             "GNUTLS.DSASignatureValue",
                             &sig)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  result = _gnutls_x509_write_int (sig, "r", r, 1);
+  result = MHD__gnutls_x509_write_int (sig, "r", r, 1);
   if (result < 0)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&sig);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&sig);
       return result;
     }
 
-  result = _gnutls_x509_write_int (sig, "s", s, 1);
+  result = MHD__gnutls_x509_write_int (sig, "s", s, 1);
   if (result < 0)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&sig);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&sig);
       return result;
     }
 
   tot_len = 0;
 
-  result = _gnutls_x509_der_encode (sig, "", sig_value, 0);
+  result = MHD__gnutls_x509_der_encode (sig, "", sig_value, 0);
 
-  asn1_delete_structure (&sig);
+  MHD__asn1_delete_structure (&sig);
 
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -433,8 +433,8 @@ encode_ber_rs (gnutls_datum_t * sig_value, mpi_t r, mpi_t s)
 /* Do DSA signature calculation. params is p, q, g, y, x in that order.
  */
 int
-mhd_gtls_dsa_sign (gnutls_datum_t * signature,
-                   const gnutls_datum_t * hash, mpi_t * params,
+MHD_gtls_dsa_sign (MHD_gnutls_datum_t * signature,
+                   const MHD_gnutls_datum_t * hash, mpi_t * params,
                    unsigned params_len)
 {
   mpi_t rs[2], mdata;
@@ -444,35 +444,35 @@ mhd_gtls_dsa_sign (gnutls_datum_t * signature,
   k = hash->size;
   if (k < 20)
     {                           /* SHA1 or better only */
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_PK_SIGN_FAILED;
     }
 
-  if (mhd_gtls_mpi_scan_nz (&mdata, hash->data, &k) != 0)
+  if (MHD_gtls_mpi_scan_nz (&mdata, hash->data, &k) != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MPI_SCAN_FAILED;
     }
 
-  ret = _gnutls_pk_sign (GCRY_PK_DSA, rs, mdata, params, params_len);
+  ret = MHD__gnutls_pk_sign (GCRY_PK_DSA, rs, mdata, params, params_len);
   /* rs[0], rs[1] now hold r,s */
-  mhd_gtls_mpi_release (&mdata);
+  MHD_gtls_mpi_release (&mdata);
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
   ret = encode_ber_rs (signature, rs[0], rs[1]);
 
   /* free r,s */
-  mhd_gtls_mpi_release (&rs[0]);
-  mhd_gtls_mpi_release (&rs[1]);
+  MHD_gtls_mpi_release (&rs[0]);
+  MHD_gtls_mpi_release (&rs[1]);
 
   if (ret != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
@@ -482,46 +482,46 @@ mhd_gtls_dsa_sign (gnutls_datum_t * signature,
 /* decodes the Dss-Sig-Value structure
  */
 static int
-decode_ber_rs (const gnutls_datum_t * sig_value, mpi_t * r, mpi_t * s)
+decode_ber_rs (const MHD_gnutls_datum_t * sig_value, mpi_t * r, mpi_t * s)
 {
   ASN1_TYPE sig;
   int result;
 
   if ((result =
-       asn1_create_element (_gnutls_get_gnutls_asn (),
+       MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (),
                             "GNUTLS.DSASignatureValue",
                             &sig)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  result = asn1_der_decoding (&sig, sig_value->data, sig_value->size, NULL);
+  result = MHD__asn1_der_decoding (&sig, sig_value->data, sig_value->size, NULL);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&sig);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&sig);
+      return MHD_gtls_asn2err (result);
     }
 
-  result = _gnutls_x509_read_int (sig, "r", r);
+  result = MHD__gnutls_x509_read_int (sig, "r", r);
   if (result < 0)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&sig);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&sig);
       return result;
     }
 
-  result = _gnutls_x509_read_int (sig, "s", s);
+  result = MHD__gnutls_x509_read_int (sig, "s", s);
   if (result < 0)
     {
-      gnutls_assert ();
-      mhd_gtls_mpi_release (s);
-      asn1_delete_structure (&sig);
+      MHD_gnutls_assert ();
+      MHD_gtls_mpi_release (s);
+      MHD__asn1_delete_structure (&sig);
       return result;
     }
 
-  asn1_delete_structure (&sig);
+  MHD__asn1_delete_structure (&sig);
 
   return 0;
 }
@@ -529,8 +529,8 @@ decode_ber_rs (const gnutls_datum_t * sig_value, mpi_t * r, mpi_t * s)
 /* params is p, q, g, y in that order
  */
 int
-mhd_gtls_dsa_verify (const gnutls_datum_t * vdata,
-                     const gnutls_datum_t * sig_value, mpi_t * params,
+MHD_gtls_dsa_verify (const MHD_gnutls_datum_t * vdata,
+                     const MHD_gnutls_datum_t * sig_value, mpi_t * params,
                      int params_len)
 {
 
@@ -541,34 +541,34 @@ mhd_gtls_dsa_verify (const gnutls_datum_t * vdata,
 
   if (vdata->size != 20)
     {                           /* sha-1 only */
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_PK_SIG_VERIFY_FAILED;
     }
 
   if (decode_ber_rs (sig_value, &rs[0], &rs[1]) != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MPI_SCAN_FAILED;
     }
 
   k = vdata->size;
-  if (mhd_gtls_mpi_scan_nz (&mdata, vdata->data, &k) != 0)
+  if (MHD_gtls_mpi_scan_nz (&mdata, vdata->data, &k) != 0)
     {
-      gnutls_assert ();
-      mhd_gtls_mpi_release (&rs[0]);
-      mhd_gtls_mpi_release (&rs[1]);
+      MHD_gnutls_assert ();
+      MHD_gtls_mpi_release (&rs[0]);
+      MHD_gtls_mpi_release (&rs[1]);
       return GNUTLS_E_MPI_SCAN_FAILED;
     }
 
   /* decrypt signature */
-  ret = _gnutls_pk_verify (GCRY_PK_DSA, mdata, rs, params, params_len);
-  mhd_gtls_mpi_release (&mdata);
-  mhd_gtls_mpi_release (&rs[0]);
-  mhd_gtls_mpi_release (&rs[1]);
+  ret = MHD__gnutls_pk_verify (GCRY_PK_DSA, mdata, rs, params, params_len);
+  MHD_gtls_mpi_release (&mdata);
+  MHD_gtls_mpi_release (&rs[0]);
+  MHD_gtls_mpi_release (&rs[1]);
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -584,7 +584,7 @@ mhd_gtls_dsa_verify (const gnutls_datum_t * vdata,
  * change the internal design to directly fit to libgcrypt.
  */
 static int
-_gnutls_pk_encrypt (int algo, mpi_t * resarr, mpi_t data,
+MHD__gnutls_pk_encrypt (int algo, mpi_t * resarr, mpi_t data,
                     mpi_t * pkey, int pkey_len)
 {
   gcry_sexp_t s_ciph, s_data, s_pkey;
@@ -601,20 +601,20 @@ _gnutls_pk_encrypt (int algo, mpi_t * resarr, mpi_t data,
       break;
 
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
   if (rc != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
   /* put the data into a simple list */
   if (gcry_sexp_build (&s_data, NULL, "%m", data))
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       gcry_sexp_release (s_pkey);
       return GNUTLS_E_INTERNAL_ERROR;
     }
@@ -626,7 +626,7 @@ _gnutls_pk_encrypt (int algo, mpi_t * resarr, mpi_t data,
 
   if (rc != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_PK_ENCRYPTION_FAILED;
 
     }
@@ -635,7 +635,7 @@ _gnutls_pk_encrypt (int algo, mpi_t * resarr, mpi_t data,
       gcry_sexp_t list = gcry_sexp_find_token (s_ciph, "a", 0);
       if (list == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           gcry_sexp_release (s_ciph);
           return GNUTLS_E_INTERNAL_ERROR;
         }
@@ -645,7 +645,7 @@ _gnutls_pk_encrypt (int algo, mpi_t * resarr, mpi_t data,
 
       if (resarr[0] == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           gcry_sexp_release (s_ciph);
           return GNUTLS_E_INTERNAL_ERROR;
         }
@@ -656,7 +656,7 @@ _gnutls_pk_encrypt (int algo, mpi_t * resarr, mpi_t data,
 }
 
 static int
-_gnutls_pk_decrypt (int algo, mpi_t * resarr, mpi_t data, mpi_t * pkey,
+MHD__gnutls_pk_decrypt (int algo, mpi_t * resarr, mpi_t data, mpi_t * pkey,
                     int pkey_len)
 {
   gcry_sexp_t s_plain, s_data, s_pkey;
@@ -674,20 +674,20 @@ _gnutls_pk_decrypt (int algo, mpi_t * resarr, mpi_t data, mpi_t * pkey,
       break;
 
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
   if (rc != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
   /* put the data into a simple list */
   if (gcry_sexp_build (&s_data, NULL, "(enc-val(rsa(a%m)))", data))
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       gcry_sexp_release (s_pkey);
       return GNUTLS_E_INTERNAL_ERROR;
     }
@@ -699,7 +699,7 @@ _gnutls_pk_decrypt (int algo, mpi_t * resarr, mpi_t data, mpi_t * pkey,
 
   if (rc != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_PK_DECRYPTION_FAILED;
 
     }
@@ -709,7 +709,7 @@ _gnutls_pk_decrypt (int algo, mpi_t * resarr, mpi_t data, mpi_t * pkey,
 
       if (resarr[0] == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           gcry_sexp_release (s_plain);
           return GNUTLS_E_INTERNAL_ERROR;
         }
@@ -723,7 +723,7 @@ _gnutls_pk_decrypt (int algo, mpi_t * resarr, mpi_t data, mpi_t * pkey,
 /* in case of DSA puts into data, r,s
  */
 static int
-_gnutls_pk_sign (int algo, mpi_t * data, mpi_t hash, mpi_t * pkey,
+MHD__gnutls_pk_sign (int algo, mpi_t * data, mpi_t hash, mpi_t * pkey,
                  int pkey_len)
 {
   gcry_sexp_t s_hash, s_key, s_sig;
@@ -739,7 +739,7 @@ _gnutls_pk_sign (int algo, mpi_t * data, mpi_t hash, mpi_t * pkey,
                               pkey[0], pkey[1], pkey[2], pkey[3], pkey[4]);
       else
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
         }
 
       break;
@@ -751,25 +751,25 @@ _gnutls_pk_sign (int algo, mpi_t * data, mpi_t hash, mpi_t * pkey,
                               pkey[4], pkey[5]);
       else
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
         }
       break;
 
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
   if (rc != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
   /* put the data into a simple list */
   if (gcry_sexp_build (&s_hash, NULL, "%m", hash))
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
@@ -780,7 +780,7 @@ _gnutls_pk_sign (int algo, mpi_t * data, mpi_t hash, mpi_t * pkey,
 
   if (rc != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_PK_SIGN_FAILED;
 
     }
@@ -793,7 +793,7 @@ _gnutls_pk_sign (int algo, mpi_t * data, mpi_t hash, mpi_t * pkey,
           list = gcry_sexp_find_token (s_sig, "r", 0);
           if (list == NULL)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               gcry_sexp_release (s_sig);
               return GNUTLS_E_INTERNAL_ERROR;
             }
@@ -804,7 +804,7 @@ _gnutls_pk_sign (int algo, mpi_t * data, mpi_t hash, mpi_t * pkey,
           list = gcry_sexp_find_token (s_sig, "s", 0);
           if (list == NULL)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               gcry_sexp_release (s_sig);
               return GNUTLS_E_INTERNAL_ERROR;
             }
@@ -817,7 +817,7 @@ _gnutls_pk_sign (int algo, mpi_t * data, mpi_t hash, mpi_t * pkey,
           list = gcry_sexp_find_token (s_sig, "s", 0);
           if (list == NULL)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               gcry_sexp_release (s_sig);
               return GNUTLS_E_INTERNAL_ERROR;
             }
@@ -833,7 +833,7 @@ _gnutls_pk_sign (int algo, mpi_t * data, mpi_t hash, mpi_t * pkey,
 
 
 static int
-_gnutls_pk_verify (int algo, mpi_t hash, mpi_t * data,
+MHD__gnutls_pk_verify (int algo, mpi_t hash, mpi_t * data,
                    mpi_t * pkey, int pkey_len)
 {
   gcry_sexp_t s_sig, s_hash, s_pkey;
@@ -856,20 +856,20 @@ _gnutls_pk_verify (int algo, mpi_t hash, mpi_t * data,
       break;
 
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
   if (rc != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
   /* put the data into a simple list */
   if (gcry_sexp_build (&s_hash, NULL, "%m", hash))
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       gcry_sexp_release (s_pkey);
       return GNUTLS_E_INTERNAL_ERROR;
     }
@@ -885,7 +885,7 @@ _gnutls_pk_verify (int algo, mpi_t hash, mpi_t * data,
       break;
 
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       gcry_sexp_release (s_pkey);
       gcry_sexp_release (s_hash);
       return GNUTLS_E_INTERNAL_ERROR;
@@ -893,7 +893,7 @@ _gnutls_pk_verify (int algo, mpi_t hash, mpi_t * data,
 
   if (rc != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       gcry_sexp_release (s_pkey);
       gcry_sexp_release (s_hash);
       return GNUTLS_E_INTERNAL_ERROR;
@@ -907,7 +907,7 @@ _gnutls_pk_verify (int algo, mpi_t hash, mpi_t * data,
 
   if (rc != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_PK_SIG_VERIFY_FAILED;
     }
 
diff --git a/src/daemon/https/tls/gnutls_pk.h b/src/daemon/https/tls/gnutls_pk.h
index ef4723d4..bd153a45 100644
--- a/src/daemon/https/tls/gnutls_pk.h
+++ b/src/daemon/https/tls/gnutls_pk.h
@@ -25,22 +25,22 @@
 #ifndef GNUTLS_PK_H
 #define GNUTLS_PK_H
 
-int mhd_gtls_pkcs1_rsa_encrypt (gnutls_datum_t * ciphertext,
-                                const gnutls_datum_t * plaintext,
+int MHD_gtls_pkcs1_rsa_encrypt (MHD_gnutls_datum_t * ciphertext,
+                                const MHD_gnutls_datum_t * plaintext,
                                 mpi_t * params, unsigned params_len,
                                 unsigned btype);
-int mhd_gtls_dsa_sign (gnutls_datum_t * signature,
-                       const gnutls_datum_t * plaintext, mpi_t * params,
+int MHD_gtls_dsa_sign (MHD_gnutls_datum_t * signature,
+                       const MHD_gnutls_datum_t * plaintext, mpi_t * params,
                        unsigned params_len);
-int mhd_gtls_pkcs1_rsa_decrypt (gnutls_datum_t * plaintext,
-                                const gnutls_datum_t * ciphertext,
+int MHD_gtls_pkcs1_rsa_decrypt (MHD_gnutls_datum_t * plaintext,
+                                const MHD_gnutls_datum_t * ciphertext,
                                 mpi_t * params, unsigned params_len,
                                 unsigned btype);
-int mhd_gtls_rsa_verify (const gnutls_datum_t * vdata,
-                         const gnutls_datum_t * ciphertext, mpi_t * params,
+int MHD_gtls_rsa_verify (const MHD_gnutls_datum_t * vdata,
+                         const MHD_gnutls_datum_t * ciphertext, mpi_t * params,
                          int params_len, int btype);
-int mhd_gtls_dsa_verify (const gnutls_datum_t * vdata,
-                         const gnutls_datum_t * sig_value, mpi_t * params,
+int MHD_gtls_dsa_verify (const MHD_gnutls_datum_t * vdata,
+                         const MHD_gnutls_datum_t * sig_value, mpi_t * params,
                          int params_len);
 
 #endif /* GNUTLS_PK_H */
diff --git a/src/daemon/https/tls/gnutls_priority.c b/src/daemon/https/tls/gnutls_priority.c
index f0a91bd6..06398e83 100644
--- a/src/daemon/https/tls/gnutls_priority.c
+++ b/src/daemon/https/tls/gnutls_priority.c
@@ -22,7 +22,7 @@
  *
  */
 
-/* Here lies the code of the gnutls_*_set_priority() functions.
+/* Here lies the code of the MHD_gnutls_*_set_priority() functions.
  */
 
 #include "gnutls_int.h"
@@ -33,8 +33,8 @@
 #define MAX_ELEMENTS 48
 
 /**
- * MHD_gnutls_cipher_set_priority - Sets the priority on the ciphers supported by gnutls.
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD__gnutls_cipher_set_priority - Sets the priority on the ciphers supported by gnutls.
+ * @session: is a #MHD_gtls_session_t structure.
  * @list: is a 0 terminated list of enum MHD_GNUTLS_CipherAlgorithm elements.
  *
  * Sets the priority on the ciphers supported by gnutls.
@@ -48,7 +48,7 @@
  *
  **/
 int
-MHD_gnutls_cipher_set_priority (mhd_gtls_session_t session, const int *list)
+MHD__gnutls_cipher_set_priority (MHD_gtls_session_t session, const int *list)
 {
   int num = 0, i;
 
@@ -67,7 +67,7 @@ MHD_gnutls_cipher_set_priority (mhd_gtls_session_t session, const int *list)
 }
 
 static int
-_set_priority (mhd_gtls_priority_st * st, const int *list)
+_set_priority (MHD_gtls_priority_st * st, const int *list)
 {
   int num = 0;
 
@@ -80,8 +80,8 @@ _set_priority (mhd_gtls_priority_st * st, const int *list)
 }
 
 /**
- * MHD_gnutls_kx_set_priority - Sets the priority on the key exchange algorithms supported by gnutls.
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD__gnutls_kx_set_priority - Sets the priority on the key exchange algorithms supported by gnutls.
+ * @session: is a #MHD_gtls_session_t structure.
  * @list: is a 0 terminated list of enum MHD_GNUTLS_KeyExchangeAlgorithm elements.
  *
  * Sets the priority on the key exchange algorithms supported by gnutls.
@@ -95,14 +95,14 @@ _set_priority (mhd_gtls_priority_st * st, const int *list)
  *
  **/
 int
-MHD_gnutls_kx_set_priority (mhd_gtls_session_t session, const int *list)
+MHD__gnutls_kx_set_priority (MHD_gtls_session_t session, const int *list)
 {
   return _set_priority (&session->internals.priorities.kx, list);
 }
 
 /**
- * MHD_gnutls_mac_set_priority - Sets the priority on the mac algorithms supported by gnutls.
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD__gnutls_mac_set_priority - Sets the priority on the mac algorithms supported by gnutls.
+ * @session: is a #MHD_gtls_session_t structure.
  * @list: is a 0 terminated list of enum MHD_GNUTLS_HashAlgorithm elements.
  *
  * Sets the priority on the mac algorithms supported by gnutls.
@@ -116,14 +116,14 @@ MHD_gnutls_kx_set_priority (mhd_gtls_session_t session, const int *list)
  *
  **/
 int
-MHD_gnutls_mac_set_priority (mhd_gtls_session_t session, const int *list)
+MHD__gnutls_mac_set_priority (MHD_gtls_session_t session, const int *list)
 {
   return _set_priority (&session->internals.priorities.mac, list);
 }
 
 /**
- * MHD_gnutls_compression_set_priority - Sets the priority on the compression algorithms supported by gnutls.
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD__gnutls_compression_set_priority - Sets the priority on the compression algorithms supported by gnutls.
+ * @session: is a #MHD_gtls_session_t structure.
  * @list: is a 0 terminated list of enum MHD_GNUTLS_CompressionMethod elements.
  *
  * Sets the priority on the compression algorithms supported by gnutls.
@@ -141,15 +141,15 @@ MHD_gnutls_mac_set_priority (mhd_gtls_session_t session, const int *list)
  *
  **/
 int
-MHD_gnutls_compression_set_priority (mhd_gtls_session_t session,
+MHD__gnutls_compression_set_priority (MHD_gtls_session_t session,
                                      const int *list)
 {
   return _set_priority (&session->internals.priorities.compression, list);
 }
 
 /**
- * MHD_gnutls_protocol_set_priority - Sets the priority on the protocol versions supported by gnutls.
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD__gnutls_protocol_set_priority - Sets the priority on the protocol versions supported by gnutls.
+ * @session: is a #MHD_gtls_session_t structure.
  * @list: is a 0 terminated list of enum MHD_GNUTLS_Protocol elements.
  *
  * Sets the priority on the protocol versions supported by gnutls.
@@ -160,7 +160,7 @@ MHD_gnutls_compression_set_priority (mhd_gtls_session_t session,
  *
  **/
 int
-MHD_gnutls_protocol_set_priority (mhd_gtls_session_t session, const int *list)
+MHD__gnutls_protocol_set_priority (MHD_gtls_session_t session, const int *list)
 {
   int ret;
 
@@ -168,14 +168,14 @@ MHD_gnutls_protocol_set_priority (mhd_gtls_session_t session, const int *list)
   /* set the current version to the first in the chain.
    * This will be overridden later.
    */
-  mhd_gtls_set_current_version (session, list[0]);
+  MHD_gtls_set_current_version (session, list[0]);
 
   return ret;
 }
 
 /**
- * MHD_gnutls_certificate_type_set_priority - Sets the priority on the certificate types supported by gnutls.
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD__gnutls_certificate_type_set_priority - Sets the priority on the certificate types supported by gnutls.
+ * @session: is a #MHD_gtls_session_t structure.
  * @list: is a 0 terminated list of enum MHD_GNUTLS_CertificateType elements.
  *
  * Sets the priority on the certificate types supported by gnutls.
@@ -189,7 +189,7 @@ MHD_gnutls_protocol_set_priority (mhd_gtls_session_t session, const int *list)
  *
  **/
 int
-MHD_gnutls_certificate_type_set_priority (mhd_gtls_session_t session,
+MHD__gnutls_certificate_type_set_priority (MHD_gtls_session_t session,
                                           const int *list)
 {
 #if ENABLE_OPENPGP
@@ -201,39 +201,39 @@ MHD_gnutls_certificate_type_set_priority (mhd_gtls_session_t session,
 #endif
 }
 
-static const int mhd_gtls_protocol_priority[] = { MHD_GNUTLS_PROTOCOL_TLS1_1,
+static const int MHD_gtls_protocol_priority[] = { MHD_GNUTLS_PROTOCOL_TLS1_1,
   MHD_GNUTLS_PROTOCOL_TLS1_0,
   MHD_GNUTLS_PROTOCOL_SSL3,
   0
 };
 
-static const int mhd_gtls_cipher_priority_secure256[] =
+static const int MHD_gtls_cipher_priority_secure256[] =
   { MHD_GNUTLS_CIPHER_AES_256_CBC,
   0
 };
 
-static const int mhd_gtls_kx_priority_secure[] = { MHD_GNUTLS_KX_RSA,
+static const int MHD_gtls_kx_priority_secure[] = { MHD_GNUTLS_KX_RSA,
   0
 };
 
-static const int mhd_gtls_mac_priority_secure[] = { MHD_GNUTLS_MAC_SHA1,
+static const int MHD_gtls_mac_priority_secure[] = { MHD_GNUTLS_MAC_SHA1,
   0
 };
 
-static int mhd_gtls_cert_type_priority[] = { MHD_GNUTLS_CRT_X509,
+static int MHD_gtls_cert_type_priority[] = { MHD_GNUTLS_CRT_X509,
   0
 };
 
-static const int mhd_gtls_comp_priority[] = { MHD_GNUTLS_COMP_NULL,
+static const int MHD_gtls_comp_priority[] = { MHD_GNUTLS_COMP_NULL,
   0
 };
 
-typedef void (rmadd_func) (mhd_gtls_priority_st * priority_list, int alg);
+typedef void (rmadd_func) (MHD_gtls_priority_st * priority_list, int alg);
 
 /**
- * MHD_gnutls_priority_set - Sets priorities for the cipher suites supported by gnutls.
- * @session: is a #mhd_gtls_session_t structure.
- * @priority: is a #gnutls_priority_t structure.
+ * MHD__gnutls_priority_set - Sets priorities for the cipher suites supported by gnutls.
+ * @session: is a #MHD_gtls_session_t structure.
+ * @priority: is a #MHD_gnutls_priority_t structure.
  *
  * Sets the priorities to use on the ciphers, key exchange methods,
  * macs and compression methods.
@@ -242,12 +242,12 @@ typedef void (rmadd_func) (mhd_gtls_priority_st * priority_list, int alg);
  *
  **/
 int
-MHD_gnutls_priority_set (mhd_gtls_session_t session,
-                         gnutls_priority_t priority)
+MHD__gnutls_priority_set (MHD_gtls_session_t session,
+                         MHD_gnutls_priority_t priority)
 {
   if (priority == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_NO_CIPHER_SUITES;
     }
 
@@ -259,13 +259,13 @@ MHD_gnutls_priority_set (mhd_gtls_session_t session,
 
 /**
  * MHD_tls_set_default_priority - Sets priorities for the cipher suites supported by gnutls.
- * @priority_cache: is a #gnutls_prioritity_t structure.
+ * @priority_cache: is a #MHD_gnutls_prioritity_t structure.
  * @priorities: is a string describing priorities
  * @err_pos: In case of an error this will have the position in the string the error occured
  *
  * Sets priorities for the ciphers, key exchange methods, macs and
  * compression methods. This is to avoid using the
- * gnutls_*_priority() functions.
+ * MHD_gnutls_*_priority() functions.
  *
  * The #priorities option allows you to specify a semi-colon
  * separated list of the cipher priorities to enable.
@@ -323,45 +323,45 @@ MHD_gnutls_priority_set (mhd_gtls_session_t session,
  * 0 on success.
  **/
 int
-MHD_tls_set_default_priority (gnutls_priority_t * priority_cache,
+MHD_tls_set_default_priority (MHD_gnutls_priority_t * priority_cache,
                               const char *priorities, const char **err_pos)
 {
-  *priority_cache = gnutls_calloc (1, sizeof (struct MHD_gtls_priority_st));
+  *priority_cache = MHD_gnutls_calloc (1, sizeof (struct MHD_gtls_priority_st));
   if (*priority_cache == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
   /* set mode to "SECURE256" */
-  _set_priority (&(*priority_cache)->protocol, mhd_gtls_protocol_priority);
+  _set_priority (&(*priority_cache)->protocol, MHD_gtls_protocol_priority);
   _set_priority (&(*priority_cache)->cipher,
-                 mhd_gtls_cipher_priority_secure256);
-  _set_priority (&(*priority_cache)->kx, mhd_gtls_kx_priority_secure);
-  _set_priority (&(*priority_cache)->mac, mhd_gtls_mac_priority_secure);
-  _set_priority (&(*priority_cache)->cert_type, mhd_gtls_cert_type_priority);
-  _set_priority (&(*priority_cache)->compression, mhd_gtls_comp_priority);
+                 MHD_gtls_cipher_priority_secure256);
+  _set_priority (&(*priority_cache)->kx, MHD_gtls_kx_priority_secure);
+  _set_priority (&(*priority_cache)->mac, MHD_gtls_mac_priority_secure);
+  _set_priority (&(*priority_cache)->cert_type, MHD_gtls_cert_type_priority);
+  _set_priority (&(*priority_cache)->compression, MHD_gtls_comp_priority);
 
   (*priority_cache)->no_padding = 0;
   return 0;
 }
 
 /**
- * MHD_gnutls_priority_deinit - Deinitialize the priorities cache for the cipher suites supported by gnutls.
- * @priority_cache: is a #gnutls_prioritity_t structure.
+ * MHD__gnutls_priority_deinit - Deinitialize the priorities cache for the cipher suites supported by gnutls.
+ * @priority_cache: is a #MHD_gnutls_prioritity_t structure.
  *
  * Deinitializes the priority cache.
  *
  **/
 void
-MHD_gnutls_priority_deinit (gnutls_priority_t priority_cache)
+MHD__gnutls_priority_deinit (MHD_gnutls_priority_t priority_cache)
 {
-  gnutls_free (priority_cache);
+  MHD_gnutls_free (priority_cache);
 }
 
 /**
- * MHD_gnutls_priority_set_direct - Sets priorities for the cipher suites supported by gnutls.
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD__gnutls_priority_set_direct - Sets priorities for the cipher suites supported by gnutls.
+ * @session: is a #MHD_gtls_session_t structure.
  * @priorities: is a string describing priorities
  * @err_pos: In case of an error this will have the position in the string the error occured
  *
@@ -374,27 +374,27 @@ MHD_gnutls_priority_deinit (gnutls_priority_t priority_cache)
  *
  **/
 int
-MHD_gnutls_priority_set_direct (mhd_gtls_session_t session,
+MHD__gnutls_priority_set_direct (MHD_gtls_session_t session,
                                 const char *priorities, const char **err_pos)
 {
-  gnutls_priority_t prio;
+  MHD_gnutls_priority_t prio;
   int ret;
 
   ret = MHD_tls_set_default_priority (&prio, priorities, err_pos);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  ret = MHD_gnutls_priority_set (session, prio);
+  ret = MHD__gnutls_priority_set (session, prio);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  MHD_gnutls_priority_deinit (prio);
+  MHD__gnutls_priority_deinit (prio);
 
   return 0;
 }
diff --git a/src/daemon/https/tls/gnutls_record.c b/src/daemon/https/tls/gnutls_record.c
index a9422c76..9ccdb1e3 100644
--- a/src/daemon/https/tls/gnutls_record.c
+++ b/src/daemon/https/tls/gnutls_record.c
@@ -44,27 +44,27 @@
 #include <gnutls_dh.h>
 
 /**
- * MHD_gnutls_protocol_get_version - Returns the version of the currently used protocol
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD__gnutls_protocol_get_version - Returns the version of the currently used protocol
+ * @session: is a #MHD_gtls_session_t structure.
  *
  * Returns: the version of the currently used protocol.
  **/
 enum MHD_GNUTLS_Protocol
-MHD_gnutls_protocol_get_version (mhd_gtls_session_t session)
+MHD__gnutls_protocol_get_version (MHD_gtls_session_t session)
 {
   return session->security_parameters.version;
 }
 
 void
-mhd_gtls_set_current_version (mhd_gtls_session_t session,
+MHD_gtls_set_current_version (MHD_gtls_session_t session,
                               enum MHD_GNUTLS_Protocol version)
 {
   session->security_parameters.version = version;
 }
 
 /**
- * MHD_gnutls_transport_set_lowat - Used to set the lowat value in order for select to check for pending data.
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD__gnutls_transport_set_lowat - Used to set the lowat value in order for select to check for pending data.
+ * @session: is a #MHD_gtls_session_t structure.
  * @num: is the low water value.
  *
  * Used to set the lowat value in order for select to check if there
@@ -75,14 +75,14 @@ mhd_gtls_set_current_version (mhd_gtls_session_t session,
  * to zero.
  **/
 void
-MHD_gnutls_transport_set_lowat (mhd_gtls_session_t session, int num)
+MHD__gnutls_transport_set_lowat (MHD_gtls_session_t session, int num)
 {
   session->internals.lowat = num;
 }
 
 /**
  * MHD_gtls_record_disable_padding - Used to disabled padding in TLS 1.0 and above
- * @session: is a #mhd_gtls_session_t structure.
+ * @session: is a #MHD_gtls_session_t structure.
  *
  * Used to disabled padding in TLS 1.0 and above.  Normally you do
  * not need to use this function, but there are buggy clients that
@@ -93,14 +93,14 @@ MHD_gnutls_transport_set_lowat (mhd_gtls_session_t session, int num)
  * out there, need to call this function.
  **/
 void
-MHD_gtls_record_disable_padding (mhd_gtls_session_t session)
+MHD_gtls_record_disable_padding (MHD_gtls_session_t session)
 {
   session->internals.priorities.no_padding = 1;
 }
 
 /**
- * MHD_gnutls_transport_set_ptr - Used to set first argument of the transport functions
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD__gnutls_transport_set_ptr - Used to set first argument of the transport functions
+ * @session: is a #MHD_gtls_session_t structure.
  * @ptr: is the value.
  *
  * Used to set the first argument of the transport function (like
@@ -108,16 +108,16 @@ MHD_gtls_record_disable_padding (mhd_gtls_session_t session)
  * the connection handle.
  **/
 void
-MHD_gnutls_transport_set_ptr (mhd_gtls_session_t session,
-                              gnutls_transport_ptr_t ptr)
+MHD__gnutls_transport_set_ptr (MHD_gtls_session_t session,
+                              MHD_gnutls_transport_ptr_t ptr)
 {
   session->internals.transport_recv_ptr = ptr;
   session->internals.transport_send_ptr = ptr;
 }
 
 /**
- * MHD_gnutls_transport_set_ptr2 - Used to set first argument of the transport functions
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD__gnutls_transport_set_ptr2 - Used to set first argument of the transport functions
+ * @session: is a #MHD_gtls_session_t structure.
  * @recv_ptr: is the value for the pull function
  * @send_ptr: is the value for the push function
  *
@@ -127,21 +127,21 @@ MHD_gnutls_transport_set_ptr (mhd_gtls_session_t session,
  * different pointers for receiving and sending.
  **/
 void
-MHD_gnutls_transport_set_ptr2 (mhd_gtls_session_t session,
-                               gnutls_transport_ptr_t recv_ptr,
-                               gnutls_transport_ptr_t send_ptr)
+MHD__gnutls_transport_set_ptr2 (MHD_gtls_session_t session,
+                               MHD_gnutls_transport_ptr_t recv_ptr,
+                               MHD_gnutls_transport_ptr_t send_ptr)
 {
   session->internals.transport_send_ptr = send_ptr;
   session->internals.transport_recv_ptr = recv_ptr;
 }
 
 /**
- * MHD_gnutls_bye - This function terminates the current TLS/SSL connection.
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD__gnutls_bye - This function terminates the current TLS/SSL connection.
+ * @session: is a #MHD_gtls_session_t structure.
  * @how: is an integer
  *
  * Terminates the current TLS/SSL connection. The connection should
- * have been initiated using MHD_gnutls_handshake().  @how should be one
+ * have been initiated using MHD__gnutls_handshake().  @how should be one
  * of %GNUTLS_SHUT_RDWR, %GNUTLS_SHUT_WR.
  *
  * In case of %GNUTLS_SHUT_RDWR then the TLS connection gets
@@ -163,13 +163,13 @@ MHD_gnutls_transport_set_ptr2 (mhd_gtls_session_t session,
  * session, thus this behavior is not recommended.
  *
  * This function may also return %GNUTLS_E_AGAIN or
- * %GNUTLS_E_INTERRUPTED; cf.  MHD_gnutls_record_get_direction().
+ * %GNUTLS_E_INTERRUPTED; cf.  MHD__gnutls_record_get_direction().
  *
  * Returns: %GNUTLS_E_SUCCESS on success, or an error code, see
  *   function documentation for entire semantics.
  **/
 int
-MHD_gnutls_bye (mhd_gtls_session_t session, gnutls_close_request_t how)
+MHD__gnutls_bye (MHD_gtls_session_t session, MHD_gnutls_close_request_t how)
 {
   int ret = 0;
 
@@ -177,22 +177,22 @@ MHD_gnutls_bye (mhd_gtls_session_t session, gnutls_close_request_t how)
     {
     case STATE0:
     case STATE60:
-      ret = mhd_gtls_io_write_flush (session);
+      ret = MHD_gtls_io_write_flush (session);
       STATE = STATE60;
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
     case STATE61:
       ret =
-        MHD_gnutls_alert_send (session, GNUTLS_AL_WARNING,
+        MHD__gnutls_alert_send (session, GNUTLS_AL_WARNING,
                                GNUTLS_A_CLOSE_NOTIFY);
       STATE = STATE61;
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
@@ -202,8 +202,8 @@ MHD_gnutls_bye (mhd_gtls_session_t session, gnutls_close_request_t how)
         {
           do
             {
-              mhd_gtls_io_clear_peeked_data (session);
-              ret = mhd_gtls_recv_int (session, GNUTLS_ALERT, -1, NULL, 0);
+              MHD_gtls_io_clear_peeked_data (session);
+              ret = MHD_gtls_recv_int (session, GNUTLS_ALERT, -1, NULL, 0);
             }
           while (ret == GNUTLS_E_GOT_APPLICATION_DATA);
 
@@ -212,7 +212,7 @@ MHD_gnutls_bye (mhd_gtls_session_t session, gnutls_close_request_t how)
 
           if (ret < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return ret;
             }
         }
@@ -220,7 +220,7 @@ MHD_gnutls_bye (mhd_gtls_session_t session, gnutls_close_request_t how)
 
       break;
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
@@ -231,13 +231,13 @@ MHD_gnutls_bye (mhd_gtls_session_t session, gnutls_close_request_t how)
 }
 
 inline static void
-session_invalidate (mhd_gtls_session_t session)
+session_invalidate (MHD_gtls_session_t session)
 {
   session->internals.valid_connection = VALID_FALSE;
 }
 
 inline static void
-session_unresumable (mhd_gtls_session_t session)
+session_unresumable (MHD_gtls_session_t session)
 {
   session->internals.resumable = RESUME_FALSE;
 }
@@ -245,7 +245,7 @@ session_unresumable (mhd_gtls_session_t session)
 /* returns 0 if session is valid
  */
 inline static int
-session_is_valid (mhd_gtls_session_t session)
+session_is_valid (MHD_gtls_session_t session)
 {
   if (session->internals.valid_connection == VALID_FALSE)
     return GNUTLS_E_INVALID_SESSION;
@@ -257,18 +257,18 @@ session_is_valid (mhd_gtls_session_t session)
  * version must have 2 bytes at least.
  */
 inline static void
-copy_record_version (mhd_gtls_session_t session,
-                     gnutls_handshake_description_t htype, opaque version[2])
+copy_record_version (MHD_gtls_session_t session,
+                     MHD_gnutls_handshake_description_t htype, opaque version[2])
 {
   enum MHD_GNUTLS_Protocol lver;
 
   if (htype != GNUTLS_HANDSHAKE_CLIENT_HELLO
       || session->internals.default_record_version[0] == 0)
     {
-      lver = MHD_gnutls_protocol_get_version (session);
+      lver = MHD__gnutls_protocol_get_version (session);
 
-      version[0] = mhd_gtls_version_get_major (lver);
-      version[1] = mhd_gtls_version_get_minor (lver);
+      version[0] = MHD_gtls_version_get_major (lver);
+      version[1] = MHD_gtls_version_get_minor (lver);
     }
   else
     {
@@ -278,7 +278,7 @@ copy_record_version (mhd_gtls_session_t session,
 }
 
 /* This function behaves exactly like write(). The only difference is
- * that it accepts, the mhd_gtls_session_t and the content_type_t of data to
+ * that it accepts, the MHD_gtls_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.
  *
@@ -292,9 +292,9 @@ copy_record_version (mhd_gtls_session_t session,
  *
  */
 ssize_t
-mhd_gtls_send_int (mhd_gtls_session_t session,
+MHD_gtls_send_int (MHD_gtls_session_t session,
                    content_type_t type,
-                   gnutls_handshake_description_t htype,
+                   MHD_gnutls_handshake_description_t htype,
                    const void *_data, size_t sizeofdata)
 {
   uint8_t *cipher;
@@ -311,14 +311,14 @@ mhd_gtls_send_int (mhd_gtls_session_t session,
   if (session->internals.record_send_buffer.length == 0 && (sizeofdata == 0
                                                             && _data == NULL))
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   if (type != GNUTLS_ALERT)     /* alert messages are sent anyway */
     if (session_is_valid (session) || session->internals.may_not_write != 0)
       {
-        gnutls_assert ();
+        MHD_gnutls_assert ();
         return GNUTLS_E_INVALID_SESSION;
       }
 
@@ -329,11 +329,11 @@ mhd_gtls_send_int (mhd_gtls_session_t session,
    */
   copy_record_version (session, htype, &headers[1]);
 
-  _gnutls_record_log
+  MHD__gnutls_record_log
     ("REC[%x]: Sending Packet[%d] %s(%d) with length: %d\n", session,
-     (int) mhd_gtls_uint64touint32 (&session->connection_state.
+     (int) MHD_gtls_uint64touint32 (&session->connection_state.
                                     write_sequence_number),
-     _gnutls_packet2str (type), type, sizeofdata);
+     MHD__gnutls_packet2str (type), type, sizeofdata);
 
   if (sizeofdata > MAX_RECORD_SEND_SIZE)
     data2send_size = MAX_RECORD_SEND_SIZE;
@@ -345,7 +345,7 @@ mhd_gtls_send_int (mhd_gtls_session_t session,
    */
   if (session->internals.record_send_buffer.length > 0)
     {
-      ret = mhd_gtls_io_write_flush (session);
+      ret = MHD_gtls_io_write_flush (session);
       if (ret > 0)
         cipher_size = ret;
       else
@@ -360,24 +360,24 @@ mhd_gtls_send_int (mhd_gtls_session_t session,
       /* now proceed to packet encryption
        */
       cipher_size = data2send_size + MAX_RECORD_OVERHEAD;
-      cipher = gnutls_malloc (cipher_size);
+      cipher = MHD_gnutls_malloc (cipher_size);
       if (cipher == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_MEMORY_ERROR;
         }
 
       cipher_size =
-        mhd_gtls_encrypt (session, headers, RECORD_HEADER_SIZE, data,
+        MHD_gtls_encrypt (session, headers, RECORD_HEADER_SIZE, data,
                           data2send_size, cipher, cipher_size, type,
                           (session->internals.priorities.no_padding ==
                            0) ? 1 : 0);
       if (cipher_size <= 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           if (cipher_size == 0)
             cipher_size = GNUTLS_E_ENCRYPTION_FAILED;
-          gnutls_free (cipher);
+          MHD_gnutls_free (cipher);
           return cipher_size;   /* error */
         }
 
@@ -386,17 +386,17 @@ mhd_gtls_send_int (mhd_gtls_session_t session,
 
       /* increase sequence number
        */
-      if (mhd_gtls_uint64pp
+      if (MHD_gtls_uint64pp
           (&session->connection_state.write_sequence_number) != 0)
         {
           session_invalidate (session);
-          gnutls_assert ();
-          gnutls_free (cipher);
+          MHD_gnutls_assert ();
+          MHD_gnutls_free (cipher);
           return GNUTLS_E_RECORD_LIMIT_REACHED;
         }
 
-      ret = mhd_gtls_io_write_buffered (session, cipher, cipher_size);
-      gnutls_free (cipher);
+      ret = MHD_gtls_io_write_buffered (session, cipher, cipher_size);
+      MHD_gnutls_free (cipher);
     }
 
   if (ret != cipher_size)
@@ -406,29 +406,29 @@ mhd_gtls_send_int (mhd_gtls_session_t session,
           /* If we have sent any data then just return
            * the error value. Do not invalidate the session.
            */
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
       if (ret > 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           ret = GNUTLS_E_INTERNAL_ERROR;
         }
       session_unresumable (session);
       session->internals.may_not_write = 1;
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
   session->internals.record_send_buffer_user_size = 0;
 
-  _gnutls_record_log ("REC[%x]: Sent Packet[%d] %s(%d) with length: %d\n",
+  MHD__gnutls_record_log ("REC[%x]: Sent Packet[%d] %s(%d) with length: %d\n",
                       session,
                       (int)
-                      mhd_gtls_uint64touint32
+                      MHD_gtls_uint64touint32
                       (&session->connection_state.write_sequence_number),
-                      _gnutls_packet2str (type), type, cipher_size);
+                      MHD__gnutls_packet2str (type), type, cipher_size);
 
   return retval;
 }
@@ -437,20 +437,20 @@ mhd_gtls_send_int (mhd_gtls_session_t session,
  * completed. This sends a Change Cipher Spec packet to the peer.
  */
 ssize_t
-mhd_gtls_send_change_cipher_spec (mhd_gtls_session_t session, int again)
+MHD_gtls_send_change_cipher_spec (MHD_gtls_session_t session, int again)
 {
   static const opaque data[1] = {
     GNUTLS_TYPE_CHANGE_CIPHER_SPEC
   };
 
-  _gnutls_handshake_log ("REC[%x]: Sent ChangeCipherSpec\n", session);
+  MHD__gnutls_handshake_log ("REC[%x]: Sent ChangeCipherSpec\n", session);
 
   if (again == 0)
-    return mhd_gtls_send_int (session, GNUTLS_CHANGE_CIPHER_SPEC, -1, data,
+    return MHD_gtls_send_int (session, GNUTLS_CHANGE_CIPHER_SPEC, -1, data,
                               1);
   else
     {
-      return mhd_gtls_io_write_flush (session);
+      return MHD_gtls_io_write_flush (session);
     }
 }
 
@@ -466,7 +466,7 @@ check_recv_type (content_type_t recv_type)
     case GNUTLS_INNER_APPLICATION:
       return 0;
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_A_UNEXPECTED_MESSAGE;
     }
 
@@ -476,27 +476,27 @@ check_recv_type (content_type_t recv_type)
  * then it copies the data.
  */
 static int
-check_buffers (mhd_gtls_session_t session,
+check_buffers (MHD_gtls_session_t session,
                content_type_t type, opaque * data, int sizeofdata)
 {
   if ((type == GNUTLS_APPLICATION_DATA || type == GNUTLS_HANDSHAKE || type
        == GNUTLS_INNER_APPLICATION)
-      && mhd_gnutls_record_buffer_get_size (type, session) > 0)
+      && MHD_gnutls_record_buffer_get_size (type, session) > 0)
     {
       int ret, ret2;
-      ret = mhd_gtls_record_buffer_get (type, session, data, sizeofdata);
+      ret = MHD_gtls_record_buffer_get (type, session, data, sizeofdata);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
       /* if the buffer just got empty */
-      if (mhd_gnutls_record_buffer_get_size (type, session) == 0)
+      if (MHD_gnutls_record_buffer_get_size (type, session) == 0)
         {
-          if ((ret2 = mhd_gtls_io_clear_peeked_data (session)) < 0)
+          if ((ret2 = MHD_gtls_io_clear_peeked_data (session)) < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return ret2;
             }
         }
@@ -511,10 +511,10 @@ check_buffers (mhd_gtls_session_t session,
  * content type.
  */
 static int
-record_check_headers (mhd_gtls_session_t session,
+record_check_headers (MHD_gtls_session_t session,
                       uint8_t headers[RECORD_HEADER_SIZE],
                       content_type_t type,
-                      gnutls_handshake_description_t htype,
+                      MHD_gnutls_handshake_description_t htype,
                       /*output */ content_type_t * recv_type,
                       opaque version[2],
                       uint16_t * length, uint16_t * header_size)
@@ -546,7 +546,7 @@ record_check_headers (mhd_gtls_session_t session,
        */
       session->internals.v2_hello = *length;
 
-      _gnutls_record_log ("REC[%x]: V2 packet received. Length: %d\n",
+      MHD__gnutls_record_log ("REC[%x]: V2 packet received. Length: %d\n",
                           session, *length);
 
     }
@@ -559,7 +559,7 @@ record_check_headers (mhd_gtls_session_t session,
 
       /* No DECR_LEN, since headers has enough size.
        */
-      *length = mhd_gtls_read_uint16 (&headers[3]);
+      *length = MHD_gtls_read_uint16 (&headers[3]);
     }
 
   return 0;
@@ -569,8 +569,8 @@ record_check_headers (mhd_gtls_session_t session,
  * negotiated in the handshake.
  */
 inline static int
-record_check_version (mhd_gtls_session_t session,
-                      gnutls_handshake_description_t htype, opaque version[2])
+record_check_version (MHD_gtls_session_t session,
+                      MHD_gnutls_handshake_description_t htype, opaque version[2])
 {
   if (htype == GNUTLS_HANDSHAKE_CLIENT_HELLO)
     {
@@ -578,23 +578,23 @@ record_check_version (mhd_gtls_session_t session,
        */
       if (version[0] > 3)
         {
-          gnutls_assert ();
-          _gnutls_record_log
+          MHD_gnutls_assert ();
+          MHD__gnutls_record_log
             ("REC[%x]: INVALID VERSION PACKET: (%d) %d.%d\n", session,
              htype, version[0], version[1]);
           return GNUTLS_E_UNSUPPORTED_VERSION_PACKET;
         }
     }
   else if (htype != GNUTLS_HANDSHAKE_SERVER_HELLO
-           && MHD_gnutls_protocol_get_version (session)
-           != mhd_gtls_version_get (version[0], version[1]))
+           && MHD__gnutls_protocol_get_version (session)
+           != MHD_gtls_version_get (version[0], version[1]))
     {
       /* Reject record packets that have a different version than the
        * one negotiated. Note that this version is not protected by any
        * mac. I don't really think that this check serves any purpose.
        */
-      gnutls_assert ();
-      _gnutls_record_log ("REC[%x]: INVALID VERSION PACKET: (%d) %d.%d\n",
+      MHD_gnutls_assert ();
+      MHD__gnutls_record_log ("REC[%x]: INVALID VERSION PACKET: (%d) %d.%d\n",
                           session, htype, version[0], version[1]);
 
       return GNUTLS_E_UNSUPPORTED_VERSION_PACKET;
@@ -607,10 +607,10 @@ record_check_version (mhd_gtls_session_t session,
  * the one we actually expect.
  */
 static int
-record_check_type (mhd_gtls_session_t session,
+record_check_type (MHD_gtls_session_t session,
                    content_type_t recv_type,
                    content_type_t type,
-                   gnutls_handshake_description_t htype,
+                   MHD_gnutls_handshake_description_t htype,
                    opaque * data, int data_size)
 {
 
@@ -620,7 +620,7 @@ record_check_type (mhd_gtls_session_t session,
                               == GNUTLS_HANDSHAKE
                               || type == GNUTLS_INNER_APPLICATION))
     {
-      mhd_gnutls_record_buffer_put (type, session, (void *) data, data_size);
+      MHD_gnutls_record_buffer_put (type, session, (void *) data, data_size);
     }
   else
     {
@@ -628,9 +628,9 @@ record_check_type (mhd_gtls_session_t session,
         {
         case GNUTLS_ALERT:
 
-          _gnutls_record_log
+          MHD__gnutls_record_log
             ("REC[%x]: Alert[%d|%d] - %s - was received\n", session,
-             data[0], data[1], MHD_gnutls_alert_get_name ((int) data[1]));
+             data[0], data[1], MHD__gnutls_alert_get_name ((int) data[1]));
 
           session->internals.last_alert = data[1];
           session->internals.last_alert_level = data[0];
@@ -651,7 +651,7 @@ record_check_type (mhd_gtls_session_t session,
               /* if the alert is FATAL or WARNING
                * return the apropriate message
                */
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               ret = GNUTLS_E_WARNING_ALERT_RECEIVED;
               if (data[0] == GNUTLS_AL_FATAL)
                 {
@@ -668,17 +668,17 @@ record_check_type (mhd_gtls_session_t session,
           /* this packet is now handled in the recv_int()
            * function
            */
-          gnutls_assert ();
+          MHD_gnutls_assert ();
 
           return GNUTLS_E_UNEXPECTED_PACKET;
 
         case GNUTLS_APPLICATION_DATA:
           /* even if data is unexpected put it into the buffer */
           if ((ret =
-               mhd_gnutls_record_buffer_put (recv_type, session,
+               MHD_gnutls_record_buffer_put (recv_type, session,
                                              (void *) data, data_size)) < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return ret;
             }
 
@@ -691,7 +691,7 @@ record_check_type (mhd_gtls_session_t session,
             return GNUTLS_E_GOT_APPLICATION_DATA;
           else
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return GNUTLS_E_UNEXPECTED_PACKET;
             }
 
@@ -702,7 +702,7 @@ record_check_type (mhd_gtls_session_t session,
            */
           if (session->security_parameters.entity == GNUTLS_SERVER)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return GNUTLS_E_REHANDSHAKE;
             }
 
@@ -712,28 +712,28 @@ record_check_type (mhd_gtls_session_t session,
            */
 
           /* So we accept it */
-          return mhd_gtls_recv_hello_request (session, data, data_size);
+          return MHD_gtls_recv_hello_request (session, data, data_size);
 
           break;
         case GNUTLS_INNER_APPLICATION:
           /* even if data is unexpected put it into the buffer */
           if ((ret =
-               mhd_gnutls_record_buffer_put (recv_type, session,
+               MHD_gnutls_record_buffer_put (recv_type, session,
                                              (void *) data, data_size)) < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return ret;
             }
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_UNEXPECTED_PACKET;
           break;
         default:
 
-          _gnutls_record_log
+          MHD__gnutls_record_log
             ("REC[%x]: Received Unknown packet %d expecting %d\n",
              session, recv_type, type);
 
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_INTERNAL_ERROR;
         }
     }
@@ -747,7 +747,7 @@ record_check_type (mhd_gtls_session_t session,
  * also initialize it.
  */
 inline static int
-get_temp_recv_buffer (mhd_gtls_session_t session, gnutls_datum_t * tmp)
+get_temp_recv_buffer (MHD_gtls_session_t session, MHD_gnutls_datum_t * tmp)
 {
   size_t max_record_size;
 
@@ -769,11 +769,11 @@ get_temp_recv_buffer (mhd_gtls_session_t session, gnutls_datum_t * tmp)
        */
       session->internals.recv_buffer.data
         =
-        gnutls_realloc (session->internals.recv_buffer.data, max_record_size);
+        MHD_gnutls_realloc (session->internals.recv_buffer.data, max_record_size);
 
       if (session->internals.recv_buffer.data == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_MEMORY_ERROR;
         }
 
@@ -789,19 +789,19 @@ get_temp_recv_buffer (mhd_gtls_session_t session, gnutls_datum_t * tmp)
 #define MAX_EMPTY_PACKETS_SEQUENCE 4
 
 /* This function behaves exactly like read(). The only difference is
- * that it accepts the mhd_gtls_session_t and the content_type_t of data to
+ * that it accepts the MHD_gtls_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 gnutls_handshake_description_t was introduced to support SSL V2.0 client hellos.
+ * The MHD_gnutls_handshake_description_t was introduced to support SSL V2.0 client hellos.
  */
 ssize_t
-mhd_gtls_recv_int (mhd_gtls_session_t session,
+MHD_gtls_recv_int (MHD_gtls_session_t session,
                    content_type_t type,
-                   gnutls_handshake_description_t htype,
+                   MHD_gnutls_handshake_description_t htype,
                    opaque * data, size_t sizeofdata)
 {
-  gnutls_datum_t tmp;
+  MHD_gnutls_datum_t tmp;
   int decrypted_length;
   opaque version[2];
   uint8_t *headers;
@@ -822,7 +822,7 @@ begin:
 
   if (empty_packet > MAX_EMPTY_PACKETS_SEQUENCE)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_TOO_MANY_EMPTY_PACKETS;
     }
 
@@ -835,7 +835,7 @@ begin:
   else if (session_is_valid (session) != 0 || session->internals.may_not_read
            != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_SESSION;
     }
 
@@ -850,7 +850,7 @@ begin:
    */
   header_size = RECORD_HEADER_SIZE;
 
-  if ((ret = mhd_gtls_io_read_buffered (session, &headers, header_size, -1))
+  if ((ret = MHD_gtls_io_read_buffered (session, &headers, header_size, -1))
       != header_size)
     {
       if (ret < 0 && MHD_gtls_error_is_fatal (ret) == 0)
@@ -859,18 +859,18 @@ begin:
       session_invalidate (session);
       if (type == GNUTLS_ALERT)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return 0;             /* we were expecting close notify */
         }
       session_unresumable (session);
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
     }
 
   if ((ret = record_check_headers (session, headers, type, htype, &recv_type,
                                    version, &length, &header_size)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -879,7 +879,7 @@ begin:
    */
   if ((ret = check_recv_type (recv_type)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -888,38 +888,38 @@ begin:
    */
   if ((ret = record_check_version (session, htype, version)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       session_invalidate (session);
       return ret;
     }
 
-  _gnutls_record_log
+  MHD__gnutls_record_log
     ("REC[%x]: Expected Packet[%d] %s(%d) with length: %d\n", session,
-     (int) mhd_gtls_uint64touint32 (&session->connection_state.
+     (int) MHD_gtls_uint64touint32 (&session->connection_state.
                                     read_sequence_number),
-     _gnutls_packet2str (type), type, sizeofdata);
-  _gnutls_record_log ("REC[%x]: Received Packet[%d] %s(%d) with length: %d\n",
+     MHD__gnutls_packet2str (type), type, sizeofdata);
+  MHD__gnutls_record_log ("REC[%x]: Received Packet[%d] %s(%d) with length: %d\n",
                       session,
                       (int)
-                      mhd_gtls_uint64touint32 (&session->connection_state.
+                      MHD_gtls_uint64touint32 (&session->connection_state.
                                                read_sequence_number),
-                      _gnutls_packet2str (recv_type), recv_type, length);
+                      MHD__gnutls_packet2str (recv_type), recv_type, length);
 
   if (length > MAX_RECV_SIZE)
     {
-      _gnutls_record_log
+      MHD__gnutls_record_log
         ("REC[%x]: FATAL ERROR: Received packet with length: %d\n",
          session, length);
 
       session_unresumable (session);
       session_invalidate (session);
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
     }
 
   /* check if we have that data into buffer.
    */
-  if ((ret = mhd_gtls_io_read_buffered (session, &recv_data,
+  if ((ret = MHD_gtls_io_read_buffered (session, &recv_data,
                                         header_size + length, recv_type))
       != header_size + length)
     {
@@ -928,31 +928,31 @@ begin:
 
       session_unresumable (session);
       session_invalidate (session);
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
     }
 
   /* ok now we are sure that we can read all the data - so
    * move on !
    */
-  mhd_gtls_io_clear_read_buffer (session);
+  MHD_gtls_io_clear_read_buffer (session);
   ciphertext = &recv_data[header_size];
 
   ret = get_temp_recv_buffer (session, &tmp);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
   /* decrypt the data we got. */
-  ret = mhd_gtls_decrypt (session, ciphertext, length, tmp.data, tmp.size,
+  ret = MHD_gtls_decrypt (session, ciphertext, length, tmp.data, tmp.size,
                           recv_type);
   if (ret < 0)
     {
       session_unresumable (session);
       session_invalidate (session);
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
   decrypted_length = ret;
@@ -963,12 +963,12 @@ begin:
       == GNUTLS_CHANGE_CIPHER_SPEC)
     {
 
-      _gnutls_record_log
+      MHD__gnutls_record_log
         ("REC[%x]: ChangeCipherSpec Packet was received\n", session);
 
       if ((size_t) ret != sizeofdata)
         {                       /* sizeofdata should be 1 */
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
         }
       memcpy (data, tmp.data, sizeofdata);
@@ -976,19 +976,19 @@ begin:
       return ret;
     }
 
-  _gnutls_record_log
+  MHD__gnutls_record_log
     ("REC[%x]: Decrypted Packet[%d] %s(%d) with length: %d\n", session,
-     (int) mhd_gtls_uint64touint32 (&session->connection_state.
+     (int) MHD_gtls_uint64touint32 (&session->connection_state.
                                     read_sequence_number),
-     _gnutls_packet2str (recv_type), recv_type, decrypted_length);
+     MHD__gnutls_packet2str (recv_type), recv_type, decrypted_length);
 
   /* increase sequence number
    */
-  if (mhd_gtls_uint64pp (&session->connection_state.read_sequence_number) !=
+  if (MHD_gtls_uint64pp (&session->connection_state.read_sequence_number) !=
       0)
     {
       session_invalidate (session);
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_RECORD_LIMIT_REACHED;
     }
 
@@ -999,7 +999,7 @@ begin:
     {
       if (ret == GNUTLS_E_INT_RET_0)
         return 0;
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -1010,27 +1010,27 @@ begin:
                               || type == GNUTLS_INNER_APPLICATION))
     {
 
-      ret = mhd_gtls_record_buffer_get (type, session, data, sizeofdata);
+      ret = MHD_gtls_record_buffer_get (type, session, data, sizeofdata);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
       /* if the buffer just got empty
        */
-      if (mhd_gnutls_record_buffer_get_size (type, session) == 0)
+      if (MHD_gnutls_record_buffer_get_size (type, session) == 0)
         {
-          if ((ret2 = mhd_gtls_io_clear_peeked_data (session)) < 0)
+          if ((ret2 = MHD_gtls_io_clear_peeked_data (session)) < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return ret2;
             }
         }
     }
   else
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNEXPECTED_PACKET;
       /* we didn't get what we wanted to
        */
@@ -1053,8 +1053,8 @@ begin:
 }
 
 /**
- * MHD_gnutls_record_send - sends to the peer the specified data
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD__gnutls_record_send - sends to the peer the specified data
+ * @session: is a #MHD_gtls_session_t structure.
  * @data: contains the data to send
  * @sizeofdata: is the length of the data
  *
@@ -1065,7 +1065,7 @@ begin:
  * Note that if the send buffer is full, send() will block this
  * function.  See the send() documentation for full information.  You
  * can replace the default push function by using
- * MHD_gnutls_transport_set_ptr2() with a call to send() with a
+ * MHD__gnutls_transport_set_ptr2() with a call to send() with a
  * MSG_DONTWAIT flag if blocking is a problem.
  *
  * If the EINTR is returned by the internal push function (the
@@ -1073,7 +1073,7 @@ begin:
  * %GNUTLS_E_INTERRUPTED or %GNUTLS_E_AGAIN is returned, you must
  * call this function again, with the same parameters; alternatively
  * you could provide a %NULL pointer for data, and 0 for
- * size. cf. MHD_gnutls_record_get_direction().
+ * size. cf. MHD__gnutls_record_get_direction().
  *
  * Returns: the number of bytes sent, or a negative error code.  The
  * number of bytes sent might be less than @sizeofdata.  The maximum
@@ -1081,16 +1081,16 @@ begin:
  * the negotiated maximum record size.
  **/
 ssize_t
-MHD_gnutls_record_send (mhd_gtls_session_t session,
+MHD__gnutls_record_send (MHD_gtls_session_t session,
                         const void *data, size_t sizeofdata)
 {
-  return mhd_gtls_send_int (session, GNUTLS_APPLICATION_DATA, -1, data,
+  return MHD_gtls_send_int (session, GNUTLS_APPLICATION_DATA, -1, data,
                             sizeofdata);
 }
 
 /**
- * MHD_gnutls_record_recv - reads data from the TLS record protocol
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD__gnutls_record_recv - reads data from the TLS record protocol
+ * @session: is a #MHD_gtls_session_t structure.
  * @data: the buffer that the data will be read into
  * @sizeofdata: the number of requested bytes
  *
@@ -1108,7 +1108,7 @@ MHD_gnutls_record_send (mhd_gtls_session_t session,
  * is recv()) then %GNUTLS_E_INTERRUPTED will be returned.  If
  * %GNUTLS_E_INTERRUPTED or %GNUTLS_E_AGAIN is returned, you must
  * call this function again to get the data.  See also
- * MHD_gnutls_record_get_direction().
+ * MHD__gnutls_record_get_direction().
  *
  * A server may also receive %GNUTLS_E_REHANDSHAKE when a client has
  * initiated a handshake. In that case the server can only initiate a
@@ -1119,23 +1119,23 @@ MHD_gnutls_record_send (mhd_gtls_session_t session,
  * received might be less than @sizeofdata.
  **/
 ssize_t
-MHD_gnutls_record_recv (mhd_gtls_session_t session, void *data,
+MHD__gnutls_record_recv (MHD_gtls_session_t session, void *data,
                         size_t sizeofdata)
 {
-  return mhd_gtls_recv_int (session, GNUTLS_APPLICATION_DATA, -1, data,
+  return MHD_gtls_recv_int (session, GNUTLS_APPLICATION_DATA, -1, data,
                             sizeofdata);
 }
 
 /**
- * MHD_gnutls_record_get_max_size - returns the maximum record size
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD__gnutls_record_get_max_size - returns the maximum record size
+ * @session: is a #MHD_gtls_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
-MHD_gnutls_record_get_max_size (mhd_gtls_session_t session)
+MHD__gnutls_record_get_max_size (MHD_gtls_session_t session)
 {
   /* Recv will hold the negotiated max record size
    * always.
@@ -1144,8 +1144,8 @@ MHD_gnutls_record_get_max_size (mhd_gtls_session_t session)
 }
 
 /**
- * MHD_gnutls_record_set_max_size - sets the maximum record size
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD__gnutls_record_set_max_size - sets the maximum record size
+ * @session: is a #MHD_gtls_session_t structure.
  * @size: is the new size
  *
  * This function sets the maximum record packet size in this
@@ -1161,18 +1161,18 @@ MHD_gnutls_record_get_max_size (mhd_gtls_session_t session)
  * all TLS implementations use or even understand this extension.
  **/
 ssize_t
-MHD_gnutls_record_set_max_size (mhd_gtls_session_t session, size_t size)
+MHD__gnutls_record_set_max_size (MHD_gtls_session_t session, size_t size)
 {
   ssize_t new_size;
 
   if (session->security_parameters.entity == GNUTLS_SERVER)
     return GNUTLS_E_INVALID_REQUEST;
 
-  new_size = mhd_gtls_mre_record2num (size);
+  new_size = MHD_gtls_mre_record2num (size);
 
   if (new_size < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return new_size;
     }
 
diff --git a/src/daemon/https/tls/gnutls_record.h b/src/daemon/https/tls/gnutls_record.h
index e1fea3f2..fe7300b6 100644
--- a/src/daemon/https/tls/gnutls_record.h
+++ b/src/daemon/https/tls/gnutls_record.h
@@ -22,12 +22,12 @@
  *
  */
 
-ssize_t mhd_gtls_send_int (mhd_gtls_session_t session, content_type_t type,
-                           gnutls_handshake_description_t htype,
+ssize_t MHD_gtls_send_int (MHD_gtls_session_t session, content_type_t type,
+                           MHD_gnutls_handshake_description_t htype,
                            const void *data, size_t sizeofdata);
-ssize_t mhd_gtls_recv_int (mhd_gtls_session_t session, content_type_t type,
-                           gnutls_handshake_description_t, opaque * data,
+ssize_t MHD_gtls_recv_int (MHD_gtls_session_t session, content_type_t type,
+                           MHD_gnutls_handshake_description_t, opaque * data,
                            size_t sizeofdata);
-ssize_t mhd_gtls_send_change_cipher_spec (mhd_gtls_session_t session,
+ssize_t MHD_gtls_send_change_cipher_spec (MHD_gtls_session_t session,
                                           int again);
-void MHD_gnutls_transport_set_lowat (mhd_gtls_session_t session, int num);
+void MHD__gnutls_transport_set_lowat (MHD_gtls_session_t session, int num);
diff --git a/src/daemon/https/tls/gnutls_rsa_export.c b/src/daemon/https/tls/gnutls_rsa_export.c
index ce06e47e..64834a98 100644
--- a/src/daemon/https/tls/gnutls_rsa_export.c
+++ b/src/daemon/https/tls/gnutls_rsa_export.c
@@ -46,7 +46,7 @@
  * We only support limited key sizes.
  */
 const mpi_t *
-_gnutls_rsa_params_to_mpi (mhd_gtls_rsa_params_t rsa_params)
+MHD__gnutls_rsa_params_to_mpi (MHD_gtls_rsa_params_t rsa_params)
 {
   if (rsa_params == NULL)
     {
@@ -61,7 +61,7 @@ _gnutls_rsa_params_to_mpi (mhd_gtls_rsa_params_t rsa_params)
  * prime1 - p (3), prime2 - q(4), u (5).
  */
 int
-_gnutls_rsa_generate_params (mpi_t * resarr, int *resarr_len, int bits)
+MHD__gnutls_rsa_generate_params (mpi_t * resarr, int *resarr_len, int bits)
 {
 
   int ret;
@@ -70,7 +70,7 @@ _gnutls_rsa_generate_params (mpi_t * resarr, int *resarr_len, int bits)
   ret = gcry_sexp_build (&parms, NULL, "(genkey(rsa(nbits %d)))", bits);
   if (ret != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
@@ -80,14 +80,14 @@ _gnutls_rsa_generate_params (mpi_t * resarr, int *resarr_len, int bits)
 
   if (ret != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
   list = gcry_sexp_find_token (key, "n", 0);
   if (list == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       gcry_sexp_release (key);
       return GNUTLS_E_INTERNAL_ERROR;
     }
@@ -98,7 +98,7 @@ _gnutls_rsa_generate_params (mpi_t * resarr, int *resarr_len, int bits)
   list = gcry_sexp_find_token (key, "e", 0);
   if (list == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       gcry_sexp_release (key);
       return GNUTLS_E_INTERNAL_ERROR;
     }
@@ -109,7 +109,7 @@ _gnutls_rsa_generate_params (mpi_t * resarr, int *resarr_len, int bits)
   list = gcry_sexp_find_token (key, "d", 0);
   if (list == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       gcry_sexp_release (key);
       return GNUTLS_E_INTERNAL_ERROR;
     }
@@ -120,7 +120,7 @@ _gnutls_rsa_generate_params (mpi_t * resarr, int *resarr_len, int bits)
   list = gcry_sexp_find_token (key, "p", 0);
   if (list == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       gcry_sexp_release (key);
       return GNUTLS_E_INTERNAL_ERROR;
     }
@@ -132,7 +132,7 @@ _gnutls_rsa_generate_params (mpi_t * resarr, int *resarr_len, int bits)
   list = gcry_sexp_find_token (key, "q", 0);
   if (list == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       gcry_sexp_release (key);
       return GNUTLS_E_INTERNAL_ERROR;
     }
@@ -144,7 +144,7 @@ _gnutls_rsa_generate_params (mpi_t * resarr, int *resarr_len, int bits)
   list = gcry_sexp_find_token (key, "u", 0);
   if (list == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       gcry_sexp_release (key);
       return GNUTLS_E_INTERNAL_ERROR;
     }
@@ -154,12 +154,12 @@ _gnutls_rsa_generate_params (mpi_t * resarr, int *resarr_len, int bits)
 
   gcry_sexp_release (key);
 
-  _gnutls_dump_mpi ("n: ", resarr[0]);
-  _gnutls_dump_mpi ("e: ", resarr[1]);
-  _gnutls_dump_mpi ("d: ", resarr[2]);
-  _gnutls_dump_mpi ("p: ", resarr[3]);
-  _gnutls_dump_mpi ("q: ", resarr[4]);
-  _gnutls_dump_mpi ("u: ", resarr[5]);
+  MHD__gnutls_dump_mpi ("n: ", resarr[0]);
+  MHD__gnutls_dump_mpi ("e: ", resarr[1]);
+  MHD__gnutls_dump_mpi ("d: ", resarr[2]);
+  MHD__gnutls_dump_mpi ("p: ", resarr[3]);
+  MHD__gnutls_dump_mpi ("q: ", resarr[4]);
+  MHD__gnutls_dump_mpi ("u: ", resarr[5]);
 
   *resarr_len = 6;
 
@@ -168,21 +168,21 @@ _gnutls_rsa_generate_params (mpi_t * resarr, int *resarr_len, int bits)
 }
 
 /**
-  * MHD_gnutls_rsa_params_init - This function will initialize the temporary RSA parameters
+  * MHD__gnutls_rsa_params_init - This function will initialize the temporary RSA parameters
   * @rsa_params: Is a structure that will hold the parameters
   *
   * This function will initialize the temporary RSA parameters structure.
   *
   **/
 int
-MHD_gnutls_rsa_params_init (mhd_gtls_rsa_params_t * rsa_params)
+MHD__gnutls_rsa_params_init (MHD_gtls_rsa_params_t * rsa_params)
 {
   int ret;
 
-  ret = gnutls_x509_privkey_init (rsa_params);
+  ret = MHD_gnutls_x509_privkey_init (rsa_params);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -192,20 +192,20 @@ MHD_gnutls_rsa_params_init (mhd_gtls_rsa_params_t * rsa_params)
 }
 
 /**
-  * MHD_gnutls_rsa_params_deinit - This function will deinitialize the RSA parameters
+  * MHD__gnutls_rsa_params_deinit - This function will deinitialize the RSA parameters
   * @rsa_params: Is a structure that holds the parameters
   *
   * This function will deinitialize the RSA parameters structure.
   *
   **/
 void
-MHD_gnutls_rsa_params_deinit (mhd_gtls_rsa_params_t rsa_params)
+MHD__gnutls_rsa_params_deinit (MHD_gtls_rsa_params_t rsa_params)
 {
-  gnutls_x509_privkey_deinit (rsa_params);
+  MHD_gnutls_x509_privkey_deinit (rsa_params);
 }
 
 /**
-  * MHD_gnutls_rsa_params_generate2 - This function will generate temporary RSA parameters
+  * MHD__gnutls_rsa_params_generate2 - This function will generate temporary RSA parameters
   * @params: The structure where the parameters will be stored
   * @bits: is the prime's number of bits
   *
@@ -220,8 +220,8 @@ MHD_gnutls_rsa_params_deinit (mhd_gtls_rsa_params_t rsa_params)
   *
   **/
 int
-MHD_gnutls_rsa_params_generate2 (mhd_gtls_rsa_params_t params,
+MHD__gnutls_rsa_params_generate2 (MHD_gtls_rsa_params_t params,
                                  unsigned int bits)
 {
-  return gnutls_x509_privkey_generate (params, MHD_GNUTLS_PK_RSA, bits, 0);
+  return MHD_gnutls_x509_privkey_generate (params, MHD_GNUTLS_PK_RSA, bits, 0);
 }
diff --git a/src/daemon/https/tls/gnutls_rsa_export.h b/src/daemon/https/tls/gnutls_rsa_export.h
index 8e21ed59..61cfdd97 100644
--- a/src/daemon/https/tls/gnutls_rsa_export.h
+++ b/src/daemon/https/tls/gnutls_rsa_export.h
@@ -22,6 +22,6 @@
  *
  */
 
-const mpi_t *_gnutls_rsa_params_to_mpi (mhd_gtls_rsa_params_t);
-int _gnutls_peers_cert_less_512 (mhd_gtls_session_t session);
-int _gnutls_rsa_generate_params (mpi_t * resarr, int *resarr_len, int bits);
+const mpi_t *MHD__gnutls_rsa_params_to_mpi (MHD_gtls_rsa_params_t);
+int MHD__gnutls_peers_cert_less_512 (MHD_gtls_session_t session);
+int MHD__gnutls_rsa_generate_params (mpi_t * resarr, int *resarr_len, int bits);
diff --git a/src/daemon/https/tls/gnutls_session.c b/src/daemon/https/tls/gnutls_session.c
index 95758817..81a56d5c 100644
--- a/src/daemon/https/tls/gnutls_session.c
+++ b/src/daemon/https/tls/gnutls_session.c
@@ -31,7 +31,7 @@
 
 /**
   * MHD_gtls_session_get_id - Returns session id.
-  * @session: is a #mhd_gtls_session_t structure.
+  * @session: is a #MHD_gtls_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.
   *
@@ -46,7 +46,7 @@
   * Returns zero on success.
   **/
 int
-MHD_gtls_session_get_id (mhd_gtls_session_t session,
+MHD_gtls_session_get_id (MHD_gtls_session_t session,
                          void *session_id, size_t * session_id_size)
 {
   size_t given_session_id_size = *session_id_size;
diff --git a/src/daemon/https/tls/gnutls_session_pack.c b/src/daemon/https/tls/gnutls_session_pack.c
index 85bebc8c..258cd9c2 100644
--- a/src/daemon/https/tls/gnutls_session_pack.c
+++ b/src/daemon/https/tls/gnutls_session_pack.c
@@ -43,16 +43,16 @@
 
 #define PACK_HEADER_SIZE 1
 #define MAX_SEC_PARAMS 7+MAX_SRP_USERNAME+MAX_SERVER_NAME_EXTENSIONS*(3+MAX_SERVER_NAME_SIZE)+165
-static int pack_certificate_auth_info (mhd_gtls_session_t,
-                                       gnutls_datum_t * packed_session);
-static int unpack_certificate_auth_info (mhd_gtls_session_t,
-                                         const gnutls_datum_t *
+static int pack_certificate_auth_info (MHD_gtls_session_t,
+                                       MHD_gnutls_datum_t * packed_session);
+static int unpack_certificate_auth_info (MHD_gtls_session_t,
+                                         const MHD_gnutls_datum_t *
                                          packed_session);
 
-static int unpack_security_parameters (mhd_gtls_session_t session,
-                                       const gnutls_datum_t * packed_session);
-static int pack_security_parameters (mhd_gtls_session_t session,
-                                     gnutls_datum_t * packed_session);
+static int unpack_security_parameters (MHD_gtls_session_t session,
+                                       const MHD_gnutls_datum_t * packed_session);
+static int pack_security_parameters (MHD_gtls_session_t session,
+                                     MHD_gnutls_datum_t * packed_session);
 
 /* Packs the ANON session authentication data. */
 #ifdef ENABLE_ANON
@@ -69,10 +69,10 @@ static int pack_security_parameters (mhd_gtls_session_t session,
  *      x bytes the public key
  */
 static int
-pack_anon_auth_info (mhd_gtls_session_t session,
-                     gnutls_datum_t * packed_session)
+pack_anon_auth_info (MHD_gtls_session_t session,
+                     MHD_gnutls_datum_t * packed_session)
 {
-  mhd_anon_auth_info_t info = mhd_gtls_get_auth_info (session);
+  mhd_anon_auth_info_t info = MHD_gtls_get_auth_info (session);
   int pos = 0;
   size_t pack_size;
 
@@ -87,29 +87,29 @@ pack_anon_auth_info (mhd_gtls_session_t session,
   /* calculate the size and allocate the data.
    */
   packed_session->data =
-    gnutls_malloc (packed_session->size + MAX_SEC_PARAMS);
+    MHD_gnutls_malloc (packed_session->size + MAX_SEC_PARAMS);
 
   if (packed_session->data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
   packed_session->data[0] = MHD_GNUTLS_CRD_ANON;
-  mhd_gtls_write_uint32 (pack_size, &packed_session->data[PACK_HEADER_SIZE]);
+  MHD_gtls_write_uint32 (pack_size, &packed_session->data[PACK_HEADER_SIZE]);
   pos += 4 + PACK_HEADER_SIZE;
 
   if (pack_size > 0)
     {
-      mhd_gtls_write_uint16 (info->dh.secret_bits,
+      MHD_gtls_write_uint16 (info->dh.secret_bits,
                              &packed_session->data[pos]);
       pos += 2;
 
-      mhd_gtls_write_datum32 (&packed_session->data[pos], info->dh.prime);
+      MHD_gtls_write_datum32 (&packed_session->data[pos], info->dh.prime);
       pos += 4 + info->dh.prime.size;
-      mhd_gtls_write_datum32 (&packed_session->data[pos], info->dh.generator);
+      MHD_gtls_write_datum32 (&packed_session->data[pos], info->dh.generator);
       pos += 4 + info->dh.generator.size;
-      mhd_gtls_write_datum32 (&packed_session->data[pos],
+      MHD_gtls_write_datum32 (&packed_session->data[pos],
                               info->dh.public_key);
       pos += 4 + info->dh.public_key.size;
 
@@ -130,8 +130,8 @@ pack_anon_auth_info (mhd_gtls_session_t session,
  *      x bytes the public key
  */
 static int
-unpack_anon_auth_info (mhd_gtls_session_t session,
-                       const gnutls_datum_t * packed_session)
+unpack_anon_auth_info (MHD_gtls_session_t session,
+                       const MHD_gnutls_datum_t * packed_session)
 {
   size_t pack_size;
   int pos = 0, size, ret;
@@ -139,11 +139,11 @@ unpack_anon_auth_info (mhd_gtls_session_t session,
 
   if (packed_session->data[0] != MHD_GNUTLS_CRD_ANON)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  pack_size = mhd_gtls_read_uint32 (&packed_session->data[PACK_HEADER_SIZE]);
+  pack_size = MHD_gtls_read_uint32 (&packed_session->data[PACK_HEADER_SIZE]);
   pos += PACK_HEADER_SIZE + 4;
 
 
@@ -153,60 +153,60 @@ unpack_anon_auth_info (mhd_gtls_session_t session,
   /* a simple check for integrity */
   if (pack_size + PACK_HEADER_SIZE + 4 > packed_session->size)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   /* client and serer have the same auth_info here
    */
   ret =
-    mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_ANON,
+    MHD_gtls_auth_info_set (session, MHD_GNUTLS_CRD_ANON,
                             sizeof (anon_auth_info_st), 1);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  info = mhd_gtls_get_auth_info (session);
+  info = MHD_gtls_get_auth_info (session);
   if (info == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
-  info->dh.secret_bits = mhd_gtls_read_uint16 (&packed_session->data[pos]);
+  info->dh.secret_bits = MHD_gtls_read_uint16 (&packed_session->data[pos]);
   pos += 2;
 
-  size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
+  size = MHD_gtls_read_uint32 (&packed_session->data[pos]);
   pos += 4;
-  ret = _gnutls_set_datum (&info->dh.prime, &packed_session->data[pos], size);
+  ret = MHD__gnutls_set_datum (&info->dh.prime, &packed_session->data[pos], size);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
   pos += size;
 
-  size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
+  size = MHD_gtls_read_uint32 (&packed_session->data[pos]);
   pos += 4;
   ret =
-    _gnutls_set_datum (&info->dh.generator, &packed_session->data[pos], size);
+    MHD__gnutls_set_datum (&info->dh.generator, &packed_session->data[pos], size);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
   pos += size;
 
-  size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
+  size = MHD_gtls_read_uint32 (&packed_session->data[pos]);
   pos += 4;
   ret =
-    _gnutls_set_datum (&info->dh.public_key, &packed_session->data[pos],
+    MHD__gnutls_set_datum (&info->dh.public_key, &packed_session->data[pos],
                        size);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
   pos += size;
@@ -214,9 +214,9 @@ unpack_anon_auth_info (mhd_gtls_session_t session,
   return 0;
 
 error:
-  _gnutls_free_datum (&info->dh.prime);
-  _gnutls_free_datum (&info->dh.generator);
-  _gnutls_free_datum (&info->dh.public_key);
+  MHD__gnutls_free_datum (&info->dh.prime);
+  MHD__gnutls_free_datum (&info->dh.generator);
+  MHD__gnutls_free_datum (&info->dh.public_key);
   return ret;
 }
 #endif /* ANON */
@@ -230,14 +230,14 @@ error:
  * The data will be in a platform independent format.
  */
 int
-mhd_gtls_session_pack (mhd_gtls_session_t session,
-                       gnutls_datum_t * packed_session)
+MHD_gtls_session_pack (MHD_gtls_session_t session,
+                       MHD_gnutls_datum_t * packed_session)
 {
   int ret;
 
   if (packed_session == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
@@ -249,7 +249,7 @@ mhd_gtls_session_pack (mhd_gtls_session_t session,
       ret = pack_srp_auth_info (session, packed_session);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
       break;
@@ -259,7 +259,7 @@ mhd_gtls_session_pack (mhd_gtls_session_t session,
       ret = pack_psk_auth_info (session, packed_session);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
       break;
@@ -269,7 +269,7 @@ mhd_gtls_session_pack (mhd_gtls_session_t session,
       ret = pack_anon_auth_info (session, packed_session);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
       break;
@@ -278,7 +278,7 @@ mhd_gtls_session_pack (mhd_gtls_session_t session,
       ret = pack_certificate_auth_info (session, packed_session);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
       break;
@@ -287,14 +287,14 @@ mhd_gtls_session_pack (mhd_gtls_session_t session,
 
     }
 
-  /* Auth_info structures copied. Now copy mhd_gtls_security_param_st.
+  /* Auth_info structures copied. Now copy MHD_gtls_security_param_st.
    * packed_session must have allocated space for the security parameters.
    */
   ret = pack_security_parameters (session, packed_session);
   if (ret < 0)
     {
-      gnutls_assert ();
-      _gnutls_free_datum (packed_session);
+      MHD_gnutls_assert ();
+      MHD__gnutls_free_datum (packed_session);
       return ret;
     }
 
@@ -305,20 +305,20 @@ mhd_gtls_session_pack (mhd_gtls_session_t session,
 /* Load session data from a buffer.
  */
 int
-mhd_gtls_session_unpack (mhd_gtls_session_t session,
-                         const gnutls_datum_t * packed_session)
+MHD_gtls_session_unpack (MHD_gtls_session_t session,
+                         const MHD_gnutls_datum_t * packed_session)
 {
   int ret;
 
   if (packed_session == NULL || packed_session->size == 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
-  if (mhd_gtls_get_auth_info (session) != NULL)
+  if (MHD_gtls_get_auth_info (session) != NULL)
     {
-      mhd_gtls_free_auth_info (session);
+      MHD_gtls_free_auth_info (session);
     }
 
   switch (packed_session->data[0])
@@ -328,7 +328,7 @@ mhd_gtls_session_unpack (mhd_gtls_session_t session,
       ret = unpack_srp_auth_info (session, packed_session);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
       break;
@@ -338,7 +338,7 @@ mhd_gtls_session_unpack (mhd_gtls_session_t session,
       ret = unpack_psk_auth_info (session, packed_session);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
       break;
@@ -348,7 +348,7 @@ mhd_gtls_session_unpack (mhd_gtls_session_t session,
       ret = unpack_anon_auth_info (session, packed_session);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
       break;
@@ -357,23 +357,23 @@ mhd_gtls_session_unpack (mhd_gtls_session_t session,
       ret = unpack_certificate_auth_info (session, packed_session);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
       break;
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
 
     }
 
-  /* Auth_info structures copied. Now copy mhd_gtls_security_param_st.
+  /* Auth_info structures copied. Now copy MHD_gtls_security_param_st.
    * packed_session must have allocated space for the security parameters.
    */
   ret = unpack_security_parameters (session, packed_session);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -404,12 +404,12 @@ mhd_gtls_session_unpack (mhd_gtls_session_t session,
  *       and so on...
  */
 static int
-pack_certificate_auth_info (mhd_gtls_session_t session,
-                            gnutls_datum_t * packed_session)
+pack_certificate_auth_info (MHD_gtls_session_t session,
+                            MHD_gnutls_datum_t * packed_session)
 {
   unsigned int pos = 0, i;
   int cert_size, pack_size;
-  cert_auth_info_t info = mhd_gtls_get_auth_info (session);
+  cert_auth_info_t info = MHD_gtls_get_auth_info (session);
 
   if (info)
     {
@@ -431,47 +431,47 @@ pack_certificate_auth_info (mhd_gtls_session_t session,
   /* calculate the size and allocate the data.
    */
   packed_session->data =
-    gnutls_malloc (packed_session->size + MAX_SEC_PARAMS);
+    MHD_gnutls_malloc (packed_session->size + MAX_SEC_PARAMS);
 
   if (packed_session->data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
   packed_session->data[0] = MHD_GNUTLS_CRD_CERTIFICATE;
-  mhd_gtls_write_uint32 (pack_size, &packed_session->data[PACK_HEADER_SIZE]);
+  MHD_gtls_write_uint32 (pack_size, &packed_session->data[PACK_HEADER_SIZE]);
   pos += 4 + PACK_HEADER_SIZE;
 
 
   if (pack_size > 0)
     {
 
-      mhd_gtls_write_uint16 (info->dh.secret_bits,
+      MHD_gtls_write_uint16 (info->dh.secret_bits,
                              &packed_session->data[pos]);
       pos += 2;
 
-      mhd_gtls_write_datum32 (&packed_session->data[pos], info->dh.prime);
+      MHD_gtls_write_datum32 (&packed_session->data[pos], info->dh.prime);
       pos += 4 + info->dh.prime.size;
-      mhd_gtls_write_datum32 (&packed_session->data[pos], info->dh.generator);
+      MHD_gtls_write_datum32 (&packed_session->data[pos], info->dh.generator);
       pos += 4 + info->dh.generator.size;
-      mhd_gtls_write_datum32 (&packed_session->data[pos],
+      MHD_gtls_write_datum32 (&packed_session->data[pos],
                               info->dh.public_key);
       pos += 4 + info->dh.public_key.size;
 
-      mhd_gtls_write_datum32 (&packed_session->data[pos],
+      MHD_gtls_write_datum32 (&packed_session->data[pos],
                               info->rsa_export.modulus);
       pos += 4 + info->rsa_export.modulus.size;
-      mhd_gtls_write_datum32 (&packed_session->data[pos],
+      MHD_gtls_write_datum32 (&packed_session->data[pos],
                               info->rsa_export.exponent);
       pos += 4 + info->rsa_export.exponent.size;
 
-      mhd_gtls_write_uint32 (info->ncerts, &packed_session->data[pos]);
+      MHD_gtls_write_uint32 (info->ncerts, &packed_session->data[pos]);
       pos += 4;
 
       for (i = 0; i < info->ncerts; i++)
         {
-          mhd_gtls_write_datum32 (&packed_session->data[pos],
+          MHD_gtls_write_datum32 (&packed_session->data[pos],
                                   info->raw_certificate_list[i]);
           pos += sizeof (uint32_t) + info->raw_certificate_list[i].size;
         }
@@ -484,8 +484,8 @@ pack_certificate_auth_info (mhd_gtls_session_t session,
 /* Upack certificate info.
  */
 static int
-unpack_certificate_auth_info (mhd_gtls_session_t session,
-                              const gnutls_datum_t * packed_session)
+unpack_certificate_auth_info (MHD_gtls_session_t session,
+                              const MHD_gnutls_datum_t * packed_session)
 {
   int pos = 0, size, ret;
   unsigned int i = 0, j;
@@ -494,11 +494,11 @@ unpack_certificate_auth_info (mhd_gtls_session_t session,
 
   if (packed_session->data[0] != MHD_GNUTLS_CRD_CERTIFICATE)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  pack_size = mhd_gtls_read_uint32 (&packed_session->data[PACK_HEADER_SIZE]);
+  pack_size = MHD_gtls_read_uint32 (&packed_session->data[PACK_HEADER_SIZE]);
   pos += PACK_HEADER_SIZE + 4;
 
   if (pack_size == 0)
@@ -507,98 +507,98 @@ unpack_certificate_auth_info (mhd_gtls_session_t session,
   /* a simple check for integrity */
   if (pack_size + PACK_HEADER_SIZE + 4 > packed_session->size)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   /* client and server have the same auth_info here
    */
   ret =
-    mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
+    MHD_gtls_auth_info_set (session, MHD_GNUTLS_CRD_CERTIFICATE,
                             sizeof (cert_auth_info_st), 1);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  info = mhd_gtls_get_auth_info (session);
+  info = MHD_gtls_get_auth_info (session);
   if (info == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
-  info->dh.secret_bits = mhd_gtls_read_uint16 (&packed_session->data[pos]);
+  info->dh.secret_bits = MHD_gtls_read_uint16 (&packed_session->data[pos]);
   pos += 2;
 
-  size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
+  size = MHD_gtls_read_uint32 (&packed_session->data[pos]);
   pos += 4;
-  ret = _gnutls_set_datum (&info->dh.prime, &packed_session->data[pos], size);
+  ret = MHD__gnutls_set_datum (&info->dh.prime, &packed_session->data[pos], size);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
   pos += size;
 
-  size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
+  size = MHD_gtls_read_uint32 (&packed_session->data[pos]);
   pos += 4;
   ret =
-    _gnutls_set_datum (&info->dh.generator, &packed_session->data[pos], size);
+    MHD__gnutls_set_datum (&info->dh.generator, &packed_session->data[pos], size);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
   pos += size;
 
-  size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
+  size = MHD_gtls_read_uint32 (&packed_session->data[pos]);
   pos += 4;
   ret =
-    _gnutls_set_datum (&info->dh.public_key, &packed_session->data[pos],
+    MHD__gnutls_set_datum (&info->dh.public_key, &packed_session->data[pos],
                        size);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
   pos += size;
 
-  size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
+  size = MHD_gtls_read_uint32 (&packed_session->data[pos]);
   pos += 4;
   ret =
-    _gnutls_set_datum (&info->rsa_export.modulus,
+    MHD__gnutls_set_datum (&info->rsa_export.modulus,
                        &packed_session->data[pos], size);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
   pos += size;
 
-  size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
+  size = MHD_gtls_read_uint32 (&packed_session->data[pos]);
   pos += 4;
   ret =
-    _gnutls_set_datum (&info->rsa_export.exponent,
+    MHD__gnutls_set_datum (&info->rsa_export.exponent,
                        &packed_session->data[pos], size);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
   pos += size;
 
-  info->ncerts = mhd_gtls_read_uint32 (&packed_session->data[pos]);
+  info->ncerts = MHD_gtls_read_uint32 (&packed_session->data[pos]);
   pos += 4;
 
   if (info->ncerts > 0)
     {
       info->raw_certificate_list =
-        gnutls_calloc (1, sizeof (gnutls_datum_t) * info->ncerts);
+        MHD_gnutls_calloc (1, sizeof (MHD_gnutls_datum_t) * info->ncerts);
       if (info->raw_certificate_list == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           ret = GNUTLS_E_MEMORY_ERROR;
           goto error;
         }
@@ -606,17 +606,17 @@ unpack_certificate_auth_info (mhd_gtls_session_t session,
 
   for (i = 0; i < info->ncerts; i++)
     {
-      size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
+      size = MHD_gtls_read_uint32 (&packed_session->data[pos]);
       pos += sizeof (uint32_t);
 
       ret =
-        _gnutls_set_datum (&info->raw_certificate_list[i],
+        MHD__gnutls_set_datum (&info->raw_certificate_list[i],
                            &packed_session->data[pos], size);
       pos += size;
 
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           goto error;
         }
     }
@@ -625,17 +625,17 @@ unpack_certificate_auth_info (mhd_gtls_session_t session,
   return 0;
 
 error:
-  _gnutls_free_datum (&info->dh.prime);
-  _gnutls_free_datum (&info->dh.generator);
-  _gnutls_free_datum (&info->dh.public_key);
+  MHD__gnutls_free_datum (&info->dh.prime);
+  MHD__gnutls_free_datum (&info->dh.generator);
+  MHD__gnutls_free_datum (&info->dh.public_key);
 
-  _gnutls_free_datum (&info->rsa_export.modulus);
-  _gnutls_free_datum (&info->rsa_export.exponent);
+  MHD__gnutls_free_datum (&info->rsa_export.modulus);
+  MHD__gnutls_free_datum (&info->rsa_export.exponent);
 
   for (j = 0; j < i; j++)
-    _gnutls_free_datum (&info->raw_certificate_list[j]);
+    MHD__gnutls_free_datum (&info->raw_certificate_list[j]);
 
-  gnutls_free (info->raw_certificate_list);
+  MHD_gnutls_free (info->raw_certificate_list);
 
   return ret;
 
@@ -651,10 +651,10 @@ error:
  *      x bytes the SRP username
  */
 static int
-pack_srp_auth_info (mhd_gtls_session_t session,
-                    gnutls_datum_t * packed_session)
+pack_srp_auth_info (MHD_gtls_session_t session,
+                    MHD_gnutls_datum_t * packed_session)
 {
-  srp_server_auth_info_t info = mhd_gtls_get_auth_info (session);
+  srp_server_auth_info_t info = MHD_gtls_get_auth_info (session);
   int pack_size;
 
   if (info && info->username)
@@ -667,16 +667,16 @@ pack_srp_auth_info (mhd_gtls_session_t session,
   /* calculate the size and allocate the data.
    */
   packed_session->data =
-    gnutls_malloc (packed_session->size + MAX_SEC_PARAMS);
+    MHD_gnutls_malloc (packed_session->size + MAX_SEC_PARAMS);
 
   if (packed_session->data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
   packed_session->data[0] = MHD_GNUTLS_CRD_SRP;
-  mhd_gtls_write_uint32 (pack_size, &packed_session->data[PACK_HEADER_SIZE]);
+  MHD_gtls_write_uint32 (pack_size, &packed_session->data[PACK_HEADER_SIZE]);
 
   if (pack_size > 0)
     memcpy (&packed_session->data[PACK_HEADER_SIZE + sizeof (uint32_t)],
@@ -687,8 +687,8 @@ pack_srp_auth_info (mhd_gtls_session_t session,
 
 
 static int
-unpack_srp_auth_info (mhd_gtls_session_t session,
-                      const gnutls_datum_t * packed_session)
+unpack_srp_auth_info (MHD_gtls_session_t session,
+                      const MHD_gnutls_datum_t * packed_session)
 {
   size_t username_size;
   int ret;
@@ -696,12 +696,12 @@ unpack_srp_auth_info (mhd_gtls_session_t session,
 
   if (packed_session->data[0] != MHD_GNUTLS_CRD_SRP)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   username_size =
-    mhd_gtls_read_uint32 (&packed_session->data[PACK_HEADER_SIZE]);
+    MHD_gtls_read_uint32 (&packed_session->data[PACK_HEADER_SIZE]);
 
   if (username_size == 0)
     return 0;                   /* nothing to be done */
@@ -709,23 +709,23 @@ unpack_srp_auth_info (mhd_gtls_session_t session,
   /* a simple check for integrity */
   if (username_size + 4 + PACK_HEADER_SIZE > packed_session->size)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   ret =
-    mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_SRP,
+    MHD_gtls_auth_info_set (session, MHD_GNUTLS_CRD_SRP,
                             sizeof (srp_server_auth_info_st), 1);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  info = mhd_gtls_get_auth_info (session);
+  info = MHD_gtls_get_auth_info (session);
   if (info == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
@@ -757,13 +757,13 @@ unpack_srp_auth_info (mhd_gtls_session_t session,
  *      x bytes the public key
  */
 static int
-pack_psk_auth_info (mhd_gtls_session_t session,
-                    gnutls_datum_t * packed_session)
+pack_psk_auth_info (MHD_gtls_session_t session,
+                    MHD_gnutls_datum_t * packed_session)
 {
   psk_auth_info_t info;
   int pack_size, username_size = 0, pos;
 
-  info = mhd_gtls_get_auth_info (session);
+  info = MHD_gtls_get_auth_info (session);
 
   if (info)
     {
@@ -780,11 +780,11 @@ pack_psk_auth_info (mhd_gtls_session_t session,
   /* calculate the size and allocate the data.
    */
   packed_session->data =
-    gnutls_malloc (packed_session->size + MAX_SEC_PARAMS);
+    MHD_gnutls_malloc (packed_session->size + MAX_SEC_PARAMS);
 
   if (packed_session->data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
@@ -793,27 +793,27 @@ pack_psk_auth_info (mhd_gtls_session_t session,
   packed_session->data[pos] = MHD_GNUTLS_CRD_PSK;
   pos++;
 
-  mhd_gtls_write_uint32 (pack_size, &packed_session->data[pos]);
+  MHD_gtls_write_uint32 (pack_size, &packed_session->data[pos]);
   pos += 4;
 
 
   if (pack_size > 0)
     {
-      mhd_gtls_write_uint32 (username_size, &packed_session->data[pos]);
+      MHD_gtls_write_uint32 (username_size, &packed_session->data[pos]);
       pos += 4;
 
       memcpy (&packed_session->data[pos], info->username, username_size);
       pos += username_size;
 
-      mhd_gtls_write_uint16 (info->dh.secret_bits,
+      MHD_gtls_write_uint16 (info->dh.secret_bits,
                              &packed_session->data[pos]);
       pos += 2;
 
-      mhd_gtls_write_datum32 (&packed_session->data[pos], info->dh.prime);
+      MHD_gtls_write_datum32 (&packed_session->data[pos], info->dh.prime);
       pos += 4 + info->dh.prime.size;
-      mhd_gtls_write_datum32 (&packed_session->data[pos], info->dh.generator);
+      MHD_gtls_write_datum32 (&packed_session->data[pos], info->dh.generator);
       pos += 4 + info->dh.generator.size;
-      mhd_gtls_write_datum32 (&packed_session->data[pos],
+      MHD_gtls_write_datum32 (&packed_session->data[pos],
                               info->dh.public_key);
       pos += 4 + info->dh.public_key.size;
 
@@ -824,8 +824,8 @@ pack_psk_auth_info (mhd_gtls_session_t session,
 }
 
 static int
-unpack_psk_auth_info (mhd_gtls_session_t session,
-                      const gnutls_datum_t * packed_session)
+unpack_psk_auth_info (MHD_gtls_session_t session,
+                      const MHD_gnutls_datum_t * packed_session)
 {
   size_t username_size;
   size_t pack_size;
@@ -834,11 +834,11 @@ unpack_psk_auth_info (mhd_gtls_session_t session,
 
   if (packed_session->data[0] != MHD_GNUTLS_CRD_PSK)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  pack_size = mhd_gtls_read_uint32 (&packed_session->data[PACK_HEADER_SIZE]);
+  pack_size = MHD_gtls_read_uint32 (&packed_session->data[PACK_HEADER_SIZE]);
   pos += PACK_HEADER_SIZE + 4;
 
 
@@ -848,66 +848,66 @@ unpack_psk_auth_info (mhd_gtls_session_t session,
   /* a simple check for integrity */
   if (pack_size + PACK_HEADER_SIZE + 4 > packed_session->size)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   /* client and serer have the same auth_info here
    */
   ret =
-    mhd_gtls_auth_info_set (session, MHD_GNUTLS_CRD_PSK,
+    MHD_gtls_auth_info_set (session, MHD_GNUTLS_CRD_PSK,
                             sizeof (psk_auth_info_st), 1);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  info = mhd_gtls_get_auth_info (session);
+  info = MHD_gtls_get_auth_info (session);
   if (info == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
-  username_size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
+  username_size = MHD_gtls_read_uint32 (&packed_session->data[pos]);
   pos += 4;
 
   memcpy (info->username, &packed_session->data[pos], username_size);
   pos += username_size;
 
-  info->dh.secret_bits = mhd_gtls_read_uint16 (&packed_session->data[pos]);
+  info->dh.secret_bits = MHD_gtls_read_uint16 (&packed_session->data[pos]);
   pos += 2;
 
-  size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
+  size = MHD_gtls_read_uint32 (&packed_session->data[pos]);
   pos += 4;
-  ret = _gnutls_set_datum (&info->dh.prime, &packed_session->data[pos], size);
+  ret = MHD__gnutls_set_datum (&info->dh.prime, &packed_session->data[pos], size);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
   pos += size;
 
-  size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
+  size = MHD_gtls_read_uint32 (&packed_session->data[pos]);
   pos += 4;
   ret =
-    _gnutls_set_datum (&info->dh.generator, &packed_session->data[pos], size);
+    MHD__gnutls_set_datum (&info->dh.generator, &packed_session->data[pos], size);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
   pos += size;
 
-  size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
+  size = MHD_gtls_read_uint32 (&packed_session->data[pos]);
   pos += 4;
   ret =
-    _gnutls_set_datum (&info->dh.public_key, &packed_session->data[pos],
+    MHD__gnutls_set_datum (&info->dh.public_key, &packed_session->data[pos],
                        size);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
   pos += size;
@@ -915,9 +915,9 @@ unpack_psk_auth_info (mhd_gtls_session_t session,
   return 0;
 
 error:
-  _gnutls_free_datum (&info->dh.prime);
-  _gnutls_free_datum (&info->dh.generator);
-  _gnutls_free_datum (&info->dh.public_key);
+  MHD__gnutls_free_datum (&info->dh.prime);
+  MHD__gnutls_free_datum (&info->dh.generator);
+  MHD__gnutls_free_datum (&info->dh.public_key);
   return ret;
 }
 #endif
@@ -972,8 +972,8 @@ error:
  *                MAX: 7+MAX_SRP_USERNAME+MAX_SERVER_NAME_EXTENSIONS*(3+MAX_SERVER_NAME_SIZE)
  */
 static int
-pack_security_parameters (mhd_gtls_session_t session,
-                          gnutls_datum_t * packed_session)
+pack_security_parameters (MHD_gtls_session_t session,
+                          MHD_gnutls_datum_t * packed_session)
 {
   int pos = 0;
   size_t len, init, i;
@@ -981,7 +981,7 @@ pack_security_parameters (mhd_gtls_session_t session,
   /* move after the auth info stuff.
    */
   init =
-    mhd_gtls_read_uint32 (&packed_session->data[PACK_HEADER_SIZE]) + 4 +
+    MHD_gtls_read_uint32 (&packed_session->data[PACK_HEADER_SIZE]) + 4 +
     PACK_HEADER_SIZE;
 
   pos = init + 4;               /* make some space to write later the size */
@@ -1024,16 +1024,16 @@ pack_security_parameters (mhd_gtls_session_t session,
           session->security_parameters.session_id_size);
   pos += session->security_parameters.session_id_size;
 
-  mhd_gtls_write_uint32 (session->security_parameters.timestamp,
+  MHD_gtls_write_uint32 (session->security_parameters.timestamp,
                          &packed_session->data[pos]);
   pos += 4;
 
   /* Extensions */
-  mhd_gtls_write_uint16 (session->security_parameters.max_record_send_size,
+  MHD_gtls_write_uint16 (session->security_parameters.max_record_send_size,
                          &packed_session->data[pos]);
   pos += 2;
 
-  mhd_gtls_write_uint16 (session->security_parameters.max_record_recv_size,
+  MHD_gtls_write_uint16 (session->security_parameters.max_record_recv_size,
                          &packed_session->data[pos]);
   pos += 2;
 
@@ -1045,7 +1045,7 @@ pack_security_parameters (mhd_gtls_session_t session,
           session->security_parameters.extensions.srp_username, len);
   pos += len;
 
-  mhd_gtls_write_uint16 (session->security_parameters.extensions.
+  MHD_gtls_write_uint16 (session->security_parameters.extensions.
                          server_names_size, &packed_session->data[pos]);
   pos += 2;
 
@@ -1054,7 +1054,7 @@ pack_security_parameters (mhd_gtls_session_t session,
     {
       packed_session->data[pos++] =
         session->security_parameters.extensions.server_names[i].type;
-      mhd_gtls_write_uint16 (session->security_parameters.extensions.
+      MHD_gtls_write_uint16 (session->security_parameters.extensions.
                              server_names[i].name_length,
                              &packed_session->data[pos]);
       pos += 2;
@@ -1068,7 +1068,7 @@ pack_security_parameters (mhd_gtls_session_t session,
     }
 
   /* write the total size */
-  mhd_gtls_write_uint32 (pos - init - 4, &packed_session->data[init]);
+  MHD_gtls_write_uint32 (pos - init - 4, &packed_session->data[init]);
   packed_session->size += pos - init;
 
   return 0;
@@ -1076,8 +1076,8 @@ pack_security_parameters (mhd_gtls_session_t session,
 
 
 static int
-unpack_security_parameters (mhd_gtls_session_t session,
-                            const gnutls_datum_t * packed_session)
+unpack_security_parameters (MHD_gtls_session_t session,
+                            const MHD_gnutls_datum_t * packed_session)
 {
   size_t pack_size, init, i;
   int pos = 0, len;
@@ -1086,12 +1086,12 @@ unpack_security_parameters (mhd_gtls_session_t session,
 
   /* skip the auth info stuff */
   init =
-    mhd_gtls_read_uint32 (&packed_session->data[PACK_HEADER_SIZE]) + 4 +
+    MHD_gtls_read_uint32 (&packed_session->data[PACK_HEADER_SIZE]) + 4 +
     PACK_HEADER_SIZE;
 
   pos = init;
 
-  pack_size = mhd_gtls_read_uint32 (&packed_session->data[pos]);
+  pack_size = MHD_gtls_read_uint32 (&packed_session->data[pos]);
   pos += 4;
 
 
@@ -1101,7 +1101,7 @@ unpack_security_parameters (mhd_gtls_session_t session,
   /* a simple check for integrity */
   if (pack_size > MAX_SEC_PARAMS)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -1150,24 +1150,24 @@ unpack_security_parameters (mhd_gtls_session_t session,
   pos += session->internals.resumed_security_parameters.session_id_size;
 
   session->internals.resumed_security_parameters.timestamp =
-    mhd_gtls_read_uint32 (&packed_session->data[pos]);
+    MHD_gtls_read_uint32 (&packed_session->data[pos]);
   pos += 4;
 
   if (timestamp - session->internals.resumed_security_parameters.timestamp >
       session->internals.expire_time
       || session->internals.resumed_security_parameters.timestamp > timestamp)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_EXPIRED;
     }
 
   /* Extensions */
   session->internals.resumed_security_parameters.max_record_send_size =
-    mhd_gtls_read_uint16 (&packed_session->data[pos]);
+    MHD_gtls_read_uint16 (&packed_session->data[pos]);
   pos += 2;
 
   session->internals.resumed_security_parameters.max_record_recv_size =
-    mhd_gtls_read_uint16 (&packed_session->data[pos]);
+    MHD_gtls_read_uint16 (&packed_session->data[pos]);
   pos += 2;
 
 
@@ -1180,7 +1180,7 @@ unpack_security_parameters (mhd_gtls_session_t session,
   pos += len;
 
   session->internals.resumed_security_parameters.extensions.
-    server_names_size = mhd_gtls_read_uint16 (&packed_session->data[pos]);
+    server_names_size = MHD_gtls_read_uint16 (&packed_session->data[pos]);
   pos += 2;
   for (i = 0;
        i <
@@ -1191,7 +1191,7 @@ unpack_security_parameters (mhd_gtls_session_t session,
         server_names[i].type = packed_session->data[pos++];
       session->internals.resumed_security_parameters.extensions.
         server_names[i].name_length =
-        mhd_gtls_read_uint16 (&packed_session->data[pos]);
+        MHD_gtls_read_uint16 (&packed_session->data[pos]);
       pos += 2;
 
       memcpy (session->internals.resumed_security_parameters.extensions.
diff --git a/src/daemon/https/tls/gnutls_session_pack.h b/src/daemon/https/tls/gnutls_session_pack.h
index e93d9d28..e327f71f 100644
--- a/src/daemon/https/tls/gnutls_session_pack.h
+++ b/src/daemon/https/tls/gnutls_session_pack.h
@@ -22,7 +22,7 @@
  *
  */
 
-int mhd_gtls_session_pack (mhd_gtls_session_t session,
-                           gnutls_datum_t * packed_session);
-int mhd_gtls_session_unpack (mhd_gtls_session_t session,
-                             const gnutls_datum_t * packed_session);
+int MHD_gtls_session_pack (MHD_gtls_session_t session,
+                           MHD_gnutls_datum_t * packed_session);
+int MHD_gtls_session_unpack (MHD_gtls_session_t session,
+                             const MHD_gnutls_datum_t * packed_session);
diff --git a/src/daemon/https/tls/gnutls_sig.c b/src/daemon/https/tls/gnutls_sig.c
index 3a41999d..0309e588 100644
--- a/src/daemon/https/tls/gnutls_sig.c
+++ b/src/daemon/https/tls/gnutls_sig.c
@@ -37,79 +37,79 @@
 #include <gnutls_sig.h>
 #include <gnutls_kx.h>
 
-static int _gnutls_tls_sign (mhd_gtls_session_t session,
-                             gnutls_cert * cert,
-                             gnutls_privkey * pkey,
-                             const gnutls_datum_t * hash_concat,
-                             gnutls_datum_t * signature);
+static int MHD__gnutls_tls_sign (MHD_gtls_session_t session,
+                             MHD_gnutls_cert * cert,
+                             MHD_gnutls_privkey * pkey,
+                             const MHD_gnutls_datum_t * hash_concat,
+                             MHD_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
-mhd_gtls_tls_sign_hdata (mhd_gtls_session_t session,
-                         gnutls_cert * cert,
-                         gnutls_privkey * pkey, gnutls_datum_t * signature)
+MHD_gtls_tls_sign_hdata (MHD_gtls_session_t session,
+                         MHD_gnutls_cert * cert,
+                         MHD_gnutls_privkey * pkey, MHD_gnutls_datum_t * signature)
 {
-  gnutls_datum_t dconcat;
+  MHD_gnutls_datum_t dconcat;
   int ret;
   opaque concat[36];
   mac_hd_t td_md5;
   mac_hd_t td_sha;
-  enum MHD_GNUTLS_Protocol ver = MHD_gnutls_protocol_get_version (session);
+  enum MHD_GNUTLS_Protocol ver = MHD__gnutls_protocol_get_version (session);
 
-  td_sha = mhd_gnutls_hash_copy (session->internals.handshake_mac_handle_sha);
+  td_sha = MHD_gnutls_hash_copy (session->internals.handshake_mac_handle_sha);
   if (td_sha == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_HASH_FAILED;
     }
 
   if (ver == MHD_GNUTLS_PROTOCOL_SSL3)
     {
-      ret = mhd_gtls_generate_master (session, 1);
+      ret = MHD_gtls_generate_master (session, 1);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
-      mhd_gnutls_mac_deinit_ssl3_handshake (td_sha, &concat[16],
+      MHD_gnutls_mac_deinit_ssl3_handshake (td_sha, &concat[16],
                                             session->security_parameters.
                                             master_secret, TLS_MASTER_SIZE);
     }
   else
-    mhd_gnutls_hash_deinit (td_sha, &concat[16]);
+    MHD_gnutls_hash_deinit (td_sha, &concat[16]);
 
   switch (cert->subject_pk_algorithm)
     {
     case MHD_GNUTLS_PK_RSA:
       td_md5 =
-        mhd_gnutls_hash_copy (session->internals.handshake_mac_handle_md5);
+        MHD_gnutls_hash_copy (session->internals.handshake_mac_handle_md5);
       if (td_md5 == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_HASH_FAILED;
         }
 
       if (ver == MHD_GNUTLS_PROTOCOL_SSL3)
-        mhd_gnutls_mac_deinit_ssl3_handshake (td_md5, concat,
+        MHD_gnutls_mac_deinit_ssl3_handshake (td_md5, concat,
                                               session->security_parameters.
                                               master_secret, TLS_MASTER_SIZE);
       else
-        mhd_gnutls_hash_deinit (td_md5, concat);
+        MHD_gnutls_hash_deinit (td_md5, concat);
 
       dconcat.data = concat;
       dconcat.size = 36;
       break;
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
-  ret = _gnutls_tls_sign (session, cert, pkey, &dconcat, signature);
+  ret = MHD__gnutls_tls_sign (session, cert, pkey, &dconcat, signature);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
     }
 
   return ret;
@@ -119,50 +119,50 @@ mhd_gtls_tls_sign_hdata (mhd_gtls_session_t session,
  * Used in DHE_* ciphersuites.
  */
 int
-mhd_gtls_tls_sign_params (mhd_gtls_session_t session,
-                          gnutls_cert * cert,
-                          gnutls_privkey * pkey,
-                          gnutls_datum_t * params, gnutls_datum_t * signature)
+MHD_gtls_tls_sign_params (MHD_gtls_session_t session,
+                          MHD_gnutls_cert * cert,
+                          MHD_gnutls_privkey * pkey,
+                          MHD_gnutls_datum_t * params, MHD_gnutls_datum_t * signature)
 {
-  gnutls_datum_t dconcat;
+  MHD_gnutls_datum_t dconcat;
   int ret;
   mac_hd_t td_sha;
   opaque concat[36];
-  enum MHD_GNUTLS_Protocol ver = MHD_gnutls_protocol_get_version (session);
+  enum MHD_GNUTLS_Protocol ver = MHD__gnutls_protocol_get_version (session);
 
-  td_sha = mhd_gtls_hash_init (MHD_GNUTLS_MAC_SHA1);
+  td_sha = MHD_gtls_hash_init (MHD_GNUTLS_MAC_SHA1);
   if (td_sha == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_HASH_FAILED;
     }
 
-  mhd_gnutls_hash (td_sha, session->security_parameters.client_random,
+  MHD_gnutls_hash (td_sha, session->security_parameters.client_random,
                    TLS_RANDOM_SIZE);
-  mhd_gnutls_hash (td_sha, session->security_parameters.server_random,
+  MHD_gnutls_hash (td_sha, session->security_parameters.server_random,
                    TLS_RANDOM_SIZE);
-  mhd_gnutls_hash (td_sha, params->data, params->size);
+  MHD_gnutls_hash (td_sha, params->data, params->size);
 
   switch (cert->subject_pk_algorithm)
     {
     case MHD_GNUTLS_PK_RSA:
       if (ver < MHD_GNUTLS_PROTOCOL_TLS1_2)
         {
-          mac_hd_t td_md5 = mhd_gtls_hash_init (MHD_GNUTLS_MAC_MD5);
+          mac_hd_t td_md5 = MHD_gtls_hash_init (MHD_GNUTLS_MAC_MD5);
           if (td_md5 == NULL)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return GNUTLS_E_HASH_FAILED;
             }
 
-          mhd_gnutls_hash (td_md5, session->security_parameters.client_random,
+          MHD_gnutls_hash (td_md5, session->security_parameters.client_random,
                            TLS_RANDOM_SIZE);
-          mhd_gnutls_hash (td_md5, session->security_parameters.server_random,
+          MHD_gnutls_hash (td_md5, session->security_parameters.server_random,
                            TLS_RANDOM_SIZE);
-          mhd_gnutls_hash (td_md5, params->data, params->size);
+          MHD_gnutls_hash (td_md5, params->data, params->size);
 
-          mhd_gnutls_hash_deinit (td_md5, concat);
-          mhd_gnutls_hash_deinit (td_sha, &concat[16]);
+          MHD_gnutls_hash_deinit (td_md5, concat);
+          MHD_gnutls_hash_deinit (td_sha, &concat[16]);
 
           dconcat.size = 36;
         }
@@ -173,27 +173,27 @@ mhd_gtls_tls_sign_params (mhd_gtls_session_t session,
           memcpy (concat,
                   "\x30\x21\x30\x09\x06\x05\x2b\x0e\x03\x02\x1a\x05\x00\x04\x14",
                   15);
-          mhd_gnutls_hash_deinit (td_sha, &concat[15]);
+          MHD_gnutls_hash_deinit (td_sha, &concat[15]);
           dconcat.size = 35;
 #else
           /* No parameters field. */
           memcpy (concat,
                   "\x30\x1f\x30\x07\x06\x05\x2b\x0e\x03\x02\x1a\x04\x14", 13);
-          mhd_gnutls_hash_deinit (td_sha, &concat[13]);
+          MHD_gnutls_hash_deinit (td_sha, &concat[13]);
           dconcat.size = 33;
 #endif
         }
       dconcat.data = concat;
       break;
     default:
-      gnutls_assert ();
-      mhd_gnutls_hash_deinit (td_sha, NULL);
+      MHD_gnutls_assert ();
+      MHD_gnutls_hash_deinit (td_sha, NULL);
       return GNUTLS_E_INTERNAL_ERROR;
     }
-  ret = _gnutls_tls_sign (session, cert, pkey, &dconcat, signature);
+  ret = MHD__gnutls_tls_sign (session, cert, pkey, &dconcat, signature);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
     }
 
   return ret;
@@ -204,10 +204,10 @@ mhd_gtls_tls_sign_params (mhd_gtls_session_t session,
  * given data. The output will be allocated and be put in signature.
  */
 int
-mhd_gtls_sign (enum MHD_GNUTLS_PublicKeyAlgorithm algo,
+MHD_gtls_sign (enum MHD_GNUTLS_PublicKeyAlgorithm algo,
                mpi_t * params,
                int params_size,
-               const gnutls_datum_t * data, gnutls_datum_t * signature)
+               const MHD_gnutls_datum_t * data, MHD_gnutls_datum_t * signature)
 {
   int ret;
 
@@ -216,16 +216,16 @@ mhd_gtls_sign (enum MHD_GNUTLS_PublicKeyAlgorithm algo,
     case MHD_GNUTLS_PK_RSA:
       /* encrypt */
       if ((ret =
-           mhd_gtls_pkcs1_rsa_encrypt (signature, data, params, params_size,
+           MHD_gtls_pkcs1_rsa_encrypt (signature, data, params, params_size,
                                        1)) < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
       break;
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
       break;
     }
@@ -238,11 +238,11 @@ mhd_gtls_sign (enum MHD_GNUTLS_PublicKeyAlgorithm algo,
  * it supports signing.
  */
 static int
-_gnutls_tls_sign (mhd_gtls_session_t session,
-                  gnutls_cert * cert,
-                  gnutls_privkey * pkey,
-                  const gnutls_datum_t * hash_concat,
-                  gnutls_datum_t * signature)
+MHD__gnutls_tls_sign (MHD_gtls_session_t session,
+                  MHD_gnutls_cert * cert,
+                  MHD_gnutls_privkey * pkey,
+                  const MHD_gnutls_datum_t * hash_concat,
+                  MHD_gnutls_datum_t * signature)
 {
 
   /* If our certificate supports signing
@@ -252,7 +252,7 @@ _gnutls_tls_sign (mhd_gtls_session_t session,
     if (cert->key_usage != 0)
       if (!(cert->key_usage & KEY_DIGITAL_SIGNATURE))
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_KEY_USAGE_VIOLATION;
         }
 
@@ -269,23 +269,23 @@ _gnutls_tls_sign (mhd_gtls_session_t session,
                                               hash_concat, signature);
     }
 
-  return mhd_gtls_sign (pkey->pk_algorithm, pkey->params, pkey->params_size,
+  return MHD_gtls_sign (pkey->pk_algorithm, pkey->params, pkey->params_size,
                         hash_concat, signature);
 }
 
 static int
-_gnutls_verify_sig (gnutls_cert * cert,
-                    const gnutls_datum_t * hash_concat,
-                    gnutls_datum_t * signature, size_t sha1pos)
+MHD__gnutls_verify_sig (MHD_gnutls_cert * cert,
+                    const MHD_gnutls_datum_t * hash_concat,
+                    MHD_gnutls_datum_t * signature, size_t sha1pos)
 {
   int ret;
-  gnutls_datum_t vdata;
+  MHD_gnutls_datum_t vdata;
 
   if ( (cert == NULL) || (cert->version == 0) )
     {                           /* this is the only way to check
                                  * if it is initialized
                                  */
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_CERTIFICATE_ERROR;
     }
 
@@ -295,7 +295,7 @@ _gnutls_verify_sig (gnutls_cert * cert,
     if (cert->key_usage != 0)
       if (!(cert->key_usage & KEY_DIGITAL_SIGNATURE))
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_KEY_USAGE_VIOLATION;
         }
 
@@ -307,16 +307,16 @@ _gnutls_verify_sig (gnutls_cert * cert,
       vdata.size = hash_concat->size;
 
       /* verify signature */
-      if ((ret = mhd_gtls_rsa_verify (&vdata, signature, cert->params,
+      if ((ret = MHD_gtls_rsa_verify (&vdata, signature, cert->params,
                                       cert->params_size, 1)) < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
       break;
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
@@ -327,60 +327,60 @@ _gnutls_verify_sig (gnutls_cert * cert,
  * verify message).
  */
 int
-mhd_gtls_verify_sig_hdata (mhd_gtls_session_t session,
-                           gnutls_cert * cert, gnutls_datum_t * signature)
+MHD_gtls_verify_sig_hdata (MHD_gtls_session_t session,
+                           MHD_gnutls_cert * cert, MHD_gnutls_datum_t * signature)
 {
   int ret;
   opaque concat[36];
   mac_hd_t td_md5;
   mac_hd_t td_sha;
-  gnutls_datum_t dconcat;
-  enum MHD_GNUTLS_Protocol ver = MHD_gnutls_protocol_get_version (session);
+  MHD_gnutls_datum_t dconcat;
+  enum MHD_GNUTLS_Protocol ver = MHD__gnutls_protocol_get_version (session);
 
-  td_md5 = mhd_gnutls_hash_copy (session->internals.handshake_mac_handle_md5);
+  td_md5 = MHD_gnutls_hash_copy (session->internals.handshake_mac_handle_md5);
   if (td_md5 == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_HASH_FAILED;
     }
 
-  td_sha = mhd_gnutls_hash_copy (session->internals.handshake_mac_handle_sha);
+  td_sha = MHD_gnutls_hash_copy (session->internals.handshake_mac_handle_sha);
   if (td_sha == NULL)
     {
-      gnutls_assert ();
-      mhd_gnutls_hash_deinit (td_md5, NULL);
+      MHD_gnutls_assert ();
+      MHD_gnutls_hash_deinit (td_md5, NULL);
       return GNUTLS_E_HASH_FAILED;
     }
 
   if (ver == MHD_GNUTLS_PROTOCOL_SSL3)
     {
-      ret = mhd_gtls_generate_master (session, 1);
+      ret = MHD_gtls_generate_master (session, 1);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
-      mhd_gnutls_mac_deinit_ssl3_handshake (td_md5, concat,
+      MHD_gnutls_mac_deinit_ssl3_handshake (td_md5, concat,
                                             session->security_parameters.
                                             master_secret, TLS_MASTER_SIZE);
-      mhd_gnutls_mac_deinit_ssl3_handshake (td_sha, &concat[16],
+      MHD_gnutls_mac_deinit_ssl3_handshake (td_sha, &concat[16],
                                             session->security_parameters.
                                             master_secret, TLS_MASTER_SIZE);
     }
   else
     {
-      mhd_gnutls_hash_deinit (td_md5, concat);
-      mhd_gnutls_hash_deinit (td_sha, &concat[16]);
+      MHD_gnutls_hash_deinit (td_md5, concat);
+      MHD_gnutls_hash_deinit (td_sha, &concat[16]);
     }
 
   dconcat.data = concat;
   dconcat.size = 20 + 16;       /* md5+ sha */
 
-  ret = _gnutls_verify_sig (cert, &dconcat, signature, 16);
+  ret = MHD__gnutls_verify_sig (cert, &dconcat, signature, 16);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -392,53 +392,53 @@ mhd_gtls_verify_sig_hdata (mhd_gtls_session_t session,
  * Used in DHE_* ciphersuites.
  */
 int
-mhd_gtls_verify_sig_params (mhd_gtls_session_t session,
-                            gnutls_cert * cert,
-                            const gnutls_datum_t * params,
-                            gnutls_datum_t * signature)
+MHD_gtls_verify_sig_params (MHD_gtls_session_t session,
+                            MHD_gnutls_cert * cert,
+                            const MHD_gnutls_datum_t * params,
+                            MHD_gnutls_datum_t * signature)
 {
-  gnutls_datum_t dconcat;
+  MHD_gnutls_datum_t dconcat;
   int ret;
   mac_hd_t td_md5 = NULL;
   mac_hd_t td_sha;
   opaque concat[36];
-  enum MHD_GNUTLS_Protocol ver = MHD_gnutls_protocol_get_version (session);
+  enum MHD_GNUTLS_Protocol ver = MHD__gnutls_protocol_get_version (session);
 
   if (ver < MHD_GNUTLS_PROTOCOL_TLS1_2)
     {
-      td_md5 = mhd_gtls_hash_init (MHD_GNUTLS_MAC_MD5);
+      td_md5 = MHD_gtls_hash_init (MHD_GNUTLS_MAC_MD5);
       if (td_md5 == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_HASH_FAILED;
         }
 
-      mhd_gnutls_hash (td_md5, session->security_parameters.client_random,
+      MHD_gnutls_hash (td_md5, session->security_parameters.client_random,
                        TLS_RANDOM_SIZE);
-      mhd_gnutls_hash (td_md5, session->security_parameters.server_random,
+      MHD_gnutls_hash (td_md5, session->security_parameters.server_random,
                        TLS_RANDOM_SIZE);
-      mhd_gnutls_hash (td_md5, params->data, params->size);
+      MHD_gnutls_hash (td_md5, params->data, params->size);
     }
 
-  td_sha = mhd_gtls_hash_init (MHD_GNUTLS_MAC_SHA1);
+  td_sha = MHD_gtls_hash_init (MHD_GNUTLS_MAC_SHA1);
   if (td_sha == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       if (td_md5)
-        mhd_gnutls_hash_deinit (td_md5, NULL);
+        MHD_gnutls_hash_deinit (td_md5, NULL);
       return GNUTLS_E_HASH_FAILED;
     }
 
-  mhd_gnutls_hash (td_sha, session->security_parameters.client_random,
+  MHD_gnutls_hash (td_sha, session->security_parameters.client_random,
                    TLS_RANDOM_SIZE);
-  mhd_gnutls_hash (td_sha, session->security_parameters.server_random,
+  MHD_gnutls_hash (td_sha, session->security_parameters.server_random,
                    TLS_RANDOM_SIZE);
-  mhd_gnutls_hash (td_sha, params->data, params->size);
+  MHD_gnutls_hash (td_sha, params->data, params->size);
 
   if (ver < MHD_GNUTLS_PROTOCOL_TLS1_2)
     {
-      mhd_gnutls_hash_deinit (td_md5, concat);
-      mhd_gnutls_hash_deinit (td_sha, &concat[16]);
+      MHD_gnutls_hash_deinit (td_md5, concat);
+      MHD_gnutls_hash_deinit (td_sha, &concat[16]);
       dconcat.size = 36;
     }
   else
@@ -448,23 +448,23 @@ mhd_gtls_verify_sig_params (mhd_gtls_session_t session,
       memcpy (concat,
               "\x30\x21\x30\x09\x06\x05\x2b\x0e\x03\x02\x1a\x05\x00\x04\x14",
               15);
-      mhd_gnutls_hash_deinit (td_sha, &concat[15]);
+      MHD_gnutls_hash_deinit (td_sha, &concat[15]);
       dconcat.size = 35;
 #else
       /* No parameters field. */
       memcpy (concat,
               "\x30\x1f\x30\x07\x06\x05\x2b\x0e\x03\x02\x1a\x04\x14", 13);
-      mhd_gnutls_hash_deinit (td_sha, &concat[13]);
+      MHD_gnutls_hash_deinit (td_sha, &concat[13]);
       dconcat.size = 33;
 #endif
     }
 
   dconcat.data = concat;
 
-  ret = _gnutls_verify_sig (cert, &dconcat, signature, dconcat.size - 20);
+  ret = MHD__gnutls_verify_sig (cert, &dconcat, signature, dconcat.size - 20);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
diff --git a/src/daemon/https/tls/gnutls_sig.h b/src/daemon/https/tls/gnutls_sig.h
index eaef5226..6259191d 100644
--- a/src/daemon/https/tls/gnutls_sig.h
+++ b/src/daemon/https/tls/gnutls_sig.h
@@ -25,28 +25,28 @@
 #ifndef GNUTLS_SIG_H
 # define GNUTLS_SIG_H
 
-int mhd_gtls_tls_sign_hdata (mhd_gtls_session_t session,
-                             gnutls_cert * cert,
-                             gnutls_privkey * pkey,
-                             gnutls_datum_t * signature);
+int MHD_gtls_tls_sign_hdata (MHD_gtls_session_t session,
+                             MHD_gnutls_cert * cert,
+                             MHD_gnutls_privkey * pkey,
+                             MHD_gnutls_datum_t * signature);
 
-int mhd_gtls_tls_sign_params (mhd_gtls_session_t session,
-                              gnutls_cert * cert,
-                              gnutls_privkey * pkey,
-                              gnutls_datum_t * params,
-                              gnutls_datum_t * signature);
+int MHD_gtls_tls_sign_params (MHD_gtls_session_t session,
+                              MHD_gnutls_cert * cert,
+                              MHD_gnutls_privkey * pkey,
+                              MHD_gnutls_datum_t * params,
+                              MHD_gnutls_datum_t * signature);
 
-int mhd_gtls_verify_sig_hdata (mhd_gtls_session_t session,
-                               gnutls_cert * cert,
-                               gnutls_datum_t * signature);
+int MHD_gtls_verify_sig_hdata (MHD_gtls_session_t session,
+                               MHD_gnutls_cert * cert,
+                               MHD_gnutls_datum_t * signature);
 
-int mhd_gtls_verify_sig_params (mhd_gtls_session_t session,
-                                gnutls_cert * cert,
-                                const gnutls_datum_t * params,
-                                gnutls_datum_t * signature);
+int MHD_gtls_verify_sig_params (MHD_gtls_session_t session,
+                                MHD_gnutls_cert * cert,
+                                const MHD_gnutls_datum_t * params,
+                                MHD_gnutls_datum_t * signature);
 
-int mhd_gtls_sign (enum MHD_GNUTLS_PublicKeyAlgorithm algo,
+int MHD_gtls_sign (enum MHD_GNUTLS_PublicKeyAlgorithm algo,
                    mpi_t * params, int params_size,
-                   const gnutls_datum_t * data, gnutls_datum_t * signature);
+                   const MHD_gnutls_datum_t * data, MHD_gnutls_datum_t * signature);
 
 #endif
diff --git a/src/daemon/https/tls/gnutls_state.c b/src/daemon/https/tls/gnutls_state.c
index ae793ee0..49802b2e 100644
--- a/src/daemon/https/tls/gnutls_state.c
+++ b/src/daemon/https/tls/gnutls_state.c
@@ -22,8 +22,8 @@
  *
  */
 
-/* Functions to manipulate the session (gnutls_int.h), and some other stuff
- * are included here. The file's name is traditionally gnutls_state even if the
+/* Functions to manipulate the session (MHD_gnutls_int.h), and some other stuff
+ * are included here. The file's name is traditionally MHD_gnutls_state even if the
  * state has been renamed to session.
  */
 
@@ -43,27 +43,27 @@
 #include <gnutls_rsa_export.h>
 
 void
-_gnutls_session_cert_type_set (mhd_gtls_session_t session,
+MHD__gnutls_session_cert_type_set (MHD_gtls_session_t session,
                                enum MHD_GNUTLS_CertificateType ct)
 {
   session->security_parameters.cert_type = ct;
 }
 
 /**
- * gnutls_cipher_get - Returns the currently used cipher.
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD_gnutls_cipher_get - Returns the currently used cipher.
+ * @session: is a #MHD_gtls_session_t structure.
  *
  * Returns: the currently used cipher.
  **/
 enum MHD_GNUTLS_CipherAlgorithm
-gnutls_cipher_get (mhd_gtls_session_t session)
+MHD_gnutls_cipher_get (MHD_gtls_session_t session)
 {
   return session->security_parameters.read_bulk_cipher_algorithm;
 }
 
 /**
- * gnutls_certificate_type_get - Returns the currently used certificate type.
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD_gnutls_certificate_type_get - Returns the currently used certificate type.
+ * @session: is a #MHD_gtls_session_t structure.
  *
  * The certificate type is by default X.509, unless it is negotiated
  * as a TLS extension.
@@ -72,43 +72,43 @@ gnutls_cipher_get (mhd_gtls_session_t session)
  *   type.
  **/
 enum MHD_GNUTLS_CertificateType
-gnutls_certificate_type_get (mhd_gtls_session_t session)
+MHD_gnutls_certificate_type_get (MHD_gtls_session_t session)
 {
   return session->security_parameters.cert_type;
 }
 
 /**
- * gnutls_kx_get - Returns the key exchange algorithm.
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD_gnutls_kx_get - Returns the key exchange algorithm.
+ * @session: is a #MHD_gtls_session_t structure.
  *
  * Returns: the key exchange algorithm used in the last handshake.
  **/
 enum MHD_GNUTLS_KeyExchangeAlgorithm
-gnutls_kx_get (mhd_gtls_session_t session)
+MHD_gnutls_kx_get (MHD_gtls_session_t session)
 {
   return session->security_parameters.kx_algorithm;
 }
 
 /**
- * gnutls_mac_get - Returns the currently used mac algorithm.
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD_gnutls_mac_get - Returns the currently used mac algorithm.
+ * @session: is a #MHD_gtls_session_t structure.
  *
  * Returns: the currently used mac algorithm.
  **/
 enum MHD_GNUTLS_HashAlgorithm
-gnutls_mac_get (mhd_gtls_session_t session)
+MHD_gnutls_mac_get (MHD_gtls_session_t session)
 {
   return session->security_parameters.read_mac_algorithm;
 }
 
 /**
- * gnutls_compression_get - Returns the currently used compression algorithm.
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD_gnutls_compression_get - Returns the currently used compression algorithm.
+ * @session: is a #MHD_gtls_session_t structure.
  *
  * Returns: the currently used compression method.
  **/
 enum MHD_GNUTLS_CompressionMethod
-MHD_gtls_compression_get (mhd_gtls_session_t session)
+MHD_gtls_compression_get (MHD_gtls_session_t session)
 {
   return session->security_parameters.read_compression_algorithm;
 }
@@ -118,18 +118,18 @@ MHD_gtls_compression_get (mhd_gtls_session_t session)
  * and a matching certificate exists.
  */
 int
-mhd_gtls_session_cert_type_supported (mhd_gtls_session_t session,
+MHD_gtls_session_cert_type_supported (MHD_gtls_session_t session,
                                       enum MHD_GNUTLS_CertificateType
                                       cert_type)
 {
   unsigned i;
   unsigned cert_found = 0;
-  mhd_gtls_cert_credentials_t cred;
+  MHD_gtls_cert_credentials_t cred;
 
   if (session->security_parameters.entity == GNUTLS_SERVER)
     {
       cred
-        = (mhd_gtls_cert_credentials_t) mhd_gtls_get_cred (session->key,
+        = (MHD_gtls_cert_credentials_t) MHD_gtls_get_cred (session->key,
                                                            MHD_GNUTLS_CRD_CERTIFICATE,
                                                            NULL);
 
@@ -173,13 +173,13 @@ mhd_gtls_session_cert_type_supported (mhd_gtls_session_t session,
  * in a session struct.
  */
 inline static void
-deinit_internal_params (mhd_gtls_session_t session)
+deinit_internal_params (MHD_gtls_session_t session)
 {
   if (session->internals.params.free_dh_params)
-    MHD_gnutls_dh_params_deinit (session->internals.params.dh_params);
+    MHD__gnutls_dh_params_deinit (session->internals.params.dh_params);
 
   if (session->internals.params.free_rsa_params)
-    MHD_gnutls_rsa_params_deinit (session->internals.params.rsa_params);
+    MHD__gnutls_rsa_params_deinit (session->internals.params.rsa_params);
 
   memset (&session->internals.params, 0, sizeof (session->internals.params));
 }
@@ -189,7 +189,7 @@ deinit_internal_params (mhd_gtls_session_t session)
  * This is used to allow further handshakes.
  */
 void
-mhd_gtls_handshake_internal_state_clear (mhd_gtls_session_t session)
+MHD_gtls_handshake_internal_state_clear (MHD_gtls_session_t session)
 {
   session->internals.extensions_sent_size = 0;
 
@@ -199,7 +199,7 @@ mhd_gtls_handshake_internal_state_clear (mhd_gtls_session_t session)
   session->internals.adv_version_minor = 0;
   session->internals.v2_hello = 0;
   memset (&session->internals.handshake_header_buffer, 0,
-          sizeof (mhd_gtls_handshake_header_buffer_st));
+          sizeof (MHD_gtls_handshake_header_buffer_st));
   session->internals.adv_version_minor = 0;
   session->internals.adv_version_minor = 0;
   session->internals.direction = 0;
@@ -211,7 +211,7 @@ mhd_gtls_handshake_internal_state_clear (mhd_gtls_session_t session)
   session->internals.last_handshake_out = -1;
 
   session->internals.resumable = RESUME_TRUE;
-  _gnutls_free_datum (&session->internals.recv_buffer);
+  MHD__gnutls_free_datum (&session->internals.recv_buffer);
 
   deinit_internal_params (session);
 
@@ -219,14 +219,14 @@ mhd_gtls_handshake_internal_state_clear (mhd_gtls_session_t session)
 
 #define MIN_DH_BITS 727
 /**
- * MHD_gnutls_init - This function initializes the session to null (null encryption etc...).
+ * MHD__gnutls_init - This function initializes the session to null (null encryption etc...).
  * @con_end: indicate if this session is to be used for server or client.
- * @session: is a pointer to a #mhd_gtls_session_t structure.
+ * @session: is a pointer to a #MHD_gtls_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 MHD_gnutls_deinit().  Returns zero on success.
+ * be free'd by calling MHD__gnutls_deinit().  Returns zero on success.
  *
  * @con_end can be one of %GNUTLS_CLIENT and %GNUTLS_SERVER.
  *
@@ -235,10 +235,10 @@ mhd_gtls_handshake_internal_state_clear (mhd_gtls_session_t session)
 
 /* TODO rm redundent pointer ref */
 int
-MHD_gnutls_init (mhd_gtls_session_t * session,
-                 gnutls_connection_end_t con_end)
+MHD__gnutls_init (MHD_gtls_session_t * session,
+                 MHD_gnutls_connection_end_t con_end)
 {
-  *session = gnutls_calloc (1, sizeof (struct MHD_gtls_session_int));
+  *session = MHD_gnutls_calloc (1, sizeof (struct MHD_gtls_session_int));
   if (*session == NULL)
     return GNUTLS_E_MEMORY_ERROR;
 
@@ -263,32 +263,32 @@ MHD_gnutls_init (mhd_gtls_session_t * session,
   (*session)->internals.enable_private = 0;
 
   /* Initialize buffers */
-  mhd_gtls_buffer_init (&(*session)->internals.application_data_buffer);
-  mhd_gtls_buffer_init (&(*session)->internals.handshake_data_buffer);
-  mhd_gtls_buffer_init (&(*session)->internals.handshake_hash_buffer);
-  mhd_gtls_buffer_init (&(*session)->internals.ia_data_buffer);
+  MHD_gtls_buffer_init (&(*session)->internals.application_data_buffer);
+  MHD_gtls_buffer_init (&(*session)->internals.handshake_data_buffer);
+  MHD_gtls_buffer_init (&(*session)->internals.handshake_hash_buffer);
+  MHD_gtls_buffer_init (&(*session)->internals.ia_data_buffer);
 
-  mhd_gtls_buffer_init (&(*session)->internals.record_send_buffer);
-  mhd_gtls_buffer_init (&(*session)->internals.record_recv_buffer);
+  MHD_gtls_buffer_init (&(*session)->internals.record_send_buffer);
+  MHD_gtls_buffer_init (&(*session)->internals.record_recv_buffer);
 
-  mhd_gtls_buffer_init (&(*session)->internals.handshake_send_buffer);
-  mhd_gtls_buffer_init (&(*session)->internals.handshake_recv_buffer);
+  MHD_gtls_buffer_init (&(*session)->internals.handshake_send_buffer);
+  MHD_gtls_buffer_init (&(*session)->internals.handshake_recv_buffer);
 
-  (*session)->key = gnutls_calloc (1, sizeof (struct mhd_gtls_key));
+  (*session)->key = MHD_gnutls_calloc (1, sizeof (struct MHD_gtls_key));
   if ((*session)->key == NULL)
     {
-    cleanup_session:gnutls_free (*session);
+    cleanup_session:MHD_gnutls_free (*session);
       *session = NULL;
       return GNUTLS_E_MEMORY_ERROR;
     }
 
   (*session)->internals.expire_time = DEFAULT_EXPIRE_TIME;      /* one hour default */
 
-  MHD_gnutls_dh_set_prime_bits ((*session), MIN_DH_BITS);
+  MHD__gnutls_dh_set_prime_bits ((*session), MIN_DH_BITS);
 
-  MHD_gnutls_transport_set_lowat ((*session), DEFAULT_LOWAT);   /* the default for tcp */
+  MHD__gnutls_transport_set_lowat ((*session), DEFAULT_LOWAT);   /* the default for tcp */
 
-  MHD_gnutls_handshake_set_max_packet_length ((*session),
+  MHD__gnutls_handshake_set_max_packet_length ((*session),
                                               MAX_HANDSHAKE_PACKET_SIZE);
 
   /* Allocate a minimum size for recv_data
@@ -296,16 +296,16 @@ MHD_gnutls_init (mhd_gtls_session_t * session,
    * the receive procedure slow.
    */
   (*session)->internals.record_recv_buffer.data
-    = gnutls_malloc (INITIAL_RECV_BUFFER_SIZE);
+    = MHD_gnutls_malloc (INITIAL_RECV_BUFFER_SIZE);
   if ((*session)->internals.record_recv_buffer.data == NULL)
     {
-      gnutls_free ((*session)->key);
+      MHD_gnutls_free ((*session)->key);
       goto cleanup_session;
     }
 
   /* set the socket pointers to -1; */
-  (*session)->internals.transport_recv_ptr = (gnutls_transport_ptr_t) - 1;
-  (*session)->internals.transport_send_ptr = (gnutls_transport_ptr_t) - 1;
+  (*session)->internals.transport_recv_ptr = (MHD_gnutls_transport_ptr_t) - 1;
+  (*session)->internals.transport_send_ptr = (MHD_gnutls_transport_ptr_t) - 1;
 
   /* set the default maximum record size for TLS
    */
@@ -318,7 +318,7 @@ MHD_gnutls_init (mhd_gtls_session_t * session,
    * as NULL or 0. This is why calloc is used.
    */
 
-  mhd_gtls_handshake_internal_state_clear (*session);
+  MHD_gtls_handshake_internal_state_clear (*session);
 
   return 0;
 }
@@ -326,113 +326,113 @@ MHD_gnutls_init (mhd_gtls_session_t * session,
 /* returns RESUME_FALSE or RESUME_TRUE.
  */
 int
-mhd_gtls_session_is_resumable (mhd_gtls_session_t session)
+MHD_gtls_session_is_resumable (MHD_gtls_session_t session)
 {
   return session->internals.resumable;
 }
 
 /**
- * MHD_gnutls_deinit - This function clears all buffers associated with a session
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD__gnutls_deinit - This function clears all buffers associated with a session
+ * @session: is a #MHD_gtls_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
-MHD_gnutls_deinit (mhd_gtls_session_t session)
+MHD__gnutls_deinit (MHD_gtls_session_t session)
 {
 
   if (session == NULL)
     return;
 
   /* remove auth info firstly */
-  mhd_gtls_free_auth_info (session);
+  MHD_gtls_free_auth_info (session);
 
-  mhd_gtls_handshake_internal_state_clear (session);
-  _gnutls_handshake_io_buffer_clear (session);
+  MHD_gtls_handshake_internal_state_clear (session);
+  MHD__gnutls_handshake_io_buffer_clear (session);
 
-  _gnutls_free_datum (&session->connection_state.read_mac_secret);
-  _gnutls_free_datum (&session->connection_state.write_mac_secret);
+  MHD__gnutls_free_datum (&session->connection_state.read_mac_secret);
+  MHD__gnutls_free_datum (&session->connection_state.write_mac_secret);
 
-  mhd_gtls_buffer_clear (&session->internals.ia_data_buffer);
-  mhd_gtls_buffer_clear (&session->internals.handshake_hash_buffer);
-  mhd_gtls_buffer_clear (&session->internals.handshake_data_buffer);
-  mhd_gtls_buffer_clear (&session->internals.application_data_buffer);
-  mhd_gtls_buffer_clear (&session->internals.record_recv_buffer);
-  mhd_gtls_buffer_clear (&session->internals.record_send_buffer);
+  MHD_gtls_buffer_clear (&session->internals.ia_data_buffer);
+  MHD_gtls_buffer_clear (&session->internals.handshake_hash_buffer);
+  MHD_gtls_buffer_clear (&session->internals.handshake_data_buffer);
+  MHD_gtls_buffer_clear (&session->internals.application_data_buffer);
+  MHD_gtls_buffer_clear (&session->internals.record_recv_buffer);
+  MHD_gtls_buffer_clear (&session->internals.record_send_buffer);
 
-  MHD_gnutls_credentials_clear (session);
-  mhd_gtls_selected_certs_deinit (session);
+  MHD__gnutls_credentials_clear (session);
+  MHD_gtls_selected_certs_deinit (session);
 
   if (session->connection_state.read_cipher_state != NULL)
-    mhd_gnutls_cipher_deinit (session->connection_state.read_cipher_state);
+    MHD_gnutls_cipher_deinit (session->connection_state.read_cipher_state);
   if (session->connection_state.write_cipher_state != NULL)
-    mhd_gnutls_cipher_deinit (session->connection_state.write_cipher_state);
+    MHD_gnutls_cipher_deinit (session->connection_state.write_cipher_state);
 
   if (session->connection_state.read_compression_state != NULL)
-    mhd_gtls_comp_deinit (session->connection_state.read_compression_state,
+    MHD_gtls_comp_deinit (session->connection_state.read_compression_state,
                           1);
   if (session->connection_state.write_compression_state != NULL)
-    mhd_gtls_comp_deinit (session->connection_state.write_compression_state,
+    MHD_gtls_comp_deinit (session->connection_state.write_compression_state,
                           0);
 
-  _gnutls_free_datum (&session->cipher_specs.server_write_mac_secret);
-  _gnutls_free_datum (&session->cipher_specs.client_write_mac_secret);
-  _gnutls_free_datum (&session->cipher_specs.server_write_IV);
-  _gnutls_free_datum (&session->cipher_specs.client_write_IV);
-  _gnutls_free_datum (&session->cipher_specs.server_write_key);
-  _gnutls_free_datum (&session->cipher_specs.client_write_key);
+  MHD__gnutls_free_datum (&session->cipher_specs.server_write_mac_secret);
+  MHD__gnutls_free_datum (&session->cipher_specs.client_write_mac_secret);
+  MHD__gnutls_free_datum (&session->cipher_specs.server_write_IV);
+  MHD__gnutls_free_datum (&session->cipher_specs.client_write_IV);
+  MHD__gnutls_free_datum (&session->cipher_specs.server_write_key);
+  MHD__gnutls_free_datum (&session->cipher_specs.client_write_key);
 
   if (session->key != NULL)
     {
-      mhd_gtls_mpi_release (&session->key->KEY);
-      mhd_gtls_mpi_release (&session->key->client_Y);
-      mhd_gtls_mpi_release (&session->key->client_p);
-      mhd_gtls_mpi_release (&session->key->client_g);
-
-      mhd_gtls_mpi_release (&session->key->u);
-      mhd_gtls_mpi_release (&session->key->a);
-      mhd_gtls_mpi_release (&session->key->x);
-      mhd_gtls_mpi_release (&session->key->A);
-      mhd_gtls_mpi_release (&session->key->B);
-      mhd_gtls_mpi_release (&session->key->b);
+      MHD_gtls_mpi_release (&session->key->KEY);
+      MHD_gtls_mpi_release (&session->key->client_Y);
+      MHD_gtls_mpi_release (&session->key->client_p);
+      MHD_gtls_mpi_release (&session->key->client_g);
+
+      MHD_gtls_mpi_release (&session->key->u);
+      MHD_gtls_mpi_release (&session->key->a);
+      MHD_gtls_mpi_release (&session->key->x);
+      MHD_gtls_mpi_release (&session->key->A);
+      MHD_gtls_mpi_release (&session->key->B);
+      MHD_gtls_mpi_release (&session->key->b);
 
       /* RSA */
-      mhd_gtls_mpi_release (&session->key->rsa[0]);
-      mhd_gtls_mpi_release (&session->key->rsa[1]);
+      MHD_gtls_mpi_release (&session->key->rsa[0]);
+      MHD_gtls_mpi_release (&session->key->rsa[1]);
 
-      mhd_gtls_mpi_release (&session->key->dh_secret);
-      gnutls_free (session->key);
+      MHD_gtls_mpi_release (&session->key->dh_secret);
+      MHD_gnutls_free (session->key);
 
       session->key = NULL;
     }
 
-  gnutls_free (session->internals.srp_username);
+  MHD_gnutls_free (session->internals.srp_username);
 
   if (session->internals.srp_password)
     {
       memset (session->internals.srp_password, 0,
               strlen (session->internals.srp_password));
-      gnutls_free (session->internals.srp_password);
+      MHD_gnutls_free (session->internals.srp_password);
     }
 
   memset (session, 0, sizeof (struct MHD_gtls_session_int));
-  gnutls_free (session);
+  MHD_gnutls_free (session);
 }
 
 /* Returns the minimum prime bits that are acceptable.
  */
 int
-mhd_gtls_dh_get_allowed_prime_bits (mhd_gtls_session_t session)
+MHD_gtls_dh_get_allowed_prime_bits (MHD_gtls_session_t session)
 {
   return session->internals.dh_prime_bits;
 }
 
 int
-mhd_gtls_dh_set_peer_public (mhd_gtls_session_t session, mpi_t public)
+MHD_gtls_dh_set_peer_public (MHD_gtls_session_t session, mpi_t public)
 {
-  mhd_gtls_dh_info_st *dh;
+  MHD_gtls_dh_info_st *dh;
   int ret;
 
   switch (MHD_gtls_auth_get_type (session))
@@ -440,7 +440,7 @@ mhd_gtls_dh_set_peer_public (mhd_gtls_session_t session, mpi_t public)
     case MHD_GNUTLS_CRD_ANON:
       {
         mhd_anon_auth_info_t info;
-        info = mhd_gtls_get_auth_info (session);
+        info = MHD_gtls_get_auth_info (session);
         if (info == NULL)
           return GNUTLS_E_INTERNAL_ERROR;
 
@@ -451,7 +451,7 @@ mhd_gtls_dh_set_peer_public (mhd_gtls_session_t session, mpi_t public)
       {
         cert_auth_info_t info;
 
-        info = mhd_gtls_get_auth_info (session);
+        info = MHD_gtls_get_auth_info (session);
         if (info == NULL)
           return GNUTLS_E_INTERNAL_ERROR;
 
@@ -459,14 +459,14 @@ mhd_gtls_dh_set_peer_public (mhd_gtls_session_t session, mpi_t public)
         break;
       }
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
-  ret = mhd_gtls_mpi_dprint_lz (&dh->public_key, public);
+  ret = MHD_gtls_mpi_dprint_lz (&dh->public_key, public);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -474,14 +474,14 @@ mhd_gtls_dh_set_peer_public (mhd_gtls_session_t session, mpi_t public)
 }
 
 int
-mhd_gtls_dh_set_secret_bits (mhd_gtls_session_t session, unsigned bits)
+MHD_gtls_dh_set_secret_bits (MHD_gtls_session_t session, unsigned bits)
 {
   switch (MHD_gtls_auth_get_type (session))
     {
     case MHD_GNUTLS_CRD_ANON:
       {
         mhd_anon_auth_info_t info;
-        info = mhd_gtls_get_auth_info (session);
+        info = MHD_gtls_get_auth_info (session);
         if (info == NULL)
           return GNUTLS_E_INTERNAL_ERROR;
         info->dh.secret_bits = bits;
@@ -491,14 +491,14 @@ mhd_gtls_dh_set_secret_bits (mhd_gtls_session_t session, unsigned bits)
       {
         cert_auth_info_t info;
 
-        info = mhd_gtls_get_auth_info (session);
+        info = MHD_gtls_get_auth_info (session);
         if (info == NULL)
           return GNUTLS_E_INTERNAL_ERROR;
 
         info->dh.secret_bits = bits;
         break;
     default:
-        gnutls_assert ();
+        MHD_gnutls_assert ();
         return GNUTLS_E_INTERNAL_ERROR;
       }
     }
@@ -510,28 +510,28 @@ mhd_gtls_dh_set_secret_bits (mhd_gtls_session_t session, unsigned bits)
  * RSA exponent and the modulus.
  */
 int
-mhd_gtls_rsa_export_set_pubkey (mhd_gtls_session_t session,
+MHD_gtls_rsa_export_set_pubkey (MHD_gtls_session_t session,
                                 mpi_t exponent, mpi_t modulus)
 {
   cert_auth_info_t info;
   int ret;
 
-  info = mhd_gtls_get_auth_info (session);
+  info = MHD_gtls_get_auth_info (session);
   if (info == NULL)
     return GNUTLS_E_INTERNAL_ERROR;
 
-  ret = mhd_gtls_mpi_dprint_lz (&info->rsa_export.modulus, modulus);
+  ret = MHD_gtls_mpi_dprint_lz (&info->rsa_export.modulus, modulus);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  ret = mhd_gtls_mpi_dprint_lz (&info->rsa_export.exponent, exponent);
+  ret = MHD_gtls_mpi_dprint_lz (&info->rsa_export.exponent, exponent);
   if (ret < 0)
     {
-      gnutls_assert ();
-      _gnutls_free_datum (&info->rsa_export.modulus);
+      MHD_gnutls_assert ();
+      MHD__gnutls_free_datum (&info->rsa_export.modulus);
       return ret;
     }
 
@@ -541,9 +541,9 @@ mhd_gtls_rsa_export_set_pubkey (mhd_gtls_session_t session,
 /* Sets the prime and the generator in the auth info structure.
  */
 int
-mhd_gtls_dh_set_group (mhd_gtls_session_t session, mpi_t gen, mpi_t prime)
+MHD_gtls_dh_set_group (MHD_gtls_session_t session, mpi_t gen, mpi_t prime)
 {
-  mhd_gtls_dh_info_st *dh;
+  MHD_gtls_dh_info_st *dh;
   int ret;
 
   switch (MHD_gtls_auth_get_type (session))
@@ -551,7 +551,7 @@ mhd_gtls_dh_set_group (mhd_gtls_session_t session, mpi_t gen, mpi_t prime)
     case MHD_GNUTLS_CRD_ANON:
       {
         mhd_anon_auth_info_t info;
-        info = mhd_gtls_get_auth_info (session);
+        info = MHD_gtls_get_auth_info (session);
         if (info == NULL)
           return GNUTLS_E_INTERNAL_ERROR;
 
@@ -562,7 +562,7 @@ mhd_gtls_dh_set_group (mhd_gtls_session_t session, mpi_t gen, mpi_t prime)
       {
         cert_auth_info_t info;
 
-        info = mhd_gtls_get_auth_info (session);
+        info = MHD_gtls_get_auth_info (session);
         if (info == NULL)
           return GNUTLS_E_INTERNAL_ERROR;
 
@@ -570,26 +570,26 @@ mhd_gtls_dh_set_group (mhd_gtls_session_t session, mpi_t gen, mpi_t prime)
         break;
       }
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
   /* prime
    */
-  ret = mhd_gtls_mpi_dprint_lz (&dh->prime, prime);
+  ret = MHD_gtls_mpi_dprint_lz (&dh->prime, prime);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
   /* generator
    */
-  ret = mhd_gtls_mpi_dprint_lz (&dh->generator, gen);
+  ret = MHD_gtls_mpi_dprint_lz (&dh->generator, gen);
   if (ret < 0)
     {
-      gnutls_assert ();
-      _gnutls_free_datum (&dh->prime);
+      MHD_gnutls_assert ();
+      MHD__gnutls_free_datum (&dh->prime);
       return ret;
     }
 
@@ -597,8 +597,8 @@ mhd_gtls_dh_set_group (mhd_gtls_session_t session, mpi_t gen, mpi_t prime)
 }
 
 /**
- * MHD_gnutls_certificate_send_x509_rdn_sequence - This function will order gnutls to send or not the x.509 rdn sequence
- * @session: is a pointer to a #mhd_gtls_session_t structure.
+ * MHD__gnutls_certificate_send_x509_rdn_sequence - This function will order gnutls to send or not the x.509 rdn sequence
+ * @session: is a pointer to a #MHD_gtls_session_t structure.
  * @status: is 0 or 1
  *
  * If status is non zero, this function will order gnutls not to send
@@ -611,15 +611,15 @@ mhd_gtls_dh_set_group (mhd_gtls_session_t session, mpi_t gen, mpi_t prime)
  * methods other than certificate with X.509 certificates.
  **/
 void
-MHD_gnutls_certificate_send_x509_rdn_sequence (mhd_gtls_session_t session,
+MHD__gnutls_certificate_send_x509_rdn_sequence (MHD_gtls_session_t session,
                                                int status)
 {
   session->internals.ignore_rdn_sequence = status;
 }
 
 /*-
- * _gnutls_record_set_default_version - Used to set the default version for the first record packet
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD__gnutls_record_set_default_version - Used to set the default version for the first record packet
+ * @session: is a #MHD_gtls_session_t structure.
  * @major: is a tls major version
  * @minor: is a tls minor version
  *
@@ -629,7 +629,7 @@ MHD_gnutls_certificate_send_x509_rdn_sequence (mhd_gtls_session_t session,
  *
  -*/
 void
-_gnutls_record_set_default_version (mhd_gtls_session_t session,
+MHD__gnutls_record_set_default_version (MHD_gtls_session_t session,
                                     unsigned char major, unsigned char minor)
 {
   session->internals.default_record_version[0] = major;
@@ -638,7 +638,7 @@ _gnutls_record_set_default_version (mhd_gtls_session_t session,
 
 /**
  * MHD_gtls_handshake_set_private_extensions - Used to enable the private cipher suites
- * @session: is a #mhd_gtls_session_t structure.
+ * @session: is a #MHD_gtls_session_t structure.
  * @allow: is an integer (0 or 1)
  *
  * This function will enable or disable the use of private cipher
@@ -653,29 +653,29 @@ _gnutls_record_set_default_version (mhd_gtls_session_t session,
  * gnutls servers and clients may cause interoperability problems.
  **/
 void
-MHD_gtls_handshake_set_private_extensions (mhd_gtls_session_t session,
+MHD_gtls_handshake_set_private_extensions (MHD_gtls_session_t session,
                                            int allow)
 {
   session->internals.enable_private = allow;
 }
 
 inline static int
-_gnutls_cal_PRF_A (enum MHD_GNUTLS_HashAlgorithm algorithm,
+MHD__gnutls_cal_PRF_A (enum MHD_GNUTLS_HashAlgorithm algorithm,
                    const void *secret,
                    int secret_size,
                    const void *seed, int seed_size, void *result)
 {
   mac_hd_t td1;
 
-  td1 = mhd_gtls_hmac_init (algorithm, secret, secret_size);
+  td1 = MHD_gtls_MHD_hmac_init (algorithm, secret, secret_size);
   if (td1 == GNUTLS_MAC_FAILED)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
-  mhd_gnutls_hash (td1, seed, seed_size);
-  mhd_gnutls_hmac_deinit (td1, result);
+  MHD_gnutls_hash (td1, seed, seed_size);
+  MHD_gnutls_MHD_hmac_deinit (td1, result);
 
   return 0;
 }
@@ -686,7 +686,7 @@ _gnutls_cal_PRF_A (enum MHD_GNUTLS_HashAlgorithm algorithm,
  * (used in the PRF function)
  */
 static int
-_gnutls_P_hash (enum MHD_GNUTLS_HashAlgorithm algorithm,
+MHD__gnutls_P_hash (enum MHD_GNUTLS_HashAlgorithm algorithm,
                 const opaque * secret,
                 int secret_size,
                 const opaque * seed,
@@ -700,11 +700,11 @@ _gnutls_P_hash (enum MHD_GNUTLS_HashAlgorithm algorithm,
 
   if (seed_size > MAX_SEED_SIZE || total_bytes <= 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
-  blocksize = mhd_gnutls_hash_get_algo_len (algorithm);
+  blocksize = MHD_gnutls_hash_get_algo_len (algorithm);
 
   output_bytes = 0;
   do
@@ -722,27 +722,27 @@ _gnutls_P_hash (enum MHD_GNUTLS_HashAlgorithm algorithm,
 
   for (i = 0; i < times; i++)
     {
-      td2 = mhd_gtls_hmac_init (algorithm, secret, secret_size);
+      td2 = MHD_gtls_MHD_hmac_init (algorithm, secret, secret_size);
       if (td2 == GNUTLS_MAC_FAILED)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_INTERNAL_ERROR;
         }
 
       /* here we calculate A(i+1) */
-      if ((result = _gnutls_cal_PRF_A (algorithm, secret, secret_size, Atmp,
+      if ((result = MHD__gnutls_cal_PRF_A (algorithm, secret, secret_size, Atmp,
                                        A_size, Atmp)) < 0)
         {
-          gnutls_assert ();
-          mhd_gnutls_hmac_deinit (td2, final);
+          MHD_gnutls_assert ();
+          MHD_gnutls_MHD_hmac_deinit (td2, final);
           return result;
         }
 
       A_size = blocksize;
 
-      mhd_gnutls_hash (td2, Atmp, A_size);
-      mhd_gnutls_hash (td2, seed, seed_size);
-      mhd_gnutls_hmac_deinit (td2, final);
+      MHD_gnutls_hash (td2, Atmp, A_size);
+      MHD_gnutls_hash (td2, seed, seed_size);
+      MHD_gnutls_MHD_hmac_deinit (td2, final);
 
       if ((1 + i) * blocksize < total_bytes)
         {
@@ -765,7 +765,7 @@ _gnutls_P_hash (enum MHD_GNUTLS_HashAlgorithm algorithm,
 /* Xor's two buffers and puts the output in the first one.
  */
 inline static void
-_gnutls_xor (opaque * o1, opaque * o2, int length)
+MHD__gnutls_xor (opaque * o1, opaque * o2, int length)
 {
   int i;
   for (i = 0; i < length; i++)
@@ -781,7 +781,7 @@ _gnutls_xor (opaque * o1, opaque * o2, int length)
  * available.
  */
 int
-mhd_gtls_PRF (mhd_gtls_session_t session,
+MHD_gtls_PRF (MHD_gtls_session_t session,
               const opaque * secret,
               int secret_size,
               const char *label,
@@ -793,11 +793,11 @@ mhd_gtls_PRF (mhd_gtls_session_t session,
   opaque s_seed[MAX_SEED_SIZE];
   opaque o1[MAX_PRF_BYTES], o2[MAX_PRF_BYTES];
   int result;
-  enum MHD_GNUTLS_Protocol ver = MHD_gnutls_protocol_get_version (session);
+  enum MHD_GNUTLS_Protocol ver = MHD__gnutls_protocol_get_version (session);
 
   if (total_bytes > MAX_PRF_BYTES)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
   /* label+seed = s_seed */
@@ -805,7 +805,7 @@ mhd_gtls_PRF (mhd_gtls_session_t session,
 
   if (s_seed_size > MAX_SEED_SIZE)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
@@ -815,11 +815,11 @@ mhd_gtls_PRF (mhd_gtls_session_t session,
   if (ver >= MHD_GNUTLS_PROTOCOL_TLS1_2)
     {
       result =
-        _gnutls_P_hash (MHD_GNUTLS_MAC_SHA1, secret, secret_size, s_seed,
+        MHD__gnutls_P_hash (MHD_GNUTLS_MAC_SHA1, secret, secret_size, s_seed,
                         s_seed_size, total_bytes, ret);
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return result;
         }
     }
@@ -836,24 +836,24 @@ mhd_gtls_PRF (mhd_gtls_session_t session,
         }
 
       result =
-        _gnutls_P_hash (MHD_GNUTLS_MAC_MD5, s1, l_s, s_seed, s_seed_size,
+        MHD__gnutls_P_hash (MHD_GNUTLS_MAC_MD5, s1, l_s, s_seed, s_seed_size,
                         total_bytes, o1);
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return result;
         }
 
       result =
-        _gnutls_P_hash (MHD_GNUTLS_MAC_SHA1, s2, l_s, s_seed, s_seed_size,
+        MHD__gnutls_P_hash (MHD_GNUTLS_MAC_SHA1, s2, l_s, s_seed, s_seed_size,
                         total_bytes, o2);
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return result;
         }
 
-      _gnutls_xor (o1, o2, total_bytes);
+      MHD__gnutls_xor (o1, o2, total_bytes);
 
       memcpy (ret, o1, total_bytes);
     }
@@ -863,8 +863,8 @@ mhd_gtls_PRF (mhd_gtls_session_t session,
 }
 
 /**
- * MHD_gnutls_prf_raw - access the TLS PRF directly
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD__gnutls_prf_raw - access the TLS PRF directly
+ * @session: is a #MHD_gtls_session_t structure.
  * @label_size: length of the @label variable.
  * @label: label used in PRF computation, typically a short string.
  * @seed_size: length of the @seed variable.
@@ -885,14 +885,14 @@ mhd_gtls_PRF (mhd_gtls_session_t session,
  * session unless @seed include the client random and server random
  * fields (the PRF would output the same data on another connection
  * resumed from the first one), it is not recommended to use this
- * function directly.  The MHD_gnutls_prf() function seed the PRF with the
+ * function directly.  The MHD__gnutls_prf() function seed the PRF with the
  * client and server random fields directly, and is recommended if you
  * want to generate pseudo random data unique for each session.
  *
  * Returns: %GNUTLS_E_SUCCESS on success, or an error code.
  **/
 int
-MHD_gnutls_prf_raw (mhd_gtls_session_t session,
+MHD__gnutls_prf_raw (MHD_gtls_session_t session,
                     size_t label_size,
                     const char *label,
                     size_t seed_size, const char *seed, size_t outsize,
@@ -900,7 +900,7 @@ MHD_gnutls_prf_raw (mhd_gtls_session_t session,
 {
   int ret;
 
-  ret = mhd_gtls_PRF (session, session->security_parameters.master_secret,
+  ret = MHD_gtls_PRF (session, session->security_parameters.master_secret,
                       TLS_MASTER_SIZE, label, label_size, (opaque *) seed,
                       seed_size, outsize, out);
 
@@ -908,8 +908,8 @@ MHD_gnutls_prf_raw (mhd_gtls_session_t session,
 }
 
 /**
- * MHD_gnutls_prf - derive pseudo-random data using the TLS PRF
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD__gnutls_prf - derive pseudo-random data using the TLS PRF
+ * @session: is a #MHD_gtls_session_t structure.
  * @label_size: length of the @label variable.
  * @label: label used in PRF computation, typically a short string.
  * @server_random_first: non-0 if server random field should be first in seed
@@ -937,7 +937,7 @@ MHD_gnutls_prf_raw (mhd_gtls_session_t session,
  * Returns: %GNUTLS_E_SUCCESS on success, or an error code.
  **/
 int
-MHD_gnutls_prf (mhd_gtls_session_t session,
+MHD__gnutls_prf (MHD_gtls_session_t session,
                 size_t label_size,
                 const char *label,
                 int server_random_first,
@@ -948,10 +948,10 @@ MHD_gnutls_prf (mhd_gtls_session_t session,
   opaque *seed;
   size_t seedsize = 2 * TLS_RANDOM_SIZE + extra_size;
 
-  seed = gnutls_malloc (seedsize);
+  seed = MHD_gnutls_malloc (seedsize);
   if (!seed)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
@@ -964,18 +964,18 @@ MHD_gnutls_prf (mhd_gtls_session_t session,
 
   memcpy (seed + 2 * TLS_RANDOM_SIZE, extra, extra_size);
 
-  ret = mhd_gtls_PRF (session, session->security_parameters.master_secret,
+  ret = MHD_gtls_PRF (session, session->security_parameters.master_secret,
                       TLS_MASTER_SIZE, label, label_size, seed, seedsize,
                       outsize, out);
 
-  gnutls_free (seed);
+  MHD_gnutls_free (seed);
 
   return ret;
 }
 
 /**
  * MHD_gtls_session_get_client_random - get the session's client random value
- * @session: is a #mhd_gtls_session_t structure.
+ * @session: is a #MHD_gtls_session_t structure.
  *
  * Return a pointer to the 32-byte client random field used in the
  * session.  The pointer must not be modified or deallocated.
@@ -987,14 +987,14 @@ MHD_gnutls_prf (mhd_gtls_session_t session,
  * Returns: pointer to client random data.
  **/
 const void *
-MHD_gtls_session_get_client_random (mhd_gtls_session_t session)
+MHD_gtls_session_get_client_random (MHD_gtls_session_t session)
 {
   return (char *) session->security_parameters.client_random;
 }
 
 /**
  * MHD_gtls_session_get_server_random - get the session's server random value
- * @session: is a #mhd_gtls_session_t structure.
+ * @session: is a #MHD_gtls_session_t structure.
  *
  * Return a pointer to the 32-byte server random field used in the
  * session.  The pointer must not be modified or deallocated.
@@ -1006,14 +1006,14 @@ MHD_gtls_session_get_client_random (mhd_gtls_session_t session)
  * Returns: pointer to server random data.
  **/
 const void *
-MHD_gtls_session_get_server_random (mhd_gtls_session_t session)
+MHD_gtls_session_get_server_random (MHD_gtls_session_t session)
 {
   return (char *) session->security_parameters.server_random;
 }
 
 /**
  * MHD_gtls_session_get_master_secret - get the session's master secret value
- * @session: is a #mhd_gtls_session_t structure.
+ * @session: is a #MHD_gtls_session_t structure.
  *
  * Return a pointer to the 48-byte master secret in the session.  The
  * pointer must not be modified or deallocated.
@@ -1022,26 +1022,26 @@ MHD_gtls_session_get_server_random (mhd_gtls_session_t session)
  * will be garbage; in particular, a %NULL return value should not be
  * expected.
  *
- * Consider using MHD_gnutls_prf() rather than extracting the master
+ * Consider using MHD__gnutls_prf() rather than extracting the master
  * secret and use it to derive further data.
  *
  * Returns: pointer to master secret data.
  **/
 const void *
-MHD_gtls_session_get_master_secret (mhd_gtls_session_t session)
+MHD_gtls_session_get_master_secret (MHD_gtls_session_t session)
 {
   return (char *) session->security_parameters.master_secret;
 }
 
 /**
  * MHD_gtls_session_is_resumed - Used to check whether this session is a resumed one
- * @session: is a #mhd_gtls_session_t structure.
+ * @session: is a #MHD_gtls_session_t structure.
  *
  * Returns: non zero if this session is resumed, or a zero if this is
  * a new session.
  **/
 int
-MHD_gtls_session_is_resumed (mhd_gtls_session_t session)
+MHD_gtls_session_is_resumed (MHD_gtls_session_t session)
 {
 #if MHD_DEBUG_TLS
   if (session->security_parameters.entity == GNUTLS_CLIENT)
@@ -1066,22 +1066,22 @@ MHD_gtls_session_is_resumed (mhd_gtls_session_t session)
 }
 
 /*-
- * mhd_gtls_session_is_export - Used to check whether this session is of export grade
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD_gtls_session_is_export - Used to check whether this session is of export grade
+ * @session: is a #MHD_gtls_session_t structure.
  *
  * This function will return non zero if this session is of export grade.
  *
  -*/
 int
-mhd_gtls_session_is_export (mhd_gtls_session_t session)
+MHD_gtls_session_is_export (MHD_gtls_session_t session)
 {
   enum MHD_GNUTLS_CipherAlgorithm cipher;
 
   cipher =
-    mhd_gtls_cipher_suite_get_cipher_algo (&session->security_parameters.
+    MHD_gtls_cipher_suite_get_cipher_algo (&session->security_parameters.
                                            current_cipher_suite);
 
-  if (mhd_gtls_cipher_get_export_flag (cipher) != 0)
+  if (MHD_gtls_cipher_get_export_flag (cipher) != 0)
     return 1;
 
   return 0;
@@ -1089,20 +1089,20 @@ mhd_gtls_session_is_export (mhd_gtls_session_t session)
 
 /**
  * MHD_gtls_session_get_ptr - Used to get the user pointer from the session structure
- * @session: is a #mhd_gtls_session_t structure.
+ * @session: is a #MHD_gtls_session_t structure.
  *
  * Returns: the user given pointer from the session structure.  This
- * is the pointer set with MHD_gnutls_session_set_ptr().
+ * is the pointer set with MHD__gnutls_session_set_ptr().
  **/
 void *
-MHD_gtls_session_get_ptr (mhd_gtls_session_t session)
+MHD_gtls_session_get_ptr (MHD_gtls_session_t session)
 {
   return session->internals.user_ptr;
 }
 
 /**
- * MHD_gnutls_session_set_ptr - Used to set the user pointer to the session structure
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD__gnutls_session_set_ptr - Used to set the user pointer to the session structure
+ * @session: is a #MHD_gtls_session_t structure.
  * @ptr: is the user pointer
  *
  * This function will set (associate) the user given pointer to the
@@ -1110,37 +1110,37 @@ MHD_gtls_session_get_ptr (mhd_gtls_session_t session)
  * MHD_gtls_session_get_ptr().
  **/
 void
-MHD_gnutls_session_set_ptr (mhd_gtls_session_t session, void *ptr)
+MHD__gnutls_session_set_ptr (MHD_gtls_session_t session, void *ptr)
 {
   session->internals.user_ptr = ptr;
 }
 
 /**
- * MHD_gnutls_record_get_direction - This function will return the direction of the last interrupted function call
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD__gnutls_record_get_direction - This function will return the direction of the last interrupted function call
+ * @session: is a #MHD_gtls_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.  MHD_gnutls_handshake()) was interrupted for some reason, that
+ * (e.g.  MHD__gnutls_handshake()) was interrupted for some reason, that
  * is, if a function returned %GNUTLS_E_INTERRUPTED or
  * %GNUTLS_E_AGAIN.  In such a case, you might want to call select()
  * or poll() before calling the interrupted gnutls function again.
  * To tell you whether a file descriptor should be selected for
- * either reading or writing, MHD_gnutls_record_get_direction() returns 0
+ * either reading or writing, MHD__gnutls_record_get_direction() returns 0
  * if the interrupted function was trying to read data, and 1 if it
  * was trying to write data.
  *
  * Returns: 0 if trying to read data, 1 if trying to write data.
  **/
 int
-MHD_gnutls_record_get_direction (mhd_gtls_session_t session)
+MHD__gnutls_record_get_direction (MHD_gtls_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 #mhd_gtls_session_t structure.
+ * MHD__gnutls_rsa_pms_set_version - Sets a version to be used at the RSA PMS
+ * @session: is a #MHD_gtls_session_t structure.
  * @major: is the major version to use
  * @minor: is the minor version to use
  *
@@ -1150,7 +1150,7 @@ MHD_gnutls_record_get_direction (mhd_gtls_session_t session)
  *
  -*/
 void
-_gnutls_rsa_pms_set_version (mhd_gtls_session_t session,
+MHD__gnutls_rsa_pms_set_version (MHD_gtls_session_t session,
                              unsigned char major, unsigned char minor)
 {
   session->internals.rsa_pms_version[0] = major;
@@ -1158,8 +1158,8 @@ _gnutls_rsa_pms_set_version (mhd_gtls_session_t session,
 }
 
 /**
- * MHD_gnutls_handshake_set_post_client_hello_function - This function will a callback to be called after the client hello is received
- * @res: is a mhd_gtls_anon_server_credentials_t structure
+ * MHD__gnutls_handshake_set_post_client_hello_function - This function will a callback to be called after the client hello is received
+ * @res: is a MHD_gtls_anon_server_credentials_t structure
  * @func: is the function to be called
  *
  * This function will set a callback to be called after the client
@@ -1180,9 +1180,9 @@ _gnutls_rsa_pms_set_version (mhd_gtls_session_t session,
  *
  **/
 void
-MHD_gnutls_handshake_set_post_client_hello_function (mhd_gtls_session_t
+MHD__gnutls_handshake_set_post_client_hello_function (MHD_gtls_session_t
                                                      session,
-                                                     gnutls_handshake_post_client_hello_func
+                                                     MHD_gnutls_handshake_post_client_hello_func
                                                      func)
 {
   session->internals.user_hello_func = func;
diff --git a/src/daemon/https/tls/gnutls_state.h b/src/daemon/https/tls/gnutls_state.h
index e5d1877a..34aeda93 100644
--- a/src/daemon/https/tls/gnutls_state.h
+++ b/src/daemon/https/tls/gnutls_state.h
@@ -27,51 +27,51 @@
 
 #include <gnutls_int.h>
 
-void _gnutls_session_cert_type_set (mhd_gtls_session_t session,
+void MHD__gnutls_session_cert_type_set (MHD_gtls_session_t session,
                                     enum MHD_GNUTLS_CertificateType);
-enum MHD_GNUTLS_KeyExchangeAlgorithm gnutls_kx_get (mhd_gtls_session_t
+enum MHD_GNUTLS_KeyExchangeAlgorithm MHD_gnutls_kx_get (MHD_gtls_session_t
                                                     session);
-enum MHD_GNUTLS_CipherAlgorithm gnutls_cipher_get (mhd_gtls_session_t
+enum MHD_GNUTLS_CipherAlgorithm MHD_gnutls_cipher_get (MHD_gtls_session_t
                                                    session);
 enum MHD_GNUTLS_CertificateType
-gnutls_certificate_type_get (mhd_gtls_session_t);
+MHD_gnutls_certificate_type_get (MHD_gtls_session_t);
 
 #include <gnutls_auth_int.h>
 
 #define CHECK_AUTH(auth, ret) if (MHD_gtls_auth_get_type(session) != auth) { \
-        gnutls_assert(); \
+        MHD_gnutls_assert(); \
         return ret; \
         }
 
 #endif
 
-int mhd_gtls_session_cert_type_supported (mhd_gtls_session_t,
+int MHD_gtls_session_cert_type_supported (MHD_gtls_session_t,
                                           enum MHD_GNUTLS_CertificateType);
 
-int mhd_gtls_dh_set_secret_bits (mhd_gtls_session_t session, unsigned bits);
+int MHD_gtls_dh_set_secret_bits (MHD_gtls_session_t session, unsigned bits);
 
-int mhd_gtls_dh_set_peer_public (mhd_gtls_session_t session, mpi_t public);
-int mhd_gtls_dh_set_group (mhd_gtls_session_t session, mpi_t gen,
+int MHD_gtls_dh_set_peer_public (MHD_gtls_session_t session, mpi_t public);
+int MHD_gtls_dh_set_group (MHD_gtls_session_t session, mpi_t gen,
                            mpi_t prime);
 
-int mhd_gtls_dh_get_allowed_prime_bits (mhd_gtls_session_t session);
-void mhd_gtls_handshake_internal_state_clear (mhd_gtls_session_t);
+int MHD_gtls_dh_get_allowed_prime_bits (MHD_gtls_session_t session);
+void MHD_gtls_handshake_internal_state_clear (MHD_gtls_session_t);
 
-int mhd_gtls_rsa_export_set_pubkey (mhd_gtls_session_t session,
+int MHD_gtls_rsa_export_set_pubkey (MHD_gtls_session_t session,
                                     mpi_t exponent, mpi_t modulus);
 
-int mhd_gtls_session_is_resumable (mhd_gtls_session_t session);
-int mhd_gtls_session_is_export (mhd_gtls_session_t session);
+int MHD_gtls_session_is_resumable (MHD_gtls_session_t session);
+int MHD_gtls_session_is_export (MHD_gtls_session_t session);
 
-int mhd_gtls_openpgp_send_fingerprint (mhd_gtls_session_t session);
+int MHD_gtls_openpgp_send_fingerprint (MHD_gtls_session_t session);
 
-int mhd_gtls_PRF (mhd_gtls_session_t session,
+int MHD_gtls_PRF (MHD_gtls_session_t session,
                   const opaque * secret, int secret_size,
                   const char *label, int label_size,
                   const opaque * seed, int seed_size,
                   int total_bytes, void *ret);
 
-int MHD_gnutls_init (mhd_gtls_session_t * session,
-                     gnutls_connection_end_t con_end);
+int MHD__gnutls_init (MHD_gtls_session_t * session,
+                     MHD_gnutls_connection_end_t con_end);
 
 #define DEFAULT_CERT_TYPE MHD_GNUTLS_CRT_X509
diff --git a/src/daemon/https/tls/gnutls_str.c b/src/daemon/https/tls/gnutls_str.c
index 38f04738..4fc4174b 100644
--- a/src/daemon/https/tls/gnutls_str.c
+++ b/src/daemon/https/tls/gnutls_str.c
@@ -34,7 +34,7 @@
  * They should be used only with null terminated strings.
  */
 void
-mhd_gtls_str_cat (char *dest, size_t dest_tot_size, const char *src)
+MHD_gtls_str_cat (char *dest, size_t dest_tot_size, const char *src)
 {
   size_t str_size = strlen (src);
   size_t dest_size = strlen (dest);
@@ -54,7 +54,7 @@ mhd_gtls_str_cat (char *dest, size_t dest_tot_size, const char *src)
 }
 
 void
-mhd_gtls_str_cpy (char *dest, size_t dest_tot_size, const char *src)
+MHD_gtls_str_cpy (char *dest, size_t dest_tot_size, const char *src)
 {
   size_t str_size = strlen (src);
 
@@ -73,7 +73,7 @@ mhd_gtls_str_cpy (char *dest, size_t dest_tot_size, const char *src)
 }
 
 void
-mhd_gtls_mem_cpy (char *dest,
+MHD_gtls_mem_cpy (char *dest,
                   size_t dest_tot_size, const char *src, size_t src_size)
 {
 
@@ -91,10 +91,10 @@ mhd_gtls_mem_cpy (char *dest,
 }
 
 void
-mhd_gtls_string_init (mhd_gtls_string * str,
-                      gnutls_alloc_function alloc_func,
-                      gnutls_realloc_function realloc_func,
-                      gnutls_free_function free_func)
+MHD_gtls_string_init (MHD_gtls_string * str,
+                      MHD_gnutls_alloc_function alloc_func,
+                      MHD_gnutls_realloc_function realloc_func,
+                      MHD_gnutls_free_function free_func)
 {
   str->data = NULL;
   str->max_length = 0;
@@ -106,7 +106,7 @@ mhd_gtls_string_init (mhd_gtls_string * str,
 }
 
 void
-mhd_gtls_string_clear (mhd_gtls_string * str)
+MHD_gtls_string_clear (MHD_gtls_string * str)
 {
   if (str == NULL || str->data == NULL)
     return;
@@ -119,10 +119,10 @@ mhd_gtls_string_clear (mhd_gtls_string * str)
 
 /* This one does not copy the string.
  */
-gnutls_datum_t
-mhd_gtls_string2datum (mhd_gtls_string * str)
+MHD_gnutls_datum_t
+MHD_gtls_string2datum (MHD_gtls_string * str)
 {
-  gnutls_datum_t ret;
+  MHD_gnutls_datum_t ret;
 
   ret.data = str->data;
   ret.size = str->length;
@@ -133,7 +133,7 @@ mhd_gtls_string2datum (mhd_gtls_string * str)
 #define MIN_CHUNK 256
 
 int
-mhd_gtls_string_copy_str (mhd_gtls_string * dest, const char *src)
+MHD_gtls_string_copy_str (MHD_gtls_string * dest, const char *src)
 {
   size_t src_len = strlen (src);
   size_t max;
@@ -150,7 +150,7 @@ mhd_gtls_string_copy_str (mhd_gtls_string * dest, const char *src)
       dest->data = dest->realloc_func (dest->data, max);
       if (dest->data == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_MEMORY_ERROR;
         }
       dest->max_length = MAX (MIN_CHUNK, src_len);
@@ -163,7 +163,7 @@ mhd_gtls_string_copy_str (mhd_gtls_string * dest, const char *src)
 }
 
 int
-mhd_gtls_string_append_str (mhd_gtls_string * dest, const char *src)
+MHD_gtls_string_append_str (MHD_gtls_string * dest, const char *src)
 {
   size_t src_len = strlen (src);
   size_t tot_len = src_len + dest->length;
@@ -183,7 +183,7 @@ mhd_gtls_string_append_str (mhd_gtls_string * dest, const char *src)
       dest->data = dest->realloc_func (dest->data, new_len);
       if (dest->data == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_MEMORY_ERROR;
         }
       dest->max_length = new_len;
@@ -196,7 +196,7 @@ mhd_gtls_string_append_str (mhd_gtls_string * dest, const char *src)
 }
 
 int
-mhd_gtls_string_append_data (mhd_gtls_string * dest,
+MHD_gtls_string_append_data (MHD_gtls_string * dest,
                              const void *data, size_t data_size)
 {
   size_t tot_len = data_size + dest->length;
@@ -215,7 +215,7 @@ mhd_gtls_string_append_data (mhd_gtls_string * dest,
       dest->data = dest->realloc_func (dest->data, new_len);
       if (dest->data == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_MEMORY_ERROR;
         }
       dest->max_length = new_len;
@@ -233,7 +233,7 @@ mhd_gtls_string_append_data (mhd_gtls_string * dest,
  * truncated hex string is returned (always null terminated).
  */
 char *
-mhd_gtls_bin2hex (const void *_old,
+MHD_gtls_bin2hex (const void *_old,
                   size_t oldlen, char *buffer, size_t buffer_size)
 {
   unsigned int i, j;
@@ -252,7 +252,7 @@ mhd_gtls_bin2hex (const void *_old,
 /* just a hex2bin function.
  */
 int
-mhd_gtls_hex2bin (const opaque * hex_data,
+MHD_gtls_hex2bin (const opaque * hex_data,
                   int hex_size, opaque * bin_data, size_t * bin_size)
 {
   int i, j;
@@ -265,7 +265,7 @@ mhd_gtls_hex2bin (const opaque * hex_data,
 
   if (*bin_size < (size_t) hex_size)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_SHORT_MEMORY_BUFFER;
     }
 
@@ -277,7 +277,7 @@ mhd_gtls_hex2bin (const opaque * hex_data,
       val = strtoul ((char *) hex2_data, NULL, 16);
       if (val == ULONG_MAX)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_SRP_PWD_PARSING_ERROR;
         }
       bin_data[j] = val;
diff --git a/src/daemon/https/tls/gnutls_str.h b/src/daemon/https/tls/gnutls_str.h
index ead7ba2a..bedee1df 100644
--- a/src/daemon/https/tls/gnutls_str.h
+++ b/src/daemon/https/tls/gnutls_str.h
@@ -27,37 +27,37 @@
 
 #include <gnutls_int.h>
 
-void mhd_gtls_str_cpy (char *dest, size_t dest_tot_size, const char *src);
-void mhd_gtls_mem_cpy (char *dest, size_t dest_tot_size, const char *src,
+void MHD_gtls_str_cpy (char *dest, size_t dest_tot_size, const char *src);
+void MHD_gtls_mem_cpy (char *dest, size_t dest_tot_size, const char *src,
                        size_t src_size);
-void mhd_gtls_str_cat (char *dest, size_t dest_tot_size, const char *src);
+void MHD_gtls_str_cat (char *dest, size_t dest_tot_size, const char *src);
 
 typedef struct
 {
   opaque *data;
   size_t max_length;
   size_t length;
-  gnutls_realloc_function realloc_func;
-  gnutls_alloc_function alloc_func;
-  gnutls_free_function free_func;
-} mhd_gtls_string;
+  MHD_gnutls_realloc_function realloc_func;
+  MHD_gnutls_alloc_function alloc_func;
+  MHD_gnutls_free_function free_func;
+} MHD_gtls_string;
 
-void mhd_gtls_string_init (mhd_gtls_string *, gnutls_alloc_function,
-                           gnutls_realloc_function, gnutls_free_function);
-void mhd_gtls_string_clear (mhd_gtls_string *);
+void MHD_gtls_string_init (MHD_gtls_string *, MHD_gnutls_alloc_function,
+                           MHD_gnutls_realloc_function, MHD_gnutls_free_function);
+void MHD_gtls_string_clear (MHD_gtls_string *);
 
 /* Beware, do not clear the string, after calling this
  * function
  */
-gnutls_datum_t mhd_gtls_string2datum (mhd_gtls_string * str);
+MHD_gnutls_datum_t MHD_gtls_string2datum (MHD_gtls_string * str);
 
-int mhd_gtls_string_copy_str (mhd_gtls_string * dest, const char *src);
-int mhd_gtls_string_append_str (mhd_gtls_string *, const char *str);
-int mhd_gtls_string_append_data (mhd_gtls_string *, const void *data,
+int MHD_gtls_string_copy_str (MHD_gtls_string * dest, const char *src);
+int MHD_gtls_string_append_str (MHD_gtls_string *, const char *str);
+int MHD_gtls_string_append_data (MHD_gtls_string *, const void *data,
                                  size_t data_size);
-char *mhd_gtls_bin2hex (const void *old, size_t oldlen, char *buffer,
+char *MHD_gtls_bin2hex (const void *old, size_t oldlen, char *buffer,
                         size_t buffer_size);
-int mhd_gtls_hex2bin (const opaque * hex_data, int hex_size,
+int MHD_gtls_hex2bin (const opaque * hex_data, int hex_size,
                       opaque * bin_data, size_t * bin_size);
 
 #endif
diff --git a/src/daemon/https/tls/gnutls_supplemental.c b/src/daemon/https/tls/gnutls_supplemental.c
index 997da8a1..7b265031 100644
--- a/src/daemon/https/tls/gnutls_supplemental.c
+++ b/src/daemon/https/tls/gnutls_supplemental.c
@@ -25,13 +25,13 @@
 /* This file contains support functions for 'TLS Handshake Message for
  * Supplemental Data' (RFC 4680).
  *
- * The idea here is simple.  MHD_gnutls_handshake() in gnuts_handshake.c
- * will call _gnutls_gen_supplemental and _gnutls_parse_supplemental
+ * The idea here is simple.  MHD__gnutls_handshake() in gnuts_handshake.c
+ * will call MHD__gnutls_gen_supplemental and MHD__gnutls_parse_supplemental
  * when some extension requested that supplemental data be sent or
  * received.  Extension request this by setting the flags
  * do_recv_supplemental or do_send_supplemental in the session.
  *
- * The functions in this file iterate through the _gnutls_supplemental
+ * The functions in this file iterate through the MHD__gnutls_supplemental
  * array, and calls the send/recv functions for each respective data
  * type.
  *
@@ -50,29 +50,29 @@
 #include "gnutls_errors.h"
 #include "gnutls_num.h"
 
-typedef int (*supp_recv_func) (mhd_gtls_session_t session,
+typedef int (*supp_recv_func) (MHD_gtls_session_t session,
                                const opaque * data, size_t data_size);
-typedef int (*supp_send_func) (mhd_gtls_session_t session,
-                               mhd_gtls_buffer * buf);
+typedef int (*supp_send_func) (MHD_gtls_session_t session,
+                               MHD_gtls_buffer * buf);
 
 typedef struct
 {
   const char *name;
-  gnutls_supplemental_data_format_type_t type;
+  MHD_gnutls_supplemental_data_format_type_t type;
   supp_recv_func supp_recv_func;
   supp_send_func supp_send_func;
-} gnutls_supplemental_entry;
+} MHD_gnutls_supplemental_entry;
 
-gnutls_supplemental_entry _gnutls_supplemental[] = {
+MHD_gnutls_supplemental_entry MHD__gnutls_supplemental[] = {
   {0, 0, 0, 0}
 };
 
 const char *
-MHD_gtls_supplemental_get_name (gnutls_supplemental_data_format_type_t type)
+MHD_gtls_supplemental_get_name (MHD_gnutls_supplemental_data_format_type_t type)
 {
-  gnutls_supplemental_entry *p;
+  MHD_gnutls_supplemental_entry *p;
 
-  for (p = _gnutls_supplemental; p->name != NULL; p++)
+  for (p = MHD__gnutls_supplemental; p->name != NULL; p++)
     if (p->type == type)
       return p->name;
 
@@ -80,11 +80,11 @@ MHD_gtls_supplemental_get_name (gnutls_supplemental_data_format_type_t type)
 }
 
 static supp_recv_func
-get_supp_func_recv (gnutls_supplemental_data_format_type_t type)
+get_supp_func_recv (MHD_gnutls_supplemental_data_format_type_t type)
 {
-  gnutls_supplemental_entry *p;
+  MHD_gnutls_supplemental_entry *p;
 
-  for (p = _gnutls_supplemental; p->name != NULL; p++)
+  for (p = MHD__gnutls_supplemental; p->name != NULL; p++)
     if (p->type == type)
       return p->supp_recv_func;
 
@@ -92,37 +92,37 @@ get_supp_func_recv (gnutls_supplemental_data_format_type_t type)
 }
 
 int
-_gnutls_gen_supplemental (mhd_gtls_session_t session, mhd_gtls_buffer * buf)
+MHD__gnutls_gen_supplemental (MHD_gtls_session_t session, MHD_gtls_buffer * buf)
 {
-  gnutls_supplemental_entry *p;
+  MHD_gnutls_supplemental_entry *p;
   int ret;
 
   /* Make room for 3 byte length field. */
-  ret = mhd_gtls_buffer_append (buf, "\0\0\0", 3);
+  ret = MHD_gtls_buffer_append (buf, "\0\0\0", 3);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  for (p = _gnutls_supplemental; p->name; p++)
+  for (p = MHD__gnutls_supplemental; p->name; p++)
     {
       supp_send_func supp_send = p->supp_send_func;
       size_t sizepos = buf->length;
       int ret;
 
       /* Make room for supplement type and length byte length field. */
-      ret = mhd_gtls_buffer_append (buf, "\0\0\0\0", 4);
+      ret = MHD_gtls_buffer_append (buf, "\0\0\0\0", 4);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
       ret = supp_send (session, buf);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
@@ -142,14 +142,14 @@ _gnutls_gen_supplemental (mhd_gtls_session_t session, mhd_gtls_buffer * buf)
   buf->data[1] = ((buf->length - 3) >> 8) & 0xFF;
   buf->data[2] = (buf->length - 3) & 0xFF;
 
-  _gnutls_debug_log ("EXT[%x]: Sending %d bytes of supplemental data\n",
+  MHD__gnutls_debug_log ("EXT[%x]: Sending %d bytes of supplemental data\n",
                      session, buf->length);
 
   return buf->length;
 }
 
 int
-_gnutls_parse_supplemental (mhd_gtls_session_t session,
+MHD__gnutls_parse_supplemental (MHD_gtls_session_t session,
                             const uint8_t * data, int datalen)
 {
   const opaque *p = data;
@@ -157,12 +157,12 @@ _gnutls_parse_supplemental (mhd_gtls_session_t session,
   size_t total_size;
 
   DECR_LEN (dsize, 3);
-  total_size = mhd_gtls_read_uint24 (p);
+  total_size = MHD_gtls_read_uint24 (p);
   p += 3;
 
   if (dsize != total_size)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER;
     }
 
@@ -173,14 +173,14 @@ _gnutls_parse_supplemental (mhd_gtls_session_t session,
       supp_recv_func recv_func;
 
       DECR_LEN (dsize, 2);
-      supp_data_type = mhd_gtls_read_uint16 (p);
+      supp_data_type = MHD_gtls_read_uint16 (p);
       p += 2;
 
       DECR_LEN (dsize, 2);
-      supp_data_length = mhd_gtls_read_uint16 (p);
+      supp_data_length = MHD_gtls_read_uint16 (p);
       p += 2;
 
-      _gnutls_debug_log ("EXT[%x]: Got supplemental type=%02x length=%d\n",
+      MHD__gnutls_debug_log ("EXT[%x]: Got supplemental type=%02x length=%d\n",
                          session, supp_data_type, supp_data_length);
 
       recv_func = get_supp_func_recv (supp_data_type);
@@ -189,13 +189,13 @@ _gnutls_parse_supplemental (mhd_gtls_session_t session,
           int ret = recv_func (session, p, supp_data_length);
           if (ret < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return ret;
             }
         }
       else
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER;
         }
 
diff --git a/src/daemon/https/tls/gnutls_supplemental.h b/src/daemon/https/tls/gnutls_supplemental.h
index eaccfe74..a215ab56 100644
--- a/src/daemon/https/tls/gnutls_supplemental.h
+++ b/src/daemon/https/tls/gnutls_supplemental.h
@@ -24,7 +24,7 @@
 
 #include <gnutls_int.h>
 
-int _gnutls_parse_supplemental (mhd_gtls_session_t session,
+int MHD__gnutls_parse_supplemental (MHD_gtls_session_t session,
                                 const uint8_t * data, int data_size);
-int _gnutls_gen_supplemental (mhd_gtls_session_t session,
-                              mhd_gtls_buffer * buf);
+int MHD__gnutls_gen_supplemental (MHD_gtls_session_t session,
+                              MHD_gtls_buffer * buf);
diff --git a/src/daemon/https/tls/gnutls_ui.c b/src/daemon/https/tls/gnutls_ui.c
index b211a175..7709b2b7 100644
--- a/src/daemon/https/tls/gnutls_ui.c
+++ b/src/daemon/https/tls/gnutls_ui.c
@@ -37,8 +37,8 @@
 /* ANON & DHE */
 
 /**
- * MHD_gnutls_dh_set_prime_bits - Used to set the bits for a DH ciphersuite
- * @session: is a #mhd_gtls_session_t structure.
+ * MHD__gnutls_dh_set_prime_bits - Used to set the bits for a DH ciphersuite
+ * @session: is a #MHD_gtls_session_t structure.
  * @bits: is the number of bits
  *
  * This function sets the number of bits, for use in an
@@ -53,13 +53,13 @@
  *
  **/
 void
-MHD_gnutls_dh_set_prime_bits (mhd_gtls_session_t session, unsigned int bits)
+MHD__gnutls_dh_set_prime_bits (MHD_gtls_session_t session, unsigned int bits)
 {
   session->internals.dh_prime_bits = bits;
 }
 
 /**
- * MHD_gnutls_dh_get_group - This function returns the group of the DH authentication
+ * MHD__gnutls_dh_get_group - This function returns the group of the DH authentication
  * @session: is a gnutls session
  * @raw_gen: will hold the generator.
  * @raw_prime: will hold the prime.
@@ -67,16 +67,16 @@ MHD_gnutls_dh_set_prime_bits (mhd_gtls_session_t session, unsigned int bits)
  * This function will return the group parameters used in the last Diffie Hellman
  * authentication with the peer. These are the prime and the generator used.
  * This function should be used for both anonymous and ephemeral diffie Hellman.
- * The output parameters must be freed with gnutls_free().
+ * The output parameters must be freed with MHD_gnutls_free().
  *
  * Returns a negative value in case of an error.
  *
  **/
 int
-MHD_gnutls_dh_get_group (mhd_gtls_session_t session,
-                         gnutls_datum_t * raw_gen, gnutls_datum_t * raw_prime)
+MHD__gnutls_dh_get_group (MHD_gtls_session_t session,
+                         MHD_gnutls_datum_t * raw_gen, MHD_gnutls_datum_t * raw_prime)
 {
-  mhd_gtls_dh_info_st *dh;
+  MHD_gtls_dh_info_st *dh;
   int ret;
   mhd_anon_auth_info_t anon_info;
   cert_auth_info_t cert_info;
@@ -84,34 +84,34 @@ MHD_gnutls_dh_get_group (mhd_gtls_session_t session,
   switch (MHD_gtls_auth_get_type (session))
     {
     case MHD_GNUTLS_CRD_ANON:
-      anon_info = mhd_gtls_get_auth_info (session);
+      anon_info = MHD_gtls_get_auth_info (session);
       if (anon_info == NULL)
         return GNUTLS_E_INTERNAL_ERROR;
       dh = &anon_info->dh;
       break;
     case MHD_GNUTLS_CRD_CERTIFICATE:
-      cert_info = mhd_gtls_get_auth_info (session);
+      cert_info = MHD_gtls_get_auth_info (session);
       if (cert_info == NULL)
         return GNUTLS_E_INTERNAL_ERROR;
       dh = &cert_info->dh;
       break;
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  ret = _gnutls_set_datum (raw_prime, dh->prime.data, dh->prime.size);
+  ret = MHD__gnutls_set_datum (raw_prime, dh->prime.data, dh->prime.size);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  ret = _gnutls_set_datum (raw_gen, dh->generator.data, dh->generator.size);
+  ret = MHD__gnutls_set_datum (raw_gen, dh->generator.data, dh->generator.size);
   if (ret < 0)
     {
-      gnutls_assert ();
-      _gnutls_free_datum (raw_prime);
+      MHD_gnutls_assert ();
+      MHD__gnutls_free_datum (raw_prime);
       return ret;
     }
 
@@ -119,22 +119,22 @@ MHD_gnutls_dh_get_group (mhd_gtls_session_t session,
 }
 
 /**
- * MHD_gnutls_dh_get_pubkey - This function returns the peer's public key used in DH authentication
+ * MHD__gnutls_dh_get_pubkey - This function returns the peer's public key used in DH authentication
  * @session: is a gnutls session
  * @raw_key: will hold the public key.
  *
  * This function will return the peer's public key used in the last Diffie Hellman authentication.
  * This function should be used for both anonymous and ephemeral diffie Hellman.
- * The output parameters must be freed with gnutls_free().
+ * The output parameters must be freed with MHD_gnutls_free().
  *
  * Returns a negative value in case of an error.
  *
  **/
 int
-MHD_gnutls_dh_get_pubkey (mhd_gtls_session_t session,
-                          gnutls_datum_t * raw_key)
+MHD__gnutls_dh_get_pubkey (MHD_gtls_session_t session,
+                          MHD_gnutls_datum_t * raw_key)
 {
-  mhd_gtls_dh_info_st *dh;
+  MHD_gtls_dh_info_st *dh;
   mhd_anon_auth_info_t anon_info;
   cert_auth_info_t cert_info;
   cert_auth_info_t psk_info;
@@ -143,7 +143,7 @@ MHD_gnutls_dh_get_pubkey (mhd_gtls_session_t session,
     {
     case MHD_GNUTLS_CRD_ANON:
       {
-        anon_info = mhd_gtls_get_auth_info (session);
+        anon_info = MHD_gtls_get_auth_info (session);
         if (anon_info == NULL)
           return GNUTLS_E_INTERNAL_ERROR;
         dh = &anon_info->dh;
@@ -151,7 +151,7 @@ MHD_gnutls_dh_get_pubkey (mhd_gtls_session_t session,
       }
     case MHD_GNUTLS_CRD_PSK:
       {
-        psk_info = mhd_gtls_get_auth_info (session);
+        psk_info = MHD_gtls_get_auth_info (session);
         if (psk_info == NULL)
           return GNUTLS_E_INTERNAL_ERROR;
         dh = &psk_info->dh;
@@ -160,18 +160,18 @@ MHD_gnutls_dh_get_pubkey (mhd_gtls_session_t session,
     case MHD_GNUTLS_CRD_CERTIFICATE:
       {
 
-        cert_info = mhd_gtls_get_auth_info (session);
+        cert_info = MHD_gtls_get_auth_info (session);
         if (cert_info == NULL)
           return GNUTLS_E_INTERNAL_ERROR;
         dh = &cert_info->dh;
         break;
       }
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  return _gnutls_set_datum (raw_key, dh->public_key.data,
+  return MHD__gnutls_set_datum (raw_key, dh->public_key.data,
                             dh->public_key.size);
 }
 
@@ -183,39 +183,39 @@ MHD_gnutls_dh_get_pubkey (mhd_gtls_session_t session,
  *
  * This function will return the peer's public key exponent and
  * modulus used in the last RSA-EXPORT authentication.  The output
- * parameters must be freed with gnutls_free().
+ * parameters must be freed with MHD_gnutls_free().
  *
  * Returns a negative value in case of an error.
  *
  **/
 int
-MHD_gtls_rsa_export_get_pubkey (mhd_gtls_session_t session,
-                                gnutls_datum_t * exponent,
-                                gnutls_datum_t * modulus)
+MHD_gtls_rsa_export_get_pubkey (MHD_gtls_session_t session,
+                                MHD_gnutls_datum_t * exponent,
+                                MHD_gnutls_datum_t * modulus)
 {
   cert_auth_info_t info;
   int ret;
 
   if (MHD_gtls_auth_get_type (session) == MHD_GNUTLS_CRD_CERTIFICATE)
     {
-      info = mhd_gtls_get_auth_info (session);
+      info = MHD_gtls_get_auth_info (session);
       if (info == NULL)
         return GNUTLS_E_INTERNAL_ERROR;
 
-      ret = _gnutls_set_datum (modulus, info->rsa_export.modulus.data,
+      ret = MHD__gnutls_set_datum (modulus, info->rsa_export.modulus.data,
                                info->rsa_export.modulus.size);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
-      ret = _gnutls_set_datum (exponent, info->rsa_export.exponent.data,
+      ret = MHD__gnutls_set_datum (exponent, info->rsa_export.exponent.data,
                                info->rsa_export.exponent.size);
       if (ret < 0)
         {
-          gnutls_assert ();
-          _gnutls_free_datum (modulus);
+          MHD_gnutls_assert ();
+          MHD__gnutls_free_datum (modulus);
           return ret;
         }
 
@@ -226,7 +226,7 @@ MHD_gtls_rsa_export_get_pubkey (mhd_gtls_session_t session,
 }
 
 /**
- * MHD_gnutls_dh_get_secret_bits - This function returns the bits used in DH authentication
+ * MHD__gnutls_dh_get_secret_bits - This function returns the bits used in DH authentication
  * @session: is a gnutls session
  *
  * This function will return the bits used in the last Diffie Hellman authentication
@@ -235,7 +235,7 @@ MHD_gtls_rsa_export_get_pubkey (mhd_gtls_session_t session,
  *
  **/
 int
-MHD_gnutls_dh_get_secret_bits (mhd_gtls_session_t session)
+MHD__gnutls_dh_get_secret_bits (MHD_gtls_session_t session)
 {
   switch (MHD_gtls_auth_get_type (session))
     {
@@ -243,7 +243,7 @@ MHD_gnutls_dh_get_secret_bits (mhd_gtls_session_t session)
       {
         mhd_anon_auth_info_t info;
 
-        info = mhd_gtls_get_auth_info (session);
+        info = MHD_gtls_get_auth_info (session);
         if (info == NULL)
           return GNUTLS_E_INTERNAL_ERROR;
         return info->dh.secret_bits;
@@ -252,20 +252,20 @@ MHD_gnutls_dh_get_secret_bits (mhd_gtls_session_t session)
       {
         cert_auth_info_t info;
 
-        info = mhd_gtls_get_auth_info (session);
+        info = MHD_gtls_get_auth_info (session);
         if (info == NULL)
           return GNUTLS_E_INTERNAL_ERROR;
 
         return info->dh.secret_bits;
       }
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 }
 
 /**
- * MHD_gnutls_dh_get_prime_bits - This function returns the bits used in DH authentication
+ * MHD__gnutls_dh_get_prime_bits - This function returns the bits used in DH authentication
  * @session: is a gnutls session
  *
  * This function will return the bits of the prime used in the last Diffie Hellman authentication
@@ -274,9 +274,9 @@ MHD_gnutls_dh_get_secret_bits (mhd_gtls_session_t session)
  *
  **/
 int
-MHD_gnutls_dh_get_prime_bits (mhd_gtls_session_t session)
+MHD__gnutls_dh_get_prime_bits (MHD_gtls_session_t session)
 {
-  mhd_gtls_dh_info_st *dh;
+  MHD_gtls_dh_info_st *dh;
 
   switch (MHD_gtls_auth_get_type (session))
     {
@@ -284,7 +284,7 @@ MHD_gnutls_dh_get_prime_bits (mhd_gtls_session_t session)
       {
         mhd_anon_auth_info_t info;
 
-        info = mhd_gtls_get_auth_info (session);
+        info = MHD_gtls_get_auth_info (session);
         if (info == NULL)
           return GNUTLS_E_INTERNAL_ERROR;
         dh = &info->dh;
@@ -294,7 +294,7 @@ MHD_gnutls_dh_get_prime_bits (mhd_gtls_session_t session)
       {
         cert_auth_info_t info;
 
-        info = mhd_gtls_get_auth_info (session);
+        info = MHD_gtls_get_auth_info (session);
         if (info == NULL)
           return GNUTLS_E_INTERNAL_ERROR;
 
@@ -302,7 +302,7 @@ MHD_gnutls_dh_get_prime_bits (mhd_gtls_session_t session)
         break;
       }
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -320,11 +320,11 @@ MHD_gnutls_dh_get_prime_bits (mhd_gtls_session_t session)
  *
  **/
 int
-MHD_gtls_rsa_export_get_modulus_bits (mhd_gtls_session_t session)
+MHD_gtls_rsa_export_get_modulus_bits (MHD_gtls_session_t session)
 {
   cert_auth_info_t info;
 
-  info = mhd_gtls_get_auth_info (session);
+  info = MHD_gtls_get_auth_info (session);
   if (info == NULL)
     return GNUTLS_E_INTERNAL_ERROR;
 
@@ -332,7 +332,7 @@ MHD_gtls_rsa_export_get_modulus_bits (mhd_gtls_session_t session)
 }
 
 /**
- * MHD_gnutls_dh_get_peers_public_bits - This function returns the bits used in DH authentication
+ * MHD__gnutls_dh_get_peers_public_bits - This function returns the bits used in DH authentication
  * @session: is a gnutls session
  *
  * This function will return the bits used in the last Diffie Hellman authentication
@@ -341,9 +341,9 @@ MHD_gtls_rsa_export_get_modulus_bits (mhd_gtls_session_t session)
  *
  **/
 int
-MHD_gnutls_dh_get_peers_public_bits (mhd_gtls_session_t session)
+MHD__gnutls_dh_get_peers_public_bits (MHD_gtls_session_t session)
 {
-  mhd_gtls_dh_info_st *dh;
+  MHD_gtls_dh_info_st *dh;
 
   switch (MHD_gtls_auth_get_type (session))
     {
@@ -351,7 +351,7 @@ MHD_gnutls_dh_get_peers_public_bits (mhd_gtls_session_t session)
       {
         mhd_anon_auth_info_t info;
 
-        info = mhd_gtls_get_auth_info (session);
+        info = MHD_gtls_get_auth_info (session);
         if (info == NULL)
           return GNUTLS_E_INTERNAL_ERROR;
 
@@ -362,7 +362,7 @@ MHD_gnutls_dh_get_peers_public_bits (mhd_gtls_session_t session)
       {
         cert_auth_info_t info;
 
-        info = mhd_gtls_get_auth_info (session);
+        info = MHD_gtls_get_auth_info (session);
         if (info == NULL)
           return GNUTLS_E_INTERNAL_ERROR;
 
@@ -370,7 +370,7 @@ MHD_gnutls_dh_get_peers_public_bits (mhd_gtls_session_t session)
         break;
       }
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -391,20 +391,20 @@ MHD_gnutls_dh_get_peers_public_bits (mhd_gtls_session_t session)
  * Returns NULL in case of an error, or if no certificate was used.
  *
  **/
-const gnutls_datum_t *
-MHD_gtls_certificate_get_ours (mhd_gtls_session_t session)
+const MHD_gnutls_datum_t *
+MHD_gtls_certificate_get_ours (MHD_gtls_session_t session)
 {
-  mhd_gtls_cert_credentials_t cred;
+  MHD_gtls_cert_credentials_t cred;
 
   CHECK_AUTH (MHD_GNUTLS_CRD_CERTIFICATE, NULL);
 
   cred
-    = (mhd_gtls_cert_credentials_t) mhd_gtls_get_cred (session->key,
+    = (MHD_gtls_cert_credentials_t) MHD_gtls_get_cred (session->key,
                                                        MHD_GNUTLS_CRD_CERTIFICATE,
                                                        NULL);
   if (cred == NULL || cred->cert_list == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return NULL;
     }
 
@@ -431,15 +431,15 @@ MHD_gtls_certificate_get_ours (mhd_gtls_session_t session)
  * Returns NULL in case of an error, or if no certificate was sent.
  *
  **/
-const gnutls_datum_t *
-MHD_gtls_certificate_get_peers (mhd_gtls_session_t
+const MHD_gnutls_datum_t *
+MHD_gtls_certificate_get_peers (MHD_gtls_session_t
                                 session, unsigned int *list_size)
 {
   cert_auth_info_t info;
 
   CHECK_AUTH (MHD_GNUTLS_CRD_CERTIFICATE, NULL);
 
-  info = mhd_gtls_get_auth_info (session);
+  info = MHD_gtls_get_auth_info (session);
   if (info == NULL)
     return NULL;
 
@@ -457,20 +457,20 @@ MHD_gtls_certificate_get_peers (mhd_gtls_session_t
  *
  **/
 int
-MHD_gtls_certificate_client_get_request_status (mhd_gtls_session_t session)
+MHD_gtls_certificate_client_get_request_status (MHD_gtls_session_t session)
 {
   cert_auth_info_t info;
 
   CHECK_AUTH (MHD_GNUTLS_CRD_CERTIFICATE, 0);
 
-  info = mhd_gtls_get_auth_info (session);
+  info = MHD_gtls_get_auth_info (session);
   if (info == NULL)
     return GNUTLS_E_INTERNAL_ERROR;
   return info->certificate_requested;
 }
 
 /**
- * MHD_gnutls_fingerprint - This function calculates the fingerprint of the given data
+ * MHD__gnutls_fingerprint - This function calculates the fingerprint of the given data
  * @algo: is a digest algorithm
  * @data: is the data
  * @result: is the place where the result will be copied (may be null).
@@ -490,12 +490,12 @@ MHD_gtls_certificate_client_get_request_status (mhd_gtls_session_t session)
  *
  **/
 int
-MHD_gnutls_fingerprint (enum MHD_GNUTLS_HashAlgorithm algo,
-                        const gnutls_datum_t * data,
+MHD__gnutls_fingerprint (enum MHD_GNUTLS_HashAlgorithm algo,
+                        const MHD_gnutls_datum_t * data,
                         void *result, size_t * result_size)
 {
   GNUTLS_HASH_HANDLE td;
-  int hash_len = mhd_gnutls_hash_get_algo_len (HASH2MAC (algo));
+  int hash_len = MHD_gnutls_hash_get_algo_len (HASH2MAC (algo));
 
   if (hash_len < 0 || (unsigned) hash_len > *result_size || result == NULL)
     {
@@ -506,21 +506,21 @@ MHD_gnutls_fingerprint (enum MHD_GNUTLS_HashAlgorithm algo,
 
   if (result)
     {
-      td = mhd_gtls_hash_init (HASH2MAC (algo));
+      td = MHD_gtls_hash_init (HASH2MAC (algo));
       if (td == NULL)
         return GNUTLS_E_HASH_FAILED;
 
-      mhd_gnutls_hash (td, data->data, data->size);
+      MHD_gnutls_hash (td, data->data, data->size);
 
-      mhd_gnutls_hash_deinit (td, result);
+      MHD_gnutls_hash_deinit (td, result);
     }
 
   return 0;
 }
 
 /**
- * MHD_gnutls_certificate_set_dh_params - This function will set the DH parameters for a server to use
- * @res: is a mhd_gtls_cert_credentials_t structure
+ * MHD__gnutls_certificate_set_dh_params - This function will set the DH parameters for a server to use
+ * @res: is a MHD_gtls_cert_credentials_t structure
  * @dh_params: is a structure that holds diffie hellman parameters.
  *
  * This function will set the diffie hellman parameters for a
@@ -532,15 +532,15 @@ MHD_gnutls_fingerprint (enum MHD_GNUTLS_HashAlgorithm algo,
  *
  **/
 void
-MHD_gnutls_certificate_set_dh_params (mhd_gtls_cert_credentials_t res,
-                                      mhd_gtls_dh_params_t dh_params)
+MHD__gnutls_certificate_set_dh_params (MHD_gtls_cert_credentials_t res,
+                                      MHD_gtls_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 mhd_gtls_cert_credentials_t structure
+ * MHD_gnutls_certificate_set_params_function - This function will set the DH or RSA parameters callback
+ * @res: is a MHD_gtls_cert_credentials_t structure
  * @func: is the function to be called
  *
  * This function will set a callback in order for the server to get the
@@ -549,32 +549,32 @@ MHD_gnutls_certificate_set_dh_params (mhd_gtls_cert_credentials_t res,
  *
  **/
 void
-gnutls_certificate_set_params_function (mhd_gtls_cert_credentials_t res,
-                                        gnutls_params_function * func)
+MHD_gnutls_certificate_set_params_function (MHD_gtls_cert_credentials_t res,
+                                        MHD_gnutls_params_function * func)
 {
   res->params_func = func;
 }
 
 /**
- * MHD_gnutls_certificate_set_verify_flags - This function will set the flags to be used at certificate verification
- * @res: is a mhd_gtls_cert_credentials_t structure
+ * MHD__gnutls_certificate_set_verify_flags - This function will set the flags to be used at certificate verification
+ * @res: is a MHD_gtls_cert_credentials_t structure
  * @flags: are the flags
  *
  * 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.
+ * #MHD_gnutls_certificate_verify_flags enumerations.
  *
  **/
 void
-MHD_gnutls_certificate_set_verify_flags (mhd_gtls_cert_credentials_t
+MHD__gnutls_certificate_set_verify_flags (MHD_gtls_cert_credentials_t
                                          res, unsigned int flags)
 {
   res->verify_flags = flags;
 }
 
 /**
- * MHD_gnutls_certificate_set_verify_limits - This function will set the upper limits to be used at certificate verification
- * @res: is a gnutls_certificate_credentials structure
+ * MHD__gnutls_certificate_set_verify_limits - This function will set the upper limits to be used at certificate verification
+ * @res: is a MHD_gnutls_certificate_credentials structure
  * @max_bits: is the number of bits of an acceptable certificate (default 8200)
  * @max_depth: is maximum depth of the verification of a certificate chain (default 5)
  *
@@ -584,7 +584,7 @@ MHD_gnutls_certificate_set_verify_flags (mhd_gtls_cert_credentials_t
  *
  **/
 void
-MHD_gnutls_certificate_set_verify_limits (mhd_gtls_cert_credentials_t
+MHD__gnutls_certificate_set_verify_limits (MHD_gtls_cert_credentials_t
                                           res,
                                           unsigned int max_bits,
                                           unsigned int max_depth)
@@ -594,8 +594,8 @@ MHD_gnutls_certificate_set_verify_limits (mhd_gtls_cert_credentials_t
 }
 
 /**
- * MHD_gnutls_certificate_set_rsa_export_params - This function will set the RSA parameters for a server to use
- * @res: is a mhd_gtls_cert_credentials_t structure
+ * MHD__gnutls_certificate_set_rsa_export_params - This function will set the RSA parameters for a server to use
+ * @res: is a MHD_gtls_cert_credentials_t structure
  * @rsa_params: is a structure that holds temporary RSA parameters.
  *
  * This function will set the temporary RSA parameters for a certificate
@@ -604,17 +604,17 @@ MHD_gnutls_certificate_set_verify_limits (mhd_gtls_cert_credentials_t
  *
  **/
 void
-MHD_gnutls_certificate_set_rsa_export_params (mhd_gtls_cert_credentials_t
+MHD__gnutls_certificate_set_rsa_export_params (MHD_gtls_cert_credentials_t
                                               res,
-                                              mhd_gtls_rsa_params_t
+                                              MHD_gtls_rsa_params_t
                                               rsa_params)
 {
   res->rsa_params = rsa_params;
 }
 
 /**
- * gnutls_anon_set_params_function - This function will set the DH or RSA parameters callback
- * @res: is a mhd_gtls_anon_server_credentials_t structure
+ * MHD_gnutls_anon_set_params_function - This function will set the DH or RSA parameters callback
+ * @res: is a MHD_gtls_anon_server_credentials_t structure
  * @func: is the function to be called
  *
  * This function will set a callback in order for the server to get the
@@ -623,8 +623,8 @@ MHD_gnutls_certificate_set_rsa_export_params (mhd_gtls_cert_credentials_t
  *
  **/
 void
-gnutls_anon_set_params_function (mhd_gtls_anon_server_credentials_t res,
-                                 gnutls_params_function * func)
+MHD_gnutls_anon_set_params_function (MHD_gtls_anon_server_credentials_t res,
+                                 MHD_gnutls_params_function * func)
 {
   res->params_func = func;
 }
diff --git a/src/daemon/https/tls/gnutls_x509.c b/src/daemon/https/tls/gnutls_x509.c
index f854b710..811f5dbe 100644
--- a/src/daemon/https/tls/gnutls_x509.c
+++ b/src/daemon/https/tls/gnutls_x509.c
@@ -64,21 +64,21 @@
  * is unacceptable.
   */
 inline static int
-check_bits (gnutls_x509_crt_t crt, unsigned int max_bits)
+check_bits (MHD_gnutls_x509_crt_t crt, unsigned int max_bits)
 {
   int ret;
   unsigned int bits;
 
-  ret = gnutls_x509_crt_get_pk_algorithm (crt, &bits);
+  ret = MHD_gnutls_x509_crt_get_pk_algorithm (crt, &bits);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
   if (bits > max_bits && max_bits > 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_CONSTRAINT_ERROR;
     }
 
@@ -88,43 +88,43 @@ check_bits (gnutls_x509_crt_t crt, unsigned int max_bits)
 
 #define CLEAR_CERTS for(x=0;x<peer_certificate_list_size;x++) { \
         if (peer_certificate_list[x]) \
-                gnutls_x509_crt_deinit(peer_certificate_list[x]); \
+                MHD_gnutls_x509_crt_deinit(peer_certificate_list[x]); \
         } \
-        gnutls_free( peer_certificate_list)
+        MHD_gnutls_free( peer_certificate_list)
 
 /*-
-  * _gnutls_x509_cert_verify_peers - This function returns the peer's certificate status
+  * MHD__gnutls_x509_cert_verify_peers - This function returns the peer's certificate status
   * @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_t enumerated elements.
+  * The return value (status) should be one of the MHD_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 (mhd_gtls_session_t session,
+MHD__gnutls_x509_cert_verify_peers (MHD_gtls_session_t session,
                                 unsigned int *status)
 {
   cert_auth_info_t info;
-  mhd_gtls_cert_credentials_t cred;
-  gnutls_x509_crt_t *peer_certificate_list;
+  MHD_gtls_cert_credentials_t cred;
+  MHD_gnutls_x509_crt_t *peer_certificate_list;
   int peer_certificate_list_size, i, x, ret;
 
   CHECK_AUTH (MHD_GNUTLS_CRD_CERTIFICATE, GNUTLS_E_INVALID_REQUEST);
 
-  info = mhd_gtls_get_auth_info (session);
+  info = MHD_gtls_get_auth_info (session);
   if (info == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  cred = (mhd_gtls_cert_credentials_t)
-    mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
+  cred = (MHD_gtls_cert_credentials_t)
+    MHD_gtls_get_cred (session->key, MHD_GNUTLS_CRD_CERTIFICATE, NULL);
   if (cred == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
     }
 
@@ -133,40 +133,40 @@ _gnutls_x509_cert_verify_peers (mhd_gtls_session_t session,
 
   if (info->ncerts > cred->verify_depth && cred->verify_depth > 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_CONSTRAINT_ERROR;
     }
 
-  /* generate a list of gnutls_certs based on the auth info
+  /* generate a list of MHD_gnutls_certs based on the auth info
    * raw certs.
    */
   peer_certificate_list_size = info->ncerts;
   peer_certificate_list =
-    gnutls_calloc (1,
-                   peer_certificate_list_size * sizeof (gnutls_x509_crt_t));
+    MHD_gnutls_calloc (1,
+                   peer_certificate_list_size * sizeof (MHD_gnutls_x509_crt_t));
   if (peer_certificate_list == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
   for (i = 0; i < peer_certificate_list_size; i++)
     {
-      ret = gnutls_x509_crt_init (&peer_certificate_list[i]);
+      ret = MHD_gnutls_x509_crt_init (&peer_certificate_list[i]);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           CLEAR_CERTS;
           return ret;
         }
 
       ret =
-        gnutls_x509_crt_import (peer_certificate_list[i],
+        MHD_gnutls_x509_crt_import (peer_certificate_list[i],
                                 &info->raw_certificate_list[i],
                                 GNUTLS_X509_FMT_DER);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           CLEAR_CERTS;
           return ret;
         }
@@ -174,7 +174,7 @@ _gnutls_x509_cert_verify_peers (mhd_gtls_session_t session,
       ret = check_bits (peer_certificate_list[i], cred->verify_bits);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           CLEAR_CERTS;
           return ret;
         }
@@ -184,7 +184,7 @@ _gnutls_x509_cert_verify_peers (mhd_gtls_session_t session,
   /* Verify certificate
    */
   ret =
-    gnutls_x509_crt_list_verify (peer_certificate_list,
+    MHD_gnutls_x509_crt_list_verify (peer_certificate_list,
                                  peer_certificate_list_size,
                                  cred->x509_ca_list, cred->x509_ncas,
                                  cred->x509_crl_list, cred->x509_ncrls,
@@ -194,7 +194,7 @@ _gnutls_x509_cert_verify_peers (mhd_gtls_session_t session,
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -209,55 +209,55 @@ _gnutls_x509_cert_verify_peers (mhd_gtls_session_t session,
  * the given key parameters.
  */
 static int
-_gnutls_check_key_cert_match (mhd_gtls_cert_credentials_t res)
+MHD__gnutls_check_key_cert_match (MHD_gtls_cert_credentials_t res)
 {
-  gnutls_datum_t cid;
-  gnutls_datum_t kid;
+  MHD_gnutls_datum_t cid;
+  MHD_gnutls_datum_t kid;
   unsigned pk = res->cert_list[res->ncerts - 1][0].subject_pk_algorithm;
 
   if (res->pkey[res->ncerts - 1].pk_algorithm != pk)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_CERTIFICATE_KEY_MISMATCH;
     }
 
-  _gnutls_x509_write_rsa_params (res->pkey[res->ncerts - 1].params,
+  MHD__gnutls_x509_write_rsa_params (res->pkey[res->ncerts - 1].params,
                                  res->pkey[res->ncerts -
                                            1].params_size, &kid);
 
 
-  _gnutls_x509_write_rsa_params (res->cert_list[res->ncerts - 1][0].params,
+  MHD__gnutls_x509_write_rsa_params (res->cert_list[res->ncerts - 1][0].params,
                                  res->cert_list[res->ncerts -
                                                 1][0].params_size, &cid);
 
   if (cid.size != kid.size)
     {
-      gnutls_assert ();
-      _gnutls_free_datum (&kid);
-      _gnutls_free_datum (&cid);
+      MHD_gnutls_assert ();
+      MHD__gnutls_free_datum (&kid);
+      MHD__gnutls_free_datum (&cid);
       return GNUTLS_E_CERTIFICATE_KEY_MISMATCH;
     }
 
   if (memcmp (kid.data, cid.data, kid.size) != 0)
     {
-      gnutls_assert ();
-      _gnutls_free_datum (&kid);
-      _gnutls_free_datum (&cid);
+      MHD_gnutls_assert ();
+      MHD__gnutls_free_datum (&kid);
+      MHD__gnutls_free_datum (&cid);
       return GNUTLS_E_CERTIFICATE_KEY_MISMATCH;
     }
 
-  _gnutls_free_datum (&kid);
-  _gnutls_free_datum (&cid);
+  MHD__gnutls_free_datum (&kid);
+  MHD__gnutls_free_datum (&cid);
   return 0;
 }
 
 /* Reads a DER encoded certificate list from memory and stores it to
- * a gnutls_cert structure.
+ * a MHD_gnutls_cert structure.
  * Returns the number of certificates parsed.
  */
 static int
-parse_crt_mem (gnutls_cert ** cert_list, unsigned *ncerts,
-               gnutls_x509_crt_t cert)
+parse_crt_mem (MHD_gnutls_cert ** cert_list, unsigned *ncerts,
+               MHD_gnutls_x509_crt_t cert)
 {
   int i;
   int ret;
@@ -265,19 +265,19 @@ parse_crt_mem (gnutls_cert ** cert_list, unsigned *ncerts,
   i = *ncerts + 1;
 
   *cert_list =
-    (gnutls_cert *) mhd_gtls_realloc_fast (*cert_list,
-                                           i * sizeof (gnutls_cert));
+    (MHD_gnutls_cert *) MHD_gtls_realloc_fast (*cert_list,
+                                           i * sizeof (MHD_gnutls_cert));
 
   if (*cert_list == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
-  ret = mhd_gtls_x509_crt_to_gcert (&cert_list[0][i - 1], cert, 0);
+  ret = MHD_gtls_x509_crt_to_gcert (&cert_list[0][i - 1], cert, 0);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -287,65 +287,65 @@ parse_crt_mem (gnutls_cert ** cert_list, unsigned *ncerts,
 }
 
 /* Reads a DER encoded certificate list from memory and stores it to
- * a gnutls_cert structure. 
+ * a MHD_gnutls_cert structure. 
  * Returns the number of certificates parsed.
  */
 static int
-parse_der_cert_mem (gnutls_cert ** cert_list, unsigned *ncerts,
+parse_der_cert_mem (MHD_gnutls_cert ** cert_list, unsigned *ncerts,
                     const void *input_cert, int input_cert_size)
 {
-  gnutls_datum_t tmp;
-  gnutls_x509_crt_t cert;
+  MHD_gnutls_datum_t tmp;
+  MHD_gnutls_x509_crt_t cert;
   int ret;
 
-  ret = gnutls_x509_crt_init (&cert);
+  ret = MHD_gnutls_x509_crt_init (&cert);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
   tmp.data = (opaque *) input_cert;
   tmp.size = input_cert_size;
 
-  ret = gnutls_x509_crt_import (cert, &tmp, GNUTLS_X509_FMT_DER);
+  ret = MHD_gnutls_x509_crt_import (cert, &tmp, GNUTLS_X509_FMT_DER);
   if (ret < 0)
     {
-      gnutls_assert ();
-      gnutls_x509_crt_deinit (cert);
+      MHD_gnutls_assert ();
+      MHD_gnutls_x509_crt_deinit (cert);
       return ret;
     }
 
   ret = parse_crt_mem (cert_list, ncerts, cert);
-  gnutls_x509_crt_deinit (cert);
+  MHD_gnutls_x509_crt_deinit (cert);
 
   return ret;
 }
 
 /* Reads a base64 encoded certificate list from memory and stores it to
- * a gnutls_cert structure. Returns the number of certificate parsed.
+ * a MHD_gnutls_cert structure. Returns the number of certificate parsed.
  */
 static int
-parse_pem_cert_mem (gnutls_cert ** cert_list, unsigned *ncerts,
+parse_pem_cert_mem (MHD_gnutls_cert ** cert_list, unsigned *ncerts,
                     const char *input_cert, int input_cert_size)
 {
   int size, siz2, i;
   const char *ptr;
   opaque *ptr2;
-  gnutls_datum_t tmp;
+  MHD_gnutls_datum_t tmp;
   int ret, count;
 
   /* move to the certificate
    */
-  ptr = memmem (input_cert, input_cert_size,
+  ptr = MHD_memmem (input_cert, input_cert_size,
                 PEM_CERT_SEP, sizeof (PEM_CERT_SEP) - 1);
   if (ptr == NULL)
-    ptr = memmem (input_cert, input_cert_size,
+    ptr = MHD_memmem (input_cert, input_cert_size,
                   PEM_CERT_SEP2, sizeof (PEM_CERT_SEP2) - 1);
 
   if (ptr == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_BASE64_DECODING_ERROR;
     }
   size = input_cert_size - (ptr - input_cert);
@@ -356,34 +356,34 @@ parse_pem_cert_mem (gnutls_cert ** cert_list, unsigned *ncerts,
   do
     {
 
-      siz2 = _gnutls_fbase64_decode (NULL, (const unsigned char*) ptr, size, &ptr2);
+      siz2 = MHD__gnutls_fbase64_decode (NULL, (const unsigned char*) ptr, size, &ptr2);
 
       if (siz2 < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_BASE64_DECODING_ERROR;
         }
 
       *cert_list =
-        (gnutls_cert *) mhd_gtls_realloc_fast (*cert_list,
-                                               i * sizeof (gnutls_cert));
+        (MHD_gnutls_cert *) MHD_gtls_realloc_fast (*cert_list,
+                                               i * sizeof (MHD_gnutls_cert));
 
       if (*cert_list == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_MEMORY_ERROR;
         }
 
       tmp.data = ptr2;
       tmp.size = siz2;
 
-      ret = mhd_gtls_x509_raw_cert_to_gcert (&cert_list[0][i - 1], &tmp, 0);
+      ret = MHD_gtls_x509_raw_cert_to_gcert (&cert_list[0][i - 1], &tmp, 0);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
-      _gnutls_free_datum (&tmp);        /* free ptr2 */
+      MHD__gnutls_free_datum (&tmp);        /* free ptr2 */
 
       /* now we move ptr after the pem header
        */
@@ -396,9 +396,9 @@ parse_pem_cert_mem (gnutls_cert ** cert_list, unsigned *ncerts,
         {
           char *ptr3;
 
-          ptr3 = memmem (ptr, size, PEM_CERT_SEP, sizeof (PEM_CERT_SEP) - 1);
+          ptr3 = MHD_memmem (ptr, size, PEM_CERT_SEP, sizeof (PEM_CERT_SEP) - 1);
           if (ptr3 == NULL)
-            ptr3 = memmem (ptr, size, PEM_CERT_SEP2,
+            ptr3 = MHD_memmem (ptr, size, PEM_CERT_SEP2,
                            sizeof (PEM_CERT_SEP2) - 1);
 
           ptr = ptr3;
@@ -422,30 +422,30 @@ parse_pem_cert_mem (gnutls_cert ** cert_list, unsigned *ncerts,
 /* Reads a DER or PEM certificate from memory
  */
 static int
-read_cert_mem (mhd_gtls_cert_credentials_t res, const void *cert,
-               int cert_size, gnutls_x509_crt_fmt_t type)
+read_cert_mem (MHD_gtls_cert_credentials_t res, const void *cert,
+               int cert_size, MHD_gnutls_x509_crt_fmt_t type)
 {
   int ret;
 
   /* allocate space for the certificate to add
    */
-  res->cert_list = mhd_gtls_realloc_fast (res->cert_list,
+  res->cert_list = MHD_gtls_realloc_fast (res->cert_list,
                                           (1 +
                                            res->ncerts) *
-                                          sizeof (gnutls_cert *));
+                                          sizeof (MHD_gnutls_cert *));
   if (res->cert_list == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
-  res->cert_list_length = mhd_gtls_realloc_fast (res->cert_list_length,
+  res->cert_list_length = MHD_gtls_realloc_fast (res->cert_list_length,
                                                  (1 +
                                                   res->ncerts) *
                                                  sizeof (int));
   if (res->cert_list_length == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
@@ -464,7 +464,7 @@ read_cert_mem (mhd_gtls_cert_credentials_t res, const void *cert,
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -473,19 +473,19 @@ read_cert_mem (mhd_gtls_cert_credentials_t res, const void *cert,
 
 
 int
-_gnutls_x509_privkey_to_gkey (gnutls_privkey * dest,
-                              gnutls_x509_privkey_t src)
+MHD__gnutls_x509_privkey_to_gkey (MHD_gnutls_privkey * dest,
+                              MHD_gnutls_x509_privkey_t src)
 {
   int i, ret;
 
-  memset (dest, 0, sizeof (gnutls_privkey));
+  memset (dest, 0, sizeof (MHD_gnutls_privkey));
 
   for (i = 0; i < src->params_size; i++)
     {
-      dest->params[i] = _gnutls_mpi_copy (src->params[i]);
+      dest->params[i] = MHD__gnutls_mpi_copy (src->params[i]);
       if (dest->params[i] == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           ret = GNUTLS_E_MEMORY_ERROR;
           goto cleanup;
         }
@@ -500,13 +500,13 @@ cleanup:
 
   for (i = 0; i < src->params_size; i++)
     {
-      mhd_gtls_mpi_release (&dest->params[i]);
+      MHD_gtls_mpi_release (&dest->params[i]);
     }
   return ret;
 }
 
 void
-mhd_gtls_gkey_deinit (gnutls_privkey * key)
+MHD_gtls_gkey_deinit (MHD_gnutls_privkey * key)
 {
   int i;
   if (key == NULL)
@@ -514,51 +514,51 @@ mhd_gtls_gkey_deinit (gnutls_privkey * key)
 
   for (i = 0; i < key->params_size; i++)
     {
-      mhd_gtls_mpi_release (&key->params[i]);
+      MHD_gtls_mpi_release (&key->params[i]);
     }
 }
 
 int
-_gnutls_x509_raw_privkey_to_gkey (gnutls_privkey * privkey,
-                                  const gnutls_datum_t * raw_key,
-                                  gnutls_x509_crt_fmt_t type)
+MHD__gnutls_x509_raw_privkey_to_gkey (MHD_gnutls_privkey * privkey,
+                                  const MHD_gnutls_datum_t * raw_key,
+                                  MHD_gnutls_x509_crt_fmt_t type)
 {
-  gnutls_x509_privkey_t tmpkey;
+  MHD_gnutls_x509_privkey_t tmpkey;
   int ret;
 
-  ret = gnutls_x509_privkey_init (&tmpkey);
+  ret = MHD_gnutls_x509_privkey_init (&tmpkey);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  ret = gnutls_x509_privkey_import (tmpkey, raw_key, type);
+  ret = MHD_gnutls_x509_privkey_import (tmpkey, raw_key, type);
 
 #ifdef ENABLE_PKI
   /* If normal key decoding doesn't work try decoding a plain PKCS #8 key */
   if (ret < 0)
     ret =
-      gnutls_x509_privkey_import_pkcs8 (tmpkey, raw_key, type, NULL,
+      MHD_gnutls_x509_privkey_import_pkcs8 (tmpkey, raw_key, type, NULL,
                                         GNUTLS_PKCS_PLAIN);
 #endif
 
   if (ret < 0)
     {
-      gnutls_assert ();
-      gnutls_x509_privkey_deinit (tmpkey);
+      MHD_gnutls_assert ();
+      MHD_gnutls_x509_privkey_deinit (tmpkey);
       return ret;
     }
 
-  ret = _gnutls_x509_privkey_to_gkey (privkey, tmpkey);
+  ret = MHD__gnutls_x509_privkey_to_gkey (privkey, tmpkey);
   if (ret < 0)
     {
-      gnutls_assert ();
-      gnutls_x509_privkey_deinit (tmpkey);
+      MHD_gnutls_assert ();
+      MHD_gnutls_x509_privkey_deinit (tmpkey);
       return ret;
     }
 
-  gnutls_x509_privkey_deinit (tmpkey);
+  MHD_gnutls_x509_privkey_deinit (tmpkey);
 
   return 0;
 }
@@ -568,20 +568,20 @@ _gnutls_x509_raw_privkey_to_gkey (gnutls_privkey * privkey,
  * that GnuTLS doesn't know the private key.
  */
 static int
-read_key_mem (mhd_gtls_cert_credentials_t res,
-              const void *key, int key_size, gnutls_x509_crt_fmt_t type)
+read_key_mem (MHD_gtls_cert_credentials_t res,
+              const void *key, int key_size, MHD_gnutls_x509_crt_fmt_t type)
 {
   int ret;
-  gnutls_datum_t tmp;
+  MHD_gnutls_datum_t tmp;
 
   /* allocate space for the pkey list
    */
   res->pkey =
-    mhd_gtls_realloc_fast (res->pkey,
-                           (res->ncerts + 1) * sizeof (gnutls_privkey));
+    MHD_gtls_realloc_fast (res->pkey,
+                           (res->ncerts + 1) * sizeof (MHD_gnutls_privkey));
   if (res->pkey == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
@@ -591,29 +591,29 @@ read_key_mem (mhd_gtls_cert_credentials_t res,
       tmp.size = key_size;
 
       ret =
-        _gnutls_x509_raw_privkey_to_gkey (&res->pkey[res->ncerts], &tmp,
+        MHD__gnutls_x509_raw_privkey_to_gkey (&res->pkey[res->ncerts], &tmp,
                                           type);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
     }
   else
-    memset (&res->pkey[res->ncerts], 0, sizeof (gnutls_privkey));
+    memset (&res->pkey[res->ncerts], 0, sizeof (MHD_gnutls_privkey));
 
   return 0;
 }
 
 /**
-  * MHD_gnutls_certificate_set_x509_key_mem - Used to set keys in a mhd_gtls_cert_credentials_t structure
-  * @res: is an #mhd_gtls_cert_credentials_t structure.
+  * MHD__gnutls_certificate_set_x509_key_mem - Used to set keys in a MHD_gtls_cert_credentials_t structure
+  * @res: is an #MHD_gtls_cert_credentials_t structure.
   * @cert: contains a certificate list (path) for the specified private key
   * @key: is the private key, or %NULL
   * @type: is PEM or DER
   *
   * This function sets a certificate/private key pair in the
-  * mhd_gtls_cert_credentials_t structure. This function may be called
+  * MHD_gtls_cert_credentials_t structure. This function may be called
   * more than once (in case multiple keys/certificates exist for the
   * server).
   *
@@ -636,10 +636,10 @@ read_key_mem (mhd_gtls_cert_credentials_t res,
   * Returns: %GNUTLS_E_SUCCESS on success, or an error code.
   **/
 int
-MHD_gnutls_certificate_set_x509_key_mem (mhd_gtls_cert_credentials_t
-                                         res, const gnutls_datum_t * cert,
-                                         const gnutls_datum_t * key,
-                                         gnutls_x509_crt_fmt_t type)
+MHD__gnutls_certificate_set_x509_key_mem (MHD_gtls_cert_credentials_t
+                                         res, const MHD_gnutls_datum_t * cert,
+                                         const MHD_gnutls_datum_t * key,
+                                         MHD_gnutls_x509_crt_fmt_t type)
 {
   int ret;
 
@@ -654,9 +654,9 @@ MHD_gnutls_certificate_set_x509_key_mem (mhd_gtls_cert_credentials_t
 
   res->ncerts++;
 
-  if (key && (ret = _gnutls_check_key_cert_match (res)) < 0)
+  if (key && (ret = MHD__gnutls_check_key_cert_match (res)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -664,9 +664,9 @@ MHD_gnutls_certificate_set_x509_key_mem (mhd_gtls_cert_credentials_t
 }
 
 static int
-generate_rdn_seq (mhd_gtls_cert_credentials_t res)
+generate_rdn_seq (MHD_gtls_cert_credentials_t res)
 {
-  gnutls_datum_t tmp;
+  MHD_gnutls_datum_t tmp;
   int ret;
   unsigned size, i;
   opaque *pdata;
@@ -685,22 +685,22 @@ generate_rdn_seq (mhd_gtls_cert_credentials_t res)
   size = 0;
   for (i = 0; i < res->x509_ncas; i++)
     {
-      if ((ret = gnutls_x509_crt_get_raw_dn (res->x509_ca_list[i], &tmp)) < 0)
+      if ((ret = MHD_gnutls_x509_crt_get_raw_dn (res->x509_ca_list[i], &tmp)) < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
       size += (2 + tmp.size);
-      _gnutls_free_datum (&tmp);
+      MHD__gnutls_free_datum (&tmp);
     }
 
   if (res->x509_rdn_sequence.data != NULL)
-    gnutls_free (res->x509_rdn_sequence.data);
+    MHD_gnutls_free (res->x509_rdn_sequence.data);
 
-  res->x509_rdn_sequence.data = gnutls_malloc (size);
+  res->x509_rdn_sequence.data = MHD_gnutls_malloc (size);
   if (res->x509_rdn_sequence.data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
   res->x509_rdn_sequence.size = size;
@@ -709,16 +709,16 @@ generate_rdn_seq (mhd_gtls_cert_credentials_t res)
 
   for (i = 0; i < res->x509_ncas; i++)
     {
-      if ((ret = gnutls_x509_crt_get_raw_dn (res->x509_ca_list[i], &tmp)) < 0)
+      if ((ret = MHD_gnutls_x509_crt_get_raw_dn (res->x509_ca_list[i], &tmp)) < 0)
         {
-          _gnutls_free_datum (&res->x509_rdn_sequence);
-          gnutls_assert ();
+          MHD__gnutls_free_datum (&res->x509_rdn_sequence);
+          MHD_gnutls_assert ();
           return ret;
         }
 
-      mhd_gtls_write_datum16 (pdata, tmp);
+      MHD_gtls_write_datum16 (pdata, tmp);
       pdata += (2 + tmp.size);
-      _gnutls_free_datum (&tmp);
+      MHD__gnutls_free_datum (&tmp);
     }
 
   return 0;
@@ -728,7 +728,7 @@ generate_rdn_seq (mhd_gtls_cert_credentials_t res)
  * certificate (uses the KeyUsage field).
  */
 int
-_gnutls_check_key_usage (const gnutls_cert * cert,
+MHD__gnutls_check_key_usage (const MHD_gnutls_cert * cert,
                          enum MHD_GNUTLS_KeyExchangeAlgorithm alg)
 {
   unsigned int key_usage = 0;
@@ -736,17 +736,17 @@ _gnutls_check_key_usage (const gnutls_cert * cert,
 
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
-  if (mhd_gtls_map_kx_get_cred (alg, 1) == MHD_GNUTLS_CRD_CERTIFICATE ||
-      mhd_gtls_map_kx_get_cred (alg, 0) == MHD_GNUTLS_CRD_CERTIFICATE)
+  if (MHD_gtls_map_kx_get_cred (alg, 1) == MHD_GNUTLS_CRD_CERTIFICATE ||
+      MHD_gtls_map_kx_get_cred (alg, 0) == MHD_GNUTLS_CRD_CERTIFICATE)
     {
 
       key_usage = cert->key_usage;
 
-      encipher_type = mhd_gtls_kx_encipher_type (alg);
+      encipher_type = MHD_gtls_kx_encipher_type (alg);
 
       if (key_usage != 0 && encipher_type != CIPHER_IGN)
         {
@@ -761,7 +761,7 @@ _gnutls_check_key_usage (const gnutls_cert * cert,
                */
               if (!(key_usage & KEY_KEY_ENCIPHERMENT))
                 {
-                  gnutls_assert ();
+                  MHD_gnutls_assert ();
                   return GNUTLS_E_KEY_USAGE_VIOLATION;
                 }
             }
@@ -772,7 +772,7 @@ _gnutls_check_key_usage (const gnutls_cert * cert,
                */
               if (!(key_usage & KEY_DIGITAL_SIGNATURE))
                 {
-                  gnutls_assert ();
+                  MHD_gnutls_assert ();
                   return GNUTLS_E_KEY_USAGE_VIOLATION;
                 }
             }
@@ -784,25 +784,25 @@ _gnutls_check_key_usage (const gnutls_cert * cert,
 
 
 static int
-parse_pem_ca_mem (gnutls_x509_crt_t ** cert_list, unsigned *ncerts,
+parse_pem_ca_mem (MHD_gnutls_x509_crt_t ** cert_list, unsigned *ncerts,
                   const opaque * input_cert, int input_cert_size)
 {
   int i, size;
   const opaque *ptr;
-  gnutls_datum_t tmp;
+  MHD_gnutls_datum_t tmp;
   int ret, count;
 
   /* move to the certificate
    */
-  ptr = memmem (input_cert, input_cert_size,
+  ptr = MHD_memmem (input_cert, input_cert_size,
                 PEM_CERT_SEP, sizeof (PEM_CERT_SEP) - 1);
   if (ptr == NULL)
-    ptr = memmem (input_cert, input_cert_size,
+    ptr = MHD_memmem (input_cert, input_cert_size,
                   PEM_CERT_SEP2, sizeof (PEM_CERT_SEP2) - 1);
 
   if (ptr == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_BASE64_DECODING_ERROR;
     }
   size = input_cert_size - (ptr - input_cert);
@@ -814,21 +814,21 @@ parse_pem_ca_mem (gnutls_x509_crt_t ** cert_list, unsigned *ncerts,
     {
 
       *cert_list =
-        (gnutls_x509_crt_t *) mhd_gtls_realloc_fast (*cert_list,
+        (MHD_gnutls_x509_crt_t *) MHD_gtls_realloc_fast (*cert_list,
                                                      i *
                                                      sizeof
-                                                     (gnutls_x509_crt_t));
+                                                     (MHD_gnutls_x509_crt_t));
 
       if (*cert_list == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_MEMORY_ERROR;
         }
 
-      ret = gnutls_x509_crt_init (&cert_list[0][i - 1]);
+      ret = MHD_gnutls_x509_crt_init (&cert_list[0][i - 1]);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
@@ -836,11 +836,11 @@ parse_pem_ca_mem (gnutls_x509_crt_t ** cert_list, unsigned *ncerts,
       tmp.size = size;
 
       ret =
-        gnutls_x509_crt_import (cert_list[0][i - 1],
+        MHD_gnutls_x509_crt_import (cert_list[0][i - 1],
                                 &tmp, GNUTLS_X509_FMT_PEM);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
@@ -855,9 +855,9 @@ parse_pem_ca_mem (gnutls_x509_crt_t ** cert_list, unsigned *ncerts,
         {
           char *ptr3;
 
-          ptr3 = memmem (ptr, size, PEM_CERT_SEP, sizeof (PEM_CERT_SEP) - 1);
+          ptr3 = MHD_memmem (ptr, size, PEM_CERT_SEP, sizeof (PEM_CERT_SEP) - 1);
           if (ptr3 == NULL)
-            ptr3 = memmem (ptr, size,
+            ptr3 = MHD_memmem (ptr, size,
                            PEM_CERT_SEP2, sizeof (PEM_CERT_SEP2) - 1);
 
           ptr = (const opaque *) ptr3;
@@ -878,45 +878,45 @@ parse_pem_ca_mem (gnutls_x509_crt_t ** cert_list, unsigned *ncerts,
 }
 
 /* Reads a DER encoded certificate list from memory and stores it to
- * a gnutls_cert structure.
+ * a MHD_gnutls_cert structure.
  * returns the number of certificates parsed.
  */
 static int
-parse_der_ca_mem (gnutls_x509_crt_t ** cert_list, unsigned *ncerts,
+parse_der_ca_mem (MHD_gnutls_x509_crt_t ** cert_list, unsigned *ncerts,
                   const void *input_cert, int input_cert_size)
 {
   int i;
-  gnutls_datum_t tmp;
+  MHD_gnutls_datum_t tmp;
   int ret;
 
   i = *ncerts + 1;
 
   *cert_list =
-    (gnutls_x509_crt_t *) mhd_gtls_realloc_fast (*cert_list,
+    (MHD_gnutls_x509_crt_t *) MHD_gtls_realloc_fast (*cert_list,
                                                  i *
-                                                 sizeof (gnutls_x509_crt_t));
+                                                 sizeof (MHD_gnutls_x509_crt_t));
 
   if (*cert_list == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
   tmp.data = (opaque *) input_cert;
   tmp.size = input_cert_size;
 
-  ret = gnutls_x509_crt_init (&cert_list[0][i - 1]);
+  ret = MHD_gnutls_x509_crt_init (&cert_list[0][i - 1]);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
   ret =
-    gnutls_x509_crt_import (cert_list[0][i - 1], &tmp, GNUTLS_X509_FMT_DER);
+    MHD_gnutls_x509_crt_import (cert_list[0][i - 1], &tmp, GNUTLS_X509_FMT_DER);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -926,8 +926,8 @@ parse_der_ca_mem (gnutls_x509_crt_t ** cert_list, unsigned *ncerts,
 }
 
 /**
-  * MHD_gnutls_certificate_set_x509_trust_mem - Used to add trusted CAs in a mhd_gtls_cert_credentials_t structure
-  * @res: is an #mhd_gtls_cert_credentials_t structure.
+  * MHD__gnutls_certificate_set_x509_trust_mem - Used to add trusted CAs in a MHD_gtls_cert_credentials_t structure
+  * @res: is an #MHD_gtls_cert_credentials_t structure.
   * @ca: is a list of trusted CAs or a DER certificate
   * @type: is DER or PEM
   *
@@ -939,15 +939,15 @@ parse_der_ca_mem (gnutls_x509_crt_t ** cert_list, unsigned *ncerts,
   *
   * In case of a server the CAs set here will be sent to the client if
   * a certificate request is sent. This can be disabled using
-  * MHD_gnutls_certificate_send_x509_rdn_sequence().
+  * MHD__gnutls_certificate_send_x509_rdn_sequence().
   *
   * Returns: the number of certificates processed or a negative value
   * on error.
   **/
 int
-MHD_gnutls_certificate_set_x509_trust_mem (mhd_gtls_cert_credentials_t
-                                           res, const gnutls_datum_t * ca,
-                                           gnutls_x509_crt_fmt_t type)
+MHD__gnutls_certificate_set_x509_trust_mem (MHD_gtls_cert_credentials_t
+                                           res, const MHD_gnutls_datum_t * ca,
+                                           MHD_gnutls_x509_crt_fmt_t type)
 {
   int ret, ret2;
 
@@ -967,21 +967,21 @@ MHD_gnutls_certificate_set_x509_trust_mem (mhd_gtls_cert_credentials_t
 #ifdef ENABLE_PKI
 
 static int
-parse_pem_crl_mem (gnutls_x509_crl_t ** crl_list, unsigned *ncrls,
+parse_pem_crl_mem (MHD_gnutls_x509_crl_t ** crl_list, unsigned *ncrls,
                    const opaque * input_crl, int input_crl_size)
 {
   int size, i;
   const opaque *ptr;
-  gnutls_datum_t tmp;
+  MHD_gnutls_datum_t tmp;
   int ret, count;
 
   /* move to the certificate
    */
-  ptr = memmem (input_crl, input_crl_size,
+  ptr = MHD_memmem (input_crl, input_crl_size,
                 PEM_CRL_SEP, sizeof (PEM_CRL_SEP) - 1);
   if (ptr == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_BASE64_DECODING_ERROR;
     }
 
@@ -994,21 +994,21 @@ parse_pem_crl_mem (gnutls_x509_crl_t ** crl_list, unsigned *ncrls,
     {
 
       *crl_list =
-        (gnutls_x509_crl_t *) mhd_gtls_realloc_fast (*crl_list,
+        (MHD_gnutls_x509_crl_t *) MHD_gtls_realloc_fast (*crl_list,
                                                      i *
                                                      sizeof
-                                                     (gnutls_x509_crl_t));
+                                                     (MHD_gnutls_x509_crl_t));
 
       if (*crl_list == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_MEMORY_ERROR;
         }
 
-      ret = gnutls_x509_crl_init (&crl_list[0][i - 1]);
+      ret = MHD_gnutls_x509_crl_init (&crl_list[0][i - 1]);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
       
@@ -1016,11 +1016,11 @@ parse_pem_crl_mem (gnutls_x509_crl_t ** crl_list, unsigned *ncrls,
       tmp.size = size;
 
       ret =
-        gnutls_x509_crl_import (crl_list[0][i - 1],
+        MHD_gnutls_x509_crl_import (crl_list[0][i - 1],
                                 &tmp, GNUTLS_X509_FMT_PEM);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
@@ -1033,7 +1033,7 @@ parse_pem_crl_mem (gnutls_x509_crl_t ** crl_list, unsigned *ncrls,
       size = input_crl_size - (ptr - input_crl);
 
       if (size > 0)
-        ptr = memmem (ptr, size, PEM_CRL_SEP, sizeof (PEM_CRL_SEP) - 1);
+        ptr = MHD_memmem (ptr, size, PEM_CRL_SEP, sizeof (PEM_CRL_SEP) - 1);
       else
         ptr = NULL;
       i++;
@@ -1048,45 +1048,45 @@ parse_pem_crl_mem (gnutls_x509_crl_t ** crl_list, unsigned *ncrls,
 }
 
 /* Reads a DER encoded certificate list from memory and stores it to
- * a gnutls_cert structure.
+ * a MHD_gnutls_cert structure.
  * returns the number of certificates parsed.
  */
 static int
-parse_der_crl_mem (gnutls_x509_crl_t ** crl_list, unsigned *ncrls,
+parse_der_crl_mem (MHD_gnutls_x509_crl_t ** crl_list, unsigned *ncrls,
                    const void *input_crl, int input_crl_size)
 {
   int i;
-  gnutls_datum_t tmp;
+  MHD_gnutls_datum_t tmp;
   int ret;
 
   i = *ncrls + 1;
 
   *crl_list =
-    (gnutls_x509_crl_t *) mhd_gtls_realloc_fast (*crl_list,
+    (MHD_gnutls_x509_crl_t *) MHD_gtls_realloc_fast (*crl_list,
                                                  i *
-                                                 sizeof (gnutls_x509_crl_t));
+                                                 sizeof (MHD_gnutls_x509_crl_t));
 
   if (*crl_list == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
   tmp.data = (opaque *) input_crl;
   tmp.size = input_crl_size;
 
-  ret = gnutls_x509_crl_init (&crl_list[0][i - 1]);
+  ret = MHD_gnutls_x509_crl_init (&crl_list[0][i - 1]);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
   ret =
-    gnutls_x509_crl_import (crl_list[0][i - 1], &tmp, GNUTLS_X509_FMT_DER);
+    MHD_gnutls_x509_crl_import (crl_list[0][i - 1], &tmp, GNUTLS_X509_FMT_DER);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -1099,20 +1099,20 @@ parse_der_crl_mem (gnutls_x509_crl_t ** crl_list, unsigned *ncrls,
 /* Reads a DER or PEM CRL from memory
  */
 static int
-read_crl_mem (mhd_gtls_cert_credentials_t res, const void *crl,
-              int crl_size, gnutls_x509_crt_fmt_t type)
+read_crl_mem (MHD_gtls_cert_credentials_t res, const void *crl,
+              int crl_size, MHD_gnutls_x509_crt_fmt_t type)
 {
   int ret;
 
   /* allocate space for the certificate to add
    */
-  res->x509_crl_list = mhd_gtls_realloc_fast (res->x509_crl_list,
+  res->x509_crl_list = MHD_gtls_realloc_fast (res->x509_crl_list,
                                               (1 +
                                                res->x509_ncrls) *
-                                              sizeof (gnutls_x509_crl_t));
+                                              sizeof (MHD_gnutls_x509_crl_t));
   if (res->x509_crl_list == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
@@ -1125,7 +1125,7 @@ read_crl_mem (mhd_gtls_cert_credentials_t res, const void *crl,
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -1133,8 +1133,8 @@ read_crl_mem (mhd_gtls_cert_credentials_t res, const void *crl,
 }
 
 /**
-  * MHD_gnutls_certificate_set_x509_crl_mem - Used to add CRLs in a mhd_gtls_cert_credentials_t structure
-  * @res: is an #mhd_gtls_cert_credentials_t structure.
+  * MHD__gnutls_certificate_set_x509_crl_mem - Used to add CRLs in a MHD_gtls_cert_credentials_t structure
+  * @res: is an #MHD_gtls_cert_credentials_t structure.
   * @CRL: is a list of trusted CRLs. They should have been verified before.
   * @type: is DER or PEM
   *
@@ -1147,9 +1147,9 @@ read_crl_mem (mhd_gtls_cert_credentials_t res, const void *crl,
   * Returns: number of CRLs processed, or a negative value on error.
   **/
 int
-MHD_gnutls_certificate_set_x509_crl_mem (mhd_gtls_cert_credentials_t
-                                         res, const gnutls_datum_t * CRL,
-                                         gnutls_x509_crt_fmt_t type)
+MHD__gnutls_certificate_set_x509_crl_mem (MHD_gtls_cert_credentials_t
+                                         res, const MHD_gnutls_datum_t * CRL,
+                                         MHD_gnutls_x509_crt_fmt_t type)
 {
   int ret;
 
@@ -1162,26 +1162,26 @@ MHD_gnutls_certificate_set_x509_crl_mem (mhd_gtls_cert_credentials_t
 #include <pkcs12.h>
 
 /**
-  * MHD_gnutls_certificate_free_crls - Used to free all the CRLs from a mhd_gtls_cert_credentials_t structure
-  * @sc: is an #mhd_gtls_cert_credentials_t structure.
+  * MHD__gnutls_certificate_free_crls - Used to free all the CRLs from a MHD_gtls_cert_credentials_t structure
+  * @sc: is an #MHD_gtls_cert_credentials_t structure.
   *
   * This function will delete all the CRLs associated
   * with the given credentials.
   *
   **/
 void
-MHD_gnutls_certificate_free_crls (mhd_gtls_cert_credentials_t sc)
+MHD__gnutls_certificate_free_crls (MHD_gtls_cert_credentials_t sc)
 {
   unsigned j;
 
   for (j = 0; j < sc->x509_ncrls; j++)
     {
-      gnutls_x509_crl_deinit (sc->x509_crl_list[j]);
+      MHD_gnutls_x509_crl_deinit (sc->x509_crl_list[j]);
     }
 
   sc->x509_ncrls = 0;
 
-  gnutls_free (sc->x509_crl_list);
+  MHD_gnutls_free (sc->x509_crl_list);
   sc->x509_crl_list = NULL;
 }
 
diff --git a/src/daemon/https/tls/gnutls_x509.h b/src/daemon/https/tls/gnutls_x509.h
index b0135d95..b2d92603 100644
--- a/src/daemon/https/tls/gnutls_x509.h
+++ b/src/daemon/https/tls/gnutls_x509.h
@@ -24,7 +24,7 @@
 
 #include <libtasn1.h>
 
-int _gnutls_x509_cert_verify_peers (mhd_gtls_session_t session,
+int MHD__gnutls_x509_cert_verify_peers (MHD_gtls_session_t session,
                                     unsigned int *status);
 
 #define PEM_CERT_SEP2 "-----BEGIN X509 CERTIFICATE"
@@ -35,14 +35,14 @@ int _gnutls_x509_cert_verify_peers (mhd_gtls_session_t session,
 #define PEM_KEY_RSA_SEP "-----BEGIN RSA"
 #define PEM_KEY_DSA_SEP "-----BEGIN DSA"
 
-int _gnutls_check_key_usage (const gnutls_cert * cert,
+int MHD__gnutls_check_key_usage (const MHD_gnutls_cert * cert,
                              enum MHD_GNUTLS_KeyExchangeAlgorithm alg);
 
-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 MHD__gnutls_x509_read_rsa_params (opaque * der, int dersize, mpi_t * params);
+int MHD__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_t * raw_key,
-                                      gnutls_x509_crt_fmt_t type);
-int _gnutls_x509_privkey_to_gkey (gnutls_privkey * privkey,
-                                  gnutls_x509_privkey_t);
+int MHD__gnutls_x509_raw_privkey_to_gkey (MHD_gnutls_privkey * privkey,
+                                      const MHD_gnutls_datum_t * raw_key,
+                                      MHD_gnutls_x509_crt_fmt_t type);
+int MHD__gnutls_x509_privkey_to_gkey (MHD_gnutls_privkey * privkey,
+                                  MHD_gnutls_x509_privkey_t);
diff --git a/src/daemon/https/tls/pkix_asn1_tab.c b/src/daemon/https/tls/pkix_asn1_tab.c
index e8471bfd..30b5ddd1 100644
--- a/src/daemon/https/tls/pkix_asn1_tab.c
+++ b/src/daemon/https/tls/pkix_asn1_tab.c
@@ -4,7 +4,7 @@
 
 #include <libtasn1.h>
 
-const ASN1_ARRAY_TYPE pkix_asn1_tab[] = {
+const ASN1_ARRAY_TYPE MHD_pkix_asn1_tab[] = {
   {"PKIX1", 536875024, 0},
   {0, 1073741836, 0},
   {"id-ce", 1879048204, 0},
diff --git a/src/daemon/https/tls/x509_b64.c b/src/daemon/https/tls/x509_b64.c
index d4100bc9..b19e301f 100644
--- a/src/daemon/https/tls/x509_b64.c
+++ b/src/daemon/https/tls/x509_b64.c
@@ -142,7 +142,7 @@ decode (uint8_t * result, const opaque * data)
  * The result_size is the return value
  */
 int
-_gnutls_base64_encode (const uint8_t * data, size_t data_size,
+MHD__gnutls_base64_encode (const uint8_t * data, size_t data_size,
                        uint8_t ** result)
 {
   unsigned int i, j;
@@ -151,7 +151,7 @@ _gnutls_base64_encode (const uint8_t * data, size_t data_size,
 
   ret = B64SIZE (data_size);
 
-  (*result) = gnutls_malloc (ret + 1);
+  (*result) = MHD_gnutls_malloc (ret + 1);
   if ((*result) == NULL)
     return GNUTLS_E_MEMORY_ERROR;
 
@@ -160,7 +160,7 @@ _gnutls_base64_encode (const uint8_t * data, size_t data_size,
       tmp = encode (tmpres, &data[i], data_size - i);
       if (tmp == -1)
         {
-          gnutls_free ((*result));
+          MHD_gnutls_free ((*result));
           return GNUTLS_E_MEMORY_ERROR;
         }
       memcpy (&(*result)[j], tmpres, tmp);
@@ -174,8 +174,8 @@ _gnutls_base64_encode (const uint8_t * data, size_t data_size,
         do { \
         what+=size; \
         if (what > ret) { \
-                gnutls_assert(); \
-                gnutls_free( (*result)); *result = NULL; \
+                MHD_gnutls_assert(); \
+                MHD_gnutls_free( (*result)); *result = NULL; \
                 return GNUTLS_E_INTERNAL_ERROR; \
         } \
         } while(0)
@@ -184,7 +184,7 @@ _gnutls_base64_encode (const uint8_t * data, size_t data_size,
  * The result_size (including the null terminator) is the return value.
  */
 int
-_gnutls_fbase64_encode (const char *msg, const uint8_t * data,
+MHD__gnutls_fbase64_encode (const char *msg, const uint8_t * data,
                         int data_size, uint8_t ** result)
 {
   int i, ret, tmp, j;
@@ -197,7 +197,7 @@ _gnutls_fbase64_encode (const char *msg, const uint8_t * data,
 
   if (msglen > 50)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_BASE64_ENCODING_ERROR;
     }
 
@@ -217,10 +217,10 @@ _gnutls_fbase64_encode (const char *msg, const uint8_t * data,
 
   ret = B64FSIZE (msglen, data_size);
 
-  (*result) = gnutls_calloc (1, ret + 1);
+  (*result) = MHD_gnutls_calloc (1, ret + 1);
   if ((*result) == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
@@ -236,8 +236,8 @@ _gnutls_fbase64_encode (const char *msg, const uint8_t * data,
       tmp = encode (tmpres, &data[i], data_size - i);
       if (tmp == -1)
         {
-          gnutls_assert ();
-          gnutls_free ((*result));
+          MHD_gnutls_assert ();
+          MHD_gnutls_free ((*result));
           *result = NULL;
           return GNUTLS_E_BASE64_ENCODING_ERROR;
         }
@@ -302,26 +302,26 @@ _gnutls_fbase64_encode (const char *msg, const uint8_t * data,
   *
   **/
 int
-MHD_gtls_pem_base64_encode (const char *msg, const gnutls_datum_t * data,
+MHD_gtls_pem_base64_encode (const char *msg, const MHD_gnutls_datum_t * data,
                             char *result, size_t * result_size)
 {
   opaque *ret;
   int size;
 
-  size = _gnutls_fbase64_encode (msg, data->data, data->size, &ret);
+  size = MHD__gnutls_fbase64_encode (msg, data->data, data->size, &ret);
   if (size < 0)
     return size;
 
   if (result == NULL || *result_size < (unsigned) size)
     {
-      gnutls_free (ret);
+      MHD_gnutls_free (ret);
       *result_size = size;
       return GNUTLS_E_SHORT_MEMORY_BUFFER;
     }
   else
     {
       memcpy (result, ret, size);
-      gnutls_free (ret);
+      MHD_gnutls_free (ret);
       *result_size = size - 1;
     }
 
@@ -338,13 +338,13 @@ MHD_gtls_pem_base64_encode (const char *msg, const gnutls_datum_t * data,
   * encoding. This is the encoding used in PEM messages. This function will
   * allocate the required memory to hold the encoded data.
   *
-  * You should use gnutls_free() to free the returned data.
+  * You should use MHD_gnutls_free() to free the returned data.
   *
   **/
 int
 MHD_gtls_pem_base64_encode_alloc (const char *msg,
-                                  const gnutls_datum_t * data,
-                                  gnutls_datum_t * result)
+                                  const MHD_gnutls_datum_t * data,
+                                  MHD_gnutls_datum_t * result)
 {
   opaque *ret;
   int size;
@@ -352,7 +352,7 @@ MHD_gtls_pem_base64_encode_alloc (const char *msg,
   if (result == NULL)
     return GNUTLS_E_INVALID_REQUEST;
 
-  size = _gnutls_fbase64_encode (msg, data->data, data->size, &ret);
+  size = MHD__gnutls_fbase64_encode (msg, data->data, data->size, &ret);
   if (size < 0)
     return size;
 
@@ -366,7 +366,7 @@ MHD_gtls_pem_base64_encode_alloc (const char *msg,
  * The result_size is the return value
  */
 int
-_gnutls_base64_decode (const uint8_t * data, size_t data_size,
+MHD__gnutls_base64_decode (const uint8_t * data, size_t data_size,
                        uint8_t ** result)
 {
   unsigned int i, j;
@@ -374,7 +374,7 @@ _gnutls_base64_decode (const uint8_t * data, size_t data_size,
   uint8_t tmpres[3];
 
   est = ((data_size * 3) / 4) + 1;
-  (*result) = gnutls_malloc (est);
+  (*result) = MHD_gnutls_malloc (est);
   if ((*result) == NULL)
     return GNUTLS_E_MEMORY_ERROR;
 
@@ -384,7 +384,7 @@ _gnutls_base64_decode (const uint8_t * data, size_t data_size,
       tmp = decode (tmpres, &data[i]);
       if (tmp < 0)
         {
-          gnutls_free (*result);
+          MHD_gnutls_free (*result);
           *result = NULL;
           return tmp;
         }
@@ -402,7 +402,7 @@ cpydata (const uint8_t * data, int data_size, uint8_t ** result)
 {
   int i, j;
 
-  (*result) = gnutls_malloc (data_size);
+  (*result) = MHD_gnutls_malloc (data_size);
   if (*result == NULL)
     return GNUTLS_E_MEMORY_ERROR;
 
@@ -424,7 +424,7 @@ cpydata (const uint8_t * data, int data_size, uint8_t ** result)
 #define ENDSTR "-----\n"
 #define ENDSTR2 "-----\r"
 int
-_gnutls_fbase64_decode (const char *header, const opaque * data,
+MHD__gnutls_fbase64_decode (const char *header, const opaque * data,
                         size_t data_size, uint8_t ** result)
 {
   int ret;
@@ -436,16 +436,16 @@ _gnutls_fbase64_decode (const char *header, const opaque * data,
   int kdata_size;
   char pem_header[128];
 
-  mhd_gtls_str_cpy (pem_header, sizeof (pem_header), top);
+  MHD_gtls_str_cpy (pem_header, sizeof (pem_header), top);
   if (header != NULL)
-    mhd_gtls_str_cat (pem_header, sizeof (pem_header), header);
+    MHD_gtls_str_cat (pem_header, sizeof (pem_header), header);
 
-  rdata = memmem (data, data_size, pem_header, strlen (pem_header));
+  rdata = MHD_memmem (data, data_size, pem_header, strlen (pem_header));
 
   if (rdata == NULL)
     {
-      gnutls_assert ();
-      _gnutls_debug_log ("Could not find '%s'\n", pem_header);
+      MHD_gnutls_assert ();
+      MHD__gnutls_debug_log ("Could not find '%s'\n", pem_header);
       return GNUTLS_E_BASE64_UNEXPECTED_HEADER_ERROR;
     }
 
@@ -453,20 +453,20 @@ _gnutls_fbase64_decode (const char *header, const opaque * data,
 
   if (data_size < 4 + strlen (bottom))
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_BASE64_DECODING_ERROR;
     }
 
-  kdata = memmem (rdata, data_size, ENDSTR, sizeof (ENDSTR) - 1);
+  kdata = MHD_memmem (rdata, data_size, ENDSTR, sizeof (ENDSTR) - 1);
   /* allow CR as well.
    */
   if (kdata == NULL)
-    kdata = memmem (rdata, data_size, ENDSTR2, sizeof (ENDSTR2) - 1);
+    kdata = MHD_memmem (rdata, data_size, ENDSTR2, sizeof (ENDSTR2) - 1);
 
   if (kdata == NULL)
     {
-      gnutls_assert ();
-      _gnutls_x509_log ("Could not find '%s'\n", ENDSTR);
+      MHD_gnutls_assert ();
+      MHD__gnutls_x509_log ("Could not find '%s'\n", ENDSTR);
       return GNUTLS_E_BASE64_DECODING_ERROR;
     }
   data_size -= strlen (ENDSTR);
@@ -476,10 +476,10 @@ _gnutls_fbase64_decode (const char *header, const opaque * data,
 
   /* position is now after the ---BEGIN--- headers */
 
-  kdata = memmem (rdata, data_size, bottom, strlen (bottom));
+  kdata = MHD_memmem (rdata, data_size, bottom, strlen (bottom));
   if (kdata == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_BASE64_DECODING_ERROR;
     }
 
@@ -489,7 +489,7 @@ _gnutls_fbase64_decode (const char *header, const opaque * data,
 
   if (rdata_size < 4)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_BASE64_DECODING_ERROR;
     }
 
@@ -497,24 +497,24 @@ _gnutls_fbase64_decode (const char *header, const opaque * data,
 
   if (kdata_size < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return kdata_size;
     }
 
   if (kdata_size < 4)
     {
-      gnutls_assert ();
-      gnutls_free (kdata);
+      MHD_gnutls_assert ();
+      MHD_gnutls_free (kdata);
       return GNUTLS_E_BASE64_DECODING_ERROR;
     }
 
-  if ((ret = _gnutls_base64_decode (kdata, kdata_size, result)) < 0)
+  if ((ret = MHD__gnutls_base64_decode (kdata, kdata_size, result)) < 0)
     {
-      gnutls_free (kdata);
-      gnutls_assert ();
+      MHD_gnutls_free (kdata);
+      MHD_gnutls_assert ();
       return GNUTLS_E_BASE64_DECODING_ERROR;
     }
-  gnutls_free (kdata);
+  MHD_gnutls_free (kdata);
 
   return ret;
 }
@@ -535,27 +535,27 @@ _gnutls_fbase64_decode (const char *header, const opaque * data,
   **/
 int
 MHD_gtls_pem_base64_decode (const char *header,
-                            const gnutls_datum_t * b64_data,
+                            const MHD_gnutls_datum_t * b64_data,
                             unsigned char *result, size_t * result_size)
 {
   opaque *ret;
   int size;
 
   size =
-    _gnutls_fbase64_decode (header, b64_data->data, b64_data->size, &ret);
+    MHD__gnutls_fbase64_decode (header, b64_data->data, b64_data->size, &ret);
   if (size < 0)
     return size;
 
   if (result == NULL || *result_size < (unsigned) size)
     {
-      gnutls_free (ret);
+      MHD_gnutls_free (ret);
       *result_size = size;
       return GNUTLS_E_SHORT_MEMORY_BUFFER;
     }
   else
     {
       memcpy (result, ret, size);
-      gnutls_free (ret);
+      MHD_gnutls_free (ret);
       *result_size = size;
     }
 
@@ -574,13 +574,13 @@ MHD_gtls_pem_base64_decode (const char *header,
   * "-----BEGIN header" and decode only this part. Otherwise it will decode the
   * first PEM packet found.
   *
-  * You should use gnutls_free() to free the returned data.
+  * You should use MHD_gnutls_free() to free the returned data.
   *
   **/
 int
 MHD_gtls_pem_base64_decode_alloc (const char *header,
-                                  const gnutls_datum_t * b64_data,
-                                  gnutls_datum_t * result)
+                                  const MHD_gnutls_datum_t * b64_data,
+                                  MHD_gnutls_datum_t * result)
 {
   opaque *ret;
   int size;
@@ -589,7 +589,7 @@ MHD_gtls_pem_base64_decode_alloc (const char *header,
     return GNUTLS_E_INVALID_REQUEST;
 
   size =
-    _gnutls_fbase64_decode (header, b64_data->data, b64_data->size, &ret);
+    MHD__gnutls_fbase64_decode (header, b64_data->data, b64_data->size, &ret);
   if (size < 0)
     return size;
 
diff --git a/src/daemon/https/tls/x509_b64.h b/src/daemon/https/tls/x509_b64.h
index d079ebc6..8638420b 100644
--- a/src/daemon/https/tls/x509_b64.h
+++ b/src/daemon/https/tls/x509_b64.h
@@ -22,13 +22,13 @@
  *
  */
 
-int _gnutls_base64_encode (const uint8_t * data, size_t data_size,
+int MHD__gnutls_base64_encode (const uint8_t * data, size_t data_size,
                            uint8_t ** result);
-int _gnutls_fbase64_encode (const char *msg, const uint8_t * data,
+int MHD__gnutls_fbase64_encode (const char *msg, const uint8_t * data,
                             int data_size, uint8_t ** result);
-int _gnutls_base64_decode (const uint8_t * data, size_t data_size,
+int MHD__gnutls_base64_decode (const uint8_t * data, size_t data_size,
                            uint8_t ** result);
-int _gnutls_fbase64_decode (const char *header, const uint8_t * data,
+int MHD__gnutls_fbase64_decode (const char *header, const uint8_t * data,
                             size_t data_size, uint8_t ** result);
 
 #define B64SIZE( data_size) ((data_size%3==0)?((data_size*4)/3):(4+((data_size/3)*4)))