156 files changed, 9547 insertions, 9587 deletions

diff --git a/src/daemon/connection.c b/src/daemon/connection.c
index 08e9367c..9c37a5c0 100644
--- a/src/daemon/connection.c
+++ b/src/daemon/connection.c
@@ -1632,7 +1632,7 @@ MHD_connection_handle_write (struct MHD_Connection *connection)
 #if HTTPS_SUPPORT
           if (connection->daemon->options & MHD_USE_SSL)
             {
-              ret = MHD_gnutls_record_send (connection->tls_session,
+              ret = MHD__gnutls_record_send (connection->tls_session,
                                             &connection->response->data
                                             [connection->
                                              response_write_position -
diff --git a/src/daemon/connection_https.c b/src/daemon/connection_https.c
index e9a2226f..622c2564 100644
--- a/src/daemon/connection_https.c
+++ b/src/daemon/connection_https.c
@@ -99,7 +99,7 @@ MHD_tls_connection_close (struct MHD_Connection *connection,
                               enum MHD_RequestTerminationCode
                               termination_code)
 {
-  MHD_gnutls_bye (connection->tls_session, GNUTLS_SHUT_WR);
+  MHD__gnutls_bye (connection->tls_session, GNUTLS_SHUT_WR);
   connection->tls_session->internals.read_eof = 1;
   SHUTDOWN (connection->socket_fd, SHUT_RDWR);
   CLOSE (connection->socket_fd);
@@ -211,7 +211,7 @@ MHD_tls_connection_handle_read (struct MHD_Connection *connection)
       if (connection->state == MHD_TLS_CONNECTION_INIT ||
           connection->state == MHD_TLS_HELLO_REQUEST)
         {
-          ret = MHD_gnutls_handshake (connection->tls_session);
+          ret = MHD__gnutls_handshake (connection->tls_session);
           if (ret == 0)
             {
               /* set connection state to enable HTTP processing */
@@ -249,10 +249,10 @@ MHD_tls_connection_handle_read (struct MHD_Connection *connection)
 
     case GNUTLS_ALERT:
       /*
-       * this call of mhd_gtls_recv_int expects 0 bytes read.
+       * this call of MHD_gtls_recv_int expects 0 bytes read.
        * done to decrypt alert message
        */
-      mhd_gtls_recv_int (connection->tls_session, GNUTLS_ALERT,
+      MHD_gtls_recv_int (connection->tls_session, GNUTLS_ALERT,
                          GNUTLS_HANDSHAKE_FINISHED, 0, 0);
 
       /* CLOSE_NOTIFY */
@@ -269,7 +269,7 @@ MHD_tls_connection_handle_read (struct MHD_Connection *connection)
 #if HAVE_MESSAGES
           MHD_DLOG (connection->daemon,
                     "Received TLS alert: %s\n",
-                    MHD_gnutls_alert_get_name ((int) connection->tls_session->
+                    MHD__gnutls_alert_get_name ((int) connection->tls_session->
                                                internals.last_alert));
 #endif
           return MHD_YES;
diff --git a/src/daemon/daemon.c b/src/daemon/daemon.c
index 77dcf990..860d3b1f 100644
--- a/src/daemon/daemon.c
+++ b/src/daemon/daemon.c
@@ -67,12 +67,12 @@
 
 #if HTTPS_SUPPORT
 /**
- * Note: code duplication with code in gnutls_priority.c 
+ * Note: code duplication with code in MHD_gnutls_priority.c 
  *
  * @return 0
  */
 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;
 
@@ -98,7 +98,7 @@ recv_tls_adapter (struct MHD_Connection* connection,
                   void *other,
                   size_t i)
 {
-  return MHD_gnutls_record_recv(connection->tls_session,
+  return MHD__gnutls_record_recv(connection->tls_session,
                                 other, i);
 }
 
@@ -115,7 +115,7 @@ send_tls_adapter (struct MHD_Connection* connection,
                   const void *other, 
                     size_t i)
 {
-  return MHD_gnutls_record_send(connection->tls_session, 
+  return MHD__gnutls_record_send(connection->tls_session, 
                                 other, i);
 }
 
@@ -128,8 +128,8 @@ send_tls_adapter (struct MHD_Connection* connection,
 static int
 MHD_init_daemon_certificate (struct MHD_Daemon *daemon)
 {
-  gnutls_datum_t key;
-  gnutls_datum_t cert;
+  MHD_gnutls_datum_t key;
+  MHD_gnutls_datum_t cert;
 
   /* certificate & key loaded from memory */
   if (daemon->https_mem_cert && daemon->https_mem_key)
@@ -139,7 +139,7 @@ MHD_init_daemon_certificate (struct MHD_Daemon *daemon)
       cert.data = (unsigned char *) daemon->https_mem_cert;
       cert.size = strlen (daemon->https_mem_cert);
 
-      return MHD_gnutls_certificate_set_x509_key_mem (daemon->x509_cred,
+      return MHD__gnutls_certificate_set_x509_key_mem (daemon->x509_cred,
                                                       &cert, &key,
                                                       GNUTLS_X509_FMT_PEM);
     }
@@ -160,15 +160,15 @@ MHD_TLS_init (struct MHD_Daemon *daemon)
   switch (daemon->cred_type)
     {
     case MHD_GNUTLS_CRD_ANON:
-      if ( (0 != MHD_gnutls_anon_allocate_server_credentials (&daemon->anon_cred)) ||
-           (0 != MHD_gnutls_dh_params_init (&daemon->dh_params)) )
+      if ( (0 != MHD__gnutls_anon_allocate_server_credentials (&daemon->anon_cred)) ||
+           (0 != MHD__gnutls_dh_params_init (&daemon->dh_params)) )
         return GNUTLS_E_MEMORY_ERROR;        
-      MHD_gnutls_dh_params_generate2 (daemon->dh_params, 1024);
-      MHD_gnutls_anon_set_server_dh_params (daemon->anon_cred,
+      MHD__gnutls_dh_params_generate2 (daemon->dh_params, 1024);
+      MHD__gnutls_anon_set_server_dh_params (daemon->anon_cred,
                                             daemon->dh_params);
       return 0;
     case MHD_GNUTLS_CRD_CERTIFICATE:
-      if (0 != MHD_gnutls_certificate_allocate_credentials (&daemon->x509_cred))
+      if (0 != MHD__gnutls_certificate_allocate_credentials (&daemon->x509_cred))
         return GNUTLS_E_MEMORY_ERROR;
       return MHD_init_daemon_certificate (daemon);
     default:
@@ -491,21 +491,21 @@ MHD_accept_connection (struct MHD_Daemon *daemon)
       connection->send_cls = &send_tls_adapter;
       connection->state = MHD_TLS_CONNECTION_INIT;
       MHD_set_https_calbacks (connection);    
-      MHD_gnutls_init (&connection->tls_session, GNUTLS_SERVER);
-      MHD_gnutls_priority_set (connection->tls_session, connection->daemon->priority_cache);
+      MHD__gnutls_init (&connection->tls_session, GNUTLS_SERVER);
+      MHD__gnutls_priority_set (connection->tls_session, connection->daemon->priority_cache);
       switch (connection->daemon->cred_type)
         {
           /* set needed credentials for certificate authentication. */
         case MHD_GNUTLS_CRD_CERTIFICATE:
-          MHD_gnutls_credentials_set (connection->tls_session,
+          MHD__gnutls_credentials_set (connection->tls_session,
                                       MHD_GNUTLS_CRD_CERTIFICATE,
                                       connection->daemon->x509_cred);
           break;
         case MHD_GNUTLS_CRD_ANON:
           /* set needed credentials for anonymous authentication. */
-          MHD_gnutls_credentials_set (connection->tls_session, MHD_GNUTLS_CRD_ANON,
+          MHD__gnutls_credentials_set (connection->tls_session, MHD_GNUTLS_CRD_ANON,
                                       connection->daemon->anon_cred);
-          MHD_gnutls_dh_set_prime_bits (connection->tls_session, 1024);
+          MHD__gnutls_dh_set_prime_bits (connection->tls_session, 1024);
           break;
         default:
 #if HAVE_MESSAGES
@@ -515,12 +515,12 @@ MHD_accept_connection (struct MHD_Daemon *daemon)
 #endif
           abort();
         }
-      MHD_gnutls_transport_set_ptr (connection->tls_session,
-                                    (gnutls_transport_ptr_t) connection);
-      MHD_gnutls_transport_set_pull_function(connection->tls_session, 
-                                             (mhd_gtls_pull_func) &recv_param_adapter);
-      MHD_gnutls_transport_set_push_function(connection->tls_session, 
-                                             (mhd_gtls_push_func) &send_param_adapter);  
+      MHD__gnutls_transport_set_ptr (connection->tls_session,
+                                    (MHD_gnutls_transport_ptr_t) connection);
+      MHD__gnutls_transport_set_pull_function(connection->tls_session, 
+                                             (MHD_gtls_pull_func) &recv_param_adapter);
+      MHD__gnutls_transport_set_push_function(connection->tls_session, 
+                                             (MHD_gtls_push_func) &send_param_adapter);  
     }
 #endif
 
@@ -583,7 +583,7 @@ MHD_cleanup_connections (struct MHD_Daemon *daemon)
           MHD_pool_destroy (pos->pool);
 #if HTTPS_SUPPORT
           if (pos->tls_session != NULL)            
-            MHD_gnutls_deinit (pos->tls_session);
+            MHD__gnutls_deinit (pos->tls_session);
 #endif
           free (pos->addr);
           free (pos);
@@ -859,10 +859,10 @@ MHD_start_daemon_va (unsigned int options,
 #if HTTPS_SUPPORT
   if (options & MHD_USE_SSL)
     {
-      /* lock gnutls_global mutex since it uses reference counting */
-      pthread_mutex_lock (&gnutls_init_mutex);
-      MHD_gnutls_global_init ();
-      pthread_mutex_unlock (&gnutls_init_mutex);
+      /* lock MHD_gnutls_global mutex since it uses reference counting */
+      pthread_mutex_lock (&MHD_gnutls_init_mutex);
+      MHD__gnutls_global_init ();
+      pthread_mutex_unlock (&MHD_gnutls_init_mutex);
       /* set default priorities */
       MHD_tls_set_default_priority (&retVal->priority_cache, "", NULL);
       retVal->cred_type = MHD_GNUTLS_CRD_CERTIFICATE;
@@ -1104,15 +1104,15 @@ MHD_stop_daemon (struct MHD_Daemon *daemon)
 #if HTTPS_SUPPORT
   if (daemon->options & MHD_USE_SSL)
     {
-      MHD_gnutls_priority_deinit (daemon->priority_cache);
+      MHD__gnutls_priority_deinit (daemon->priority_cache);
       if (daemon->x509_cred)
-        MHD_gnutls_certificate_free_credentials (daemon->x509_cred);
+        MHD__gnutls_certificate_free_credentials (daemon->x509_cred);
       if (daemon->anon_cred)
-        MHD_gnutls_anon_free_server_credentials (daemon->anon_cred);
-      /* lock gnutls_global mutex since it uses reference counting */
-      pthread_mutex_lock (&gnutls_init_mutex);
-      MHD_gnutls_global_deinit ();
-      pthread_mutex_unlock (&gnutls_init_mutex);
+        MHD__gnutls_anon_free_server_credentials (daemon->anon_cred);
+      /* lock MHD_gnutls_global mutex since it uses reference counting */
+      pthread_mutex_lock (&MHD_gnutls_init_mutex);
+      MHD__gnutls_global_deinit ();
+      pthread_mutex_unlock (&MHD_gnutls_init_mutex);
     }
 #endif
   free (daemon);
diff --git a/src/daemon/https/gnutls.h b/src/daemon/https/gnutls.h
index ed939584..fb1b280f 100644
--- a/src/daemon/https/gnutls.h
+++ b/src/daemon/https/gnutls.h
@@ -60,7 +60,7 @@ extern "C"
   {
     GNUTLS_PARAMS_RSA_EXPORT = 1,
     GNUTLS_PARAMS_DH
-  } gnutls_params_type_t;
+  } MHD_gnutls_params_type_t;
 
   /* exported for other gnutls headers. This is the maximum number of
    * algorithms (ciphers, kx or macs).
@@ -72,13 +72,13 @@ extern "C"
   {
     GNUTLS_SERVER = 1,
     GNUTLS_CLIENT
-  } gnutls_connection_end_t;
+  } MHD_gnutls_connection_end_t;
 
   typedef enum
   {
     GNUTLS_AL_WARNING = 1,
     GNUTLS_AL_FATAL
-  } gnutls_alert_level_t;
+  } MHD_gnutls_alert_level_t;
 
   typedef enum
   {
@@ -110,7 +110,7 @@ extern "C"
     GNUTLS_A_CERTIFICATE_UNOBTAINABLE = 111,
     GNUTLS_A_UNRECOGNIZED_NAME = 112,
     GNUTLS_A_UNKNOWN_PSK_IDENTITY = 115,
-  } gnutls_alert_description_t;
+  } MHD_gnutls_alert_description_t;
 
   typedef enum
   { GNUTLS_HANDSHAKE_HELLO_REQUEST = 0,
@@ -124,7 +124,7 @@ extern "C"
     GNUTLS_HANDSHAKE_CLIENT_KEY_EXCHANGE = 16,
     GNUTLS_HANDSHAKE_FINISHED = 20,
     GNUTLS_HANDSHAKE_SUPPLEMENTAL = 23
-  } gnutls_handshake_description_t;
+  } MHD_gnutls_handshake_description_t;
 
   typedef enum
   {
@@ -141,26 +141,26 @@ extern "C"
     GNUTLS_CERT_SIGNER_NOT_FOUND = 64,
     GNUTLS_CERT_SIGNER_NOT_CA = 128,
     GNUTLS_CERT_INSECURE_ALGORITHM = 256
-  } gnutls_certificate_status_t;
+  } MHD_gnutls_certificate_status_t;
 
   typedef enum
   {
     GNUTLS_CERT_IGNORE,
     GNUTLS_CERT_REQUEST = 1,
     GNUTLS_CERT_REQUIRE
-  } gnutls_certificate_request_t;
+  } MHD_gnutls_certificate_request_t;
 
   typedef enum
   {
     GNUTLS_SHUT_RDWR = 0,
     GNUTLS_SHUT_WR = 1
-  } gnutls_close_request_t;
+  } MHD_gnutls_close_request_t;
 
   typedef enum
   {
     GNUTLS_X509_FMT_DER,
     GNUTLS_X509_FMT_PEM
-  } gnutls_x509_crt_fmt_t;
+  } MHD_gnutls_x509_crt_fmt_t;
 
   typedef enum
   {
@@ -173,92 +173,92 @@ extern "C"
     GNUTLS_SIGN_RSA_SHA256,
     GNUTLS_SIGN_RSA_SHA384,
     GNUTLS_SIGN_RSA_SHA512
-  } gnutls_sign_algorithm_t;
+  } MHD_gnutls_sign_algorithm_t;
 
 /* If you want to change this, then also change the define in
- * gnutls_int.h, and recompile.
+ * MHD_gnutls_int.h, and recompile.
  */
-  typedef void *gnutls_transport_ptr_t;
+  typedef void *MHD_gnutls_transport_ptr_t;
 
   struct MHD_gtls_session_int;
-  typedef struct MHD_gtls_session_int *mhd_gtls_session_t;
+  typedef struct MHD_gtls_session_int *MHD_gtls_session_t;
 
   struct MHD_gtls_dh_params_int;
-  typedef struct MHD_gtls_dh_params_int *mhd_gtls_dh_params_t;
+  typedef struct MHD_gtls_dh_params_int *MHD_gtls_dh_params_t;
 
   struct MHD_gtls_x509_privkey_int;     /* XXX ugly. */
-  typedef struct MHD_gtls_x509_privkey_int *mhd_gtls_rsa_params_t;      /* XXX ugly. */
+  typedef struct MHD_gtls_x509_privkey_int *MHD_gtls_rsa_params_t;      /* XXX ugly. */
 
   struct MHD_gtls_priority_st;
-  typedef struct MHD_gtls_priority_st *gnutls_priority_t;
+  typedef struct MHD_gtls_priority_st *MHD_gnutls_priority_t;
 
   typedef struct
   {
     unsigned char *data;
     unsigned int size;
-  } gnutls_datum_t;
+  } MHD_gnutls_datum_t;
 
 
-  typedef struct gnutls_params_st
+  typedef struct MHD_gnutls_params_st
   {
-    gnutls_params_type_t type;
+    MHD_gnutls_params_type_t type;
     union params
     {
-      mhd_gtls_dh_params_t dh;
-      mhd_gtls_rsa_params_t rsa_export;
+      MHD_gtls_dh_params_t dh;
+      MHD_gtls_rsa_params_t rsa_export;
     } params;
     int deinit;
-  } gnutls_params_st;
+  } MHD_gnutls_params_st;
 
-  typedef int gnutls_params_function (mhd_gtls_session_t,
-                                      gnutls_params_type_t,
-                                      gnutls_params_st *);
+  typedef int MHD_gnutls_params_function (MHD_gtls_session_t,
+                                      MHD_gnutls_params_type_t,
+                                      MHD_gnutls_params_st *);
 
 /* internal functions */
-  int MHD_gnutls_global_init (void);
-  void MHD_gnutls_global_deinit (void);
+  int MHD__gnutls_global_init (void);
+  void MHD__gnutls_global_deinit (void);
 
-  int MHD_gnutls_init (mhd_gtls_session_t * session,
-                       gnutls_connection_end_t con_end);
-  void MHD_gnutls_deinit (mhd_gtls_session_t session);
+  int MHD__gnutls_init (MHD_gtls_session_t * session,
+                       MHD_gnutls_connection_end_t con_end);
+  void MHD__gnutls_deinit (MHD_gtls_session_t session);
 
-  int MHD_gnutls_bye (mhd_gtls_session_t session, gnutls_close_request_t how);
-  int MHD_gnutls_handshake (mhd_gtls_session_t session);
-  int MHD_gnutls_rehandshake (mhd_gtls_session_t session);
+  int MHD__gnutls_bye (MHD_gtls_session_t session, MHD_gnutls_close_request_t how);
+  int MHD__gnutls_handshake (MHD_gtls_session_t session);
+  int MHD__gnutls_rehandshake (MHD_gtls_session_t session);
 
-  int mhd_gtls_handshake_client (mhd_gtls_session_t session);
+  int MHD_gtls_handshake_client (MHD_gtls_session_t session);
 
-  gnutls_alert_description_t gnutls_alert_get (mhd_gtls_session_t session);
-  int MHD_gnutls_alert_send (mhd_gtls_session_t session,
-                             gnutls_alert_level_t level,
-                             gnutls_alert_description_t desc);
-  int MHD_gnutls_alert_send_appropriate (mhd_gtls_session_t session, int err);
-  const char *MHD_gnutls_alert_get_name (gnutls_alert_description_t alert);
+  MHD_gnutls_alert_description_t MHD_gnutls_alert_get (MHD_gtls_session_t session);
+  int MHD__gnutls_alert_send (MHD_gtls_session_t session,
+                             MHD_gnutls_alert_level_t level,
+                             MHD_gnutls_alert_description_t desc);
+  int MHD__gnutls_alert_send_appropriate (MHD_gtls_session_t session, int err);
+  const char *MHD__gnutls_alert_get_name (MHD_gnutls_alert_description_t alert);
 
-  enum MHD_GNUTLS_CompressionMethod MHD_gtls_compression_get (mhd_gtls_session_t
+  enum MHD_GNUTLS_CompressionMethod MHD_gtls_compression_get (MHD_gtls_session_t
                                                         session);
-//  enum MHD_GNUTLS_CipherAlgorithm gnutls_cipher_get (mhd_gtls_session_t session);
-//  enum MHD_GNUTLS_KeyExchangeAlgorithm gnutls_kx_get (mhd_gtls_session_t session);
-//  enum MHD_GNUTLS_HashAlgorithm gnutls_mac_get (mhd_gtls_session_t session);
-//  enum MHD_GNUTLS_CertificateType gnutls_certificate_type_get (mhd_gtls_session_t
+//  enum MHD_GNUTLS_CipherAlgorithm MHD_gnutls_cipher_get (MHD_gtls_session_t session);
+//  enum MHD_GNUTLS_KeyExchangeAlgorithm MHD_gnutls_kx_get (MHD_gtls_session_t session);
+//  enum MHD_GNUTLS_HashAlgorithm MHD_gnutls_mac_get (MHD_gtls_session_t session);
+//  enum MHD_GNUTLS_CertificateType MHD_gnutls_certificate_type_get (MHD_gtls_session_t
 //                                                         session);
 
-  size_t MHD_gnutls_cipher_get_key_size (enum MHD_GNUTLS_CipherAlgorithm
+  size_t MHD__gnutls_cipher_get_key_size (enum MHD_GNUTLS_CipherAlgorithm
                                          algorithm);
-  size_t MHD_gnutls_mac_get_key_size (enum MHD_GNUTLS_HashAlgorithm
+  size_t MHD__gnutls_mac_get_key_size (enum MHD_GNUTLS_HashAlgorithm
                                       algorithm);
 
 /* the name of the specified algorithms */
-  const char *MHD_gnutls_cipher_get_name (enum MHD_GNUTLS_CipherAlgorithm
+  const char *MHD__gnutls_cipher_get_name (enum MHD_GNUTLS_CipherAlgorithm
                                           algorithm);
-  const char *MHD_gnutls_mac_get_name (enum MHD_GNUTLS_HashAlgorithm
+  const char *MHD__gnutls_mac_get_name (enum MHD_GNUTLS_HashAlgorithm
                                        algorithm);
   const char *MHD_gtls_compression_get_name (enum
                                                MHD_GNUTLS_CompressionMethod
                                                algorithm);
-  const char *MHD_gnutls_kx_get_name (enum MHD_GNUTLS_KeyExchangeAlgorithm
+  const char *MHD__gnutls_kx_get_name (enum MHD_GNUTLS_KeyExchangeAlgorithm
                                       algorithm);
-  const char *MHD_gnutls_certificate_type_get_name (enum
+  const char *MHD__gnutls_certificate_type_get_name (enum
                                                     MHD_GNUTLS_CertificateType
                                                     type);
 
@@ -286,38 +286,38 @@ extern "C"
   void MHD_gtls_perror (int error);
   const char *MHD_gtls_strerror (int error);
 
-  void MHD_gtls_handshake_set_private_extensions (mhd_gtls_session_t session,
+  void MHD_gtls_handshake_set_private_extensions (MHD_gtls_session_t session,
                                                   int allow);
-    gnutls_handshake_description_t
-    MHD_gtls_handshake_get_last_out (mhd_gtls_session_t session);
-    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_out (MHD_gtls_session_t session);
+    MHD_gnutls_handshake_description_t
+    MHD_gtls_handshake_get_last_in (MHD_gtls_session_t session);
 
 /*
  * Record layer functions.
  */
-  ssize_t MHD_gnutls_record_send (mhd_gtls_session_t session,
+  ssize_t MHD__gnutls_record_send (MHD_gtls_session_t session,
                                   const void *data, size_t sizeofdata);
-  ssize_t MHD_gnutls_record_recv (mhd_gtls_session_t session, void *data,
+  ssize_t MHD__gnutls_record_recv (MHD_gtls_session_t session, void *data,
                                   size_t sizeofdata);
 
   /* provides extra compatibility */
-  void MHD_gtls_record_disable_padding (mhd_gtls_session_t session);
-  size_t MHD_gtls_record_check_pending (mhd_gtls_session_t session);
+  void MHD_gtls_record_disable_padding (MHD_gtls_session_t session);
+  size_t MHD_gtls_record_check_pending (MHD_gtls_session_t session);
 
-  int MHD_gnutls_record_get_direction (mhd_gtls_session_t session);
-  size_t MHD_gnutls_record_get_max_size (mhd_gtls_session_t session);
-  ssize_t MHD_gnutls_record_set_max_size (mhd_gtls_session_t session,
+  int MHD__gnutls_record_get_direction (MHD_gtls_session_t session);
+  size_t MHD__gnutls_record_get_max_size (MHD_gtls_session_t session);
+  ssize_t MHD__gnutls_record_set_max_size (MHD_gtls_session_t session,
                                           size_t size);
 
 
-  int MHD_gnutls_prf (mhd_gtls_session_t session,
+  int MHD__gnutls_prf (MHD_gtls_session_t session,
                       size_t label_size, const char *label,
                       int server_random_first,
                       size_t extra_size, const char *extra,
                       size_t outsize, char *out);
 
-  int MHD_gnutls_prf_raw (mhd_gtls_session_t session,
+  int 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, char *out);
@@ -328,13 +328,13 @@ extern "C"
   typedef enum
   {
     GNUTLS_NAME_DNS = 1
-  } gnutls_server_name_type_t;
+  } MHD_gnutls_server_name_type_t;
 
-  int MHD_gnutls_server_name_set (mhd_gtls_session_t session,
-                                  gnutls_server_name_type_t type,
+  int 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 MHD_gnutls_server_name_get (mhd_gtls_session_t session,
+  int MHD__gnutls_server_name_get (MHD_gtls_session_t session,
                                   void *data, size_t * data_length,
                                   unsigned int *type, unsigned int indx);
 
@@ -343,437 +343,437 @@ extern "C"
    */
 
   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);
 
-  typedef int (*gnutls_oprfi_callback_func) (mhd_gtls_session_t session,
+  typedef int (*MHD_gnutls_oprfi_callback_func) (MHD_gtls_session_t session,
                                              void *userdata,
                                              size_t oprfi_len,
                                              const unsigned char *in_oprfi,
                                              unsigned char *out_oprfi);
 
   void
-    MHD_gtls_oprfi_enable_server (mhd_gtls_session_t session,
-                                  gnutls_oprfi_callback_func cb,
+    MHD_gtls_oprfi_enable_server (MHD_gtls_session_t session,
+                                  MHD_gnutls_oprfi_callback_func cb,
                                   void *userdata);
 
   /* Supplemental data, RFC 4680. */
   typedef enum
   {
     GNUTLS_SUPPLEMENTAL_USER_MAPPING_DATA = 0
-  } gnutls_supplemental_data_format_type_t;
+  } MHD_gnutls_supplemental_data_format_type_t;
 
   const char *MHD_gtls_supplemental_get_name
-    (gnutls_supplemental_data_format_type_t type);
+    (MHD_gnutls_supplemental_data_format_type_t type);
 
-  int MHD_gnutls_cipher_set_priority (mhd_gtls_session_t session,
+  int MHD__gnutls_cipher_set_priority (MHD_gtls_session_t session,
                                       const int *list);
-  int MHD_gnutls_mac_set_priority (mhd_gtls_session_t session,
+  int MHD__gnutls_mac_set_priority (MHD_gtls_session_t session,
                                    const int *list);
-  int MHD_gnutls_compression_set_priority (mhd_gtls_session_t session,
+  int MHD__gnutls_compression_set_priority (MHD_gtls_session_t session,
                                            const int *list);
-  int MHD_gnutls_kx_set_priority (mhd_gtls_session_t session,
+  int MHD__gnutls_kx_set_priority (MHD_gtls_session_t session,
                                   const int *list);
-  int MHD_gnutls_protocol_set_priority (mhd_gtls_session_t session,
+  int 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,
+  int MHD__gnutls_certificate_type_set_priority (MHD_gtls_session_t session,
                                                 const int *list);
 
-  int MHD_tls_set_default_priority (gnutls_priority_t *, const char *priority,
+  int MHD_tls_set_default_priority (MHD_gnutls_priority_t *, const char *priority,
                                     const char **err_pos);
-  void MHD_gnutls_priority_deinit (gnutls_priority_t);
+  void MHD__gnutls_priority_deinit (MHD_gnutls_priority_t);
 
-  int MHD_gnutls_priority_set (mhd_gtls_session_t session, gnutls_priority_t);
-  int MHD_gnutls_priority_set_direct (mhd_gtls_session_t session,
+  int MHD__gnutls_priority_set (MHD_gtls_session_t session, MHD_gnutls_priority_t);
+  int MHD__gnutls_priority_set_direct (MHD_gtls_session_t session,
                                       const char *priority,
                                       const char **err_pos);
 
 /* get the currently used protocol version */
-  enum MHD_GNUTLS_Protocol MHD_gnutls_protocol_get_version (mhd_gtls_session_t
+  enum MHD_GNUTLS_Protocol MHD__gnutls_protocol_get_version (MHD_gtls_session_t
                                                             session);
 
-  const char *MHD_gnutls_protocol_get_name (enum MHD_GNUTLS_Protocol version);
+  const char *MHD__gnutls_protocol_get_name (enum MHD_GNUTLS_Protocol version);
 
 /*
  * get/set session
  */
-//  int gnutls_session_set_data (mhd_gtls_session_t session,
+//  int MHD_gnutls_session_set_data (MHD_gtls_session_t session,
 //                               const void *session_data,
 //                               size_t session_data_size);
-//  int gnutls_session_get_data (mhd_gtls_session_t session, void *session_data,
+//  int MHD_gnutls_session_get_data (MHD_gtls_session_t session, void *session_data,
 //                               size_t * session_data_size);
-//  int gnutls_session_get_data2 (mhd_gtls_session_t session,
-//                                gnutls_datum_t * data);
+//  int MHD_gnutls_session_get_data2 (MHD_gtls_session_t session,
+//                                MHD_gnutls_datum_t * data);
 
-  int MHD_gtls_session_get_id (mhd_gtls_session_t session, void *session_id,
+  int MHD_gtls_session_get_id (MHD_gtls_session_t session, void *session_id,
                                size_t * session_id_size);
 
 /* returns security values.
  * Do not use them unless you know what you're doing.
  */
-  const void *MHD_gtls_session_get_server_random (mhd_gtls_session_t session);
-  const void *MHD_gtls_session_get_client_random (mhd_gtls_session_t session);
-  const void *MHD_gtls_session_get_master_secret (mhd_gtls_session_t session);
+  const void *MHD_gtls_session_get_server_random (MHD_gtls_session_t session);
+  const void *MHD_gtls_session_get_client_random (MHD_gtls_session_t session);
+  const void *MHD_gtls_session_get_master_secret (MHD_gtls_session_t session);
 
-  int MHD_gtls_session_is_resumed (mhd_gtls_session_t session);
+  int MHD_gtls_session_is_resumed (MHD_gtls_session_t session);
 
-  typedef int (*gnutls_handshake_post_client_hello_func) (mhd_gtls_session_t);
+  typedef int (*MHD_gnutls_handshake_post_client_hello_func) (MHD_gtls_session_t);
   void
-    MHD_gnutls_handshake_set_post_client_hello_function (mhd_gtls_session_t,
-                                                         gnutls_handshake_post_client_hello_func);
+    MHD__gnutls_handshake_set_post_client_hello_function (MHD_gtls_session_t,
+                                                         MHD_gnutls_handshake_post_client_hello_func);
 
-  void MHD_gnutls_handshake_set_max_packet_length (mhd_gtls_session_t session,
+  void MHD__gnutls_handshake_set_max_packet_length (MHD_gtls_session_t session,
                                                    size_t max);
 
 /*
  * Functions for setting/clearing credentials
  */
-  void MHD_gnutls_credentials_clear (mhd_gtls_session_t session);
+  void MHD__gnutls_credentials_clear (MHD_gtls_session_t session);
 
 /*
  * cred is a structure defined by the kx algorithm
  */
-  int MHD_gnutls_credentials_set (mhd_gtls_session_t session,
+  int MHD__gnutls_credentials_set (MHD_gtls_session_t session,
                                   enum MHD_GNUTLS_CredentialsType type,
                                   void *cred);
 
-/* Credential structures - used in MHD_gnutls_credentials_set(); */
-  struct mhd_gtls_certificate_credentials_st;
-  typedef struct mhd_gtls_certificate_credentials_st
-    *mhd_gtls_cert_credentials_t;
-  typedef mhd_gtls_cert_credentials_t mhd_gtls_cert_server_credentials;
-  typedef mhd_gtls_cert_credentials_t mhd_gtls_cert_client_credentials;
+/* Credential structures - used in MHD__gnutls_credentials_set(); */
+  struct MHD_gtls_certificate_credentials_st;
+  typedef struct MHD_gtls_certificate_credentials_st
+    *MHD_gtls_cert_credentials_t;
+  typedef MHD_gtls_cert_credentials_t MHD_gtls_cert_server_credentials;
+  typedef MHD_gtls_cert_credentials_t MHD_gtls_cert_client_credentials;
 
-  typedef struct mhd_gtls_anon_server_credentials_st
-    *mhd_gtls_anon_server_credentials_t;
-  typedef struct mhd_gtls_anon_client_credentials_st
-    *mhd_gtls_anon_client_credentials_t;
+  typedef struct MHD_gtls_anon_server_credentials_st
+    *MHD_gtls_anon_server_credentials_t;
+  typedef struct MHD_gtls_anon_client_credentials_st
+    *MHD_gtls_anon_client_credentials_t;
 
   void
-    MHD_gnutls_anon_free_server_credentials
-    (mhd_gtls_anon_server_credentials_t sc);
+    MHD__gnutls_anon_free_server_credentials
+    (MHD_gtls_anon_server_credentials_t sc);
   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);
 
   void
-    MHD_gnutls_anon_set_server_dh_params (mhd_gtls_anon_server_credentials_t
+    MHD__gnutls_anon_set_server_dh_params (MHD_gtls_anon_server_credentials_t
                                           res,
-                                          mhd_gtls_dh_params_t dh_params);
+                                          MHD_gtls_dh_params_t dh_params);
 
   void
-    MHD_gnutls_anon_set_server_params_function
-    (mhd_gtls_anon_server_credentials_t res, gnutls_params_function * func);
+    MHD__gnutls_anon_set_server_params_function
+    (MHD_gtls_anon_server_credentials_t res, MHD_gnutls_params_function * func);
 
   void
-    MHD_gnutls_anon_free_client_credentials
-    (mhd_gtls_anon_client_credentials_t sc);
+    MHD__gnutls_anon_free_client_credentials
+    (MHD_gtls_anon_client_credentials_t sc);
   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);
 
-  void MHD_gnutls_certificate_free_credentials (mhd_gtls_cert_credentials_t
+  void MHD__gnutls_certificate_free_credentials (MHD_gtls_cert_credentials_t
                                                 sc);
   int
-    MHD_gnutls_certificate_allocate_credentials (mhd_gtls_cert_credentials_t
+    MHD__gnutls_certificate_allocate_credentials (MHD_gtls_cert_credentials_t
                                                  * res);
 
-  void MHD_gnutls_certificate_free_keys (mhd_gtls_cert_credentials_t sc);
-  void MHD_gnutls_certificate_free_cas (mhd_gtls_cert_credentials_t sc);
-  void MHD_gnutls_certificate_free_ca_names (mhd_gtls_cert_credentials_t sc);
-  void MHD_gnutls_certificate_free_crls (mhd_gtls_cert_credentials_t sc);
+  void MHD__gnutls_certificate_free_keys (MHD_gtls_cert_credentials_t sc);
+  void MHD__gnutls_certificate_free_cas (MHD_gtls_cert_credentials_t sc);
+  void MHD__gnutls_certificate_free_ca_names (MHD_gtls_cert_credentials_t sc);
+  void MHD__gnutls_certificate_free_crls (MHD_gtls_cert_credentials_t sc);
 
-  void MHD_gnutls_certificate_set_dh_params (mhd_gtls_cert_credentials_t res,
-                                             mhd_gtls_dh_params_t dh_params);
+  void MHD__gnutls_certificate_set_dh_params (MHD_gtls_cert_credentials_t res,
+                                             MHD_gtls_dh_params_t dh_params);
   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);
-  void MHD_gnutls_certificate_set_verify_flags (mhd_gtls_cert_credentials_t
+  void MHD__gnutls_certificate_set_verify_flags (MHD_gtls_cert_credentials_t
                                                 res, unsigned int flags);
-  void MHD_gnutls_certificate_set_verify_limits (mhd_gtls_cert_credentials_t
+  void MHD__gnutls_certificate_set_verify_limits (MHD_gtls_cert_credentials_t
                                                  res, unsigned int max_bits,
                                                  unsigned int max_depth);
 
-  int MHD_gnutls_certificate_set_x509_trust_file (mhd_gtls_cert_credentials_t
+  int MHD__gnutls_certificate_set_x509_trust_file (MHD_gtls_cert_credentials_t
                                                   res, const char *CAFILE,
-                                                  gnutls_x509_crt_fmt_t type);
-  int MHD_gnutls_certificate_set_x509_trust_mem (mhd_gtls_cert_credentials_t
+                                                  MHD_gnutls_x509_crt_fmt_t type);
+  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);
+                                                 const MHD_gnutls_datum_t * CA,
+                                                 MHD_gnutls_x509_crt_fmt_t type);
 
-  int MHD_gnutls_certificate_set_x509_crl_file (mhd_gtls_cert_credentials_t
+  int MHD__gnutls_certificate_set_x509_crl_file (MHD_gtls_cert_credentials_t
                                                 res, const char *crlfile,
-                                                gnutls_x509_crt_fmt_t type);
-  int MHD_gnutls_certificate_set_x509_crl_mem (mhd_gtls_cert_credentials_t
+                                                MHD_gnutls_x509_crt_fmt_t type);
+  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);
+                                               const MHD_gnutls_datum_t * CRL,
+                                               MHD_gnutls_x509_crt_fmt_t type);
 
   /*
    * CERTFILE is an x509 certificate in PEM form.
    * KEYFILE is a pkcs-1 private key in PEM form (for RSA keys).
    */
-  int MHD_gnutls_certificate_set_x509_key_file (mhd_gtls_cert_credentials_t
+  int MHD__gnutls_certificate_set_x509_key_file (MHD_gtls_cert_credentials_t
                                                 res, const char *CERTFILE,
                                                 const char *KEYFILE,
-                                                gnutls_x509_crt_fmt_t type);
-  int MHD_gnutls_certificate_set_x509_key_mem (mhd_gtls_cert_credentials_t
+                                                MHD_gnutls_x509_crt_fmt_t type);
+  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);
+                                               const MHD_gnutls_datum_t * CERT,
+                                               const MHD_gnutls_datum_t * KEY,
+                                               MHD_gnutls_x509_crt_fmt_t type);
 
-  void MHD_gnutls_certificate_send_x509_rdn_sequence (mhd_gtls_session_t
+  void MHD__gnutls_certificate_send_x509_rdn_sequence (MHD_gtls_session_t
                                                       session, int status);
 
 /*
  * New functions to allow setting already parsed X.509 stuff.
  */
   struct MHD_gtls_x509_privkey_int;
-  typedef struct MHD_gtls_x509_privkey_int *gnutls_x509_privkey_t;
+  typedef struct MHD_gtls_x509_privkey_int *MHD_gnutls_x509_privkey_t;
 
-  struct gnutls_x509_crl_int;
-  typedef struct gnutls_x509_crl_int *gnutls_x509_crl_t;
+  struct MHD_gnutls_x509_crl_int;
+  typedef struct MHD_gnutls_x509_crl_int *MHD_gnutls_x509_crl_t;
 
-  struct gnutls_x509_crt_int;
-  typedef struct gnutls_x509_crt_int *gnutls_x509_crt_t;
+  struct MHD_gnutls_x509_crt_int;
+  typedef struct MHD_gnutls_x509_crt_int *MHD_gnutls_x509_crt_t;
 
-//  int gnutls_certificate_set_x509_key (mhd_gtls_cert_credentials_t res,
-//                                       gnutls_x509_crt_t * cert_list,
+//  int MHD_gnutls_certificate_set_x509_key (MHD_gtls_cert_credentials_t res,
+//                                       MHD_gnutls_x509_crt_t * cert_list,
 //                                       int cert_list_size,
-//                                       gnutls_x509_privkey_t key);
-//  int gnutls_certificate_set_x509_trust (mhd_gtls_cert_credentials_t res,
-//                                         gnutls_x509_crt_t * ca_list,
+//                                       MHD_gnutls_x509_privkey_t key);
+//  int MHD_gnutls_certificate_set_x509_trust (MHD_gtls_cert_credentials_t res,
+//                                         MHD_gnutls_x509_crt_t * ca_list,
 //                                         int ca_list_size);
-//  int gnutls_certificate_set_x509_crl (mhd_gtls_cert_credentials_t res,
-//                                       gnutls_x509_crl_t * crl_list,
+//  int MHD_gnutls_certificate_set_x509_crl (MHD_gtls_cert_credentials_t res,
+//                                       MHD_gnutls_x509_crl_t * crl_list,
 //                                       int crl_list_size);
 
 /* global state functions
  */
 
 
-  typedef void *(*gnutls_alloc_function) (size_t);
-  typedef void *(*gnutls_calloc_function) (size_t, size_t);
-  typedef int (*gnutls_is_secure_function) (const void *);
-  typedef void (*gnutls_free_function) (void *);
-  typedef void *(*gnutls_realloc_function) (void *, size_t);
+  typedef void *(*MHD_gnutls_alloc_function) (size_t);
+  typedef void *(*MHD_gnutls_calloc_function) (size_t, size_t);
+  typedef int (*MHD_gnutls_is_secure_function) (const void *);
+  typedef void (*MHD_gnutls_free_function) (void *);
+  typedef void *(*MHD_gnutls_realloc_function) (void *, size_t);
 
   extern void
-    MHD_gtls_global_set_mem_functions (gnutls_alloc_function gt_alloc_func,
-                                       gnutls_alloc_function
+    MHD_gtls_global_set_mem_functions (MHD_gnutls_alloc_function gt_alloc_func,
+                                       MHD_gnutls_alloc_function
                                        gt_secure_alloc_func,
-                                       gnutls_is_secure_function
+                                       MHD_gnutls_is_secure_function
                                        gt_is_secure_func,
-                                       gnutls_realloc_function
+                                       MHD_gnutls_realloc_function
                                        gt_realloc_func,
-                                       gnutls_free_function gt_free_func);
+                                       MHD_gnutls_free_function gt_free_func);
 
 /* For use in callbacks */
-  extern gnutls_alloc_function gnutls_malloc;
-  extern gnutls_alloc_function gnutls_secure_malloc;
-  extern gnutls_realloc_function gnutls_realloc;
-  extern gnutls_calloc_function gnutls_calloc;
-  extern gnutls_free_function gnutls_free;
+  extern MHD_gnutls_alloc_function MHD_gnutls_malloc;
+  extern MHD_gnutls_alloc_function MHD_gnutls_secure_malloc;
+  extern MHD_gnutls_realloc_function MHD_gnutls_realloc;
+  extern MHD_gnutls_calloc_function MHD_gnutls_calloc;
+  extern MHD_gnutls_free_function MHD_gnutls_free;
 
-  extern char *(*gnutls_strdup) (const char *);
+  extern char *(*MHD_gnutls_strdup) (const char *);
 
-  typedef void (*gnutls_log_func) (int, const char *);
-  void MHD_gtls_global_set_log_function (gnutls_log_func log_func);
+  typedef void (*MHD_gnutls_log_func) (int, const char *);
+  void MHD_gtls_global_set_log_function (MHD_gnutls_log_func log_func);
   void MHD_gtls_global_set_log_level (int level);
 
 /*
  * Diffie Hellman parameter handling.
  */
-  int MHD_gnutls_dh_params_init (mhd_gtls_dh_params_t * dh_params);
-  void MHD_gnutls_dh_params_deinit (mhd_gtls_dh_params_t dh_params);
-  int MHD_gnutls_dh_params_generate2 (mhd_gtls_dh_params_t params,
+  int MHD__gnutls_dh_params_init (MHD_gtls_dh_params_t * dh_params);
+  void MHD__gnutls_dh_params_deinit (MHD_gtls_dh_params_t dh_params);
+  int MHD__gnutls_dh_params_generate2 (MHD_gtls_dh_params_t params,
                                       unsigned int bits);
 
 
 /* RSA params */
-  int MHD_gnutls_rsa_params_init (mhd_gtls_rsa_params_t * rsa_params);
-  void MHD_gnutls_rsa_params_deinit (mhd_gtls_rsa_params_t rsa_params);
-  int MHD_gnutls_rsa_params_generate2 (mhd_gtls_rsa_params_t params,
+  int MHD__gnutls_rsa_params_init (MHD_gtls_rsa_params_t * rsa_params);
+  void MHD__gnutls_rsa_params_deinit (MHD_gtls_rsa_params_t rsa_params);
+  int MHD__gnutls_rsa_params_generate2 (MHD_gtls_rsa_params_t params,
                                        unsigned int bits);
 
 
 /*
  * Session stuff
  */
-  typedef ssize_t (*mhd_gtls_pull_func) (gnutls_transport_ptr_t, void *,
+  typedef ssize_t (*MHD_gtls_pull_func) (MHD_gnutls_transport_ptr_t, void *,
                                          size_t);
-  typedef ssize_t (*mhd_gtls_push_func) (gnutls_transport_ptr_t, const void *,
+  typedef ssize_t (*MHD_gtls_push_func) (MHD_gnutls_transport_ptr_t, const void *,
                                          size_t);
-  void MHD_gnutls_transport_set_ptr (mhd_gtls_session_t session,
-                                     gnutls_transport_ptr_t ptr);
-  void MHD_gnutls_transport_set_ptr2 (mhd_gtls_session_t session,
-                                      gnutls_transport_ptr_t recv_ptr,
-                                      gnutls_transport_ptr_t send_ptr);
+  void MHD__gnutls_transport_set_ptr (MHD_gtls_session_t session,
+                                     MHD_gnutls_transport_ptr_t ptr);
+  void MHD__gnutls_transport_set_ptr2 (MHD_gtls_session_t session,
+                                      MHD_gnutls_transport_ptr_t recv_ptr,
+                                      MHD_gnutls_transport_ptr_t send_ptr);
 
-  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);
 
 
-  void MHD_gnutls_transport_set_push_function (mhd_gtls_session_t session,
-                                               mhd_gtls_push_func push_func);
-  void MHD_gnutls_transport_set_pull_function (mhd_gtls_session_t session,
-                                               mhd_gtls_pull_func pull_func);
+  void MHD__gnutls_transport_set_push_function (MHD_gtls_session_t session,
+                                               MHD_gtls_push_func push_func);
+  void MHD__gnutls_transport_set_pull_function (MHD_gtls_session_t session,
+                                               MHD_gtls_pull_func pull_func);
 
-  void MHD_gnutls_transport_set_errno (mhd_gtls_session_t session, int err);
-  void MHD_gnutls_transport_set_global_errno (int err);
+  void MHD__gnutls_transport_set_errno (MHD_gtls_session_t session, int err);
+  void MHD__gnutls_transport_set_global_errno (int err);
 
 /*
  * session specific
  */
-  void MHD_gnutls_session_set_ptr (mhd_gtls_session_t session, void *ptr);
-  void *MHD_gtls_session_get_ptr (mhd_gtls_session_t session);
+  void MHD__gnutls_session_set_ptr (MHD_gtls_session_t session, void *ptr);
+  void *MHD_gtls_session_get_ptr (MHD_gtls_session_t session);
 
 /*
  * this function returns the hash of the given data.
  */
-  int MHD_gnutls_fingerprint (enum MHD_GNUTLS_HashAlgorithm algo,
-                              const gnutls_datum_t * data, void *result,
+  int MHD__gnutls_fingerprint (enum MHD_GNUTLS_HashAlgorithm algo,
+                              const MHD_gnutls_datum_t * data, void *result,
                               size_t * result_size);
 
 /*
  *  SRP
  */
-//  typedef struct gnutls_srp_server_credentials_st
-//    *gnutls_srp_server_credentials_t;
-//  typedef struct gnutls_srp_client_credentials_st
-//    *gnutls_srp_client_credentials_t;
+//  typedef struct MHD_gnutls_srp_server_credentials_st
+//    *MHD_gnutls_srp_server_credentials_t;
+//  typedef struct MHD_gnutls_srp_client_credentials_st
+//    *MHD_gnutls_srp_client_credentials_t;
 //
-//  void gnutls_srp_free_client_credentials (gnutls_srp_client_credentials_t
+//  void MHD_gnutls_srp_free_client_credentials (MHD_gnutls_srp_client_credentials_t
 //                                           sc);
-//  int gnutls_srp_allocate_client_credentials (gnutls_srp_client_credentials_t
+//  int MHD_gnutls_srp_allocate_client_credentials (MHD_gnutls_srp_client_credentials_t
 //                                              * sc);
-//  int gnutls_srp_set_client_credentials (gnutls_srp_client_credentials_t res,
+//  int MHD_gnutls_srp_set_client_credentials (MHD_gnutls_srp_client_credentials_t res,
 //                                         const char *username,
 //                                         const char *password);
 //
-//  void gnutls_srp_free_server_credentials (gnutls_srp_server_credentials_t
+//  void MHD_gnutls_srp_free_server_credentials (MHD_gnutls_srp_server_credentials_t
 //                                           sc);
-//  int gnutls_srp_allocate_server_credentials (gnutls_srp_server_credentials_t
+//  int MHD_gnutls_srp_allocate_server_credentials (MHD_gnutls_srp_server_credentials_t
 //                                              * sc);
-//  int gnutls_srp_set_server_credentials_file (gnutls_srp_server_credentials_t
+//  int MHD_gnutls_srp_set_server_credentials_file (MHD_gnutls_srp_server_credentials_t
 //                                              res, const char *password_file,
 //                                              const char *password_conf_file);
 //
-//  const char *gnutls_srp_server_get_username (mhd_gtls_session_t session);
+//  const char *MHD_gnutls_srp_server_get_username (MHD_gtls_session_t session);
 //
-//  extern int gnutls_srp_verifier (const char *username,
+//  extern int MHD_gnutls_srp_verifier (const char *username,
 //                                  const char *password,
-//                                  const gnutls_datum_t * salt,
-//                                  const gnutls_datum_t * generator,
-//                                  const gnutls_datum_t * prime,
-//                                  gnutls_datum_t * res);
+//                                  const MHD_gnutls_datum_t * salt,
+//                                  const MHD_gnutls_datum_t * generator,
+//                                  const MHD_gnutls_datum_t * prime,
+//                                  MHD_gnutls_datum_t * res);
 //
 ///* The static parameters defined in draft-ietf-tls-srp-05
-// * Those should be used as input to gnutls_srp_verifier().
+// * Those should be used as input to MHD_gnutls_srp_verifier().
 // */
-//  extern const gnutls_datum_t gnutls_srp_2048_group_prime;
-//  extern const gnutls_datum_t gnutls_srp_2048_group_generator;
+//  extern const MHD_gnutls_datum_t MHD_gnutls_srp_2048_group_prime;
+//  extern const MHD_gnutls_datum_t MHD_gnutls_srp_2048_group_generator;
 //
-//  extern const gnutls_datum_t gnutls_srp_1536_group_prime;
-//  extern const gnutls_datum_t gnutls_srp_1536_group_generator;
+//  extern const MHD_gnutls_datum_t MHD_gnutls_srp_1536_group_prime;
+//  extern const MHD_gnutls_datum_t MHD_gnutls_srp_1536_group_generator;
 //
-//  extern const gnutls_datum_t gnutls_srp_1024_group_prime;
-//  extern const gnutls_datum_t gnutls_srp_1024_group_generator;
+//  extern const MHD_gnutls_datum_t MHD_gnutls_srp_1024_group_prime;
+//  extern const MHD_gnutls_datum_t MHD_gnutls_srp_1024_group_generator;
 //
-//  typedef int gnutls_srp_server_credentials_function (mhd_gtls_session_t,
+//  typedef int MHD_gnutls_srp_server_credentials_function (MHD_gtls_session_t,
 //                                                      const char *username,
-//                                                      gnutls_datum_t * salt,
-//                                                      gnutls_datum_t *
+//                                                      MHD_gnutls_datum_t * salt,
+//                                                      MHD_gnutls_datum_t *
 //                                                      verifier,
-//                                                      gnutls_datum_t *
+//                                                      MHD_gnutls_datum_t *
 //                                                      generator,
-//                                                      gnutls_datum_t * prime);
+//                                                      MHD_gnutls_datum_t * prime);
 //  void
-//    gnutls_srp_set_server_credentials_function
-//    (gnutls_srp_server_credentials_t cred,
-//     gnutls_srp_server_credentials_function * func);
+//    MHD_gnutls_srp_set_server_credentials_function
+//    (MHD_gnutls_srp_server_credentials_t cred,
+//     MHD_gnutls_srp_server_credentials_function * func);
 //
-//  typedef int gnutls_srp_client_credentials_function (mhd_gtls_session_t,
+//  typedef int MHD_gnutls_srp_client_credentials_function (MHD_gtls_session_t,
 //                                                      char **, char **);
 //  void
-//    gnutls_srp_set_client_credentials_function
-//    (gnutls_srp_client_credentials_t cred,
-//     gnutls_srp_client_credentials_function * func);
+//    MHD_gnutls_srp_set_client_credentials_function
+//    (MHD_gnutls_srp_client_credentials_t cred,
+//     MHD_gnutls_srp_client_credentials_function * func);
 //
-//  int gnutls_srp_base64_encode (const gnutls_datum_t * data, char *result,
+//  int MHD_gnutls_srp_base64_encode (const MHD_gnutls_datum_t * data, char *result,
 //                                size_t * result_size);
-//  int gnutls_srp_base64_encode_alloc (const gnutls_datum_t * data,
-//                                      gnutls_datum_t * result);
+//  int MHD_gnutls_srp_base64_encode_alloc (const MHD_gnutls_datum_t * data,
+//                                      MHD_gnutls_datum_t * result);
 //
-//  int gnutls_srp_base64_decode (const gnutls_datum_t * b64_data, char *result,
+//  int MHD_gnutls_srp_base64_decode (const MHD_gnutls_datum_t * b64_data, char *result,
 //                                size_t * result_size);
-//  int gnutls_srp_base64_decode_alloc (const gnutls_datum_t * b64_data,
-//                                      gnutls_datum_t * result);
+//  int MHD_gnutls_srp_base64_decode_alloc (const MHD_gnutls_datum_t * b64_data,
+//                                      MHD_gnutls_datum_t * result);
 
 /*
  * PSK stuff
  */
-//  typedef struct gnutls_psk_server_credentials_st
-//    *gnutls_psk_server_credentials_t;
-//  typedef struct gnutls_psk_client_credentials_st
-//    *gnutls_psk_client_credentials_t;
+//  typedef struct MHD_gnutls_psk_server_credentials_st
+//    *MHD_gnutls_psk_server_credentials_t;
+//  typedef struct MHD_gnutls_psk_client_credentials_st
+//    *MHD_gnutls_psk_client_credentials_t;
 //
-//  typedef enum gnutls_psk_key_flags
+//  typedef enum MHD_gnutls_psk_key_flags
 //  {
 //    GNUTLS_PSK_KEY_RAW = 0,
 //    GNUTLS_PSK_KEY_HEX
-//  } gnutls_psk_key_flags;
+//  } MHD_gnutls_psk_key_flags;
 //
-//  void gnutls_psk_free_client_credentials (gnutls_psk_client_credentials_t
+//  void MHD_gnutls_psk_free_client_credentials (MHD_gnutls_psk_client_credentials_t
 //                                           sc);
-//  int gnutls_psk_allocate_client_credentials (gnutls_psk_client_credentials_t
+//  int MHD_gnutls_psk_allocate_client_credentials (MHD_gnutls_psk_client_credentials_t
 //                                              * sc);
-//  int gnutls_psk_set_client_credentials (gnutls_psk_client_credentials_t res,
+//  int MHD_gnutls_psk_set_client_credentials (MHD_gnutls_psk_client_credentials_t res,
 //                                         const char *username,
-//                                         const gnutls_datum_t * key,
-//                                         gnutls_psk_key_flags format);
+//                                         const MHD_gnutls_datum_t * key,
+//                                         MHD_gnutls_psk_key_flags format);
 //
-//  void gnutls_psk_free_server_credentials (gnutls_psk_server_credentials_t
+//  void MHD_gnutls_psk_free_server_credentials (MHD_gnutls_psk_server_credentials_t
 //                                           sc);
-//  int gnutls_psk_allocate_server_credentials (gnutls_psk_server_credentials_t
+//  int MHD_gnutls_psk_allocate_server_credentials (MHD_gnutls_psk_server_credentials_t
 //                                              * sc);
-//  int gnutls_psk_set_server_credentials_file (gnutls_psk_server_credentials_t
+//  int MHD_gnutls_psk_set_server_credentials_file (MHD_gnutls_psk_server_credentials_t
 //                                              res, const char *password_file);
 //
-//  const char *gnutls_psk_server_get_username (mhd_gtls_session_t session);
+//  const char *MHD_gnutls_psk_server_get_username (MHD_gtls_session_t session);
 //
-//  typedef int gnutls_psk_server_credentials_function (mhd_gtls_session_t,
+//  typedef int MHD_gnutls_psk_server_credentials_function (MHD_gtls_session_t,
 //                                                      const char *username,
-//                                                      gnutls_datum_t * key);
+//                                                      MHD_gnutls_datum_t * key);
 //  void
-//    gnutls_psk_set_server_credentials_function
-//    (gnutls_psk_server_credentials_t cred,
-//     gnutls_psk_server_credentials_function * func);
+//    MHD_gnutls_psk_set_server_credentials_function
+//    (MHD_gnutls_psk_server_credentials_t cred,
+//     MHD_gnutls_psk_server_credentials_function * func);
 //
-//  typedef int gnutls_psk_client_credentials_function (mhd_gtls_session_t,
+//  typedef int MHD_gnutls_psk_client_credentials_function (MHD_gtls_session_t,
 //                                                      char **username,
-//                                                      gnutls_datum_t * key);
+//                                                      MHD_gnutls_datum_t * key);
 //  void
-//    gnutls_psk_set_client_credentials_function
-//    (gnutls_psk_client_credentials_t cred,
-//     gnutls_psk_client_credentials_function * func);
+//    MHD_gnutls_psk_set_client_credentials_function
+//    (MHD_gnutls_psk_client_credentials_t cred,
+//     MHD_gnutls_psk_client_credentials_function * func);
 //
-//  int gnutls_hex_encode (const gnutls_datum_t * data, char *result,
+//  int MHD_gnutls_hex_encode (const MHD_gnutls_datum_t * data, char *result,
 //                         size_t * result_size);
-//  int gnutls_hex_decode (const gnutls_datum_t * hex_data, char *result,
+//  int MHD_gnutls_hex_decode (const MHD_gnutls_datum_t * hex_data, char *result,
 //                         size_t * result_size);
 //
-//  void gnutls_psk_set_server_dh_params (gnutls_psk_server_credentials_t res,
-//                                        mhd_gtls_dh_params_t dh_params);
+//  void MHD_gnutls_psk_set_server_dh_params (MHD_gnutls_psk_server_credentials_t res,
+//                                        MHD_gtls_dh_params_t dh_params);
 //
-//  void gnutls_psk_set_server_params_function (gnutls_psk_server_credentials_t
+//  void MHD_gnutls_psk_set_server_params_function (MHD_gnutls_psk_server_credentials_t
 //                                              res,
-//                                              gnutls_params_function * func);
+//                                              MHD_gnutls_params_function * func);
 
-  typedef enum gnutls_x509_subject_alt_name_t
+  typedef enum MHD_gnutls_x509_subject_alt_name_t
   {
     GNUTLS_SAN_DNSNAME = 1,
     GNUTLS_SAN_RFC822NAME,
@@ -783,30 +783,30 @@ extern "C"
     GNUTLS_SAN_DN,
     /* The following are "virtual" subject alternative name types, in
        that they are represented by an otherName value and an OID.
-       Used by gnutls_x509_crt_get_subject_alt_othername_oid().  */
+       Used by MHD_gnutls_x509_crt_get_subject_alt_othername_oid().  */
     GNUTLS_SAN_OTHERNAME_XMPP = 1000
-  } gnutls_x509_subject_alt_name_t;
+  } MHD_gnutls_x509_subject_alt_name_t;
 
-  typedef struct gnutls_retr_st
+  typedef struct MHD_gnutls_retr_st
   {
     enum MHD_GNUTLS_CertificateType type;
     union cert
     {
-      gnutls_x509_crt_t *x509;
+      MHD_gnutls_x509_crt_t *x509;
     } cert;
     unsigned int ncerts;
 
     union key
     {
-      gnutls_x509_privkey_t x509;
+      MHD_gnutls_x509_privkey_t x509;
     } key;
 
     unsigned int deinit_all;    /* if non zero all keys will be deinited */
-  } gnutls_retr_st;
+  } MHD_gnutls_retr_st;
 
-  typedef int gnutls_certificate_client_retrieve_function (mhd_gtls_session_t,
+  typedef int MHD_gnutls_certificate_client_retrieve_function (MHD_gtls_session_t,
                                                            const
-                                                           gnutls_datum_t *
+                                                           MHD_gnutls_datum_t *
                                                            req_ca_rdn,
                                                            int nreqs,
                                                            const
@@ -815,115 +815,115 @@ extern "C"
                                                            *pk_algos,
                                                            int
                                                            pk_algos_length,
-                                                           gnutls_retr_st *);
+                                                           MHD_gnutls_retr_st *);
 
-  typedef int gnutls_certificate_server_retrieve_function (mhd_gtls_session_t,
-                                                           gnutls_retr_st *);
+  typedef int MHD_gnutls_certificate_server_retrieve_function (MHD_gtls_session_t,
+                                                           MHD_gnutls_retr_st *);
 
   /*
    * Functions that allow auth_info_t structures handling
    */
-  enum MHD_GNUTLS_CredentialsType MHD_gtls_auth_get_type (mhd_gtls_session_t
+  enum MHD_GNUTLS_CredentialsType 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);
   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);
 
   /*
    * DH
    */
-  void MHD_gnutls_dh_set_prime_bits (mhd_gtls_session_t session,
+  void MHD__gnutls_dh_set_prime_bits (MHD_gtls_session_t session,
                                      unsigned int bits);
-  int MHD_gnutls_dh_get_secret_bits (mhd_gtls_session_t session);
-  int MHD_gnutls_dh_get_peers_public_bits (mhd_gtls_session_t session);
-  int MHD_gnutls_dh_get_prime_bits (mhd_gtls_session_t session);
+  int MHD__gnutls_dh_get_secret_bits (MHD_gtls_session_t session);
+  int MHD__gnutls_dh_get_peers_public_bits (MHD_gtls_session_t session);
+  int MHD__gnutls_dh_get_prime_bits (MHD_gtls_session_t session);
 
-  int MHD_gnutls_dh_get_group (mhd_gtls_session_t session,
-                               gnutls_datum_t * raw_gen,
-                               gnutls_datum_t * raw_prime);
-  int MHD_gnutls_dh_get_pubkey (mhd_gtls_session_t session,
-                                gnutls_datum_t * raw_key);
+  int MHD__gnutls_dh_get_group (MHD_gtls_session_t session,
+                               MHD_gnutls_datum_t * raw_gen,
+                               MHD_gnutls_datum_t * raw_prime);
+  int MHD__gnutls_dh_get_pubkey (MHD_gtls_session_t session,
+                                MHD_gnutls_datum_t * raw_key);
 
   /*
    * RSA
    */
-  int MHD_gtls_rsa_export_get_pubkey (mhd_gtls_session_t session,
-                                      gnutls_datum_t * exponent,
-                                      gnutls_datum_t * modulus);
-  int MHD_gtls_rsa_export_get_modulus_bits (mhd_gtls_session_t session);
+  int MHD_gtls_rsa_export_get_pubkey (MHD_gtls_session_t session,
+                                      MHD_gnutls_datum_t * exponent,
+                                      MHD_gnutls_datum_t * modulus);
+  int MHD_gtls_rsa_export_get_modulus_bits (MHD_gtls_session_t session);
 
   /* External signing callback.  Experimental. */
-  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);
 
-  void MHD_gtls_sign_callback_set (mhd_gtls_session_t session,
-                                   gnutls_sign_func sign_func,
+  void MHD_gtls_sign_callback_set (MHD_gtls_session_t session,
+                                   MHD_gnutls_sign_func sign_func,
                                    void *userdata);
-    gnutls_sign_func MHD_gtls_sign_callback_get (mhd_gtls_session_t session,
+    MHD_gnutls_sign_func MHD_gtls_sign_callback_get (MHD_gtls_session_t session,
                                                  void **userdata);
 
   /* These are set on the credentials structure.
    */
   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);
   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);
 
-  void MHD_gtls_certificate_server_set_request (mhd_gtls_session_t session,
-                                                gnutls_certificate_request_t
+  void MHD_gtls_certificate_server_set_request (MHD_gtls_session_t session,
+                                                MHD_gnutls_certificate_request_t
                                                 req);
 
   /* get data from the session */
-  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);
-  const gnutls_datum_t *MHD_gtls_certificate_get_ours (mhd_gtls_session_t
+  const MHD_gnutls_datum_t *MHD_gtls_certificate_get_ours (MHD_gtls_session_t
                                                        session);
 
-  time_t MHD_gtls_certificate_activation_time_peers (mhd_gtls_session_t
+  time_t MHD_gtls_certificate_activation_time_peers (MHD_gtls_session_t
                                                      session);
-  time_t MHD_gtls_certificate_expiration_time_peers (mhd_gtls_session_t
+  time_t MHD_gtls_certificate_expiration_time_peers (MHD_gtls_session_t
                                                      session);
 
-  int MHD_gtls_certificate_client_get_request_status (mhd_gtls_session_t
+  int MHD_gtls_certificate_client_get_request_status (MHD_gtls_session_t
                                                       session);
-  int MHD_gtls_certificate_verify_peers2 (mhd_gtls_session_t session,
+  int MHD_gtls_certificate_verify_peers2 (MHD_gtls_session_t session,
                                           unsigned int *status);
 
   /* this is obsolete (?). */
-  int MHD_gtls_certificate_verify_peers (mhd_gtls_session_t session);
+  int MHD_gtls_certificate_verify_peers (MHD_gtls_session_t session);
 
   int MHD_gtls_pem_base64_encode (const char *msg,
-                                  const gnutls_datum_t * data, char *result,
+                                  const MHD_gnutls_datum_t * data, char *result,
                                   size_t * result_size);
   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);
 
   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);
   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);
 
   //  void
-  //    gnutls_certificate_set_params_function (mhd_gtls_cert_credentials_t
+  //    MHD_gnutls_certificate_set_params_function (MHD_gtls_cert_credentials_t
   //                                            res,
-  //                                            gnutls_params_function * func);
-  //  void gnutls_anon_set_params_function (mhd_gtls_anon_server_credentials_t res,
-  //                                        gnutls_params_function * func);
-  //  void gnutls_psk_set_params_function (gnutls_psk_server_credentials_t res,
-  //                                       gnutls_params_function * func);
+  //                                            MHD_gnutls_params_function * func);
+  //  void MHD_gnutls_anon_set_params_function (MHD_gtls_anon_server_credentials_t res,
+  //                                        MHD_gnutls_params_function * func);
+  //  void MHD_gnutls_psk_set_params_function (MHD_gnutls_psk_server_credentials_t res,
+  //                                       MHD_gnutls_params_function * func);
 
 
   /* key_usage will be an OR of the following values: */
@@ -1002,7 +1002,7 @@ extern "C"
 
 
   /* returned if libextra functionality was requested but
-   * gnutls_global_init_extra() was not called.
+   * MHD_gnutls_global_init_extra() was not called.
    */
 #define GNUTLS_E_INIT_LIBEXTRA -82
 #define GNUTLS_E_LIBRARY_VERSION_MISMATCH -83
diff --git a/src/daemon/https/lgl/Makefile.am b/src/daemon/https/lgl/Makefile.am
index 93423d2d..17a8bafc 100644
--- a/src/daemon/https/lgl/Makefile.am
+++ b/src/daemon/https/lgl/Makefile.am
@@ -14,7 +14,6 @@ liblgl_la_LDFLAGS = -lgcrypt
 liblgl_la_SOURCES = \
 sha1.c sha1.h \
 gc-libgcrypt.c \
-time_r.c \
 rijndael-api-fst.c rijndael-api-fst.h \
 gc-pbkdf2-sha1.c gc.h \
 rijndael-alg-fst.c rijndael-alg-fst.h \
diff --git a/src/daemon/https/lgl/des.c b/src/daemon/https/lgl/des.c
index 4f6c5be0..7bc4c4d0 100644
--- a/src/daemon/https/lgl/des.c
+++ b/src/daemon/https/lgl/des.c
@@ -54,13 +54,13 @@
  *     unsigned char plaintext[8];
  *     unsigned char ciphertext[8];
  *     unsigned char recoverd[8];
- *     gl_des_ctx context;
+ *     MHD_gl_des_ctx context;
  *
  *     // Fill 'key' and 'plaintext' with some data
  *     ....
  *
  *     // Set up the DES encryption context
- *     gl_des_setkey(&context, key);
+ *     MHD_gl_des_setkey(&context, key);
  *
  *     // Encrypt the plaintext
  *     des_ecb_encrypt(&context, plaintext, ciphertext);
@@ -77,20 +77,20 @@
  *     unsigned char plaintext[8];
  *     unsigned char ciphertext[8];
  *     unsigned char recoverd[8];
- *     gl_3des_ctx context;
+ *     MHD_gl_3des_ctx context;
  *
  *     // If you would like to use two 64bit keys, fill 'key1' and'key2'
  *     // then setup the encryption context:
- *     gl_3des_set2keys(&context, key1, key2);
+ *     MHD_gl_3des_set2keys(&context, key1, key2);
  *
  *     // To use three 64bit keys with Triple-DES use:
- *     gl_3des_set3keys(&context, key1, key2, key3);
+ *     MHD_gl_3des_set3keys(&context, key1, key2, key3);
  *
  *     // Encrypting plaintext with Triple-DES
- *     gl_3des_ecb_encrypt(&context, plaintext, ciphertext);
+ *     MHD_gl_3des_ecb_encrypt(&context, plaintext, ciphertext);
  *
  *     // Decrypting ciphertext to recover the plaintext with Triple-DES
- *     gl_3des_ecb_decrypt(&context, ciphertext, recoverd);
+ *     MHD_gl_3des_ecb_decrypt(&context, ciphertext, recoverd);
  */
 
 
@@ -320,7 +320,7 @@ static const unsigned char weak_keys[64][8] = {
 };
 
 bool
-gl_des_is_weak_key (const char *key)
+MHD_gl_des_is_weak_key (const char *key)
 {
   char work[8];
   int i, left, right, middle, cmp_result;
@@ -518,7 +518,7 @@ des_key_schedule (const char *_rawkey, uint32_t * subkey)
 }
 
 void
-gl_des_setkey (gl_des_ctx * ctx, const char *key)
+MHD_gl_des_setkey (MHD_gl_des_ctx * ctx, const char *key)
 {
   int i;
 
@@ -532,18 +532,18 @@ gl_des_setkey (gl_des_ctx * ctx, const char *key)
 }
 
 bool
-gl_des_makekey (gl_des_ctx * ctx, const char *key, size_t keylen)
+MHD_gl_des_makekey (MHD_gl_des_ctx * ctx, const char *key, size_t keylen)
 {
   if (keylen != 8)
     return false;
 
-  gl_des_setkey (ctx, key);
+  MHD_gl_des_setkey (ctx, key);
 
-  return !gl_des_is_weak_key (key);
+  return !MHD_gl_des_is_weak_key (key);
 }
 
 void
-gl_des_ecb_crypt (gl_des_ctx * ctx, const char *_from, char *_to, int mode)
+MHD_gl_des_ecb_crypt (MHD_gl_des_ctx * ctx, const char *_from, char *_to, int mode)
 {
   const unsigned char *from = (const unsigned char *) _from;
   unsigned char *to = (unsigned char *) _to;
@@ -565,7 +565,7 @@ READ_64BIT_DATA (from, left, right)
     FINAL_PERMUTATION (right, work, left) WRITE_64BIT_DATA (to, right, left)}
 
 void
-gl_3des_set2keys (gl_3des_ctx * ctx, const char *key1, const char *key2)
+MHD_gl_3des_set2keys (MHD_gl_3des_ctx * ctx, const char *key1, const char *key2)
 {
   int i;
 
@@ -589,7 +589,7 @@ gl_3des_set2keys (gl_3des_ctx * ctx, const char *key1, const char *key2)
 }
 
 void
-gl_3des_set3keys (gl_3des_ctx * ctx, const char *key1,
+MHD_gl_3des_set3keys (MHD_gl_3des_ctx * ctx, const char *key1,
                   const char *key2, const char *key3)
 {
   int i;
@@ -612,7 +612,7 @@ gl_3des_set3keys (gl_3des_ctx * ctx, const char *key1,
 }
 
 void
-gl_3des_ecb_crypt (gl_3des_ctx * ctx, const char *_from, char *_to, int mode)
+MHD_gl_3des_ecb_crypt (MHD_gl_3des_ctx * ctx, const char *_from, char *_to, int mode)
 {
   const unsigned char *from = (const unsigned char *) _from;
   unsigned char *to = (unsigned char *) _to;
@@ -650,13 +650,13 @@ READ_64BIT_DATA (from, left, right)
     FINAL_PERMUTATION (right, work, left) WRITE_64BIT_DATA (to, right, left)}
 
 bool
-gl_3des_makekey (gl_3des_ctx * ctx, const char *key, size_t keylen)
+MHD_gl_3des_makekey (MHD_gl_3des_ctx * ctx, const char *key, size_t keylen)
 {
   if (keylen != 24)
     return false;
 
-  gl_3des_set3keys (ctx, key, key + 8, key + 16);
+  MHD_gl_3des_set3keys (ctx, key, key + 8, key + 16);
 
-  return !(gl_des_is_weak_key (key)
-           || gl_des_is_weak_key (key + 8) || gl_des_is_weak_key (key + 16));
+  return !(MHD_gl_des_is_weak_key (key)
+           || MHD_gl_des_is_weak_key (key + 8) || MHD_gl_des_is_weak_key (key + 16));
 }
diff --git a/src/daemon/https/lgl/des.h b/src/daemon/https/lgl/des.h
index a80ede84..4d9eb20c 100644
--- a/src/daemon/https/lgl/des.h
+++ b/src/daemon/https/lgl/des.h
@@ -34,7 +34,7 @@ typedef struct
 {
   uint32_t encrypt_subkeys[32];
   uint32_t decrypt_subkeys[32];
-} gl_des_ctx;
+} MHD_gl_des_ctx;
 
 /*
  * Encryption/Decryption context of Triple-DES
@@ -43,11 +43,11 @@ typedef struct
 {
   uint32_t encrypt_subkeys[96];
   uint32_t decrypt_subkeys[96];
-} gl_3des_ctx;
+} MHD_gl_3des_ctx;
 
 /* Check whether the 8 byte key is weak.  Does not check the parity
  * bits of the key but simple ignore them. */
-extern bool gl_des_is_weak_key (const char *key);
+extern bool MHD_gl_des_is_weak_key (const char *key);
 
 /*
  * DES
@@ -57,20 +57,20 @@ extern bool gl_des_is_weak_key (const char *key);
 /* Fill a DES context CTX with subkeys calculated from 64bit KEY.
  * Does not check parity bits, but simply ignore them.  Does not check
  * for weak keys. */
-extern void gl_des_setkey (gl_des_ctx * ctx, const char *key);
+extern void MHD_gl_des_setkey (MHD_gl_des_ctx * ctx, const char *key);
 
 /* Fill a DES context CTX with subkeys calculated from 64bit KEY, with
  * weak key checking.  Does not check parity bits, but simply ignore
  * them. */
-extern bool gl_des_makekey (gl_des_ctx * ctx, const char *key, size_t keylen);
+extern bool MHD_gl_des_makekey (MHD_gl_des_ctx * ctx, const char *key, size_t keylen);
 
 /* Electronic Codebook Mode DES encryption/decryption of data
  * according to 'mode'. */
 extern void
-gl_des_ecb_crypt (gl_des_ctx * ctx, const char *from, char *to, int mode);
+MHD_gl_des_ecb_crypt (MHD_gl_des_ctx * ctx, const char *from, char *to, int mode);
 
-#define gl_des_ecb_encrypt(ctx, from, to)  gl_des_ecb_crypt(ctx, from, to, 0)
-#define gl_des_ecb_decrypt(ctx, from, to)  gl_des_ecb_crypt(ctx, from, to, 1)
+#define MHD_gl_des_ecb_encrypt(ctx, from, to)  MHD_gl_des_ecb_crypt(ctx, from, to, 0)
+#define MHD_gl_des_ecb_decrypt(ctx, from, to)  MHD_gl_des_ecb_crypt(ctx, from, to, 1)
 
 /* Triple-DES
  * ----------
@@ -80,7 +80,7 @@ gl_des_ecb_crypt (gl_des_ctx * ctx, const char *from, char *to, int mode);
  * 64bit keys in KEY1 and KEY2.  Does not check the parity bits of the
  * keys, but simply ignore them.  Does not check for weak keys. */
 extern void
-gl_3des_set2keys (gl_3des_ctx * ctx, const char *key1, const char *key2);
+MHD_gl_3des_set2keys (MHD_gl_3des_ctx * ctx, const char *key1, const char *key2);
 
 /*
  * Fill a Triple-DES context CTX with subkeys calculated from three
@@ -88,22 +88,22 @@ gl_3des_set2keys (gl_3des_ctx * ctx, const char *key1, const char *key2);
  * of the keys, but simply ignore them.  Does not check for weak
  * keys. */
 extern void
-gl_3des_set3keys (gl_3des_ctx * ctx,
+MHD_gl_3des_set3keys (MHD_gl_3des_ctx * ctx,
                   const char *key1, const char *key2, const char *key3);
 
 /* Fill a Triple-DES context CTX with subkeys calculated from three
  * concatenated 64bit keys in KEY, with weak key checking.  Does not
  * check the parity bits of the keys, but simply ignore them. */
 extern bool
-gl_3des_makekey (gl_3des_ctx * ctx, const char *key, size_t keylen);
+MHD_gl_3des_makekey (MHD_gl_3des_ctx * ctx, const char *key, size_t keylen);
 
 /* Electronic Codebook Mode Triple-DES encryption/decryption of data
  * according to 'mode'.  Sometimes this mode is named 'EDE' mode
  * (Encryption-Decryption-Encryption). */
 extern void
-gl_3des_ecb_crypt (gl_3des_ctx * ctx, const char *from, char *to, int mode);
+MHD_gl_3des_ecb_crypt (MHD_gl_3des_ctx * ctx, const char *from, char *to, int mode);
 
-#define gl_3des_ecb_encrypt(ctx, from, to) gl_3des_ecb_crypt(ctx,from,to,0)
-#define gl_3des_ecb_decrypt(ctx, from, to) gl_3des_ecb_crypt(ctx,from,to,1)
+#define MHD_gl_3des_ecb_encrypt(ctx, from, to) MHD_gl_3des_ecb_crypt(ctx,from,to,0)
+#define MHD_gl_3des_ecb_decrypt(ctx, from, to) MHD_gl_3des_ecb_crypt(ctx,from,to,1)
 
 #endif /* DES_H */
diff --git a/src/daemon/https/lgl/gc-gnulib.c b/src/daemon/https/lgl/gc-gnulib.c
index 237eb45c..46448679 100644
--- a/src/daemon/https/lgl/gc-gnulib.c
+++ b/src/daemon/https/lgl/gc-gnulib.c
@@ -68,13 +68,13 @@
 #undef close
 
 Gc_rc
-gc_init (void)
+MHD_gc_init (void)
 {
   return GC_OK;
 }
 
 void
-gc_done (void)
+MHD_gc_done (void)
 {
   return;
 }
@@ -139,19 +139,19 @@ randomize (int level, char *data, size_t datalen)
 }
 
 Gc_rc
-gc_nonce (char *data, size_t datalen)
+MHD_gc_nonce (char *data, size_t datalen)
 {
   return randomize (0, data, datalen);
 }
 
 Gc_rc
-gc_pseudo_random (char *data, size_t datalen)
+MHD_gc_pseudo_random (char *data, size_t datalen)
 {
   return randomize (1, data, datalen);
 }
 
 Gc_rc
-gc_random (char *data, size_t datalen)
+MHD_gc_random (char *data, size_t datalen)
 {
   return randomize (2, data, datalen);
 }
@@ -160,17 +160,17 @@ gc_random (char *data, size_t datalen)
 
 /* Memory allocation. */
 void
-gc_set_allocators (gc_malloc_t func_malloc,
-                   gc_malloc_t secure_malloc,
-                   gc_secure_check_t secure_check,
-                   gc_realloc_t func_realloc, gc_free_t func_free)
+MHD_gc_set_allocators (MHD_gc_malloc_t func_malloc,
+                   MHD_gc_malloc_t secure_malloc,
+                   MHD_gc_secure_check_t secure_check,
+                   MHD_gc_realloc_t func_realloc, MHD_gc_free_t func_free)
 {
   return;
 }
 
 /* Ciphers. */
 
-typedef struct _gc_cipher_ctx
+typedef struct _MHD_gc_cipher_ctx
 {
   Gc_cipher alg;
   Gc_cipher_mode mode;
@@ -182,20 +182,20 @@ typedef struct _gc_cipher_ctx
   arcfour_context arcfourContext;
 #endif
 #ifdef GNULIB_GC_DES
-  gl_des_ctx desContext;
+  MHD_gl_des_ctx desContext;
 #endif
 #ifdef GNULIB_GC_RIJNDAEL
   rijndaelKeyInstance aesEncKey;
   rijndaelKeyInstance aesDecKey;
   rijndaelCipherInstance aesContext;
 #endif
-} _gc_cipher_ctx;
+} _MHD_gc_cipher_ctx;
 
 Gc_rc
-gc_cipher_open (Gc_cipher alg,
-                Gc_cipher_mode mode, gc_cipher_handle * outhandle)
+MHD_gc_cipher_open (Gc_cipher alg,
+                Gc_cipher_mode mode, MHD_gc_cipher_handle * outhandle)
 {
-  _gc_cipher_ctx *ctx;
+  _MHD_gc_cipher_ctx *ctx;
   Gc_rc rc = GC_OK;
 
   ctx = calloc (sizeof (*ctx), 1);
@@ -277,9 +277,9 @@ gc_cipher_open (Gc_cipher alg,
 }
 
 Gc_rc
-gc_cipher_setkey (gc_cipher_handle handle, size_t keylen, const char *key)
+MHD_gc_cipher_setkey (MHD_gc_cipher_handle handle, size_t keylen, const char *key)
 {
-  _gc_cipher_ctx *ctx = handle;
+  _MHD_gc_cipher_ctx *ctx = handle;
 
   switch (ctx->alg)
     {
@@ -300,7 +300,7 @@ gc_cipher_setkey (gc_cipher_handle handle, size_t keylen, const char *key)
     case GC_DES:
       if (keylen != 8)
         return GC_INVALID_CIPHER;
-      gl_des_setkey (&ctx->desContext, key);
+      MHD_gl_des_setkey (&ctx->desContext, key);
       break;
 #endif
 
@@ -341,9 +341,9 @@ gc_cipher_setkey (gc_cipher_handle handle, size_t keylen, const char *key)
 }
 
 Gc_rc
-gc_cipher_setiv (gc_cipher_handle handle, size_t ivlen, const char *iv)
+MHD_gc_cipher_setiv (MHD_gc_cipher_handle handle, size_t ivlen, const char *iv)
 {
-  _gc_cipher_ctx *ctx = handle;
+  _MHD_gc_cipher_ctx *ctx = handle;
 
   switch (ctx->alg)
     {
@@ -395,9 +395,9 @@ gc_cipher_setiv (gc_cipher_handle handle, size_t ivlen, const char *iv)
 }
 
 Gc_rc
-gc_cipher_encrypt_inline (gc_cipher_handle handle, size_t len, char *data)
+MHD_gc_cipher_encrypt_inline (MHD_gc_cipher_handle handle, size_t len, char *data)
 {
-  _gc_cipher_ctx *ctx = handle;
+  _MHD_gc_cipher_ctx *ctx = handle;
 
   switch (ctx->alg)
     {
@@ -438,7 +438,7 @@ gc_cipher_encrypt_inline (gc_cipher_handle handle, size_t len, char *data)
 #ifdef GNULIB_GC_DES
     case GC_DES:
       for (; len >= 8; len -= 8, data += 8)
-        gl_des_ecb_encrypt (&ctx->desContext, data, data);
+        MHD_gl_des_ecb_encrypt (&ctx->desContext, data, data);
       break;
 #endif
 
@@ -465,9 +465,9 @@ gc_cipher_encrypt_inline (gc_cipher_handle handle, size_t len, char *data)
 }
 
 Gc_rc
-gc_cipher_decrypt_inline (gc_cipher_handle handle, size_t len, char *data)
+MHD_gc_cipher_decrypt_inline (MHD_gc_cipher_handle handle, size_t len, char *data)
 {
-  _gc_cipher_ctx *ctx = handle;
+  _MHD_gc_cipher_ctx *ctx = handle;
 
   switch (ctx->alg)
     {
@@ -510,7 +510,7 @@ gc_cipher_decrypt_inline (gc_cipher_handle handle, size_t len, char *data)
 #ifdef GNULIB_GC_DES
     case GC_DES:
       for (; len >= 8; len -= 8, data += 8)
-        gl_des_ecb_decrypt (&ctx->desContext, data, data);
+        MHD_gl_des_ecb_decrypt (&ctx->desContext, data, data);
       break;
 #endif
 
@@ -537,9 +537,9 @@ gc_cipher_decrypt_inline (gc_cipher_handle handle, size_t len, char *data)
 }
 
 Gc_rc
-gc_cipher_close (gc_cipher_handle handle)
+MHD_gc_cipher_close (MHD_gc_cipher_handle handle)
 {
-  _gc_cipher_ctx *ctx = handle;
+  _MHD_gc_cipher_ctx *ctx = handle;
 
   if (ctx)
     free (ctx);
@@ -551,23 +551,23 @@ gc_cipher_close (gc_cipher_handle handle)
 
 #define MAX_DIGEST_SIZE 20
 
-typedef struct _gc_hash_ctx
+typedef struct _MHD_gc_hash_ctx
 {
   Gc_hash alg;
   Gc_hash_mode mode;
   char hash[MAX_DIGEST_SIZE];
 #ifdef GNULIB_GC_MD5
-  struct md5_ctx md5Context;
+  struct MHD_md5_ctx md5Context;
 #endif
 #ifdef GNULIB_GC_SHA1
-  struct sha1_ctx sha1Context;
+  struct MHD_sha1_ctx sha1Context;
 #endif
-} _gc_hash_ctx;
+} _MHD_gc_hash_ctx;
 
 Gc_rc
-gc_hash_open (Gc_hash hash, Gc_hash_mode mode, gc_hash_handle * outhandle)
+MHD_gc_hash_open (Gc_hash hash, Gc_hash_mode mode, MHD_gc_hash_handle * outhandle)
 {
-  _gc_hash_ctx *ctx;
+  _MHD_gc_hash_ctx *ctx;
   Gc_rc rc = GC_OK;
 
   ctx = calloc (sizeof (*ctx), 1);
@@ -581,13 +581,13 @@ gc_hash_open (Gc_hash hash, Gc_hash_mode mode, gc_hash_handle * outhandle)
     {
 #ifdef GNULIB_GC_MD5
     case GC_MD5:
-      md5_init_ctx (&ctx->md5Context);
+      MHD_md5_init_ctx (&ctx->md5Context);
       break;
 #endif
 
 #ifdef GNULIB_GC_SHA1
     case GC_SHA1:
-      sha1_init_ctx (&ctx->sha1Context);
+      MHD_sha1_init_ctx (&ctx->sha1Context);
       break;
 #endif
 
@@ -615,10 +615,10 @@ gc_hash_open (Gc_hash hash, Gc_hash_mode mode, gc_hash_handle * outhandle)
 }
 
 Gc_rc
-gc_hash_clone (gc_hash_handle handle, gc_hash_handle * outhandle)
+MHD_gc_hash_clone (MHD_gc_hash_handle handle, MHD_gc_hash_handle * outhandle)
 {
-  _gc_hash_ctx *in = handle;
-  _gc_hash_ctx *out;
+  _MHD_gc_hash_ctx *in = handle;
+  _MHD_gc_hash_ctx *out;
 
   *outhandle = out = calloc (sizeof (*out), 1);
   if (!out)
@@ -630,7 +630,7 @@ gc_hash_clone (gc_hash_handle handle, gc_hash_handle * outhandle)
 }
 
 size_t
-gc_hash_digest_length (Gc_hash hash)
+MHD_gc_hash_digest_length (Gc_hash hash)
 {
   size_t len;
 
@@ -664,21 +664,21 @@ gc_hash_digest_length (Gc_hash hash)
 }
 
 void
-gc_hash_write (gc_hash_handle handle, size_t len, const char *data)
+MHD_gc_hash_write (MHD_gc_hash_handle handle, size_t len, const char *data)
 {
-  _gc_hash_ctx *ctx = handle;
+  _MHD_gc_hash_ctx *ctx = handle;
 
   switch (ctx->alg)
     {
 #ifdef GNULIB_GC_MD5
     case GC_MD5:
-      md5_process_bytes (data, len, &ctx->md5Context);
+      MHD_md5_process_bytes (data, len, &ctx->md5Context);
       break;
 #endif
 
 #ifdef GNULIB_GC_SHA1
     case GC_SHA1:
-      sha1_process_bytes (data, len, &ctx->sha1Context);
+      MHD_sha1_process_bytes (data, len, &ctx->sha1Context);
       break;
 #endif
 
@@ -688,23 +688,23 @@ gc_hash_write (gc_hash_handle handle, size_t len, const char *data)
 }
 
 const char *
-gc_hash_read (gc_hash_handle handle)
+MHD_gc_hash_read (MHD_gc_hash_handle handle)
 {
-  _gc_hash_ctx *ctx = handle;
+  _MHD_gc_hash_ctx *ctx = handle;
   const char *ret = NULL;
 
   switch (ctx->alg)
     {
 #ifdef GNULIB_GC_MD5
     case GC_MD5:
-      md5_finish_ctx (&ctx->md5Context, ctx->hash);
+      MHD_md5_finish_ctx (&ctx->md5Context, ctx->hash);
       ret = ctx->hash;
       break;
 #endif
 
 #ifdef GNULIB_GC_SHA1
     case GC_SHA1:
-      sha1_finish_ctx (&ctx->sha1Context, ctx->hash);
+      MHD_sha1_finish_ctx (&ctx->sha1Context, ctx->hash);
       ret = ctx->hash;
       break;
 #endif
@@ -717,27 +717,27 @@ gc_hash_read (gc_hash_handle handle)
 }
 
 void
-gc_hash_close (gc_hash_handle handle)
+MHD_gc_hash_close (MHD_gc_hash_handle handle)
 {
-  _gc_hash_ctx *ctx = handle;
+  _MHD_gc_hash_ctx *ctx = handle;
 
   free (ctx);
 }
 
 Gc_rc
-gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
+MHD_gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
 {
   switch (hash)
     {
 #ifdef GNULIB_GC_MD5
     case GC_MD5:
-      md5_buffer (in, inlen, resbuf);
+      MHD_md5_buffer (in, inlen, resbuf);
       break;
 #endif
 
 #ifdef GNULIB_GC_SHA1
     case GC_SHA1:
-      sha1_buffer (in, inlen, resbuf);
+      MHD_sha1_buffer (in, inlen, resbuf);
       break;
 #endif
 
@@ -750,38 +750,38 @@ gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
 
 #ifdef GNULIB_GC_MD5
 Gc_rc
-gc_md5 (const void *in, size_t inlen, void *resbuf)
+MHD_gc_md5 (const void *in, size_t inlen, void *resbuf)
 {
-  md5_buffer (in, inlen, resbuf);
+  MHD_md5_buffer (in, inlen, resbuf);
   return GC_OK;
 }
 #endif
 
 #ifdef GNULIB_GC_SHA1
 Gc_rc
-gc_sha1 (const void *in, size_t inlen, void *resbuf)
+MHD_gc_sha1 (const void *in, size_t inlen, void *resbuf)
 {
-  sha1_buffer (in, inlen, resbuf);
+  MHD_sha1_buffer (in, inlen, resbuf);
   return GC_OK;
 }
 #endif
 
 #ifdef GNULIB_GC_HMAC_MD5
 Gc_rc
-gc_hmac_md5 (const void *key, size_t keylen,
+MHD_gc_MHD_hmac_md5 (const void *key, size_t keylen,
              const void *in, size_t inlen, char *resbuf)
 {
-  hmac_md5 (key, keylen, in, inlen, resbuf);
+  MHD_hmac_md5 (key, keylen, in, inlen, resbuf);
   return GC_OK;
 }
 #endif
 
 #ifdef GNULIB_GC_HMAC_SHA1
 Gc_rc
-gc_hmac_sha1 (const void *key,
+MHD_gc_MHD_hmac_sha1 (const void *key,
               size_t keylen, const void *in, size_t inlen, char *resbuf)
 {
-  hmac_sha1 (key, keylen, in, inlen, resbuf);
+  MHD_hmac_sha1 (key, keylen, in, inlen, resbuf);
   return GC_OK;
 }
 #endif
diff --git a/src/daemon/https/lgl/gc-libgcrypt.c b/src/daemon/https/lgl/gc-libgcrypt.c
index 884bf31a..2a87d482 100644
--- a/src/daemon/https/lgl/gc-libgcrypt.c
+++ b/src/daemon/https/lgl/gc-libgcrypt.c
@@ -36,7 +36,7 @@
 /* Initialization. */
 
 Gc_rc
-gc_init (void)
+MHD_gc_init (void)
 {
   gcry_error_t err;
 
@@ -54,7 +54,7 @@ gc_init (void)
 }
 
 void
-gc_done (void)
+MHD_gc_done (void)
 {
   return;
 }
@@ -64,21 +64,21 @@ gc_done (void)
 /* Randomness. */
 
 Gc_rc
-gc_nonce (char *data, size_t datalen)
+MHD_gc_nonce (char *data, size_t datalen)
 {
   gcry_create_nonce ((unsigned char *) data, datalen);
   return GC_OK;
 }
 
 Gc_rc
-gc_pseudo_random (char *data, size_t datalen)
+MHD_gc_pseudo_random (char *data, size_t datalen)
 {
   gcry_randomize ((unsigned char *) data, datalen, GCRY_STRONG_RANDOM);
   return GC_OK;
 }
 
 Gc_rc
-gc_random (char *data, size_t datalen)
+MHD_gc_random (char *data, size_t datalen)
 {
   gcry_randomize ((unsigned char *) data, datalen, GCRY_VERY_STRONG_RANDOM);
   return GC_OK;
@@ -89,10 +89,10 @@ gc_random (char *data, size_t datalen)
 /* Memory allocation. */
 
 void
-gc_set_allocators (gc_malloc_t func_malloc,
-                   gc_malloc_t secure_malloc,
-                   gc_secure_check_t secure_check,
-                   gc_realloc_t func_realloc, gc_free_t func_free)
+MHD_gc_set_allocators (MHD_gc_malloc_t func_malloc,
+                   MHD_gc_malloc_t secure_malloc,
+                   MHD_gc_secure_check_t secure_check,
+                   MHD_gc_realloc_t func_realloc, MHD_gc_free_t func_free)
 {
   gcry_set_allocation_handler (func_malloc, secure_malloc, secure_check,
                                func_realloc, func_free);
@@ -101,8 +101,8 @@ gc_set_allocators (gc_malloc_t func_malloc,
 /* Ciphers. */
 
 Gc_rc
-gc_cipher_open (Gc_cipher alg,
-                Gc_cipher_mode mode, gc_cipher_handle * outhandle)
+MHD_gc_cipher_open (Gc_cipher alg,
+                Gc_cipher_mode mode, MHD_gc_cipher_handle * outhandle)
 {
   int gcryalg, gcrymode;
   gcry_error_t err;
@@ -179,7 +179,7 @@ gc_cipher_open (Gc_cipher alg,
 }
 
 Gc_rc
-gc_cipher_setkey (gc_cipher_handle handle, size_t keylen, const char *key)
+MHD_gc_cipher_setkey (MHD_gc_cipher_handle handle, size_t keylen, const char *key)
 {
   gcry_error_t err;
 
@@ -191,7 +191,7 @@ gc_cipher_setkey (gc_cipher_handle handle, size_t keylen, const char *key)
 }
 
 Gc_rc
-gc_cipher_setiv (gc_cipher_handle handle, size_t ivlen, const char *iv)
+MHD_gc_cipher_setiv (MHD_gc_cipher_handle handle, size_t ivlen, const char *iv)
 {
   gcry_error_t err;
 
@@ -203,7 +203,7 @@ gc_cipher_setiv (gc_cipher_handle handle, size_t ivlen, const char *iv)
 }
 
 Gc_rc
-gc_cipher_encrypt_inline (gc_cipher_handle handle, size_t len, char *data)
+MHD_gc_cipher_encrypt_inline (MHD_gc_cipher_handle handle, size_t len, char *data)
 {
   if (gcry_cipher_encrypt ((gcry_cipher_hd_t) handle, data, len, NULL, len) !=
       0)
@@ -213,7 +213,7 @@ gc_cipher_encrypt_inline (gc_cipher_handle handle, size_t len, char *data)
 }
 
 Gc_rc
-gc_cipher_decrypt_inline (gc_cipher_handle handle, size_t len, char *data)
+MHD_gc_cipher_decrypt_inline (MHD_gc_cipher_handle handle, size_t len, char *data)
 {
   if (gcry_cipher_decrypt ((gcry_cipher_hd_t) handle, data, len, NULL, len) !=
       0)
@@ -223,7 +223,7 @@ gc_cipher_decrypt_inline (gc_cipher_handle handle, size_t len, char *data)
 }
 
 Gc_rc
-gc_cipher_close (gc_cipher_handle handle)
+MHD_gc_cipher_close (MHD_gc_cipher_handle handle)
 {
   gcry_cipher_close (handle);
 
@@ -232,17 +232,17 @@ gc_cipher_close (gc_cipher_handle handle)
 
 /* Hashes. */
 
-typedef struct _gc_hash_ctx
+typedef struct _MHD_gc_hash_ctx
 {
   Gc_hash alg;
   Gc_hash_mode mode;
   gcry_md_hd_t gch;
-} _gc_hash_ctx;
+} _MHD_gc_hash_ctx;
 
 Gc_rc
-gc_hash_open (Gc_hash hash, Gc_hash_mode mode, gc_hash_handle * outhandle)
+MHD_gc_hash_open (Gc_hash hash, Gc_hash_mode mode, MHD_gc_hash_handle * outhandle)
 {
-  _gc_hash_ctx *ctx;
+  _MHD_gc_hash_ctx *ctx;
   int gcryalg = 0, gcrymode = 0;
   gcry_error_t err;
   Gc_rc rc = GC_OK;
@@ -322,10 +322,10 @@ gc_hash_open (Gc_hash hash, Gc_hash_mode mode, gc_hash_handle * outhandle)
 }
 
 Gc_rc
-gc_hash_clone (gc_hash_handle handle, gc_hash_handle * outhandle)
+MHD_gc_hash_clone (MHD_gc_hash_handle handle, MHD_gc_hash_handle * outhandle)
 {
-  _gc_hash_ctx *in = handle;
-  _gc_hash_ctx *out;
+  _MHD_gc_hash_ctx *in = handle;
+  _MHD_gc_hash_ctx *out;
   int err;
 
   *outhandle = out = calloc (sizeof (*out), 1);
@@ -345,7 +345,7 @@ gc_hash_clone (gc_hash_handle handle, gc_hash_handle * outhandle)
 }
 
 size_t
-gc_hash_digest_length (Gc_hash hash)
+MHD_gc_hash_digest_length (Gc_hash hash)
 {
   size_t len;
 
@@ -391,23 +391,23 @@ gc_hash_digest_length (Gc_hash hash)
 }
 
 void
-gc_hash_hmac_setkey (gc_hash_handle handle, size_t len, const char *key)
+MHD_gc_hash_MHD_hmac_setkey (MHD_gc_hash_handle handle, size_t len, const char *key)
 {
-  _gc_hash_ctx *ctx = handle;
+  _MHD_gc_hash_ctx *ctx = handle;
   gcry_md_setkey (ctx->gch, key, len);
 }
 
 void
-gc_hash_write (gc_hash_handle handle, size_t len, const char *data)
+MHD_gc_hash_write (MHD_gc_hash_handle handle, size_t len, const char *data)
 {
-  _gc_hash_ctx *ctx = handle;
+  _MHD_gc_hash_ctx *ctx = handle;
   gcry_md_write (ctx->gch, data, len);
 }
 
 const char *
-gc_hash_read (gc_hash_handle handle)
+MHD_gc_hash_read (MHD_gc_hash_handle handle)
 {
-  _gc_hash_ctx *ctx = handle;
+  _MHD_gc_hash_ctx *ctx = handle;
   const char *digest;
   {
     gcry_md_final (ctx->gch);
@@ -418,9 +418,9 @@ gc_hash_read (gc_hash_handle handle)
 }
 
 void
-gc_hash_close (gc_hash_handle handle)
+MHD_gc_hash_close (MHD_gc_hash_handle handle)
 {
-  _gc_hash_ctx *ctx = handle;
+  _MHD_gc_hash_ctx *ctx = handle;
 
   gcry_md_close (ctx->gch);
 
@@ -428,7 +428,7 @@ gc_hash_close (gc_hash_handle handle)
 }
 
 Gc_rc
-gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
+MHD_gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
 {
   int gcryalg;
 
@@ -482,7 +482,7 @@ gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
 /* One-call interface. */
 #ifdef GNULIB_GC_MD5
 Gc_rc
-gc_md5 (const void *in, size_t inlen, void *resbuf)
+MHD_gc_md5 (const void *in, size_t inlen, void *resbuf)
 {
   size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
   gcry_md_hd_t hd;
@@ -514,7 +514,7 @@ gc_md5 (const void *in, size_t inlen, void *resbuf)
 
 #ifdef GNULIB_GC_SHA1
 Gc_rc
-gc_sha1 (const void *in, size_t inlen, void *resbuf)
+MHD_gc_sha1 (const void *in, size_t inlen, void *resbuf)
 {
   size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
   gcry_md_hd_t hd;
@@ -546,7 +546,7 @@ gc_sha1 (const void *in, size_t inlen, void *resbuf)
 
 #ifdef GNULIB_GC_HMAC_MD5
 Gc_rc
-gc_hmac_md5 (const void *key, size_t keylen,
+MHD_gc_MHD_hmac_md5 (const void *key, size_t keylen,
              const void *in, size_t inlen, char *resbuf)
 {
   size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
@@ -586,7 +586,7 @@ gc_hmac_md5 (const void *key, size_t keylen,
 
 #ifdef GNULIB_GC_HMAC_SHA1
 Gc_rc
-gc_hmac_sha1 (const void *key,
+MHD_gc_MHD_hmac_sha1 (const void *key,
               size_t keylen, const void *in, size_t inlen, char *resbuf)
 {
   size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
diff --git a/src/daemon/https/lgl/gc-pbkdf2-sha1.c b/src/daemon/https/lgl/gc-pbkdf2-sha1.c
index b29b42fd..98ac9f96 100644
--- a/src/daemon/https/lgl/gc-pbkdf2-sha1.c
+++ b/src/daemon/https/lgl/gc-pbkdf2-sha1.c
@@ -52,7 +52,7 @@
  */
 
 Gc_rc
-gc_pbkdf2_sha1 (const char *P, size_t Plen,
+MHD_gc_pbkdf2_sha1 (const char *P, size_t Plen,
                 const char *S, size_t Slen,
                 unsigned int c, char *DK, size_t dkLen)
 {
@@ -161,10 +161,10 @@ gc_pbkdf2_sha1 (const char *P, size_t Plen,
               tmp[Slen + 2] = (i & 0x0000ff00) >> 8;
               tmp[Slen + 3] = (i & 0x000000ff) >> 0;
 
-              rc = gc_hmac_sha1 (P, Plen, tmp, tmplen, U);
+              rc = MHD_gc_MHD_hmac_sha1 (P, Plen, tmp, tmplen, U);
             }
           else
-            rc = gc_hmac_sha1 (P, Plen, U, hLen, U);
+            rc = MHD_gc_MHD_hmac_sha1 (P, Plen, U, hLen, U);
 
           if (rc != GC_OK)
             {
diff --git a/src/daemon/https/lgl/gc.h b/src/daemon/https/lgl/gc.h
index 1e1f808c..ecc506fc 100644
--- a/src/daemon/https/lgl/gc.h
+++ b/src/daemon/https/lgl/gc.h
@@ -58,7 +58,7 @@ enum Gc_hash_mode
 };
 typedef enum Gc_hash_mode Gc_hash_mode;
 
-typedef void *gc_hash_handle;
+typedef void *MHD_gc_hash_handle;
 
 #define GC_MD2_DIGEST_SIZE 16
 #define GC_MD4_DIGEST_SIZE 16
@@ -93,49 +93,49 @@ enum Gc_cipher_mode
 };
 typedef enum Gc_cipher_mode Gc_cipher_mode;
 
-typedef void *gc_cipher_handle;
+typedef void *MHD_gc_cipher_handle;
 
 /* Call before respectively after any other functions. */
-Gc_rc gc_init (void);
-void gc_done (void);
+Gc_rc MHD_gc_init (void);
+void MHD_gc_done (void);
 
 /* Memory allocation (avoid). */
-typedef void *(*gc_malloc_t) (size_t n);
-typedef int (*gc_secure_check_t) (const void *);
-typedef void *(*gc_realloc_t) (void *p, size_t n);
-typedef void (*gc_free_t) (void *);
-void gc_set_allocators (gc_malloc_t func_malloc,
-                        gc_malloc_t secure_malloc,
-                        gc_secure_check_t secure_check,
-                        gc_realloc_t func_realloc, gc_free_t func_free);
+typedef void *(*MHD_gc_malloc_t) (size_t n);
+typedef int (*MHD_gc_secure_check_t) (const void *);
+typedef void *(*MHD_gc_realloc_t) (void *p, size_t n);
+typedef void (*MHD_gc_free_t) (void *);
+void MHD_gc_set_allocators (MHD_gc_malloc_t func_malloc,
+                        MHD_gc_malloc_t secure_malloc,
+                        MHD_gc_secure_check_t secure_check,
+                        MHD_gc_realloc_t func_realloc, MHD_gc_free_t func_free);
 
 /* Randomness. */
-Gc_rc gc_nonce (char *data, size_t datalen);
-Gc_rc gc_pseudo_random (char *data, size_t datalen);
-Gc_rc gc_random (char *data, size_t datalen);
+Gc_rc MHD_gc_nonce (char *data, size_t datalen);
+Gc_rc MHD_gc_pseudo_random (char *data, size_t datalen);
+Gc_rc MHD_gc_random (char *data, size_t datalen);
 
 /* Ciphers. */
-Gc_rc gc_cipher_open (Gc_cipher cipher,
-                      Gc_cipher_mode mode, gc_cipher_handle * outhandle);
-Gc_rc gc_cipher_setkey (gc_cipher_handle handle,
+Gc_rc MHD_gc_cipher_open (Gc_cipher cipher,
+                      Gc_cipher_mode mode, MHD_gc_cipher_handle * outhandle);
+Gc_rc MHD_gc_cipher_setkey (MHD_gc_cipher_handle handle,
                         size_t keylen, const char *key);
-Gc_rc gc_cipher_setiv (gc_cipher_handle handle, size_t ivlen, const char *iv);
-Gc_rc gc_cipher_encrypt_inline (gc_cipher_handle handle,
+Gc_rc MHD_gc_cipher_setiv (MHD_gc_cipher_handle handle, size_t ivlen, const char *iv);
+Gc_rc MHD_gc_cipher_encrypt_inline (MHD_gc_cipher_handle handle,
                                 size_t len, char *data);
-Gc_rc gc_cipher_decrypt_inline (gc_cipher_handle handle,
+Gc_rc MHD_gc_cipher_decrypt_inline (MHD_gc_cipher_handle handle,
                                 size_t len, char *data);
-Gc_rc gc_cipher_close (gc_cipher_handle handle);
+Gc_rc MHD_gc_cipher_close (MHD_gc_cipher_handle handle);
 
 /* Hashes. */
 
-Gc_rc gc_hash_open (Gc_hash hash,
-                    Gc_hash_mode mode, gc_hash_handle * outhandle);
-Gc_rc gc_hash_clone (gc_hash_handle handle, gc_hash_handle * outhandle);
-size_t gc_hash_digest_length (Gc_hash hash);
-void gc_hash_hmac_setkey (gc_hash_handle handle, size_t len, const char *key);
-void gc_hash_write (gc_hash_handle handle, size_t len, const char *data);
-const char *gc_hash_read (gc_hash_handle handle);
-void gc_hash_close (gc_hash_handle handle);
+Gc_rc MHD_gc_hash_open (Gc_hash hash,
+                    Gc_hash_mode mode, MHD_gc_hash_handle * outhandle);
+Gc_rc MHD_gc_hash_clone (MHD_gc_hash_handle handle, MHD_gc_hash_handle * outhandle);
+size_t MHD_gc_hash_digest_length (Gc_hash hash);
+void MHD_gc_hash_MHD_hmac_setkey (MHD_gc_hash_handle handle, size_t len, const char *key);
+void MHD_gc_hash_write (MHD_gc_hash_handle handle, size_t len, const char *data);
+const char *MHD_gc_hash_read (MHD_gc_hash_handle handle);
+void MHD_gc_hash_close (MHD_gc_hash_handle handle);
 
 /* Compute a hash value over buffer IN of INLEN bytes size using the
  algorithm HASH, placing the result in the pre-allocated buffer OUT.
@@ -143,16 +143,16 @@ void gc_hash_close (gc_hash_handle handle);
  GC_<HASH>_DIGEST_SIZE.  For example, for GC_MD5 the output buffer
  must be 16 bytes.  The return value is 0 (GC_OK) on success, or
  another Gc_rc error code. */
-Gc_rc gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *out);
+Gc_rc MHD_gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *out);
 
 /* One-call interface. */
-Gc_rc gc_md2 (const void *in, size_t inlen, void *resbuf);
-Gc_rc gc_md4 (const void *in, size_t inlen, void *resbuf);
-Gc_rc gc_md5 (const void *in, size_t inlen, void *resbuf);
-Gc_rc gc_sha1 (const void *in, size_t inlen, void *resbuf);
-Gc_rc gc_hmac_md5 (const void *key,
+Gc_rc MHD_gc_md2 (const void *in, size_t inlen, void *resbuf);
+Gc_rc MHD_gc_md4 (const void *in, size_t inlen, void *resbuf);
+Gc_rc MHD_gc_md5 (const void *in, size_t inlen, void *resbuf);
+Gc_rc MHD_gc_sha1 (const void *in, size_t inlen, void *resbuf);
+Gc_rc MHD_gc_MHD_hmac_md5 (const void *key,
                    size_t keylen, const void *in, size_t inlen, char *resbuf);
-Gc_rc gc_hmac_sha1 (const void *key,
+Gc_rc MHD_gc_MHD_hmac_sha1 (const void *key,
                     size_t keylen,
                     const void *in, size_t inlen, char *resbuf);
 
@@ -163,7 +163,7 @@ Gc_rc gc_hmac_sha1 (const void *key,
  counts are 1000-20000).  This function "stretches" the key to be
  exactly dkLen bytes long.  GC_OK is returned on success, otherwise
  an Gc_rc error code is returned.  */
-Gc_rc gc_pbkdf2_sha1 (const char *P,
+Gc_rc MHD_gc_pbkdf2_sha1 (const char *P,
                       size_t Plen,
                       const char *S,
                       size_t Slen, unsigned int c, char *DK, size_t dkLen);
@@ -285,7 +285,7 @@ Gc_rc gc_pbkdf2_sha1 (const char *P,
  requirement, what entropy quality it require, and call the proper API.
  Meeting the implied semantic properties should be the job for gnulib.
 
- >> Perhaps gc_dev_random and gc_dev_urandom?
+ >> Perhaps MHD_gc_dev_random and MHD_gc_dev_urandom?
  >
  > To some extent.  I'd rather insulate the user from the details of
  > where the random numbers come from.  On the other hand we need to
diff --git a/src/daemon/https/lgl/hmac-md5.c b/src/daemon/https/lgl/hmac-md5.c
index 1bd56103..fc6902a9 100644
--- a/src/daemon/https/lgl/hmac-md5.c
+++ b/src/daemon/https/lgl/hmac-md5.c
@@ -30,11 +30,11 @@
 #define OPAD 0x5c
 
 int
-hmac_md5 (const void *key, size_t keylen,
+MHD_hmac_md5 (const void *key, size_t keylen,
           const void *in, size_t inlen, void *resbuf)
 {
-  struct md5_ctx inner;
-  struct md5_ctx outer;
+  struct MHD_md5_ctx inner;
+  struct MHD_md5_ctx outer;
   char optkeybuf[16];
   char block[64];
   char innerhash[16];
@@ -43,11 +43,11 @@ hmac_md5 (const void *key, size_t keylen,
 
   if (keylen > 64)
     {
-      struct md5_ctx keyhash;
+      struct MHD_md5_ctx keyhash;
 
-      md5_init_ctx (&keyhash);
-      md5_process_bytes (key, keylen, &keyhash);
-      md5_finish_ctx (&keyhash, optkeybuf);
+      MHD_md5_init_ctx (&keyhash);
+      MHD_md5_process_bytes (key, keylen, &keyhash);
+      MHD_md5_finish_ctx (&keyhash, optkeybuf);
 
       key = optkeybuf;
       keylen = 16;
@@ -55,27 +55,27 @@ hmac_md5 (const void *key, size_t keylen,
 
   /* Compute INNERHASH from KEY and IN.  */
 
-  md5_init_ctx (&inner);
+  MHD_md5_init_ctx (&inner);
 
   memset (block, IPAD, sizeof (block));
-  memxor (block, key, keylen);
+  MHD_memxor (block, key, keylen);
 
-  md5_process_block (block, 64, &inner);
-  md5_process_bytes (in, inlen, &inner);
+  MHD_md5_process_block (block, 64, &inner);
+  MHD_md5_process_bytes (in, inlen, &inner);
 
-  md5_finish_ctx (&inner, innerhash);
+  MHD_md5_finish_ctx (&inner, innerhash);
 
   /* Compute result from KEY and INNERHASH.  */
 
-  md5_init_ctx (&outer);
+  MHD_md5_init_ctx (&outer);
 
   memset (block, OPAD, sizeof (block));
-  memxor (block, key, keylen);
+  MHD_memxor (block, key, keylen);
 
-  md5_process_block (block, 64, &outer);
-  md5_process_bytes (innerhash, 16, &outer);
+  MHD_md5_process_block (block, 64, &outer);
+  MHD_md5_process_bytes (innerhash, 16, &outer);
 
-  md5_finish_ctx (&outer, resbuf);
+  MHD_md5_finish_ctx (&outer, resbuf);
 
   return 0;
 }
diff --git a/src/daemon/https/lgl/hmac-sha1.c b/src/daemon/https/lgl/hmac-sha1.c
index e634ad9c..5d341cb4 100644
--- a/src/daemon/https/lgl/hmac-sha1.c
+++ b/src/daemon/https/lgl/hmac-sha1.c
@@ -30,11 +30,11 @@
 #define OPAD 0x5c
 
 int
-hmac_sha1 (const void *key, size_t keylen,
+MHD_hmac_sha1 (const void *key, size_t keylen,
            const void *in, size_t inlen, void *resbuf)
 {
-  struct sha1_ctx inner;
-  struct sha1_ctx outer;
+  struct MHD_sha1_ctx inner;
+  struct MHD_sha1_ctx outer;
   char optkeybuf[20];
   char block[64];
   char innerhash[20];
@@ -43,11 +43,11 @@ hmac_sha1 (const void *key, size_t keylen,
 
   if (keylen > 64)
     {
-      struct sha1_ctx keyhash;
+      struct MHD_sha1_ctx keyhash;
 
-      sha1_init_ctx (&keyhash);
-      sha1_process_bytes (key, keylen, &keyhash);
-      sha1_finish_ctx (&keyhash, optkeybuf);
+      MHD_sha1_init_ctx (&keyhash);
+      MHD_sha1_process_bytes (key, keylen, &keyhash);
+      MHD_sha1_finish_ctx (&keyhash, optkeybuf);
 
       key = optkeybuf;
       keylen = 20;
@@ -55,27 +55,27 @@ hmac_sha1 (const void *key, size_t keylen,
 
   /* Compute INNERHASH from KEY and IN.  */
 
-  sha1_init_ctx (&inner);
+  MHD_sha1_init_ctx (&inner);
 
   memset (block, IPAD, sizeof (block));
-  memxor (block, key, keylen);
+  MHD_memxor (block, key, keylen);
 
-  sha1_process_block (block, 64, &inner);
-  sha1_process_bytes (in, inlen, &inner);
+  MHD_sha1_process_block (block, 64, &inner);
+  MHD_sha1_process_bytes (in, inlen, &inner);
 
-  sha1_finish_ctx (&inner, innerhash);
+  MHD_sha1_finish_ctx (&inner, innerhash);
 
   /* Compute result from KEY and INNERHASH.  */
 
-  sha1_init_ctx (&outer);
+  MHD_sha1_init_ctx (&outer);
 
   memset (block, OPAD, sizeof (block));
-  memxor (block, key, keylen);
+  MHD_memxor (block, key, keylen);
 
-  sha1_process_block (block, 64, &outer);
-  sha1_process_bytes (innerhash, 20, &outer);
+  MHD_sha1_process_block (block, 64, &outer);
+  MHD_sha1_process_bytes (innerhash, 20, &outer);
 
-  sha1_finish_ctx (&outer, resbuf);
+  MHD_sha1_finish_ctx (&outer, resbuf);
 
   return 0;
 }
diff --git a/src/daemon/https/lgl/hmac.h b/src/daemon/https/lgl/hmac.h
index 78bcbb16..29764056 100644
--- a/src/daemon/https/lgl/hmac.h
+++ b/src/daemon/https/lgl/hmac.h
@@ -27,7 +27,7 @@
    KEYLEN bytes, writing the output to pre-allocated 16 byte minimum
    RESBUF buffer.  Return 0 on success.  */
 int
-hmac_md5 (const void *key, size_t keylen,
+MHD_hmac_md5 (const void *key, size_t keylen,
           const void *buffer, size_t buflen, void *resbuf);
 
 /* Compute Hashed Message Authentication Code with SHA-1, over BUFFER
@@ -35,7 +35,7 @@ hmac_md5 (const void *key, size_t keylen,
    output to pre-allocated 20 byte minimum RESBUF buffer.  Return 0 on
    success.  */
 int
-hmac_sha1 (const void *key, size_t keylen,
+MHD_hmac_sha1 (const void *key, size_t keylen,
            const void *in, size_t inlen, void *resbuf);
 
 #endif /* HMAC_H */
diff --git a/src/daemon/https/lgl/md5.c b/src/daemon/https/lgl/md5.c
index 51502d6e..bc1fccbc 100644
--- a/src/daemon/https/lgl/md5.c
+++ b/src/daemon/https/lgl/md5.c
@@ -40,13 +40,13 @@
 # endif
 /* We need to keep the namespace clean so define the MD5 function
    protected using leading __ .  */
-# define md5_init_ctx __md5_init_ctx
-# define md5_process_block __md5_process_block
-# define md5_process_bytes __md5_process_bytes
-# define md5_finish_ctx __md5_finish_ctx
-# define md5_read_ctx __md5_read_ctx
-# define md5_stream __md5_stream
-# define md5_buffer __md5_buffer
+# define MHD_md5_init_ctx __MHD_md5_init_ctx
+# define MHD_md5_process_block __MHD_md5_process_block
+# define MHD_md5_process_bytes __MHD_md5_process_bytes
+# define MHD_md5_finish_ctx __MHD_md5_finish_ctx
+# define MHD_md5_read_ctx __MHD_md5_read_ctx
+# define MHD_md5_stream __MHD_md5_stream
+# define MHD_md5_buffer __MHD_md5_buffer
 #endif
 
 #ifdef WORDS_BIGENDIAN
@@ -69,7 +69,7 @@ static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ...  */  };
 /* Initialize structure containing state of computation.
    (RFC 1321, 3.3: Step 3)  */
 void
-md5_init_ctx (struct md5_ctx *ctx)
+MHD_md5_init_ctx (struct MHD_md5_ctx *ctx)
 {
   ctx->A = 0x67452301;
   ctx->B = 0xefcdab89;
@@ -86,7 +86,7 @@ md5_init_ctx (struct md5_ctx *ctx)
    IMPORTANT: On some systems it is required that RESBUF is correctly
    aligned for a 32-bit value.  */
 void *
-md5_read_ctx (const struct md5_ctx *ctx, void *resbuf)
+MHD_md5_read_ctx (const struct MHD_md5_ctx *ctx, void *resbuf)
 {
   ((uint32_t *) resbuf)[0] = SWAP (ctx->A);
   ((uint32_t *) resbuf)[1] = SWAP (ctx->B);
@@ -102,7 +102,7 @@ md5_read_ctx (const struct md5_ctx *ctx, void *resbuf)
    IMPORTANT: On some systems it is required that RESBUF is correctly
    aligned for a 32-bit value.  */
 void *
-md5_finish_ctx (struct md5_ctx *ctx, void *resbuf)
+MHD_md5_finish_ctx (struct MHD_md5_ctx *ctx, void *resbuf)
 {
   /* Take yet unprocessed bytes into account.  */
   uint32_t bytes = ctx->buflen;
@@ -120,23 +120,23 @@ md5_finish_ctx (struct md5_ctx *ctx, void *resbuf)
   memcpy (&((char *) ctx->buffer)[bytes], fillbuf, (size - 2) * 4 - bytes);
 
   /* Process last bytes.  */
-  md5_process_block (ctx->buffer, size * 4, ctx);
+  MHD_md5_process_block (ctx->buffer, size * 4, ctx);
 
-  return md5_read_ctx (ctx, resbuf);
+  return MHD_md5_read_ctx (ctx, resbuf);
 }
 
 /* Compute MD5 message digest for bytes read from STREAM.  The
    resulting message digest number will be written into the 16 bytes
    beginning at RESBLOCK.  */
 int
-md5_stream (FILE * stream, void *resblock)
+MHD_md5_stream (FILE * stream, void *resblock)
 {
-  struct md5_ctx ctx;
+  struct MHD_md5_ctx ctx;
   char buffer[BLOCKSIZE + 72];
   size_t sum;
 
   /* Initialize the computation context.  */
-  md5_init_ctx (&ctx);
+  MHD_md5_init_ctx (&ctx);
 
   /* Iterate over full file contents.  */
   while (1)
@@ -177,17 +177,17 @@ md5_stream (FILE * stream, void *resblock)
       /* Process buffer with BLOCKSIZE bytes.  Note that
          BLOCKSIZE % 64 == 0
        */
-      md5_process_block (buffer, BLOCKSIZE, &ctx);
+      MHD_md5_process_block (buffer, BLOCKSIZE, &ctx);
     }
 
 process_partial_block:
 
   /* Process any remaining bytes.  */
   if (sum > 0)
-    md5_process_bytes (buffer, sum, &ctx);
+    MHD_md5_process_bytes (buffer, sum, &ctx);
 
   /* Construct result in desired memory.  */
-  md5_finish_ctx (&ctx, resblock);
+  MHD_md5_finish_ctx (&ctx, resblock);
   return 0;
 }
 
@@ -196,23 +196,23 @@ process_partial_block:
    output yields to the wanted ASCII representation of the message
    digest.  */
 void *
-md5_buffer (const char *buffer, size_t len, void *resblock)
+MHD_md5_buffer (const char *buffer, size_t len, void *resblock)
 {
-  struct md5_ctx ctx;
+  struct MHD_md5_ctx ctx;
 
   /* Initialize the computation context.  */
-  md5_init_ctx (&ctx);
+  MHD_md5_init_ctx (&ctx);
 
   /* Process whole buffer but last len % 64 bytes.  */
-  md5_process_bytes (buffer, len, &ctx);
+  MHD_md5_process_bytes (buffer, len, &ctx);
 
   /* Put result in desired memory area.  */
-  return md5_finish_ctx (&ctx, resblock);
+  return MHD_md5_finish_ctx (&ctx, resblock);
 }
 
 
 void
-md5_process_bytes (const void *buffer, size_t len, struct md5_ctx *ctx)
+MHD_md5_process_bytes (const void *buffer, size_t len, struct MHD_md5_ctx *ctx)
 {
   /* When we already have some bits in our internal buffer concatenate
      both inputs first.  */
@@ -226,7 +226,7 @@ md5_process_bytes (const void *buffer, size_t len, struct md5_ctx *ctx)
 
       if (ctx->buflen > 64)
         {
-          md5_process_block (ctx->buffer, ctx->buflen & ~63, ctx);
+          MHD_md5_process_block (ctx->buffer, ctx->buflen & ~63, ctx);
 
           ctx->buflen &= 63;
           /* The regions in the following copy operation cannot overlap.  */
@@ -248,14 +248,14 @@ md5_process_bytes (const void *buffer, size_t len, struct md5_ctx *ctx)
       if (UNALIGNED_P (buffer))
         while (len > 64)
           {
-            md5_process_block (memcpy (ctx->buffer, buffer, 64), 64, ctx);
+            MHD_md5_process_block (memcpy (ctx->buffer, buffer, 64), 64, ctx);
             buffer = (const char *) buffer + 64;
             len -= 64;
           }
       else
 #endif
         {
-          md5_process_block (buffer, len & ~63, ctx);
+          MHD_md5_process_block (buffer, len & ~63, ctx);
           buffer = (const char *) buffer + (len & ~63);
           len &= 63;
         }
@@ -270,7 +270,7 @@ md5_process_bytes (const void *buffer, size_t len, struct md5_ctx *ctx)
       left_over += len;
       if (left_over >= 64)
         {
-          md5_process_block (ctx->buffer, 64, ctx);
+          MHD_md5_process_block (ctx->buffer, 64, ctx);
           left_over -= 64;
           memcpy (ctx->buffer, &ctx->buffer[16], left_over);
         }
@@ -292,7 +292,7 @@ md5_process_bytes (const void *buffer, size_t len, struct md5_ctx *ctx)
    It is assumed that LEN % 64 == 0.  */
 
 void
-md5_process_block (const void *buffer, size_t len, struct md5_ctx *ctx)
+MHD_md5_process_block (const void *buffer, size_t len, struct MHD_md5_ctx *ctx)
 {
   uint32_t correct_words[16];
   const uint32_t *words = buffer;
diff --git a/src/daemon/https/lgl/md5.h b/src/daemon/https/lgl/md5.h
index a03f1e8a..80793b66 100644
--- a/src/daemon/https/lgl/md5.h
+++ b/src/daemon/https/lgl/md5.h
@@ -45,17 +45,17 @@
 #endif
 
 #ifndef _LIBC
-# define __md5_buffer md5_buffer
-# define __md5_finish_ctx md5_finish_ctx
-# define __md5_init_ctx md5_init_ctx
-# define __md5_process_block md5_process_block
-# define __md5_process_bytes md5_process_bytes
-# define __md5_read_ctx md5_read_ctx
-# define __md5_stream md5_stream
+# define __MHD_md5_buffer MHD_md5_buffer
+# define __MHD_md5_finish_ctx MHD_md5_finish_ctx
+# define __MHD_md5_init_ctx MHD_md5_init_ctx
+# define __MHD_md5_process_block MHD_md5_process_block
+# define __MHD_md5_process_bytes MHD_md5_process_bytes
+# define __MHD_md5_read_ctx MHD_md5_read_ctx
+# define __MHD_md5_stream MHD_md5_stream
 #endif
 
 /* Structure to save state of computation between the single steps.  */
-struct md5_ctx
+struct MHD_md5_ctx
 {
   uint32_t A;
   uint32_t B;
@@ -69,28 +69,28 @@ struct md5_ctx
 
 /*
  * The following three functions are build up the low level used in
- * the functions `md5_stream' and `md5_buffer'.
+ * the functions `MHD_md5_stream' and `MHD_md5_buffer'.
  */
 
 /* Initialize structure containing state of computation.
    (RFC 1321, 3.3: Step 3)  */
 extern void
-__md5_init_ctx (struct md5_ctx *ctx)
+__MHD_md5_init_ctx (struct MHD_md5_ctx *ctx)
   __THROW;
 
 /* Starting with the result of former calls of this function (or the
    initialization function update the context for the next LEN bytes
    starting at BUFFER.
    It is necessary that LEN is a multiple of 64!!! */
-     extern void __md5_process_block (const void *buffer, size_t len,
-                                      struct md5_ctx *ctx) __THROW;
+     extern void __MHD_md5_process_block (const void *buffer, size_t len,
+                                      struct MHD_md5_ctx *ctx) __THROW;
 
 /* Starting with the result of former calls of this function (or the
    initialization function update the context for the next LEN bytes
    starting at BUFFER.
    It is NOT required that LEN is a multiple of 64.  */
-     extern void __md5_process_bytes (const void *buffer, size_t len,
-                                      struct md5_ctx *ctx) __THROW;
+     extern void __MHD_md5_process_bytes (const void *buffer, size_t len,
+                                      struct MHD_md5_ctx *ctx) __THROW;
 
 /* Process the remaining bytes in the buffer and put result from CTX
    in first 16 bytes following RESBUF.  The result is always in little
@@ -99,7 +99,7 @@ __md5_init_ctx (struct md5_ctx *ctx)
 
    IMPORTANT: On some systems, RESBUF must be aligned to a 32-bit
    boundary. */
-     extern void *__md5_finish_ctx (struct md5_ctx *ctx,
+     extern void *__MHD_md5_finish_ctx (struct MHD_md5_ctx *ctx,
                                     void *resbuf) __THROW;
 
 
@@ -109,20 +109,20 @@ __md5_init_ctx (struct md5_ctx *ctx)
 
    IMPORTANT: On some systems, RESBUF must be aligned to a 32-bit
    boundary. */
-     extern void *__md5_read_ctx (const struct md5_ctx *ctx,
+     extern void *__MHD_md5_read_ctx (const struct MHD_md5_ctx *ctx,
                                   void *resbuf) __THROW;
 
 
 /* Compute MD5 message digest for bytes read from STREAM.  The
    resulting message digest number will be written into the 16 bytes
    beginning at RESBLOCK.  */
-     extern int __md5_stream (FILE * stream, void *resblock) __THROW;
+     extern int __MHD_md5_stream (FILE * stream, void *resblock) __THROW;
 
 /* Compute MD5 message digest for LEN bytes beginning at BUFFER.  The
    result is always in little endian byte order, so that a byte-wise
    output yields to the wanted ASCII representation of the message
    digest.  */
-     extern void *__md5_buffer (const char *buffer, size_t len,
+     extern void *__MHD_md5_buffer (const char *buffer, size_t len,
                                 void *resblock) __THROW;
 
 #endif /* md5.h */
diff --git a/src/daemon/https/lgl/memmem.c b/src/daemon/https/lgl/memmem.c
index 9a0e67d2..08e54742 100644
--- a/src/daemon/https/lgl/memmem.c
+++ b/src/daemon/https/lgl/memmem.c
@@ -26,11 +26,11 @@
 # define __builtin_expect(expr, val)   (expr)
 #endif
 
-#undef memmem
+#undef MHD_memmem
 
 /* Return the first occurrence of NEEDLE in HAYSTACK.  */
 void *
-memmem (haystack, haystack_len, needle, needle_len)
+MHD_memmem (haystack, haystack_len, needle, needle_len)
      const void *haystack;
      size_t haystack_len;
      const void *needle;
diff --git a/src/daemon/https/lgl/memxor.c b/src/daemon/https/lgl/memxor.c
index dabada9f..a1921494 100644
--- a/src/daemon/https/lgl/memxor.c
+++ b/src/daemon/https/lgl/memxor.c
@@ -1,4 +1,4 @@
-/* memxor.c -- perform binary exclusive OR operation of two memory blocks.
+/* MHD_memxor.c -- perform binary exclusive OR operation of two memory blocks.
    Copyright (C) 2005, 2006 Free Software Foundation, Inc.
 
    This program is free software; you can redistribute it and/or modify
@@ -15,7 +15,7 @@
    along with this program; if not, write to the Free Software Foundation,
    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
 
-/* Written by Simon Josefsson.  The interface was inspired by memxor
+/* Written by Simon Josefsson.  The interface was inspired by MHD_memxor
    in Niels Möller's Nettle. */
 
 #include "MHD_config.h"
@@ -23,7 +23,7 @@
 #include "memxor.h"
 
 void *
-memxor (void *restrict dest, const void *restrict src, size_t n)
+MHD_memxor (void *restrict dest, const void *restrict src, size_t n)
 {
   char const *s = src;
   char *d = dest;
diff --git a/src/daemon/https/lgl/memxor.h b/src/daemon/https/lgl/memxor.h
index 4f85f2d7..47e6b3fa 100644
--- a/src/daemon/https/lgl/memxor.h
+++ b/src/daemon/https/lgl/memxor.h
@@ -1,4 +1,4 @@
-/* memxor.h -- perform binary exclusive OR operation on memory blocks.
+/* MHD_memxor.h -- perform binary exclusive OR operation on memory blocks.
    Copyright (C) 2005 Free Software Foundation, Inc.
 
    This program is free software; you can redistribute it and/or modify
@@ -15,7 +15,7 @@
    along with this program; if not, write to the Free Software Foundation,
    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
 
-/* Written by Simon Josefsson.  The interface was inspired by memxor
+/* Written by Simon Josefsson.  The interface was inspired by MHD_memxor
    in Niels Möller's Nettle. */
 
 #ifndef MEMXOR_H
@@ -26,6 +26,6 @@
 /* Compute binary exclusive OR of memory areas DEST and SRC, putting
    the result in DEST, of length N bytes.  Returns a pointer to
    DEST. */
-void *memxor (void *restrict dest, const void *restrict src, size_t n);
+void *MHD_memxor (void *restrict dest, const void *restrict src, size_t n);
 
 #endif /* MEMXOR_H */
diff --git a/src/daemon/https/lgl/sha1.c b/src/daemon/https/lgl/sha1.c
index 501abba1..c336cc4e 100644
--- a/src/daemon/https/lgl/sha1.c
+++ b/src/daemon/https/lgl/sha1.c
@@ -53,9 +53,9 @@ static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ...  */  };
 
 /* Take a pointer to a 160 bit block of data (five 32 bit ints) and
    initialize it to the start constants of the SHA1 algorithm.  This
-   must be called before using hash in the call to sha1_hash.  */
+   must be called before using hash in the call to MHD_sha1_hash.  */
 void
-sha1_init_ctx (struct sha1_ctx *ctx)
+MHD_sha1_init_ctx (struct MHD_sha1_ctx *ctx)
 {
   ctx->A = 0x67452301;
   ctx->B = 0xefcdab89;
@@ -73,7 +73,7 @@ sha1_init_ctx (struct sha1_ctx *ctx)
    IMPORTANT: On some systems it is required that RESBUF is correctly
    aligned for a 32-bit value.  */
 void *
-sha1_read_ctx (const struct sha1_ctx *ctx, void *resbuf)
+MHD_sha1_read_ctx (const struct MHD_sha1_ctx *ctx, void *resbuf)
 {
   ((uint32_t *) resbuf)[0] = SWAP (ctx->A);
   ((uint32_t *) resbuf)[1] = SWAP (ctx->B);
@@ -90,7 +90,7 @@ sha1_read_ctx (const struct sha1_ctx *ctx, void *resbuf)
    IMPORTANT: On some systems it is required that RESBUF is correctly
    aligned for a 32-bit value.  */
 void *
-sha1_finish_ctx (struct sha1_ctx *ctx, void *resbuf)
+MHD_sha1_finish_ctx (struct MHD_sha1_ctx *ctx, void *resbuf)
 {
   /* Take yet unprocessed bytes into account.  */
   uint32_t bytes = ctx->buflen;
@@ -108,23 +108,23 @@ sha1_finish_ctx (struct sha1_ctx *ctx, void *resbuf)
   memcpy (&((char *) ctx->buffer)[bytes], fillbuf, (size - 2) * 4 - bytes);
 
   /* Process last bytes.  */
-  sha1_process_block (ctx->buffer, size * 4, ctx);
+  MHD_sha1_process_block (ctx->buffer, size * 4, ctx);
 
-  return sha1_read_ctx (ctx, resbuf);
+  return MHD_sha1_read_ctx (ctx, resbuf);
 }
 
 /* Compute SHA1 message digest for bytes read from STREAM.  The
    resulting message digest number will be written into the 16 bytes
    beginning at RESBLOCK.  */
 int
-sha1_stream (FILE * stream, void *resblock)
+MHD_sha1_stream (FILE * stream, void *resblock)
 {
-  struct sha1_ctx ctx;
+  struct MHD_sha1_ctx ctx;
   char buffer[BLOCKSIZE + 72];
   size_t sum;
 
   /* Initialize the computation context.  */
-  sha1_init_ctx (&ctx);
+  MHD_sha1_init_ctx (&ctx);
 
   /* Iterate over full file contents.  */
   while (1)
@@ -165,17 +165,17 @@ sha1_stream (FILE * stream, void *resblock)
       /* Process buffer with BLOCKSIZE bytes.  Note that
          BLOCKSIZE % 64 == 0
        */
-      sha1_process_block (buffer, BLOCKSIZE, &ctx);
+      MHD_sha1_process_block (buffer, BLOCKSIZE, &ctx);
     }
 
 process_partial_block:;
 
   /* Process any remaining bytes.  */
   if (sum > 0)
-    sha1_process_bytes (buffer, sum, &ctx);
+    MHD_sha1_process_bytes (buffer, sum, &ctx);
 
   /* Construct result in desired memory.  */
-  sha1_finish_ctx (&ctx, resblock);
+  MHD_sha1_finish_ctx (&ctx, resblock);
   return 0;
 }
 
@@ -184,22 +184,22 @@ process_partial_block:;
    output yields to the wanted ASCII representation of the message
    digest.  */
 void *
-sha1_buffer (const char *buffer, size_t len, void *resblock)
+MHD_sha1_buffer (const char *buffer, size_t len, void *resblock)
 {
-  struct sha1_ctx ctx;
+  struct MHD_sha1_ctx ctx;
 
   /* Initialize the computation context.  */
-  sha1_init_ctx (&ctx);
+  MHD_sha1_init_ctx (&ctx);
 
   /* Process whole buffer but last len % 64 bytes.  */
-  sha1_process_bytes (buffer, len, &ctx);
+  MHD_sha1_process_bytes (buffer, len, &ctx);
 
   /* Put result in desired memory area.  */
-  return sha1_finish_ctx (&ctx, resblock);
+  return MHD_sha1_finish_ctx (&ctx, resblock);
 }
 
 void
-sha1_process_bytes (const void *buffer, size_t len, struct sha1_ctx *ctx)
+MHD_sha1_process_bytes (const void *buffer, size_t len, struct MHD_sha1_ctx *ctx)
 {
   /* When we already have some bits in our internal buffer concatenate
      both inputs first.  */
@@ -213,7 +213,7 @@ sha1_process_bytes (const void *buffer, size_t len, struct sha1_ctx *ctx)
 
       if (ctx->buflen > 64)
         {
-          sha1_process_block (ctx->buffer, ctx->buflen & ~63, ctx);
+          MHD_sha1_process_block (ctx->buffer, ctx->buflen & ~63, ctx);
 
           ctx->buflen &= 63;
           /* The regions in the following copy operation cannot overlap.  */
@@ -235,14 +235,14 @@ sha1_process_bytes (const void *buffer, size_t len, struct sha1_ctx *ctx)
       if (UNALIGNED_P (buffer))
         while (len > 64)
           {
-            sha1_process_block (memcpy (ctx->buffer, buffer, 64), 64, ctx);
+            MHD_sha1_process_block (memcpy (ctx->buffer, buffer, 64), 64, ctx);
             buffer = (const char *) buffer + 64;
             len -= 64;
           }
       else
 #endif
         {
-          sha1_process_block (buffer, len & ~63, ctx);
+          MHD_sha1_process_block (buffer, len & ~63, ctx);
           buffer = (const char *) buffer + (len & ~63);
           len &= 63;
         }
@@ -257,7 +257,7 @@ sha1_process_bytes (const void *buffer, size_t len, struct sha1_ctx *ctx)
       left_over += len;
       if (left_over >= 64)
         {
-          sha1_process_block (ctx->buffer, 64, ctx);
+          MHD_sha1_process_block (ctx->buffer, 64, ctx);
           left_over -= 64;
           memcpy (ctx->buffer, &ctx->buffer[16], left_over);
         }
@@ -284,7 +284,7 @@ sha1_process_bytes (const void *buffer, size_t len, struct sha1_ctx *ctx)
    Most of this code comes from GnuPG's cipher/sha1.c.  */
 
 void
-sha1_process_block (const void *buffer, size_t len, struct sha1_ctx *ctx)
+MHD_sha1_process_block (const void *buffer, size_t len, struct MHD_sha1_ctx *ctx)
 {
   const uint32_t *words = buffer;
   size_t nwords = len / sizeof (uint32_t);
diff --git a/src/daemon/https/lgl/sha1.h b/src/daemon/https/lgl/sha1.h
index 7bfd376c..382d96cf 100644
--- a/src/daemon/https/lgl/sha1.h
+++ b/src/daemon/https/lgl/sha1.h
@@ -23,7 +23,7 @@
 # include <stdint.h>
 
 /* Structure to save state of computation between the single steps.  */
-struct sha1_ctx
+struct MHD_sha1_ctx
 {
   uint32_t A;
   uint32_t B;
@@ -38,21 +38,21 @@ struct sha1_ctx
 
 
 /* Initialize structure containing state of computation. */
-extern void sha1_init_ctx (struct sha1_ctx *ctx);
+extern void MHD_sha1_init_ctx (struct MHD_sha1_ctx *ctx);
 
 /* Starting with the result of former calls of this function (or the
    initialization function update the context for the next LEN bytes
    starting at BUFFER.
    It is necessary that LEN is a multiple of 64!!! */
-extern void sha1_process_block (const void *buffer, size_t len,
-                                struct sha1_ctx *ctx);
+extern void MHD_sha1_process_block (const void *buffer, size_t len,
+                                struct MHD_sha1_ctx *ctx);
 
 /* Starting with the result of former calls of this function (or the
    initialization function update the context for the next LEN bytes
    starting at BUFFER.
    It is NOT required that LEN is a multiple of 64.  */
-extern void sha1_process_bytes (const void *buffer, size_t len,
-                                struct sha1_ctx *ctx);
+extern void MHD_sha1_process_bytes (const void *buffer, size_t len,
+                                struct MHD_sha1_ctx *ctx);
 
 /* Process the remaining bytes in the buffer and put result from CTX
    in first 20 bytes following RESBUF.  The result is always in little
@@ -61,7 +61,7 @@ extern void sha1_process_bytes (const void *buffer, size_t len,
 
    IMPORTANT: On some systems it is required that RESBUF be correctly
    aligned for a 32 bits value.  */
-extern void *sha1_finish_ctx (struct sha1_ctx *ctx, void *resbuf);
+extern void *MHD_sha1_finish_ctx (struct MHD_sha1_ctx *ctx, void *resbuf);
 
 
 /* Put result from CTX in first 20 bytes following RESBUF.  The result is
@@ -70,18 +70,18 @@ extern void *sha1_finish_ctx (struct sha1_ctx *ctx, void *resbuf);
 
    IMPORTANT: On some systems it is required that RESBUF is correctly
    aligned for a 32 bits value.  */
-extern void *sha1_read_ctx (const struct sha1_ctx *ctx, void *resbuf);
+extern void *MHD_sha1_read_ctx (const struct MHD_sha1_ctx *ctx, void *resbuf);
 
 
 /* Compute SHA1 message digest for bytes read from STREAM.  The
    resulting message digest number will be written into the 20 bytes
    beginning at RESBLOCK.  */
-extern int sha1_stream (FILE * stream, void *resblock);
+extern int MHD_sha1_stream (FILE * stream, void *resblock);
 
 /* Compute SHA1 message digest for LEN bytes beginning at BUFFER.  The
    result is always in little endian byte order, so that a byte-wise
    output yields to the wanted ASCII representation of the message
    digest.  */
-extern void *sha1_buffer (const char *buffer, size_t len, void *resblock);
+extern void *MHD_sha1_buffer (const char *buffer, size_t len, void *resblock);
 
 #endif
diff --git a/src/daemon/https/lgl/time_r.c b/src/daemon/https/lgl/time_r.c
deleted file mode 100644
index 025cadca..00000000
--- a/src/daemon/https/lgl/time_r.c
+++ /dev/null
@@ -1,46 +0,0 @@
-/* Reentrant time functions like localtime_r.
-
- Copyright (C) 2003, 2006, 2007 Free Software Foundation, Inc.
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU Lesser General Public License as published by
- the Free Software Foundation; either version 2.1, or (at your option)
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public License along
- with this program; if not, write to the Free Software Foundation,
- Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
-
-/* Written by Paul Eggert.  */
-
-#include "MHD_config.h"
-
-#include <time.h>
-
-#include <string.h>
-
-static struct tm *
-copy_tm_result (struct tm *dest, struct tm const *src)
-{
-  if (!src)
-    return 0;
-  *dest = *src;
-  return dest;
-}
-
-struct tm *
-gmtime_r (time_t const *restrict t, struct tm *restrict tp)
-{
-  return copy_tm_result (tp, gmtime (t));
-}
-
-struct tm *
-localtime_r (time_t const *restrict t, struct tm *restrict tp)
-{
-  return copy_tm_result (tp, localtime (t));
-}
diff --git a/src/daemon/https/minitasn1/coding.c b/src/daemon/https/minitasn1/coding.c
index cc29a003..0f223b04 100644
--- a/src/daemon/https/minitasn1/coding.c
+++ b/src/daemon/https/minitasn1/coding.c
@@ -37,7 +37,7 @@
 #define MAX_TAG_LEN 16
 
 /******************************************************/
-/* Function : _asn1_error_description_value_not_found */
+/* Function : MHD__asn1_error_description_value_not_found */
 /* Description: creates the ErrorDescription string   */
 /* for the ASN1_VALUE_NOT_FOUND error.                */
 /* Parameters:                                        */
@@ -46,7 +46,7 @@
 /* Return:                                            */
 /******************************************************/
 void
-_asn1_error_description_value_not_found (node_asn * node,
+MHD__asn1_error_description_value_not_found (node_asn * node,
                                          char *ErrorDescription)
 {
 
@@ -54,14 +54,14 @@ _asn1_error_description_value_not_found (node_asn * node,
     return;
 
   Estrcpy (ErrorDescription, ":: value of element '");
-  _asn1_hierarchical_name (node, ErrorDescription + strlen (ErrorDescription),
+  MHD__asn1_hierarchical_name (node, ErrorDescription + strlen (ErrorDescription),
                            MAX_ERROR_DESCRIPTION_SIZE - 40);
   Estrcat (ErrorDescription, "' not found");
 
 }
 
 /**
- * asn1_length_der:
+ * MHD__asn1_length_der:
  * @len: value to convert.
  * @ans: string returned.
  * @ans_len: number of meaningful bytes of ANS (ans[0]..ans[ans_len-1]).
@@ -70,7 +70,7 @@ _asn1_error_description_value_not_found (node_asn * node,
  * The @ans buffer is pre-allocated and must have room for the output.
  **/
 void
-asn1_length_der (unsigned long int len, unsigned char *ans, int *ans_len)
+MHD__asn1_length_der (unsigned long int len, unsigned char *ans, int *ans_len)
 {
   int k;
   unsigned char temp[SIZEOF_UNSIGNED_LONG_INT];
@@ -102,7 +102,7 @@ asn1_length_der (unsigned long int len, unsigned char *ans, int *ans_len)
 }
 
 /******************************************************/
-/* Function : _asn1_tag_der                           */
+/* Function : MHD__asn1_tag_der                           */
 /* Description: creates the DER coding for the CLASS  */
 /* and TAG parameters.                                */
 /* Parameters:                                        */
@@ -114,7 +114,7 @@ asn1_length_der (unsigned long int len, unsigned char *ans, int *ans_len)
 /* Return:                                            */
 /******************************************************/
 void
-_asn1_tag_der (unsigned char class, unsigned int tag_value,
+MHD__asn1_tag_der (unsigned char class, unsigned int tag_value,
                unsigned char *ans, int *ans_len)
 {
   int k;
@@ -144,7 +144,7 @@ _asn1_tag_der (unsigned char class, unsigned int tag_value,
 }
 
 /**
- * asn1_octet_der:
+ * MHD__asn1_octet_der:
  * @str: OCTET string.
  * @str_len: STR length (str[0]..str[str_len-1]).
  * @der: string returned.
@@ -153,20 +153,20 @@ _asn1_tag_der (unsigned char class, unsigned int tag_value,
  * Creates the DER coding for an OCTET type (length included).
  **/
 void
-asn1_octet_der (const unsigned char *str, int str_len,
+MHD__asn1_octet_der (const unsigned char *str, int str_len,
                 unsigned char *der, int *der_len)
 {
   int len_len;
 
   if (der == NULL || str_len < 0)
     return;
-  asn1_length_der (str_len, der, &len_len);
+  MHD__asn1_length_der (str_len, der, &len_len);
   memcpy (der + len_len, str, str_len);
   *der_len = str_len + len_len;
 }
 
 /******************************************************/
-/* Function : _asn1_time_der                          */
+/* Function : MHD__asn1_time_der                          */
 /* Description: creates the DER coding for a TIME     */
 /* type (length included).                            */
 /* Parameters:                                        */
@@ -179,15 +179,15 @@ asn1_octet_der (const unsigned char *str, int str_len,
 /*   ASN1_MEM_ERROR when DER isn't big enough         */
 /*   ASN1_SUCCESS otherwise                           */
 /******************************************************/
-asn1_retCode
-_asn1_time_der (unsigned char *str, unsigned char *der, int *der_len)
+MHD__asn1_retCode
+MHD__asn1_time_der (unsigned char *str, unsigned char *der, int *der_len)
 {
   int len_len;
   int max_len;
 
   max_len = *der_len;
 
-  asn1_length_der (strlen (str), (max_len > 0) ? der : NULL, &len_len);
+  MHD__asn1_length_der (strlen (str), (max_len > 0) ? der : NULL, &len_len);
 
   if ((len_len + (int) strlen (str)) <= max_len)
     memcpy (der + len_len, str, strlen (str));
@@ -202,13 +202,13 @@ _asn1_time_der (unsigned char *str, unsigned char *der, int *der_len)
 
 /*
 void
-_asn1_get_utctime_der(unsigned char *der,int *der_len,unsigned char *str)
+MHD__asn1_get_utctime_der(unsigned char *der,int *der_len,unsigned char *str)
 {
   int len_len,str_len;
   char temp[20];
 
   if(str==NULL) return;
-  str_len=asn1_get_length_der(der,*der_len,&len_len);
+  str_len=MHD__asn1_get_length_der(der,*der_len,&len_len);
   if (str_len<0) return;
   memcpy(temp,der+len_len,str_len);
   *der_len=str_len+len_len;
@@ -237,7 +237,7 @@ _asn1_get_utctime_der(unsigned char *der,int *der_len,unsigned char *str)
 */
 
 /******************************************************/
-/* Function : _asn1_objectid_der                      */
+/* Function : MHD__asn1_objectid_der                      */
 /* Description: creates the DER coding for an         */
 /* OBJECT IDENTIFIER  type (length included).         */
 /* Parameters:                                        */
@@ -250,8 +250,8 @@ _asn1_get_utctime_der(unsigned char *der,int *der_len,unsigned char *str)
 /*   ASN1_MEM_ERROR when DER isn't big enough         */
 /*   ASN1_SUCCESS otherwise                           */
 /******************************************************/
-asn1_retCode
-_asn1_objectid_der (unsigned char *str, unsigned char *der, int *der_len)
+MHD__asn1_retCode
+MHD__asn1_objectid_der (unsigned char *str, unsigned char *der, int *der_len)
 {
   int len_len, counter, k, first, max_len;
   char *temp, *n_end, *n_start;
@@ -260,7 +260,7 @@ _asn1_objectid_der (unsigned char *str, unsigned char *der, int *der_len)
 
   max_len = *der_len;
 
-  temp = (char *) _asn1_alloca (strlen (str) + 2);
+  temp = (char *) MHD__asn1_alloca (strlen (str) + 2);
   if (temp == NULL)
     return ASN1_MEM_ALLOC_ERROR;
 
@@ -304,15 +304,15 @@ _asn1_objectid_der (unsigned char *str, unsigned char *der, int *der_len)
       n_start = n_end + 1;
     }
 
-  asn1_length_der (*der_len, NULL, &len_len);
+  MHD__asn1_length_der (*der_len, NULL, &len_len);
   if (max_len >= (*der_len + len_len))
     {
       memmove (der + len_len, der, *der_len);
-      asn1_length_der (*der_len, der, &len_len);
+      MHD__asn1_length_der (*der_len, der, &len_len);
     }
   *der_len += len_len;
 
-  _asn1_afree (temp);
+  MHD__asn1_afree (temp);
 
   if (max_len < (*der_len))
     return ASN1_MEM_ERROR;
@@ -324,7 +324,7 @@ _asn1_objectid_der (unsigned char *str, unsigned char *der, int *der_len)
 const char bit_mask[] = { 0xFF, 0xFE, 0xFC, 0xF8, 0xF0, 0xE0, 0xC0, 0x80 };
 
 /**
- * asn1_bit_der:
+ * MHD__asn1_bit_der:
  * @str: BIT string.
  * @bit_len: number of meaningful bits in STR.
  * @der: string returned.
@@ -335,7 +335,7 @@ const char bit_mask[] = { 0xFF, 0xFE, 0xFC, 0xF8, 0xF0, 0xE0, 0xC0, 0x80 };
  * included).
  **/
 void
-asn1_bit_der (const unsigned char *str, int bit_len,
+MHD__asn1_bit_der (const unsigned char *str, int bit_len,
               unsigned char *der, int *der_len)
 {
   int len_len, len_byte, len_pad;
@@ -348,7 +348,7 @@ asn1_bit_der (const unsigned char *str, int bit_len,
     len_pad = 0;
   else
     len_byte++;
-  asn1_length_der (len_byte + 1, der, &len_len);
+  MHD__asn1_length_der (len_byte + 1, der, &len_len);
   der[len_len] = len_pad;
   memcpy (der + len_len + 1, str, len_byte);
   der[len_len + len_byte] &= bit_mask[len_pad];
@@ -357,7 +357,7 @@ asn1_bit_der (const unsigned char *str, int bit_len,
 
 
 /******************************************************/
-/* Function : _asn1_complete_explicit_tag             */
+/* Function : MHD__asn1_complete_explicit_tag             */
 /* Description: add the length coding to the EXPLICIT */
 /* tags.                                              */
 /* Parameters:                                        */
@@ -370,8 +370,8 @@ asn1_bit_der (const unsigned char *str, int bit_len,
 /*   ASN1_MEM_ERROR if der vector isn't big enough,   */
 /*   otherwise ASN1_SUCCESS.                          */
 /******************************************************/
-asn1_retCode
-_asn1_complete_explicit_tag (node_asn * node, unsigned char *der,
+MHD__asn1_retCode
+MHD__asn1_complete_explicit_tag (node_asn * node, unsigned char *der,
                              int *counter, int *max_len)
 {
   node_asn *p;
@@ -397,8 +397,8 @@ _asn1_complete_explicit_tag (node_asn * node, unsigned char *der,
               if (p->type & CONST_EXPLICIT)
                 {
                   len2 = strtol (p->name, NULL, 10);
-                  _asn1_set_name (p, NULL);
-                  asn1_length_der (*counter - len2, temp, &len3);
+                  MHD__asn1_set_name (p, NULL);
+                  MHD__asn1_length_der (*counter - len2, temp, &len3);
                   if (len3 <= (*max_len))
                     {
                       memmove (der + len2 + len3, der + len2,
@@ -429,7 +429,7 @@ _asn1_complete_explicit_tag (node_asn * node, unsigned char *der,
 
 
 /******************************************************/
-/* Function : _asn1_insert_tag_der                    */
+/* Function : MHD__asn1_insert_tag_der                    */
 /* Description: creates the DER coding of tags of one */
 /* NODE.                                              */
 /* Parameters:                                        */
@@ -443,8 +443,8 @@ _asn1_complete_explicit_tag (node_asn * node, unsigned char *der,
 /*   ASN1_MEM_ERROR if der vector isn't big enough,   */
 /*   otherwise ASN1_SUCCESS.                          */
 /******************************************************/
-asn1_retCode
-_asn1_insert_tag_der (node_asn * node, unsigned char *der, int *counter,
+MHD__asn1_retCode
+MHD__asn1_insert_tag_der (node_asn * node, unsigned char *der, int *counter,
                       int *max_len)
 {
   node_asn *p;
@@ -474,10 +474,10 @@ _asn1_insert_tag_der (node_asn * node, unsigned char *der, int *counter,
               if (p->type & CONST_EXPLICIT)
                 {
                   if (is_tag_implicit)
-                    _asn1_tag_der (class_implicit, tag_implicit, tag_der,
+                    MHD__asn1_tag_der (class_implicit, tag_implicit, tag_der,
                                    &tag_len);
                   else
-                    _asn1_tag_der (class | ASN1_CLASS_STRUCTURED,
+                    MHD__asn1_tag_der (class | ASN1_CLASS_STRUCTURED,
                                    strtoul (p->value, NULL, 10), tag_der,
                                    &tag_len);
 
@@ -486,8 +486,8 @@ _asn1_insert_tag_der (node_asn * node, unsigned char *der, int *counter,
                     memcpy (der + *counter, tag_der, tag_len);
                   *counter += tag_len;
 
-                  _asn1_ltostr (*counter, temp);
-                  _asn1_set_name (p, temp);
+                  MHD__asn1_ltostr (*counter, temp);
+                  MHD__asn1_set_name (p, temp);
 
                   is_tag_implicit = 0;
                 }
@@ -512,62 +512,62 @@ _asn1_insert_tag_der (node_asn * node, unsigned char *der, int *counter,
 
   if (is_tag_implicit)
     {
-      _asn1_tag_der (class_implicit, tag_implicit, tag_der, &tag_len);
+      MHD__asn1_tag_der (class_implicit, tag_implicit, tag_der, &tag_len);
     }
   else
     {
       switch (type_field (node->type))
         {
         case TYPE_NULL:
-          _asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_NULL, tag_der,
+          MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_NULL, tag_der,
                          &tag_len);
           break;
         case TYPE_BOOLEAN:
-          _asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_BOOLEAN, tag_der,
+          MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_BOOLEAN, tag_der,
                          &tag_len);
           break;
         case TYPE_INTEGER:
-          _asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_INTEGER, tag_der,
+          MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_INTEGER, tag_der,
                          &tag_len);
           break;
         case TYPE_ENUMERATED:
-          _asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_ENUMERATED, tag_der,
+          MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_ENUMERATED, tag_der,
                          &tag_len);
           break;
         case TYPE_OBJECT_ID:
-          _asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_OBJECT_ID, tag_der,
+          MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_OBJECT_ID, tag_der,
                          &tag_len);
           break;
         case TYPE_TIME:
           if (node->type & CONST_UTC)
             {
-              _asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_UTCTime, tag_der,
+              MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_UTCTime, tag_der,
                              &tag_len);
             }
           else
-            _asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_GENERALIZEDTime,
+            MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_GENERALIZEDTime,
                            tag_der, &tag_len);
           break;
         case TYPE_OCTET_STRING:
-          _asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_OCTET_STRING, tag_der,
+          MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_OCTET_STRING, tag_der,
                          &tag_len);
           break;
         case TYPE_GENERALSTRING:
-          _asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_GENERALSTRING,
+          MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_GENERALSTRING,
                          tag_der, &tag_len);
           break;
         case TYPE_BIT_STRING:
-          _asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_BIT_STRING, tag_der,
+          MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_BIT_STRING, tag_der,
                          &tag_len);
           break;
         case TYPE_SEQUENCE:
         case TYPE_SEQUENCE_OF:
-          _asn1_tag_der (ASN1_CLASS_UNIVERSAL | ASN1_CLASS_STRUCTURED,
+          MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL | ASN1_CLASS_STRUCTURED,
                          ASN1_TAG_SEQUENCE, tag_der, &tag_len);
           break;
         case TYPE_SET:
         case TYPE_SET_OF:
-          _asn1_tag_der (ASN1_CLASS_UNIVERSAL | ASN1_CLASS_STRUCTURED,
+          MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL | ASN1_CLASS_STRUCTURED,
                          ASN1_TAG_SET, tag_der, &tag_len);
           break;
         case TYPE_TAG:
@@ -596,7 +596,7 @@ _asn1_insert_tag_der (node_asn * node, unsigned char *der, int *counter,
 }
 
 /******************************************************/
-/* Function : _asn1_ordering_set                      */
+/* Function : MHD__asn1_ordering_set                      */
 /* Description: puts the elements of a SET type in    */
 /* the correct order according to DER rules.          */
 /* Parameters:                                        */
@@ -605,7 +605,7 @@ _asn1_insert_tag_der (node_asn * node, unsigned char *der, int *counter,
 /* Return:                                            */
 /******************************************************/
 void
-_asn1_ordering_set (unsigned char *der, int der_len, node_asn * node)
+MHD__asn1_ordering_set (unsigned char *der, int der_len, node_asn * node)
 {
   struct vet
   {
@@ -637,7 +637,7 @@ _asn1_ordering_set (unsigned char *der, int der_len, node_asn * node)
   first = last = NULL;
   while (p)
     {
-      p_vet = (struct vet *) _asn1_alloca (sizeof (struct vet));
+      p_vet = (struct vet *) MHD__asn1_alloca (sizeof (struct vet));
       if (p_vet == NULL)
         return;
 
@@ -650,7 +650,7 @@ _asn1_ordering_set (unsigned char *der, int der_len, node_asn * node)
       last = p_vet;
 
       /* tag value calculation */
-      if (asn1_get_tag_der
+      if (MHD__asn1_get_tag_der
           (der + counter, der_len - counter, &class, &len2,
            &tag) != ASN1_SUCCESS)
         return;
@@ -658,7 +658,7 @@ _asn1_ordering_set (unsigned char *der, int der_len, node_asn * node)
       counter += len2;
 
       /* extraction and length */
-      len2 = asn1_get_length_der (der + counter, der_len - counter, &len);
+      len2 = MHD__asn1_get_length_der (der + counter, der_len - counter, &len);
       if (len2 < 0)
         return;
       counter += len + len2;
@@ -678,7 +678,7 @@ _asn1_ordering_set (unsigned char *der, int der_len, node_asn * node)
           if (p_vet->value > p2_vet->value)
             {
               /* change position */
-              temp = (unsigned char *) _asn1_alloca (p_vet->end - counter);
+              temp = (unsigned char *) MHD__asn1_alloca (p_vet->end - counter);
               if (temp == NULL)
                 return;
 
@@ -687,7 +687,7 @@ _asn1_ordering_set (unsigned char *der, int der_len, node_asn * node)
                       p2_vet->end - p_vet->end);
               memcpy (der + counter + p2_vet->end - p_vet->end, temp,
                       p_vet->end - counter);
-              _asn1_afree (temp);
+              MHD__asn1_afree (temp);
 
               tag = p_vet->value;
               p_vet->value = p2_vet->value;
@@ -705,13 +705,13 @@ _asn1_ordering_set (unsigned char *der, int der_len, node_asn * node)
         p_vet->prev->next = NULL;
       else
         first = NULL;
-      _asn1_afree (p_vet);
+      MHD__asn1_afree (p_vet);
       p_vet = first;
     }
 }
 
 /******************************************************/
-/* Function : _asn1_ordering_set_of                   */
+/* Function : MHD__asn1_ordering_set_of                   */
 /* Description: puts the elements of a SET OF type in */
 /* the correct order according to DER rules.          */
 /* Parameters:                                        */
@@ -720,7 +720,7 @@ _asn1_ordering_set (unsigned char *der, int der_len, node_asn * node)
 /* Return:                                            */
 /******************************************************/
 void
-_asn1_ordering_set_of (unsigned char *der, int der_len, node_asn * node)
+MHD__asn1_ordering_set_of (unsigned char *der, int der_len, node_asn * node)
 {
   struct vet
   {
@@ -751,7 +751,7 @@ _asn1_ordering_set_of (unsigned char *der, int der_len, node_asn * node)
   first = last = NULL;
   while (p)
     {
-      p_vet = (struct vet *) _asn1_alloca (sizeof (struct vet));
+      p_vet = (struct vet *) MHD__asn1_alloca (sizeof (struct vet));
       if (p_vet == NULL)
         return;
 
@@ -767,13 +767,13 @@ _asn1_ordering_set_of (unsigned char *der, int der_len, node_asn * node)
       if (der_len - counter > 0)
         {
 
-          if (asn1_get_tag_der
+          if (MHD__asn1_get_tag_der
               (der + counter, der_len - counter, &class, &len,
                NULL) != ASN1_SUCCESS)
             return;
           counter += len;
 
-          len2 = asn1_get_length_der (der + counter, der_len - counter, &len);
+          len2 = MHD__asn1_get_length_der (der + counter, der_len - counter, &len);
           if (len2 < 0)
             return;
           counter += len + len2;
@@ -816,7 +816,7 @@ _asn1_ordering_set_of (unsigned char *der, int der_len, node_asn * node)
           if (change == 1)
             {
               /* change position */
-              temp = (unsigned char *) _asn1_alloca (p_vet->end - counter);
+              temp = (unsigned char *) MHD__asn1_alloca (p_vet->end - counter);
               if (temp == NULL)
                 return;
 
@@ -825,7 +825,7 @@ _asn1_ordering_set_of (unsigned char *der, int der_len, node_asn * node)
                       (p2_vet->end) - (p_vet->end));
               memcpy (der + counter + (p2_vet->end) - (p_vet->end), temp,
                       (p_vet->end) - counter);
-              _asn1_afree (temp);
+              MHD__asn1_afree (temp);
 
               p_vet->end = counter + (p2_vet->end - p_vet->end);
             }
@@ -839,13 +839,13 @@ _asn1_ordering_set_of (unsigned char *der, int der_len, node_asn * node)
         p_vet->prev->next = NULL;
       else
         first = NULL;
-      _asn1_afree (p_vet);
+      MHD__asn1_afree (p_vet);
       p_vet = first;
     }
 }
 
 /**
-  * asn1_der_coding - Creates the DER encoding for the NAME structure
+  * MHD__asn1_der_coding - Creates the DER encoding for the NAME structure
   * @element: pointer to an ASN1 element
   * @name: the name of the structure you want to encode (it must be
   *   inside *POINTER).
@@ -871,17 +871,17 @@ _asn1_ordering_set_of (unsigned char *der, int der_len, node_asn * node)
   *     LEN will contain the length needed.
   *
   **/
-asn1_retCode
-asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
+MHD__asn1_retCode
+MHD__asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
                  char *ErrorDescription)
 {
   node_asn *node, *p, *p2;
   char temp[SIZEOF_UNSIGNED_LONG_INT * 3 + 1];
   int counter, counter_old, len2, len3, tlen, move, max_len, max_len_old;
-  asn1_retCode err;
+  MHD__asn1_retCode err;
   unsigned char *der = ider;
 
-  node = asn1_find_node (element, name);
+  node = MHD__asn1_find_node (element, name);
   if (node == NULL)
     return ASN1_ELEMENT_NOT_FOUND;
 
@@ -889,7 +889,7 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
    * That is because in some point we modify the
    * structure, and I don't know why! --nmav
    */
-  node = _asn1_copy_structure3 (node);
+  node = MHD__asn1_copy_structure3 (node);
   if (node == NULL)
     return ASN1_ELEMENT_NOT_FOUND;
 
@@ -905,7 +905,7 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
       max_len_old = max_len;
       if (move != UP)
         {
-          err = _asn1_insert_tag_der (p, der, &counter, &max_len);
+          err = MHD__asn1_insert_tag_der (p, der, &counter, &max_len);
           if (err != ASN1_SUCCESS && err != ASN1_MEM_ERROR)
             goto error;
         }
@@ -928,7 +928,7 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
             {
               if (p->value == NULL)
                 {
-                  _asn1_error_description_value_not_found (p,
+                  MHD__asn1_error_description_value_not_found (p,
                                                            ErrorDescription);
                   err = ASN1_VALUE_NOT_FOUND;
                   goto error;
@@ -958,12 +958,12 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
             {
               if (p->value == NULL)
                 {
-                  _asn1_error_description_value_not_found (p,
+                  MHD__asn1_error_description_value_not_found (p,
                                                            ErrorDescription);
                   err = ASN1_VALUE_NOT_FOUND;
                   goto error;
                 }
-              len2 = asn1_get_length_der (p->value, p->value_len, &len3);
+              len2 = MHD__asn1_get_length_der (p->value, p->value_len, &len3);
               if (len2 < 0)
                 {
                   err = ASN1_DER_ERROR;
@@ -986,13 +986,13 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
             {
               if (p->value == NULL)
                 {
-                  _asn1_error_description_value_not_found (p,
+                  MHD__asn1_error_description_value_not_found (p,
                                                            ErrorDescription);
                   err = ASN1_VALUE_NOT_FOUND;
                   goto error;
                 }
               len2 = max_len;
-              err = _asn1_objectid_der (p->value, der + counter, &len2);
+              err = MHD__asn1_objectid_der (p->value, der + counter, &len2);
               if (err != ASN1_SUCCESS && err != ASN1_MEM_ERROR)
                 goto error;
 
@@ -1004,12 +1004,12 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
         case TYPE_TIME:
           if (p->value == NULL)
             {
-              _asn1_error_description_value_not_found (p, ErrorDescription);
+              MHD__asn1_error_description_value_not_found (p, ErrorDescription);
               err = ASN1_VALUE_NOT_FOUND;
               goto error;
             }
           len2 = max_len;
-          err = _asn1_time_der (p->value, der + counter, &len2);
+          err = MHD__asn1_time_der (p->value, der + counter, &len2);
           if (err != ASN1_SUCCESS && err != ASN1_MEM_ERROR)
             goto error;
 
@@ -1020,11 +1020,11 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
         case TYPE_OCTET_STRING:
           if (p->value == NULL)
             {
-              _asn1_error_description_value_not_found (p, ErrorDescription);
+              MHD__asn1_error_description_value_not_found (p, ErrorDescription);
               err = ASN1_VALUE_NOT_FOUND;
               goto error;
             }
-          len2 = asn1_get_length_der (p->value, p->value_len, &len3);
+          len2 = MHD__asn1_get_length_der (p->value, p->value_len, &len3);
           if (len2 < 0)
             {
               err = ASN1_DER_ERROR;
@@ -1039,11 +1039,11 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
         case TYPE_GENERALSTRING:
           if (p->value == NULL)
             {
-              _asn1_error_description_value_not_found (p, ErrorDescription);
+              MHD__asn1_error_description_value_not_found (p, ErrorDescription);
               err = ASN1_VALUE_NOT_FOUND;
               goto error;
             }
-          len2 = asn1_get_length_der (p->value, p->value_len, &len3);
+          len2 = MHD__asn1_get_length_der (p->value, p->value_len, &len3);
           if (len2 < 0)
             {
               err = ASN1_DER_ERROR;
@@ -1058,11 +1058,11 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
         case TYPE_BIT_STRING:
           if (p->value == NULL)
             {
-              _asn1_error_description_value_not_found (p, ErrorDescription);
+              MHD__asn1_error_description_value_not_found (p, ErrorDescription);
               err = ASN1_VALUE_NOT_FOUND;
               goto error;
             }
-          len2 = asn1_get_length_der (p->value, p->value_len, &len3);
+          len2 = MHD__asn1_get_length_der (p->value, p->value_len, &len3);
           if (len2 < 0)
             {
               err = ASN1_DER_ERROR;
@@ -1078,10 +1078,10 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
         case TYPE_SET:
           if (move != UP)
             {
-              _asn1_ltostr (counter, temp);
+              MHD__asn1_ltostr (counter, temp);
               tlen = strlen (temp);
               if (tlen > 0)
-                _asn1_set_value (p, temp, tlen + 1);
+                MHD__asn1_set_value (p, temp, tlen + 1);
               if (p->down == NULL)
                 {
                   move = UP;
@@ -1105,10 +1105,10 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
           else
             {                   /* move==UP */
               len2 = strtol (p->value, NULL, 10);
-              _asn1_set_value (p, NULL, 0);
+              MHD__asn1_set_value (p, NULL, 0);
               if ((type_field (p->type) == TYPE_SET) && (max_len >= 0))
-                _asn1_ordering_set (der + len2, max_len - len2, p);
-              asn1_length_der (counter - len2, temp, &len3);
+                MHD__asn1_ordering_set (der + len2, max_len - len2, p);
+              MHD__asn1_length_der (counter - len2, temp, &len3);
               max_len -= len3;
               if (max_len >= 0)
                 {
@@ -1123,11 +1123,11 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
         case TYPE_SET_OF:
           if (move != UP)
             {
-              _asn1_ltostr (counter, temp);
+              MHD__asn1_ltostr (counter, temp);
               tlen = strlen (temp);
 
               if (tlen > 0)
-                _asn1_set_value (p, temp, tlen + 1);
+                MHD__asn1_set_value (p, temp, tlen + 1);
               p = p->down;
               while ((type_field (p->type) == TYPE_TAG)
                      || (type_field (p->type) == TYPE_SIZE))
@@ -1139,19 +1139,19 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
                   continue;
                 }
               else
-                p = _asn1_find_up (p);
+                p = MHD__asn1_find_up (p);
               move = UP;
             }
           if (move == UP)
             {
               len2 = strtol (p->value, NULL, 10);
-              _asn1_set_value (p, NULL, 0);
+              MHD__asn1_set_value (p, NULL, 0);
               if ((type_field (p->type) == TYPE_SET_OF)
                   && (max_len - len2 > 0))
                 {
-                  _asn1_ordering_set_of (der + len2, max_len - len2, p);
+                  MHD__asn1_ordering_set_of (der + len2, max_len - len2, p);
                 }
-              asn1_length_der (counter - len2, temp, &len3);
+              MHD__asn1_length_der (counter - len2, temp, &len3);
               max_len -= len3;
               if (max_len >= 0)
                 {
@@ -1165,11 +1165,11 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
         case TYPE_ANY:
           if (p->value == NULL)
             {
-              _asn1_error_description_value_not_found (p, ErrorDescription);
+              MHD__asn1_error_description_value_not_found (p, ErrorDescription);
               err = ASN1_VALUE_NOT_FOUND;
               goto error;
             }
-          len2 = asn1_get_length_der (p->value, p->value_len, &len3);
+          len2 = MHD__asn1_get_length_der (p->value, p->value_len, &len3);
           if (len2 < 0)
             {
               err = ASN1_DER_ERROR;
@@ -1188,7 +1188,7 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
 
       if ((move != DOWN) && (counter != counter_old))
         {
-          err = _asn1_complete_explicit_tag (p, der, &counter, &max_len);
+          err = MHD__asn1_complete_explicit_tag (p, der, &counter, &max_len);
           if (err != ASN1_SUCCESS && err != ASN1_MEM_ERROR)
             goto error;
         }
@@ -1211,7 +1211,7 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
             move = UP;
         }
       if (move == UP)
-        p = _asn1_find_up (p);
+        p = MHD__asn1_find_up (p);
     }
 
   *len = counter;
@@ -1225,6 +1225,6 @@ asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
   err = ASN1_SUCCESS;
 
 error:
-  asn1_delete_structure (&node);
+  MHD__asn1_delete_structure (&node);
   return err;
 }
diff --git a/src/daemon/https/minitasn1/decoding.c b/src/daemon/https/minitasn1/decoding.c
index 7174ce1f..27586b5e 100644
--- a/src/daemon/https/minitasn1/decoding.c
+++ b/src/daemon/https/minitasn1/decoding.c
@@ -35,18 +35,18 @@
 
 
 void
-_asn1_error_description_tag_error (node_asn * node, char *ErrorDescription)
+MHD__asn1_error_description_tag_error (node_asn * node, char *ErrorDescription)
 {
 
   Estrcpy (ErrorDescription, ":: tag error near element '");
-  _asn1_hierarchical_name (node, ErrorDescription + strlen (ErrorDescription),
+  MHD__asn1_hierarchical_name (node, ErrorDescription + strlen (ErrorDescription),
                            MAX_ERROR_DESCRIPTION_SIZE - 40);
   Estrcat (ErrorDescription, "'");
 
 }
 
 /**
- * asn1_get_length_der:
+ * MHD__asn1_get_length_der:
  * @der: DER data to decode.
  * @der_len: Length of DER data to decode.
  * @len: Output variable containing the length of the DER length field.
@@ -57,7 +57,7 @@ _asn1_error_description_tag_error (node_asn * node, char *ErrorDescription)
  *   length, or -2 when the value was too big.
  **/
 signed long
-asn1_get_length_der (const unsigned char *der, int der_len, int *len)
+MHD__asn1_get_length_der (const unsigned char *der, int der_len, int *len)
 {
   unsigned long ans;
   int k, punt;
@@ -104,7 +104,7 @@ asn1_get_length_der (const unsigned char *der, int der_len, int *len)
 
 
 /**
- * asn1_get_tag_der:
+ * MHD__asn1_get_tag_der:
  * @der: DER data to decode.
  * @der_len: Length of DER data to decode.
  * @cls: Output variable containing decoded class.
@@ -116,7 +116,7 @@ asn1_get_length_der (const unsigned char *der, int der_len, int *len)
  * Return value: Returns ASN1_SUCCESS on success, or an error.
  **/
 int
-asn1_get_tag_der (const unsigned char *der, int der_len,
+MHD__asn1_get_tag_der (const unsigned char *der, int der_len,
                   unsigned char *cls, int *len, unsigned long *tag)
 {
   int punt, ris;
@@ -164,7 +164,7 @@ asn1_get_tag_der (const unsigned char *der, int der_len,
 
 
 /**
- * asn1_get_octet_der:
+ * MHD__asn1_get_octet_der:
  * @der: DER data to decode containing the OCTET SEQUENCE.
  * @der_len: Length of DER data to decode.
  * @ret_len: Output variable containing the length of the DER data.
@@ -177,7 +177,7 @@ asn1_get_tag_der (const unsigned char *der, int der_len,
  * Return value: Returns ASN1_SUCCESS on success, or an error.
  **/
 int
-asn1_get_octet_der (const unsigned char *der, int der_len,
+MHD__asn1_get_octet_der (const unsigned char *der, int der_len,
                     int *ret_len, unsigned char *str, int str_size,
                     int *str_len)
 {
@@ -187,7 +187,7 @@ asn1_get_octet_der (const unsigned char *der, int der_len,
     return ASN1_GENERIC_ERROR;
 
   /* if(str==NULL) return ASN1_SUCCESS; */
-  *str_len = asn1_get_length_der (der, der_len, &len_len);
+  *str_len = MHD__asn1_get_length_der (der, der_len, &len_len);
 
   if (*str_len < 0)
     return ASN1_DER_ERROR;
@@ -208,14 +208,14 @@ asn1_get_octet_der (const unsigned char *der, int der_len,
 /* Returns ASN1_SUCCESS on success or an error code on error.
  */
 int
-_asn1_get_time_der (const unsigned char *der, int der_len, int *ret_len,
+MHD__asn1_get_time_der (const unsigned char *der, int der_len, int *ret_len,
                     char *str, int str_size)
 {
   int len_len, str_len;
 
   if (der_len <= 0 || str == NULL)
     return ASN1_DER_ERROR;
-  str_len = asn1_get_length_der (der, der_len, &len_len);
+  str_len = MHD__asn1_get_length_der (der, der_len, &len_len);
   if (str_len < 0 || str_size < str_len)
     return ASN1_DER_ERROR;
   memcpy (str, der + len_len, str_len);
@@ -228,7 +228,7 @@ _asn1_get_time_der (const unsigned char *der, int der_len, int *ret_len,
 
 
 void
-_asn1_get_objectid_der (const unsigned char *der, int der_len, int *ret_len,
+MHD__asn1_get_objectid_der (const unsigned char *der, int der_len, int *ret_len,
                         char *str, int str_size)
 {
   int len_len, len, k;
@@ -241,7 +241,7 @@ _asn1_get_objectid_der (const unsigned char *der, int der_len, int *ret_len,
 
   if (str == NULL || der_len <= 0)
     return;
-  len = asn1_get_length_der (der, der_len, &len_len);
+  len = MHD__asn1_get_length_der (der, der_len, &len_len);
 
   if (len < 0 || len > der_len || len_len > der_len)
     return;
@@ -249,9 +249,9 @@ _asn1_get_objectid_der (const unsigned char *der, int der_len, int *ret_len,
   val1 = der[len_len] / 40;
   val = der[len_len] - val1 * 40;
 
-  _asn1_str_cpy (str, str_size, _asn1_ltostr (val1, temp));
-  _asn1_str_cat (str, str_size, ".");
-  _asn1_str_cat (str, str_size, _asn1_ltostr (val, temp));
+  MHD__asn1_str_cpy (str, str_size, MHD__asn1_ltostr (val1, temp));
+  MHD__asn1_str_cat (str, str_size, ".");
+  MHD__asn1_str_cat (str, str_size, MHD__asn1_ltostr (val, temp));
 
   val = 0;
   for (k = 1; k < len; k++)
@@ -260,8 +260,8 @@ _asn1_get_objectid_der (const unsigned char *der, int der_len, int *ret_len,
       val |= der[len_len + k] & 0x7F;
       if (!(der[len_len + k] & 0x80))
         {
-          _asn1_str_cat (str, str_size, ".");
-          _asn1_str_cat (str, str_size, _asn1_ltostr (val, temp));
+          MHD__asn1_str_cat (str, str_size, ".");
+          MHD__asn1_str_cat (str, str_size, MHD__asn1_ltostr (val, temp));
           val = 0;
         }
     }
@@ -272,7 +272,7 @@ _asn1_get_objectid_der (const unsigned char *der, int der_len, int *ret_len,
 
 
 /**
- * asn1_get_bit_der:
+ * MHD__asn1_get_bit_der:
  * @der: DER data to decode containing the BIT SEQUENCE.
  * @der_len: Length of DER data to decode.
  * @ret_len: Output variable containing the length of the DER data.
@@ -285,7 +285,7 @@ _asn1_get_objectid_der (const unsigned char *der, int der_len, int *ret_len,
  * Return value: Return ASN1_SUCCESS on success, or an error.
  **/
 int
-asn1_get_bit_der (const unsigned char *der, int der_len,
+MHD__asn1_get_bit_der (const unsigned char *der, int der_len,
                   int *ret_len, unsigned char *str, int str_size,
                   int *bit_len)
 {
@@ -293,7 +293,7 @@ asn1_get_bit_der (const unsigned char *der, int der_len,
 
   if (der_len <= 0)
     return ASN1_GENERIC_ERROR;
-  len_byte = asn1_get_length_der (der, der_len, &len_len) - 1;
+  len_byte = MHD__asn1_get_length_der (der, der_len, &len_len) - 1;
   if (len_byte < 0)
     return ASN1_DER_ERROR;
 
@@ -314,7 +314,7 @@ asn1_get_bit_der (const unsigned char *der, int der_len,
 
 
 int
-_asn1_extract_tag_der (node_asn * node, const unsigned char *der, int der_len,
+MHD__asn1_extract_tag_der (node_asn * node, const unsigned char *der, int der_len,
                        int *ret_len)
 {
   node_asn *p;
@@ -345,7 +345,7 @@ _asn1_extract_tag_der (node_asn * node, const unsigned char *der, int der_len,
 
               if (p->type & CONST_EXPLICIT)
                 {
-                  if (asn1_get_tag_der
+                  if (MHD__asn1_get_tag_der
                       (der + counter, der_len - counter, &class, &len2,
                        &tag) != ASN1_SUCCESS)
                     return ASN1_DER_ERROR;
@@ -353,7 +353,7 @@ _asn1_extract_tag_der (node_asn * node, const unsigned char *der, int der_len,
                     return ASN1_DER_ERROR;
                   counter += len2;
                   len3 =
-                    asn1_get_length_der (der + counter, der_len - counter,
+                    MHD__asn1_get_length_der (der + counter, der_len - counter,
                                          &len2);
                   if (len3 < 0)
                     return ASN1_DER_ERROR;
@@ -393,7 +393,7 @@ _asn1_extract_tag_der (node_asn * node, const unsigned char *der, int der_len,
 
   if (is_tag_implicit)
     {
-      if (asn1_get_tag_der
+      if (MHD__asn1_get_tag_der
           (der + counter, der_len - counter, &class, &len2,
            &tag) != ASN1_SUCCESS)
         return ASN1_DER_ERROR;
@@ -421,7 +421,7 @@ _asn1_extract_tag_der (node_asn * node, const unsigned char *der, int der_len,
           return ASN1_SUCCESS;
         }
 
-      if (asn1_get_tag_der
+      if (MHD__asn1_get_tag_der
           (der + counter, der_len - counter, &class, &len2,
            &tag) != ASN1_SUCCESS)
         return ASN1_DER_ERROR;
@@ -507,7 +507,7 @@ _asn1_extract_tag_der (node_asn * node, const unsigned char *der, int der_len,
 
 
 int
-_asn1_delete_not_used (node_asn * node)
+MHD__asn1_delete_not_used (node_asn * node)
 {
   node_asn *p, *p2;
 
@@ -522,11 +522,11 @@ _asn1_delete_not_used (node_asn * node)
           p2 = NULL;
           if (p != node)
             {
-              p2 = _asn1_find_left (p);
+              p2 = MHD__asn1_find_left (p);
               if (!p2)
-                p2 = _asn1_find_up (p);
+                p2 = MHD__asn1_find_up (p);
             }
-          asn1_delete_structure (&p);
+          MHD__asn1_delete_structure (&p);
           p = p2;
         }
 
@@ -547,7 +547,7 @@ _asn1_delete_not_used (node_asn * node)
             {
               while (1)
                 {
-                  p = _asn1_find_up (p);
+                  p = MHD__asn1_find_up (p);
                   if (p == node)
                     {
                       p = NULL;
@@ -566,8 +566,8 @@ _asn1_delete_not_used (node_asn * node)
 }
 
 
-asn1_retCode
-_asn1_get_octet_string (const unsigned char *der, node_asn * node, int *len)
+MHD__asn1_retCode
+MHD__asn1_get_octet_string (const unsigned char *der, node_asn * node, int *len)
 {
   int len2, len3, counter, counter2, counter_end, tot_len, indefinite;
   unsigned char *temp, *temp2;
@@ -577,7 +577,7 @@ _asn1_get_octet_string (const unsigned char *der, node_asn * node, int *len)
   if (*(der - 1) & ASN1_CLASS_STRUCTURED)
     {
       tot_len = 0;
-      indefinite = asn1_get_length_der (der, *len, &len3);
+      indefinite = MHD__asn1_get_length_der (der, *len, &len3);
       if (indefinite < -1)
         return ASN1_DER_ERROR;
 
@@ -606,7 +606,7 @@ _asn1_get_octet_string (const unsigned char *der, node_asn * node, int *len)
 
           counter++;
 
-          len2 = asn1_get_length_der (der + counter, *len - counter, &len3);
+          len2 = MHD__asn1_get_length_der (der + counter, *len - counter, &len3);
           if (len2 <= 0)
             return ASN1_DER_ERROR;
 
@@ -617,20 +617,20 @@ _asn1_get_octet_string (const unsigned char *der, node_asn * node, int *len)
       /* copy */
       if (node)
         {
-          asn1_length_der (tot_len, NULL, &len2);
-          temp = _asn1_alloca (len2 + tot_len);
+          MHD__asn1_length_der (tot_len, NULL, &len2);
+          temp = MHD__asn1_alloca (len2 + tot_len);
           if (temp == NULL)
             {
               return ASN1_MEM_ALLOC_ERROR;
             }
 
-          asn1_length_der (tot_len, temp, &len2);
+          MHD__asn1_length_der (tot_len, temp, &len2);
           tot_len += len2;
           temp2 = temp + len2;
-          len2 = asn1_get_length_der (der, *len, &len3);
+          len2 = MHD__asn1_get_length_der (der, *len, &len3);
           if (len2 < -1)
             {
-              _asn1_afree (temp);
+              MHD__asn1_afree (temp);
               return ASN1_DER_ERROR;
             }
           counter2 = len3 + 1;
@@ -643,10 +643,10 @@ _asn1_get_octet_string (const unsigned char *der, node_asn * node, int *len)
           while (counter2 < counter_end)
             {
               len2 =
-                asn1_get_length_der (der + counter2, *len - counter, &len3);
+                MHD__asn1_get_length_der (der + counter2, *len - counter, &len3);
               if (len2 < -1)
                 {
-                  _asn1_afree (temp);
+                  MHD__asn1_afree (temp);
                   return ASN1_DER_ERROR;
                 }
 
@@ -658,19 +658,19 @@ _asn1_get_octet_string (const unsigned char *der, node_asn * node, int *len)
               counter2 += len2 + len3 + 1;
             }
 
-          _asn1_set_value (node, temp, tot_len);
-          _asn1_afree (temp);
+          MHD__asn1_set_value (node, temp, tot_len);
+          MHD__asn1_afree (temp);
         }
     }
   else
     {                           /* NOT STRUCTURED */
-      len2 = asn1_get_length_der (der, *len, &len3);
+      len2 = MHD__asn1_get_length_der (der, *len, &len3);
       if (len2 < 0)
         return ASN1_DER_ERROR;
       if (len3 + len2 > *len)
         return ASN1_DER_ERROR;
       if (node)
-        _asn1_set_value (node, der, len3 + len2);
+        MHD__asn1_set_value (node, der, len3 + len2);
       counter = len3 + len2;
     }
 
@@ -680,8 +680,8 @@ _asn1_get_octet_string (const unsigned char *der, node_asn * node, int *len)
 }
 
 
-asn1_retCode
-_asn1_get_indefinite_length_string (const unsigned char *der, int *len)
+MHD__asn1_retCode
+MHD__asn1_get_indefinite_length_string (const unsigned char *der, int *len)
 {
   int len2, len3, counter, indefinite;
   unsigned long tag;
@@ -704,14 +704,14 @@ _asn1_get_indefinite_length_string (const unsigned char *der, int *len)
             continue;
         }
 
-      if (asn1_get_tag_der
+      if (MHD__asn1_get_tag_der
           (der + counter, *len - counter, &class, &len2,
            &tag) != ASN1_SUCCESS)
         return ASN1_DER_ERROR;
       if (counter + len2 > *len)
         return ASN1_DER_ERROR;
       counter += len2;
-      len2 = asn1_get_length_der (der + counter, *len - counter, &len3);
+      len2 = MHD__asn1_get_length_der (der + counter, *len - counter, &len3);
       if (len2 < -1)
         return ASN1_DER_ERROR;
       if (len2 == -1)
@@ -732,7 +732,7 @@ _asn1_get_indefinite_length_string (const unsigned char *der, int *len)
 
 
 /**
-  * asn1_der_decoding - Fill the structure *ELEMENT with values of a DER encoding string.
+  * MHD__asn1_der_decoding - Fill the structure *ELEMENT with values of a DER encoding string.
   * @element: pointer to an ASN1 structure.
   * @ider: vector that contains the DER encoding.
   * @len: number of bytes of *@ider: @ider[0]..@ider[len-1].
@@ -755,8 +755,8 @@ _asn1_get_indefinite_length_string (const unsigned char *der, int *len)
   *     the structure NAME. *ELEMENT deleted.
   **/
 
-asn1_retCode
-asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
+MHD__asn1_retCode
+MHD__asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
                    char *errorDescription)
 {
   node_asn *node, *p, *p2, *p3;
@@ -774,7 +774,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
 
   if (node->type & CONST_OPTION)
     {
-      asn1_delete_structure (element);
+      MHD__asn1_delete_structure (element);
       return ASN1_GENERIC_ERROR;
     }
 
@@ -788,7 +788,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
         {
           if (p->type & CONST_SET)
             {
-              p2 = _asn1_find_up (p);
+              p2 = MHD__asn1_find_up (p);
               len2 = strtol (p2->value, NULL, 10);
               if (len2 == -1)
                 {
@@ -808,7 +808,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
                 }
               else if (counter > len2)
                 {
-                  asn1_delete_structure (element);
+                  MHD__asn1_delete_structure (element);
                   return ASN1_DER_ERROR;
                 }
               p2 = p2->down;
@@ -818,7 +818,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
                     {
                       if (type_field (p2->type) != TYPE_CHOICE)
                         ris =
-                          _asn1_extract_tag_der (p2, der + counter,
+                          MHD__asn1_extract_tag_der (p2, der + counter,
                                                  len - counter, &len2);
                       else
                         {
@@ -826,7 +826,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
                           while (p3)
                             {
                               ris =
-                                _asn1_extract_tag_der (p3, der + counter,
+                                MHD__asn1_extract_tag_der (p3, der + counter,
                                                        len - counter, &len2);
                               if (ris == ASN1_SUCCESS)
                                 break;
@@ -844,14 +844,14 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
                 }
               if (p2 == NULL)
                 {
-                  asn1_delete_structure (element);
+                  MHD__asn1_delete_structure (element);
                   return ASN1_DER_ERROR;
                 }
             }
 
           if ((p->type & CONST_OPTION) || (p->type & CONST_DEFAULT))
             {
-              p2 = _asn1_find_up (p);
+              p2 = MHD__asn1_find_up (p);
               len2 = strtol (p2->value, NULL, 10);
               if (counter == len2)
                 {
@@ -864,7 +864,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
                     move = UP;
 
                   if (p->type & CONST_OPTION)
-                    asn1_delete_structure (&p);
+                    MHD__asn1_delete_structure (&p);
 
                   p = p2;
                   continue;
@@ -877,7 +877,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
                 {
                   if (counter < len)
                     ris =
-                      _asn1_extract_tag_der (p->down, der + counter,
+                      MHD__asn1_extract_tag_der (p->down, der + counter,
                                              len - counter, &len2);
                   else
                     ris = ASN1_DER_ERROR;
@@ -886,19 +886,19 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
                       while (p->down->right)
                         {
                           p2 = p->down->right;
-                          asn1_delete_structure (&p2);
+                          MHD__asn1_delete_structure (&p2);
                         }
                       break;
                     }
                   else if (ris == ASN1_ERROR_TYPE_ANY)
                     {
-                      asn1_delete_structure (element);
+                      MHD__asn1_delete_structure (element);
                       return ASN1_ERROR_TYPE_ANY;
                     }
                   else
                     {
                       p2 = p->down;
-                      asn1_delete_structure (&p2);
+                      MHD__asn1_delete_structure (&p2);
                     }
                 }
 
@@ -906,7 +906,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
                 {
                   if (!(p->type & CONST_OPTION))
                     {
-                      asn1_delete_structure (element);
+                      MHD__asn1_delete_structure (element);
                       return ASN1_DER_ERROR;
                     }
                 }
@@ -916,7 +916,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
 
           if ((p->type & CONST_OPTION) || (p->type & CONST_DEFAULT))
             {
-              p2 = _asn1_find_up (p);
+              p2 = MHD__asn1_find_up (p);
               len2 = strtol (p2->value, NULL, 10);
               if ((len2 != -1) && (counter > len2))
                 ris = ASN1_TAG_ERROR;
@@ -924,7 +924,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
 
           if (ris == ASN1_SUCCESS)
             ris =
-              _asn1_extract_tag_der (p, der + counter, len - counter, &len2);
+              MHD__asn1_extract_tag_der (p, der + counter, len - counter, &len2);
           if (ris != ASN1_SUCCESS)
             {
               if (p->type & CONST_OPTION)
@@ -934,15 +934,15 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
                 }
               else if (p->type & CONST_DEFAULT)
                 {
-                  _asn1_set_value (p, NULL, 0);
+                  MHD__asn1_set_value (p, NULL, 0);
                   move = RIGHT;
                 }
               else
                 {
                   if (errorDescription != NULL)
-                    _asn1_error_description_tag_error (p, errorDescription);
+                    MHD__asn1_error_description_tag_error (p, errorDescription);
 
-                  asn1_delete_structure (element);
+                  MHD__asn1_delete_structure (element);
                   return ASN1_TAG_ERROR;
                 }
             }
@@ -957,7 +957,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
             case TYPE_NULL:
               if (der[counter])
                 {
-                  asn1_delete_structure (element);
+                  MHD__asn1_delete_structure (element);
                   return ASN1_DER_ERROR;
                 }
               counter++;
@@ -966,54 +966,54 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
             case TYPE_BOOLEAN:
               if (der[counter++] != 1)
                 {
-                  asn1_delete_structure (element);
+                  MHD__asn1_delete_structure (element);
                   return ASN1_DER_ERROR;
                 }
               if (der[counter++] == 0)
-                _asn1_set_value (p, "F", 1);
+                MHD__asn1_set_value (p, "F", 1);
               else
-                _asn1_set_value (p, "T", 1);
+                MHD__asn1_set_value (p, "T", 1);
               move = RIGHT;
               break;
             case TYPE_INTEGER:
             case TYPE_ENUMERATED:
               len2 =
-                asn1_get_length_der (der + counter, len - counter, &len3);
+                MHD__asn1_get_length_der (der + counter, len - counter, &len3);
               if (len2 < 0)
                 return ASN1_DER_ERROR;
               if (len2 + len3 > len - counter)
                 return ASN1_DER_ERROR;
-              _asn1_set_value (p, der + counter, len3 + len2);
+              MHD__asn1_set_value (p, der + counter, len3 + len2);
               counter += len3 + len2;
               move = RIGHT;
               break;
             case TYPE_OBJECT_ID:
-              _asn1_get_objectid_der (der + counter, len - counter, &len2,
+              MHD__asn1_get_objectid_der (der + counter, len - counter, &len2,
                                       temp, sizeof (temp));
               tlen = strlen (temp);
               if (tlen > 0)
-                _asn1_set_value (p, temp, tlen + 1);
+                MHD__asn1_set_value (p, temp, tlen + 1);
               counter += len2;
               move = RIGHT;
               break;
             case TYPE_TIME:
               result =
-                _asn1_get_time_der (der + counter, len - counter, &len2, temp,
+                MHD__asn1_get_time_der (der + counter, len - counter, &len2, temp,
                                     sizeof (temp) - 1);
               if (result != ASN1_SUCCESS)
                 {
-                  asn1_delete_structure (element);
+                  MHD__asn1_delete_structure (element);
                   return result;
                 }
               tlen = strlen (temp);
               if (tlen > 0)
-                _asn1_set_value (p, temp, tlen + 1);
+                MHD__asn1_set_value (p, temp, tlen + 1);
               counter += len2;
               move = RIGHT;
               break;
             case TYPE_OCTET_STRING:
               len3 = len - counter;
-              ris = _asn1_get_octet_string (der + counter, p, &len3);
+              ris = MHD__asn1_get_octet_string (der + counter, p, &len3);
               if (ris != ASN1_SUCCESS)
                 return ris;
               counter += len3;
@@ -1021,23 +1021,23 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
               break;
             case TYPE_GENERALSTRING:
               len2 =
-                asn1_get_length_der (der + counter, len - counter, &len3);
+                MHD__asn1_get_length_der (der + counter, len - counter, &len3);
               if (len2 < 0)
                 return ASN1_DER_ERROR;
               if (len3 + len2 > len - counter)
                 return ASN1_DER_ERROR;
-              _asn1_set_value (p, der + counter, len3 + len2);
+              MHD__asn1_set_value (p, der + counter, len3 + len2);
               counter += len3 + len2;
               move = RIGHT;
               break;
             case TYPE_BIT_STRING:
               len2 =
-                asn1_get_length_der (der + counter, len - counter, &len3);
+                MHD__asn1_get_length_der (der + counter, len - counter, &len3);
               if (len2 < 0)
                 return ASN1_DER_ERROR;
               if (len3 + len2 > len - counter)
                 return ASN1_DER_ERROR;
-              _asn1_set_value (p, der + counter, len3 + len2);
+              MHD__asn1_set_value (p, der + counter, len3 + len2);
               counter += len3 + len2;
               move = RIGHT;
               break;
@@ -1046,14 +1046,14 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
               if (move == UP)
                 {
                   len2 = strtol (p->value, NULL, 10);
-                  _asn1_set_value (p, NULL, 0);
+                  MHD__asn1_set_value (p, NULL, 0);
                   if (len2 == -1)
                     {           /* indefinite length method */
                       if (len - counter + 1 > 0)
                         {
                           if ((der[counter]) || der[counter + 1])
                             {
-                              asn1_delete_structure (element);
+                              MHD__asn1_delete_structure (element);
                               return ASN1_DER_ERROR;
                             }
                         }
@@ -1065,7 +1065,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
                     {           /* definite length method */
                       if (len2 != counter)
                         {
-                          asn1_delete_structure (element);
+                          MHD__asn1_delete_structure (element);
                           return ASN1_DER_ERROR;
                         }
                     }
@@ -1074,16 +1074,16 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
               else
                 {               /* move==DOWN || move==RIGHT */
                   len3 =
-                    asn1_get_length_der (der + counter, len - counter, &len2);
+                    MHD__asn1_get_length_der (der + counter, len - counter, &len2);
                   if (len3 < -1)
                     return ASN1_DER_ERROR;
                   counter += len2;
                   if (len3 > 0)
                     {
-                      _asn1_ltostr (counter + len3, temp);
+                      MHD__asn1_ltostr (counter + len3, temp);
                       tlen = strlen (temp);
                       if (tlen > 0)
-                        _asn1_set_value (p, temp, tlen + 1);
+                        MHD__asn1_set_value (p, temp, tlen + 1);
                       move = DOWN;
                     }
                   else if (len3 == 0)
@@ -1094,7 +1094,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
                           if (type_field (p2->type) != TYPE_TAG)
                             {
                               p3 = p2->right;
-                              asn1_delete_structure (&p2);
+                              MHD__asn1_delete_structure (&p2);
                               p2 = p3;
                             }
                           else
@@ -1104,7 +1104,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
                     }
                   else
                     {           /* indefinite length method */
-                      _asn1_set_value (p, "-1", 3);
+                      MHD__asn1_set_value (p, "-1", 3);
                       move = DOWN;
                     }
                 }
@@ -1120,31 +1120,31 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
                         return ASN1_DER_ERROR;
                       if ((der[counter]) || der[counter + 1])
                         {
-                          _asn1_append_sequence_set (p);
+                          MHD__asn1_append_sequence_set (p);
                           p = p->down;
                           while (p->right)
                             p = p->right;
                           move = RIGHT;
                           continue;
                         }
-                      _asn1_set_value (p, NULL, 0);
+                      MHD__asn1_set_value (p, NULL, 0);
                       counter += 2;
                     }
                   else
                     {           /* definite length method */
                       if (len2 > counter)
                         {
-                          _asn1_append_sequence_set (p);
+                          MHD__asn1_append_sequence_set (p);
                           p = p->down;
                           while (p->right)
                             p = p->right;
                           move = RIGHT;
                           continue;
                         }
-                      _asn1_set_value (p, NULL, 0);
+                      MHD__asn1_set_value (p, NULL, 0);
                       if (len2 != counter)
                         {
-                          asn1_delete_structure (element);
+                          MHD__asn1_delete_structure (element);
                           return ASN1_DER_ERROR;
                         }
                     }
@@ -1152,7 +1152,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
               else
                 {               /* move==DOWN || move==RIGHT */
                   len3 =
-                    asn1_get_length_der (der + counter, len - counter, &len2);
+                    MHD__asn1_get_length_der (der + counter, len - counter, &len2);
                   if (len3 < -1)
                     return ASN1_DER_ERROR;
                   counter += len2;
@@ -1160,36 +1160,36 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
                     {
                       if (len3 > 0)
                         {       /* definite length method */
-                          _asn1_ltostr (counter + len3, temp);
+                          MHD__asn1_ltostr (counter + len3, temp);
                           tlen = strlen (temp);
 
                           if (tlen > 0)
-                            _asn1_set_value (p, temp, tlen + 1);
+                            MHD__asn1_set_value (p, temp, tlen + 1);
                         }
                       else
                         {       /* indefinite length method */
-                          _asn1_set_value (p, "-1", 3);
+                          MHD__asn1_set_value (p, "-1", 3);
                         }
                       p2 = p->down;
                       while ((type_field (p2->type) == TYPE_TAG)
                              || (type_field (p2->type) == TYPE_SIZE))
                         p2 = p2->right;
                       if (p2->right == NULL)
-                        _asn1_append_sequence_set (p);
+                        MHD__asn1_append_sequence_set (p);
                       p = p2;
                     }
                 }
               move = RIGHT;
               break;
             case TYPE_ANY:
-              if (asn1_get_tag_der
+              if (MHD__asn1_get_tag_der
                   (der + counter, len - counter, &class, &len2,
                    &tag) != ASN1_SUCCESS)
                 return ASN1_DER_ERROR;
               if (counter + len2 > len)
                 return ASN1_DER_ERROR;
               len4 =
-                asn1_get_length_der (der + counter + len2,
+                MHD__asn1_get_length_der (der + counter + len2,
                                      len - counter - len2, &len3);
               if (len4 < -1)
                 return ASN1_DER_ERROR;
@@ -1198,17 +1198,17 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
               if (len4 != -1)
                 {
                   len2 += len4;
-                  asn1_length_der (len2 + len3, NULL, &len4);
-                  temp2 = (unsigned char *) _asn1_alloca (len2 + len3 + len4);
+                  MHD__asn1_length_der (len2 + len3, NULL, &len4);
+                  temp2 = (unsigned char *) MHD__asn1_alloca (len2 + len3 + len4);
                   if (temp2 == NULL)
                     {
-                      asn1_delete_structure (element);
+                      MHD__asn1_delete_structure (element);
                       return ASN1_MEM_ALLOC_ERROR;
                     }
 
-                  asn1_octet_der (der + counter, len2 + len3, temp2, &len4);
-                  _asn1_set_value (p, temp2, len4);
-                  _asn1_afree (temp2);
+                  MHD__asn1_octet_der (der + counter, len2 + len3, temp2, &len4);
+                  MHD__asn1_set_value (p, temp2, len4);
+                  MHD__asn1_afree (temp2);
                   counter += len2 + len3;
                 }
               else
@@ -1221,23 +1221,23 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
 
                   len2 = len - counter;
                   ris =
-                    _asn1_get_indefinite_length_string (der + counter, &len2);
+                    MHD__asn1_get_indefinite_length_string (der + counter, &len2);
                   if (ris != ASN1_SUCCESS)
                     {
-                      asn1_delete_structure (element);
+                      MHD__asn1_delete_structure (element);
                       return ris;
                     }
-                  asn1_length_der (len2, NULL, &len4);
-                  temp2 = (unsigned char *) _asn1_alloca (len2 + len4);
+                  MHD__asn1_length_der (len2, NULL, &len4);
+                  temp2 = (unsigned char *) MHD__asn1_alloca (len2 + len4);
                   if (temp2 == NULL)
                     {
-                      asn1_delete_structure (element);
+                      MHD__asn1_delete_structure (element);
                       return ASN1_MEM_ALLOC_ERROR;
                     }
 
-                  asn1_octet_der (der + counter, len2, temp2, &len4);
-                  _asn1_set_value (p, temp2, len4);
-                  _asn1_afree (temp2);
+                  MHD__asn1_octet_der (der + counter, len2, temp2, &len4);
+                  MHD__asn1_set_value (p, temp2, len4);
+                  MHD__asn1_afree (temp2);
                   counter += len2;
 
                   /* Check if a couple of 0x00 are present due to an EXPLICIT TAG with
@@ -1250,7 +1250,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
                         }
                       else
                         {
-                          asn1_delete_structure (element);
+                          MHD__asn1_delete_structure (element);
                           return ASN1_DER_ERROR;
                         }
                     }
@@ -1281,14 +1281,14 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
             move = UP;
         }
       if (move == UP)
-        p = _asn1_find_up (p);
+        p = MHD__asn1_find_up (p);
     }
 
-  _asn1_delete_not_used (*element);
+  MHD__asn1_delete_not_used (*element);
 
   if (counter != len)
     {
-      asn1_delete_structure (element);
+      MHD__asn1_delete_structure (element);
       return ASN1_DER_ERROR;
     }
 
@@ -1302,7 +1302,7 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
 #define EXIT         4
 
 /**
-  * asn1_der_decoding_element - Fill the element named ELEMENTNAME of the structure STRUCTURE with values of a DER encoding string.
+  * MHD__asn1_der_decoding_element - Fill the element named ELEMENTNAME of the structure STRUCTURE with values of a DER encoding string.
   * @structure: pointer to an ASN1 structure
   * @elementName: name of the element to fill
   * @ider: vector that contains the DER encoding of the whole structure.
@@ -1328,8 +1328,8 @@ asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
   *   the structure STRUCTURE. *ELEMENT deleted.
   *
   **/
-asn1_retCode
-asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
+MHD__asn1_retCode
+MHD__asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
                            const void *ider, int len, char *errorDescription)
 {
   node_asn *node, *p, *p2, *p3, *nodeFound = ASN1_TYPE_EMPTY;
@@ -1348,13 +1348,13 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
 
   if (elementName == NULL)
     {
-      asn1_delete_structure (structure);
+      MHD__asn1_delete_structure (structure);
       return ASN1_ELEMENT_NOT_FOUND;
     }
 
   if (node->type & CONST_OPTION)
     {
-      asn1_delete_structure (structure);
+      MHD__asn1_delete_structure (structure);
       return ASN1_GENERIC_ERROR;
     }
 
@@ -1365,7 +1365,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
         strcpy (currentName, (*structure)->name);
       else
         {
-          asn1_delete_structure (structure);
+          MHD__asn1_delete_structure (structure);
           return ASN1_MEM_ERROR;
         }
       if (!(strcmp (currentName, elementName)))
@@ -1404,7 +1404,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
         {
           if (p->type & CONST_SET)
             {
-              p2 = _asn1_find_up (p);
+              p2 = MHD__asn1_find_up (p);
               len2 = strtol (p2->value, NULL, 10);
               if (counter == len2)
                 {
@@ -1414,7 +1414,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
                 }
               else if (counter > len2)
                 {
-                  asn1_delete_structure (structure);
+                  MHD__asn1_delete_structure (structure);
                   return ASN1_DER_ERROR;
                 }
               p2 = p2->down;
@@ -1424,7 +1424,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
                     {
                       if (type_field (p2->type) != TYPE_CHOICE)
                         ris =
-                          _asn1_extract_tag_der (p2, der + counter,
+                          MHD__asn1_extract_tag_der (p2, der + counter,
                                                  len - counter, &len2);
                       else
                         {
@@ -1432,7 +1432,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
                           while (p3)
                             {
                               ris =
-                                _asn1_extract_tag_der (p3, der + counter,
+                                MHD__asn1_extract_tag_der (p3, der + counter,
                                                        len - counter, &len2);
                               if (ris == ASN1_SUCCESS)
                                 break;
@@ -1450,14 +1450,14 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
                 }
               if (p2 == NULL)
                 {
-                  asn1_delete_structure (structure);
+                  MHD__asn1_delete_structure (structure);
                   return ASN1_DER_ERROR;
                 }
             }
 
           if ((p->type & CONST_OPTION) || (p->type & CONST_DEFAULT))
             {
-              p2 = _asn1_find_up (p);
+              p2 = MHD__asn1_find_up (p);
               len2 = strtol (p2->value, NULL, 10);
               if (counter == len2)
                 {
@@ -1470,7 +1470,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
                     move = UP;
 
                   if (p->type & CONST_OPTION)
-                    asn1_delete_structure (&p);
+                    MHD__asn1_delete_structure (&p);
 
                   p = p2;
                   continue;
@@ -1483,7 +1483,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
                 {
                   if (counter < len)
                     ris =
-                      _asn1_extract_tag_der (p->down, der + counter,
+                      MHD__asn1_extract_tag_der (p->down, der + counter,
                                              len - counter, &len2);
                   else
                     ris = ASN1_DER_ERROR;
@@ -1492,19 +1492,19 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
                       while (p->down->right)
                         {
                           p2 = p->down->right;
-                          asn1_delete_structure (&p2);
+                          MHD__asn1_delete_structure (&p2);
                         }
                       break;
                     }
                   else if (ris == ASN1_ERROR_TYPE_ANY)
                     {
-                      asn1_delete_structure (structure);
+                      MHD__asn1_delete_structure (structure);
                       return ASN1_ERROR_TYPE_ANY;
                     }
                   else
                     {
                       p2 = p->down;
-                      asn1_delete_structure (&p2);
+                      MHD__asn1_delete_structure (&p2);
                     }
                 }
 
@@ -1512,7 +1512,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
                 {
                   if (!(p->type & CONST_OPTION))
                     {
-                      asn1_delete_structure (structure);
+                      MHD__asn1_delete_structure (structure);
                       return ASN1_DER_ERROR;
                     }
                 }
@@ -1522,7 +1522,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
 
           if ((p->type & CONST_OPTION) || (p->type & CONST_DEFAULT))
             {
-              p2 = _asn1_find_up (p);
+              p2 = MHD__asn1_find_up (p);
               len2 = strtol (p2->value, NULL, 10);
               if (counter > len2)
                 ris = ASN1_TAG_ERROR;
@@ -1530,7 +1530,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
 
           if (ris == ASN1_SUCCESS)
             ris =
-              _asn1_extract_tag_der (p, der + counter, len - counter, &len2);
+              MHD__asn1_extract_tag_der (p, der + counter, len - counter, &len2);
           if (ris != ASN1_SUCCESS)
             {
               if (p->type & CONST_OPTION)
@@ -1540,15 +1540,15 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
                 }
               else if (p->type & CONST_DEFAULT)
                 {
-                  _asn1_set_value (p, NULL, 0);
+                  MHD__asn1_set_value (p, NULL, 0);
                   move = RIGHT;
                 }
               else
                 {
                   if (errorDescription != NULL)
-                    _asn1_error_description_tag_error (p, errorDescription);
+                    MHD__asn1_error_description_tag_error (p, errorDescription);
 
-                  asn1_delete_structure (structure);
+                  MHD__asn1_delete_structure (structure);
                   return ASN1_TAG_ERROR;
                 }
             }
@@ -1563,7 +1563,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
             case TYPE_NULL:
               if (der[counter])
                 {
-                  asn1_delete_structure (structure);
+                  MHD__asn1_delete_structure (structure);
                   return ASN1_DER_ERROR;
                 }
 
@@ -1576,16 +1576,16 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
             case TYPE_BOOLEAN:
               if (der[counter++] != 1)
                 {
-                  asn1_delete_structure (structure);
+                  MHD__asn1_delete_structure (structure);
                   return ASN1_DER_ERROR;
                 }
 
               if (state == FOUND)
                 {
                   if (der[counter++] == 0)
-                    _asn1_set_value (p, "F", 1);
+                    MHD__asn1_set_value (p, "F", 1);
                   else
-                    _asn1_set_value (p, "T", 1);
+                    MHD__asn1_set_value (p, "T", 1);
 
                   if (p == nodeFound)
                     state = EXIT;
@@ -1599,14 +1599,14 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
             case TYPE_INTEGER:
             case TYPE_ENUMERATED:
               len2 =
-                asn1_get_length_der (der + counter, len - counter, &len3);
+                MHD__asn1_get_length_der (der + counter, len - counter, &len3);
               if (len2 < 0)
                 return ASN1_DER_ERROR;
               if (state == FOUND)
                 {
                   if (len3 + len2 > len - counter)
                     return ASN1_DER_ERROR;
-                  _asn1_set_value (p, der + counter, len3 + len2);
+                  MHD__asn1_set_value (p, der + counter, len3 + len2);
 
                   if (p == nodeFound)
                     state = EXIT;
@@ -1617,12 +1617,12 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
             case TYPE_OBJECT_ID:
               if (state == FOUND)
                 {
-                  _asn1_get_objectid_der (der + counter, len - counter, &len2,
+                  MHD__asn1_get_objectid_der (der + counter, len - counter, &len2,
                                           temp, sizeof (temp));
                   tlen = strlen (temp);
 
                   if (tlen > 0)
-                    _asn1_set_value (p, temp, tlen + 1);
+                    MHD__asn1_set_value (p, temp, tlen + 1);
 
                   if (p == nodeFound)
                     state = EXIT;
@@ -1630,7 +1630,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
               else
                 {
                   len2 =
-                    asn1_get_length_der (der + counter, len - counter, &len3);
+                    MHD__asn1_get_length_der (der + counter, len - counter, &len3);
                   if (len2 < 0)
                     return ASN1_DER_ERROR;
                   len2 += len3;
@@ -1643,17 +1643,17 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
               if (state == FOUND)
                 {
                   result =
-                    _asn1_get_time_der (der + counter, len - counter, &len2,
+                    MHD__asn1_get_time_der (der + counter, len - counter, &len2,
                                         temp, sizeof (temp) - 1);
                   if (result != ASN1_SUCCESS)
                     {
-                      asn1_delete_structure (structure);
+                      MHD__asn1_delete_structure (structure);
                       return result;
                     }
 
                   tlen = strlen (temp);
                   if (tlen > 0)
-                    _asn1_set_value (p, temp, tlen + 1);
+                    MHD__asn1_set_value (p, temp, tlen + 1);
 
                   if (p == nodeFound)
                     state = EXIT;
@@ -1661,7 +1661,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
               else
                 {
                   len2 =
-                    asn1_get_length_der (der + counter, len - counter, &len3);
+                    MHD__asn1_get_length_der (der + counter, len - counter, &len3);
                   if (len2 < 0)
                     return ASN1_DER_ERROR;
                   len2 += len3;
@@ -1674,12 +1674,12 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
               len3 = len - counter;
               if (state == FOUND)
                 {
-                  ris = _asn1_get_octet_string (der + counter, p, &len3);
+                  ris = MHD__asn1_get_octet_string (der + counter, p, &len3);
                   if (p == nodeFound)
                     state = EXIT;
                 }
               else
-                ris = _asn1_get_octet_string (der + counter, NULL, &len3);
+                ris = MHD__asn1_get_octet_string (der + counter, NULL, &len3);
 
               if (ris != ASN1_SUCCESS)
                 return ris;
@@ -1688,14 +1688,14 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
               break;
             case TYPE_GENERALSTRING:
               len2 =
-                asn1_get_length_der (der + counter, len - counter, &len3);
+                MHD__asn1_get_length_der (der + counter, len - counter, &len3);
               if (len2 < 0)
                 return ASN1_DER_ERROR;
               if (state == FOUND)
                 {
                   if (len3 + len2 > len - counter)
                     return ASN1_DER_ERROR;
-                  _asn1_set_value (p, der + counter, len3 + len2);
+                  MHD__asn1_set_value (p, der + counter, len3 + len2);
 
                   if (p == nodeFound)
                     state = EXIT;
@@ -1705,14 +1705,14 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
               break;
             case TYPE_BIT_STRING:
               len2 =
-                asn1_get_length_der (der + counter, len - counter, &len3);
+                MHD__asn1_get_length_der (der + counter, len - counter, &len3);
               if (len2 < 0)
                 return ASN1_DER_ERROR;
               if (state == FOUND)
                 {
                   if (len3 + len2 > len - counter)
                     return ASN1_DER_ERROR;
-                  _asn1_set_value (p, der + counter, len3 + len2);
+                  MHD__asn1_set_value (p, der + counter, len3 + len2);
 
                   if (p == nodeFound)
                     state = EXIT;
@@ -1725,12 +1725,12 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
               if (move == UP)
                 {
                   len2 = strtol (p->value, NULL, 10);
-                  _asn1_set_value (p, NULL, 0);
+                  MHD__asn1_set_value (p, NULL, 0);
                   if (len2 == -1)
                     {           /* indefinite length method */
                       if ((der[counter]) || der[counter + 1])
                         {
-                          asn1_delete_structure (structure);
+                          MHD__asn1_delete_structure (structure);
                           return ASN1_DER_ERROR;
                         }
                       counter += 2;
@@ -1739,7 +1739,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
                     {           /* definite length method */
                       if (len2 != counter)
                         {
-                          asn1_delete_structure (structure);
+                          MHD__asn1_delete_structure (structure);
                           return ASN1_DER_ERROR;
                         }
                     }
@@ -1752,7 +1752,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
                   if (state == OTHER_BRANCH)
                     {
                       len3 =
-                        asn1_get_length_der (der + counter, len - counter,
+                        MHD__asn1_get_length_der (der + counter, len - counter,
                                              &len2);
                       if (len3 < 0)
                         return ASN1_DER_ERROR;
@@ -1762,18 +1762,18 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
                   else
                     {           /*  state==SAME_BRANCH or state==FOUND */
                       len3 =
-                        asn1_get_length_der (der + counter, len - counter,
+                        MHD__asn1_get_length_der (der + counter, len - counter,
                                              &len2);
                       if (len3 < 0)
                         return ASN1_DER_ERROR;
                       counter += len2;
                       if (len3 > 0)
                         {
-                          _asn1_ltostr (counter + len3, temp);
+                          MHD__asn1_ltostr (counter + len3, temp);
                           tlen = strlen (temp);
 
                           if (tlen > 0)
-                            _asn1_set_value (p, temp, tlen + 1);
+                            MHD__asn1_set_value (p, temp, tlen + 1);
                           move = DOWN;
                         }
                       else if (len3 == 0)
@@ -1784,7 +1784,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
                               if (type_field (p2->type) != TYPE_TAG)
                                 {
                                   p3 = p2->right;
-                                  asn1_delete_structure (&p2);
+                                  MHD__asn1_delete_structure (&p2);
                                   p2 = p3;
                                 }
                               else
@@ -1794,7 +1794,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
                         }
                       else
                         {       /* indefinite length method */
-                          _asn1_set_value (p, "-1", 3);
+                          MHD__asn1_set_value (p, "-1", 3);
                           move = DOWN;
                         }
                     }
@@ -1807,17 +1807,17 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
                   len2 = strtol (p->value, NULL, 10);
                   if (len2 > counter)
                     {
-                      _asn1_append_sequence_set (p);
+                      MHD__asn1_append_sequence_set (p);
                       p = p->down;
                       while (p->right)
                         p = p->right;
                       move = RIGHT;
                       continue;
                     }
-                  _asn1_set_value (p, NULL, 0);
+                  MHD__asn1_set_value (p, NULL, 0);
                   if (len2 != counter)
                     {
-                      asn1_delete_structure (structure);
+                      MHD__asn1_delete_structure (structure);
                       return ASN1_DER_ERROR;
                     }
 
@@ -1829,7 +1829,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
                   if (state == OTHER_BRANCH)
                     {
                       len3 =
-                        asn1_get_length_der (der + counter, len - counter,
+                        MHD__asn1_get_length_der (der + counter, len - counter,
                                              &len2);
                       if (len3 < 0)
                         return ASN1_DER_ERROR;
@@ -1839,24 +1839,24 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
                   else
                     {           /* state==FOUND or state==SAME_BRANCH */
                       len3 =
-                        asn1_get_length_der (der + counter, len - counter,
+                        MHD__asn1_get_length_der (der + counter, len - counter,
                                              &len2);
                       if (len3 < 0)
                         return ASN1_DER_ERROR;
                       counter += len2;
                       if (len3)
                         {
-                          _asn1_ltostr (counter + len3, temp);
+                          MHD__asn1_ltostr (counter + len3, temp);
                           tlen = strlen (temp);
 
                           if (tlen > 0)
-                            _asn1_set_value (p, temp, tlen + 1);
+                            MHD__asn1_set_value (p, temp, tlen + 1);
                           p2 = p->down;
                           while ((type_field (p2->type) == TYPE_TAG)
                                  || (type_field (p2->type) == TYPE_SIZE))
                             p2 = p2->right;
                           if (p2->right == NULL)
-                            _asn1_append_sequence_set (p);
+                            MHD__asn1_append_sequence_set (p);
                           p = p2;
                           state = FOUND;
                         }
@@ -1865,7 +1865,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
 
               break;
             case TYPE_ANY:
-              if (asn1_get_tag_der
+              if (MHD__asn1_get_tag_der
                   (der + counter, len - counter, &class, &len2,
                    &tag) != ASN1_SUCCESS)
                 return ASN1_DER_ERROR;
@@ -1873,7 +1873,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
                 return ASN1_DER_ERROR;
 
               len4 =
-                asn1_get_length_der (der + counter + len2,
+                MHD__asn1_get_length_der (der + counter + len2,
                                      len - counter - len2, &len3);
               if (len4 < -1)
                 return ASN1_DER_ERROR;
@@ -1883,19 +1883,19 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
                   len2 += len4;
                   if (state == FOUND)
                     {
-                      asn1_length_der (len2 + len3, NULL, &len4);
+                      MHD__asn1_length_der (len2 + len3, NULL, &len4);
                       temp2 =
-                        (unsigned char *) _asn1_alloca (len2 + len3 + len4);
+                        (unsigned char *) MHD__asn1_alloca (len2 + len3 + len4);
                       if (temp2 == NULL)
                         {
-                          asn1_delete_structure (structure);
+                          MHD__asn1_delete_structure (structure);
                           return ASN1_MEM_ALLOC_ERROR;
                         }
 
-                      asn1_octet_der (der + counter, len2 + len3, temp2,
+                      MHD__asn1_octet_der (der + counter, len2 + len3, temp2,
                                       &len4);
-                      _asn1_set_value (p, temp2, len4);
-                      _asn1_afree (temp2);
+                      MHD__asn1_set_value (p, temp2, len4);
+                      MHD__asn1_afree (temp2);
 
                       if (p == nodeFound)
                         state = EXIT;
@@ -1912,26 +1912,26 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
 
                   len2 = len - counter;
                   ris =
-                    _asn1_get_indefinite_length_string (der + counter, &len2);
+                    MHD__asn1_get_indefinite_length_string (der + counter, &len2);
                   if (ris != ASN1_SUCCESS)
                     {
-                      asn1_delete_structure (structure);
+                      MHD__asn1_delete_structure (structure);
                       return ris;
                     }
 
                   if (state == FOUND)
                     {
-                      asn1_length_der (len2, NULL, &len4);
-                      temp2 = (unsigned char *) _asn1_alloca (len2 + len4);
+                      MHD__asn1_length_der (len2, NULL, &len4);
+                      temp2 = (unsigned char *) MHD__asn1_alloca (len2 + len4);
                       if (temp2 == NULL)
                         {
-                          asn1_delete_structure (structure);
+                          MHD__asn1_delete_structure (structure);
                           return ASN1_MEM_ALLOC_ERROR;
                         }
 
-                      asn1_octet_der (der + counter, len2, temp2, &len4);
-                      _asn1_set_value (p, temp2, len4);
-                      _asn1_afree (temp2);
+                      MHD__asn1_octet_der (der + counter, len2, temp2, &len4);
+                      MHD__asn1_set_value (p, temp2, len4);
+                      MHD__asn1_afree (temp2);
 
                       if (p == nodeFound)
                         state = EXIT;
@@ -1949,7 +1949,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
                         }
                       else
                         {
-                          asn1_delete_structure (structure);
+                          MHD__asn1_delete_structure (structure);
                           return ASN1_DER_ERROR;
                         }
                     }
@@ -1983,7 +1983,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
                     }
                   else
                     {
-                      asn1_delete_structure (structure);
+                      MHD__asn1_delete_structure (structure);
                       return ASN1_MEM_ERROR;
                     }
                   if (!(strcmp (currentName, elementName)))
@@ -2026,7 +2026,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
                     strcat (currentName, p->name);
                   else
                     {
-                      asn1_delete_structure (structure);
+                      MHD__asn1_delete_structure (structure);
                       return ASN1_MEM_ERROR;
                     }
 
@@ -2049,7 +2049,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
 
       if (move == UP)
         {
-          p = _asn1_find_up (p);
+          p = MHD__asn1_find_up (p);
 
           if (state != FOUND)
             {
@@ -2077,11 +2077,11 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
         }
     }
 
-  _asn1_delete_not_used (*structure);
+  MHD__asn1_delete_not_used (*structure);
 
   if (counter > len)
     {
-      asn1_delete_structure (structure);
+      MHD__asn1_delete_structure (structure);
       return ASN1_DER_ERROR;
     }
 
@@ -2091,7 +2091,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
 
 
 /**
-  * asn1_der_decoding_startEnd - Find the start and end point of an element in a DER encoding string.
+  * MHD__asn1_der_decoding_startEnd - Find the start and end point of an element in a DER encoding string.
   * @element: pointer to an ASN1 element
   * @ider: vector that contains the DER encoding.
   * @len: number of bytes of *@ider: @ider[0]..@ider[len-1]
@@ -2103,7 +2103,7 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
   *
   * Find the start and end point of an element in a DER encoding
   * string. I mean that if you have a der encoding and you have
-  * already used the function "asn1_der_decoding" to fill a structure,
+  * already used the function "MHD__asn1_der_decoding" to fill a structure,
   * it may happen that you want to find the piece of string concerning
   * an element of the structure.
   *
@@ -2120,8 +2120,8 @@ asn1_der_decoding_element (ASN1_TYPE * structure, const char *elementName,
   *   the structure ELEMENT.
   *
   **/
-asn1_retCode
-asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
+MHD__asn1_retCode
+MHD__asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
                             const char *name_element, int *start, int *end)
 {
   node_asn *node, *node_to_find, *p, *p2, *p3;
@@ -2136,7 +2136,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
   if (node == ASN1_TYPE_EMPTY)
     return ASN1_ELEMENT_NOT_FOUND;
 
-  node_to_find = asn1_find_node (node, name_element);
+  node_to_find = MHD__asn1_find_node (node, name_element);
 
   if (node_to_find == NULL)
     return ASN1_ELEMENT_NOT_FOUND;
@@ -2162,7 +2162,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
         {
           if (p->type & CONST_SET)
             {
-              p2 = _asn1_find_up (p);
+              p2 = MHD__asn1_find_up (p);
               len2 = strtol (p2->value, NULL, 10);
               if (len2 == -1)
                 {
@@ -2189,13 +2189,13 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
                     {           /* CONTROLLARE */
                       if (type_field (p2->type) != TYPE_CHOICE)
                         ris =
-                          _asn1_extract_tag_der (p2, der + counter,
+                          MHD__asn1_extract_tag_der (p2, der + counter,
                                                  len - counter, &len2);
                       else
                         {
                           p3 = p2->down;
                           ris =
-                            _asn1_extract_tag_der (p3, der + counter,
+                            MHD__asn1_extract_tag_der (p3, der + counter,
                                                    len - counter, &len2);
                         }
                       if (ris == ASN1_SUCCESS)
@@ -2218,7 +2218,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
             {
               p = p->down;
               ris =
-                _asn1_extract_tag_der (p, der + counter, len - counter,
+                MHD__asn1_extract_tag_der (p, der + counter, len - counter,
                                        &len2);
               if (p == node_to_find)
                 *start = counter;
@@ -2226,7 +2226,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
 
           if (ris == ASN1_SUCCESS)
             ris =
-              _asn1_extract_tag_der (p, der + counter, len - counter, &len2);
+              MHD__asn1_extract_tag_der (p, der + counter, len - counter, &len2);
           if (ris != ASN1_SUCCESS)
             {
               if (p->type & CONST_OPTION)
@@ -2266,7 +2266,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
             case TYPE_INTEGER:
             case TYPE_ENUMERATED:
               len2 =
-                asn1_get_length_der (der + counter, len - counter, &len3);
+                MHD__asn1_get_length_der (der + counter, len - counter, &len3);
               if (len2 < 0)
                 return ASN1_DER_ERROR;
               counter += len3 + len2;
@@ -2274,7 +2274,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
               break;
             case TYPE_OBJECT_ID:
               len2 =
-                asn1_get_length_der (der + counter, len - counter, &len3);
+                MHD__asn1_get_length_der (der + counter, len - counter, &len3);
               if (len2 < 0)
                 return ASN1_DER_ERROR;
               counter += len2 + len3;
@@ -2282,7 +2282,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
               break;
             case TYPE_TIME:
               len2 =
-                asn1_get_length_der (der + counter, len - counter, &len3);
+                MHD__asn1_get_length_der (der + counter, len - counter, &len3);
               if (len2 < 0)
                 return ASN1_DER_ERROR;
               counter += len2 + len3;
@@ -2290,7 +2290,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
               break;
             case TYPE_OCTET_STRING:
               len3 = len - counter;
-              ris = _asn1_get_octet_string (der + counter, NULL, &len3);
+              ris = MHD__asn1_get_octet_string (der + counter, NULL, &len3);
               if (ris != ASN1_SUCCESS)
                 return ris;
               counter += len3;
@@ -2298,7 +2298,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
               break;
             case TYPE_GENERALSTRING:
               len2 =
-                asn1_get_length_der (der + counter, len - counter, &len3);
+                MHD__asn1_get_length_der (der + counter, len - counter, &len3);
               if (len2 < 0)
                 return ASN1_DER_ERROR;
               counter += len3 + len2;
@@ -2306,7 +2306,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
               break;
             case TYPE_BIT_STRING:
               len2 =
-                asn1_get_length_der (der + counter, len - counter, &len3);
+                MHD__asn1_get_length_der (der + counter, len - counter, &len3);
               if (len2 < 0)
                 return ASN1_DER_ERROR;
               counter += len3 + len2;
@@ -2317,7 +2317,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
               if (move != UP)
                 {
                   len3 =
-                    asn1_get_length_der (der + counter, len - counter, &len2);
+                    MHD__asn1_get_length_der (der + counter, len - counter, &len2);
                   if (len3 < -1)
                     return ASN1_DER_ERROR;
                   counter += len2;
@@ -2338,7 +2338,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
               if (move != UP)
                 {
                   len3 =
-                    asn1_get_length_der (der + counter, len - counter, &len2);
+                    MHD__asn1_get_length_der (der + counter, len - counter, &len2);
                   if (len3 < -1)
                     return ASN1_DER_ERROR;
                   counter += len2;
@@ -2361,7 +2361,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
               move = RIGHT;
               break;
             case TYPE_ANY:
-              if (asn1_get_tag_der
+              if (MHD__asn1_get_tag_der
                   (der + counter, len - counter, &class, &len2,
                    &tag) != ASN1_SUCCESS)
                 return ASN1_DER_ERROR;
@@ -2369,7 +2369,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
                 return ASN1_DER_ERROR;
 
               len4 =
-                asn1_get_length_der (der + counter + len2,
+                MHD__asn1_get_length_der (der + counter + len2,
                                      len - counter - len2, &len3);
               if (len4 < -1)
                 return ASN1_DER_ERROR;
@@ -2388,7 +2388,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
 
                   len2 = len - counter;
                   ris =
-                    _asn1_get_indefinite_length_string (der + counter, &len2);
+                    MHD__asn1_get_indefinite_length_string (der + counter, &len2);
                   if (ris != ASN1_SUCCESS)
                     return ris;
                   counter += len2;
@@ -2435,7 +2435,7 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
             move = UP;
         }
       if (move == UP)
-        p = _asn1_find_up (p);
+        p = MHD__asn1_find_up (p);
     }
 
   return ASN1_ELEMENT_NOT_FOUND;
@@ -2443,12 +2443,12 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
 
 
 /**
-  * asn1_expand_any_defined_by - Expand "ANY DEFINED BY" fields in structure.
+  * MHD__asn1_expand_any_defined_by - Expand "ANY DEFINED BY" fields in structure.
   * @definitions: ASN1 definitions
   * @element: pointer to an ASN1 structure
   *
   * Expands every "ANY DEFINED BY" element of a structure created from
-  * a DER decoding process (asn1_der_decoding function). The element ANY
+  * a DER decoding process (MHD__asn1_der_decoding function). The element ANY
   * must be defined by an OBJECT IDENTIFIER. The type used to expand
   * the element ANY is the first one following the definition of
   * the actual value of the OBJECT IDENTIFIER.
@@ -2464,12 +2464,12 @@ asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
   *   other errors: Result of der decoding process.
   **/
 
-asn1_retCode
-asn1_expand_any_defined_by (ASN1_TYPE definitions, ASN1_TYPE * element)
+MHD__asn1_retCode
+MHD__asn1_expand_any_defined_by (ASN1_TYPE definitions, ASN1_TYPE * element)
 {
   char definitionsName[MAX_NAME_SIZE], name[2 * MAX_NAME_SIZE + 1],
     value[MAX_NAME_SIZE];
-  asn1_retCode retCode = ASN1_SUCCESS, result;
+  MHD__asn1_retCode retCode = ASN1_SUCCESS, result;
   int len, len2, len3;
   ASN1_TYPE p, p2, p3, aux = ASN1_TYPE_EMPTY;
   char errorDescription[MAX_ERROR_DESCRIPTION_SIZE];
@@ -2500,7 +2500,7 @@ asn1_expand_any_defined_by (ASN1_TYPE definitions, ASN1_TYPE * element)
                   break;
                 }
 
-              p3 = _asn1_find_up (p);
+              p3 = MHD__asn1_find_up (p);
 
               if (!p3)
                 {
@@ -2520,8 +2520,8 @@ asn1_expand_any_defined_by (ASN1_TYPE definitions, ASN1_TYPE * element)
                   (p3->value == NULL))
                 {
 
-                  p3 = _asn1_find_up (p);
-                  p3 = _asn1_find_up (p3);
+                  p3 = MHD__asn1_find_up (p);
+                  p3 = MHD__asn1_find_up (p3);
 
                   if (!p3)
                     {
@@ -2558,7 +2558,7 @@ asn1_expand_any_defined_by (ASN1_TYPE definitions, ASN1_TYPE * element)
 
                       len = MAX_NAME_SIZE;
                       result =
-                        asn1_read_value (definitions, name, value, &len);
+                        MHD__asn1_read_value (definitions, name, value, &len);
 
                       if ((result == ASN1_SUCCESS)
                           && (!strcmp (p3->value, value)))
@@ -2574,27 +2574,27 @@ asn1_expand_any_defined_by (ASN1_TYPE definitions, ASN1_TYPE * element)
                               strcat (name, p2->name);
 
                               result =
-                                asn1_create_element (definitions, name, &aux);
+                                MHD__asn1_create_element (definitions, name, &aux);
                               if (result == ASN1_SUCCESS)
                                 {
-                                  _asn1_set_name (aux, p->name);
+                                  MHD__asn1_set_name (aux, p->name);
                                   len2 =
-                                    asn1_get_length_der (p->value,
+                                    MHD__asn1_get_length_der (p->value,
                                                          p->value_len, &len3);
                                   if (len2 < 0)
                                     return ASN1_DER_ERROR;
 
                                   result =
-                                    asn1_der_decoding (&aux, p->value + len3,
+                                    MHD__asn1_der_decoding (&aux, p->value + len3,
                                                        len2,
                                                        errorDescription);
                                   if (result == ASN1_SUCCESS)
                                     {
 
-                                      _asn1_set_right (aux, p->right);
-                                      _asn1_set_right (p, aux);
+                                      MHD__asn1_set_right (aux, p->right);
+                                      MHD__asn1_set_right (p, aux);
 
-                                      result = asn1_delete_structure (&p);
+                                      result = MHD__asn1_delete_structure (&p);
                                       if (result == ASN1_SUCCESS)
                                         {
                                           p = aux;
@@ -2602,20 +2602,20 @@ asn1_expand_any_defined_by (ASN1_TYPE definitions, ASN1_TYPE * element)
                                           break;
                                         }
                                       else
-                                        {       /* error with asn1_delete_structure */
-                                          asn1_delete_structure (&aux);
+                                        {       /* error with MHD__asn1_delete_structure */
+                                          MHD__asn1_delete_structure (&aux);
                                           retCode = result;
                                           break;
                                         }
                                     }
                                   else
-                                    {   /* error with asn1_der_decoding */
+                                    {   /* error with MHD__asn1_der_decoding */
                                       retCode = result;
                                       break;
                                     }
                                 }
                               else
-                                {       /* error with asn1_create_element */
+                                {       /* error with MHD__asn1_create_element */
                                   retCode = result;
                                   break;
                                 }
@@ -2658,7 +2658,7 @@ asn1_expand_any_defined_by (ASN1_TYPE definitions, ASN1_TYPE * element)
         {
           while (1)
             {
-              p = _asn1_find_up (p);
+              p = MHD__asn1_find_up (p);
               if (p == *element)
                 {
                   p = NULL;
@@ -2679,7 +2679,7 @@ asn1_expand_any_defined_by (ASN1_TYPE definitions, ASN1_TYPE * element)
 
 
 /**
-  * asn1_expand_octet_string - Expand "OCTET STRING" fields in structure.
+  * MHD__asn1_expand_octet_string - Expand "OCTET STRING" fields in structure.
   * @definitions: ASN1 definitions
   * @element: pointer to an ASN1 structure
   * @octetName: name of the OCTECT STRING field to expand.
@@ -2687,7 +2687,7 @@ asn1_expand_any_defined_by (ASN1_TYPE definitions, ASN1_TYPE * element)
   *    the type for expansion.
   *
   * Expands an "OCTET STRING" element of a structure created from a
-  * DER decoding process (asn1_der_decoding function). The type used
+  * DER decoding process (MHD__asn1_der_decoding function). The type used
   * for expansion is the first one following the definition of the
   * actual value of the OBJECT IDENTIFIER indicated by OBJECTNAME.
   *
@@ -2702,12 +2702,12 @@ asn1_expand_any_defined_by (ASN1_TYPE definitions, ASN1_TYPE * element)
   *
   *   other errors: result of der decoding process.
   **/
-asn1_retCode
-asn1_expand_octet_string (ASN1_TYPE definitions, ASN1_TYPE * element,
+MHD__asn1_retCode
+MHD__asn1_expand_octet_string (ASN1_TYPE definitions, ASN1_TYPE * element,
                           const char *octetName, const char *objectName)
 {
   char name[2 * MAX_NAME_SIZE + 1], value[MAX_NAME_SIZE];
-  asn1_retCode retCode = ASN1_SUCCESS, result;
+  MHD__asn1_retCode retCode = ASN1_SUCCESS, result;
   int len, len2, len3;
   ASN1_TYPE p2, aux = ASN1_TYPE_EMPTY;
   ASN1_TYPE octetNode = ASN1_TYPE_EMPTY, objectNode = ASN1_TYPE_EMPTY;
@@ -2716,7 +2716,7 @@ asn1_expand_octet_string (ASN1_TYPE definitions, ASN1_TYPE * element,
   if ((definitions == ASN1_TYPE_EMPTY) || (*element == ASN1_TYPE_EMPTY))
     return ASN1_ELEMENT_NOT_FOUND;
 
-  octetNode = asn1_find_node (*element, octetName);
+  octetNode = MHD__asn1_find_node (*element, octetName);
   if (octetNode == ASN1_TYPE_EMPTY)
     return ASN1_ELEMENT_NOT_FOUND;
   if (type_field (octetNode->type) != TYPE_OCTET_STRING)
@@ -2724,7 +2724,7 @@ asn1_expand_octet_string (ASN1_TYPE definitions, ASN1_TYPE * element,
   if (octetNode->value == NULL)
     return ASN1_VALUE_NOT_FOUND;
 
-  objectNode = asn1_find_node (*element, objectName);
+  objectNode = MHD__asn1_find_node (*element, objectName);
   if (objectNode == ASN1_TYPE_EMPTY)
     return ASN1_ELEMENT_NOT_FOUND;
 
@@ -2747,7 +2747,7 @@ asn1_expand_octet_string (ASN1_TYPE definitions, ASN1_TYPE * element,
           strcat (name, p2->name);
 
           len = sizeof (value);
-          result = asn1_read_value (definitions, name, value, &len);
+          result = MHD__asn1_read_value (definitions, name, value, &len);
 
           if ((result == ASN1_SUCCESS)
               && (!strcmp (objectNode->value, value)))
@@ -2764,46 +2764,46 @@ asn1_expand_octet_string (ASN1_TYPE definitions, ASN1_TYPE * element,
                   strcat (name, ".");
                   strcat (name, p2->name);
 
-                  result = asn1_create_element (definitions, name, &aux);
+                  result = MHD__asn1_create_element (definitions, name, &aux);
                   if (result == ASN1_SUCCESS)
                     {
-                      _asn1_set_name (aux, octetNode->name);
+                      MHD__asn1_set_name (aux, octetNode->name);
                       len2 =
-                        asn1_get_length_der (octetNode->value,
+                        MHD__asn1_get_length_der (octetNode->value,
                                              octetNode->value_len, &len3);
                       if (len2 < 0)
                         return ASN1_DER_ERROR;
 
                       result =
-                        asn1_der_decoding (&aux, octetNode->value + len3,
+                        MHD__asn1_der_decoding (&aux, octetNode->value + len3,
                                            len2, errorDescription);
                       if (result == ASN1_SUCCESS)
                         {
 
-                          _asn1_set_right (aux, octetNode->right);
-                          _asn1_set_right (octetNode, aux);
+                          MHD__asn1_set_right (aux, octetNode->right);
+                          MHD__asn1_set_right (octetNode, aux);
 
-                          result = asn1_delete_structure (&octetNode);
+                          result = MHD__asn1_delete_structure (&octetNode);
                           if (result == ASN1_SUCCESS)
                             {
                               aux = ASN1_TYPE_EMPTY;
                               break;
                             }
                           else
-                            {   /* error with asn1_delete_structure */
-                              asn1_delete_structure (&aux);
+                            {   /* error with MHD__asn1_delete_structure */
+                              MHD__asn1_delete_structure (&aux);
                               retCode = result;
                               break;
                             }
                         }
                       else
-                        {       /* error with asn1_der_decoding */
+                        {       /* error with MHD__asn1_der_decoding */
                           retCode = result;
                           break;
                         }
                     }
                   else
-                    {           /* error with asn1_create_element */
+                    {           /* error with MHD__asn1_create_element */
                       retCode = result;
                       break;
                     }
diff --git a/src/daemon/https/minitasn1/element.c b/src/daemon/https/minitasn1/element.c
index 5bfb1ed0..dfaa05b2 100644
--- a/src/daemon/https/minitasn1/element.c
+++ b/src/daemon/https/minitasn1/element.c
@@ -34,7 +34,7 @@
 #include "structure.h"
 
 void
-_asn1_hierarchical_name (node_asn * node, char *name, int name_size)
+MHD__asn1_hierarchical_name (node_asn * node, char *name, int name_size)
 {
   node_asn *p;
   char tmp_name[64];
@@ -47,21 +47,21 @@ _asn1_hierarchical_name (node_asn * node, char *name, int name_size)
     {
       if (p->name != NULL)
         {
-          _asn1_str_cpy (tmp_name, sizeof (tmp_name), name),
-            _asn1_str_cpy (name, name_size, p->name);
-          _asn1_str_cat (name, name_size, ".");
-          _asn1_str_cat (name, name_size, tmp_name);
+          MHD__asn1_str_cpy (tmp_name, sizeof (tmp_name), name),
+            MHD__asn1_str_cpy (name, name_size, p->name);
+          MHD__asn1_str_cat (name, name_size, ".");
+          MHD__asn1_str_cat (name, name_size, tmp_name);
         }
-      p = _asn1_find_up (p);
+      p = MHD__asn1_find_up (p);
     }
 
   if (name[0] == 0)
-    _asn1_str_cpy (name, name_size, "ROOT");
+    MHD__asn1_str_cpy (name, name_size, "ROOT");
 }
 
 
 /******************************************************************/
-/* Function : _asn1_convert_integer                               */
+/* Function : MHD__asn1_convert_integer                               */
 /* Description: converts an integer from a null terminated string */
 /*              to der decoding. The convertion from a null       */
 /*              terminated string to an integer is made with      */
@@ -74,8 +74,8 @@ _asn1_hierarchical_name (node_asn * node, char *name, int name_size)
 /*   len: number of significant byte of value_out.                */
 /* Return: ASN1_MEM_ERROR or ASN1_SUCCESS                         */
 /******************************************************************/
-asn1_retCode
-_asn1_convert_integer (const char *value, unsigned char *value_out,
+MHD__asn1_retCode
+MHD__asn1_convert_integer (const char *value, unsigned char *value_out,
                        int value_out_size, int *len)
 {
   char negative;
@@ -117,10 +117,10 @@ _asn1_convert_integer (const char *value, unsigned char *value_out,
 
 
 #ifdef LIBTASN1_DEBUG_INTEGER
-  _libtasn1_log ("_asn1_convert_integer: valueIn=%s, lenOut=%d", value, *len);
+  MHD__libtasn1_log ("MHD__asn1_convert_integer: valueIn=%s, lenOut=%d", value, *len);
   for (k = 0; k < SIZEOF_UNSIGNED_LONG_INT; k++)
-    _libtasn1_log (", vOut[%d]=%d", k, value_out[k]);
-  _libtasn1_log ("\n");
+    MHD__libtasn1_log (", vOut[%d]=%d", k, value_out[k]);
+  MHD__libtasn1_log ("\n");
 #endif
 
 
@@ -129,7 +129,7 @@ _asn1_convert_integer (const char *value, unsigned char *value_out,
 
 
 int
-_asn1_append_sequence_set (node_asn * node)
+MHD__asn1_append_sequence_set (node_asn * node)
 {
   node_asn *p, *p2;
   char temp[10];
@@ -142,21 +142,21 @@ _asn1_append_sequence_set (node_asn * node)
   while ((type_field (p->type) == TYPE_TAG)
          || (type_field (p->type) == TYPE_SIZE))
     p = p->right;
-  p2 = _asn1_copy_structure3 (p);
+  p2 = MHD__asn1_copy_structure3 (p);
   while (p->right)
     p = p->right;
-  _asn1_set_right (p, p2);
+  MHD__asn1_set_right (p, p2);
 
   if (p->name == NULL)
-    _asn1_str_cpy (temp, sizeof (temp), "?1");
+    MHD__asn1_str_cpy (temp, sizeof (temp), "?1");
   else
     {
       n = strtol (p->name + 1, NULL, 0);
       n++;
       temp[0] = '?';
-      _asn1_ltostr (n, temp + 1);
+      MHD__asn1_ltostr (n, temp + 1);
     }
-  _asn1_set_name (p2, temp);
+  MHD__asn1_set_name (p2, temp);
   /*  p2->type |= CONST_OPTION; */
 
   return ASN1_SUCCESS;
@@ -164,7 +164,7 @@ _asn1_append_sequence_set (node_asn * node)
 
 
 /**
-  * asn1_write_value - Set the value of one element inside a structure.
+  * MHD__asn1_write_value - Set the value of one element inside a structure.
   * @node_root: pointer to a structure
   * @name: the name of the element inside the structure that you want to set.
   * @ivalue: vector used to specify the value to set. If len is >0,
@@ -178,7 +178,7 @@ _asn1_append_sequence_set (node_asn * node)
   * If an element is OPTIONAL and you want to delete it, you must use
   * the value=NULL and len=0.  Using "pkix.asn":
   *
-  * result=asn1_write_value(cert, "tbsCertificate.issuerUniqueID",
+  * result=MHD__asn1_write_value(cert, "tbsCertificate.issuerUniqueID",
   * NULL, 0);
   *
   * Description for each type:
@@ -244,7 +244,7 @@ _asn1_append_sequence_set (node_asn * node)
   *   the alternatives with a null terminated string. LEN != 0. Using
   *   "pkix.asn"\:
   *
-  *           result=asn1_write_value(cert,
+  *           result=MHD__asn1_write_value(cert,
   *           "certificate1.tbsCertificate.subject", "rdnSequence",
   *           1);
   *
@@ -257,12 +257,12 @@ _asn1_append_sequence_set (node_asn * node)
   *
   *   Using "pkix.asn"\:
   *
-  *   result=asn1_write_value(cert,
+  *   result=MHD__asn1_write_value(cert,
   *   "certificate1.tbsCertificate.subject.rdnSequence", "NEW", 1);
   *
   * SET OF: the same as SEQUENCE OF.  Using "pkix.asn":
   *
-  *           result=asn1_write_value(cert,
+  *           result=MHD__asn1_write_value(cert,
   *           "tbsCertificate.subject.rdnSequence.?LAST", "NEW", 1);
   *
   * Returns:
@@ -274,8 +274,8 @@ _asn1_append_sequence_set (node_asn * node)
   *   ASN1_VALUE_NOT_VALID: VALUE has a wrong format.
   *
   **/
-asn1_retCode
-asn1_write_value (ASN1_TYPE node_root, const char *name,
+MHD__asn1_retCode
+MHD__asn1_write_value (ASN1_TYPE node_root, const char *name,
                   const void *ivalue, int len)
 {
   node_asn *node, *p, *p2;
@@ -283,13 +283,13 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
   int len2, k, k2, negative;
   const unsigned char *value = ivalue;
 
-  node = asn1_find_node (node_root, name);
+  node = MHD__asn1_find_node (node_root, name);
   if (node == NULL)
     return ASN1_ELEMENT_NOT_FOUND;
 
   if ((node->type & CONST_OPTION) && (value == NULL) && (len == 0))
     {
-      asn1_delete_structure (&node);
+      MHD__asn1_delete_structure (&node);
       return ASN1_SUCCESS;
     }
 
@@ -302,7 +302,7 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
         p = p->right;
 
       while (p->right)
-        asn1_delete_structure (&p->right);
+        MHD__asn1_delete_structure (&p->right);
 
       return ASN1_SUCCESS;
     }
@@ -318,12 +318,12 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
               while (type_field (p->type) != TYPE_DEFAULT)
                 p = p->right;
               if (p->type & CONST_TRUE)
-                _asn1_set_value (node, NULL, 0);
+                MHD__asn1_set_value (node, NULL, 0);
               else
-                _asn1_set_value (node, "T", 1);
+                MHD__asn1_set_value (node, "T", 1);
             }
           else
-            _asn1_set_value (node, "T", 1);
+            MHD__asn1_set_value (node, "T", 1);
         }
       else if (!strcmp (value, "FALSE"))
         {
@@ -333,12 +333,12 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
               while (type_field (p->type) != TYPE_DEFAULT)
                 p = p->right;
               if (p->type & CONST_FALSE)
-                _asn1_set_value (node, NULL, 0);
+                MHD__asn1_set_value (node, NULL, 0);
               else
-                _asn1_set_value (node, "F", 1);
+                MHD__asn1_set_value (node, "F", 1);
             }
           else
-            _asn1_set_value (node, "F", 1);
+            MHD__asn1_set_value (node, "F", 1);
         }
       else
         return ASN1_VALUE_NOT_VALID;
@@ -350,11 +350,11 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
           if ((isdigit (value[0])) || (value[0] == '-'))
             {
               value_temp =
-                (unsigned char *) _asn1_alloca (SIZEOF_UNSIGNED_LONG_INT);
+                (unsigned char *) MHD__asn1_alloca (SIZEOF_UNSIGNED_LONG_INT);
               if (value_temp == NULL)
                 return ASN1_MEM_ALLOC_ERROR;
 
-              _asn1_convert_integer (value, value_temp,
+              MHD__asn1_convert_integer (value, value_temp,
                                      SIZEOF_UNSIGNED_LONG_INT, &len);
             }
           else
@@ -370,11 +370,11 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
                         {
                           value_temp =
                             (unsigned char *)
-                            _asn1_alloca (SIZEOF_UNSIGNED_LONG_INT);
+                            MHD__asn1_alloca (SIZEOF_UNSIGNED_LONG_INT);
                           if (value_temp == NULL)
                             return ASN1_MEM_ALLOC_ERROR;
 
-                          _asn1_convert_integer (p->value,
+                          MHD__asn1_convert_integer (p->value,
                                                  value_temp,
                                                  SIZEOF_UNSIGNED_LONG_INT,
                                                  &len);
@@ -389,7 +389,7 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
         }
       else
         {                       /* len != 0 */
-          value_temp = (unsigned char *) _asn1_alloca (len);
+          value_temp = (unsigned char *) MHD__asn1_alloca (len);
           if (value_temp == NULL)
             return ASN1_MEM_ALLOC_ERROR;
           memcpy (value_temp, value, len);
@@ -403,7 +403,7 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
 
       if (negative && (type_field (node->type) == TYPE_ENUMERATED))
         {
-          _asn1_afree (value_temp);
+          MHD__asn1_afree (value_temp);
           return ASN1_VALUE_NOT_VALID;
         }
 
@@ -417,18 +417,18 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
           (!negative && (value_temp[k] & 0x80)))
         k--;
 
-      asn1_length_der (len - k, NULL, &len2);
-      temp = (unsigned char *) _asn1_alloca (len - k + len2);
+      MHD__asn1_length_der (len - k, NULL, &len2);
+      temp = (unsigned char *) MHD__asn1_alloca (len - k + len2);
       if (temp == NULL)
         {
-          _asn1_afree (value_temp);
+          MHD__asn1_afree (value_temp);
           return ASN1_MEM_ALLOC_ERROR;
         }
 
-      asn1_octet_der (value_temp + k, len - k, temp, &len2);
-      _asn1_set_value (node, temp, len2);
+      MHD__asn1_octet_der (value_temp + k, len - k, temp, &len2);
+      MHD__asn1_set_value (node, temp, len2);
 
-      _asn1_afree (temp);
+      MHD__asn1_afree (temp);
 
 
       if (node->type & CONST_DEFAULT)
@@ -439,21 +439,21 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
           if ((isdigit (p->value[0])) || (p->value[0] == '-'))
             {
               default_temp =
-                (unsigned char *) _asn1_alloca (SIZEOF_UNSIGNED_LONG_INT);
+                (unsigned char *) MHD__asn1_alloca (SIZEOF_UNSIGNED_LONG_INT);
               if (default_temp == NULL)
                 {
-                  _asn1_afree (value_temp);
+                  MHD__asn1_afree (value_temp);
                   return ASN1_MEM_ALLOC_ERROR;
                 }
 
-              _asn1_convert_integer (p->value, default_temp,
+              MHD__asn1_convert_integer (p->value, default_temp,
                                      SIZEOF_UNSIGNED_LONG_INT, &len2);
             }
           else
             {                   /* is an identifier like v1 */
               if (!(node->type & CONST_LIST))
                 {
-                  _asn1_afree (value_temp);
+                  MHD__asn1_afree (value_temp);
                   return ASN1_VALUE_NOT_VALID;
                 }
               p2 = node->down;
@@ -465,14 +465,14 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
                         {
                           default_temp =
                             (unsigned char *)
-                            _asn1_alloca (SIZEOF_UNSIGNED_LONG_INT);
+                            MHD__asn1_alloca (SIZEOF_UNSIGNED_LONG_INT);
                           if (default_temp == NULL)
                             {
-                              _asn1_afree (value_temp);
+                              MHD__asn1_afree (value_temp);
                               return ASN1_MEM_ALLOC_ERROR;
                             }
 
-                          _asn1_convert_integer (p2->value,
+                          MHD__asn1_convert_integer (p2->value,
                                                  default_temp,
                                                  SIZEOF_UNSIGNED_LONG_INT,
                                                  &len2);
@@ -483,7 +483,7 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
                 }
               if (p2 == NULL)
                 {
-                  _asn1_afree (value_temp);
+                  MHD__asn1_afree (value_temp);
                   return ASN1_VALUE_NOT_VALID;
                 }
             }
@@ -497,11 +497,11 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
                     break;
                   }
               if (k2 == len2)
-                _asn1_set_value (node, NULL, 0);
+                MHD__asn1_set_value (node, NULL, 0);
             }
-          _asn1_afree (default_temp);
+          MHD__asn1_afree (default_temp);
         }
-      _asn1_afree (value_temp);
+      MHD__asn1_afree (value_temp);
       break;
     case TYPE_OBJECT_ID:
       for (k = 0; k < strlen (value); k++)
@@ -514,11 +514,11 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
             p = p->right;
           if (!strcmp (value, p->value))
             {
-              _asn1_set_value (node, NULL, 0);
+              MHD__asn1_set_value (node, NULL, 0);
               break;
             }
         }
-      _asn1_set_value (node, value, strlen (value) + 1);
+      MHD__asn1_set_value (node, value, strlen (value) + 1);
       break;
     case TYPE_TIME:
       if (node->type & CONST_UTC)
@@ -558,49 +558,49 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
             default:
               return ASN1_VALUE_NOT_FOUND;
             }
-          _asn1_set_value (node, value, strlen (value) + 1);
+          MHD__asn1_set_value (node, value, strlen (value) + 1);
         }
       else
         {                       /* GENERALIZED TIME */
           if (value)
-            _asn1_set_value (node, value, strlen (value) + 1);
+            MHD__asn1_set_value (node, value, strlen (value) + 1);
         }
       break;
     case TYPE_OCTET_STRING:
       if (len == 0)
         len = strlen (value);
-      asn1_length_der (len, NULL, &len2);
-      temp = (unsigned char *) _asn1_alloca (len + len2);
+      MHD__asn1_length_der (len, NULL, &len2);
+      temp = (unsigned char *) MHD__asn1_alloca (len + len2);
       if (temp == NULL)
         return ASN1_MEM_ALLOC_ERROR;
 
-      asn1_octet_der (value, len, temp, &len2);
-      _asn1_set_value (node, temp, len2);
-      _asn1_afree (temp);
+      MHD__asn1_octet_der (value, len, temp, &len2);
+      MHD__asn1_set_value (node, temp, len2);
+      MHD__asn1_afree (temp);
       break;
     case TYPE_GENERALSTRING:
       if (len == 0)
         len = strlen (value);
-      asn1_length_der (len, NULL, &len2);
-      temp = (unsigned char *) _asn1_alloca (len + len2);
+      MHD__asn1_length_der (len, NULL, &len2);
+      temp = (unsigned char *) MHD__asn1_alloca (len + len2);
       if (temp == NULL)
         return ASN1_MEM_ALLOC_ERROR;
 
-      asn1_octet_der (value, len, temp, &len2);
-      _asn1_set_value (node, temp, len2);
-      _asn1_afree (temp);
+      MHD__asn1_octet_der (value, len, temp, &len2);
+      MHD__asn1_set_value (node, temp, len2);
+      MHD__asn1_afree (temp);
       break;
     case TYPE_BIT_STRING:
       if (len == 0)
         len = strlen (value);
-      asn1_length_der ((len >> 3) + 2, NULL, &len2);
-      temp = (unsigned char *) _asn1_alloca ((len >> 3) + 2 + len2);
+      MHD__asn1_length_der ((len >> 3) + 2, NULL, &len2);
+      temp = (unsigned char *) MHD__asn1_alloca ((len >> 3) + 2 + len2);
       if (temp == NULL)
         return ASN1_MEM_ALLOC_ERROR;
 
-      asn1_bit_der (value, len, temp, &len2);
-      _asn1_set_value (node, temp, len2);
-      _asn1_afree (temp);
+      MHD__asn1_bit_der (value, len, temp, &len2);
+      MHD__asn1_set_value (node, temp, len2);
+      MHD__asn1_afree (temp);
       break;
     case TYPE_CHOICE:
       p = node->down;
@@ -613,7 +613,7 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
                 {
                   if (p2 != p)
                     {
-                      asn1_delete_structure (&p2);
+                      MHD__asn1_delete_structure (&p2);
                       p2 = node->down;
                     }
                   else
@@ -627,20 +627,20 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
         return ASN1_ELEMENT_NOT_FOUND;
       break;
     case TYPE_ANY:
-      asn1_length_der (len, NULL, &len2);
-      temp = (unsigned char *) _asn1_alloca (len + len2);
+      MHD__asn1_length_der (len, NULL, &len2);
+      temp = (unsigned char *) MHD__asn1_alloca (len + len2);
       if (temp == NULL)
         return ASN1_MEM_ALLOC_ERROR;
 
-      asn1_octet_der (value, len, temp, &len2);
-      _asn1_set_value (node, temp, len2);
-      _asn1_afree (temp);
+      MHD__asn1_octet_der (value, len, temp, &len2);
+      MHD__asn1_set_value (node, temp, len2);
+      MHD__asn1_afree (temp);
       break;
     case TYPE_SEQUENCE_OF:
     case TYPE_SET_OF:
       if (strcmp (value, "NEW"))
         return ASN1_VALUE_NOT_VALID;
-      _asn1_append_sequence_set (node);
+      MHD__asn1_append_sequence_set (node);
       break;
     default:
       return ASN1_ELEMENT_NOT_FOUND;
@@ -678,7 +678,7 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
         }
 
 /**
-  * asn1_read_value - Returns the value of one element inside a structure
+  * MHD__asn1_read_value - Returns the value of one element inside a structure
   * @root: pointer to a structure.
   * @name: the name of the element inside a structure that you want to read.
   * @ivalue: vector that will contain the element's content, must be a
@@ -743,15 +743,15 @@ asn1_write_value (ASN1_TYPE node_root, const char *name,
   *   In this case LEN will contain the number of bytes needed.
   *
   **/
-asn1_retCode
-asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
+MHD__asn1_retCode
+MHD__asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
 {
   node_asn *node, *p, *p2;
   int len2, len3;
   int value_size = *len;
   unsigned char *value = ivalue;
 
-  node = asn1_find_node (root, name);
+  node = MHD__asn1_find_node (root, name);
   if (node == NULL)
     return ASN1_ELEMENT_NOT_FOUND;
 
@@ -800,7 +800,7 @@ asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
           if ((isdigit (p->value[0])) || (p->value[0] == '-')
               || (p->value[0] == '+'))
             {
-              if (_asn1_convert_integer
+              if (MHD__asn1_convert_integer
                   (p->value, value, value_size, len) != ASN1_SUCCESS)
                 return ASN1_MEM_ERROR;
             }
@@ -813,7 +813,7 @@ asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
                     {
                       if ((p2->name) && (!strcmp (p2->name, p->value)))
                         {
-                          if (_asn1_convert_integer
+                          if (MHD__asn1_convert_integer
                               (p2->value, value, value_size,
                                len) != ASN1_SUCCESS)
                             return ASN1_MEM_ERROR;
@@ -827,7 +827,7 @@ asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
       else
         {
           len2 = -1;
-          if (asn1_get_octet_der
+          if (MHD__asn1_get_octet_der
               (node->value, node->value_len, &len2, value, value_size,
                len) != ASN1_SUCCESS)
             return ASN1_MEM_ERROR;
@@ -869,21 +869,21 @@ asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
       break;
     case TYPE_OCTET_STRING:
       len2 = -1;
-      if (asn1_get_octet_der
+      if (MHD__asn1_get_octet_der
           (node->value, node->value_len, &len2, value, value_size,
            len) != ASN1_SUCCESS)
         return ASN1_MEM_ERROR;
       break;
     case TYPE_GENERALSTRING:
       len2 = -1;
-      if (asn1_get_octet_der
+      if (MHD__asn1_get_octet_der
           (node->value, node->value_len, &len2, value, value_size,
            len) != ASN1_SUCCESS)
         return ASN1_MEM_ERROR;
       break;
     case TYPE_BIT_STRING:
       len2 = -1;
-      if (asn1_get_bit_der
+      if (MHD__asn1_get_bit_der
           (node->value, node->value_len, &len2, value, value_size,
            len) != ASN1_SUCCESS)
         return ASN1_MEM_ERROR;
@@ -893,7 +893,7 @@ asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
       break;
     case TYPE_ANY:
       len3 = -1;
-      len2 = asn1_get_length_der (node->value, node->value_len, &len3);
+      len2 = MHD__asn1_get_length_der (node->value, node->value_len, &len3);
       if (len2 < 0)
         return ASN1_DER_ERROR;
       PUT_VALUE (value, value_size, node->value + len3, len2);
@@ -907,7 +907,7 @@ asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
 
 
 /**
-  * asn1_read_tag - Returns the TAG of one element inside a structure
+  * MHD__asn1_read_tag - Returns the TAG of one element inside a structure
   * @root: pointer to a structure
   * @name: the name of the element inside a structure.
   * @tagValue:  variable that will contain the TAG value.
@@ -925,13 +925,13 @@ asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
   *   ASN1_ELEMENT_NOT_FOUND: NAME is not a valid element.
   *
   **/
-asn1_retCode
-asn1_read_tag (node_asn * root, const char *name, int *tagValue,
+MHD__asn1_retCode
+MHD__asn1_read_tag (node_asn * root, const char *name, int *tagValue,
                int *classValue)
 {
   node_asn *node, *p, *pTag;
 
-  node = asn1_find_node (root, name);
+  node = MHD__asn1_find_node (root, name);
   if (node == NULL)
     return ASN1_ELEMENT_NOT_FOUND;
 
diff --git a/src/daemon/https/minitasn1/element.h b/src/daemon/https/minitasn1/element.h
index b6341e8a..eea9839a 100644
--- a/src/daemon/https/minitasn1/element.h
+++ b/src/daemon/https/minitasn1/element.h
@@ -3,12 +3,12 @@
 #define _ELEMENT_H
 
 
-asn1_retCode _asn1_append_sequence_set (node_asn * node);
+MHD__asn1_retCode MHD__asn1_append_sequence_set (node_asn * node);
 
-asn1_retCode _asn1_convert_integer (const char *value,
+MHD__asn1_retCode MHD__asn1_convert_integer (const char *value,
                                     unsigned char *value_out,
                                     int value_out_size, int *len);
 
-void _asn1_hierarchical_name (node_asn * node, char *name, int name_size);
+void MHD__asn1_hierarchical_name (node_asn * node, char *name, int name_size);
 
 #endif
diff --git a/src/daemon/https/minitasn1/errors.c b/src/daemon/https/minitasn1/errors.c
index 544b3f01..72b61938 100644
--- a/src/daemon/https/minitasn1/errors.c
+++ b/src/daemon/https/minitasn1/errors.c
@@ -30,14 +30,14 @@
 #define LIBTASN1_ERROR_ENTRY(name) \
         { #name, name }
 
-struct libtasn1_error_entry
+struct MHD__libtasn1_error_entry
 {
   const char *name;
   int number;
 };
-typedef struct libtasn1_error_entry libtasn1_error_entry;
+typedef struct MHD__libtasn1_error_entry MHD__libtasn1_error_entry;
 
-static const libtasn1_error_entry error_algorithms[] = {
+static const MHD__libtasn1_error_entry error_algorithms[] = {
   LIBTASN1_ERROR_ENTRY (ASN1_SUCCESS),
   LIBTASN1_ERROR_ENTRY (ASN1_FILE_NOT_FOUND),
   LIBTASN1_ERROR_ENTRY (ASN1_ELEMENT_NOT_FOUND),
@@ -60,7 +60,7 @@ static const libtasn1_error_entry error_algorithms[] = {
 };
 
 #define LIBTASN1_ERROR_LOOP(b) \
-        const libtasn1_error_entry *p; \
+        const MHD__libtasn1_error_entry *p; \
                 for(p = error_algorithms; p->name != NULL; p++) { b ; }
 
 #define LIBTASN1_ERROR_ALG_LOOP(a) \
@@ -69,14 +69,14 @@ static const libtasn1_error_entry error_algorithms[] = {
 
 
 /**
-  * libtasn1_perror - prints a string to stderr with a description of an error
+  * MHD__libtasn1_perror - prints a string to stderr with a description of an error
   * @error: is an error returned by a libtasn1 function.
   *
   * This function is like perror(). The only difference is that it
   * accepts an error returned by a libtasn1 function.
   **/
 void
-libtasn1_perror (asn1_retCode error)
+MHD__libtasn1_perror (MHD__asn1_retCode error)
 {
   const char *ret = NULL;
 
@@ -89,7 +89,7 @@ libtasn1_perror (asn1_retCode error)
 
 
 /**
-  * libtasn1_strerror - Returns a string with a description of an error
+  * MHD__libtasn1_strerror - Returns a string with a description of an error
   * @error: is an error returned by a libtasn1 function.
   *
   * This function is similar to strerror(). The only difference is
@@ -99,7 +99,7 @@ libtasn1_perror (asn1_retCode error)
   *   code.
   **/
 const char *
-libtasn1_strerror (asn1_retCode error)
+MHD__libtasn1_strerror (MHD__asn1_retCode error)
 {
   const char *ret = NULL;
 
@@ -113,7 +113,7 @@ libtasn1_strerror (asn1_retCode error)
  */
 #ifdef LIBTASN1_DEBUG
 void
-_libtasn1_log (const char *fmt, ...)
+MHD__libtasn1_log (const char *fmt, ...)
 {
   va_list args;
   char str[MAX_LOG_SIZE];
@@ -128,7 +128,7 @@ _libtasn1_log (const char *fmt, ...)
 }
 #else /* not DEBUG */
 void
-_libtasn1_log (const char *fmt, ...)
+MHD__libtasn1_log (const char *fmt, ...)
 {
   return;
 }
diff --git a/src/daemon/https/minitasn1/errors.h b/src/daemon/https/minitasn1/errors.h
index 05faa321..cb5536ba 100644
--- a/src/daemon/https/minitasn1/errors.h
+++ b/src/daemon/https/minitasn1/errors.h
@@ -25,6 +25,6 @@
 
 #include "int.h"
 
-void _libtasn1_log (const char *fmt, ...);
+void MHD__libtasn1_log (const char *fmt, ...);
 
 #endif /* ERRORS_H */
diff --git a/src/daemon/https/minitasn1/gstr.c b/src/daemon/https/minitasn1/gstr.c
index 0430ee1a..7068db51 100644
--- a/src/daemon/https/minitasn1/gstr.c
+++ b/src/daemon/https/minitasn1/gstr.c
@@ -29,7 +29,7 @@
  * They should be used only with null terminated strings.
  */
 void
-_asn1_str_cat (char *dest, size_t dest_tot_size, const char *src)
+MHD__asn1_str_cat (char *dest, size_t dest_tot_size, const char *src)
 {
   size_t str_size = strlen (src);
   size_t dest_size = strlen (dest);
@@ -49,7 +49,7 @@ _asn1_str_cat (char *dest, size_t dest_tot_size, const char *src)
 }
 
 void
-_asn1_str_cpy (char *dest, size_t dest_tot_size, const char *src)
+MHD__asn1_str_cpy (char *dest, size_t dest_tot_size, const char *src)
 {
   size_t str_size = strlen (src);
 
diff --git a/src/daemon/https/minitasn1/gstr.h b/src/daemon/https/minitasn1/gstr.h
index 360c6d88..e0cda357 100644
--- a/src/daemon/https/minitasn1/gstr.h
+++ b/src/daemon/https/minitasn1/gstr.h
@@ -1,5 +1,5 @@
-void _asn1_str_cpy (char *dest, size_t dest_tot_size, const char *src);
-void _asn1_str_cat (char *dest, size_t dest_tot_size, const char *src);
+void MHD__asn1_str_cpy (char *dest, size_t dest_tot_size, const char *src);
+void MHD__asn1_str_cat (char *dest, size_t dest_tot_size, const char *src);
 
-#define Estrcpy(x,y) _asn1_str_cpy(x,MAX_ERROR_DESCRIPTION_SIZE,y)
-#define Estrcat(x,y) _asn1_str_cat(x,MAX_ERROR_DESCRIPTION_SIZE,y)
+#define Estrcpy(x,y) MHD__asn1_str_cpy(x,MAX_ERROR_DESCRIPTION_SIZE,y)
+#define Estrcat(x,y) MHD__asn1_str_cat(x,MAX_ERROR_DESCRIPTION_SIZE,y)
diff --git a/src/daemon/https/minitasn1/libtasn1.h b/src/daemon/https/minitasn1/libtasn1.h
index 58862e63..b9cfe610 100644
--- a/src/daemon/https/minitasn1/libtasn1.h
+++ b/src/daemon/https/minitasn1/libtasn1.h
@@ -43,7 +43,7 @@ extern "C"
   /* (null character included)    */
 
 
-  typedef int asn1_retCode;     /* type returned by libtasn1 functions */
+  typedef int MHD__asn1_retCode;     /* type returned by libtasn1 functions */
 
   /*****************************************/
   /*  Errors returned by libtasn1 functions */
@@ -68,7 +68,7 @@ extern "C"
 #define ASN1_ELEMENT_NOT_EMPTY     17
 
 /*************************************/
-/* Constants used in asn1_visit_tree */
+/* Constants used in MHD__asn1_visit_tree */
 /*************************************/
 #define ASN1_PRINT_NAME             1
 #define ASN1_PRINT_NAME_TYPE        2
@@ -76,7 +76,7 @@ extern "C"
 #define ASN1_PRINT_ALL              4
 
 /*****************************************/
-/* Constants returned by asn1_read_tag   */
+/* Constants returned by MHD__asn1_read_tag   */
 /*****************************************/
 #define ASN1_CLASS_UNIVERSAL        0x00        /* old: 1 */
 #define ASN1_CLASS_APPLICATION      0x40        /* old: 2 */
@@ -85,7 +85,7 @@ extern "C"
 #define ASN1_CLASS_STRUCTURED       0x20
 
 /*****************************************/
-/* Constants returned by asn1_read_tag   */
+/* Constants returned by MHD__asn1_read_tag   */
 /*****************************************/
 #define ASN1_TAG_BOOLEAN          0x01
 #define ASN1_TAG_INTEGER          0x02
@@ -137,106 +137,106 @@ extern "C"
   /*  Functions definitions          */
   /***********************************/
 
-  asn1_retCode asn1_parser2tree (const char *file_name,
+  MHD__asn1_retCode MHD__asn1_parser2tree (const char *file_name,
                                  ASN1_TYPE * definitions,
                                  char *errorDescription);
 
-  asn1_retCode asn1_parser2array (const char *inputFileName,
+  MHD__asn1_retCode MHD__asn1_parser2array (const char *inputFileName,
                                   const char *outputFileName,
                                   const char *vectorName,
                                   char *errorDescription);
 
-  asn1_retCode asn1_array2tree (const ASN1_ARRAY_TYPE * array,
+  MHD__asn1_retCode MHD__asn1_array2tree (const ASN1_ARRAY_TYPE * array,
                                 ASN1_TYPE * definitions,
                                 char *errorDescription);
 
-  void asn1_print_structure (FILE * out, ASN1_TYPE structure,
+  void MHD__asn1_print_structure (FILE * out, ASN1_TYPE structure,
                              const char *name, int mode);
 
-  asn1_retCode asn1_create_element (ASN1_TYPE definitions,
+  MHD__asn1_retCode MHD__asn1_create_element (ASN1_TYPE definitions,
                                     const char *source_name,
                                     ASN1_TYPE * element);
 
-  asn1_retCode asn1_delete_structure (ASN1_TYPE * structure);
+  MHD__asn1_retCode MHD__asn1_delete_structure (ASN1_TYPE * structure);
 
-  asn1_retCode asn1_delete_element (ASN1_TYPE structure,
+  MHD__asn1_retCode MHD__asn1_delete_element (ASN1_TYPE structure,
                                     const char *element_name);
 
-  asn1_retCode asn1_write_value (ASN1_TYPE node_root, const char *name,
+  MHD__asn1_retCode MHD__asn1_write_value (ASN1_TYPE node_root, const char *name,
                                  const void *ivalue, int len);
 
-  asn1_retCode asn1_read_value (ASN1_TYPE root, const char *name,
+  MHD__asn1_retCode MHD__asn1_read_value (ASN1_TYPE root, const char *name,
                                 void *ivalue, int *len);
 
-  asn1_retCode asn1_number_of_elements (ASN1_TYPE element, const char *name,
+  MHD__asn1_retCode MHD__asn1_number_of_elements (ASN1_TYPE element, const char *name,
                                         int *num);
 
-  asn1_retCode asn1_der_coding (ASN1_TYPE element, const char *name,
+  MHD__asn1_retCode MHD__asn1_der_coding (ASN1_TYPE element, const char *name,
                                 void *ider, int *len, char *ErrorDescription);
 
-  asn1_retCode asn1_der_decoding (ASN1_TYPE * element, const void *ider,
+  MHD__asn1_retCode MHD__asn1_der_decoding (ASN1_TYPE * element, const void *ider,
                                   int len, char *errorDescription);
 
-  asn1_retCode asn1_der_decoding_element (ASN1_TYPE * structure,
+  MHD__asn1_retCode MHD__asn1_der_decoding_element (ASN1_TYPE * structure,
                                           const char *elementName,
                                           const void *ider, int len,
                                           char *errorDescription);
 
-  asn1_retCode asn1_der_decoding_startEnd (ASN1_TYPE element,
+  MHD__asn1_retCode MHD__asn1_der_decoding_startEnd (ASN1_TYPE element,
                                            const void *ider, int len,
                                            const char *name_element,
                                            int *start, int *end);
 
-  asn1_retCode asn1_expand_any_defined_by (ASN1_TYPE definitions,
+  MHD__asn1_retCode MHD__asn1_expand_any_defined_by (ASN1_TYPE definitions,
                                            ASN1_TYPE * element);
 
-  asn1_retCode asn1_expand_octet_string (ASN1_TYPE definitions,
+  MHD__asn1_retCode MHD__asn1_expand_octet_string (ASN1_TYPE definitions,
                                          ASN1_TYPE * element,
                                          const char *octetName,
                                          const char *objectName);
 
-  asn1_retCode asn1_read_tag (node_asn * root, const char *name,
+  MHD__asn1_retCode MHD__asn1_read_tag (node_asn * root, const char *name,
                               int *tagValue, int *classValue);
 
-  const char *asn1_find_structure_from_oid (ASN1_TYPE definitions,
+  const char *MHD__asn1_find_structure_from_oid (ASN1_TYPE definitions,
                                             const char *oidValue);
 
-  const char *asn1_check_version (const char *req_version);
+  const char *MHD__asn1_check_version (const char *req_version);
 
-  const char *libtasn1_strerror (asn1_retCode error);
+  const char *MHD__libtasn1_strerror (MHD__asn1_retCode error);
 
-  void libtasn1_perror (asn1_retCode error);
+  void MHD__libtasn1_perror (MHD__asn1_retCode error);
 
   /* DER utility functions. */
 
-  int asn1_get_tag_der (const unsigned char *der, int der_len,
+  int MHD__asn1_get_tag_der (const unsigned char *der, int der_len,
                         unsigned char *cls, int *len, unsigned long *tag);
 
-  void asn1_octet_der (const unsigned char *str, int str_len,
+  void MHD__asn1_octet_der (const unsigned char *str, int str_len,
                        unsigned char *der, int *der_len);
 
-  asn1_retCode asn1_get_octet_der (const unsigned char *der, int der_len,
+  MHD__asn1_retCode MHD__asn1_get_octet_der (const unsigned char *der, int der_len,
                                    int *ret_len, unsigned char *str,
                                    int str_size, int *str_len);
 
-  void asn1_bit_der (const unsigned char *str, int bit_len,
+  void MHD__asn1_bit_der (const unsigned char *str, int bit_len,
                      unsigned char *der, int *der_len);
 
-  asn1_retCode asn1_get_bit_der (const unsigned char *der, int der_len,
+  MHD__asn1_retCode MHD__asn1_get_bit_der (const unsigned char *der, int der_len,
                                  int *ret_len, unsigned char *str,
                                  int str_size, int *bit_len);
 
-  signed long asn1_get_length_der (const unsigned char *der, int der_len,
+  signed long MHD__asn1_get_length_der (const unsigned char *der, int der_len,
                                    int *len);
 
-  void asn1_length_der (unsigned long int len, unsigned char *ans,
+  void MHD__asn1_length_der (unsigned long int len, unsigned char *ans,
                         int *ans_len);
 
   /* Other utility functions. */
 
-  ASN1_TYPE asn1_find_node (ASN1_TYPE pointer, const char *name);
+  ASN1_TYPE MHD__asn1_find_node (ASN1_TYPE pointer, const char *name);
 
-  asn1_retCode asn1_copy_node (ASN1_TYPE dst, const char *dst_name,
+  MHD__asn1_retCode MHD__asn1_copy_node (ASN1_TYPE dst, const char *dst_name,
                                ASN1_TYPE src, const char *src_name);
 
 #ifdef __cplusplus
diff --git a/src/daemon/https/minitasn1/mem.h b/src/daemon/https/minitasn1/mem.h
index 3a5c7aa9..76139df0 100644
--- a/src/daemon/https/minitasn1/mem.h
+++ b/src/daemon/https/minitasn1/mem.h
@@ -1,7 +1,7 @@
 #ifndef MEM_H
 # define MEM_H
 
-/* Use _asn1_afree() when calling alloca, or
+/* Use MHD__asn1_afree() when calling alloca, or
  * memory leaks may occur in systems which do not
  * support alloca.
  */
@@ -9,17 +9,17 @@
 # ifdef HAVE_ALLOCA_H
 #  include <alloca.h>
 # endif
-# define _asn1_alloca alloca
-# define _asn1_afree(x)
+# define MHD__asn1_alloca alloca
+# define MHD__asn1_afree(x)
 #else
-# define _asn1_alloca _asn1_malloc
-# define _asn1_afree _asn1_free
+# define MHD__asn1_alloca MHD__asn1_malloc
+# define MHD__asn1_afree MHD__asn1_free
 #endif /* HAVE_ALLOCA */
 
-#define _asn1_malloc malloc
-#define _asn1_free free
-#define _asn1_calloc calloc
-#define _asn1_realloc realloc
-#define _asn1_strdup strdup
+#define MHD__asn1_malloc malloc
+#define MHD__asn1_free free
+#define MHD__asn1_calloc calloc
+#define MHD__asn1_realloc realloc
+#define MHD__asn1_strdup strdup
 
 #endif /* MEM_H */
diff --git a/src/daemon/https/minitasn1/parser_aux.c b/src/daemon/https/minitasn1/parser_aux.c
index dcaee0a9..2ec54cbf 100644
--- a/src/daemon/https/minitasn1/parser_aux.c
+++ b/src/daemon/https/minitasn1/parser_aux.c
@@ -27,7 +27,7 @@
 #include "structure.h"
 #include "element.h"
 
-char _asn1_identifierMissing[MAX_NAME_SIZE + 1];        /* identifier name not found */
+char MHD__asn1_identifierMissing[MAX_NAME_SIZE + 1];        /* identifier name not found */
 
 /***********************************************/
 /* Type: list_type                             */
@@ -45,7 +45,7 @@ typedef struct list_struct
 list_type *firstElement = NULL;
 
 /******************************************************/
-/* Function : _asn1_add_node                          */
+/* Function : MHD__asn1_add_node                          */
 /* Description: creates a new NODE_ASN element and    */
 /* puts it in the list pointed by firstElement.       */
 /* Parameters:                                        */
@@ -54,19 +54,19 @@ list_type *firstElement = NULL;
 /* Return: pointer to the new element.                */
 /******************************************************/
 node_asn *
-_asn1_add_node (unsigned int type)
+MHD__asn1_add_node (unsigned int type)
 {
   list_type *listElement;
   node_asn *punt;
 
-  punt = (node_asn *) _asn1_calloc (1, sizeof (node_asn));
+  punt = (node_asn *) MHD__asn1_calloc (1, sizeof (node_asn));
   if (punt == NULL)
     return NULL;
 
-  listElement = (list_type *) _asn1_malloc (sizeof (list_type));
+  listElement = (list_type *) MHD__asn1_malloc (sizeof (list_type));
   if (listElement == NULL)
     {
-      _asn1_free (punt);
+      MHD__asn1_free (punt);
       return NULL;
     }
 
@@ -80,7 +80,7 @@ _asn1_add_node (unsigned int type)
 }
 
 /**
- * asn1_find_node:
+ * MHD__asn1_find_node:
  * @pointer: NODE_ASN element pointer.
  * @name: null terminated string with the element's name to find.
  *
@@ -92,7 +92,7 @@ _asn1_add_node (unsigned int type)
  * Return value: the searching result. NULL if not found.
  **/
 ASN1_TYPE
-asn1_find_node (ASN1_TYPE pointer, const char *name)
+MHD__asn1_find_node (ASN1_TYPE pointer, const char *name)
 {
   node_asn *p;
   char *n_end, n[MAX_NAME_SIZE + 1];
@@ -119,7 +119,7 @@ asn1_find_node (ASN1_TYPE pointer, const char *name)
         }
       else
         {
-          _asn1_str_cpy (n, sizeof (n), n_start);
+          MHD__asn1_str_cpy (n, sizeof (n), n_start);
           n_start = NULL;
         }
 
@@ -152,7 +152,7 @@ asn1_find_node (ASN1_TYPE pointer, const char *name)
         }
       else
         {
-          _asn1_str_cpy (n, sizeof (n), n_start);
+          MHD__asn1_str_cpy (n, sizeof (n), n_start);
           n_start = NULL;
         }
 
@@ -189,7 +189,7 @@ asn1_find_node (ASN1_TYPE pointer, const char *name)
 
 
 /******************************************************************/
-/* Function : _asn1_set_value                                     */
+/* Function : MHD__asn1_set_value                                     */
 /* Description: sets the field VALUE in a NODE_ASN element. The   */
 /*              previous value (if exist) will be lost            */
 /* Parameters:                                                    */
@@ -199,7 +199,7 @@ asn1_find_node (ASN1_TYPE pointer, const char *name)
 /* Return: pointer to the NODE_ASN element.                       */
 /******************************************************************/
 node_asn *
-_asn1_set_value (node_asn * node, const void *_value, unsigned int len)
+MHD__asn1_set_value (node_asn * node, const void *_value, unsigned int len)
 {
   const unsigned char *value = _value;
 
@@ -207,13 +207,13 @@ _asn1_set_value (node_asn * node, const void *_value, unsigned int len)
     return node;
   if (node->value)
     {
-      _asn1_free (node->value);
+      MHD__asn1_free (node->value);
       node->value = NULL;
       node->value_len = 0;
     }
   if (!len)
     return node;
-  node->value = (unsigned char *) _asn1_malloc (len);
+  node->value = (unsigned char *) MHD__asn1_malloc (len);
   if (node->value == NULL)
     return NULL;
   node->value_len = len;
@@ -223,7 +223,7 @@ _asn1_set_value (node_asn * node, const void *_value, unsigned int len)
 }
 
 /******************************************************************/
-/* Function : _asn1_set_name                                      */
+/* Function : MHD__asn1_set_name                                      */
 /* Description: sets the field NAME in a NODE_ASN element. The    */
 /*              previous value (if exist) will be lost            */
 /* Parameters:                                                    */
@@ -233,14 +233,14 @@ _asn1_set_value (node_asn * node, const void *_value, unsigned int len)
 /* Return: pointer to the NODE_ASN element.                       */
 /******************************************************************/
 node_asn *
-_asn1_set_name (node_asn * node, const char *name)
+MHD__asn1_set_name (node_asn * node, const char *name)
 {
   if (node == NULL)
     return node;
 
   if (node->name)
     {
-      _asn1_free (node->name);
+      MHD__asn1_free (node->name);
       node->name = NULL;
     }
 
@@ -249,7 +249,7 @@ _asn1_set_name (node_asn * node, const char *name)
 
   if (strlen (name))
     {
-      node->name = (char *) _asn1_strdup (name);
+      node->name = (char *) MHD__asn1_strdup (name);
       if (node->name == NULL)
         return NULL;
     }
@@ -259,7 +259,7 @@ _asn1_set_name (node_asn * node, const char *name)
 }
 
 /******************************************************************/
-/* Function : _asn1_set_right                                     */
+/* Function : MHD__asn1_set_right                                     */
 /* Description: sets the field RIGHT in a NODE_ASN element.       */
 /* Parameters:                                                    */
 /*   node: element pointer.                                       */
@@ -268,7 +268,7 @@ _asn1_set_name (node_asn * node, const char *name)
 /* Return: pointer to *NODE.                                      */
 /******************************************************************/
 node_asn *
-_asn1_set_right (node_asn * node, node_asn * right)
+MHD__asn1_set_right (node_asn * node, node_asn * right)
 {
   if (node == NULL)
     return node;
@@ -279,7 +279,7 @@ _asn1_set_right (node_asn * node, node_asn * right)
 }
 
 /******************************************************************/
-/* Function : _asn1_get_right                                     */
+/* Function : MHD__asn1_get_right                                     */
 /* Description: returns the element pointed by the RIGHT field of */
 /*              a NODE_ASN element.                               */
 /* Parameters:                                                    */
@@ -287,7 +287,7 @@ _asn1_set_right (node_asn * node, node_asn * right)
 /* Return: field RIGHT of NODE.                                   */
 /******************************************************************/
 node_asn *
-_asn1_get_right (node_asn * node)
+MHD__asn1_get_right (node_asn * node)
 {
   if (node == NULL)
     return NULL;
@@ -295,14 +295,14 @@ _asn1_get_right (node_asn * node)
 }
 
 /******************************************************************/
-/* Function : _asn1_get_last_right                                */
+/* Function : MHD__asn1_get_last_right                                */
 /* Description: return the last element along the right chain.    */
 /* Parameters:                                                    */
 /*   node: starting element pointer.                              */
 /* Return: pointer to the last element along the right chain.     */
 /******************************************************************/
 node_asn *
-_asn1_get_last_right (node_asn * node)
+MHD__asn1_get_last_right (node_asn * node)
 {
   node_asn *p;
 
@@ -315,7 +315,7 @@ _asn1_get_last_right (node_asn * node)
 }
 
 /******************************************************************/
-/* Function : _asn1_set_down                                      */
+/* Function : MHD__asn1_set_down                                      */
 /* Description: sets the field DOWN in a NODE_ASN element.        */
 /* Parameters:                                                    */
 /*   node: element pointer.                                       */
@@ -324,7 +324,7 @@ _asn1_get_last_right (node_asn * node)
 /* Return: pointer to *NODE.                                      */
 /******************************************************************/
 node_asn *
-_asn1_set_down (node_asn * node, node_asn * down)
+MHD__asn1_set_down (node_asn * node, node_asn * down)
 {
   if (node == NULL)
     return node;
@@ -335,7 +335,7 @@ _asn1_set_down (node_asn * node, node_asn * down)
 }
 
 /******************************************************************/
-/* Function : _asn1_get_down                                      */
+/* Function : MHD__asn1_get_down                                      */
 /* Description: returns the element pointed by the DOWN field of  */
 /*              a NODE_ASN element.                               */
 /* Parameters:                                                    */
@@ -343,7 +343,7 @@ _asn1_set_down (node_asn * node, node_asn * down)
 /* Return: field DOWN of NODE.                                    */
 /******************************************************************/
 node_asn *
-_asn1_get_down (node_asn * node)
+MHD__asn1_get_down (node_asn * node)
 {
   if (node == NULL)
     return NULL;
@@ -351,14 +351,14 @@ _asn1_get_down (node_asn * node)
 }
 
 /******************************************************************/
-/* Function : _asn1_get_name                                      */
+/* Function : MHD__asn1_get_name                                      */
 /* Description: returns the name of a NODE_ASN element.           */
 /* Parameters:                                                    */
 /*   node: NODE_ASN element pointer.                              */
 /* Return: a null terminated string.                              */
 /******************************************************************/
 char *
-_asn1_get_name (node_asn * node)
+MHD__asn1_get_name (node_asn * node)
 {
   if (node == NULL)
     return NULL;
@@ -366,7 +366,7 @@ _asn1_get_name (node_asn * node)
 }
 
 /******************************************************************/
-/* Function : _asn1_mod_type                                      */
+/* Function : MHD__asn1_mod_type                                      */
 /* Description: change the field TYPE of an NODE_ASN element.     */
 /*              The new value is the old one | (bitwise or) the   */
 /*              paramener VALUE.                                  */
@@ -377,7 +377,7 @@ _asn1_get_name (node_asn * node)
 /* Return: NODE pointer.                                          */
 /******************************************************************/
 node_asn *
-_asn1_mod_type (node_asn * node, unsigned int value)
+MHD__asn1_mod_type (node_asn * node, unsigned int value)
 {
   if (node == NULL)
     return node;
@@ -387,34 +387,34 @@ _asn1_mod_type (node_asn * node, unsigned int value)
 
 
 /******************************************************************/
-/* Function : _asn1_remove_node                                   */
+/* Function : MHD__asn1_remove_node                                   */
 /* Description: gets free the memory allocated for an NODE_ASN    */
 /*              element (not the elements pointed by it).         */
 /* Parameters:                                                    */
 /*   node: NODE_ASN element pointer.                              */
 /******************************************************************/
 void
-_asn1_remove_node (node_asn * node)
+MHD__asn1_remove_node (node_asn * node)
 {
   if (node == NULL)
     return;
 
   if (node->name != NULL)
-    _asn1_free (node->name);
+    MHD__asn1_free (node->name);
   if (node->value != NULL)
-    _asn1_free (node->value);
-  _asn1_free (node);
+    MHD__asn1_free (node->value);
+  MHD__asn1_free (node);
 }
 
 /******************************************************************/
-/* Function : _asn1_find_up                                       */
+/* Function : MHD__asn1_find_up                                       */
 /* Description: return the father of the NODE_ASN element.        */
 /* Parameters:                                                    */
 /*   node: NODE_ASN element pointer.                              */
 /* Return: Null if not found.                                     */
 /******************************************************************/
 node_asn *
-_asn1_find_up (node_asn * node)
+MHD__asn1_find_up (node_asn * node)
 {
   node_asn *p;
 
@@ -430,12 +430,12 @@ _asn1_find_up (node_asn * node)
 }
 
 /******************************************************************/
-/* Function : _asn1_delete_list                                   */
+/* Function : MHD__asn1_delete_list                                   */
 /* Description: deletes the list elements (not the elements       */
 /*  pointed by them).                                             */
 /******************************************************************/
 void
-_asn1_delete_list (void)
+MHD__asn1_delete_list (void)
 {
   list_type *listElement;
 
@@ -443,17 +443,17 @@ _asn1_delete_list (void)
     {
       listElement = firstElement;
       firstElement = firstElement->next;
-      _asn1_free (listElement);
+      MHD__asn1_free (listElement);
     }
 }
 
 /******************************************************************/
-/* Function : _asn1_delete_list_and nodes                         */
+/* Function : MHD__asn1_delete_list_and nodes                         */
 /* Description: deletes the list elements and the elements        */
 /*  pointed by them.                                              */
 /******************************************************************/
 void
-_asn1_delete_list_and_nodes (void)
+MHD__asn1_delete_list_and_nodes (void)
 {
   list_type *listElement;
 
@@ -461,14 +461,14 @@ _asn1_delete_list_and_nodes (void)
     {
       listElement = firstElement;
       firstElement = firstElement->next;
-      _asn1_remove_node (listElement->node);
-      _asn1_free (listElement);
+      MHD__asn1_remove_node (listElement->node);
+      MHD__asn1_free (listElement);
     }
 }
 
 
 char *
-_asn1_ltostr (long v, char *str)
+MHD__asn1_ltostr (long v, char *str)
 {
   long d, r;
   char temp[20];
@@ -502,7 +502,7 @@ _asn1_ltostr (long v, char *str)
 
 
 /******************************************************************/
-/* Function : _asn1_change_integer_value                          */
+/* Function : MHD__asn1_change_integer_value                          */
 /* Description: converts into DER coding the value assign to an   */
 /*   INTEGER constant.                                            */
 /* Parameters:                                                    */
@@ -511,8 +511,8 @@ _asn1_ltostr (long v, char *str)
 /*   ASN1_ELEMENT_NOT_FOUND if NODE is NULL,                       */
 /*   otherwise ASN1_SUCCESS                                             */
 /******************************************************************/
-asn1_retCode
-_asn1_change_integer_value (ASN1_TYPE node)
+MHD__asn1_retCode
+MHD__asn1_change_integer_value (ASN1_TYPE node)
 {
   node_asn *p;
   unsigned char val[SIZEOF_UNSIGNED_LONG_INT];
@@ -529,9 +529,9 @@ _asn1_change_integer_value (ASN1_TYPE node)
         {
           if (p->value)
             {
-              _asn1_convert_integer (p->value, val, sizeof (val), &len);
-              asn1_octet_der (val, len, val2, &len);
-              _asn1_set_value (p, val2, len);
+              MHD__asn1_convert_integer (p->value, val, sizeof (val), &len);
+              MHD__asn1_octet_der (val, len, val2, &len);
+              MHD__asn1_set_value (p, val2, len);
             }
         }
 
@@ -549,7 +549,7 @@ _asn1_change_integer_value (ASN1_TYPE node)
             {
               while (1)
                 {
-                  p = _asn1_find_up (p);
+                  p = MHD__asn1_find_up (p);
                   if (p == node)
                     {
                       p = NULL;
@@ -570,7 +570,7 @@ _asn1_change_integer_value (ASN1_TYPE node)
 
 
 /******************************************************************/
-/* Function : _asn1_expand_object_id                              */
+/* Function : MHD__asn1_expand_object_id                              */
 /* Description: expand the IDs of an OBJECT IDENTIFIER constant.  */
 /* Parameters:                                                    */
 /*   node: root of an ASN1 element.                               */
@@ -578,8 +578,8 @@ _asn1_change_integer_value (ASN1_TYPE node)
 /*   ASN1_ELEMENT_NOT_FOUND if NODE is NULL,                       */
 /*   otherwise ASN1_SUCCESS                                             */
 /******************************************************************/
-asn1_retCode
-_asn1_expand_object_id (ASN1_TYPE node)
+MHD__asn1_retCode
+MHD__asn1_expand_object_id (ASN1_TYPE node)
 {
   node_asn *p, *p2, *p3, *p4, *p5;
   char name_root[MAX_NAME_SIZE], name2[2 * MAX_NAME_SIZE + 1];
@@ -588,7 +588,7 @@ _asn1_expand_object_id (ASN1_TYPE node)
   if (node == NULL)
     return ASN1_ELEMENT_NOT_FOUND;
 
-  _asn1_str_cpy (name_root, sizeof (name_root), node->name);
+  MHD__asn1_str_cpy (name_root, sizeof (name_root), node->name);
 
   p = node;
   move = DOWN;
@@ -605,35 +605,35 @@ _asn1_expand_object_id (ASN1_TYPE node)
                 {
                   if (p2->value && !isdigit (p2->value[0]))
                     {
-                      _asn1_str_cpy (name2, sizeof (name2), name_root);
-                      _asn1_str_cat (name2, sizeof (name2), ".");
-                      _asn1_str_cat (name2, sizeof (name2), p2->value);
-                      p3 = asn1_find_node (node, name2);
+                      MHD__asn1_str_cpy (name2, sizeof (name2), name_root);
+                      MHD__asn1_str_cat (name2, sizeof (name2), ".");
+                      MHD__asn1_str_cat (name2, sizeof (name2), p2->value);
+                      p3 = MHD__asn1_find_node (node, name2);
                       if (!p3 || (type_field (p3->type) != TYPE_OBJECT_ID) ||
                           !(p3->type & CONST_ASSIGN))
                         return ASN1_ELEMENT_NOT_FOUND;
-                      _asn1_set_down (p, p2->right);
-                      _asn1_remove_node (p2);
+                      MHD__asn1_set_down (p, p2->right);
+                      MHD__asn1_remove_node (p2);
                       p2 = p;
                       p4 = p3->down;
                       while (p4)
                         {
                           if (type_field (p4->type) == TYPE_CONSTANT)
                             {
-                              p5 = _asn1_add_node_only (TYPE_CONSTANT);
-                              _asn1_set_name (p5, p4->name);
+                              p5 = MHD__asn1_add_node_only (TYPE_CONSTANT);
+                              MHD__asn1_set_name (p5, p4->name);
                               tlen = strlen (p4->value);
                               if (tlen > 0)
-                                _asn1_set_value (p5, p4->value, tlen + 1);
+                                MHD__asn1_set_value (p5, p4->value, tlen + 1);
                               if (p2 == p)
                                 {
-                                  _asn1_set_right (p5, p->down);
-                                  _asn1_set_down (p, p5);
+                                  MHD__asn1_set_right (p5, p->down);
+                                  MHD__asn1_set_down (p, p5);
                                 }
                               else
                                 {
-                                  _asn1_set_right (p5, p2->right);
-                                  _asn1_set_right (p2, p5);
+                                  MHD__asn1_set_right (p5, p2->right);
+                                  MHD__asn1_set_right (p2, p5);
                                 }
                               p2 = p5;
                             }
@@ -671,7 +671,7 @@ _asn1_expand_object_id (ASN1_TYPE node)
             move = UP;
         }
       if (move == UP)
-        p = _asn1_find_up (p);
+        p = MHD__asn1_find_up (p);
     }
 
 
@@ -691,10 +691,10 @@ _asn1_expand_object_id (ASN1_TYPE node)
               p2 = p->down;
               if (p2 && (type_field (p2->type) == TYPE_DEFAULT))
                 {
-                  _asn1_str_cpy (name2, sizeof (name2), name_root);
-                  _asn1_str_cat (name2, sizeof (name2), ".");
-                  _asn1_str_cat (name2, sizeof (name2), p2->value);
-                  p3 = asn1_find_node (node, name2);
+                  MHD__asn1_str_cpy (name2, sizeof (name2), name_root);
+                  MHD__asn1_str_cat (name2, sizeof (name2), ".");
+                  MHD__asn1_str_cat (name2, sizeof (name2), p2->value);
+                  p3 = MHD__asn1_find_node (node, name2);
                   if (!p3 || (type_field (p3->type) != TYPE_OBJECT_ID) ||
                       !(p3->type & CONST_ASSIGN))
                     return ASN1_ELEMENT_NOT_FOUND;
@@ -705,14 +705,14 @@ _asn1_expand_object_id (ASN1_TYPE node)
                       if (type_field (p4->type) == TYPE_CONSTANT)
                         {
                           if (name2[0])
-                            _asn1_str_cat (name2, sizeof (name2), ".");
-                          _asn1_str_cat (name2, sizeof (name2), p4->value);
+                            MHD__asn1_str_cat (name2, sizeof (name2), ".");
+                          MHD__asn1_str_cat (name2, sizeof (name2), p4->value);
                         }
                       p4 = p4->right;
                     }
                   tlen = strlen (name2);
                   if (tlen > 0)
-                    _asn1_set_value (p2, name2, tlen + 1);
+                    MHD__asn1_set_value (p2, name2, tlen + 1);
                 }
             }
           move = DOWN;
@@ -742,7 +742,7 @@ _asn1_expand_object_id (ASN1_TYPE node)
             move = UP;
         }
       if (move == UP)
-        p = _asn1_find_up (p);
+        p = MHD__asn1_find_up (p);
     }
 
   return ASN1_SUCCESS;
@@ -750,7 +750,7 @@ _asn1_expand_object_id (ASN1_TYPE node)
 
 
 /******************************************************************/
-/* Function : _asn1_type_set_config                               */
+/* Function : MHD__asn1_type_set_config                               */
 /* Description: sets the CONST_SET and CONST_NOT_USED properties  */
 /*   in the fields of the SET elements.                           */
 /* Parameters:                                                    */
@@ -759,8 +759,8 @@ _asn1_expand_object_id (ASN1_TYPE node)
 /*   ASN1_ELEMENT_NOT_FOUND if NODE is NULL,                       */
 /*   otherwise ASN1_SUCCESS                                             */
 /******************************************************************/
-asn1_retCode
-_asn1_type_set_config (ASN1_TYPE node)
+MHD__asn1_retCode
+MHD__asn1_type_set_config (ASN1_TYPE node)
 {
   node_asn *p, *p2;
   int move;
@@ -812,7 +812,7 @@ _asn1_type_set_config (ASN1_TYPE node)
             move = UP;
         }
       if (move == UP)
-        p = _asn1_find_up (p);
+        p = MHD__asn1_find_up (p);
     }
 
   return ASN1_SUCCESS;
@@ -820,10 +820,10 @@ _asn1_type_set_config (ASN1_TYPE node)
 
 
 /******************************************************************/
-/* Function : _asn1_check_identifier                              */
+/* Function : MHD__asn1_check_identifier                              */
 /* Description: checks the definitions of all the identifiers     */
 /*   and the first element of an OBJECT_ID (e.g. {pkix 0 4}).     */
-/*   The _asn1_identifierMissing global variable is filled if     */
+/*   The MHD__asn1_identifierMissing global variable is filled if     */
 /*   necessary.                                                   */
 /* Parameters:                                                    */
 /*   node: root of an ASN1 element.                               */
@@ -832,8 +832,8 @@ _asn1_type_set_config (ASN1_TYPE node)
 /*   ASN1_IDENTIFIER_NOT_FOUND   if an identifier is not defined, */
 /*   otherwise ASN1_SUCCESS                                       */
 /******************************************************************/
-asn1_retCode
-_asn1_check_identifier (ASN1_TYPE node)
+MHD__asn1_retCode
+MHD__asn1_check_identifier (ASN1_TYPE node)
 {
   node_asn *p, *p2;
   char name2[MAX_NAME_SIZE * 2 + 2];
@@ -846,13 +846,13 @@ _asn1_check_identifier (ASN1_TYPE node)
     {
       if (type_field (p->type) == TYPE_IDENTIFIER)
         {
-          _asn1_str_cpy (name2, sizeof (name2), node->name);
-          _asn1_str_cat (name2, sizeof (name2), ".");
-          _asn1_str_cat (name2, sizeof (name2), p->value);
-          p2 = asn1_find_node (node, name2);
+          MHD__asn1_str_cpy (name2, sizeof (name2), node->name);
+          MHD__asn1_str_cat (name2, sizeof (name2), ".");
+          MHD__asn1_str_cat (name2, sizeof (name2), p->value);
+          p2 = MHD__asn1_find_node (node, name2);
           if (p2 == NULL)
             {
-              strcpy (_asn1_identifierMissing, p->value);
+              strcpy (MHD__asn1_identifierMissing, p->value);
               return ASN1_IDENTIFIER_NOT_FOUND;
             }
         }
@@ -862,16 +862,16 @@ _asn1_check_identifier (ASN1_TYPE node)
           p2 = p->down;
           if (p2 && (type_field (p2->type) == TYPE_DEFAULT))
             {
-              _asn1_str_cpy (name2, sizeof (name2), node->name);
-              _asn1_str_cat (name2, sizeof (name2), ".");
-              _asn1_str_cat (name2, sizeof (name2), p2->value);
-              strcpy (_asn1_identifierMissing, p2->value);
-              p2 = asn1_find_node (node, name2);
+              MHD__asn1_str_cpy (name2, sizeof (name2), node->name);
+              MHD__asn1_str_cat (name2, sizeof (name2), ".");
+              MHD__asn1_str_cat (name2, sizeof (name2), p2->value);
+              strcpy (MHD__asn1_identifierMissing, p2->value);
+              p2 = MHD__asn1_find_node (node, name2);
               if (!p2 || (type_field (p2->type) != TYPE_OBJECT_ID) ||
                   !(p2->type & CONST_ASSIGN))
                 return ASN1_IDENTIFIER_NOT_FOUND;
               else
-                _asn1_identifierMissing[0] = 0;
+                MHD__asn1_identifierMissing[0] = 0;
             }
         }
       else if ((type_field (p->type) == TYPE_OBJECT_ID) &&
@@ -882,16 +882,16 @@ _asn1_check_identifier (ASN1_TYPE node)
             {
               if (p2->value && !isdigit (p2->value[0]))
                 {
-                  _asn1_str_cpy (name2, sizeof (name2), node->name);
-                  _asn1_str_cat (name2, sizeof (name2), ".");
-                  _asn1_str_cat (name2, sizeof (name2), p2->value);
-                  strcpy (_asn1_identifierMissing, p2->value);
-                  p2 = asn1_find_node (node, name2);
+                  MHD__asn1_str_cpy (name2, sizeof (name2), node->name);
+                  MHD__asn1_str_cat (name2, sizeof (name2), ".");
+                  MHD__asn1_str_cat (name2, sizeof (name2), p2->value);
+                  strcpy (MHD__asn1_identifierMissing, p2->value);
+                  p2 = MHD__asn1_find_node (node, name2);
                   if (!p2 || (type_field (p2->type) != TYPE_OBJECT_ID) ||
                       !(p2->type & CONST_ASSIGN))
                     return ASN1_IDENTIFIER_NOT_FOUND;
                   else
-                    _asn1_identifierMissing[0] = 0;
+                    MHD__asn1_identifierMissing[0] = 0;
                 }
             }
         }
@@ -906,7 +906,7 @@ _asn1_check_identifier (ASN1_TYPE node)
         {
           while (1)
             {
-              p = _asn1_find_up (p);
+              p = MHD__asn1_find_up (p);
               if (p == node)
                 {
                   p = NULL;
@@ -926,7 +926,7 @@ _asn1_check_identifier (ASN1_TYPE node)
 
 
 /******************************************************************/
-/* Function : _asn1_set_default_tag                               */
+/* Function : MHD__asn1_set_default_tag                               */
 /* Description: sets the default IMPLICIT or EXPLICIT property in */
 /*   the tagged elements that don't have this declaration.        */
 /* Parameters:                                                    */
@@ -936,8 +936,8 @@ _asn1_check_identifier (ASN1_TYPE node)
 /*     a DEFINITIONS element,                                     */
 /*   otherwise ASN1_SUCCESS                                       */
 /******************************************************************/
-asn1_retCode
-_asn1_set_default_tag (ASN1_TYPE node)
+MHD__asn1_retCode
+MHD__asn1_set_default_tag (ASN1_TYPE node)
 {
   node_asn *p;
 
@@ -966,7 +966,7 @@ _asn1_set_default_tag (ASN1_TYPE node)
         {
           while (1)
             {
-              p = _asn1_find_up (p);
+              p = MHD__asn1_find_up (p);
               if (p == node)
                 {
                   p = NULL;
@@ -1027,7 +1027,7 @@ parse_version_string (const char *s, int *major, int *minor, int *micro)
 }
 
 /**
- * asn1_check_version - check for library version
+ * MHD__asn1_check_version - check for library version
  * @req_version: Required version number, or NULL.
  *
  * Check that the the version of the library is at minimum the
@@ -1041,7 +1041,7 @@ parse_version_string (const char *s, int *major, int *minor, int *micro)
  *   run-time library does not meet the required version number.
  */
 const char *
-asn1_check_version (const char *req_version)
+MHD__asn1_check_version (const char *req_version)
 {
   const char *ver = LIBTASN1_VERSION;
   int my_major, my_minor, my_micro;
diff --git a/src/daemon/https/minitasn1/parser_aux.h b/src/daemon/https/minitasn1/parser_aux.h
index 4f7d3f1b..88b505bb 100644
--- a/src/daemon/https/minitasn1/parser_aux.h
+++ b/src/daemon/https/minitasn1/parser_aux.h
@@ -6,45 +6,45 @@
 /***************************************/
 /*  Functions used by ASN.1 parser     */
 /***************************************/
-node_asn *_asn1_add_node (unsigned int type);
+node_asn *MHD__asn1_add_node (unsigned int type);
 
-node_asn *_asn1_set_value (node_asn * node, const void *value,
+node_asn *MHD__asn1_set_value (node_asn * node, const void *value,
                            unsigned int len);
 
-node_asn *_asn1_set_name (node_asn * node, const char *name);
+node_asn *MHD__asn1_set_name (node_asn * node, const char *name);
 
-node_asn *_asn1_set_right (node_asn * node, node_asn * right);
+node_asn *MHD__asn1_set_right (node_asn * node, node_asn * right);
 
-node_asn *_asn1_get_right (node_asn * node);
+node_asn *MHD__asn1_get_right (node_asn * node);
 
-node_asn *_asn1_get_last_right (node_asn * node);
+node_asn *MHD__asn1_get_last_right (node_asn * node);
 
-node_asn *_asn1_set_down (node_asn * node, node_asn * down);
+node_asn *MHD__asn1_set_down (node_asn * node, node_asn * down);
 
-char *_asn1_get_name (node_asn * node);
+char *MHD__asn1_get_name (node_asn * node);
 
-node_asn *_asn1_get_down (node_asn * node);
+node_asn *MHD__asn1_get_down (node_asn * node);
 
-node_asn *_asn1_mod_type (node_asn * node, unsigned int value);
+node_asn *MHD__asn1_mod_type (node_asn * node, unsigned int value);
 
-void _asn1_remove_node (node_asn * node);
+void MHD__asn1_remove_node (node_asn * node);
 
-void _asn1_delete_list (void);
+void MHD__asn1_delete_list (void);
 
-void _asn1_delete_list_and_nodes (void);
+void MHD__asn1_delete_list_and_nodes (void);
 
-char *_asn1_ltostr (long v, char *str);
+char *MHD__asn1_ltostr (long v, char *str);
 
-node_asn *_asn1_find_up (node_asn * node);
+node_asn *MHD__asn1_find_up (node_asn * node);
 
-asn1_retCode _asn1_change_integer_value (ASN1_TYPE node);
+MHD__asn1_retCode MHD__asn1_change_integer_value (ASN1_TYPE node);
 
-asn1_retCode _asn1_expand_object_id (ASN1_TYPE node);
+MHD__asn1_retCode MHD__asn1_expand_object_id (ASN1_TYPE node);
 
-asn1_retCode _asn1_type_set_config (ASN1_TYPE node);
+MHD__asn1_retCode MHD__asn1_type_set_config (ASN1_TYPE node);
 
-asn1_retCode _asn1_check_identifier (ASN1_TYPE node);
+MHD__asn1_retCode MHD__asn1_check_identifier (ASN1_TYPE node);
 
-asn1_retCode _asn1_set_default_tag (ASN1_TYPE node);
+MHD__asn1_retCode MHD__asn1_set_default_tag (ASN1_TYPE node);
 
 #endif
diff --git a/src/daemon/https/minitasn1/structure.c b/src/daemon/https/minitasn1/structure.c
index 264793c1..af5fdf75 100644
--- a/src/daemon/https/minitasn1/structure.c
+++ b/src/daemon/https/minitasn1/structure.c
@@ -35,11 +35,11 @@
 #include <gstr.h>
 
 
-extern char _asn1_identifierMissing[];
+extern char MHD__asn1_identifierMissing[];
 
 
 /******************************************************/
-/* Function : _asn1_add_node_only                     */
+/* Function : MHD__asn1_add_node_only                     */
 /* Description: creates a new NODE_ASN element.       */
 /* Parameters:                                        */
 /*   type: type of the new element (see TYPE_         */
@@ -47,11 +47,11 @@ extern char _asn1_identifierMissing[];
 /* Return: pointer to the new element.                */
 /******************************************************/
 node_asn *
-_asn1_add_node_only (unsigned int type)
+MHD__asn1_add_node_only (unsigned int type)
 {
   node_asn *punt;
 
-  punt = (node_asn *) _asn1_calloc (1, sizeof (node_asn));
+  punt = (node_asn *) MHD__asn1_calloc (1, sizeof (node_asn));
   if (punt == NULL)
     return NULL;
 
@@ -62,7 +62,7 @@ _asn1_add_node_only (unsigned int type)
 
 
 /******************************************************************/
-/* Function : _asn1_find_left                                     */
+/* Function : MHD__asn1_find_left                                     */
 /* Description: returns the NODE_ASN element with RIGHT field that*/
 /*              points the element NODE.                          */
 /* Parameters:                                                    */
@@ -70,7 +70,7 @@ _asn1_add_node_only (unsigned int type)
 /* Return: NULL if not found.                                     */
 /******************************************************************/
 node_asn *
-_asn1_find_left (node_asn * node)
+MHD__asn1_find_left (node_asn * node)
 {
   if ((node == NULL) || (node->left == NULL) || (node->left->down == node))
     return NULL;
@@ -79,8 +79,8 @@ _asn1_find_left (node_asn * node)
 }
 
 
-asn1_retCode
-_asn1_create_static_structure (ASN1_TYPE pointer, char *output_file_name,
+MHD__asn1_retCode
+MHD__asn1_create_static_structure (ASN1_TYPE pointer, char *output_file_name,
                                char *vector_name)
 {
   FILE *file;
@@ -136,7 +136,7 @@ _asn1_create_static_structure (ASN1_TYPE pointer, char *output_file_name,
         {
           while (1)
             {
-              p = _asn1_find_up (p);
+              p = MHD__asn1_find_up (p);
               if (p == pointer)
                 {
                   p = NULL;
@@ -160,14 +160,14 @@ _asn1_create_static_structure (ASN1_TYPE pointer, char *output_file_name,
 
 
 /**
-  * asn1_array2tree - Creates the structures needed to manage the ASN1 definitions.
+  * MHD__asn1_array2tree - Creates the structures needed to manage the ASN1 definitions.
   * @array: specify the array that contains ASN.1 declarations
   * @definitions: return the pointer to the structure created by
   *   *ARRAY ASN.1 declarations
   * @errorDescription: return the error description.
   *
   * Creates the structures needed to manage the ASN.1 definitions.
-  * @array is a vector created by asn1_parser2array().
+  * @array is a vector created by MHD__asn1_parser2array().
   *
   * Returns:
   *
@@ -180,14 +180,14 @@ _asn1_create_static_structure (ASN1_TYPE pointer, char *output_file_name,
   *
   * ASN1_ARRAY_ERROR: The array pointed by @array is wrong.
   **/
-asn1_retCode
-asn1_array2tree (const ASN1_ARRAY_TYPE * array, ASN1_TYPE * definitions,
+MHD__asn1_retCode
+MHD__asn1_array2tree (const ASN1_ARRAY_TYPE * array, ASN1_TYPE * definitions,
                  char *errorDescription)
 {
   node_asn *p, *p_last = NULL;
   unsigned long k;
   int move;
-  asn1_retCode result;
+  MHD__asn1_retCode result;
 
 
   if (*definitions != ASN1_TYPE_EMPTY)
@@ -198,19 +198,19 @@ asn1_array2tree (const ASN1_ARRAY_TYPE * array, ASN1_TYPE * definitions,
   k = 0;
   while (array[k].value || array[k].type || array[k].name)
     {
-      p = _asn1_add_node (array[k].type & (~CONST_DOWN));
+      p = MHD__asn1_add_node (array[k].type & (~CONST_DOWN));
       if (array[k].name)
-        _asn1_set_name (p, array[k].name);
+        MHD__asn1_set_name (p, array[k].name);
       if (array[k].value)
-        _asn1_set_value (p, array[k].value, strlen (array[k].value) + 1);
+        MHD__asn1_set_value (p, array[k].value, strlen (array[k].value) + 1);
 
       if (*definitions == NULL)
         *definitions = p;
 
       if (move == DOWN)
-        _asn1_set_down (p_last, p);
+        MHD__asn1_set_down (p_last, p);
       else if (move == RIGHT)
-        _asn1_set_right (p_last, p);
+        MHD__asn1_set_right (p_last, p);
 
       p_last = p;
 
@@ -225,7 +225,7 @@ asn1_array2tree (const ASN1_ARRAY_TYPE * array, ASN1_TYPE * definitions,
               if (p_last == *definitions)
                 break;
 
-              p_last = _asn1_find_up (p_last);
+              p_last = MHD__asn1_find_up (p_last);
 
               if (p_last == NULL)
                 break;
@@ -243,11 +243,11 @@ asn1_array2tree (const ASN1_ARRAY_TYPE * array, ASN1_TYPE * definitions,
 
   if (p_last == *definitions)
     {
-      result = _asn1_check_identifier (*definitions);
+      result = MHD__asn1_check_identifier (*definitions);
       if (result == ASN1_SUCCESS)
         {
-          _asn1_change_integer_value (*definitions);
-          _asn1_expand_object_id (*definitions);
+          MHD__asn1_change_integer_value (*definitions);
+          MHD__asn1_expand_object_id (*definitions);
         }
     }
   else
@@ -260,7 +260,7 @@ asn1_array2tree (const ASN1_ARRAY_TYPE * array, ASN1_TYPE * definitions,
       if (result == ASN1_IDENTIFIER_NOT_FOUND)
         {
           Estrcpy (errorDescription, ":: identifier '");
-          Estrcat (errorDescription, _asn1_identifierMissing);
+          Estrcat (errorDescription, MHD__asn1_identifierMissing);
           Estrcat (errorDescription, "' not found");
         }
       else
@@ -269,17 +269,17 @@ asn1_array2tree (const ASN1_ARRAY_TYPE * array, ASN1_TYPE * definitions,
 
   if (result != ASN1_SUCCESS)
     {
-      _asn1_delete_list_and_nodes ();
+      MHD__asn1_delete_list_and_nodes ();
       *definitions = ASN1_TYPE_EMPTY;
     }
   else
-    _asn1_delete_list ();
+    MHD__asn1_delete_list ();
 
   return result;
 }
 
 /**
-  * asn1_delete_structure - Deletes the structure pointed by *ROOT.
+  * MHD__asn1_delete_structure - Deletes the structure pointed by *ROOT.
   * @structure: pointer to the structure that you want to delete.
   *
   * Deletes the structure *@structure.  At the end, *@structure is set
@@ -292,8 +292,8 @@ asn1_array2tree (const ASN1_ARRAY_TYPE * array, ASN1_TYPE * definitions,
   * ASN1_ELEMENT_NOT_FOUND: *@structure was ASN1_TYPE_EMPTY.
   *
   **/
-asn1_retCode
-asn1_delete_structure (ASN1_TYPE * structure)
+MHD__asn1_retCode
+MHD__asn1_delete_structure (ASN1_TYPE * structure)
 {
   node_asn *p, *p2, *p3;
 
@@ -312,19 +312,19 @@ asn1_delete_structure (ASN1_TYPE * structure)
           p2 = p->right;
           if (p != *structure)
             {
-              p3 = _asn1_find_up (p);
-              _asn1_set_down (p3, p2);
-              _asn1_remove_node (p);
+              p3 = MHD__asn1_find_up (p);
+              MHD__asn1_set_down (p3, p2);
+              MHD__asn1_remove_node (p);
               p = p3;
             }
           else
             {                   /* p==root */
-              p3 = _asn1_find_left (p);
+              p3 = MHD__asn1_find_left (p);
               if (!p3)
                 {
-                  p3 = _asn1_find_up (p);
+                  p3 = MHD__asn1_find_up (p);
                   if (p3)
-                    _asn1_set_down (p3, p2);
+                    MHD__asn1_set_down (p3, p2);
                   else
                     {
                       if (p->right)
@@ -332,8 +332,8 @@ asn1_delete_structure (ASN1_TYPE * structure)
                     }
                 }
               else
-                _asn1_set_right (p3, p2);
-              _asn1_remove_node (p);
+                MHD__asn1_set_right (p3, p2);
+              MHD__asn1_remove_node (p);
               p = NULL;
             }
         }
@@ -346,7 +346,7 @@ asn1_delete_structure (ASN1_TYPE * structure)
 
 
 /**
-  * asn1_delete_element - Deletes the element of a structure.
+  * MHD__asn1_delete_element - Deletes the element of a structure.
   * @structure: pointer to the structure that contains the element you
   *   want to delete.
   * @element_name: element's name you want to delete.
@@ -360,34 +360,34 @@ asn1_delete_structure (ASN1_TYPE * structure)
   * ASN1_ELEMENT_NOT_FOUND: The name element was not found.
   *
   **/
-asn1_retCode
-asn1_delete_element (ASN1_TYPE structure, const char *element_name)
+MHD__asn1_retCode
+MHD__asn1_delete_element (ASN1_TYPE structure, const char *element_name)
 {
   node_asn *p2, *p3, *source_node;
 
-  source_node = asn1_find_node (structure, element_name);
+  source_node = MHD__asn1_find_node (structure, element_name);
 
   if (source_node == ASN1_TYPE_EMPTY)
     return ASN1_ELEMENT_NOT_FOUND;
 
   p2 = source_node->right;
-  p3 = _asn1_find_left (source_node);
+  p3 = MHD__asn1_find_left (source_node);
   if (!p3)
     {
-      p3 = _asn1_find_up (source_node);
+      p3 = MHD__asn1_find_up (source_node);
       if (p3)
-        _asn1_set_down (p3, p2);
+        MHD__asn1_set_down (p3, p2);
       else if (source_node->right)
         source_node->right->left = NULL;
     }
   else
-    _asn1_set_right (p3, p2);
+    MHD__asn1_set_right (p3, p2);
 
-  return asn1_delete_structure (&source_node);
+  return MHD__asn1_delete_structure (&source_node);
 }
 
 node_asn *
-_asn1_copy_structure3 (node_asn * source_node)
+MHD__asn1_copy_structure3 (node_asn * source_node)
 {
   node_asn *dest_node, *p_s, *p_d, *p_d_prev;
   int move;
@@ -395,7 +395,7 @@ _asn1_copy_structure3 (node_asn * source_node)
   if (source_node == NULL)
     return NULL;
 
-  dest_node = _asn1_add_node_only (source_node->type);
+  dest_node = MHD__asn1_add_node_only (source_node->type);
 
   p_s = source_node;
   p_d = dest_node;
@@ -407,9 +407,9 @@ _asn1_copy_structure3 (node_asn * source_node)
       if (move != UP)
         {
           if (p_s->name)
-            _asn1_set_name (p_d, p_s->name);
+            MHD__asn1_set_name (p_d, p_s->name);
           if (p_s->value)
-            _asn1_set_value (p_d, p_s->value, p_s->value_len);
+            MHD__asn1_set_value (p_d, p_s->value, p_s->value_len);
           move = DOWN;
         }
       else
@@ -421,8 +421,8 @@ _asn1_copy_structure3 (node_asn * source_node)
             {
               p_s = p_s->down;
               p_d_prev = p_d;
-              p_d = _asn1_add_node_only (p_s->type);
-              _asn1_set_down (p_d_prev, p_d);
+              p_d = MHD__asn1_add_node_only (p_s->type);
+              MHD__asn1_set_down (p_d_prev, p_d);
             }
           else
             move = RIGHT;
@@ -437,16 +437,16 @@ _asn1_copy_structure3 (node_asn * source_node)
             {
               p_s = p_s->right;
               p_d_prev = p_d;
-              p_d = _asn1_add_node_only (p_s->type);
-              _asn1_set_right (p_d_prev, p_d);
+              p_d = MHD__asn1_add_node_only (p_s->type);
+              MHD__asn1_set_right (p_d_prev, p_d);
             }
           else
             move = UP;
         }
       if (move == UP)
         {
-          p_s = _asn1_find_up (p_s);
-          p_d = _asn1_find_up (p_d);
+          p_s = MHD__asn1_find_up (p_s);
+          p_d = MHD__asn1_find_up (p_d);
         }
     }
   while (p_s != source_node);
@@ -456,19 +456,19 @@ _asn1_copy_structure3 (node_asn * source_node)
 
 
 node_asn *
-_asn1_copy_structure2 (node_asn * root, const char *source_name)
+MHD__asn1_copy_structure2 (node_asn * root, const char *source_name)
 {
   node_asn *source_node;
 
-  source_node = asn1_find_node (root, source_name);
+  source_node = MHD__asn1_find_node (root, source_name);
 
-  return _asn1_copy_structure3 (source_node);
+  return MHD__asn1_copy_structure3 (source_node);
 
 }
 
 
-asn1_retCode
-_asn1_type_choice_config (node_asn * node)
+MHD__asn1_retCode
+MHD__asn1_type_choice_config (node_asn * node)
 {
   node_asn *p, *p2, *p3, *p4;
   int move, tlen;
@@ -491,19 +491,19 @@ _asn1_type_choice_config (node_asn * node)
                   if (type_field (p2->type) != TYPE_TAG)
                     {
                       p2->type |= CONST_TAG;
-                      p3 = _asn1_find_left (p2);
+                      p3 = MHD__asn1_find_left (p2);
                       while (p3)
                         {
                           if (type_field (p3->type) == TYPE_TAG)
                             {
-                              p4 = _asn1_add_node_only (p3->type);
+                              p4 = MHD__asn1_add_node_only (p3->type);
                               tlen = strlen (p3->value);
                               if (tlen > 0)
-                                _asn1_set_value (p4, p3->value, tlen + 1);
-                              _asn1_set_right (p4, p2->down);
-                              _asn1_set_down (p2, p4);
+                                MHD__asn1_set_value (p4, p3->value, tlen + 1);
+                              MHD__asn1_set_right (p4, p2->down);
+                              MHD__asn1_set_down (p2, p4);
                             }
-                          p3 = _asn1_find_left (p3);
+                          p3 = MHD__asn1_find_left (p3);
                         }
                     }
                   p2 = p2->right;
@@ -514,7 +514,7 @@ _asn1_type_choice_config (node_asn * node)
                 {
                   p3 = p2->right;
                   if (type_field (p2->type) == TYPE_TAG)
-                    asn1_delete_structure (&p2);
+                    MHD__asn1_delete_structure (&p2);
                   p2 = p3;
                 }
             }
@@ -545,15 +545,15 @@ _asn1_type_choice_config (node_asn * node)
             move = UP;
         }
       if (move == UP)
-        p = _asn1_find_up (p);
+        p = MHD__asn1_find_up (p);
     }
 
   return ASN1_SUCCESS;
 }
 
 
-asn1_retCode
-_asn1_expand_identifier (node_asn ** node, node_asn * root)
+MHD__asn1_retCode
+MHD__asn1_expand_identifier (node_asn ** node, node_asn * root)
 {
   node_asn *p, *p2, *p3;
   char name2[MAX_NAME_SIZE + 2];
@@ -571,15 +571,15 @@ _asn1_expand_identifier (node_asn ** node, node_asn * root)
         {
           if (type_field (p->type) == TYPE_IDENTIFIER)
             {
-              _asn1_str_cpy (name2, sizeof (name2), root->name);
-              _asn1_str_cat (name2, sizeof (name2), ".");
-              _asn1_str_cat (name2, sizeof (name2), p->value);
-              p2 = _asn1_copy_structure2 (root, name2);
+              MHD__asn1_str_cpy (name2, sizeof (name2), root->name);
+              MHD__asn1_str_cat (name2, sizeof (name2), ".");
+              MHD__asn1_str_cat (name2, sizeof (name2), p->value);
+              p2 = MHD__asn1_copy_structure2 (root, name2);
               if (p2 == NULL)
                 {
                   return ASN1_IDENTIFIER_NOT_FOUND;
                 }
-              _asn1_set_name (p2, p->name);
+              MHD__asn1_set_name (p2, p->name);
               p2->right = p->right;
               p2->left = p->left;
               if (p->right)
@@ -589,18 +589,18 @@ _asn1_expand_identifier (node_asn ** node, node_asn * root)
                 {
                   while (p3->right)
                     p3 = p3->right;
-                  _asn1_set_right (p3, p2->down);
-                  _asn1_set_down (p2, p->down);
+                  MHD__asn1_set_right (p3, p2->down);
+                  MHD__asn1_set_down (p2, p->down);
                 }
 
-              p3 = _asn1_find_left (p);
+              p3 = MHD__asn1_find_left (p);
               if (p3)
-                _asn1_set_right (p3, p2);
+                MHD__asn1_set_right (p3, p2);
               else
                 {
-                  p3 = _asn1_find_up (p);
+                  p3 = MHD__asn1_find_up (p);
                   if (p3)
-                    _asn1_set_down (p3, p2);
+                    MHD__asn1_set_down (p3, p2);
                   else
                     {
                       p2->left = NULL;
@@ -622,7 +622,7 @@ _asn1_expand_identifier (node_asn ** node, node_asn * root)
 
               if (p == *node)
                 *node = p2;
-              _asn1_remove_node (p);
+              MHD__asn1_remove_node (p);
               p = p2;
               move = DOWN;
               continue;
@@ -654,7 +654,7 @@ _asn1_expand_identifier (node_asn ** node, node_asn * root)
             move = UP;
         }
       if (move == UP)
-        p = _asn1_find_up (p);
+        p = MHD__asn1_find_up (p);
     }
 
   return ASN1_SUCCESS;
@@ -662,7 +662,7 @@ _asn1_expand_identifier (node_asn ** node, node_asn * root)
 
 
 /**
-  * asn1_create_element - Creates a structure of type SOURCE_NAME.
+  * MHD__asn1_create_element - Creates a structure of type SOURCE_NAME.
   * @definitions: pointer to the structure returned by "parser_asn1" function
   * @source_name: the name of the type of the new structure (must be
   *   inside p_structure).
@@ -671,7 +671,7 @@ _asn1_expand_identifier (node_asn ** node, node_asn * root)
   * Creates a structure of type @source_name.  Example using
   *  "pkix.asn":
   *
-  * rc = asn1_create_structure(cert_def, "PKIX1.Certificate",
+  * rc = MHD__asn1_create_structure(cert_def, "PKIX1.Certificate",
   * certptr);
   *
   * Returns:
@@ -680,22 +680,22 @@ _asn1_expand_identifier (node_asn ** node, node_asn * root)
   *
   * ASN1_ELEMENT_NOT_FOUND: SOURCE_NAME isn't known
   **/
-asn1_retCode
-asn1_create_element (ASN1_TYPE definitions, const char *source_name,
+MHD__asn1_retCode
+MHD__asn1_create_element (ASN1_TYPE definitions, const char *source_name,
                      ASN1_TYPE * element)
 {
   node_asn *dest_node;
   int res;
 
-  dest_node = _asn1_copy_structure2 (definitions, source_name);
+  dest_node = MHD__asn1_copy_structure2 (definitions, source_name);
 
   if (dest_node == NULL)
     return ASN1_ELEMENT_NOT_FOUND;
 
-  _asn1_set_name (dest_node, "");
+  MHD__asn1_set_name (dest_node, "");
 
-  res = _asn1_expand_identifier (&dest_node, definitions);
-  _asn1_type_choice_config (dest_node);
+  res = MHD__asn1_expand_identifier (&dest_node, definitions);
+  MHD__asn1_type_choice_config (dest_node);
 
   *element = dest_node;
 
@@ -704,7 +704,7 @@ asn1_create_element (ASN1_TYPE definitions, const char *source_name,
 
 
 /**
-  * asn1_print_structure - Prints on the standard output the structure's tree
+  * MHD__asn1_print_structure - Prints on the standard output the structure's tree
   * @out: pointer to the output file (e.g. stdout).
   * @structure: pointer to the structure that you want to visit.
   * @name: an element of the structure
@@ -716,7 +716,7 @@ asn1_create_element (ASN1_TYPE definitions, const char *source_name,
   * from the @name element inside the structure @structure.
   **/
 void
-asn1_print_structure (FILE * out, ASN1_TYPE structure, const char *name,
+MHD__asn1_print_structure (FILE * out, ASN1_TYPE structure, const char *name,
                       int mode)
 {
   node_asn *p, *root;
@@ -725,7 +725,7 @@ asn1_print_structure (FILE * out, ASN1_TYPE structure, const char *name,
   if (out == NULL)
     return;
 
-  root = asn1_find_node (structure, name);
+  root = MHD__asn1_find_node (structure, name);
 
   if (root == NULL)
     return;
@@ -872,7 +872,7 @@ asn1_print_structure (FILE * out, ASN1_TYPE structure, const char *name,
               if (p->value)
                 {
                   len2 = -1;
-                  len = asn1_get_length_der (p->value, p->value_len, &len2);
+                  len = MHD__asn1_get_length_der (p->value, p->value_len, &len2);
                   fprintf (out, "  value:0x");
                   if (len > 0)
                     for (k = 0; k < len; k++)
@@ -883,7 +883,7 @@ asn1_print_structure (FILE * out, ASN1_TYPE structure, const char *name,
               if (p->value)
                 {
                   len2 = -1;
-                  len = asn1_get_length_der (p->value, p->value_len, &len2);
+                  len = MHD__asn1_get_length_der (p->value, p->value_len, &len2);
                   fprintf (out, "  value:0x");
                   if (len > 0)
                     for (k = 0; k < len; k++)
@@ -907,7 +907,7 @@ asn1_print_structure (FILE * out, ASN1_TYPE structure, const char *name,
               if (p->value)
                 {
                   len2 = -1;
-                  len = asn1_get_length_der (p->value, p->value_len, &len2);
+                  len = MHD__asn1_get_length_der (p->value, p->value_len, &len2);
                   if (len > 0)
                     {
                       fprintf (out, "  value(%i):",
@@ -921,7 +921,7 @@ asn1_print_structure (FILE * out, ASN1_TYPE structure, const char *name,
               if (p->value)
                 {
                   len2 = -1;
-                  len = asn1_get_length_der (p->value, p->value_len, &len2);
+                  len = MHD__asn1_get_length_der (p->value, p->value_len, &len2);
                   fprintf (out, "  value:");
                   if (len > 0)
                     for (k = 0; k < len; k++)
@@ -932,7 +932,7 @@ asn1_print_structure (FILE * out, ASN1_TYPE structure, const char *name,
               if (p->value)
                 {
                   len2 = -1;
-                  len = asn1_get_length_der (p->value, p->value_len, &len2);
+                  len = MHD__asn1_get_length_der (p->value, p->value_len, &len2);
                   fprintf (out, "  value:");
                   if (len > 0)
                     for (k = 0; k < len; k++)
@@ -947,7 +947,7 @@ asn1_print_structure (FILE * out, ASN1_TYPE structure, const char *name,
               if (p->value)
                 {
                   len3 = -1;
-                  len2 = asn1_get_length_der (p->value, p->value_len, &len3);
+                  len2 = MHD__asn1_get_length_der (p->value, p->value_len, &len3);
                   fprintf (out, "  value:");
                   if (len2 > 0)
                     for (k = 0; k < len2; k++)
@@ -1048,7 +1048,7 @@ asn1_print_structure (FILE * out, ASN1_TYPE structure, const char *name,
         {
           while (1)
             {
-              p = _asn1_find_up (p);
+              p = MHD__asn1_find_up (p);
               if (p == root)
                 {
                   p = NULL;
@@ -1068,7 +1068,7 @@ asn1_print_structure (FILE * out, ASN1_TYPE structure, const char *name,
 
 
 /**
-  * asn1_number_of_elements - Counts the number of elements of a structure.
+  * MHD__asn1_number_of_elements - Counts the number of elements of a structure.
   * @element: pointer to the root of an ASN1 structure.
   * @name: the name of a sub-structure of ROOT.
   * @num: pointer to an integer where the result will be stored
@@ -1085,8 +1085,8 @@ asn1_print_structure (FILE * out, ASN1_TYPE structure, const char *name,
   *  ASN1_GENERIC_ERROR: Pointer num equal to NULL.
   *
   **/
-asn1_retCode
-asn1_number_of_elements (ASN1_TYPE element, const char *name, int *num)
+MHD__asn1_retCode
+MHD__asn1_number_of_elements (ASN1_TYPE element, const char *name, int *num)
 {
   node_asn *node, *p;
 
@@ -1095,7 +1095,7 @@ asn1_number_of_elements (ASN1_TYPE element, const char *name, int *num)
 
   *num = 0;
 
-  node = asn1_find_node (element, name);
+  node = MHD__asn1_find_node (element, name);
   if (node == NULL)
     return ASN1_ELEMENT_NOT_FOUND;
 
@@ -1113,7 +1113,7 @@ asn1_number_of_elements (ASN1_TYPE element, const char *name, int *num)
 
 
 /**
-  * asn1_find_structure_from_oid - Locate structure defined by a specific OID.
+  * MHD__asn1_find_structure_from_oid - Locate structure defined by a specific OID.
   * @definitions: ASN1 definitions
   * @oidValue: value of the OID to search (e.g. "1.2.3.4").
   *
@@ -1125,13 +1125,13 @@ asn1_number_of_elements (ASN1_TYPE element, const char *name, int *num)
   *
   **/
 const char *
-asn1_find_structure_from_oid (ASN1_TYPE definitions, const char *oidValue)
+MHD__asn1_find_structure_from_oid (ASN1_TYPE definitions, const char *oidValue)
 {
   char definitionsName[MAX_NAME_SIZE], name[2 * MAX_NAME_SIZE + 1];
   char value[MAX_NAME_SIZE];
   ASN1_TYPE p;
   int len;
-  asn1_retCode result;
+  MHD__asn1_retCode result;
 
   if ((definitions == ASN1_TYPE_EMPTY) || (oidValue == NULL))
     return NULL;                /* ASN1_ELEMENT_NOT_FOUND; */
@@ -1151,7 +1151,7 @@ asn1_find_structure_from_oid (ASN1_TYPE definitions, const char *oidValue)
           strcat (name, p->name);
 
           len = MAX_NAME_SIZE;
-          result = asn1_read_value (definitions, name, value, &len);
+          result = MHD__asn1_read_value (definitions, name, value, &len);
 
           if ((result == ASN1_SUCCESS) && (!strcmp (oidValue, value)))
             {
@@ -1169,7 +1169,7 @@ asn1_find_structure_from_oid (ASN1_TYPE definitions, const char *oidValue)
 }
 
 /**
- * asn1_copy_node:
+ * MHD__asn1_copy_node:
  * @dst: Destination ASN1_TYPE node.
  * @dst_name: Field name in destination node.
  * @src: Source ASN1_TYPE node.
@@ -1179,8 +1179,8 @@ asn1_find_structure_from_oid (ASN1_TYPE definitions, const char *oidValue)
  *
  * Return value: Return ASN1_SUCCESS on success.
  **/
-asn1_retCode
-asn1_copy_node (ASN1_TYPE dst, const char *dst_name,
+MHD__asn1_retCode
+MHD__asn1_copy_node (ASN1_TYPE dst, const char *dst_name,
                 ASN1_TYPE src, const char *src_name)
 {
 /* FIXME: rewrite using copy_structure().
@@ -1191,31 +1191,31 @@ asn1_copy_node (ASN1_TYPE dst, const char *dst_name,
   void *data = NULL;
   int size = 0;
 
-  result = asn1_der_coding (src, src_name, NULL, &size, NULL);
+  result = MHD__asn1_der_coding (src, src_name, NULL, &size, NULL);
   if (result != ASN1_MEM_ERROR)
     return result;
 
-  data = _asn1_malloc (size);
+  data = MHD__asn1_malloc (size);
   if (data == NULL)
     return ASN1_MEM_ERROR;
 
-  result = asn1_der_coding (src, src_name, data, &size, NULL);
+  result = MHD__asn1_der_coding (src, src_name, data, &size, NULL);
   if (result != ASN1_SUCCESS)
     {
-      _asn1_free (data);
+      MHD__asn1_free (data);
       return result;
     }
 
-  dst_node = asn1_find_node (dst, dst_name);
+  dst_node = MHD__asn1_find_node (dst, dst_name);
   if (dst_node == NULL)
     {
-      _asn1_free (data);
+      MHD__asn1_free (data);
       return ASN1_ELEMENT_NOT_FOUND;
     }
 
-  result = asn1_der_decoding (&dst_node, data, size, NULL);
+  result = MHD__asn1_der_decoding (&dst_node, data, size, NULL);
 
-  _asn1_free (data);
+  MHD__asn1_free (data);
 
   return result;
 }
diff --git a/src/daemon/https/minitasn1/structure.h b/src/daemon/https/minitasn1/structure.h
index 9fdb3343..e7941639 100644
--- a/src/daemon/https/minitasn1/structure.h
+++ b/src/daemon/https/minitasn1/structure.h
@@ -8,16 +8,16 @@
 #ifndef _STRUCTURE_H
 #define _STRUCTURE_H
 
-asn1_retCode _asn1_create_static_structure (node_asn * pointer,
+MHD__asn1_retCode MHD__asn1_create_static_structure (node_asn * pointer,
                                             char *output_file_name,
                                             char *vector_name);
 
-node_asn *_asn1_copy_structure3 (node_asn * source_node);
+node_asn *MHD__asn1_copy_structure3 (node_asn * source_node);
 
-node_asn *_asn1_copy_structure2 (node_asn * root, const char *source_name);
+node_asn *MHD__asn1_copy_structure2 (node_asn * root, const char *source_name);
 
-node_asn *_asn1_add_node_only (unsigned int type);
+node_asn *MHD__asn1_add_node_only (unsigned int type);
 
-node_asn *_asn1_find_left (node_asn * node);
+node_asn *MHD__asn1_find_left (node_asn * node);
 
 #endif
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)))
diff --git a/src/daemon/https/x509/common.c b/src/daemon/https/x509/common.c
index 53ae4be8..43da45c9 100644
--- a/src/daemon/https/x509/common.c
+++ b/src/daemon/https/x509/common.c
@@ -170,7 +170,7 @@ static const oid2string _oid2str[] = {
 /* Returns 1 if the data defined by the OID are printable.
  */
 int
-_gnutls_x509_oid_data_printable (const char *oid)
+MHD__gnutls_x509_oid_data_printable (const char *oid)
 {
   int i = 0;
 
@@ -186,11 +186,11 @@ _gnutls_x509_oid_data_printable (const char *oid)
 }
 
 /**
- * gnutls_x509_dn_oid_known - This function will return true if the given OID is known
+ * MHD_gnutls_x509_dn_oid_known - This function will return true if the given OID is known
  * @oid: holds an Object Identifier in a null terminated string
  *
  * This function will inform about known DN OIDs. This is useful since functions
- * like gnutls_x509_crt_set_dn_by_oid() use the information on known
+ * like MHD_gnutls_x509_crt_set_dn_by_oid() use the information on known
  * OIDs to properly encode their input. Object Identifiers that are not
  * known are not encoded by these functions, and their input is stored directly
  * into the ASN.1 structure. In that case of unknown OIDs, you have
@@ -200,7 +200,7 @@ _gnutls_x509_oid_data_printable (const char *oid)
  *
  **/
 int
-gnutls_x509_dn_oid_known (const char *oid)
+MHD_gnutls_x509_dn_oid_known (const char *oid)
 {
   int i = 0;
 
@@ -219,7 +219,7 @@ gnutls_x509_dn_oid_known (const char *oid)
  * type.
  */
 int
-_gnutls_x509_oid_data_choice (const char *oid)
+MHD__gnutls_x509_oid_data_choice (const char *oid)
 {
   int i = 0;
 
@@ -235,7 +235,7 @@ _gnutls_x509_oid_data_choice (const char *oid)
 }
 
 const char *
-_gnutls_x509_oid2ldap_string (const char *oid)
+MHD__gnutls_x509_oid2ldap_string (const char *oid)
 {
   int i = 0;
 
@@ -257,7 +257,7 @@ _gnutls_x509_oid2ldap_string (const char *oid)
  * hold the string.
  */
 int
-_gnutls_x509_oid_data2string (const char *oid,
+MHD__gnutls_x509_oid_data2string (const char *oid,
                               void *value,
                               int value_size, char *res, size_t * res_size)
 {
@@ -265,57 +265,57 @@ _gnutls_x509_oid_data2string (const char *oid,
   const char *ANAME = NULL;
   int CHOICE = -1, len = -1, result;
   ASN1_TYPE tmpasn = ASN1_TYPE_EMPTY;
-  char asn1_err[MAX_ERROR_DESCRIPTION_SIZE] = "";
+  char MHD__asn1_err[MAX_ERROR_DESCRIPTION_SIZE] = "";
 
   if (value == NULL || value_size <= 0 || res_size == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  if (_gnutls_x509_oid_data_printable (oid) == 0)
+  if (MHD__gnutls_x509_oid_data_printable (oid) == 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
-  ANAME = asn1_find_structure_from_oid (_gnutls_get_pkix (), oid);
-  CHOICE = _gnutls_x509_oid_data_choice (oid);
+  ANAME = MHD__asn1_find_structure_from_oid (MHD__gnutls_get_pkix (), oid);
+  CHOICE = MHD__gnutls_x509_oid_data_choice (oid);
 
   if (ANAME == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
-  mhd_gtls_str_cpy (str, sizeof (str), "PKIX1.");
-  mhd_gtls_str_cat (str, sizeof (str), ANAME);
+  MHD_gtls_str_cpy (str, sizeof (str), "PKIX1.");
+  MHD_gtls_str_cat (str, sizeof (str), ANAME);
 
-  if ((result = asn1_create_element (_gnutls_get_pkix (), str,
+  if ((result = MHD__asn1_create_element (MHD__gnutls_get_pkix (), str,
                                      &tmpasn)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  if ((result = asn1_der_decoding (&tmpasn, value, value_size, asn1_err))
+  if ((result = MHD__asn1_der_decoding (&tmpasn, value, value_size, MHD__asn1_err))
       != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      _gnutls_x509_log ("asn1_der_decoding: %s:%s\n", str, asn1_err);
-      asn1_delete_structure (&tmpasn);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__gnutls_x509_log ("MHD__asn1_der_decoding: %s:%s\n", str, MHD__asn1_err);
+      MHD__asn1_delete_structure (&tmpasn);
+      return MHD_gtls_asn2err (result);
     }
 
   /* If this is a choice then we read the choice. Otherwise it
    * is the value;
    */
   len = sizeof (str) - 1;
-  if ((result = asn1_read_value (tmpasn, "", str, &len)) != ASN1_SUCCESS)
+  if ((result = MHD__asn1_read_value (tmpasn, "", str, &len)) != ASN1_SUCCESS)
     {                           /* CHOICE */
-      gnutls_assert ();
-      asn1_delete_structure (&tmpasn);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&tmpasn);
+      return MHD_gtls_asn2err (result);
     }
 
   if (CHOICE == 0)
@@ -323,10 +323,10 @@ _gnutls_x509_oid_data2string (const char *oid,
       str[len] = 0;
 
       if (res)
-        mhd_gtls_str_cpy (res, *res_size, str);
+        MHD_gtls_str_cpy (res, *res_size, str);
       *res_size = len;
 
-      asn1_delete_structure (&tmpasn);
+      MHD__asn1_delete_structure (&tmpasn);
     }
   else
     {                           /* CHOICE */
@@ -345,17 +345,17 @@ _gnutls_x509_oid_data2string (const char *oid,
       if (strcmp (str, "teletexString") == 0)
         teletex = 1;
 
-      mhd_gtls_str_cpy (tmpname, sizeof (tmpname), str);
+      MHD_gtls_str_cpy (tmpname, sizeof (tmpname), str);
 
       len = sizeof (str) - 1;
-      if ((result = asn1_read_value (tmpasn, tmpname, str, &len))
+      if ((result = MHD__asn1_read_value (tmpasn, tmpname, str, &len))
           != ASN1_SUCCESS)
         {
-          asn1_delete_structure (&tmpasn);
-          return mhd_gtls_asn2err (result);
+          MHD__asn1_delete_structure (&tmpasn);
+          return MHD_gtls_asn2err (result);
         }
 
-      asn1_delete_structure (&tmpasn);
+      MHD__asn1_delete_structure (&tmpasn);
 
       if (teletex != 0)
         {
@@ -376,15 +376,15 @@ _gnutls_x509_oid_data2string (const char *oid,
           if (non_printable == 0)
             {
               str[len] = 0;
-              mhd_gtls_str_cpy (res, *res_size, str);
+              MHD_gtls_str_cpy (res, *res_size, str);
               *res_size = len;
             }
           else
             {
-              result = _gnutls_x509_data2hex (str, len, res, res_size);
+              result = MHD__gnutls_x509_data2hex (str, len, res, res_size);
               if (result < 0)
                 {
-                  gnutls_assert ();
+                  MHD_gnutls_assert ();
                   return result;
                 }
             }
@@ -399,7 +399,7 @@ _gnutls_x509_oid_data2string (const char *oid,
  * something like '#01020304'
  */
 int
-_gnutls_x509_data2hex (const opaque * data,
+MHD__gnutls_x509_data2hex (const opaque * data,
                        size_t data_size, opaque * out, size_t * sizeof_out)
 {
   char *res;
@@ -407,11 +407,11 @@ _gnutls_x509_data2hex (const opaque * data,
 
   if (2 * data_size + 1 > MAX_STRING_LEN)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
-  res = mhd_gtls_bin2hex (data, data_size, escaped, sizeof (escaped));
+  res = MHD_gtls_bin2hex (data, data_size, escaped, sizeof (escaped));
 
   if (res)
     {
@@ -433,7 +433,7 @@ _gnutls_x509_data2hex (const opaque * data,
     }
   else
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
@@ -522,7 +522,7 @@ mktime_utc (const struct fake_tm *tm)
  * and year is given. Returns a time_t date.
  */
 time_t
-_gnutls_x509_time2gtime (const char *ttime, int year)
+MHD__gnutls_x509_time2gtime (const char *ttime, int year)
 {
   char xx[3];
   struct fake_tm etime;
@@ -530,7 +530,7 @@ _gnutls_x509_time2gtime (const char *ttime, int year)
 
   if (strlen (ttime) < 8)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return (time_t) - 1;
     }
 
@@ -589,14 +589,14 @@ _gnutls_x509_time2gtime (const char *ttime, int year)
  * (seconds are optional)
  */
 time_t
-_gnutls_x509_utcTime2gtime (const char *ttime)
+MHD__gnutls_x509_utcTime2gtime (const char *ttime)
 {
   char xx[3];
   int year;
 
   if (strlen (ttime) < 10)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return (time_t) - 1;
     }
   xx[2] = 0;
@@ -611,7 +611,7 @@ _gnutls_x509_utcTime2gtime (const char *ttime)
   else
     year += 2000;
 
-  return _gnutls_x509_time2gtime (ttime, year);
+  return MHD__gnutls_x509_time2gtime (ttime, year);
 }
 
 /* returns a time value that contains the given time.
@@ -619,7 +619,7 @@ _gnutls_x509_utcTime2gtime (const char *ttime)
  * YEAR(2)|MONTH(2)|DAY(2)|HOUR(2)|MIN(2)|SEC(2)
  */
 int
-_gnutls_x509_gtime2utcTime (time_t gtime, char *str_time, int str_time_size)
+MHD__gnutls_x509_gtime2utcTime (time_t gtime, char *str_time, int str_time_size)
 {
   size_t ret;
 
@@ -639,7 +639,7 @@ _gnutls_x509_gtime2utcTime (time_t gtime, char *str_time, int str_time_size)
 
   if (!ret)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_SHORT_MEMORY_BUFFER;
     }
 
@@ -652,20 +652,20 @@ _gnutls_x509_gtime2utcTime (time_t gtime, char *str_time, int str_time_size)
  * YEAR(4)|MONTH(2)|DAY(2)|HOUR(2)|MIN(2)|SEC(2)*
  */
 time_t
-_gnutls_x509_generalTime2gtime (const char *ttime)
+MHD__gnutls_x509_generalTime2gtime (const char *ttime)
 {
   char xx[5];
   int year;
 
   if (strlen (ttime) < 12)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return (time_t) - 1;
     }
 
   if (strchr (ttime, 'Z') == 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       /* sorry we don't support it yet
        */
       return (time_t) - 1;
@@ -678,7 +678,7 @@ _gnutls_x509_generalTime2gtime (const char *ttime)
   year = atoi (xx);
   ttime += 4;
 
-  return _gnutls_x509_time2gtime (ttime, year);
+  return MHD__gnutls_x509_time2gtime (ttime, year);
 
 }
 
@@ -687,19 +687,19 @@ _gnutls_x509_generalTime2gtime (const char *ttime)
  */
 #define MAX_TIME 64
 time_t
-_gnutls_x509_get_time (ASN1_TYPE c2, const char *when)
+MHD__gnutls_x509_get_time (ASN1_TYPE c2, const char *when)
 {
   char ttime[MAX_TIME];
   char name[128];
   time_t c_time = (time_t) - 1;
   int len, result;
 
-  mhd_gtls_str_cpy (name, sizeof (name), when);
+  MHD_gtls_str_cpy (name, sizeof (name), when);
 
   len = sizeof (ttime) - 1;
-  if ((result = asn1_read_value (c2, name, ttime, &len)) < 0)
+  if ((result = MHD__asn1_read_value (c2, name, ttime, &len)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return (time_t) (-1);
     }
 
@@ -707,20 +707,20 @@ _gnutls_x509_get_time (ASN1_TYPE c2, const char *when)
   if (strcmp (ttime, "generalTime") == 0)
     {
 
-      mhd_gtls_str_cat (name, sizeof (name), ".generalTime");
+      MHD_gtls_str_cat (name, sizeof (name), ".generalTime");
       len = sizeof (ttime) - 1;
-      result = asn1_read_value (c2, name, ttime, &len);
+      result = MHD__asn1_read_value (c2, name, ttime, &len);
       if (result == ASN1_SUCCESS)
-        c_time = _gnutls_x509_generalTime2gtime (ttime);
+        c_time = MHD__gnutls_x509_generalTime2gtime (ttime);
     }
   else
     {                           /* UTCTIME */
 
-      mhd_gtls_str_cat (name, sizeof (name), ".utcTime");
+      MHD_gtls_str_cat (name, sizeof (name), ".utcTime");
       len = sizeof (ttime) - 1;
-      result = asn1_read_value (c2, name, ttime, &len);
+      result = MHD__asn1_read_value (c2, name, ttime, &len);
       if (result == ASN1_SUCCESS)
-        c_time = _gnutls_x509_utcTime2gtime (ttime);
+        c_time = MHD__gnutls_x509_utcTime2gtime (ttime);
     }
 
   /* We cannot handle dates after 2031 in 32 bit machines.
@@ -729,7 +729,7 @@ _gnutls_x509_get_time (ASN1_TYPE c2, const char *when)
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return (time_t) (-1);
     }
   return c_time;
@@ -739,42 +739,42 @@ _gnutls_x509_get_time (ASN1_TYPE c2, const char *when)
  * be something like "tbsCertList.thisUpdate".
  */
 int
-_gnutls_x509_set_time (ASN1_TYPE c2, const char *where, time_t tim)
+MHD__gnutls_x509_set_time (ASN1_TYPE c2, const char *where, time_t tim)
 {
   char str_time[MAX_TIME];
   char name[128];
   int result, len;
 
-  mhd_gtls_str_cpy (name, sizeof (name), where);
+  MHD_gtls_str_cpy (name, sizeof (name), where);
 
-  if ((result = asn1_write_value (c2, name, "utcTime", 1)) < 0)
+  if ((result = MHD__asn1_write_value (c2, name, "utcTime", 1)) < 0)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  result = _gnutls_x509_gtime2utcTime (tim, str_time, sizeof (str_time));
+  result = MHD__gnutls_x509_gtime2utcTime (tim, str_time, sizeof (str_time));
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
-  mhd_gtls_str_cat (name, sizeof (name), ".utcTime");
+  MHD_gtls_str_cat (name, sizeof (name), ".utcTime");
 
   len = strlen (str_time);
-  result = asn1_write_value (c2, name, str_time, len);
+  result = MHD__asn1_write_value (c2, name, str_time, len);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   return 0;
 }
 
-gnutls_x509_subject_alt_name_t
-_gnutls_x509_san_find_type (char *str_type)
+MHD_gnutls_x509_subject_alt_name_t
+MHD__gnutls_x509_san_find_type (char *str_type)
 {
   if (strcmp (str_type, "dNSName") == 0)
     return GNUTLS_SAN_DNSNAME;
@@ -788,15 +788,15 @@ _gnutls_x509_san_find_type (char *str_type)
     return GNUTLS_SAN_OTHERNAME;
   if (strcmp (str_type, "directoryName") == 0)
     return GNUTLS_SAN_DN;
-  return (gnutls_x509_subject_alt_name_t) - 1;
+  return (MHD_gnutls_x509_subject_alt_name_t) - 1;
 }
 
 /* A generic export function. Will export the given ASN.1 encoded data
  * to PEM or DER raw data.
  */
 int
-_gnutls_x509_export_int (ASN1_TYPE asn1_data,
-                         gnutls_x509_crt_fmt_t format,
+MHD__gnutls_x509_export_int (ASN1_TYPE MHD__asn1_data,
+                         MHD_gnutls_x509_crt_fmt_t format,
                          char *pem_header,
                          unsigned char *output_data,
                          size_t * output_data_size)
@@ -811,7 +811,7 @@ _gnutls_x509_export_int (ASN1_TYPE asn1_data,
 
       len = *output_data_size;
 
-      if ((result = asn1_der_coding (asn1_data, "", output_data, &len,
+      if ((result = MHD__asn1_der_coding (MHD__asn1_data, "", output_data, &len,
                                      NULL)) != ASN1_SUCCESS)
         {
           *output_data_size = len;
@@ -819,8 +819,8 @@ _gnutls_x509_export_int (ASN1_TYPE asn1_data,
             {
               return GNUTLS_E_SHORT_MEMORY_BUFFER;
             }
-          gnutls_assert ();
-          return mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          return MHD_gtls_asn2err (result);
         }
 
       *output_data_size = len;
@@ -829,35 +829,35 @@ _gnutls_x509_export_int (ASN1_TYPE asn1_data,
   else
     {                           /* PEM */
       opaque *out;
-      gnutls_datum_t tmp;
+      MHD_gnutls_datum_t tmp;
 
-      result = _gnutls_x509_der_encode (asn1_data, "", &tmp, 0);
+      result = MHD__gnutls_x509_der_encode (MHD__asn1_data, "", &tmp, 0);
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return result;
         }
 
-      result = _gnutls_fbase64_encode (pem_header, tmp.data, tmp.size, &out);
+      result = MHD__gnutls_fbase64_encode (pem_header, tmp.data, tmp.size, &out);
 
-      _gnutls_free_datum (&tmp);
+      MHD__gnutls_free_datum (&tmp);
 
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return result;
         }
 
       if (result == 0)
         {                       /* oooops */
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_INTERNAL_ERROR;
         }
 
       if ((unsigned) result > *output_data_size)
         {
-          gnutls_assert ();
-          gnutls_free (out);
+          MHD_gnutls_assert ();
+          MHD_gnutls_free (out);
           *output_data_size = result;
           return GNUTLS_E_SHORT_MEMORY_BUFFER;
         }
@@ -872,7 +872,7 @@ _gnutls_x509_export_int (ASN1_TYPE asn1_data,
            */
           *output_data_size = result - 1;
         }
-      gnutls_free (out);
+      MHD_gnutls_free (out);
 
     }
 
@@ -884,7 +884,7 @@ _gnutls_x509_export_int (ASN1_TYPE asn1_data,
  * etc.
  */
 int
-_gnutls_x509_decode_octet_string (const char *string_type,
+MHD__gnutls_x509_decode_octet_string (const char *string_type,
                                   const opaque * der,
                                   size_t der_size,
                                   opaque * output, size_t * output_size)
@@ -894,45 +894,45 @@ _gnutls_x509_decode_octet_string (const char *string_type,
   char strname[64];
 
   if (string_type == NULL)
-    mhd_gtls_str_cpy (strname, sizeof (strname), "PKIX1.pkcs-7-Data");
+    MHD_gtls_str_cpy (strname, sizeof (strname), "PKIX1.pkcs-7-Data");
   else
     {
-      mhd_gtls_str_cpy (strname, sizeof (strname), "PKIX1.");
-      mhd_gtls_str_cat (strname, sizeof (strname), string_type);
+      MHD_gtls_str_cpy (strname, sizeof (strname), "PKIX1.");
+      MHD_gtls_str_cat (strname, sizeof (strname), string_type);
     }
 
   if ((result =
-       asn1_create_element (_gnutls_get_pkix (), strname,
+       MHD__asn1_create_element (MHD__gnutls_get_pkix (), strname,
                             &c2)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  result = asn1_der_decoding (&c2, der, der_size, NULL);
+  result = MHD__asn1_der_decoding (&c2, der, der_size, NULL);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   tmp_output_size = *output_size;
-  result = asn1_read_value (c2, "", output, &tmp_output_size);
+  result = MHD__asn1_read_value (c2, "", output, &tmp_output_size);
   *output_size = tmp_output_size;
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   return 0;
 
 cleanup:if (c2)
-    asn1_delete_structure (&c2);
+    MHD__asn1_delete_structure (&c2);
 
   return result;
 }
@@ -944,37 +944,37 @@ cleanup:if (c2)
  * flags == 2 the value is a BIT STRING
  */
 int
-_gnutls_x509_read_value (ASN1_TYPE c,
-                         const char *root, gnutls_datum_t * ret, int flags)
+MHD__gnutls_x509_read_value (ASN1_TYPE c,
+                         const char *root, MHD_gnutls_datum_t * ret, int flags)
 {
   int len = 0, result;
   size_t slen;
   opaque *tmp = NULL;
 
-  result = asn1_read_value (c, root, NULL, &len);
+  result = MHD__asn1_read_value (c, root, NULL, &len);
   if (result != ASN1_MEM_ERROR)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       return result;
     }
 
   if (flags == 2)
     len /= 8;
 
-  tmp = gnutls_malloc (len);
+  tmp = MHD_gnutls_malloc (len);
   if (tmp == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_MEMORY_ERROR;
       goto cleanup;
     }
 
-  result = asn1_read_value (c, root, tmp, &len);
+  result = MHD__asn1_read_value (c, root, tmp, &len);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -987,10 +987,10 @@ _gnutls_x509_read_value (ASN1_TYPE c,
   if (flags == 1)
     {
       slen = len;
-      result = _gnutls_x509_decode_octet_string (NULL, tmp, slen, tmp, &slen);
+      result = MHD__gnutls_x509_decode_octet_string (NULL, tmp, slen, tmp, &slen);
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           goto cleanup;
         }
       len = slen;
@@ -1001,7 +1001,7 @@ _gnutls_x509_read_value (ASN1_TYPE c,
 
   return 0;
 
-cleanup:gnutls_free (tmp);
+cleanup:MHD_gnutls_free (tmp);
   return result;
 
 }
@@ -1011,8 +1011,8 @@ cleanup:gnutls_free (tmp);
  * an OCTET STRING.
  */
 int
-_gnutls_x509_der_encode (ASN1_TYPE src,
-                         const char *src_name, gnutls_datum_t * res, int str)
+MHD__gnutls_x509_der_encode (ASN1_TYPE src,
+                         const char *src_name, MHD_gnutls_datum_t * res, int str)
 {
   int size, result;
   int asize;
@@ -1020,11 +1020,11 @@ _gnutls_x509_der_encode (ASN1_TYPE src,
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
 
   size = 0;
-  result = asn1_der_coding (src, src_name, NULL, &size, NULL);
+  result = MHD__asn1_der_coding (src, src_name, NULL, &size, NULL);
   if (result != ASN1_MEM_ERROR)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -1035,60 +1035,60 @@ _gnutls_x509_der_encode (ASN1_TYPE src,
     size += 16;                 /* for later to include the octet tags */
   asize = size;
 
-  data = gnutls_malloc (size);
+  data = MHD_gnutls_malloc (size);
   if (data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_MEMORY_ERROR;
       goto cleanup;
     }
 
-  result = asn1_der_coding (src, src_name, data, &size, NULL);
+  result = MHD__asn1_der_coding (src, src_name, data, &size, NULL);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   if (str)
     {
       if ((result =
-           asn1_create_element (_gnutls_get_pkix (), "PKIX1.pkcs-7-Data",
+           MHD__asn1_create_element (MHD__gnutls_get_pkix (), "PKIX1.pkcs-7-Data",
                                 &c2)) != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          result = mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          result = MHD_gtls_asn2err (result);
           goto cleanup;
         }
 
-      result = asn1_write_value (c2, "", data, size);
+      result = MHD__asn1_write_value (c2, "", data, size);
       if (result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          result = mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          result = MHD_gtls_asn2err (result);
           goto cleanup;
         }
 
-      result = asn1_der_coding (c2, "", data, &asize, NULL);
+      result = MHD__asn1_der_coding (c2, "", data, &asize, NULL);
       if (result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          result = mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          result = MHD_gtls_asn2err (result);
           goto cleanup;
         }
 
       size = asize;
 
-      asn1_delete_structure (&c2);
+      MHD__asn1_delete_structure (&c2);
     }
 
   res->data = data;
   res->size = size;
   return 0;
 
-cleanup:gnutls_free (data);
-  asn1_delete_structure (&c2);
+cleanup:MHD_gnutls_free (data);
+  MHD__asn1_delete_structure (&c2);
   return result;
 
 }
@@ -1099,32 +1099,32 @@ cleanup:gnutls_free (data);
  * an OCTET STRING.
  */
 int
-_gnutls_x509_der_encode_and_copy (ASN1_TYPE src,
+MHD__gnutls_x509_der_encode_and_copy (ASN1_TYPE src,
                                   const char *src_name,
                                   ASN1_TYPE dest,
                                   const char *dest_name, int str)
 {
   int result;
-  gnutls_datum_t encoded;
+  MHD_gnutls_datum_t encoded;
 
-  result = _gnutls_x509_der_encode (src, src_name, &encoded, str);
+  result = MHD__gnutls_x509_der_encode (src, src_name, &encoded, str);
 
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
   /* Write the data.
    */
-  result = asn1_write_value (dest, dest_name, encoded.data, encoded.size);
+  result = MHD__asn1_write_value (dest, dest_name, encoded.data, encoded.size);
 
-  _gnutls_free_datum (&encoded);
+  MHD__gnutls_free_datum (&encoded);
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   return 0;
@@ -1134,21 +1134,21 @@ _gnutls_x509_der_encode_and_copy (ASN1_TYPE src,
  * zero it encodes it as OCTET STRING.
  */
 int
-_gnutls_x509_write_value (ASN1_TYPE c,
+MHD__gnutls_x509_write_value (ASN1_TYPE c,
                           const char *root,
-                          const gnutls_datum_t * data, int str)
+                          const MHD_gnutls_datum_t * data, int str)
 {
   int result;
   int asize;
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
-  gnutls_datum_t val;
+  MHD_gnutls_datum_t val;
 
   asize = data->size + 16;
 
-  val.data = gnutls_malloc (asize);
+  val.data = MHD_gnutls_malloc (asize);
   if (val.data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_MEMORY_ERROR;
       goto cleanup;
     }
@@ -1158,26 +1158,26 @@ _gnutls_x509_write_value (ASN1_TYPE c,
       /* Convert it to OCTET STRING
        */
       if ((result =
-           asn1_create_element (_gnutls_get_pkix (), "PKIX1.pkcs-7-Data",
+           MHD__asn1_create_element (MHD__gnutls_get_pkix (), "PKIX1.pkcs-7-Data",
                                 &c2)) != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          result = mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          result = MHD_gtls_asn2err (result);
           goto cleanup;
         }
 
-      result = asn1_write_value (c2, "", data->data, data->size);
+      result = MHD__asn1_write_value (c2, "", data->data, data->size);
       if (result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          result = mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          result = MHD_gtls_asn2err (result);
           goto cleanup;
         }
 
-      result = _gnutls_x509_der_encode (c2, "", &val, 0);
+      result = MHD__gnutls_x509_der_encode (c2, "", &val, 0);
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           goto cleanup;
         }
 
@@ -1190,21 +1190,21 @@ _gnutls_x509_write_value (ASN1_TYPE c,
 
   /* Write the data.
    */
-  result = asn1_write_value (c, root, val.data, val.size);
+  result = MHD__asn1_write_value (c, root, val.data, val.size);
 
   if (val.data != data->data)
-    _gnutls_free_datum (&val);
+    MHD__gnutls_free_datum (&val);
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   return 0;
 
 cleanup:if (val.data != data->data)
-    _gnutls_free_datum (&val);
+    MHD__gnutls_free_datum (&val);
   return result;
 }
 
@@ -1213,69 +1213,69 @@ cleanup:if (val.data != data->data)
  *
  */
 int
-_gnutls_x509_encode_and_copy_PKI_params (ASN1_TYPE dst,
+MHD__gnutls_x509_encode_and_copy_PKI_params (ASN1_TYPE dst,
                                          const char *dst_name,
                                          enum MHD_GNUTLS_PublicKeyAlgorithm
                                          pk_algorithm,
                                          mpi_t * params, int params_size)
 {
   const char *pk;
-  gnutls_datum_t der = { NULL,
+  MHD_gnutls_datum_t der = { NULL,
     0
   };
   int result;
   char name[128];
 
-  pk = mhd_gtls_x509_pk_to_oid (pk_algorithm);
+  pk = MHD_gtls_x509_pk_to_oid (pk_algorithm);
   if (pk == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
     }
 
   /* write the OID
    */
-  mhd_gtls_str_cpy (name, sizeof (name), dst_name);
-  mhd_gtls_str_cat (name, sizeof (name), ".algorithm.algorithm");
-  result = asn1_write_value (dst, name, pk, 1);
+  MHD_gtls_str_cpy (name, sizeof (name), dst_name);
+  MHD_gtls_str_cat (name, sizeof (name), ".algorithm.algorithm");
+  result = MHD__asn1_write_value (dst, name, pk, 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   if (pk_algorithm == MHD_GNUTLS_PK_RSA)
     {
       /* disable parameters, which are not used in RSA.
        */
-      mhd_gtls_str_cpy (name, sizeof (name), dst_name);
-      mhd_gtls_str_cat (name, sizeof (name), ".algorithm.parameters");
-      result = asn1_write_value (dst, name, NULL, 0);
+      MHD_gtls_str_cpy (name, sizeof (name), dst_name);
+      MHD_gtls_str_cat (name, sizeof (name), ".algorithm.parameters");
+      result = MHD__asn1_write_value (dst, name, NULL, 0);
       if (result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          return mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          return MHD_gtls_asn2err (result);
         }
 
-      result = _gnutls_x509_write_rsa_params (params, params_size, &der);
+      result = MHD__gnutls_x509_write_rsa_params (params, params_size, &der);
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return result;
         }
 
       /* Write the DER parameters. (in bits)
        */
-      mhd_gtls_str_cpy (name, sizeof (name), dst_name);
-      mhd_gtls_str_cat (name, sizeof (name), ".subjectPublicKey");
-      result = asn1_write_value (dst, name, der.data, der.size * 8);
+      MHD_gtls_str_cpy (name, sizeof (name), dst_name);
+      MHD_gtls_str_cat (name, sizeof (name), ".subjectPublicKey");
+      result = MHD__asn1_write_value (dst, name, der.data, der.size * 8);
 
-      _gnutls_free_datum (&der);
+      MHD__gnutls_free_datum (&der);
 
       if (result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          return mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          return MHD_gtls_asn2err (result);
         }
     }
   else
@@ -1288,7 +1288,7 @@ _gnutls_x509_encode_and_copy_PKI_params (ASN1_TYPE dst,
  * ASN.1 structure. src_name should be something like "tbsCertificate.subjectPublicKeyInfo".
  */
 int
-_gnutls_x509_get_pk_algorithm (ASN1_TYPE src,
+MHD__gnutls_x509_get_pk_algorithm (ASN1_TYPE src,
                                const char *src_name, unsigned int *bits)
 {
   int result;
@@ -1299,64 +1299,64 @@ _gnutls_x509_get_pk_algorithm (ASN1_TYPE src,
   mpi_t params[MAX_PUBLIC_PARAMS_SIZE];
   char name[128];
 
-  mhd_gtls_str_cpy (name, sizeof (name), src_name);
-  mhd_gtls_str_cat (name, sizeof (name), ".algorithm.algorithm");
+  MHD_gtls_str_cpy (name, sizeof (name), src_name);
+  MHD_gtls_str_cat (name, sizeof (name), ".algorithm.algorithm");
 
   len = sizeof (oid);
-  result = asn1_read_value (src, name, oid, &len);
+  result = MHD__asn1_read_value (src, name, oid, &len);
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  algo = mhd_gtls_x509_oid2pk_algorithm (oid);
+  algo = MHD_gtls_x509_oid2pk_algorithm (oid);
 
   if (bits == NULL)
     {
-      gnutls_free (str);
+      MHD_gnutls_free (str);
       return algo;
     }
 
   /* Now read the parameters' bits
    */
-  mhd_gtls_str_cpy (name, sizeof (name), src_name);
-  mhd_gtls_str_cat (name, sizeof (name), ".subjectPublicKey");
+  MHD_gtls_str_cpy (name, sizeof (name), src_name);
+  MHD_gtls_str_cat (name, sizeof (name), ".subjectPublicKey");
 
   len = 0;
-  result = asn1_read_value (src, name, NULL, &len);
+  result = MHD__asn1_read_value (src, name, NULL, &len);
   if (result != ASN1_MEM_ERROR)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   if (len % 8 != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_CERTIFICATE_ERROR;
     }
 
   len /= 8;
 
-  str = gnutls_malloc (len);
+  str = MHD_gnutls_malloc (len);
   if (str == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
-  mhd_gtls_str_cpy (name, sizeof (name), src_name);
-  mhd_gtls_str_cat (name, sizeof (name), ".subjectPublicKey");
+  MHD_gtls_str_cpy (name, sizeof (name), src_name);
+  MHD_gtls_str_cat (name, sizeof (name), ".subjectPublicKey");
 
-  result = asn1_read_value (src, name, str, &len);
+  result = MHD__asn1_read_value (src, name, str, &len);
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      gnutls_free (str);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD_gnutls_free (str);
+      return MHD_gtls_asn2err (result);
     }
 
   len /= 8;
@@ -1365,24 +1365,24 @@ _gnutls_x509_get_pk_algorithm (ASN1_TYPE src,
     {
     case MHD_GNUTLS_PK_RSA:
       {
-        if ((result = _gnutls_x509_read_rsa_params (str, len, params)) < 0)
+        if ((result = MHD__gnutls_x509_read_rsa_params (str, len, params)) < 0)
           {
-            gnutls_assert ();
+            MHD_gnutls_assert ();
             return result;
           }
 
-        bits[0] = _gnutls_mpi_get_nbits (params[0]);
+        bits[0] = MHD__gnutls_mpi_get_nbits (params[0]);
 
-        mhd_gtls_mpi_release (&params[0]);
-        mhd_gtls_mpi_release (&params[1]);
+        MHD_gtls_mpi_release (&params[0]);
+        MHD_gtls_mpi_release (&params[1]);
       }
       break;
     default:
-      _gnutls_x509_log
-        ("_gnutls_x509_get_pk_algorithm: unhandled algorithm %d\n", algo);
+      MHD__gnutls_x509_log
+        ("MHD__gnutls_x509_get_pk_algorithm: unhandled algorithm %d\n", algo);
     }
 
-  gnutls_free (str);
+  MHD_gnutls_free (str);
   return algo;
 }
 
@@ -1390,42 +1390,42 @@ _gnutls_x509_get_pk_algorithm (ASN1_TYPE src,
  * returns them into signed_data.
  */
 int
-_gnutls_x509_get_signed_data (ASN1_TYPE src,
+MHD__gnutls_x509_get_signed_data (ASN1_TYPE src,
                               const char *src_name,
-                              gnutls_datum_t * signed_data)
+                              MHD_gnutls_datum_t * signed_data)
 {
-  gnutls_datum_t der;
+  MHD_gnutls_datum_t der;
   int start, end, result;
 
-  result = _gnutls_x509_der_encode (src, "", &der, 0);
+  result = MHD__gnutls_x509_der_encode (src, "", &der, 0);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
   /* Get the signed data
    */
-  result = asn1_der_decoding_startEnd (src, der.data, der.size, src_name,
+  result = MHD__asn1_der_decoding_startEnd (src, der.data, der.size, src_name,
                                        &start, &end);
   if (result != ASN1_SUCCESS)
     {
-      result = mhd_gtls_asn2err (result);
-      gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  result = _gnutls_set_datum (signed_data, &der.data[start], end - start + 1);
+  result = MHD__gnutls_set_datum (signed_data, &der.data[start], end - start + 1);
 
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
   result = 0;
 
-cleanup:_gnutls_free_datum (&der);
+cleanup:MHD__gnutls_free_datum (&der);
 
   return result;
 }
@@ -1434,8 +1434,8 @@ cleanup:_gnutls_free_datum (&der);
  * returns them into signed_data.
  */
 int
-_gnutls_x509_get_signature (ASN1_TYPE src,
-                            const char *src_name, gnutls_datum_t * signature)
+MHD__gnutls_x509_get_signature (ASN1_TYPE src,
+                            const char *src_name, MHD_gnutls_datum_t * signature)
 {
   int bits, result, len;
 
@@ -1445,28 +1445,28 @@ _gnutls_x509_get_signature (ASN1_TYPE src,
   /* Read the signature
    */
   bits = 0;
-  result = asn1_read_value (src, src_name, NULL, &bits);
+  result = MHD__asn1_read_value (src, src_name, NULL, &bits);
 
   if (result != ASN1_MEM_ERROR)
     {
-      result = mhd_gtls_asn2err (result);
-      gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
   if (bits % 8 != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_CERTIFICATE_ERROR;
       goto cleanup;
     }
 
   len = bits / 8;
 
-  signature->data = gnutls_malloc (len);
+  signature->data = MHD_gnutls_malloc (len);
   if (signature->data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_MEMORY_ERROR;
       return result;
     }
@@ -1474,12 +1474,12 @@ _gnutls_x509_get_signature (ASN1_TYPE src,
   /* read the bit string of the signature
    */
   bits = len;
-  result = asn1_read_value (src, src_name, signature->data, &bits);
+  result = MHD__asn1_read_value (src, src_name, signature->data, &bits);
 
   if (result != ASN1_SUCCESS)
     {
-      result = mhd_gtls_asn2err (result);
-      gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
diff --git a/src/daemon/https/x509/common.h b/src/daemon/https/x509/common.h
index 0e91c96d..4050f36b 100644
--- a/src/daemon/https/x509/common.h
+++ b/src/daemon/https/x509/common.h
@@ -58,70 +58,70 @@
 #define SIG_GOST_R3410_94_OID "1.2.643.2.2.4"
 #define SIG_GOST_R3410_2001_OID "1.2.643.2.2.3"
 
-time_t _gnutls_x509_utcTime2gtime (const char *ttime);
-time_t _gnutls_x509_generalTime2gtime (const char *ttime);
-int _gnutls_x509_set_time (ASN1_TYPE c2, const char *where, time_t tim);
+time_t MHD__gnutls_x509_utcTime2gtime (const char *ttime);
+time_t MHD__gnutls_x509_generalTime2gtime (const char *ttime);
+int MHD__gnutls_x509_set_time (ASN1_TYPE c2, const char *where, time_t tim);
 
-int _gnutls_x509_decode_octet_string (const char *string_type,
+int MHD__gnutls_x509_decode_octet_string (const char *string_type,
                                       const opaque * der, size_t der_size,
                                       opaque * output, size_t * output_size);
-int _gnutls_x509_oid_data2string (const char *OID, void *value,
+int MHD__gnutls_x509_oid_data2string (const char *OID, void *value,
                                   int value_size, char *res,
                                   size_t * res_size);
-int _gnutls_x509_data2hex (const opaque * data, size_t data_size,
+int MHD__gnutls_x509_data2hex (const opaque * data, size_t data_size,
                            opaque * out, size_t * sizeof_out);
 
-const char *_gnutls_x509_oid2ldap_string (const char *OID);
+const char *MHD__gnutls_x509_oid2ldap_string (const char *OID);
 
-int _gnutls_x509_oid_data_choice (const char *OID);
-int _gnutls_x509_oid_data_printable (const char *OID);
+int MHD__gnutls_x509_oid_data_choice (const char *OID);
+int MHD__gnutls_x509_oid_data_printable (const char *OID);
 
-time_t _gnutls_x509_get_time (ASN1_TYPE c2, const char *when);
+time_t MHD__gnutls_x509_get_time (ASN1_TYPE c2, const char *when);
 
-gnutls_x509_subject_alt_name_t _gnutls_x509_san_find_type (char *str_type);
+MHD_gnutls_x509_subject_alt_name_t MHD__gnutls_x509_san_find_type (char *str_type);
 
-int _gnutls_x509_der_encode_and_copy (ASN1_TYPE src, const char *src_name,
+int MHD__gnutls_x509_der_encode_and_copy (ASN1_TYPE src, const char *src_name,
                                       ASN1_TYPE dest, const char *dest_name,
                                       int str);
-int _gnutls_x509_der_encode (ASN1_TYPE src, const char *src_name,
-                             gnutls_datum_t * res, int str);
+int MHD__gnutls_x509_der_encode (ASN1_TYPE src, const char *src_name,
+                             MHD_gnutls_datum_t * res, int str);
 
-int _gnutls_x509_export_int (ASN1_TYPE asn1_data,
-                             gnutls_x509_crt_fmt_t format, char *pem_header,
+int MHD__gnutls_x509_export_int (ASN1_TYPE MHD__asn1_data,
+                             MHD_gnutls_x509_crt_fmt_t format, char *pem_header,
                              unsigned char *output_data,
                              size_t * output_data_size);
 
-int _gnutls_x509_read_value (ASN1_TYPE c, const char *root,
-                             gnutls_datum_t * ret, int str);
-int _gnutls_x509_write_value (ASN1_TYPE c, const char *root,
-                              const gnutls_datum_t * data, int str);
+int MHD__gnutls_x509_read_value (ASN1_TYPE c, const char *root,
+                             MHD_gnutls_datum_t * ret, int str);
+int MHD__gnutls_x509_write_value (ASN1_TYPE c, const char *root,
+                              const MHD_gnutls_datum_t * data, int str);
 
-int _gnutls_x509_encode_and_write_attribute (const char *given_oid,
-                                             ASN1_TYPE asn1_struct,
+int MHD__gnutls_x509_encode_and_write_attribute (const char *given_oid,
+                                             ASN1_TYPE MHD__asn1_struct,
                                              const char *where,
                                              const void *data,
                                              int sizeof_data, int multi);
-int _gnutls_x509_decode_and_read_attribute (ASN1_TYPE asn1_struct,
+int MHD__gnutls_x509_decode_and_read_attribute (ASN1_TYPE MHD__asn1_struct,
                                             const char *where, char *oid,
                                             int oid_size,
-                                            gnutls_datum_t * value, int multi,
+                                            MHD_gnutls_datum_t * value, int multi,
                                             int octet);
 
-int _gnutls_x509_get_pk_algorithm (ASN1_TYPE src, const char *src_name,
+int MHD__gnutls_x509_get_pk_algorithm (ASN1_TYPE src, const char *src_name,
                                    unsigned int *bits);
 
-int _gnutls_x509_encode_and_copy_PKI_params (ASN1_TYPE dst,
+int MHD__gnutls_x509_encode_and_copy_PKI_params (ASN1_TYPE dst,
                                              const char *dst_name,
                                              enum
                                              MHD_GNUTLS_PublicKeyAlgorithm
                                              pk_algorithm, mpi_t * params,
                                              int params_size);
-int _gnutls_asn1_copy_node (ASN1_TYPE * dst, const char *dst_name,
+int MHD__gnutlsMHD__asn1_copy_node (ASN1_TYPE * dst, const char *dst_name,
                             ASN1_TYPE src, const char *src_name);
 
-int _gnutls_x509_get_signed_data (ASN1_TYPE src, const char *src_name,
-                                  gnutls_datum_t * signed_data);
-int _gnutls_x509_get_signature (ASN1_TYPE src, const char *src_name,
-                                gnutls_datum_t * signature);
+int MHD__gnutls_x509_get_signed_data (ASN1_TYPE src, const char *src_name,
+                                  MHD_gnutls_datum_t * signed_data);
+int MHD__gnutls_x509_get_signature (ASN1_TYPE src, const char *src_name,
+                                MHD_gnutls_datum_t * signature);
 
 #endif
diff --git a/src/daemon/https/x509/crl.c b/src/daemon/https/x509/crl.c
index 9ad49c67..17703b91 100644
--- a/src/daemon/https/x509/crl.c
+++ b/src/daemon/https/x509/crl.c
@@ -36,7 +36,7 @@
 #include <dn.h>
 
 /**
-  * gnutls_x509_crl_init - This function initializes a gnutls_x509_crl_t structure
+  * MHD_gnutls_x509_crl_init - This function initializes a MHD_gnutls_x509_crl_t structure
   * @crl: The structure to be initialized
   *
   * This function will initialize a CRL structure. CRL stands for
@@ -49,20 +49,20 @@
   *
   **/
 int
-gnutls_x509_crl_init (gnutls_x509_crl_t * crl)
+MHD_gnutls_x509_crl_init (MHD_gnutls_x509_crl_t * crl)
 {
-  *crl = gnutls_calloc (1, sizeof (gnutls_x509_crl_int));
+  *crl = MHD_gnutls_calloc (1, sizeof (MHD_gnutls_x509_crl_int));
 
   if (*crl)
     {
-      int result = asn1_create_element (_gnutls_get_pkix (),
+      int result = MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                                         "PKIX1.CertificateList",
                                         &(*crl)->crl);
       if (result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          gnutls_free (*crl);
-          return mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          MHD_gnutls_free (*crl);
+          return MHD_gtls_asn2err (result);
         }
       return 0;                 /* success */
     }
@@ -70,32 +70,32 @@ gnutls_x509_crl_init (gnutls_x509_crl_t * crl)
 }
 
 /**
-  * gnutls_x509_crl_deinit - This function deinitializes memory used by a gnutls_x509_crl_t structure
+  * MHD_gnutls_x509_crl_deinit - This function deinitializes memory used by a MHD_gnutls_x509_crl_t structure
   * @crl: The structure to be initialized
   *
   * This function will deinitialize a CRL structure.
   *
   **/
 void
-gnutls_x509_crl_deinit (gnutls_x509_crl_t crl)
+MHD_gnutls_x509_crl_deinit (MHD_gnutls_x509_crl_t crl)
 {
   if (!crl)
     return;
 
   if (crl->crl)
-    asn1_delete_structure (&crl->crl);
+    MHD__asn1_delete_structure (&crl->crl);
 
-  gnutls_free (crl);
+  MHD_gnutls_free (crl);
 }
 
 /**
-  * gnutls_x509_crl_import - This function will import a DER or PEM encoded CRL
+  * MHD_gnutls_x509_crl_import - This function will import a DER or PEM encoded CRL
   * @crl: The structure to store the parsed CRL.
   * @data: The DER or PEM encoded CRL.
   * @format: One of DER or PEM
   *
   * This function will convert the given DER or PEM encoded CRL
-  * to the native gnutls_x509_crl_t format. The output will be stored in 'crl'.
+  * to the native MHD_gnutls_x509_crl_t format. The output will be stored in 'crl'.
   *
   * If the CRL is PEM encoded it should have a header of "X509 CRL".
   *
@@ -103,19 +103,19 @@ gnutls_x509_crl_deinit (gnutls_x509_crl_t crl)
   *
   **/
 int
-gnutls_x509_crl_import (gnutls_x509_crl_t crl,
-                        const gnutls_datum_t * data,
-                        gnutls_x509_crt_fmt_t format)
+MHD_gnutls_x509_crl_import (MHD_gnutls_x509_crl_t crl,
+                        const MHD_gnutls_datum_t * data,
+                        MHD_gnutls_x509_crt_fmt_t format)
 {
   int result = 0, need_free = 0;
-  gnutls_datum_t _data;
+  MHD_gnutls_datum_t _data;
 
   _data.data = data->data;
   _data.size = data->size;
 
   if (crl == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -125,13 +125,13 @@ gnutls_x509_crl_import (gnutls_x509_crl_t crl,
     {
       opaque *out;
 
-      result = _gnutls_fbase64_decode (PEM_CRL, data->data, data->size, &out);
+      result = MHD__gnutls_fbase64_decode (PEM_CRL, data->data, data->size, &out);
 
       if (result <= 0)
         {
           if (result == 0)
             result = GNUTLS_E_INTERNAL_ERROR;
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return result;
         }
 
@@ -142,29 +142,29 @@ gnutls_x509_crl_import (gnutls_x509_crl_t crl,
     }
 
 
-  result = asn1_der_decoding (&crl->crl, _data.data, _data.size, NULL);
+  result = MHD__asn1_der_decoding (&crl->crl, _data.data, _data.size, NULL);
   if (result != ASN1_SUCCESS)
     {
-      result = mhd_gtls_asn2err (result);
-      gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
   if (need_free)
-    _gnutls_free_datum (&_data);
+    MHD__gnutls_free_datum (&_data);
 
   return 0;
 
 cleanup:
   if (need_free)
-    _gnutls_free_datum (&_data);
+    MHD__gnutls_free_datum (&_data);
   return result;
 }
 
 
 /**
-  * gnutls_x509_crl_get_issuer_dn - This function returns the CRL's issuer distinguished name
-  * @crl: should contain a gnutls_x509_crl_t structure
+  * MHD_gnutls_x509_crl_get_issuer_dn - This function returns the CRL's issuer distinguished name
+  * @crl: should contain a MHD_gnutls_x509_crl_t structure
   * @buf: a pointer to a structure to hold the peer's name (may be null)
   * @sizeof_buf: initially holds the size of @buf
   *
@@ -180,23 +180,23 @@ cleanup:
   *
   **/
 int
-gnutls_x509_crl_get_issuer_dn (const gnutls_x509_crl_t crl, char *buf,
+MHD_gnutls_x509_crl_get_issuer_dn (const MHD_gnutls_x509_crl_t crl, char *buf,
                                size_t * sizeof_buf)
 {
   if (crl == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  return _gnutls_x509_parse_dn (crl->crl,
+  return MHD__gnutls_x509_parse_dn (crl->crl,
                                 "tbsCertList.issuer.rdnSequence",
                                 buf, sizeof_buf);
 }
 
 /**
-  * gnutls_x509_crl_get_issuer_dn_by_oid - This function returns the CRL's issuer distinguished name
-  * @crl: should contain a gnutls_x509_crl_t structure
+  * MHD_gnutls_x509_crl_get_issuer_dn_by_oid - This function returns the CRL's issuer distinguished name
+  * @crl: should contain a MHD_gnutls_x509_crl_t structure
   * @oid: holds an Object Identified in null terminated string
   * @indx: In case multiple same OIDs exist in the RDN, this specifies which to send. Use zero to get the first one.
   * @raw_flag: If non zero returns the raw DER data of the DN part.
@@ -210,7 +210,7 @@ gnutls_x509_crl_get_issuer_dn (const gnutls_x509_crl_t crl, char *buf,
   * Some helper macros with popular OIDs can be found in gnutls/x509.h
   * If raw flag is zero, this function will only return known OIDs as text. Other OIDs
   * will be DER encoded, as described in RFC2253 -- in hex format with a '\#' prefix.
-  * You can check about known OIDs using gnutls_x509_dn_oid_known().
+  * You can check about known OIDs using MHD_gnutls_x509_dn_oid_known().
   *
   * If buf is null then only the size will be filled.
   *
@@ -220,25 +220,25 @@ gnutls_x509_crl_get_issuer_dn (const gnutls_x509_crl_t crl, char *buf,
   *
   **/
 int
-gnutls_x509_crl_get_issuer_dn_by_oid (gnutls_x509_crl_t crl,
+MHD_gnutls_x509_crl_get_issuer_dn_by_oid (MHD_gnutls_x509_crl_t crl,
                                       const char *oid, int indx,
                                       unsigned int raw_flag, void *buf,
                                       size_t * sizeof_buf)
 {
   if (crl == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  return _gnutls_x509_parse_dn_oid (crl->crl,
+  return MHD__gnutls_x509_parse_dn_oid (crl->crl,
                                     "tbsCertList.issuer.rdnSequence",
                                     oid, indx, raw_flag, buf, sizeof_buf);
 }
 
 /**
-  * gnutls_x509_crl_get_dn_oid - This function returns the Certificate request issuer's distinguished name OIDs
-  * @crl: should contain a gnutls_x509_crl_t structure
+  * MHD_gnutls_x509_crl_get_dn_oid - This function returns the Certificate request issuer's distinguished name OIDs
+  * @crl: should contain a MHD_gnutls_x509_crl_t structure
   * @indx: Specifies which DN OID to send. Use zero to get the first one.
   * @oid: a pointer to a structure to hold the name (may be null)
   * @sizeof_oid: initially holds the size of 'oid'
@@ -254,40 +254,40 @@ gnutls_x509_crl_get_issuer_dn_by_oid (gnutls_x509_crl_t crl,
   *
   **/
 int
-gnutls_x509_crl_get_dn_oid (gnutls_x509_crl_t crl,
+MHD_gnutls_x509_crl_get_dn_oid (MHD_gnutls_x509_crl_t crl,
                             int indx, void *oid, size_t * sizeof_oid)
 {
   if (crl == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  return _gnutls_x509_get_dn_oid (crl->crl,
+  return MHD__gnutls_x509_get_dn_oid (crl->crl,
                                   "tbsCertList.issuer.rdnSequence", indx,
                                   oid, sizeof_oid);
 }
 
 
 /**
-  * gnutls_x509_crl_get_signature_algorithm - This function returns the CRL's signature algorithm
-  * @crl: should contain a gnutls_x509_crl_t structure
+  * MHD_gnutls_x509_crl_get_signature_algorithm - This function returns the CRL's signature algorithm
+  * @crl: should contain a MHD_gnutls_x509_crl_t structure
   *
-  * This function will return a value of the gnutls_sign_algorithm_t enumeration that
+  * This function will return a value of the MHD_gnutls_sign_algorithm_t enumeration that
   * is the signature algorithm.
   *
   * Returns a negative value on error.
   *
   **/
 int
-gnutls_x509_crl_get_signature_algorithm (gnutls_x509_crl_t crl)
+MHD_gnutls_x509_crl_get_signature_algorithm (MHD_gnutls_x509_crl_t crl)
 {
   int result;
-  gnutls_datum_t sa;
+  MHD_gnutls_datum_t sa;
 
   if (crl == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -296,25 +296,25 @@ gnutls_x509_crl_get_signature_algorithm (gnutls_x509_crl_t crl)
    */
 
   result =
-    _gnutls_x509_read_value (crl->crl, "signatureAlgorithm.algorithm",
+    MHD__gnutls_x509_read_value (crl->crl, "signatureAlgorithm.algorithm",
                              &sa, 0);
 
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
-  result = mhd_gtls_x509_oid2sign_algorithm ((const char *) sa.data);
+  result = MHD_gtls_x509_oid2sign_algorithm ((const char *) sa.data);
 
-  _gnutls_free_datum (&sa);
+  MHD__gnutls_free_datum (&sa);
 
   return result;
 }
 
 /**
- * gnutls_x509_crl_get_signature - Returns the CRL's signature
- * @crl: should contain a gnutls_x509_crl_t structure
+ * MHD_gnutls_x509_crl_get_signature - Returns the CRL's signature
+ * @crl: should contain a MHD_gnutls_x509_crl_t structure
  * @sig: a pointer where the signature part will be copied (may be null).
  * @sizeof_sig: initially holds the size of @sig
  *
@@ -323,7 +323,7 @@ gnutls_x509_crl_get_signature_algorithm (gnutls_x509_crl_t crl)
  * Returns 0 on success, and a negative value on error.
  **/
 int
-gnutls_x509_crl_get_signature (gnutls_x509_crl_t crl,
+MHD_gnutls_x509_crl_get_signature (MHD_gnutls_x509_crl_t crl,
                                char *sig, size_t * sizeof_sig)
 {
   int result;
@@ -331,21 +331,21 @@ gnutls_x509_crl_get_signature (gnutls_x509_crl_t crl,
 
   if (crl == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   bits = 0;
-  result = asn1_read_value (crl->crl, "signature", NULL, &bits);
+  result = MHD__asn1_read_value (crl->crl, "signature", NULL, &bits);
   if (result != ASN1_MEM_ERROR)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   if (bits % 8 != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_CERTIFICATE_ERROR;
     }
 
@@ -357,19 +357,19 @@ gnutls_x509_crl_get_signature (gnutls_x509_crl_t crl,
       return GNUTLS_E_SHORT_MEMORY_BUFFER;
     }
 
-  result = asn1_read_value (crl->crl, "signature", sig, &len);
+  result = MHD__asn1_read_value (crl->crl, "signature", sig, &len);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   return 0;
 }
 
 /**
-  * gnutls_x509_crl_get_version - This function returns the CRL's version number
-  * @crl: should contain a gnutls_x509_crl_t structure
+  * MHD_gnutls_x509_crl_get_version - This function returns the CRL's version number
+  * @crl: should contain a MHD_gnutls_x509_crl_t structure
   *
   * This function will return the version of the specified CRL.
   *
@@ -377,32 +377,32 @@ gnutls_x509_crl_get_signature (gnutls_x509_crl_t crl,
   *
   **/
 int
-gnutls_x509_crl_get_version (gnutls_x509_crl_t crl)
+MHD_gnutls_x509_crl_get_version (MHD_gnutls_x509_crl_t crl)
 {
   opaque version[5];
   int len, result;
 
   if (crl == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   len = sizeof (version);
   if ((result =
-       asn1_read_value (crl->crl, "tbsCertList.version", version,
+       MHD__asn1_read_value (crl->crl, "tbsCertList.version", version,
                         &len)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   return (int) version[0] + 1;
 }
 
 /**
-  * gnutls_x509_crl_get_this_update - This function returns the CRL's thisUpdate time
-  * @crl: should contain a gnutls_x509_crl_t structure
+  * MHD_gnutls_x509_crl_get_this_update - This function returns the CRL's thisUpdate time
+  * @crl: should contain a MHD_gnutls_x509_crl_t structure
   *
   * This function will return the time this CRL was issued.
   *
@@ -410,20 +410,20 @@ gnutls_x509_crl_get_version (gnutls_x509_crl_t crl)
   *
   **/
 time_t
-gnutls_x509_crl_get_this_update (gnutls_x509_crl_t crl)
+MHD_gnutls_x509_crl_get_this_update (MHD_gnutls_x509_crl_t crl)
 {
   if (crl == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return (time_t) - 1;
     }
 
-  return _gnutls_x509_get_time (crl->crl, "tbsCertList.thisUpdate");
+  return MHD__gnutls_x509_get_time (crl->crl, "tbsCertList.thisUpdate");
 }
 
 /**
-  * gnutls_x509_crl_get_next_update - This function returns the CRL's nextUpdate time
-  * @crl: should contain a gnutls_x509_crl_t structure
+  * MHD_gnutls_x509_crl_get_next_update - This function returns the CRL's nextUpdate time
+  * @crl: should contain a MHD_gnutls_x509_crl_t structure
   *
   * This function will return the time the next CRL will be issued.
   * This field is optional in a CRL so it might be normal to get
@@ -433,20 +433,20 @@ gnutls_x509_crl_get_this_update (gnutls_x509_crl_t crl)
   *
   **/
 time_t
-gnutls_x509_crl_get_next_update (gnutls_x509_crl_t crl)
+MHD_gnutls_x509_crl_get_next_update (MHD_gnutls_x509_crl_t crl)
 {
   if (crl == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return (time_t) - 1;
     }
 
-  return _gnutls_x509_get_time (crl->crl, "tbsCertList.nextUpdate");
+  return MHD__gnutls_x509_get_time (crl->crl, "tbsCertList.nextUpdate");
 }
 
 /**
-  * gnutls_x509_crl_get_crt_count - This function returns the number of revoked certificates in a CRL
-  * @crl: should contain a gnutls_x509_crl_t structure
+  * MHD_gnutls_x509_crl_get_crt_count - This function returns the number of revoked certificates in a CRL
+  * @crl: should contain a MHD_gnutls_x509_crl_t structure
   *
   * This function will return the number of revoked certificates in the
   * given CRL.
@@ -455,24 +455,24 @@ gnutls_x509_crl_get_next_update (gnutls_x509_crl_t crl)
   *
   **/
 int
-gnutls_x509_crl_get_crt_count (gnutls_x509_crl_t crl)
+MHD_gnutls_x509_crl_get_crt_count (MHD_gnutls_x509_crl_t crl)
 {
 
   int count, result;
 
   if (crl == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   result =
-    asn1_number_of_elements (crl->crl,
+    MHD__asn1_number_of_elements (crl->crl,
                              "tbsCertList.revokedCertificates", &count);
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return 0;                 /* no certificates */
     }
 
@@ -480,8 +480,8 @@ gnutls_x509_crl_get_crt_count (gnutls_x509_crl_t crl)
 }
 
 /**
-  * gnutls_x509_crl_get_crt_serial - This function returns the serial number of a revoked certificate
-  * @crl: should contain a gnutls_x509_crl_t structure
+  * MHD_gnutls_x509_crl_get_crt_serial - This function returns the serial number of a revoked certificate
+  * @crl: should contain a MHD_gnutls_x509_crl_t structure
   * @indx: the index of the certificate to extract (starting from 0)
   * @serial: where the serial number will be copied
   * @serial_size: initially holds the size of serial
@@ -494,7 +494,7 @@ gnutls_x509_crl_get_crt_count (gnutls_x509_crl_t crl)
   *
   **/
 int
-gnutls_x509_crl_get_crt_serial (gnutls_x509_crl_t crl, int indx,
+MHD_gnutls_x509_crl_get_crt_serial (MHD_gnutls_x509_crl_t crl, int indx,
                                 unsigned char *serial,
                                 size_t * serial_size, time_t * t)
 {
@@ -505,7 +505,7 @@ gnutls_x509_crl_get_crt_serial (gnutls_x509_crl_t crl, int indx,
 
   if (crl == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -515,28 +515,28 @@ gnutls_x509_crl_get_crt_serial (gnutls_x509_crl_t crl, int indx,
             "tbsCertList.revokedCertificates.?%u.revocationDate", indx + 1);
 
   _serial_size = *serial_size;
-  result = asn1_read_value (crl->crl, serial_name, serial, &_serial_size);
+  result = MHD__asn1_read_value (crl->crl, serial_name, serial, &_serial_size);
 
   *serial_size = _serial_size;
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       if (result == ASN1_ELEMENT_NOT_FOUND)
         return GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE;
-      return mhd_gtls_asn2err (result);
+      return MHD_gtls_asn2err (result);
     }
 
   if (t)
     {
-      *t = _gnutls_x509_get_time (crl->crl, date_name);
+      *t = MHD__gnutls_x509_get_time (crl->crl, date_name);
     }
 
   return 0;
 }
 
 /*-
-  * _gnutls_x509_crl_get_raw_issuer_dn - This function returns the issuer's DN DER encoded
-  * @crl: should contain a gnutls_x509_crl_t structure
+  * MHD__gnutls_x509_crl_get_raw_issuer_dn - This function returns the issuer's DN DER encoded
+  * @crl: should contain a MHD_gnutls_x509_crl_t structure
   * @dn: will hold the starting point of the DN
   *
   * This function will return a pointer to the DER encoded DN structure and
@@ -546,75 +546,75 @@ gnutls_x509_crl_get_crt_serial (gnutls_x509_crl_t crl, int indx,
   *
   -*/
 int
-_gnutls_x509_crl_get_raw_issuer_dn (gnutls_x509_crl_t crl,
-                                    gnutls_datum_t * dn)
+MHD__gnutls_x509_crl_get_raw_issuer_dn (MHD_gnutls_x509_crl_t crl,
+                                    MHD_gnutls_datum_t * dn)
 {
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
   int result, len1;
   int start1, end1;
-  gnutls_datum_t crl_signed_data;
+  MHD_gnutls_datum_t crl_signed_data;
 
   if (crl == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   /* get the issuer of 'crl'
    */
   if ((result =
-       asn1_create_element (_gnutls_get_pkix (), "PKIX1.TBSCertList",
+       MHD__asn1_create_element (MHD__gnutls_get_pkix (), "PKIX1.TBSCertList",
                             &c2)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   result =
-    _gnutls_x509_get_signed_data (crl->crl, "tbsCertList", &crl_signed_data);
+    MHD__gnutls_x509_get_signed_data (crl->crl, "tbsCertList", &crl_signed_data);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
   result =
-    asn1_der_decoding (&c2, crl_signed_data.data, crl_signed_data.size, NULL);
+    MHD__asn1_der_decoding (&c2, crl_signed_data.data, crl_signed_data.size, NULL);
   if (result != ASN1_SUCCESS)
     {
       /* couldn't decode DER */
-      gnutls_assert ();
-      asn1_delete_structure (&c2);
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&c2);
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   result =
-    asn1_der_decoding_startEnd (c2, crl_signed_data.data,
+    MHD__asn1_der_decoding_startEnd (c2, crl_signed_data.data,
                                 crl_signed_data.size, "issuer",
                                 &start1, &end1);
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   len1 = end1 - start1 + 1;
 
-  _gnutls_set_datum (dn, &crl_signed_data.data[start1], len1);
+  MHD__gnutls_set_datum (dn, &crl_signed_data.data[start1], len1);
 
   result = 0;
 
 cleanup:
-  asn1_delete_structure (&c2);
-  _gnutls_free_datum (&crl_signed_data);
+  MHD__asn1_delete_structure (&c2);
+  MHD__gnutls_free_datum (&crl_signed_data);
   return result;
 }
 
 /**
-  * gnutls_x509_crl_export - This function will export the CRL
+  * MHD_gnutls_x509_crl_export - This function will export the CRL
   * @crl: Holds the revocation list
   * @format: the format of output params. One of PEM or DER.
   * @output_data: will contain a private key PEM or DER encoded
@@ -632,22 +632,22 @@ cleanup:
   *
   **/
 int
-gnutls_x509_crl_export (gnutls_x509_crl_t crl,
-                        gnutls_x509_crt_fmt_t format, void *output_data,
+MHD_gnutls_x509_crl_export (MHD_gnutls_x509_crl_t crl,
+                        MHD_gnutls_x509_crt_fmt_t format, void *output_data,
                         size_t * output_data_size)
 {
   if (crl == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  return _gnutls_x509_export_int (crl->crl, format, PEM_CRL,
+  return MHD__gnutls_x509_export_int (crl->crl, format, PEM_CRL,
                                   output_data, output_data_size);
 }
 
 /*-
-  * _gnutls_x509_crl_cpy - This function copies a gnutls_x509_crl_t structure
+  * MHD__gnutls_x509_crl_cpy - This function copies a MHD_gnutls_x509_crl_t structure
   * @dest: The structure where to copy
   * @src: The structure to be copied
   *
@@ -657,44 +657,44 @@ gnutls_x509_crl_export (gnutls_x509_crl_t crl,
   *
   -*/
 int
-_gnutls_x509_crl_cpy (gnutls_x509_crl_t dest, gnutls_x509_crl_t src)
+MHD__gnutls_x509_crl_cpy (MHD_gnutls_x509_crl_t dest, MHD_gnutls_x509_crl_t src)
 {
   int ret;
   size_t der_size;
   opaque *der;
-  gnutls_datum_t tmp;
+  MHD_gnutls_datum_t tmp;
 
-  ret = gnutls_x509_crl_export (src, GNUTLS_X509_FMT_DER, NULL, &der_size);
+  ret = MHD_gnutls_x509_crl_export (src, GNUTLS_X509_FMT_DER, NULL, &der_size);
   if (ret != GNUTLS_E_SHORT_MEMORY_BUFFER)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  der = gnutls_alloca (der_size);
+  der = MHD_gnutls_alloca (der_size);
   if (der == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
-  ret = gnutls_x509_crl_export (src, GNUTLS_X509_FMT_DER, der, &der_size);
+  ret = MHD_gnutls_x509_crl_export (src, GNUTLS_X509_FMT_DER, der, &der_size);
   if (ret < 0)
     {
-      gnutls_assert ();
-      gnutls_afree (der);
+      MHD_gnutls_assert ();
+      MHD_gnutls_afree (der);
       return ret;
     }
 
   tmp.data = der;
   tmp.size = der_size;
-  ret = gnutls_x509_crl_import (dest, &tmp, GNUTLS_X509_FMT_DER);
+  ret = MHD_gnutls_x509_crl_import (dest, &tmp, GNUTLS_X509_FMT_DER);
 
-  gnutls_afree (der);
+  MHD_gnutls_afree (der);
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
diff --git a/src/daemon/https/x509/crq.c b/src/daemon/https/x509/crq.c
index 1f240007..147be276 100644
--- a/src/daemon/https/x509/crq.c
+++ b/src/daemon/https/x509/crq.c
@@ -43,7 +43,7 @@
 #include <libtasn1.h>
 
 /**
-  * gnutls_x509_crq_init - This function initializes a gnutls_x509_crq_t structure
+  * MHD_gnutls_x509_crq_init - This function initializes a MHD_gnutls_x509_crq_t structure
   * @crq: The structure to be initialized
   *
   * This function will initialize a PKCS10 certificate request structure.
@@ -52,20 +52,20 @@
   *
   **/
 int
-gnutls_x509_crq_init (gnutls_x509_crq_t * crq)
+MHD_gnutls_x509_crq_init (MHD_gnutls_x509_crq_t * crq)
 {
-  *crq = gnutls_calloc (1, sizeof (gnutls_x509_crq_int));
+  *crq = MHD_gnutls_calloc (1, sizeof (MHD_gnutls_x509_crq_int));
 
   if (*crq)
     {
-      int result = asn1_create_element (_gnutls_get_pkix (),
+      int result = MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                                         "PKIX1.pkcs-10-CertificationRequest",
                                         &((*crq)->crq));
       if (result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          gnutls_free (*crq);
-          return mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          MHD_gnutls_free (*crq);
+          return MHD_gtls_asn2err (result);
         }
       return 0;                 /* success */
     }
@@ -73,35 +73,35 @@ gnutls_x509_crq_init (gnutls_x509_crq_t * crq)
 }
 
 /**
-  * gnutls_x509_crq_deinit - This function deinitializes memory used by a gnutls_x509_crq_t structure
+  * MHD_gnutls_x509_crq_deinit - This function deinitializes memory used by a MHD_gnutls_x509_crq_t structure
   * @crq: The structure to be initialized
   *
   * This function will deinitialize a CRL structure.
   *
   **/
 void
-gnutls_x509_crq_deinit (gnutls_x509_crq_t crq)
+MHD_gnutls_x509_crq_deinit (MHD_gnutls_x509_crq_t crq)
 {
   if (!crq)
     return;
 
   if (crq->crq)
-    asn1_delete_structure (&crq->crq);
+    MHD__asn1_delete_structure (&crq->crq);
 
-  gnutls_free (crq);
+  MHD_gnutls_free (crq);
 }
 
 #define PEM_CRQ "NEW CERTIFICATE REQUEST"
 #define PEM_CRQ2 "CERTIFICATE REQUEST"
 
 /**
-  * gnutls_x509_crq_import - This function will import a DER or PEM encoded Certificate request
+  * MHD_gnutls_x509_crq_import - This function will import a DER or PEM encoded Certificate request
   * @crq: The structure to store the parsed certificate request.
   * @data: The DER or PEM encoded certificate.
   * @format: One of DER or PEM
   *
   * This function will convert the given DER or PEM encoded Certificate
-  * to the native gnutls_x509_crq_t format. The output will be stored in @cert.
+  * to the native MHD_gnutls_x509_crq_t format. The output will be stored in @cert.
   *
   * If the Certificate is PEM encoded it should have a header of "NEW CERTIFICATE REQUEST".
   *
@@ -109,16 +109,16 @@ gnutls_x509_crq_deinit (gnutls_x509_crq_t crq)
   *
   **/
 int
-gnutls_x509_crq_import (gnutls_x509_crq_t crq,
-                        const gnutls_datum_t * data,
-                        gnutls_x509_crt_fmt_t format)
+MHD_gnutls_x509_crq_import (MHD_gnutls_x509_crq_t crq,
+                        const MHD_gnutls_datum_t * data,
+                        MHD_gnutls_x509_crt_fmt_t format)
 {
   int result = 0, need_free = 0;
-  gnutls_datum_t _data;
+  MHD_gnutls_datum_t _data;
 
   if (crq == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -132,17 +132,17 @@ gnutls_x509_crq_import (gnutls_x509_crq_t crq,
       opaque *out;
 
       /* Try the first header */
-      result = _gnutls_fbase64_decode (PEM_CRQ, data->data, data->size, &out);
+      result = MHD__gnutls_fbase64_decode (PEM_CRQ, data->data, data->size, &out);
 
       if (result <= 0)          /* Go for the second header */
         result =
-          _gnutls_fbase64_decode (PEM_CRQ2, data->data, data->size, &out);
+          MHD__gnutls_fbase64_decode (PEM_CRQ2, data->data, data->size, &out);
 
       if (result <= 0)
         {
           if (result == 0)
             result = GNUTLS_E_INTERNAL_ERROR;
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return result;
         }
 
@@ -152,11 +152,11 @@ gnutls_x509_crq_import (gnutls_x509_crq_t crq,
       need_free = 1;
     }
 
-  result = asn1_der_decoding (&crq->crq, _data.data, _data.size, NULL);
+  result = MHD__asn1_der_decoding (&crq->crq, _data.data, _data.size, NULL);
   if (result != ASN1_SUCCESS)
     {
-      result = mhd_gtls_asn2err (result);
-      gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
@@ -164,15 +164,15 @@ gnutls_x509_crq_import (gnutls_x509_crq_t crq,
 
 cleanup:
   if (need_free)
-    _gnutls_free_datum (&_data);
+    MHD__gnutls_free_datum (&_data);
   return result;
 }
 
 
 
 /**
-  * gnutls_x509_crq_get_dn - This function returns the Certificate request subject's distinguished name
-  * @crq: should contain a gnutls_x509_crq_t structure
+  * MHD_gnutls_x509_crq_get_dn - This function returns the Certificate request subject's distinguished name
+  * @crq: should contain a MHD_gnutls_x509_crq_t structure
   * @buf: a pointer to a structure to hold the name (may be null)
   * @sizeof_buf: initially holds the size of @buf
   *
@@ -189,22 +189,22 @@ cleanup:
   *
   **/
 int
-gnutls_x509_crq_get_dn (gnutls_x509_crq_t crq, char *buf, size_t * sizeof_buf)
+MHD_gnutls_x509_crq_get_dn (MHD_gnutls_x509_crq_t crq, char *buf, size_t * sizeof_buf)
 {
   if (crq == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  return _gnutls_x509_parse_dn (crq->crq,
+  return MHD__gnutls_x509_parse_dn (crq->crq,
                                 "certificationRequestInfo.subject.rdnSequence",
                                 buf, sizeof_buf);
 }
 
 /**
-  * gnutls_x509_crq_get_dn_by_oid - This function returns the Certificate request subject's distinguished name
-  * @crq: should contain a gnutls_x509_crq_t structure
+  * MHD_gnutls_x509_crq_get_dn_by_oid - This function returns the Certificate request subject's distinguished name
+  * @crq: should contain a MHD_gnutls_x509_crq_t structure
   * @oid: holds an Object Identified in null terminated string
   * @indx: In case multiple same OIDs exist in the RDN, this specifies
   *   which to send. Use zero to get the first one.
@@ -221,7 +221,7 @@ gnutls_x509_crq_get_dn (gnutls_x509_crq_t crq, char *buf, size_t * sizeof_buf)
   * If raw flag is zero, this function will only return known OIDs as
   * text. Other OIDs will be DER encoded, as described in RFC2253 --
   * in hex format with a '\#' prefix.  You can check about known OIDs
-  * using gnutls_x509_dn_oid_known().
+  * using MHD_gnutls_x509_dn_oid_known().
   *
   * If @buf is null then only the size will be filled.
   *
@@ -231,24 +231,24 @@ gnutls_x509_crq_get_dn (gnutls_x509_crq_t crq, char *buf, size_t * sizeof_buf)
   *
   **/
 int
-gnutls_x509_crq_get_dn_by_oid (gnutls_x509_crq_t crq, const char *oid,
+MHD_gnutls_x509_crq_get_dn_by_oid (MHD_gnutls_x509_crq_t crq, const char *oid,
                                int indx, unsigned int raw_flag,
                                void *buf, size_t * sizeof_buf)
 {
   if (crq == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  return _gnutls_x509_parse_dn_oid (crq->crq,
+  return MHD__gnutls_x509_parse_dn_oid (crq->crq,
                                     "certificationRequestInfo.subject.rdnSequence",
                                     oid, indx, raw_flag, buf, sizeof_buf);
 }
 
 /**
-  * gnutls_x509_crq_get_dn_oid - This function returns the Certificate request subject's distinguished name OIDs
-  * @crq: should contain a gnutls_x509_crq_t structure
+  * MHD_gnutls_x509_crq_get_dn_oid - This function returns the Certificate request subject's distinguished name OIDs
+  * @crq: should contain a MHD_gnutls_x509_crq_t structure
   * @indx: Specifies which DN OID to send. Use zero to get the first one.
   * @oid: a pointer to a structure to hold the name (may be null)
   * @sizeof_oid: initially holds the size of @oid
@@ -264,30 +264,30 @@ gnutls_x509_crq_get_dn_by_oid (gnutls_x509_crq_t crq, const char *oid,
   *
   **/
 int
-gnutls_x509_crq_get_dn_oid (gnutls_x509_crq_t crq,
+MHD_gnutls_x509_crq_get_dn_oid (MHD_gnutls_x509_crq_t crq,
                             int indx, void *oid, size_t * sizeof_oid)
 {
   if (crq == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  return _gnutls_x509_get_dn_oid (crq->crq,
+  return MHD__gnutls_x509_get_dn_oid (crq->crq,
                                   "certificationRequestInfo.subject.rdnSequence",
                                   indx, oid, sizeof_oid);
 }
 
-/* Parses an Attribute list in the asn1_struct, and searches for the
+/* Parses an Attribute list in the MHD__asn1_struct, and searches for the
  * given OID. The index indicates the attribute value to be returned.
  *
  * If raw==0 only printable data are returned, or GNUTLS_E_X509_UNSUPPORTED_ATTRIBUTE.
  *
- * asn1_attr_name must be a string in the form "certificationRequestInfo.attributes"
+ * MHD__asn1_attr_name must be a string in the form "certificationRequestInfo.attributes"
  *
  */
 static int
-parse_attribute (ASN1_TYPE asn1_struct,
+parse_attribute (ASN1_TYPE MHD__asn1_struct,
                  const char *attr_name, const char *given_oid, int indx,
                  int raw, char *buf, size_t * sizeof_buf)
 {
@@ -300,7 +300,7 @@ parse_attribute (ASN1_TYPE asn1_struct,
 
   if (*sizeof_buf == 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -319,18 +319,18 @@ parse_attribute (ASN1_TYPE asn1_struct,
         snprintf (tmpbuffer1, sizeof (tmpbuffer1), "?%u", k1);
 
       len = sizeof (value) - 1;
-      result = asn1_read_value (asn1_struct, tmpbuffer1, value, &len);
+      result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer1, value, &len);
 
       if (result == ASN1_ELEMENT_NOT_FOUND)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           break;
         }
 
       if (result != ASN1_VALUE_NOT_FOUND)
         {
-          gnutls_assert ();
-          result = mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          result = MHD_gtls_asn2err (result);
           goto cleanup;
         }
 
@@ -338,18 +338,18 @@ parse_attribute (ASN1_TYPE asn1_struct,
        */
       /* Read the OID
        */
-      mhd_gtls_str_cpy (tmpbuffer3, sizeof (tmpbuffer3), tmpbuffer1);
-      mhd_gtls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".type");
+      MHD_gtls_str_cpy (tmpbuffer3, sizeof (tmpbuffer3), tmpbuffer1);
+      MHD_gtls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".type");
 
       len = sizeof (oid) - 1;
-      result = asn1_read_value (asn1_struct, tmpbuffer3, oid, &len);
+      result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer3, oid, &len);
 
       if (result == ASN1_ELEMENT_NOT_FOUND)
         break;
       else if (result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          result = mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          result = MHD_gtls_asn2err (result);
           goto cleanup;
         }
 
@@ -362,32 +362,32 @@ parse_attribute (ASN1_TYPE asn1_struct,
                     tmpbuffer1, indx + 1);
 
           len = sizeof (value) - 1;
-          result = asn1_read_value (asn1_struct, tmpbuffer3, value, &len);
+          result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer3, value, &len);
 
           if (result != ASN1_SUCCESS)
             {
-              gnutls_assert ();
-              result = mhd_gtls_asn2err (result);
+              MHD_gnutls_assert ();
+              result = MHD_gtls_asn2err (result);
               goto cleanup;
             }
 
           if (raw == 0)
             {
-              printable = _gnutls_x509_oid_data_printable (oid);
+              printable = MHD__gnutls_x509_oid_data_printable (oid);
               if (printable == 1)
                 {
                   if ((result =
-                       _gnutls_x509_oid_data2string
+                       MHD__gnutls_x509_oid_data2string
                        (oid, value, len, buf, sizeof_buf)) < 0)
                     {
-                      gnutls_assert ();
+                      MHD_gnutls_assert ();
                       goto cleanup;
                     }
                   return 0;
                 }
               else
                 {
-                  gnutls_assert ();
+                  MHD_gnutls_assert ();
                   return GNUTLS_E_X509_UNSUPPORTED_ATTRIBUTE;
                 }
             }
@@ -403,7 +403,7 @@ parse_attribute (ASN1_TYPE asn1_struct,
               else
                 {
                   *sizeof_buf = len;
-                  gnutls_assert ();
+                  MHD_gnutls_assert ();
                   return GNUTLS_E_SHORT_MEMORY_BUFFER;
                 }
             }
@@ -412,7 +412,7 @@ parse_attribute (ASN1_TYPE asn1_struct,
     }
   while (1);
 
-  gnutls_assert ();
+  MHD_gnutls_assert ();
 
   result = GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE;
 
@@ -421,8 +421,8 @@ cleanup:
 }
 
 /**
-  * gnutls_x509_crq_get_challenge_password - This function will get the challenge password
-  * @crq: should contain a gnutls_x509_crq_t structure
+  * MHD_gnutls_x509_crq_get_challenge_password - This function will get the challenge password
+  * @crq: should contain a MHD_gnutls_x509_crq_t structure
   * @pass: will hold a null terminated password
   * @sizeof_pass: Initially holds the size of @pass.
   *
@@ -433,12 +433,12 @@ cleanup:
   *
   **/
 int
-gnutls_x509_crq_get_challenge_password (gnutls_x509_crq_t crq,
+MHD_gnutls_x509_crq_get_challenge_password (MHD_gnutls_x509_crq_t crq,
                                         char *pass, size_t * sizeof_pass)
 {
   if (crq == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -447,8 +447,8 @@ gnutls_x509_crq_get_challenge_password (gnutls_x509_crq_t crq,
 }
 
 /**
-  * gnutls_x509_crq_set_attribute_by_oid - This function will set an attribute in the request
-  * @crq: should contain a gnutls_x509_crq_t structure
+  * MHD_gnutls_x509_crq_set_attribute_by_oid - This function will set an attribute in the request
+  * @crq: should contain a MHD_gnutls_x509_crq_t structure
   * @oid: holds an Object Identified in null terminated string
   * @buf: a pointer to a structure that holds the attribute data
   * @sizeof_buf: holds the size of @buf
@@ -460,7 +460,7 @@ gnutls_x509_crq_get_challenge_password (gnutls_x509_crq_t crq,
   *
   **/
 int
-gnutls_x509_crq_set_attribute_by_oid (gnutls_x509_crq_t crq,
+MHD_gnutls_x509_crq_set_attribute_by_oid (MHD_gnutls_x509_crq_t crq,
                                       const char *oid, void *buf,
                                       size_t sizeof_buf)
 {
@@ -468,30 +468,30 @@ gnutls_x509_crq_set_attribute_by_oid (gnutls_x509_crq_t crq,
 
   if (crq == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   /* Add the attribute.
    */
   result =
-    asn1_write_value (crq->crq, "certificationRequestInfo.attributes",
+    MHD__asn1_write_value (crq->crq, "certificationRequestInfo.attributes",
                       "NEW", 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   result =
-    _gnutls_x509_encode_and_write_attribute (oid,
+    MHD__gnutls_x509_encode_and_write_attribute (oid,
                                              crq->crq,
                                              "certificationRequestInfo.attributes.?LAST",
                                              buf, sizeof_buf, 1);
 
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -499,8 +499,8 @@ gnutls_x509_crq_set_attribute_by_oid (gnutls_x509_crq_t crq,
 }
 
 /**
-  * gnutls_x509_crq_get_attribute_by_oid - This function will get an attribute of the request
-  * @crq: should contain a gnutls_x509_crq_t structure
+  * MHD_gnutls_x509_crq_get_attribute_by_oid - This function will get an attribute of the request
+  * @crq: should contain a MHD_gnutls_x509_crq_t structure
   * @oid: holds an Object Identified in null terminated string
   * @indx: In case multiple same OIDs exist in the attribute list, this specifies
   *   which to send. Use zero to get the first one.
@@ -514,13 +514,13 @@ gnutls_x509_crq_set_attribute_by_oid (gnutls_x509_crq_t crq,
   *
   **/
 int
-gnutls_x509_crq_get_attribute_by_oid (gnutls_x509_crq_t crq,
+MHD_gnutls_x509_crq_get_attribute_by_oid (MHD_gnutls_x509_crq_t crq,
                                       const char *oid, int indx, void *buf,
                                       size_t * sizeof_buf)
 {
   if (crq == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -529,8 +529,8 @@ gnutls_x509_crq_get_attribute_by_oid (gnutls_x509_crq_t crq,
 }
 
 /**
-  * gnutls_x509_crq_set_dn_by_oid - This function will set the Certificate request subject's distinguished name
-  * @crq: should contain a gnutls_x509_crq_t structure
+  * MHD_gnutls_x509_crq_set_dn_by_oid - This function will set the Certificate request subject's distinguished name
+  * @crq: should contain a MHD_gnutls_x509_crq_t structure
   * @oid: holds an Object Identifier in a null terminated string
   * @raw_flag: must be 0, or 1 if the data are DER encoded
   * @data: a pointer to the input data
@@ -541,7 +541,7 @@ gnutls_x509_crq_get_attribute_by_oid (gnutls_x509_crq_t crq,
   *
   * Some helper macros with popular OIDs can be found in gnutls/x509.h
   * With this function you can only set the known OIDs. You can test
-  * for known OIDs using gnutls_x509_dn_oid_known(). For OIDs that are
+  * for known OIDs using MHD_gnutls_x509_dn_oid_known(). For OIDs that are
   * not known (by gnutls) you should properly DER encode your data, and
   * call this function with raw_flag set.
   *
@@ -549,7 +549,7 @@ gnutls_x509_crq_get_attribute_by_oid (gnutls_x509_crq_t crq,
   *
   **/
 int
-gnutls_x509_crq_set_dn_by_oid (gnutls_x509_crq_t crq, const char *oid,
+MHD_gnutls_x509_crq_set_dn_by_oid (MHD_gnutls_x509_crq_t crq, const char *oid,
                                unsigned int raw_flag, const void *data,
                                unsigned int sizeof_data)
 {
@@ -558,14 +558,14 @@ gnutls_x509_crq_set_dn_by_oid (gnutls_x509_crq_t crq, const char *oid,
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  return _gnutls_x509_set_dn_oid (crq->crq,
+  return MHD__gnutls_x509_set_dn_oid (crq->crq,
                                   "certificationRequestInfo.subject", oid,
                                   raw_flag, data, sizeof_data);
 }
 
 /**
-  * gnutls_x509_crq_set_version - This function will set the Certificate request version
-  * @crq: should contain a gnutls_x509_crq_t structure
+  * MHD_gnutls_x509_crq_set_version - This function will set the Certificate request version
+  * @crq: should contain a MHD_gnutls_x509_crq_t structure
   * @version: holds the version number. For v1 Requests must be 1.
   *
   * This function will set the version of the certificate request. For
@@ -575,14 +575,14 @@ gnutls_x509_crq_set_dn_by_oid (gnutls_x509_crq_t crq, const char *oid,
   *
   **/
 int
-gnutls_x509_crq_set_version (gnutls_x509_crq_t crq, unsigned int version)
+MHD_gnutls_x509_crq_set_version (MHD_gnutls_x509_crq_t crq, unsigned int version)
 {
   int result;
   unsigned char null = version;
 
   if (crq == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -590,19 +590,19 @@ gnutls_x509_crq_set_version (gnutls_x509_crq_t crq, unsigned int version)
     null--;
 
   result =
-    asn1_write_value (crq->crq, "certificationRequestInfo.version", &null, 1);
+    MHD__asn1_write_value (crq->crq, "certificationRequestInfo.version", &null, 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   return 0;
 }
 
 /**
-  * gnutls_x509_crq_get_version - This function returns the Certificate request's version number
-  * @crq: should contain a gnutls_x509_crq_t structure
+  * MHD_gnutls_x509_crq_get_version - This function returns the Certificate request's version number
+  * @crq: should contain a MHD_gnutls_x509_crq_t structure
   *
   * This function will return the version of the specified Certificate request.
   *
@@ -610,35 +610,35 @@ gnutls_x509_crq_set_version (gnutls_x509_crq_t crq, unsigned int version)
   *
   **/
 int
-gnutls_x509_crq_get_version (gnutls_x509_crq_t crq)
+MHD_gnutls_x509_crq_get_version (MHD_gnutls_x509_crq_t crq)
 {
   opaque version[5];
   int len, result;
 
   if (crq == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   len = sizeof (version);
   if ((result =
-       asn1_read_value (crq->crq, "certificationRequestInfo.version",
+       MHD__asn1_read_value (crq->crq, "certificationRequestInfo.version",
                         version, &len)) != ASN1_SUCCESS)
     {
 
       if (result == ASN1_ELEMENT_NOT_FOUND)
         return 1;               /* the DEFAULT version */
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   return (int) version[0] + 1;
 }
 
 /**
-  * gnutls_x509_crq_set_key - This function will associate the Certificate request with a key
-  * @crq: should contain a gnutls_x509_crq_t structure
+  * MHD_gnutls_x509_crq_set_key - This function will associate the Certificate request with a key
+  * @crq: should contain a MHD_gnutls_x509_crq_t structure
   * @key: holds a private key
   *
   * This function will set the public parameters from the given private key to the
@@ -648,17 +648,17 @@ gnutls_x509_crq_get_version (gnutls_x509_crq_t crq)
   *
   **/
 int
-gnutls_x509_crq_set_key (gnutls_x509_crq_t crq, gnutls_x509_privkey_t key)
+MHD_gnutls_x509_crq_set_key (MHD_gnutls_x509_crq_t crq, MHD_gnutls_x509_privkey_t key)
 {
   int result;
 
   if (crq == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  result = _gnutls_x509_encode_and_copy_PKI_params (crq->crq,
+  result = MHD__gnutls_x509_encode_and_copy_PKI_params (crq->crq,
                                                     "certificationRequestInfo.subjectPKInfo",
                                                     key->pk_algorithm,
                                                     key->params,
@@ -666,7 +666,7 @@ gnutls_x509_crq_set_key (gnutls_x509_crq_t crq, gnutls_x509_privkey_t key)
 
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -674,8 +674,8 @@ gnutls_x509_crq_set_key (gnutls_x509_crq_t crq, gnutls_x509_privkey_t key)
 }
 
 /**
-  * gnutls_x509_crq_set_challenge_password - This function will set a challenge password
-  * @crq: should contain a gnutls_x509_crq_t structure
+  * MHD_gnutls_x509_crq_set_challenge_password - This function will set a challenge password
+  * @crq: should contain a MHD_gnutls_x509_crq_t structure
   * @pass: holds a null terminated password
   *
   * This function will set a challenge password to be used when revoking the request.
@@ -684,37 +684,37 @@ gnutls_x509_crq_set_key (gnutls_x509_crq_t crq, gnutls_x509_privkey_t key)
   *
   **/
 int
-gnutls_x509_crq_set_challenge_password (gnutls_x509_crq_t crq,
+MHD_gnutls_x509_crq_set_challenge_password (MHD_gnutls_x509_crq_t crq,
                                         const char *pass)
 {
   int result;
 
   if (crq == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   /* Add the attribute.
    */
   result =
-    asn1_write_value (crq->crq, "certificationRequestInfo.attributes",
+    MHD__asn1_write_value (crq->crq, "certificationRequestInfo.attributes",
                       "NEW", 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   result =
-    _gnutls_x509_encode_and_write_attribute ("1.2.840.113549.1.9.7",
+    MHD__gnutls_x509_encode_and_write_attribute ("1.2.840.113549.1.9.7",
                                              crq->crq,
                                              "certificationRequestInfo.attributes.?LAST",
                                              pass, strlen (pass), 1);
 
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -722,14 +722,14 @@ gnutls_x509_crq_set_challenge_password (gnutls_x509_crq_t crq,
 }
 
 /**
-  * gnutls_x509_crq_sign2 - This function will sign a Certificate request with a key
-  * @crq: should contain a gnutls_x509_crq_t structure
+  * MHD_gnutls_x509_crq_sign2 - This function will sign a Certificate request with a key
+  * @crq: should contain a MHD_gnutls_x509_crq_t structure
   * @key: holds a private key
   * @dig: The message digest to use. GNUTLS_DIG_SHA1 is the safe choice unless you know what you're doing.
   * @flags: must be 0
   *
   * This function will sign the certificate request with a private key.
-  * This must be the same key as the one used in gnutls_x509_crt_set_key() since a
+  * This must be the same key as the one used in MHD_gnutls_x509_crt_set_key() since a
   * certificate request is self signed.
   *
   * This must be the last step in a certificate request generation since all
@@ -739,52 +739,52 @@ gnutls_x509_crq_set_challenge_password (gnutls_x509_crq_t crq,
   *
   **/
 int
-gnutls_x509_crq_sign2 (gnutls_x509_crq_t crq, gnutls_x509_privkey_t key,
+MHD_gnutls_x509_crq_sign2 (MHD_gnutls_x509_crq_t crq, MHD_gnutls_x509_privkey_t key,
                        enum MHD_GNUTLS_HashAlgorithm dig, unsigned int flags)
 {
   int result;
-  gnutls_datum_t signature;
+  MHD_gnutls_datum_t signature;
 
   if (crq == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   /* Step 1. Self sign the request.
    */
   result =
-    _gnutls_x509_sign_tbs (crq->crq, "certificationRequestInfo",
+    MHD__gnutls_x509_sign_tbs (crq->crq, "certificationRequestInfo",
                            dig, key, &signature);
 
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
   /* Step 2. write the signature (bits)
    */
   result =
-    asn1_write_value (crq->crq, "signature", signature.data,
+    MHD__asn1_write_value (crq->crq, "signature", signature.data,
                       signature.size * 8);
 
-  _gnutls_free_datum (&signature);
+  MHD__gnutls_free_datum (&signature);
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   /* Step 3. Write the signatureAlgorithm field.
    */
-  result = _gnutls_x509_write_sig_params (crq->crq, "signatureAlgorithm",
+  result = MHD__gnutls_x509_write_sig_params (crq->crq, "signatureAlgorithm",
                                           key->pk_algorithm, dig, key->params,
                                           key->params_size);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -792,24 +792,24 @@ gnutls_x509_crq_sign2 (gnutls_x509_crq_t crq, gnutls_x509_privkey_t key,
 }
 
 /**
-  * gnutls_x509_crq_sign - This function will sign a Certificate request with a key
-  * @crq: should contain a gnutls_x509_crq_t structure
+  * MHD_gnutls_x509_crq_sign - This function will sign a Certificate request with a key
+  * @crq: should contain a MHD_gnutls_x509_crq_t structure
   * @key: holds a private key
   *
-  * This function is the same a gnutls_x509_crq_sign2() with no flags, and
+  * This function is the same a MHD_gnutls_x509_crq_sign2() with no flags, and
   * SHA1 as the hash algorithm.
   *
   * Returns 0 on success.
   *
   **/
 int
-gnutls_x509_crq_sign (gnutls_x509_crq_t crq, gnutls_x509_privkey_t key)
+MHD_gnutls_x509_crq_sign (MHD_gnutls_x509_crq_t crq, MHD_gnutls_x509_privkey_t key)
 {
-  return gnutls_x509_crq_sign2 (crq, key, MHD_GNUTLS_MAC_SHA1, 0);
+  return MHD_gnutls_x509_crq_sign2 (crq, key, MHD_GNUTLS_MAC_SHA1, 0);
 }
 
 /**
-  * gnutls_x509_crq_export - Export the generated certificate request
+  * MHD_gnutls_x509_crq_export - Export the generated certificate request
   * @crq: Holds the request
   * @format: the format of output params. One of PEM or DER.
   * @output_data: will contain a certificate request PEM or DER encoded
@@ -830,23 +830,23 @@ gnutls_x509_crq_sign (gnutls_x509_crq_t crq, gnutls_x509_privkey_t key)
   *
   **/
 int
-gnutls_x509_crq_export (gnutls_x509_crq_t crq,
-                        gnutls_x509_crt_fmt_t format, void *output_data,
+MHD_gnutls_x509_crq_export (MHD_gnutls_x509_crq_t crq,
+                        MHD_gnutls_x509_crt_fmt_t format, void *output_data,
                         size_t * output_data_size)
 {
   if (crq == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  return _gnutls_x509_export_int (crq->crq, format, PEM_CRQ,
+  return MHD__gnutls_x509_export_int (crq->crq, format, PEM_CRQ,
                                   output_data, output_data_size);
 }
 
 /**
-  * gnutls_x509_crq_get_pk_algorithm - This function returns the certificate request's PublicKey algorithm
-  * @crq: should contain a gnutls_x509_crq_t structure
+  * MHD_gnutls_x509_crq_get_pk_algorithm - This function returns the certificate request's PublicKey algorithm
+  * @crq: should contain a MHD_gnutls_x509_crq_t structure
   * @bits: if bits is non null it will hold the size of the parameters' in bits
   *
   * This function will return the public key algorithm of a PKCS \#10
@@ -862,23 +862,23 @@ gnutls_x509_crq_export (gnutls_x509_crq_t crq,
   *
   **/
 int
-gnutls_x509_crq_get_pk_algorithm (gnutls_x509_crq_t crq, unsigned int *bits)
+MHD_gnutls_x509_crq_get_pk_algorithm (MHD_gnutls_x509_crq_t crq, unsigned int *bits)
 {
   int result;
 
   if (crq == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   result =
-    _gnutls_x509_get_pk_algorithm (crq->crq,
+    MHD__gnutls_x509_get_pk_algorithm (crq->crq,
                                    "certificationRequestInfo.subjectPKInfo",
                                    bits);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
     }
 
   return result;
diff --git a/src/daemon/https/x509/crq.h b/src/daemon/https/x509/crq.h
index 80e600b5..661701bd 100644
--- a/src/daemon/https/x509/crq.h
+++ b/src/daemon/https/x509/crq.h
@@ -24,7 +24,7 @@
 
 #include <x509.h>
 
-typedef struct gnutls_x509_crq_int
+typedef struct MHD_gnutls_x509_crq_int
 {
   ASN1_TYPE crq;
-} gnutls_x509_crq_int;
+} MHD_gnutls_x509_crq_int;
diff --git a/src/daemon/https/x509/dn.c b/src/daemon/https/x509/dn.c
index 0c6a2f7a..8dcc458a 100644
--- a/src/daemon/https/x509/dn.c
+++ b/src/daemon/https/x509/dn.c
@@ -44,7 +44,7 @@ oid2ldap_string (const char *oid)
 {
   const char *ret;
 
-  ret = _gnutls_x509_oid2ldap_string (oid);
+  ret = MHD__gnutls_x509_oid2ldap_string (oid);
   if (ret)
     return ret;
 
@@ -80,18 +80,18 @@ str_escape (char *str, char *buffer, unsigned int buffer_size)
   return buffer;
 }
 
-/* Parses an X509 DN in the asn1_struct, and puts the output into
+/* Parses an X509 DN in the MHD__asn1_struct, and puts the output into
  * the string buf. The output is an LDAP encoded DN.
  *
- * asn1_rdn_name must be a string in the form "tbsCertificate.issuer.rdnSequence".
+ * MHD__asn1_rdn_name must be a string in the form "tbsCertificate.issuer.rdnSequence".
  * That is to point in the rndSequence.
  */
 int
-_gnutls_x509_parse_dn (ASN1_TYPE asn1_struct,
-                       const char *asn1_rdn_name, char *buf,
+MHD__gnutls_x509_parse_dn (ASN1_TYPE MHD__asn1_struct,
+                       const char *MHD__asn1_rdn_name, char *buf,
                        size_t * sizeof_buf)
 {
-  mhd_gtls_string out_str;
+  MHD_gtls_string out_str;
   int k2, k1, result;
   char tmpbuffer1[MAX_NAME_SIZE];
   char tmpbuffer2[MAX_NAME_SIZE];
@@ -106,7 +106,7 @@ _gnutls_x509_parse_dn (ASN1_TYPE asn1_struct,
 
   if (sizeof_buf == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -115,7 +115,7 @@ _gnutls_x509_parse_dn (ASN1_TYPE asn1_struct,
   else
     *sizeof_buf = 0;
 
-  mhd_gtls_string_init (&out_str, gnutls_malloc, gnutls_realloc, gnutls_free);
+  MHD_gtls_string_init (&out_str, MHD_gnutls_malloc, MHD_gnutls_realloc, MHD_gnutls_free);
 
   k1 = 0;
   do
@@ -124,14 +124,14 @@ _gnutls_x509_parse_dn (ASN1_TYPE asn1_struct,
       k1++;
       /* create a string like "tbsCertList.issuer.rdnSequence.?1"
        */
-      if (asn1_rdn_name[0] != 0)
-        snprintf (tmpbuffer1, sizeof (tmpbuffer1), "%s.?%u", asn1_rdn_name,
+      if (MHD__asn1_rdn_name[0] != 0)
+        snprintf (tmpbuffer1, sizeof (tmpbuffer1), "%s.?%u", MHD__asn1_rdn_name,
                   k1);
       else
         snprintf (tmpbuffer1, sizeof (tmpbuffer1), "?%u", k1);
 
       len = sizeof (value) - 1;
-      result = asn1_read_value (asn1_struct, tmpbuffer1, value, &len);
+      result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer1, value, &len);
 
       if (result == ASN1_ELEMENT_NOT_FOUND)
         {
@@ -140,8 +140,8 @@ _gnutls_x509_parse_dn (ASN1_TYPE asn1_struct,
 
       if (result != ASN1_VALUE_NOT_FOUND)
         {
-          gnutls_assert ();
-          result = mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          result = MHD_gtls_asn2err (result);
           goto cleanup;
         }
 
@@ -162,60 +162,60 @@ _gnutls_x509_parse_dn (ASN1_TYPE asn1_struct,
            */
 
           len = sizeof (value) - 1;
-          result = asn1_read_value (asn1_struct, tmpbuffer2, value, &len);
+          result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer2, value, &len);
 
           if (result == ASN1_ELEMENT_NOT_FOUND)
             break;
           if (result != ASN1_VALUE_NOT_FOUND)
             {
-              gnutls_assert ();
-              result = mhd_gtls_asn2err (result);
+              MHD_gnutls_assert ();
+              result = MHD_gtls_asn2err (result);
               goto cleanup;
             }
 
           /* Read the OID
            */
-          mhd_gtls_str_cpy (tmpbuffer3, sizeof (tmpbuffer3), tmpbuffer2);
-          mhd_gtls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".type");
+          MHD_gtls_str_cpy (tmpbuffer3, sizeof (tmpbuffer3), tmpbuffer2);
+          MHD_gtls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".type");
 
           len = sizeof (oid) - 1;
-          result = asn1_read_value (asn1_struct, tmpbuffer3, oid, &len);
+          result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer3, oid, &len);
 
           if (result == ASN1_ELEMENT_NOT_FOUND)
             break;
           else if (result != ASN1_SUCCESS)
             {
-              gnutls_assert ();
-              result = mhd_gtls_asn2err (result);
+              MHD_gnutls_assert ();
+              result = MHD_gtls_asn2err (result);
               goto cleanup;
             }
 
           /* Read the Value
            */
-          mhd_gtls_str_cpy (tmpbuffer3, sizeof (tmpbuffer3), tmpbuffer2);
-          mhd_gtls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".value");
+          MHD_gtls_str_cpy (tmpbuffer3, sizeof (tmpbuffer3), tmpbuffer2);
+          MHD_gtls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".value");
 
           len = 0;
-          result = asn1_read_value (asn1_struct, tmpbuffer3, NULL, &len);
+          result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer3, NULL, &len);
 
-          value2 = gnutls_malloc (len);
+          value2 = MHD_gnutls_malloc (len);
           if (value2 == NULL)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               result = GNUTLS_E_MEMORY_ERROR;
               goto cleanup;
             }
 
-          result = asn1_read_value (asn1_struct, tmpbuffer3, value2, &len);
+          result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer3, value2, &len);
 
           if (result != ASN1_SUCCESS)
             {
-              gnutls_assert ();
-              result = mhd_gtls_asn2err (result);
+              MHD_gnutls_assert ();
+              result = MHD_gtls_asn2err (result);
               goto cleanup;
             }
-#define STR_APPEND(y) if ((result=mhd_gtls_string_append_str( &out_str, y)) < 0) { \
-        gnutls_assert(); \
+#define STR_APPEND(y) if ((result=MHD_gtls_string_append_str( &out_str, y)) < 0) { \
+        MHD_gnutls_assert(); \
         goto cleanup; \
 }
           /*   The encodings of adjoining RelativeDistinguishedNames are separated
@@ -239,24 +239,24 @@ _gnutls_x509_parse_dn (ASN1_TYPE asn1_struct,
             }
 
           ldap_desc = oid2ldap_string (oid);
-          printable = _gnutls_x509_oid_data_printable (oid);
+          printable = MHD__gnutls_x509_oid_data_printable (oid);
 
           sizeof_escaped = 2 * len + 1;
 
-          escaped = gnutls_malloc (sizeof_escaped);
+          escaped = MHD_gnutls_malloc (sizeof_escaped);
           if (escaped == NULL)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               result = GNUTLS_E_MEMORY_ERROR;
               goto cleanup;
             }
 
           sizeof_string = 2 * len + 2;  /* in case it is not printable */
 
-          string = gnutls_malloc (sizeof_string);
+          string = MHD_gnutls_malloc (sizeof_string);
           if (string == NULL)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               result = GNUTLS_E_MEMORY_ERROR;
               goto cleanup;
             }
@@ -267,30 +267,30 @@ _gnutls_x509_parse_dn (ASN1_TYPE asn1_struct,
 
           if (printable)
             result =
-              _gnutls_x509_oid_data2string (oid,
+              MHD__gnutls_x509_oid_data2string (oid,
                                             value2, len,
                                             string, &sizeof_string);
 
           if (!printable || result < 0)
             result =
-              _gnutls_x509_data2hex (value2, len, string, &sizeof_string);
+              MHD__gnutls_x509_data2hex (value2, len, string, &sizeof_string);
 
           if (result < 0)
             {
-              gnutls_assert ();
-              _gnutls_x509_log
+              MHD_gnutls_assert ();
+              MHD__gnutls_x509_log
                 ("Found OID: '%s' with value '%s'\n",
-                 oid, mhd_gtls_bin2hex (value2, len, escaped,
+                 oid, MHD_gtls_bin2hex (value2, len, escaped,
                                         sizeof_escaped));
               goto cleanup;
             }
           STR_APPEND (str_escape (string, escaped, sizeof_escaped));
-          gnutls_free (string);
+          MHD_gnutls_free (string);
           string = NULL;
 
-          gnutls_free (escaped);
+          MHD_gnutls_free (escaped);
           escaped = NULL;
-          gnutls_free (value2);
+          MHD_gnutls_free (value2);
           value2 = NULL;
 
         }
@@ -301,7 +301,7 @@ _gnutls_x509_parse_dn (ASN1_TYPE asn1_struct,
 
   if (out_str.length >= (unsigned int) *sizeof_buf)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       *sizeof_buf = out_str.length + 1;
       result = GNUTLS_E_SHORT_MEMORY_BUFFER;
       goto cleanup;
@@ -317,28 +317,28 @@ _gnutls_x509_parse_dn (ASN1_TYPE asn1_struct,
   result = 0;
 
 cleanup:
-  gnutls_free (value2);
-  gnutls_free (string);
-  gnutls_free (escaped);
-  mhd_gtls_string_clear (&out_str);
+  MHD_gnutls_free (value2);
+  MHD_gnutls_free (string);
+  MHD_gnutls_free (escaped);
+  MHD_gtls_string_clear (&out_str);
   return result;
 }
 
-/* Parses an X509 DN in the asn1_struct, and searches for the
+/* Parses an X509 DN in the MHD__asn1_struct, and searches for the
  * given OID in the DN.
  *
  * If raw_flag == 0, the output will be encoded in the LDAP way. (#hex for non printable)
  * Otherwise the raw DER data are returned.
  *
- * asn1_rdn_name must be a string in the form "tbsCertificate.issuer.rdnSequence".
+ * MHD__asn1_rdn_name must be a string in the form "tbsCertificate.issuer.rdnSequence".
  * That is to point in the rndSequence.
  *
  * indx specifies which OID to return. Ie 0 means return the first specified
  * OID found, 1 the second etc.
  */
 int
-_gnutls_x509_parse_dn_oid (ASN1_TYPE asn1_struct,
-                           const char *asn1_rdn_name,
+MHD__gnutls_x509_parse_dn_oid (ASN1_TYPE MHD__asn1_struct,
+                           const char *MHD__asn1_rdn_name,
                            const char *given_oid, int indx,
                            unsigned int raw_flag,
                            void *buf, size_t * sizeof_buf)
@@ -365,25 +365,25 @@ _gnutls_x509_parse_dn_oid (ASN1_TYPE asn1_struct,
       k1++;
       /* create a string like "tbsCertList.issuer.rdnSequence.?1"
        */
-      if (asn1_rdn_name[0] != 0)
-        snprintf (tmpbuffer1, sizeof (tmpbuffer1), "%s.?%u", asn1_rdn_name,
+      if (MHD__asn1_rdn_name[0] != 0)
+        snprintf (tmpbuffer1, sizeof (tmpbuffer1), "%s.?%u", MHD__asn1_rdn_name,
                   k1);
       else
         snprintf (tmpbuffer1, sizeof (tmpbuffer1), "?%u", k1);
 
       len = sizeof (value) - 1;
-      result = asn1_read_value (asn1_struct, tmpbuffer1, value, &len);
+      result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer1, value, &len);
 
       if (result == ASN1_ELEMENT_NOT_FOUND)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           break;
         }
 
       if (result != ASN1_VALUE_NOT_FOUND)
         {
-          gnutls_assert ();
-          result = mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          result = MHD_gtls_asn2err (result);
           goto cleanup;
         }
 
@@ -404,7 +404,7 @@ _gnutls_x509_parse_dn_oid (ASN1_TYPE asn1_struct,
            */
 
           len = sizeof (value) - 1;
-          result = asn1_read_value (asn1_struct, tmpbuffer2, value, &len);
+          result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer2, value, &len);
 
           if (result == ASN1_ELEMENT_NOT_FOUND)
             {
@@ -412,25 +412,25 @@ _gnutls_x509_parse_dn_oid (ASN1_TYPE asn1_struct,
             }
           if (result != ASN1_VALUE_NOT_FOUND)
             {
-              gnutls_assert ();
-              result = mhd_gtls_asn2err (result);
+              MHD_gnutls_assert ();
+              result = MHD_gtls_asn2err (result);
               goto cleanup;
             }
 
           /* Read the OID
            */
-          mhd_gtls_str_cpy (tmpbuffer3, sizeof (tmpbuffer3), tmpbuffer2);
-          mhd_gtls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".type");
+          MHD_gtls_str_cpy (tmpbuffer3, sizeof (tmpbuffer3), tmpbuffer2);
+          MHD_gtls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".type");
 
           len = sizeof (oid) - 1;
-          result = asn1_read_value (asn1_struct, tmpbuffer3, oid, &len);
+          result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer3, oid, &len);
 
           if (result == ASN1_ELEMENT_NOT_FOUND)
             break;
           else if (result != ASN1_SUCCESS)
             {
-              gnutls_assert ();
-              result = mhd_gtls_asn2err (result);
+              MHD_gnutls_assert ();
+              result = MHD_gtls_asn2err (result);
               goto cleanup;
             }
 
@@ -439,18 +439,18 @@ _gnutls_x509_parse_dn_oid (ASN1_TYPE asn1_struct,
 
               /* Read the Value
                */
-              mhd_gtls_str_cpy (tmpbuffer3, sizeof (tmpbuffer3), tmpbuffer2);
-              mhd_gtls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".value");
+              MHD_gtls_str_cpy (tmpbuffer3, sizeof (tmpbuffer3), tmpbuffer2);
+              MHD_gtls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".value");
 
               len = *sizeof_buf;
-              result = asn1_read_value (asn1_struct, tmpbuffer3, buf, &len);
+              result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer3, buf, &len);
 
               if (result != ASN1_SUCCESS)
                 {
-                  gnutls_assert ();
+                  MHD_gnutls_assert ();
                   if (result == ASN1_MEM_ERROR)
                     *sizeof_buf = len;
-                  result = mhd_gtls_asn2err (result);
+                  result = MHD_gtls_asn2err (result);
                   goto cleanup;
                 }
 
@@ -469,19 +469,19 @@ _gnutls_x509_parse_dn_oid (ASN1_TYPE asn1_struct,
                 }
               else
                 {               /* parse data. raw_flag == 0 */
-                  printable = _gnutls_x509_oid_data_printable (oid);
+                  printable = MHD__gnutls_x509_oid_data_printable (oid);
 
                   if (printable == 1)
                     result =
-                      _gnutls_x509_oid_data2string (oid, buf, len,
+                      MHD__gnutls_x509_oid_data2string (oid, buf, len,
                                                     cbuf, sizeof_buf);
                   else
                     result =
-                      _gnutls_x509_data2hex (buf, len, cbuf, sizeof_buf);
+                      MHD__gnutls_x509_data2hex (buf, len, cbuf, sizeof_buf);
 
                   if (result < 0)
                     {
-                      gnutls_assert ();
+                      MHD_gnutls_assert ();
                       goto cleanup;
                     }
 
@@ -495,7 +495,7 @@ _gnutls_x509_parse_dn_oid (ASN1_TYPE asn1_struct,
     }
   while (1);
 
-  gnutls_assert ();
+  MHD_gnutls_assert ();
 
   result = GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE;
 
@@ -504,18 +504,18 @@ cleanup:
 }
 
 
-/* Parses an X509 DN in the asn1_struct, and returns the requested
+/* Parses an X509 DN in the MHD__asn1_struct, and returns the requested
  * DN OID.
  *
- * asn1_rdn_name must be a string in the form "tbsCertificate.issuer.rdnSequence".
+ * MHD__asn1_rdn_name must be a string in the form "tbsCertificate.issuer.rdnSequence".
  * That is to point in the rndSequence.
  *
  * indx specifies which OID to return. Ie 0 means return the first specified
  * OID found, 1 the second etc.
  */
 int
-_gnutls_x509_get_dn_oid (ASN1_TYPE asn1_struct,
-                         const char *asn1_rdn_name,
+MHD__gnutls_x509_get_dn_oid (ASN1_TYPE MHD__asn1_struct,
+                         const char *MHD__asn1_rdn_name,
                          int indx, void *_oid, size_t * sizeof_oid)
 {
   int k2, k1, result;
@@ -534,25 +534,25 @@ _gnutls_x509_get_dn_oid (ASN1_TYPE asn1_struct,
       k1++;
       /* create a string like "tbsCertList.issuer.rdnSequence.?1"
        */
-      if (asn1_rdn_name[0] != 0)
-        snprintf (tmpbuffer1, sizeof (tmpbuffer1), "%s.?%u", asn1_rdn_name,
+      if (MHD__asn1_rdn_name[0] != 0)
+        snprintf (tmpbuffer1, sizeof (tmpbuffer1), "%s.?%u", MHD__asn1_rdn_name,
                   k1);
       else
         snprintf (tmpbuffer1, sizeof (tmpbuffer1), "?%u", k1);
 
       len = sizeof (value) - 1;
-      result = asn1_read_value (asn1_struct, tmpbuffer1, value, &len);
+      result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer1, value, &len);
 
       if (result == ASN1_ELEMENT_NOT_FOUND)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           break;
         }
 
       if (result != ASN1_VALUE_NOT_FOUND)
         {
-          gnutls_assert ();
-          result = mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          result = MHD_gtls_asn2err (result);
           goto cleanup;
         }
 
@@ -573,7 +573,7 @@ _gnutls_x509_get_dn_oid (ASN1_TYPE asn1_struct,
            */
 
           len = sizeof (value) - 1;
-          result = asn1_read_value (asn1_struct, tmpbuffer2, value, &len);
+          result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer2, value, &len);
 
           if (result == ASN1_ELEMENT_NOT_FOUND)
             {
@@ -581,25 +581,25 @@ _gnutls_x509_get_dn_oid (ASN1_TYPE asn1_struct,
             }
           if (result != ASN1_VALUE_NOT_FOUND)
             {
-              gnutls_assert ();
-              result = mhd_gtls_asn2err (result);
+              MHD_gnutls_assert ();
+              result = MHD_gtls_asn2err (result);
               goto cleanup;
             }
 
           /* Read the OID
            */
-          mhd_gtls_str_cpy (tmpbuffer3, sizeof (tmpbuffer3), tmpbuffer2);
-          mhd_gtls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".type");
+          MHD_gtls_str_cpy (tmpbuffer3, sizeof (tmpbuffer3), tmpbuffer2);
+          MHD_gtls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".type");
 
           len = sizeof (oid) - 1;
-          result = asn1_read_value (asn1_struct, tmpbuffer3, oid, &len);
+          result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer3, oid, &len);
 
           if (result == ASN1_ELEMENT_NOT_FOUND)
             break;
           else if (result != ASN1_SUCCESS)
             {
-              gnutls_assert ();
-              result = mhd_gtls_asn2err (result);
+              MHD_gnutls_assert ();
+              result = MHD_gtls_asn2err (result);
               goto cleanup;
             }
 
@@ -611,7 +611,7 @@ _gnutls_x509_get_dn_oid (ASN1_TYPE asn1_struct,
               if (*sizeof_oid < (unsigned) len)
                 {
                   *sizeof_oid = len;
-                  gnutls_assert ();
+                  MHD_gnutls_assert ();
                   return GNUTLS_E_SHORT_MEMORY_BUFFER;
                 }
 
@@ -626,7 +626,7 @@ _gnutls_x509_get_dn_oid (ASN1_TYPE asn1_struct,
     }
   while (1);
 
-  gnutls_assert ();
+  MHD_gnutls_assert ();
 
   result = GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE;
 
@@ -639,8 +639,8 @@ cleanup:
  * In all cases only one value is written.
  */
 int
-_gnutls_x509_encode_and_write_attribute (const char *given_oid,
-                                         ASN1_TYPE asn1_struct,
+MHD__gnutls_x509_encode_and_write_attribute (const char *given_oid,
+                                         ASN1_TYPE MHD__asn1_struct,
                                          const char *where,
                                          const void *_data,
                                          int sizeof_data, int multi)
@@ -654,26 +654,26 @@ _gnutls_x509_encode_and_write_attribute (const char *given_oid,
 
   /* Find how to encode the data.
    */
-  val_name = asn1_find_structure_from_oid (_gnutls_get_pkix (), given_oid);
+  val_name = MHD__asn1_find_structure_from_oid (MHD__gnutls_get_pkix (), given_oid);
   if (val_name == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_X509_UNSUPPORTED_OID;
     }
 
-  mhd_gtls_str_cpy (tmp, sizeof (tmp), "PKIX1.");
-  mhd_gtls_str_cat (tmp, sizeof (tmp), val_name);
+  MHD_gtls_str_cpy (tmp, sizeof (tmp), "PKIX1.");
+  MHD_gtls_str_cat (tmp, sizeof (tmp), val_name);
 
-  result = asn1_create_element (_gnutls_get_pkix (), tmp, &c2);
+  result = MHD__asn1_create_element (MHD__gnutls_get_pkix (), tmp, &c2);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   tmp[0] = 0;
 
-  if ((result = _gnutls_x509_oid_data_choice (given_oid)) > 0)
+  if ((result = MHD__gnutls_x509_oid_data_choice (given_oid)) > 0)
     {
       char *string_type;
       int i;
@@ -695,64 +695,64 @@ _gnutls_x509_encode_and_write_attribute (const char *given_oid,
       /* if the type is a CHOICE then write the
        * type we'll use.
        */
-      result = asn1_write_value (c2, "", string_type, 1);
+      result = MHD__asn1_write_value (c2, "", string_type, 1);
       if (result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          asn1_delete_structure (&c2);
-          return mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          MHD__asn1_delete_structure (&c2);
+          return MHD_gtls_asn2err (result);
         }
 
-      mhd_gtls_str_cpy (tmp, sizeof (tmp), string_type);
+      MHD_gtls_str_cpy (tmp, sizeof (tmp), string_type);
     }
 
-  result = asn1_write_value (c2, tmp, data, sizeof_data);
+  result = MHD__asn1_write_value (c2, tmp, data, sizeof_data);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&c2);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&c2);
+      return MHD_gtls_asn2err (result);
     }
 
 
   /* write the data (value)
    */
 
-  mhd_gtls_str_cpy (tmp, sizeof (tmp), where);
-  mhd_gtls_str_cat (tmp, sizeof (tmp), ".value");
+  MHD_gtls_str_cpy (tmp, sizeof (tmp), where);
+  MHD_gtls_str_cat (tmp, sizeof (tmp), ".value");
 
   if (multi != 0)
     {                           /* if not writing an AttributeTypeAndValue, but an Attribute */
-      mhd_gtls_str_cat (tmp, sizeof (tmp), "s");        /* values */
+      MHD_gtls_str_cat (tmp, sizeof (tmp), "s");        /* values */
 
-      result = asn1_write_value (asn1_struct, tmp, "NEW", 1);
+      result = MHD__asn1_write_value (MHD__asn1_struct, tmp, "NEW", 1);
       if (result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          return mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          return MHD_gtls_asn2err (result);
         }
 
-      mhd_gtls_str_cat (tmp, sizeof (tmp), ".?LAST");
+      MHD_gtls_str_cat (tmp, sizeof (tmp), ".?LAST");
 
     }
 
-  result = _gnutls_x509_der_encode_and_copy (c2, "", asn1_struct, tmp, 0);
+  result = MHD__gnutls_x509_der_encode_and_copy (c2, "", MHD__asn1_struct, tmp, 0);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
   /* write the type
    */
-  mhd_gtls_str_cpy (tmp, sizeof (tmp), where);
-  mhd_gtls_str_cat (tmp, sizeof (tmp), ".type");
+  MHD_gtls_str_cpy (tmp, sizeof (tmp), where);
+  MHD_gtls_str_cat (tmp, sizeof (tmp), ".type");
 
-  result = asn1_write_value (asn1_struct, tmp, given_oid, 1);
+  result = MHD__asn1_write_value (MHD__asn1_struct, tmp, given_oid, 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   return 0;
@@ -762,8 +762,8 @@ _gnutls_x509_encode_and_write_attribute (const char *given_oid,
  * In all cases only one value is written.
  */
 static int
-_gnutls_x509_write_attribute (const char *given_oid,
-                              ASN1_TYPE asn1_struct, const char *where,
+MHD__gnutls_x509_write_attribute (const char *given_oid,
+                              ASN1_TYPE MHD__asn1_struct, const char *where,
                               const void *_data, int sizeof_data)
 {
   char tmp[128];
@@ -772,26 +772,26 @@ _gnutls_x509_write_attribute (const char *given_oid,
   /* write the data (value)
    */
 
-  mhd_gtls_str_cpy (tmp, sizeof (tmp), where);
-  mhd_gtls_str_cat (tmp, sizeof (tmp), ".value");
+  MHD_gtls_str_cpy (tmp, sizeof (tmp), where);
+  MHD_gtls_str_cat (tmp, sizeof (tmp), ".value");
 
-  result = asn1_write_value (asn1_struct, tmp, _data, sizeof_data);
+  result = MHD__asn1_write_value (MHD__asn1_struct, tmp, _data, sizeof_data);
   if (result < 0)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   /* write the type
    */
-  mhd_gtls_str_cpy (tmp, sizeof (tmp), where);
-  mhd_gtls_str_cat (tmp, sizeof (tmp), ".type");
+  MHD_gtls_str_cpy (tmp, sizeof (tmp), where);
+  MHD_gtls_str_cat (tmp, sizeof (tmp), ".type");
 
-  result = asn1_write_value (asn1_struct, tmp, given_oid, 1);
+  result = MHD__asn1_write_value (MHD__asn1_struct, tmp, given_oid, 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   return 0;
@@ -807,9 +807,9 @@ _gnutls_x509_write_attribute (const char *given_oid,
  * The output is allocated and stored in value.
  */
 int
-_gnutls_x509_decode_and_read_attribute (ASN1_TYPE asn1_struct,
+MHD__gnutls_x509_decode_and_read_attribute (ASN1_TYPE MHD__asn1_struct,
                                         const char *where, char *oid,
-                                        int oid_size, gnutls_datum_t * value,
+                                        int oid_size, MHD_gnutls_datum_t * value,
                                         int multi, int octet_string)
 {
   char tmpbuffer[128];
@@ -817,33 +817,33 @@ _gnutls_x509_decode_and_read_attribute (ASN1_TYPE asn1_struct,
 
   /* Read the OID
    */
-  mhd_gtls_str_cpy (tmpbuffer, sizeof (tmpbuffer), where);
-  mhd_gtls_str_cat (tmpbuffer, sizeof (tmpbuffer), ".type");
+  MHD_gtls_str_cpy (tmpbuffer, sizeof (tmpbuffer), where);
+  MHD_gtls_str_cat (tmpbuffer, sizeof (tmpbuffer), ".type");
 
   len = oid_size - 1;
-  result = asn1_read_value (asn1_struct, tmpbuffer, oid, &len);
+  result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer, oid, &len);
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       return result;
     }
 
   /* Read the Value
    */
 
-  mhd_gtls_str_cpy (tmpbuffer, sizeof (tmpbuffer), where);
-  mhd_gtls_str_cat (tmpbuffer, sizeof (tmpbuffer), ".value");
+  MHD_gtls_str_cpy (tmpbuffer, sizeof (tmpbuffer), where);
+  MHD_gtls_str_cat (tmpbuffer, sizeof (tmpbuffer), ".value");
 
   if (multi)
-    mhd_gtls_str_cat (tmpbuffer, sizeof (tmpbuffer), "s.?1");   /* .values.?1 */
+    MHD_gtls_str_cat (tmpbuffer, sizeof (tmpbuffer), "s.?1");   /* .values.?1 */
 
   result =
-    _gnutls_x509_read_value (asn1_struct, tmpbuffer, value, octet_string);
+    MHD__gnutls_x509_read_value (MHD__asn1_struct, tmpbuffer, value, octet_string);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -851,83 +851,83 @@ _gnutls_x509_decode_and_read_attribute (ASN1_TYPE asn1_struct,
 
 }
 
-/* Sets an X509 DN in the asn1_struct, and puts the given OID in the DN.
+/* Sets an X509 DN in the MHD__asn1_struct, and puts the given OID in the DN.
  * The input is assumed to be raw data.
  *
- * asn1_rdn_name must be a string in the form "tbsCertificate.issuer".
+ * MHD__asn1_rdn_name must be a string in the form "tbsCertificate.issuer".
  * That is to point before the rndSequence.
  *
  */
 int
-_gnutls_x509_set_dn_oid (ASN1_TYPE asn1_struct,
-                         const char *asn1_name, const char *given_oid,
+MHD__gnutls_x509_set_dn_oid (ASN1_TYPE MHD__asn1_struct,
+                         const char *MHD__asn1_name, const char *given_oid,
                          int raw_flag, const char *name, int sizeof_name)
 {
   int result;
-  char tmp[MAX_NAME_SIZE], asn1_rdn_name[MAX_NAME_SIZE];
+  char tmp[MAX_NAME_SIZE], MHD__asn1_rdn_name[MAX_NAME_SIZE];
 
   if (sizeof_name == 0 || name == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   /* create the rdnSequence
    */
-  result = asn1_write_value (asn1_struct, asn1_name, "rdnSequence", 1);
+  result = MHD__asn1_write_value (MHD__asn1_struct, MHD__asn1_name, "rdnSequence", 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  mhd_gtls_str_cpy (asn1_rdn_name, sizeof (asn1_rdn_name), asn1_name);
-  mhd_gtls_str_cat (asn1_rdn_name, sizeof (asn1_rdn_name), ".rdnSequence");
+  MHD_gtls_str_cpy (MHD__asn1_rdn_name, sizeof (MHD__asn1_rdn_name), MHD__asn1_name);
+  MHD_gtls_str_cat (MHD__asn1_rdn_name, sizeof (MHD__asn1_rdn_name), ".rdnSequence");
 
   /* create a new element
    */
-  result = asn1_write_value (asn1_struct, asn1_rdn_name, "NEW", 1);
+  result = MHD__asn1_write_value (MHD__asn1_struct, MHD__asn1_rdn_name, "NEW", 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  mhd_gtls_str_cpy (tmp, sizeof (tmp), asn1_rdn_name);
-  mhd_gtls_str_cat (tmp, sizeof (tmp), ".?LAST");
+  MHD_gtls_str_cpy (tmp, sizeof (tmp), MHD__asn1_rdn_name);
+  MHD_gtls_str_cat (tmp, sizeof (tmp), ".?LAST");
 
   /* create the set with only one element
    */
-  result = asn1_write_value (asn1_struct, tmp, "NEW", 1);
+  result = MHD__asn1_write_value (MHD__asn1_struct, tmp, "NEW", 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
 
   /* Encode and write the data
    */
-  mhd_gtls_str_cpy (tmp, sizeof (tmp), asn1_rdn_name);
-  mhd_gtls_str_cat (tmp, sizeof (tmp), ".?LAST.?LAST");
+  MHD_gtls_str_cpy (tmp, sizeof (tmp), MHD__asn1_rdn_name);
+  MHD_gtls_str_cat (tmp, sizeof (tmp), ".?LAST.?LAST");
 
   if (!raw_flag)
     {
       result =
-        _gnutls_x509_encode_and_write_attribute (given_oid,
-                                                 asn1_struct,
+        MHD__gnutls_x509_encode_and_write_attribute (given_oid,
+                                                 MHD__asn1_struct,
                                                  tmp, name, sizeof_name, 0);
     }
   else
     {
       result =
-        _gnutls_x509_write_attribute (given_oid, asn1_struct,
+        MHD__gnutls_x509_write_attribute (given_oid, MHD__asn1_struct,
                                       tmp, name, sizeof_name);
     }
 
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -936,7 +936,7 @@ _gnutls_x509_set_dn_oid (ASN1_TYPE asn1_struct,
 
 
 /**
-  * gnutls_x509_rdn_get - This function parses an RDN sequence and returns a string
+  * MHD_gnutls_x509_rdn_get - This function parses an RDN sequence and returns a string
   * @idn: should contain a DER encoded RDN sequence
   * @buf: a pointer to a structure to hold the peer's name
   * @sizeof_buf: holds the size of @buf
@@ -951,7 +951,7 @@ _gnutls_x509_set_dn_oid (ASN1_TYPE asn1_struct,
   *
   **/
 int
-gnutls_x509_rdn_get (const gnutls_datum_t * idn,
+MHD_gnutls_x509_rdn_get (const MHD_gnutls_datum_t * idn,
                      char *buf, size_t * sizeof_buf)
 {
   int result;
@@ -959,7 +959,7 @@ gnutls_x509_rdn_get (const gnutls_datum_t * idn,
 
   if (sizeof_buf == 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -968,31 +968,31 @@ gnutls_x509_rdn_get (const gnutls_datum_t * idn,
 
 
   if ((result =
-       asn1_create_element (_gnutls_get_pkix (),
+       MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                             "PKIX1.Name", &dn)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  result = asn1_der_decoding (&dn, idn->data, idn->size, NULL);
+  result = MHD__asn1_der_decoding (&dn, idn->data, idn->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 = _gnutls_x509_parse_dn (dn, "rdnSequence", buf, sizeof_buf);
+  result = MHD__gnutls_x509_parse_dn (dn, "rdnSequence", buf, sizeof_buf);
 
-  asn1_delete_structure (&dn);
+  MHD__asn1_delete_structure (&dn);
   return result;
 
 }
 
 /**
-  * gnutls_x509_rdn_get_by_oid - This function parses an RDN sequence and returns a string
+  * MHD_gnutls_x509_rdn_get_by_oid - This function parses an RDN sequence and returns a string
   * @idn: should contain a DER encoded RDN sequence
   * @oid: an Object Identifier
   * @indx: In case multiple same OIDs exist in the RDN indicates which
@@ -1010,7 +1010,7 @@ gnutls_x509_rdn_get (const gnutls_datum_t * idn,
   *
   **/
 int
-gnutls_x509_rdn_get_by_oid (const gnutls_datum_t * idn, const char *oid,
+MHD_gnutls_x509_rdn_get_by_oid (const MHD_gnutls_datum_t * idn, const char *oid,
                             int indx, unsigned int raw_flag,
                             void *buf, size_t * sizeof_buf)
 {
@@ -1023,33 +1023,33 @@ gnutls_x509_rdn_get_by_oid (const gnutls_datum_t * idn, const char *oid,
     }
 
   if ((result =
-       asn1_create_element (_gnutls_get_pkix (),
+       MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                             "PKIX1.Name", &dn)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  result = asn1_der_decoding (&dn, idn->data, idn->size, NULL);
+  result = MHD__asn1_der_decoding (&dn, idn->data, idn->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 =
-    _gnutls_x509_parse_dn_oid (dn, "rdnSequence", oid, indx,
+    MHD__gnutls_x509_parse_dn_oid (dn, "rdnSequence", oid, indx,
                                raw_flag, buf, sizeof_buf);
 
-  asn1_delete_structure (&dn);
+  MHD__asn1_delete_structure (&dn);
   return result;
 
 }
 
 /**
-  * gnutls_x509_rdn_get_oid - This function parses an RDN sequence and returns an OID.
+  * MHD_gnutls_x509_rdn_get_oid - This function parses an RDN sequence and returns an OID.
   * @idn: should contain a DER encoded RDN sequence
   * @indx: Indicates which OID to return. Use 0 for the first one.
   * @oid: a pointer to a structure to hold the peer's name OID
@@ -1063,7 +1063,7 @@ gnutls_x509_rdn_get_by_oid (const gnutls_datum_t * idn, const char *oid,
   *
   **/
 int
-gnutls_x509_rdn_get_oid (const gnutls_datum_t * idn,
+MHD_gnutls_x509_rdn_get_oid (const MHD_gnutls_datum_t * idn,
                          int indx, void *buf, size_t * sizeof_buf)
 {
   int result;
@@ -1075,25 +1075,25 @@ gnutls_x509_rdn_get_oid (const gnutls_datum_t * idn,
     }
 
   if ((result =
-       asn1_create_element (_gnutls_get_pkix (),
+       MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                             "PKIX1.Name", &dn)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  result = asn1_der_decoding (&dn, idn->data, idn->size, NULL);
+  result = MHD__asn1_der_decoding (&dn, idn->data, idn->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 = _gnutls_x509_get_dn_oid (dn, "rdnSequence", indx, buf, sizeof_buf);
+  result = MHD__gnutls_x509_get_dn_oid (dn, "rdnSequence", indx, buf, sizeof_buf);
 
-  asn1_delete_structure (&dn);
+  MHD__asn1_delete_structure (&dn);
   return result;
 
 }
@@ -1107,18 +1107,18 @@ gnutls_x509_rdn_get_oid (const gnutls_datum_t * idn,
  * a negative value is returned to indicate error.
  */
 int
-_gnutls_x509_compare_raw_dn (const gnutls_datum_t * dn1,
-                             const gnutls_datum_t * dn2)
+MHD__gnutls_x509_compare_raw_dn (const MHD_gnutls_datum_t * dn1,
+                             const MHD_gnutls_datum_t * dn2)
 {
 
   if (dn1->size != dn2->size)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return 0;
     }
   if (memcmp (dn1->data, dn2->data, dn2->size) != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return 0;
     }
   return 1;                     /* they match */
diff --git a/src/daemon/https/x509/dn.h b/src/daemon/https/x509/dn.h
index 97f85e16..04352b10 100644
--- a/src/daemon/https/x509/dn.h
+++ b/src/daemon/https/x509/dn.h
@@ -37,21 +37,21 @@
 #define OID_LDAP_UID                    "0.9.2342.19200300.100.1.1"
 #define OID_PKCS9_EMAIL                         "1.2.840.113549.1.9.1"
 
-int _gnutls_x509_parse_dn (ASN1_TYPE asn1_struct,
-                           const char *asn1_rdn_name, char *buf,
+int MHD__gnutls_x509_parse_dn (ASN1_TYPE MHD__asn1_struct,
+                           const char *MHD__asn1_rdn_name, char *buf,
                            size_t * sizeof_buf);
 
-int _gnutls_x509_parse_dn_oid (ASN1_TYPE asn1_struct,
-                               const char *asn1_rdn_name, const char *oid,
+int MHD__gnutls_x509_parse_dn_oid (ASN1_TYPE MHD__asn1_struct,
+                               const char *MHD__asn1_rdn_name, const char *oid,
                                int indx, unsigned int raw_flag, void *buf,
                                size_t * sizeof_buf);
 
-int _gnutls_x509_set_dn_oid (ASN1_TYPE asn1_struct,
-                             const char *asn1_rdn_name, const char *oid,
+int MHD__gnutls_x509_set_dn_oid (ASN1_TYPE MHD__asn1_struct,
+                             const char *MHD__asn1_rdn_name, const char *oid,
                              int raw_flag, const char *name, int sizeof_name);
 
-int _gnutls_x509_get_dn_oid (ASN1_TYPE asn1_struct,
-                             const char *asn1_rdn_name,
+int MHD__gnutls_x509_get_dn_oid (ASN1_TYPE MHD__asn1_struct,
+                             const char *MHD__asn1_rdn_name,
                              int indx, void *_oid, size_t * sizeof_oid);
 
 
diff --git a/src/daemon/https/x509/dsa.c b/src/daemon/https/x509/dsa.c
index d65bcede..d344c38f 100644
--- a/src/daemon/https/x509/dsa.c
+++ b/src/daemon/https/x509/dsa.c
@@ -33,7 +33,7 @@
 /* resarr will contain: p(0), q(1), g(2), y(3), x(4).
  */
 int
-_gnutls_dsa_generate_params (mpi_t * resarr, int *resarr_len, int bits)
+MHD__gnutls_dsa_generate_params (mpi_t * resarr, int *resarr_len, int bits)
 {
 
   int ret;
@@ -42,20 +42,20 @@ _gnutls_dsa_generate_params (mpi_t * resarr, int *resarr_len, int bits)
   /* FIXME: Remove me once we depend on 1.3.1 */
   if (bits > 1024 && gcry_check_version ("1.3.1") == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   if (bits < 512)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   ret = gcry_sexp_build (&parms, NULL, "(genkey(dsa(nbits %d)))", bits);
   if (ret != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
@@ -66,14 +66,14 @@ _gnutls_dsa_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, "p", 0);
   if (list == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       gcry_sexp_release (key);
       return GNUTLS_E_INTERNAL_ERROR;
     }
@@ -84,7 +84,7 @@ _gnutls_dsa_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;
     }
@@ -95,7 +95,7 @@ _gnutls_dsa_generate_params (mpi_t * resarr, int *resarr_len, int bits)
   list = gcry_sexp_find_token (key, "g", 0);
   if (list == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       gcry_sexp_release (key);
       return GNUTLS_E_INTERNAL_ERROR;
     }
@@ -106,7 +106,7 @@ _gnutls_dsa_generate_params (mpi_t * resarr, int *resarr_len, int bits)
   list = gcry_sexp_find_token (key, "y", 0);
   if (list == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       gcry_sexp_release (key);
       return GNUTLS_E_INTERNAL_ERROR;
     }
@@ -118,7 +118,7 @@ _gnutls_dsa_generate_params (mpi_t * resarr, int *resarr_len, int bits)
   list = gcry_sexp_find_token (key, "x", 0);
   if (list == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       gcry_sexp_release (key);
       return GNUTLS_E_INTERNAL_ERROR;
     }
@@ -129,11 +129,11 @@ _gnutls_dsa_generate_params (mpi_t * resarr, int *resarr_len, int bits)
 
   gcry_sexp_release (key);
 
-  _gnutls_dump_mpi ("p: ", resarr[0]);
-  _gnutls_dump_mpi ("q: ", resarr[1]);
-  _gnutls_dump_mpi ("g: ", resarr[2]);
-  _gnutls_dump_mpi ("y: ", resarr[3]);
-  _gnutls_dump_mpi ("x: ", resarr[4]);
+  MHD__gnutls_dump_mpi ("p: ", resarr[0]);
+  MHD__gnutls_dump_mpi ("q: ", resarr[1]);
+  MHD__gnutls_dump_mpi ("g: ", resarr[2]);
+  MHD__gnutls_dump_mpi ("y: ", resarr[3]);
+  MHD__gnutls_dump_mpi ("x: ", resarr[4]);
 
   *resarr_len = 5;
 
diff --git a/src/daemon/https/x509/dsa.h b/src/daemon/https/x509/dsa.h
index 5489ffa3..bed87a7d 100644
--- a/src/daemon/https/x509/dsa.h
+++ b/src/daemon/https/x509/dsa.h
@@ -22,4 +22,4 @@
  *
  */
 
-int _gnutls_dsa_generate_params (mpi_t * resarr, int *resarr_len, int bits);
+int MHD__gnutls_dsa_generate_params (mpi_t * resarr, int *resarr_len, int bits);
diff --git a/src/daemon/https/x509/extensions.c b/src/daemon/https/x509/extensions.c
index 5cf170af..f22fac36 100644
--- a/src/daemon/https/x509/extensions.c
+++ b/src/daemon/https/x509/extensions.c
@@ -45,9 +45,9 @@
  * be returned.
  */
 int
-_gnutls_x509_crt_get_extension (gnutls_x509_crt_t cert,
+MHD__gnutls_x509_crt_get_extension (MHD_gnutls_x509_crt_t cert,
                                 const char *extension_id, int indx,
-                                gnutls_datum_t * ret, unsigned int *_critical)
+                                MHD_gnutls_datum_t * ret, unsigned int *_critical)
 {
   int k, result, len;
   char name[MAX_NAME_SIZE], name2[MAX_NAME_SIZE];
@@ -55,7 +55,7 @@ _gnutls_x509_crt_get_extension (gnutls_x509_crt_t cert,
   char str_critical[10];
   int critical = 0;
   char extnID[128];
-  gnutls_datum_t value;
+  MHD_gnutls_datum_t value;
   int indx_counter = 0;
 
   ret->data = NULL;
@@ -69,7 +69,7 @@ _gnutls_x509_crt_get_extension (gnutls_x509_crt_t cert,
       snprintf (name, sizeof (name), "tbsCertificate.extensions.?%u", k);
 
       len = sizeof (str) - 1;
-      result = asn1_read_value (cert->cert, name, str, &len);
+      result = MHD__asn1_read_value (cert->cert, name, str, &len);
 
       /* move to next
        */
@@ -82,21 +82,21 @@ _gnutls_x509_crt_get_extension (gnutls_x509_crt_t cert,
       do
         {
 
-          mhd_gtls_str_cpy (name2, sizeof (name2), name);
-          mhd_gtls_str_cat (name2, sizeof (name2), ".extnID");
+          MHD_gtls_str_cpy (name2, sizeof (name2), name);
+          MHD_gtls_str_cat (name2, sizeof (name2), ".extnID");
 
           len = sizeof (extnID) - 1;
-          result = asn1_read_value (cert->cert, name2, extnID, &len);
+          result = MHD__asn1_read_value (cert->cert, name2, extnID, &len);
 
           if (result == ASN1_ELEMENT_NOT_FOUND)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               break;
             }
           else if (result != ASN1_SUCCESS)
             {
-              gnutls_assert ();
-              return mhd_gtls_asn2err (result);
+              MHD_gnutls_assert ();
+              return MHD_gtls_asn2err (result);
             }
 
           /* Handle Extension
@@ -108,22 +108,22 @@ _gnutls_x509_crt_get_extension (gnutls_x509_crt_t cert,
 
               /* read the critical status.
                */
-              mhd_gtls_str_cpy (name2, sizeof (name2), name);
-              mhd_gtls_str_cat (name2, sizeof (name2), ".critical");
+              MHD_gtls_str_cpy (name2, sizeof (name2), name);
+              MHD_gtls_str_cat (name2, sizeof (name2), ".critical");
 
               len = sizeof (str_critical);
               result =
-                asn1_read_value (cert->cert, name2, str_critical, &len);
+                MHD__asn1_read_value (cert->cert, name2, str_critical, &len);
 
               if (result == ASN1_ELEMENT_NOT_FOUND)
                 {
-                  gnutls_assert ();
+                  MHD_gnutls_assert ();
                   break;
                 }
               else if (result != ASN1_SUCCESS)
                 {
-                  gnutls_assert ();
-                  return mhd_gtls_asn2err (result);
+                  MHD_gnutls_assert ();
+                  return MHD_gtls_asn2err (result);
                 }
 
               if (str_critical[0] == 'T')
@@ -133,13 +133,13 @@ _gnutls_x509_crt_get_extension (gnutls_x509_crt_t cert,
 
               /* read the value.
                */
-              mhd_gtls_str_cpy (name2, sizeof (name2), name);
-              mhd_gtls_str_cat (name2, sizeof (name2), ".extnValue");
+              MHD_gtls_str_cpy (name2, sizeof (name2), name);
+              MHD_gtls_str_cat (name2, sizeof (name2), ".extnValue");
 
-              result = _gnutls_x509_read_value (cert->cert, name2, &value, 0);
+              result = MHD__gnutls_x509_read_value (cert->cert, name2, &value, 0);
               if (result < 0)
                 {
-                  gnutls_assert ();
+                  MHD_gnutls_assert ();
                   return result;
                 }
 
@@ -164,8 +164,8 @@ _gnutls_x509_crt_get_extension (gnutls_x509_crt_t cert,
     }
   else
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 }
 
@@ -176,7 +176,7 @@ _gnutls_x509_crt_get_extension (gnutls_x509_crt_t cert,
  * be returned.
  */
 int
-_gnutls_x509_crt_get_extension_oid (gnutls_x509_crt_t cert,
+MHD__gnutls_x509_crt_get_extension_oid (MHD_gnutls_x509_crt_t cert,
                                     int indx, void *oid, size_t * sizeof_oid)
 {
   int k, result, len;
@@ -193,7 +193,7 @@ _gnutls_x509_crt_get_extension_oid (gnutls_x509_crt_t cert,
       snprintf (name, sizeof (name), "tbsCertificate.extensions.?%u", k);
 
       len = sizeof (str) - 1;
-      result = asn1_read_value (cert->cert, name, str, &len);
+      result = MHD__asn1_read_value (cert->cert, name, str, &len);
 
       /* move to next
        */
@@ -206,21 +206,21 @@ _gnutls_x509_crt_get_extension_oid (gnutls_x509_crt_t cert,
       do
         {
 
-          mhd_gtls_str_cpy (name2, sizeof (name2), name);
-          mhd_gtls_str_cat (name2, sizeof (name2), ".extnID");
+          MHD_gtls_str_cpy (name2, sizeof (name2), name);
+          MHD_gtls_str_cat (name2, sizeof (name2), ".extnID");
 
           len = sizeof (extnID) - 1;
-          result = asn1_read_value (cert->cert, name2, extnID, &len);
+          result = MHD__asn1_read_value (cert->cert, name2, extnID, &len);
 
           if (result == ASN1_ELEMENT_NOT_FOUND)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               break;
             }
           else if (result != ASN1_SUCCESS)
             {
-              gnutls_assert ();
-              return mhd_gtls_asn2err (result);
+              MHD_gnutls_assert ();
+              return MHD_gtls_asn2err (result);
             }
 
           /* Handle Extension
@@ -232,7 +232,7 @@ _gnutls_x509_crt_get_extension_oid (gnutls_x509_crt_t cert,
               if (*sizeof_oid < (unsigned) len)
                 {
                   *sizeof_oid = len;
-                  gnutls_assert ();
+                  MHD_gnutls_assert ();
                   return GNUTLS_E_SHORT_MEMORY_BUFFER;
                 }
 
@@ -254,8 +254,8 @@ _gnutls_x509_crt_get_extension_oid (gnutls_x509_crt_t cert,
     }
   else
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 }
 
@@ -266,27 +266,27 @@ _gnutls_x509_crt_get_extension_oid (gnutls_x509_crt_t cert,
  */
 static int
 set_extension (ASN1_TYPE asn, const char *extension_id,
-               const gnutls_datum_t * ext_data, unsigned int critical)
+               const MHD_gnutls_datum_t * ext_data, unsigned int critical)
 {
   int result;
   const char *str;
 
   /* Add a new extension in the list.
    */
-  result = asn1_write_value (asn, "tbsCertificate.extensions", "NEW", 1);
+  result = MHD__asn1_write_value (asn, "tbsCertificate.extensions", "NEW", 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   result =
-    asn1_write_value (asn, "tbsCertificate.extensions.?LAST.extnID",
+    MHD__asn1_write_value (asn, "tbsCertificate.extensions.?LAST.extnID",
                       extension_id, 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   if (critical == 0)
@@ -296,21 +296,21 @@ set_extension (ASN1_TYPE asn, const char *extension_id,
 
 
   result =
-    asn1_write_value (asn, "tbsCertificate.extensions.?LAST.critical",
+    MHD__asn1_write_value (asn, "tbsCertificate.extensions.?LAST.critical",
                       str, 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   result =
-    _gnutls_x509_write_value (asn,
+    MHD__gnutls_x509_write_value (asn,
                               "tbsCertificate.extensions.?LAST.extnValue",
                               ext_data, 0);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -322,7 +322,7 @@ set_extension (ASN1_TYPE asn, const char *extension_id,
  */
 static int
 overwrite_extension (ASN1_TYPE asn, unsigned int indx,
-                     const gnutls_datum_t * ext_data, unsigned int critical)
+                     const MHD_gnutls_datum_t * ext_data, unsigned int critical)
 {
   char name[MAX_NAME_SIZE], name2[MAX_NAME_SIZE];
   const char *str;
@@ -335,23 +335,23 @@ overwrite_extension (ASN1_TYPE asn, unsigned int indx,
   else
     str = "TRUE";
 
-  mhd_gtls_str_cpy (name2, sizeof (name2), name);
-  mhd_gtls_str_cat (name2, sizeof (name2), ".critical");
+  MHD_gtls_str_cpy (name2, sizeof (name2), name);
+  MHD_gtls_str_cat (name2, sizeof (name2), ".critical");
 
-  result = asn1_write_value (asn, name2, str, 1);
+  result = MHD__asn1_write_value (asn, name2, str, 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  mhd_gtls_str_cpy (name2, sizeof (name2), name);
-  mhd_gtls_str_cat (name2, sizeof (name2), ".extnValue");
+  MHD_gtls_str_cpy (name2, sizeof (name2), name);
+  MHD_gtls_str_cat (name2, sizeof (name2), ".extnValue");
 
-  result = _gnutls_x509_write_value (asn, name2, ext_data, 0);
+  result = MHD__gnutls_x509_write_value (asn, name2, ext_data, 0);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -364,9 +364,9 @@ overwrite_extension (ASN1_TYPE asn, unsigned int indx,
  * Critical will be either 0 or 1.
  */
 int
-_gnutls_x509_crt_set_extension (gnutls_x509_crt_t cert,
+MHD__gnutls_x509_crt_set_extension (MHD_gnutls_x509_crt_t cert,
                                 const char *ext_id,
-                                const gnutls_datum_t * ext_data,
+                                const MHD_gnutls_datum_t * ext_data,
                                 unsigned int critical)
 {
   int result;
@@ -384,7 +384,7 @@ _gnutls_x509_crt_set_extension (gnutls_x509_crt_t cert,
       snprintf (name, sizeof (name), "tbsCertificate.extensions.?%u", k);
 
       len = sizeof (extnID) - 1;
-      result = asn1_read_value (cert->cert, name, extnID, &len);
+      result = MHD__asn1_read_value (cert->cert, name, extnID, &len);
 
       /* move to next
        */
@@ -397,21 +397,21 @@ _gnutls_x509_crt_set_extension (gnutls_x509_crt_t cert,
       do
         {
 
-          mhd_gtls_str_cpy (name2, sizeof (name2), name);
-          mhd_gtls_str_cat (name2, sizeof (name2), ".extnID");
+          MHD_gtls_str_cpy (name2, sizeof (name2), name);
+          MHD_gtls_str_cat (name2, sizeof (name2), ".extnID");
 
           len = sizeof (extnID) - 1;
-          result = asn1_read_value (cert->cert, name2, extnID, &len);
+          result = MHD__asn1_read_value (cert->cert, name2, extnID, &len);
 
           if (result == ASN1_ELEMENT_NOT_FOUND)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               break;
             }
           else if (result != ASN1_SUCCESS)
             {
-              gnutls_assert ();
-              return mhd_gtls_asn2err (result);
+              MHD_gnutls_assert ();
+              return MHD_gtls_asn2err (result);
             }
 
           /* Handle Extension
@@ -435,8 +435,8 @@ _gnutls_x509_crt_set_extension (gnutls_x509_crt_t cert,
     }
   else
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
 
@@ -448,7 +448,7 @@ _gnutls_x509_crt_set_extension (gnutls_x509_crt_t cert,
  * extension.
  */
 int
-_gnutls_x509_ext_extract_keyUsage (uint16_t * keyUsage,
+MHD__gnutls_x509_ext_extract_keyUsage (uint16_t * keyUsage,
                                    opaque * extnValue, int extnValueLen)
 {
   ASN1_TYPE ext = ASN1_TYPE_EMPTY;
@@ -458,34 +458,34 @@ _gnutls_x509_ext_extract_keyUsage (uint16_t * keyUsage,
   str[0] = str[1] = 0;
   *keyUsage = 0;
 
-  if ((result = asn1_create_element
-       (_gnutls_get_pkix (), "PKIX1.KeyUsage", &ext)) != ASN1_SUCCESS)
+  if ((result = MHD__asn1_create_element
+       (MHD__gnutls_get_pkix (), "PKIX1.KeyUsage", &ext)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  result = asn1_der_decoding (&ext, extnValue, extnValueLen, NULL);
+  result = MHD__asn1_der_decoding (&ext, extnValue, extnValueLen, NULL);
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&ext);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&ext);
+      return MHD_gtls_asn2err (result);
     }
 
   len = sizeof (str);
-  result = asn1_read_value (ext, "", str, &len);
+  result = MHD__asn1_read_value (ext, "", str, &len);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&ext);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&ext);
       return 0;
     }
 
   *keyUsage = str[0] | (str[1] << 8);
 
-  asn1_delete_structure (&ext);
+  MHD__asn1_delete_structure (&ext);
 
   return 0;
 }
@@ -493,7 +493,7 @@ _gnutls_x509_ext_extract_keyUsage (uint16_t * keyUsage,
 /* extract the basicConstraints from the DER encoded extension
  */
 int
-_gnutls_x509_ext_extract_basicConstraints (int *CA,
+MHD__gnutls_x509_ext_extract_basicConstraints (int *CA,
                                            int *pathLenConstraint,
                                            opaque * extnValue,
                                            int extnValueLen)
@@ -502,45 +502,45 @@ _gnutls_x509_ext_extract_basicConstraints (int *CA,
   char str[128];
   int len, result;
 
-  if ((result = asn1_create_element
-       (_gnutls_get_pkix (), "PKIX1.BasicConstraints", &ext)) != ASN1_SUCCESS)
+  if ((result = MHD__asn1_create_element
+       (MHD__gnutls_get_pkix (), "PKIX1.BasicConstraints", &ext)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  result = asn1_der_decoding (&ext, extnValue, extnValueLen, NULL);
+  result = MHD__asn1_der_decoding (&ext, extnValue, extnValueLen, NULL);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&ext);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&ext);
+      return MHD_gtls_asn2err (result);
     }
 
   if (pathLenConstraint)
     {
-      result = _gnutls_x509_read_uint (ext, "pathLenConstraint",
+      result = MHD__gnutls_x509_read_uint (ext, "pathLenConstraint",
                                        pathLenConstraint);
       if (result == GNUTLS_E_ASN1_ELEMENT_NOT_FOUND)
         *pathLenConstraint = -1;
       else if (result != GNUTLS_E_SUCCESS)
         {
-          gnutls_assert ();
-          asn1_delete_structure (&ext);
-          return mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          MHD__asn1_delete_structure (&ext);
+          return MHD_gtls_asn2err (result);
         }
     }
 
   /* the default value of cA is false.
    */
   len = sizeof (str) - 1;
-  result = asn1_read_value (ext, "cA", str, &len);
+  result = MHD__asn1_read_value (ext, "cA", str, &len);
   if (result == ASN1_SUCCESS && strcmp (str, "TRUE") == 0)
     *CA = 1;
   else
     *CA = 0;
 
-  asn1_delete_structure (&ext);
+  MHD__asn1_delete_structure (&ext);
 
   return 0;
 }
@@ -551,9 +551,9 @@ _gnutls_x509_ext_extract_basicConstraints (int *CA,
  * should not be present, >= 0 to indicate set values.
  */
 int
-_gnutls_x509_ext_gen_basicConstraints (int CA,
+MHD__gnutls_x509_ext_gen_basicConstraints (int CA,
                                        int pathLenConstraint,
-                                       gnutls_datum_t * der_ext)
+                                       MHD_gnutls_datum_t * der_ext)
 {
   ASN1_TYPE ext = ASN1_TYPE_EMPTY;
   const char *str;
@@ -565,44 +565,44 @@ _gnutls_x509_ext_gen_basicConstraints (int CA,
     str = "TRUE";
 
   result =
-    asn1_create_element (_gnutls_get_pkix (), "PKIX1.BasicConstraints", &ext);
+    MHD__asn1_create_element (MHD__gnutls_get_pkix (), "PKIX1.BasicConstraints", &ext);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  result = asn1_write_value (ext, "cA", str, 1);
+  result = MHD__asn1_write_value (ext, "cA", str, 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&ext);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&ext);
+      return MHD_gtls_asn2err (result);
     }
 
   if (pathLenConstraint < 0)
     {
-      result = asn1_write_value (ext, "pathLenConstraint", NULL, 0);
+      result = MHD__asn1_write_value (ext, "pathLenConstraint", NULL, 0);
       if (result < 0)
-        result = mhd_gtls_asn2err (result);
+        result = MHD_gtls_asn2err (result);
     }
   else
-    result = _gnutls_x509_write_uint32 (ext, "pathLenConstraint",
+    result = MHD__gnutls_x509_write_uint32 (ext, "pathLenConstraint",
                                         pathLenConstraint);
   if (result < 0)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&ext);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&ext);
       return result;
     }
 
-  result = _gnutls_x509_der_encode (ext, "", der_ext, 0);
+  result = MHD__gnutls_x509_der_encode (ext, "", der_ext, 0);
 
-  asn1_delete_structure (&ext);
+  MHD__asn1_delete_structure (&ext);
 
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -613,37 +613,37 @@ _gnutls_x509_ext_gen_basicConstraints (int CA,
  * Use an ORed SEQUENCE of GNUTLS_KEY_* for usage.
  */
 int
-_gnutls_x509_ext_gen_keyUsage (uint16_t usage, gnutls_datum_t * der_ext)
+MHD__gnutls_x509_ext_gen_keyUsage (uint16_t usage, MHD_gnutls_datum_t * der_ext)
 {
   ASN1_TYPE ext = ASN1_TYPE_EMPTY;
   int result;
   uint8_t str[2];
 
-  result = asn1_create_element (_gnutls_get_pkix (), "PKIX1.KeyUsage", &ext);
+  result = MHD__asn1_create_element (MHD__gnutls_get_pkix (), "PKIX1.KeyUsage", &ext);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   str[0] = usage & 0xff;
   str[1] = usage >> 8;
 
-  result = asn1_write_value (ext, "", str, 9);
+  result = MHD__asn1_write_value (ext, "", str, 9);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&ext);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&ext);
+      return MHD_gtls_asn2err (result);
     }
 
-  result = _gnutls_x509_der_encode (ext, "", der_ext, 0);
+  result = MHD__gnutls_x509_der_encode (ext, "", der_ext, 0);
 
-  asn1_delete_structure (&ext);
+  MHD__asn1_delete_structure (&ext);
 
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -652,18 +652,18 @@ _gnutls_x509_ext_gen_keyUsage (uint16_t usage, gnutls_datum_t * der_ext)
 
 static int
 write_new_general_name (ASN1_TYPE ext, const char *ext_name,
-                        gnutls_x509_subject_alt_name_t type,
+                        MHD_gnutls_x509_subject_alt_name_t type,
                         const char *data_string)
 {
   const char *str;
   int result;
   char name[128];
 
-  result = asn1_write_value (ext, ext_name, "NEW", 1);
+  result = MHD__asn1_write_value (ext, ext_name, "NEW", 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   switch (type)
@@ -681,36 +681,36 @@ write_new_general_name (ASN1_TYPE ext, const char *ext_name,
       str = "iPAddress";
       break;
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
   if (ext_name[0] == 0)
     {                           /* no dot */
-      mhd_gtls_str_cpy (name, sizeof (name), "?LAST");
+      MHD_gtls_str_cpy (name, sizeof (name), "?LAST");
     }
   else
     {
-      mhd_gtls_str_cpy (name, sizeof (name), ext_name);
-      mhd_gtls_str_cat (name, sizeof (name), ".?LAST");
+      MHD_gtls_str_cpy (name, sizeof (name), ext_name);
+      MHD_gtls_str_cat (name, sizeof (name), ".?LAST");
     }
 
-  result = asn1_write_value (ext, name, str, 1);
+  result = MHD__asn1_write_value (ext, name, str, 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  mhd_gtls_str_cat (name, sizeof (name), ".");
-  mhd_gtls_str_cat (name, sizeof (name), str);
+  MHD_gtls_str_cat (name, sizeof (name), ".");
+  MHD_gtls_str_cat (name, sizeof (name), str);
 
-  result = asn1_write_value (ext, name, data_string, strlen (data_string));
+  result = MHD__asn1_write_value (ext, name, data_string, strlen (data_string));
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&ext);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&ext);
+      return MHD_gtls_asn2err (result);
     }
 
   return 0;
@@ -720,36 +720,36 @@ write_new_general_name (ASN1_TYPE ext, const char *ext_name,
  * This is the same as subject alternative name.
  */
 int
-_gnutls_x509_ext_gen_subject_alt_name (gnutls_x509_subject_alt_name_t
+MHD__gnutls_x509_ext_gen_subject_alt_name (MHD_gnutls_x509_subject_alt_name_t
                                        type, const char *data_string,
-                                       gnutls_datum_t * der_ext)
+                                       MHD_gnutls_datum_t * der_ext)
 {
   ASN1_TYPE ext = ASN1_TYPE_EMPTY;
   int result;
 
   result =
-    asn1_create_element (_gnutls_get_pkix (), "PKIX1.GeneralNames", &ext);
+    MHD__asn1_create_element (MHD__gnutls_get_pkix (), "PKIX1.GeneralNames", &ext);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   result = write_new_general_name (ext, "", type, data_string);
   if (result < 0)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&ext);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&ext);
       return result;
     }
 
-  result = _gnutls_x509_der_encode (ext, "", der_ext, 0);
+  result = MHD__gnutls_x509_der_encode (ext, "", der_ext, 0);
 
-  asn1_delete_structure (&ext);
+  MHD__asn1_delete_structure (&ext);
 
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -759,36 +759,36 @@ _gnutls_x509_ext_gen_subject_alt_name (gnutls_x509_subject_alt_name_t
 /* generate the SubjectKeyID in a DER encoded extension
  */
 int
-_gnutls_x509_ext_gen_key_id (const void *id, size_t id_size,
-                             gnutls_datum_t * der_ext)
+MHD__gnutls_x509_ext_gen_key_id (const void *id, size_t id_size,
+                             MHD_gnutls_datum_t * der_ext)
 {
   ASN1_TYPE ext = ASN1_TYPE_EMPTY;
   int result;
 
   result =
-    asn1_create_element (_gnutls_get_pkix (),
+    MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                          "PKIX1.SubjectKeyIdentifier", &ext);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  result = asn1_write_value (ext, "", id, id_size);
+  result = MHD__asn1_write_value (ext, "", id, id_size);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&ext);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&ext);
+      return MHD_gtls_asn2err (result);
     }
 
-  result = _gnutls_x509_der_encode (ext, "", der_ext, 0);
+  result = MHD__gnutls_x509_der_encode (ext, "", der_ext, 0);
 
-  asn1_delete_structure (&ext);
+  MHD__asn1_delete_structure (&ext);
 
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -798,39 +798,39 @@ _gnutls_x509_ext_gen_key_id (const void *id, size_t id_size,
 /* generate the AuthorityKeyID in a DER encoded extension
  */
 int
-_gnutls_x509_ext_gen_auth_key_id (const void *id, size_t id_size,
-                                  gnutls_datum_t * der_ext)
+MHD__gnutls_x509_ext_gen_auth_key_id (const void *id, size_t id_size,
+                                  MHD_gnutls_datum_t * der_ext)
 {
   ASN1_TYPE ext = ASN1_TYPE_EMPTY;
   int result;
 
   result =
-    asn1_create_element (_gnutls_get_pkix (),
+    MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                          "PKIX1.AuthorityKeyIdentifier", &ext);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  result = asn1_write_value (ext, "keyIdentifier", id, id_size);
+  result = MHD__asn1_write_value (ext, "keyIdentifier", id, id_size);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&ext);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&ext);
+      return MHD_gtls_asn2err (result);
     }
 
-  asn1_write_value (ext, "authorityCertIssuer", NULL, 0);
-  asn1_write_value (ext, "authorityCertSerialNumber", NULL, 0);
+  MHD__asn1_write_value (ext, "authorityCertIssuer", NULL, 0);
+  MHD__asn1_write_value (ext, "authorityCertSerialNumber", NULL, 0);
 
-  result = _gnutls_x509_der_encode (ext, "", der_ext, 0);
+  result = MHD__gnutls_x509_der_encode (ext, "", der_ext, 0);
 
-  asn1_delete_structure (&ext);
+  MHD__asn1_delete_structure (&ext);
 
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -844,13 +844,13 @@ _gnutls_x509_ext_gen_auth_key_id (const void *id, size_t id_size,
  *
  */
 int
-_gnutls_x509_ext_gen_crl_dist_points (gnutls_x509_subject_alt_name_t
+MHD__gnutls_x509_ext_gen_crl_dist_points (MHD_gnutls_x509_subject_alt_name_t
                                       type, const void *data_string,
                                       unsigned int reason_flags,
-                                      gnutls_datum_t * der_ext)
+                                      MHD_gnutls_datum_t * der_ext)
 {
   ASN1_TYPE ext = ASN1_TYPE_EMPTY;
-  gnutls_datum_t gnames = { NULL, 0 };
+  MHD_gnutls_datum_t gnames = { NULL, 0 };
   int result;
   uint8_t reasons[2];
 
@@ -858,65 +858,65 @@ _gnutls_x509_ext_gen_crl_dist_points (gnutls_x509_subject_alt_name_t
   reasons[1] = reason_flags >> 8;
 
   result =
-    asn1_create_element (_gnutls_get_pkix (),
+    MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                          "PKIX1.CRLDistributionPoints", &ext);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  result = asn1_write_value (ext, "", "NEW", 1);
+  result = MHD__asn1_write_value (ext, "", "NEW", 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   if (reason_flags)
     {
-      result = asn1_write_value (ext, "?LAST.reasons", reasons, 9);
+      result = MHD__asn1_write_value (ext, "?LAST.reasons", reasons, 9);
       if (result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          result = mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          result = MHD_gtls_asn2err (result);
           goto cleanup;
         }
     }
   else
     {
-      result = asn1_write_value (ext, "?LAST.reasons", NULL, 0);
+      result = MHD__asn1_write_value (ext, "?LAST.reasons", NULL, 0);
       if (result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          result = mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          result = MHD_gtls_asn2err (result);
           goto cleanup;
         }
     }
 
-  result = asn1_write_value (ext, "?LAST.cRLIssuer", NULL, 0);
+  result = MHD__asn1_write_value (ext, "?LAST.cRLIssuer", NULL, 0);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   /* When used as type CHOICE.
    */
-  result = asn1_write_value (ext, "?LAST.distributionPoint", "fullName", 1);
+  result = MHD__asn1_write_value (ext, "?LAST.distributionPoint", "fullName", 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
 #if 0
   /* only needed in old code (where defined as SEQUENCE OF) */
-  asn1_write_value (ext,
+  MHD__asn1_write_value (ext,
                     "?LAST.distributionPoint.nameRelativeToCRLIssuer",
                     NULL, 0);
 #endif
@@ -926,23 +926,23 @@ _gnutls_x509_ext_gen_crl_dist_points (gnutls_x509_subject_alt_name_t
                             type, data_string);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  result = _gnutls_x509_der_encode (ext, "", der_ext, 0);
+  result = MHD__gnutls_x509_der_encode (ext, "", der_ext, 0);
 
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
   result = 0;
 
 cleanup:
-  _gnutls_free_datum (&gnames);
-  asn1_delete_structure (&ext);
+  MHD__gnutls_free_datum (&gnames);
+  MHD__asn1_delete_structure (&ext);
 
   return result;
 }
@@ -950,7 +950,7 @@ cleanup:
 /* extract the proxyCertInfo from the DER encoded extension
  */
 int
-_gnutls_x509_ext_extract_proxyCertInfo (int *pathLenConstraint,
+MHD__gnutls_x509_ext_extract_proxyCertInfo (int *pathLenConstraint,
                                         char **policyLanguage,
                                         char **policy,
                                         size_t * sizeof_policy,
@@ -958,49 +958,49 @@ _gnutls_x509_ext_extract_proxyCertInfo (int *pathLenConstraint,
 {
   ASN1_TYPE ext = ASN1_TYPE_EMPTY;
   int result;
-  gnutls_datum_t value;
+  MHD_gnutls_datum_t value;
 
-  if ((result = asn1_create_element
-       (_gnutls_get_pkix (), "PKIX1.ProxyCertInfo", &ext)) != ASN1_SUCCESS)
+  if ((result = MHD__asn1_create_element
+       (MHD__gnutls_get_pkix (), "PKIX1.ProxyCertInfo", &ext)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  result = asn1_der_decoding (&ext, extnValue, extnValueLen, NULL);
+  result = MHD__asn1_der_decoding (&ext, extnValue, extnValueLen, NULL);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&ext);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&ext);
+      return MHD_gtls_asn2err (result);
     }
 
   if (pathLenConstraint)
     {
-      result = _gnutls_x509_read_uint (ext, "pCPathLenConstraint",
+      result = MHD__gnutls_x509_read_uint (ext, "pCPathLenConstraint",
                                        pathLenConstraint);
       if (result == GNUTLS_E_ASN1_ELEMENT_NOT_FOUND)
         *pathLenConstraint = -1;
       else if (result != GNUTLS_E_SUCCESS)
         {
-          asn1_delete_structure (&ext);
-          return mhd_gtls_asn2err (result);
+          MHD__asn1_delete_structure (&ext);
+          return MHD_gtls_asn2err (result);
         }
     }
 
-  result = _gnutls_x509_read_value (ext, "proxyPolicy.policyLanguage",
+  result = MHD__gnutls_x509_read_value (ext, "proxyPolicy.policyLanguage",
                                     &value, 0);
   if (result < 0)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&ext);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&ext);
       return result;
     }
 
   if (policyLanguage)
-    *policyLanguage = gnutls_strdup (value.data);
+    *policyLanguage = MHD_gnutls_strdup (value.data);
 
-  result = _gnutls_x509_read_value (ext, "proxyPolicy.policy", &value, 0);
+  result = MHD__gnutls_x509_read_value (ext, "proxyPolicy.policy", &value, 0);
   if (result == GNUTLS_E_ASN1_ELEMENT_NOT_FOUND)
     {
       if (policy)
@@ -1010,8 +1010,8 @@ _gnutls_x509_ext_extract_proxyCertInfo (int *pathLenConstraint,
     }
   else if (result < 0)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&ext);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&ext);
       return result;
     }
   else
@@ -1022,7 +1022,7 @@ _gnutls_x509_ext_extract_proxyCertInfo (int *pathLenConstraint,
         *sizeof_policy = value.size;
     }
 
-  asn1_delete_structure (&ext);
+  MHD__asn1_delete_structure (&ext);
 
   return 0;
 }
@@ -1030,64 +1030,64 @@ _gnutls_x509_ext_extract_proxyCertInfo (int *pathLenConstraint,
 /* generate the proxyCertInfo in a DER encoded extension
  */
 int
-_gnutls_x509_ext_gen_proxyCertInfo (int pathLenConstraint,
+MHD__gnutls_x509_ext_gen_proxyCertInfo (int pathLenConstraint,
                                     const char *policyLanguage,
                                     const char *policy,
                                     size_t sizeof_policy,
-                                    gnutls_datum_t * der_ext)
+                                    MHD_gnutls_datum_t * der_ext)
 {
   ASN1_TYPE ext = ASN1_TYPE_EMPTY;
   int result;
 
-  result = asn1_create_element (_gnutls_get_pkix (),
+  result = MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                                 "PKIX1.ProxyCertInfo", &ext);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   if (pathLenConstraint < 0)
     {
-      result = asn1_write_value (ext, "pCPathLenConstraint", NULL, 0);
+      result = MHD__asn1_write_value (ext, "pCPathLenConstraint", NULL, 0);
       if (result < 0)
-        result = mhd_gtls_asn2err (result);
+        result = MHD_gtls_asn2err (result);
     }
   else
-    result = _gnutls_x509_write_uint32 (ext, "pCPathLenConstraint",
+    result = MHD__gnutls_x509_write_uint32 (ext, "pCPathLenConstraint",
                                         pathLenConstraint);
   if (result < 0)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&ext);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&ext);
       return result;
     }
 
-  result = asn1_write_value (ext, "proxyPolicy.policyLanguage",
+  result = MHD__asn1_write_value (ext, "proxyPolicy.policyLanguage",
                              policyLanguage, 1);
   if (result < 0)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&ext);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&ext);
+      return MHD_gtls_asn2err (result);
     }
 
-  result = asn1_write_value (ext, "proxyPolicy.policy",
+  result = MHD__asn1_write_value (ext, "proxyPolicy.policy",
                              policy, sizeof_policy);
   if (result < 0)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&ext);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&ext);
+      return MHD_gtls_asn2err (result);
     }
 
-  result = _gnutls_x509_der_encode (ext, "", der_ext, 0);
+  result = MHD__gnutls_x509_der_encode (ext, "", der_ext, 0);
 
-  asn1_delete_structure (&ext);
+  MHD__asn1_delete_structure (&ext);
 
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
diff --git a/src/daemon/https/x509/extensions.h b/src/daemon/https/x509/extensions.h
index 143775a6..b314d0a7 100644
--- a/src/daemon/https/x509/extensions.h
+++ b/src/daemon/https/x509/extensions.h
@@ -22,47 +22,47 @@
  *
  */
 
-int _gnutls_x509_crt_get_extension (gnutls_x509_crt_t cert,
+int MHD__gnutls_x509_crt_get_extension (MHD_gnutls_x509_crt_t cert,
                                     const char *extension_id, int indx,
-                                    gnutls_datum_t * ret,
+                                    MHD_gnutls_datum_t * ret,
                                     unsigned int *critical);
 
-int _gnutls_x509_crt_get_extension_oid (gnutls_x509_crt_t cert,
+int MHD__gnutls_x509_crt_get_extension_oid (MHD_gnutls_x509_crt_t cert,
                                         int indx, void *ret,
                                         size_t * ret_size);
-int _gnutls_x509_ext_extract_keyUsage (uint16_t * keyUsage,
+int MHD__gnutls_x509_ext_extract_keyUsage (uint16_t * keyUsage,
                                        opaque * extnValue, int extnValueLen);
-int _gnutls_x509_ext_extract_basicConstraints (int *CA,
+int MHD__gnutls_x509_ext_extract_basicConstraints (int *CA,
                                                int *pathLenConstraint,
                                                opaque * extnValue,
                                                int extnValueLen);
-int _gnutls_x509_crt_set_extension (gnutls_x509_crt_t cert,
+int MHD__gnutls_x509_crt_set_extension (MHD_gnutls_x509_crt_t cert,
                                     const char *extension_id,
-                                    const gnutls_datum_t * ext_data,
+                                    const MHD_gnutls_datum_t * ext_data,
                                     unsigned int critical);
-int _gnutls_x509_ext_gen_basicConstraints (int CA, int pathLenConstraint,
-                                           gnutls_datum_t * der_ext);
-int _gnutls_x509_ext_gen_keyUsage (uint16_t usage, gnutls_datum_t * der_ext);
-int _gnutls_x509_ext_gen_subject_alt_name (gnutls_x509_subject_alt_name_t
+int MHD__gnutls_x509_ext_gen_basicConstraints (int CA, int pathLenConstraint,
+                                           MHD_gnutls_datum_t * der_ext);
+int MHD__gnutls_x509_ext_gen_keyUsage (uint16_t usage, MHD_gnutls_datum_t * der_ext);
+int MHD__gnutls_x509_ext_gen_subject_alt_name (MHD_gnutls_x509_subject_alt_name_t
                                            type, const char *data_string,
-                                           gnutls_datum_t * der_ext);
-int _gnutls_x509_ext_gen_crl_dist_points (gnutls_x509_subject_alt_name_t
+                                           MHD_gnutls_datum_t * der_ext);
+int MHD__gnutls_x509_ext_gen_crl_dist_points (MHD_gnutls_x509_subject_alt_name_t
                                           type, const void *data_string,
                                           unsigned int reason_flags,
-                                          gnutls_datum_t * der_ext);
-int _gnutls_x509_ext_gen_key_id (const void *id, size_t id_size,
-                                 gnutls_datum_t * der_data);
-int _gnutls_x509_ext_gen_auth_key_id (const void *id, size_t id_size,
-                                      gnutls_datum_t * der_data);
+                                          MHD_gnutls_datum_t * der_ext);
+int MHD__gnutls_x509_ext_gen_key_id (const void *id, size_t id_size,
+                                 MHD_gnutls_datum_t * der_data);
+int MHD__gnutls_x509_ext_gen_auth_key_id (const void *id, size_t id_size,
+                                      MHD_gnutls_datum_t * der_data);
 
-int _gnutls_x509_ext_extract_proxyCertInfo (int *pathLenConstraint,
+int MHD__gnutls_x509_ext_extract_proxyCertInfo (int *pathLenConstraint,
                                             char **policyLanguage,
                                             char **policy,
                                             size_t * sizeof_policy,
                                             opaque * extnValue,
                                             int extnValueLen);
-int _gnutls_x509_ext_gen_proxyCertInfo (int pathLenConstraint,
+int MHD__gnutls_x509_ext_gen_proxyCertInfo (int pathLenConstraint,
                                         const char *policyLanguage,
                                         const char *policy,
                                         size_t sizeof_policy,
-                                        gnutls_datum_t * der_ext);
+                                        MHD_gnutls_datum_t * der_ext);
diff --git a/src/daemon/https/x509/mpi.c b/src/daemon/https/x509/mpi.c
index c43b3dce..4e3c8cd1 100644
--- a/src/daemon/https/x509/mpi.c
+++ b/src/daemon/https/x509/mpi.c
@@ -38,45 +38,45 @@
  * Returns 2 parameters (m,e).
  */
 int
-_gnutls_x509_read_rsa_params (opaque * der, int dersize, mpi_t * params)
+MHD__gnutls_x509_read_rsa_params (opaque * der, int dersize, mpi_t * params)
 {
   int result;
   ASN1_TYPE spk = ASN1_TYPE_EMPTY;
 
   if ((result =
-       asn1_create_element (_gnutls_get_gnutls_asn (), "GNUTLS.RSAPublicKey",
+       MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (), "GNUTLS.RSAPublicKey",
                             &spk)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  result = asn1_der_decoding (&spk, der, dersize, NULL);
+  result = MHD__asn1_der_decoding (&spk, der, dersize, NULL);
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&spk);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&spk);
+      return MHD_gtls_asn2err (result);
     }
 
-  if ((result = _gnutls_x509_read_int (spk, "modulus", &params[0])) < 0)
+  if ((result = MHD__gnutls_x509_read_int (spk, "modulus", &params[0])) < 0)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&spk);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&spk);
       return GNUTLS_E_ASN1_GENERIC_ERROR;
     }
 
   if ((result =
-       _gnutls_x509_read_int (spk, "publicExponent", &params[1])) < 0)
+       MHD__gnutls_x509_read_int (spk, "publicExponent", &params[1])) < 0)
     {
-      gnutls_assert ();
-      mhd_gtls_mpi_release (&params[0]);
-      asn1_delete_structure (&spk);
+      MHD_gnutls_assert ();
+      MHD_gtls_mpi_release (&params[0]);
+      MHD__asn1_delete_structure (&spk);
       return GNUTLS_E_ASN1_GENERIC_ERROR;
     }
 
-  asn1_delete_structure (&spk);
+  MHD__asn1_delete_structure (&spk);
 
   return 0;
 
@@ -87,26 +87,26 @@ _gnutls_x509_read_rsa_params (opaque * der, int dersize, mpi_t * params)
  * params[0-2]
  */
 int
-_gnutls_x509_read_dsa_params (opaque * der, int dersize, mpi_t * params)
+MHD__gnutls_x509_read_dsa_params (opaque * der, int dersize, mpi_t * params)
 {
   int result;
   ASN1_TYPE spk = ASN1_TYPE_EMPTY;
 
   if ((result =
-       asn1_create_element (_gnutls_get_pkix (), "PKIX1.Dss-Parms",
+       MHD__asn1_create_element (MHD__gnutls_get_pkix (), "PKIX1.Dss-Parms",
                             &spk)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  result = asn1_der_decoding (&spk, der, dersize, NULL);
+  result = MHD__asn1_der_decoding (&spk, der, dersize, NULL);
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&spk);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&spk);
+      return MHD_gtls_asn2err (result);
     }
 
   /* FIXME: If the parameters are not included in the certificate
@@ -116,35 +116,35 @@ _gnutls_x509_read_dsa_params (opaque * der, int dersize, mpi_t * params)
 
   /* Read p */
 
-  if ((result = _gnutls_x509_read_int (spk, "p", &params[0])) < 0)
+  if ((result = MHD__gnutls_x509_read_int (spk, "p", &params[0])) < 0)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&spk);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&spk);
       return GNUTLS_E_ASN1_GENERIC_ERROR;
     }
 
   /* Read q */
 
-  if ((result = _gnutls_x509_read_int (spk, "q", &params[1])) < 0)
+  if ((result = MHD__gnutls_x509_read_int (spk, "q", &params[1])) < 0)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&spk);
-      mhd_gtls_mpi_release (&params[0]);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&spk);
+      MHD_gtls_mpi_release (&params[0]);
       return GNUTLS_E_ASN1_GENERIC_ERROR;
     }
 
   /* Read g */
 
-  if ((result = _gnutls_x509_read_int (spk, "g", &params[2])) < 0)
+  if ((result = MHD__gnutls_x509_read_int (spk, "g", &params[2])) < 0)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&spk);
-      mhd_gtls_mpi_release (&params[0]);
-      mhd_gtls_mpi_release (&params[1]);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&spk);
+      MHD_gtls_mpi_release (&params[0]);
+      MHD_gtls_mpi_release (&params[1]);
       return GNUTLS_E_ASN1_GENERIC_ERROR;
     }
 
-  asn1_delete_structure (&spk);
+  MHD__asn1_delete_structure (&spk);
 
   return 0;
 
@@ -154,39 +154,39 @@ _gnutls_x509_read_dsa_params (opaque * der, int dersize, mpi_t * params)
  */
 
 int
-_gnutls_x509_read_der_int (opaque * der, int dersize, mpi_t * out)
+MHD__gnutls_x509_read_der_int (opaque * der, int dersize, mpi_t * out)
 {
   int result;
   ASN1_TYPE spk = ASN1_TYPE_EMPTY;
 
   /* == INTEGER */
   if ((result =
-       asn1_create_element (_gnutls_get_gnutls_asn (), "GNUTLS.DSAPublicKey",
+       MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (), "GNUTLS.DSAPublicKey",
                             &spk)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  result = asn1_der_decoding (&spk, der, dersize, NULL);
+  result = MHD__asn1_der_decoding (&spk, der, dersize, NULL);
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&spk);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&spk);
+      return MHD_gtls_asn2err (result);
     }
 
   /* Read Y */
 
-  if ((result = _gnutls_x509_read_int (spk, "", out)) < 0)
+  if ((result = MHD__gnutls_x509_read_int (spk, "", out)) < 0)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&spk);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&spk);
+      return MHD_gtls_asn2err (result);
     }
 
-  asn1_delete_structure (&spk);
+  MHD__asn1_delete_structure (&spk);
 
   return 0;
 
@@ -197,35 +197,35 @@ _gnutls_x509_read_der_int (opaque * der, int dersize, mpi_t * out)
  * only sets params[3]
  */
 int
-_gnutls_x509_read_dsa_pubkey (opaque * der, int dersize, mpi_t * params)
+MHD__gnutls_x509_read_dsa_pubkey (opaque * der, int dersize, mpi_t * params)
 {
-  return _gnutls_x509_read_der_int (der, dersize, &params[3]);
+  return MHD__gnutls_x509_read_der_int (der, dersize, &params[3]);
 }
 
 /* Extracts DSA and RSA parameters from a certificate.
  */
 int
-_gnutls_x509_crt_get_mpis (gnutls_x509_crt_t cert,
+MHD__gnutls_x509_crt_get_mpis (MHD_gnutls_x509_crt_t cert,
                            mpi_t * params, int *params_size)
 {
   int result;
   int pk_algorithm;
-  gnutls_datum_t tmp = { NULL, 0 };
+  MHD_gnutls_datum_t tmp = { NULL, 0 };
 
   /* Read the algorithm's OID
    */
-  pk_algorithm = gnutls_x509_crt_get_pk_algorithm (cert, NULL);
+  pk_algorithm = MHD_gnutls_x509_crt_get_pk_algorithm (cert, NULL);
 
   /* Read the algorithm's parameters
    */
   result
-    = _gnutls_x509_read_value (cert->cert,
+    = MHD__gnutls_x509_read_value (cert->cert,
                                "tbsCertificate.subjectPublicKeyInfo.subjectPublicKey",
                                &tmp, 2);
 
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -237,16 +237,16 @@ _gnutls_x509_crt_get_mpis (gnutls_x509_crt_t cert,
        */
       if (*params_size < RSA_PUBLIC_PARAMS)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           /* internal error. Increase the mpi_ts in params */
           result = GNUTLS_E_INTERNAL_ERROR;
           goto error;
         }
 
       if ((result =
-           _gnutls_x509_read_rsa_params (tmp.data, tmp.size, params)) < 0)
+           MHD__gnutls_x509_read_rsa_params (tmp.data, tmp.size, params)) < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           goto error;
         }
       *params_size = RSA_PUBLIC_PARAMS;
@@ -256,14 +256,14 @@ _gnutls_x509_crt_get_mpis (gnutls_x509_crt_t cert,
       /* other types like DH
        * currently not supported
        */
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_X509_CERTIFICATE_ERROR;
       goto error;
     }
 
   result = 0;
 
-error:_gnutls_free_datum (&tmp);
+error:MHD__gnutls_free_datum (&tmp);
   return result;
 }
 
@@ -275,8 +275,8 @@ error:_gnutls_free_datum (&tmp);
  * Allocates the space used to store the DER data.
  */
 int
-_gnutls_x509_write_rsa_params (mpi_t * params,
-                               int params_size, gnutls_datum_t * der)
+MHD__gnutls_x509_write_rsa_params (mpi_t * params,
+                               int params_size, MHD_gnutls_datum_t * der)
 {
   int result;
   ASN1_TYPE spk = ASN1_TYPE_EMPTY;
@@ -286,44 +286,44 @@ _gnutls_x509_write_rsa_params (mpi_t * params,
 
   if (params_size < 2)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_INVALID_REQUEST;
       goto cleanup;
     }
 
   if ((result =
-       asn1_create_element (_gnutls_get_gnutls_asn (), "GNUTLS.RSAPublicKey",
+       MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (), "GNUTLS.RSAPublicKey",
                             &spk)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  result = _gnutls_x509_write_int (spk, "modulus", params[0], 0);
+  result = MHD__gnutls_x509_write_int (spk, "modulus", params[0], 0);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  result = _gnutls_x509_write_int (spk, "publicExponent", params[1], 0);
+  result = MHD__gnutls_x509_write_int (spk, "publicExponent", params[1], 0);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  result = _gnutls_x509_der_encode (spk, "", der, 0);
+  result = MHD__gnutls_x509_der_encode (spk, "", der, 0);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  asn1_delete_structure (&spk);
+  MHD__asn1_delete_structure (&spk);
   return 0;
 
-cleanup:asn1_delete_structure (&spk);
+cleanup:MHD__asn1_delete_structure (&spk);
 
   return result;
 }
@@ -333,7 +333,7 @@ cleanup:asn1_delete_structure (&spk);
  * This is the "signatureAlgorithm" fields.
  */
 int
-_gnutls_x509_write_sig_params (ASN1_TYPE dst,
+MHD__gnutls_x509_write_sig_params (ASN1_TYPE dst,
                                const char *dst_name,
                                enum MHD_GNUTLS_PublicKeyAlgorithm
                                pk_algorithm,
@@ -344,39 +344,39 @@ _gnutls_x509_write_sig_params (ASN1_TYPE dst,
   char name[128];
   const char *pk;
 
-  mhd_gtls_str_cpy (name, sizeof (name), dst_name);
-  mhd_gtls_str_cat (name, sizeof (name), ".algorithm");
+  MHD_gtls_str_cpy (name, sizeof (name), dst_name);
+  MHD_gtls_str_cat (name, sizeof (name), ".algorithm");
 
-  pk = mhd_gtls_x509_sign_to_oid (pk_algorithm, HASH2MAC (dig));
+  pk = MHD_gtls_x509_sign_to_oid (pk_algorithm, HASH2MAC (dig));
   if (pk == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   /* write the OID.
    */
-  result = asn1_write_value (dst, name, pk, 1);
+  result = MHD__asn1_write_value (dst, name, pk, 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  mhd_gtls_str_cpy (name, sizeof (name), dst_name);
-  mhd_gtls_str_cat (name, sizeof (name), ".parameters");
+  MHD_gtls_str_cpy (name, sizeof (name), dst_name);
+  MHD_gtls_str_cat (name, sizeof (name), ".parameters");
 
   if (pk_algorithm == MHD_GNUTLS_PK_RSA)
     {                           /* RSA */
-      result = asn1_write_value (dst, name, NULL, 0);
+      result = MHD__asn1_write_value (dst, name, NULL, 0);
 
       if (result != ASN1_SUCCESS && result != ASN1_ELEMENT_NOT_FOUND)
         {
           /* Here we ignore the element not found error, since this
            * may have been disabled before.
            */
-          gnutls_assert ();
-          return mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          return MHD_gtls_asn2err (result);
         }
     }
 
@@ -390,8 +390,8 @@ _gnutls_x509_write_sig_params (ASN1_TYPE dst,
  * Allocates the space used to store the DER data.
  */
 int
-_gnutls_x509_write_dsa_params (mpi_t * params,
-                               int params_size, gnutls_datum_t * der)
+MHD__gnutls_x509_write_dsa_params (mpi_t * params,
+                               int params_size, MHD_gnutls_datum_t * der)
 {
   int result;
   ASN1_TYPE spk = ASN1_TYPE_EMPTY;
@@ -401,50 +401,50 @@ _gnutls_x509_write_dsa_params (mpi_t * params,
 
   if (params_size < 3)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_INVALID_REQUEST;
       goto cleanup;
     }
 
   if ((result =
-       asn1_create_element (_gnutls_get_gnutls_asn (), "GNUTLS.DSAParameters",
+       MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (), "GNUTLS.DSAParameters",
                             &spk)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  result = _gnutls_x509_write_int (spk, "p", params[0], 0);
+  result = MHD__gnutls_x509_write_int (spk, "p", params[0], 0);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  result = _gnutls_x509_write_int (spk, "q", params[1], 0);
+  result = MHD__gnutls_x509_write_int (spk, "q", params[1], 0);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  result = _gnutls_x509_write_int (spk, "g", params[2], 0);
+  result = MHD__gnutls_x509_write_int (spk, "g", params[2], 0);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  result = _gnutls_x509_der_encode (spk, "", der, 0);
+  result = MHD__gnutls_x509_der_encode (spk, "", der, 0);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
   result = 0;
 
-cleanup:asn1_delete_structure (&spk);
+cleanup:MHD__asn1_delete_structure (&spk);
   return result;
 }
 
@@ -455,8 +455,8 @@ cleanup:asn1_delete_structure (&spk);
  * Allocates the space used to store the DER data.
  */
 int
-_gnutls_x509_write_dsa_public_key (mpi_t * params,
-                                   int params_size, gnutls_datum_t * der)
+MHD__gnutls_x509_write_dsa_public_key (mpi_t * params,
+                                   int params_size, MHD_gnutls_datum_t * der)
 {
   int result;
   ASN1_TYPE spk = ASN1_TYPE_EMPTY;
@@ -466,37 +466,37 @@ _gnutls_x509_write_dsa_public_key (mpi_t * params,
 
   if (params_size < 3)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_INVALID_REQUEST;
       goto cleanup;
     }
 
   if ((result =
-       asn1_create_element (_gnutls_get_gnutls_asn (), "GNUTLS.DSAPublicKey",
+       MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (), "GNUTLS.DSAPublicKey",
                             &spk)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  result = _gnutls_x509_write_int (spk, "", params[3], 0);
+  result = MHD__gnutls_x509_write_int (spk, "", params[3], 0);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  result = _gnutls_x509_der_encode (spk, "", der, 0);
+  result = MHD__gnutls_x509_der_encode (spk, "", der, 0);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  asn1_delete_structure (&spk);
+  MHD__asn1_delete_structure (&spk);
   return 0;
 
-cleanup:asn1_delete_structure (&spk);
+cleanup:MHD__asn1_delete_structure (&spk);
   return result;
 }
 
@@ -505,51 +505,51 @@ cleanup:asn1_delete_structure (&spk);
  * steps.
  */
 int
-_gnutls_x509_read_uint (ASN1_TYPE node, const char *value, unsigned int *ret)
+MHD__gnutls_x509_read_uint (ASN1_TYPE node, const char *value, unsigned int *ret)
 {
   int len, result;
   opaque *tmpstr;
 
   len = 0;
-  result = asn1_read_value (node, value, NULL, &len);
+  result = MHD__asn1_read_value (node, value, NULL, &len);
   if (result != ASN1_MEM_ERROR)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  tmpstr = gnutls_alloca (len);
+  tmpstr = MHD_gnutls_alloca (len);
   if (tmpstr == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
-  result = asn1_read_value (node, value, tmpstr, &len);
+  result = MHD__asn1_read_value (node, value, tmpstr, &len);
 
   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);
     }
 
   if (len == 1)
     *ret = tmpstr[0];
   else if (len == 2)
-    *ret = mhd_gtls_read_uint16 (tmpstr);
+    *ret = MHD_gtls_read_uint16 (tmpstr);
   else if (len == 3)
-    *ret = mhd_gtls_read_uint24 (tmpstr);
+    *ret = MHD_gtls_read_uint24 (tmpstr);
   else if (len == 4)
-    *ret = mhd_gtls_read_uint32 (tmpstr);
+    *ret = MHD_gtls_read_uint32 (tmpstr);
   else
     {
-      gnutls_assert ();
-      gnutls_afree (tmpstr);
+      MHD_gnutls_assert ();
+      MHD_gnutls_afree (tmpstr);
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
-  gnutls_afree (tmpstr);
+  MHD_gnutls_afree (tmpstr);
 
   return 0;
 }
@@ -557,19 +557,19 @@ _gnutls_x509_read_uint (ASN1_TYPE node, const char *value, unsigned int *ret)
 /* Writes the specified integer into the specified node.
  */
 int
-_gnutls_x509_write_uint32 (ASN1_TYPE node, const char *value, uint32_t num)
+MHD__gnutls_x509_write_uint32 (ASN1_TYPE node, const char *value, uint32_t num)
 {
   opaque tmpstr[4];
   int result;
 
-  mhd_gtls_write_uint32 (num, tmpstr);
+  MHD_gtls_write_uint32 (num, tmpstr);
 
-  result = asn1_write_value (node, value, tmpstr, 4);
+  result = MHD__asn1_write_value (node, value, tmpstr, 4);
 
   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/x509/mpi.h b/src/daemon/https/x509/mpi.h
index 69e725bd..6c4534b4 100644
--- a/src/daemon/https/x509/mpi.h
+++ b/src/daemon/https/x509/mpi.h
@@ -25,32 +25,32 @@
 #include <gnutls_int.h>
 #include "x509.h"
 
-int _gnutls_x509_crt_get_mpis (gnutls_x509_crt_t cert,
+int MHD__gnutls_x509_crt_get_mpis (MHD_gnutls_x509_crt_t cert,
                                mpi_t * params, int *params_size);
-int _gnutls_x509_read_rsa_params (opaque * der, int dersize, mpi_t * params);
-int _gnutls_x509_read_dsa_pubkey (opaque * der, int dersize, mpi_t * params);
-int _gnutls_x509_read_dsa_params (opaque * der, int dersize, mpi_t * params);
+int 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 MHD__gnutls_x509_read_dsa_params (opaque * der, int dersize, mpi_t * params);
 
-int _gnutls_x509_write_rsa_params (mpi_t * params, int params_size,
-                                   gnutls_datum_t * der);
-int _gnutls_x509_write_dsa_params (mpi_t * params, int params_size,
-                                   gnutls_datum_t * der);
-int _gnutls_x509_write_dsa_public_key (mpi_t * params, int params_size,
-                                       gnutls_datum_t * der);
+int MHD__gnutls_x509_write_rsa_params (mpi_t * params, int params_size,
+                                   MHD_gnutls_datum_t * der);
+int MHD__gnutls_x509_write_dsa_params (mpi_t * params, int params_size,
+                                   MHD_gnutls_datum_t * der);
+int MHD__gnutls_x509_write_dsa_public_key (mpi_t * params, int params_size,
+                                       MHD_gnutls_datum_t * der);
 
-int _gnutls_x509_read_uint (ASN1_TYPE node, const char *value,
+int MHD__gnutls_x509_read_uint (ASN1_TYPE node, const char *value,
                             unsigned int *ret);
 
-int _gnutls_x509_read_der_int (opaque * der, int dersize, mpi_t * out);
+int MHD__gnutls_x509_read_der_int (opaque * der, int dersize, mpi_t * out);
 
-int _gnutls_x509_read_int (ASN1_TYPE node, const char *value,
+int MHD__gnutls_x509_read_int (ASN1_TYPE node, const char *value,
                            mpi_t * ret_mpi);
-int _gnutls_x509_write_int (ASN1_TYPE node, const char *value, mpi_t mpi,
+int MHD__gnutls_x509_write_int (ASN1_TYPE node, const char *value, mpi_t mpi,
                             int lz);
-int _gnutls_x509_write_uint32 (ASN1_TYPE node, const char *value,
+int MHD__gnutls_x509_write_uint32 (ASN1_TYPE node, const char *value,
                                uint32_t num);
 
-int _gnutls_x509_write_sig_params (ASN1_TYPE dst, const char *dst_name,
+int MHD__gnutls_x509_write_sig_params (ASN1_TYPE dst, const char *dst_name,
                                    enum MHD_GNUTLS_PublicKeyAlgorithm
                                    pk_algorithm,
                                    enum MHD_GNUTLS_HashAlgorithm,
diff --git a/src/daemon/https/x509/pkcs12.c b/src/daemon/https/x509/pkcs12.c
index 282e006e..af069e0d 100644
--- a/src/daemon/https/x509/pkcs12.c
+++ b/src/daemon/https/x509/pkcs12.c
@@ -46,26 +46,26 @@
  * which holds them. Returns an ASN1_TYPE of authenticatedSafe.
  */
 static int
-_decode_pkcs12_auth_safe (ASN1_TYPE pkcs12, ASN1_TYPE * authen_safe,
-                          gnutls_datum_t * raw)
+_decodeMHD_pkcs12_auth_safe (ASN1_TYPE pkcs12, ASN1_TYPE * authen_safe,
+                          MHD_gnutls_datum_t * raw)
 {
   char oid[128];
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
-  gnutls_datum_t auth_safe = { NULL, 0 };
+  MHD_gnutls_datum_t auth_safe = { NULL, 0 };
   int tmp_size, len, result;
 
   len = sizeof (oid) - 1;
-  result = asn1_read_value (pkcs12, "authSafe.contentType", oid, &len);
+  result = MHD__asn1_read_value (pkcs12, "authSafe.contentType", oid, &len);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   if (strcmp (oid, DATA_OID) != 0)
     {
-      gnutls_assert ();
-      _gnutls_x509_log ("Unknown PKCS12 Content OID '%s'\n", oid);
+      MHD_gnutls_assert ();
+      MHD__gnutls_x509_log ("Unknown PKCS12 Content OID '%s'\n", oid);
       return GNUTLS_E_UNKNOWN_PKCS_CONTENT_TYPE;
     }
 
@@ -74,36 +74,36 @@ _decode_pkcs12_auth_safe (ASN1_TYPE pkcs12, ASN1_TYPE * authen_safe,
 
   tmp_size = 0;
   result =
-    _gnutls_x509_read_value (pkcs12, "authSafe.content", &auth_safe, 1);
+    MHD__gnutls_x509_read_value (pkcs12, "authSafe.content", &auth_safe, 1);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
   /* Step 2. Extract the authenticatedSafe.
    */
 
-  if ((result = asn1_create_element
-       (_gnutls_get_pkix (), "PKIX1.pkcs-12-AuthenticatedSafe",
+  if ((result = MHD__asn1_create_element
+       (MHD__gnutls_get_pkix (), "PKIX1.pkcs-12-AuthenticatedSafe",
         &c2)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  result = asn1_der_decoding (&c2, auth_safe.data, auth_safe.size, NULL);
+  result = MHD__asn1_der_decoding (&c2, auth_safe.data, auth_safe.size, NULL);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   if (raw == NULL)
     {
-      _gnutls_free_datum (&auth_safe);
+      MHD__gnutls_free_datum (&auth_safe);
     }
   else
     {
@@ -114,19 +114,19 @@ _decode_pkcs12_auth_safe (ASN1_TYPE pkcs12, ASN1_TYPE * authen_safe,
   if (authen_safe)
     *authen_safe = c2;
   else
-    asn1_delete_structure (&c2);
+    MHD__asn1_delete_structure (&c2);
 
   return 0;
 
 cleanup:
   if (c2)
-    asn1_delete_structure (&c2);
-  _gnutls_free_datum (&auth_safe);
+    MHD__asn1_delete_structure (&c2);
+  MHD__gnutls_free_datum (&auth_safe);
   return result;
 }
 
 /**
-  * gnutls_pkcs12_init - This function initializes a gnutls_pkcs12_t structure
+  * MHD_gnutlsMHD_pkcs12_init - This function initializes a MHD_gnutlsMHD_pkcs12_t structure
   * @pkcs12: The structure to be initialized
   *
   * This function will initialize a PKCS12 structure. PKCS12 structures
@@ -137,20 +137,20 @@ cleanup:
   *
   **/
 int
-gnutls_pkcs12_init (gnutls_pkcs12_t * pkcs12)
+MHD_gnutlsMHD_pkcs12_init (MHD_gnutlsMHD_pkcs12_t * pkcs12)
 {
-  *pkcs12 = gnutls_calloc (1, sizeof (gnutls_pkcs12_int));
+  *pkcs12 = MHD_gnutls_calloc (1, sizeof (MHD_gnutlsMHD_pkcs12_int));
 
   if (*pkcs12)
     {
-      int result = asn1_create_element (_gnutls_get_pkix (),
+      int result = MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                                         "PKIX1.pkcs-12-PFX",
                                         &(*pkcs12)->pkcs12);
       if (result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          gnutls_free (*pkcs12);
-          return mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          MHD_gnutls_free (*pkcs12);
+          return MHD_gtls_asn2err (result);
         }
       return 0;                 /* success */
     }
@@ -158,33 +158,33 @@ gnutls_pkcs12_init (gnutls_pkcs12_t * pkcs12)
 }
 
 /**
-  * gnutls_pkcs12_deinit - This function deinitializes memory used by a gnutls_pkcs12_t structure
+  * MHD_gnutlsMHD_pkcs12_deinit - This function deinitializes memory used by a MHD_gnutlsMHD_pkcs12_t structure
   * @pkcs12: The structure to be initialized
   *
   * This function will deinitialize a PKCS12 structure.
   *
   **/
 void
-gnutls_pkcs12_deinit (gnutls_pkcs12_t pkcs12)
+MHD_gnutlsMHD_pkcs12_deinit (MHD_gnutlsMHD_pkcs12_t pkcs12)
 {
   if (!pkcs12)
     return;
 
   if (pkcs12->pkcs12)
-    asn1_delete_structure (&pkcs12->pkcs12);
+    MHD__asn1_delete_structure (&pkcs12->pkcs12);
 
-  gnutls_free (pkcs12);
+  MHD_gnutls_free (pkcs12);
 }
 
 /**
-  * gnutls_pkcs12_import - This function will import a DER or PEM encoded PKCS12 structure
+  * MHD_gnutlsMHD_pkcs12_import - This function will import a DER or PEM encoded PKCS12 structure
   * @pkcs12: The structure to store the parsed PKCS12.
   * @data: The DER or PEM encoded PKCS12.
   * @format: One of DER or PEM
-  * @flags: an ORed sequence of gnutls_privkey_pkcs8_flags
+  * @flags: an ORed sequence of MHD_gnutls_privkey_pkcs8_flags
   *
   * This function will convert the given DER or PEM encoded PKCS12
-  * to the native gnutls_pkcs12_t format. The output will be stored in 'pkcs12'.
+  * to the native MHD_gnutlsMHD_pkcs12_t format. The output will be stored in 'pkcs12'.
   *
   * If the PKCS12 is PEM encoded it should have a header of "PKCS12".
   *
@@ -192,19 +192,19 @@ gnutls_pkcs12_deinit (gnutls_pkcs12_t pkcs12)
   *
   **/
 int
-gnutls_pkcs12_import (gnutls_pkcs12_t pkcs12,
-                      const gnutls_datum_t * data,
-                      gnutls_x509_crt_fmt_t format, unsigned int flags)
+MHD_gnutlsMHD_pkcs12_import (MHD_gnutlsMHD_pkcs12_t pkcs12,
+                      const MHD_gnutls_datum_t * data,
+                      MHD_gnutls_x509_crt_fmt_t format, unsigned int flags)
 {
   int result = 0, need_free = 0;
-  gnutls_datum_t _data;
+  MHD_gnutls_datum_t _data;
 
   _data.data = data->data;
   _data.size = data->size;
 
   if (pkcs12 == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -214,14 +214,14 @@ gnutls_pkcs12_import (gnutls_pkcs12_t pkcs12,
     {
       opaque *out;
 
-      result = _gnutls_fbase64_decode (PEM_PKCS12, data->data, data->size,
+      result = MHD__gnutls_fbase64_decode (PEM_PKCS12, data->data, data->size,
                                        &out);
 
       if (result <= 0)
         {
           if (result == 0)
             result = GNUTLS_E_INTERNAL_ERROR;
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return result;
         }
 
@@ -231,28 +231,28 @@ gnutls_pkcs12_import (gnutls_pkcs12_t pkcs12,
       need_free = 1;
     }
 
-  result = asn1_der_decoding (&pkcs12->pkcs12, _data.data, _data.size, NULL);
+  result = MHD__asn1_der_decoding (&pkcs12->pkcs12, _data.data, _data.size, NULL);
   if (result != ASN1_SUCCESS)
     {
-      result = mhd_gtls_asn2err (result);
-      gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
   if (need_free)
-    _gnutls_free_datum (&_data);
+    MHD__gnutls_free_datum (&_data);
 
   return 0;
 
 cleanup:
   if (need_free)
-    _gnutls_free_datum (&_data);
+    MHD__gnutls_free_datum (&_data);
   return result;
 }
 
 
 /**
-  * gnutls_pkcs12_export - This function will export the pkcs12 structure
+  * MHD_gnutlsMHD_pkcs12_export - This function will export the pkcs12 structure
   * @pkcs12: Holds the pkcs12 structure
   * @format: the format of output params. One of PEM or DER.
   * @output_data: will contain a structure PEM or DER encoded
@@ -273,17 +273,17 @@ cleanup:
   *
   **/
 int
-gnutls_pkcs12_export (gnutls_pkcs12_t pkcs12,
-                      gnutls_x509_crt_fmt_t format, void *output_data,
+MHD_gnutlsMHD_pkcs12_export (MHD_gnutlsMHD_pkcs12_t pkcs12,
+                      MHD_gnutls_x509_crt_fmt_t format, void *output_data,
                       size_t * output_data_size)
 {
   if (pkcs12 == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  return _gnutls_x509_export_int (pkcs12->pkcs12, format, PEM_PKCS12,
+  return MHD__gnutls_x509_export_int (pkcs12->pkcs12, format, PEM_PKCS12,
                                   output_data, output_data_size);
 }
 
@@ -341,44 +341,44 @@ ucs2_to_ascii (char *data, int size)
  * the given bag.
  */
 int
-_pkcs12_decode_safe_contents (const gnutls_datum_t * content,
-                              gnutls_pkcs12_bag_t bag)
+MHD_pkcs12_decode_safe_contents (const MHD_gnutls_datum_t * content,
+                              MHD_gnutlsMHD_pkcs12_bag_t bag)
 {
   char oid[128], root[MAX_NAME_SIZE];
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
   int len, result;
   int bag_type;
-  gnutls_datum_t attr_val;
+  MHD_gnutls_datum_t attr_val;
   int count = 0, i, attributes, j;
   size_t size;
 
   /* Step 1. Extract the SEQUENCE.
    */
 
-  if ((result = asn1_create_element
-       (_gnutls_get_pkix (), "PKIX1.pkcs-12-SafeContents",
+  if ((result = MHD__asn1_create_element
+       (MHD__gnutls_get_pkix (), "PKIX1.pkcs-12-SafeContents",
         &c2)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  result = asn1_der_decoding (&c2, content->data, content->size, NULL);
+  result = MHD__asn1_der_decoding (&c2, content->data, content->size, NULL);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   /* Count the number of bags
    */
-  result = asn1_number_of_elements (c2, "", &count);
+  result = MHD__asn1_number_of_elements (c2, "", &count);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -390,11 +390,11 @@ _pkcs12_decode_safe_contents (const gnutls_datum_t * content,
       snprintf (root, sizeof (root), "?%u.bagId", i + 1);
 
       len = sizeof (oid);
-      result = asn1_read_value (c2, root, oid, &len);
+      result = MHD__asn1_read_value (c2, root, oid, &len);
       if (result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          result = mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          result = MHD_gtls_asn2err (result);
           goto cleanup;
         }
 
@@ -404,7 +404,7 @@ _pkcs12_decode_safe_contents (const gnutls_datum_t * content,
 
       if (bag_type < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           goto cleanup;
         }
 
@@ -413,37 +413,37 @@ _pkcs12_decode_safe_contents (const gnutls_datum_t * content,
 
       snprintf (root, sizeof (root), "?%u.bagValue", i + 1);
 
-      result = _gnutls_x509_read_value (c2, root, &bag->element[i].data, 0);
+      result = MHD__gnutls_x509_read_value (c2, root, &bag->element[i].data, 0);
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           goto cleanup;
         }
 
       if (bag_type == GNUTLS_BAG_CERTIFICATE || bag_type == GNUTLS_BAG_CRL)
         {
-          gnutls_datum_t tmp = bag->element[i].data;
+          MHD_gnutls_datum_t tmp = bag->element[i].data;
 
           result =
-            _pkcs12_decode_crt_bag (bag_type, &tmp, &bag->element[i].data);
+            MHD_pkcs12_decode_crt_bag (bag_type, &tmp, &bag->element[i].data);
           if (result < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               goto cleanup;
             }
 
-          _gnutls_free_datum (&tmp);
+          MHD__gnutls_free_datum (&tmp);
         }
 
       /* read the bag attributes
        */
       snprintf (root, sizeof (root), "?%u.bagAttributes", i + 1);
 
-      result = asn1_number_of_elements (c2, root, &attributes);
+      result = MHD__asn1_number_of_elements (c2, root, &attributes);
       if (result != ASN1_SUCCESS && result != ASN1_ELEMENT_NOT_FOUND)
         {
-          gnutls_assert ();
-          result = mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          result = MHD_gtls_asn2err (result);
           goto cleanup;
         }
 
@@ -458,13 +458,13 @@ _pkcs12_decode_safe_contents (const gnutls_datum_t * content,
                       j + 1);
 
             result =
-              _gnutls_x509_decode_and_read_attribute (c2, root, oid,
+              MHD__gnutls_x509_decode_and_read_attribute (c2, root, oid,
                                                       sizeof (oid), &attr_val,
                                                       1, 0);
 
             if (result < 0)
               {
-                gnutls_assert ();
+                MHD_gnutls_assert ();
                 continue;       /* continue in case we find some known attributes */
               }
 
@@ -473,14 +473,14 @@ _pkcs12_decode_safe_contents (const gnutls_datum_t * content,
                 size = attr_val.size;
 
                 result =
-                  _gnutls_x509_decode_octet_string (NULL, attr_val.data, size,
+                  MHD__gnutls_x509_decode_octet_string (NULL, attr_val.data, size,
                                                     attr_val.data, &size);
                 attr_val.size = size;
                 if (result < 0)
                   {
-                    _gnutls_free_datum (&attr_val);
-                    gnutls_assert ();
-                    _gnutls_x509_log
+                    MHD__gnutls_free_datum (&attr_val);
+                    MHD_gnutls_assert ();
+                    MHD__gnutls_x509_log
                       ("Error decoding PKCS12 Bag Attribute OID '%s'\n", oid);
                     continue;
                   }
@@ -490,15 +490,15 @@ _pkcs12_decode_safe_contents (const gnutls_datum_t * content,
               {
                 size = attr_val.size;
                 result =
-                  _gnutls_x509_decode_octet_string ("BMPString",
+                  MHD__gnutls_x509_decode_octet_string ("BMPString",
                                                     attr_val.data, size,
                                                     attr_val.data, &size);
                 attr_val.size = size;
                 if (result < 0)
                   {
-                    _gnutls_free_datum (&attr_val);
-                    gnutls_assert ();
-                    _gnutls_x509_log
+                    MHD__gnutls_free_datum (&attr_val);
+                    MHD_gnutls_assert ();
+                    MHD__gnutls_x509_log
                       ("Error decoding PKCS12 Bag Attribute OID '%s'\n", oid);
                     continue;
                   }
@@ -507,8 +507,8 @@ _pkcs12_decode_safe_contents (const gnutls_datum_t * content,
               }
             else
               {
-                _gnutls_free_datum (&attr_val);
-                _gnutls_x509_log
+                MHD__gnutls_free_datum (&attr_val);
+                MHD__gnutls_x509_log
                   ("Unknown PKCS12 Bag Attribute OID '%s'\n", oid);
               }
           }
@@ -518,14 +518,14 @@ _pkcs12_decode_safe_contents (const gnutls_datum_t * content,
 
     }
 
-  asn1_delete_structure (&c2);
+  MHD__asn1_delete_structure (&c2);
 
 
   return 0;
 
 cleanup:
   if (c2)
-    asn1_delete_structure (&c2);
+    MHD__asn1_delete_structure (&c2);
   return result;
 
 }
@@ -533,41 +533,41 @@ cleanup:
 
 static int
 _parse_safe_contents (ASN1_TYPE sc, const char *sc_name,
-                      gnutls_pkcs12_bag_t bag)
+                      MHD_gnutlsMHD_pkcs12_bag_t bag)
 {
-  gnutls_datum_t content = { NULL, 0 };
+  MHD_gnutls_datum_t content = { NULL, 0 };
   int result;
 
   /* Step 1. Extract the content.
    */
 
-  result = _gnutls_x509_read_value (sc, sc_name, &content, 1);
+  result = MHD__gnutls_x509_read_value (sc, sc_name, &content, 1);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  result = _pkcs12_decode_safe_contents (&content, bag);
+  result = MHD_pkcs12_decode_safe_contents (&content, bag);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  _gnutls_free_datum (&content);
+  MHD__gnutls_free_datum (&content);
 
   return 0;
 
 cleanup:
-  _gnutls_free_datum (&content);
+  MHD__gnutls_free_datum (&content);
   return result;
 }
 
 
 /**
-  * gnutls_pkcs12_get_bag - This function returns a Bag from a PKCS12 structure
-  * @pkcs12: should contain a gnutls_pkcs12_t structure
+  * MHD_gnutlsMHD_pkcs12_get_bag - This function returns a Bag from a PKCS12 structure
+  * @pkcs12: should contain a MHD_gnutlsMHD_pkcs12_t structure
   * @indx: contains the index of the bag to extract
   * @bag: An initialized bag, where the contents of the bag will be copied
   *
@@ -579,8 +579,8 @@ cleanup:
   *
   **/
 int
-gnutls_pkcs12_get_bag (gnutls_pkcs12_t pkcs12,
-                       int indx, gnutls_pkcs12_bag_t bag)
+MHD_gnutlsMHD_pkcs12_get_bag (MHD_gnutlsMHD_pkcs12_t pkcs12,
+                       int indx, MHD_gnutlsMHD_pkcs12_bag_t bag)
 {
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
   int result, len;
@@ -589,16 +589,16 @@ gnutls_pkcs12_get_bag (gnutls_pkcs12_t pkcs12,
 
   if (pkcs12 == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   /* Step 1. decode the data.
    */
-  result = _decode_pkcs12_auth_safe (pkcs12->pkcs12, &c2, NULL);
+  result = _decodeMHD_pkcs12_auth_safe (pkcs12->pkcs12, &c2, NULL);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -608,7 +608,7 @@ gnutls_pkcs12_get_bag (gnutls_pkcs12_t pkcs12,
   snprintf (root2, sizeof (root2), "?%u.contentType", indx + 1);
 
   len = sizeof (oid) - 1;
-  result = asn1_read_value (c2, root2, oid, &len);
+  result = MHD__asn1_read_value (c2, root2, oid, &len);
 
   if (result == ASN1_ELEMENT_NOT_FOUND)
     {
@@ -618,8 +618,8 @@ gnutls_pkcs12_get_bag (gnutls_pkcs12_t pkcs12,
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -639,10 +639,10 @@ gnutls_pkcs12_get_bag (gnutls_pkcs12_t pkcs12,
   bag->element[0].type = GNUTLS_BAG_ENCRYPTED;
   bag->bag_elements = 1;
 
-  result = _gnutls_x509_read_value (c2, root2, &bag->element[0].data, 0);
+  result = MHD__gnutls_x509_read_value (c2, root2, &bag->element[0].data, 0);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
@@ -650,7 +650,7 @@ gnutls_pkcs12_get_bag (gnutls_pkcs12_t pkcs12,
 
 cleanup:
   if (c2)
-    asn1_delete_structure (&c2);
+    MHD__asn1_delete_structure (&c2);
   return result;
 }
 
@@ -665,21 +665,21 @@ create_empty_pfx (ASN1_TYPE pkcs12)
 
   /* Use version 3
    */
-  result = asn1_write_value (pkcs12, "version", &three, 1);
+  result = MHD__asn1_write_value (pkcs12, "version", &three, 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   /* Write the content type of the data
    */
-  result = asn1_write_value (pkcs12, "authSafe.contentType", DATA_OID, 1);
+  result = MHD__asn1_write_value (pkcs12, "authSafe.contentType", DATA_OID, 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -687,35 +687,35 @@ create_empty_pfx (ASN1_TYPE pkcs12)
    * null one in that case.
    */
 
-  if ((result = asn1_create_element
-       (_gnutls_get_pkix (), "PKIX1.pkcs-12-AuthenticatedSafe",
+  if ((result = MHD__asn1_create_element
+       (MHD__gnutls_get_pkix (), "PKIX1.pkcs-12-AuthenticatedSafe",
         &c2)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   result =
-    _gnutls_x509_der_encode_and_copy (c2, "", pkcs12, "authSafe.content", 1);
+    MHD__gnutls_x509_der_encode_and_copy (c2, "", pkcs12, "authSafe.content", 1);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
-  asn1_delete_structure (&c2);
+  MHD__asn1_delete_structure (&c2);
 
   return 0;
 
 cleanup:
-  asn1_delete_structure (&c2);
+  MHD__asn1_delete_structure (&c2);
   return result;
 
 }
 
 /**
-  * gnutls_pkcs12_set_bag - This function inserts a Bag into a PKCS12 structure
-  * @pkcs12: should contain a gnutls_pkcs12_t structure
+  * MHD_gnutlsMHD_pkcs12_set_bag - This function inserts a Bag into a PKCS12 structure
+  * @pkcs12: should contain a MHD_gnutlsMHD_pkcs12_t structure
   * @bag: An initialized bag
   *
   * This function will insert a Bag into the PKCS12 structure.
@@ -723,7 +723,7 @@ cleanup:
   *
   **/
 int
-gnutls_pkcs12_set_bag (gnutls_pkcs12_t pkcs12, gnutls_pkcs12_bag_t bag)
+MHD_gnutlsMHD_pkcs12_set_bag (MHD_gnutlsMHD_pkcs12_t pkcs12, MHD_gnutlsMHD_pkcs12_bag_t bag)
 {
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
   ASN1_TYPE safe_cont = ASN1_TYPE_EMPTY;
@@ -733,62 +733,62 @@ gnutls_pkcs12_set_bag (gnutls_pkcs12_t pkcs12, gnutls_pkcs12_bag_t bag)
 
   if (pkcs12 == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   /* Step 1. Check if the pkcs12 structure is empty. In that
    * case generate an empty PFX.
    */
-  result = asn1_read_value (pkcs12->pkcs12, "authSafe.content", &null, &dum);
+  result = MHD__asn1_read_value (pkcs12->pkcs12, "authSafe.content", &null, &dum);
   if (result == ASN1_VALUE_NOT_FOUND)
     {
       result = create_empty_pfx (pkcs12->pkcs12);
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return result;
         }
     }
 
   /* Step 2. decode the authenticatedSafe.
    */
-  result = _decode_pkcs12_auth_safe (pkcs12->pkcs12, &c2, NULL);
+  result = _decodeMHD_pkcs12_auth_safe (pkcs12->pkcs12, &c2, NULL);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
   /* Step 3. Encode the bag elements into a SafeContents
    * structure.
    */
-  result = _pkcs12_encode_safe_contents (bag, &safe_cont, &enc);
+  result = MHD_pkcs12_encode_safe_contents (bag, &safe_cont, &enc);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
   /* Step 4. Insert the encoded SafeContents into the AuthenticatedSafe
    * structure.
    */
-  result = asn1_write_value (c2, "", "NEW", 1);
+  result = MHD__asn1_write_value (c2, "", "NEW", 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   if (enc)
-    result = asn1_write_value (c2, "?LAST.contentType", ENC_DATA_OID, 1);
+    result = MHD__asn1_write_value (c2, "?LAST.contentType", ENC_DATA_OID, 1);
   else
-    result = asn1_write_value (c2, "?LAST.contentType", DATA_OID, 1);
+    result = MHD__asn1_write_value (c2, "?LAST.contentType", DATA_OID, 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -797,56 +797,56 @@ gnutls_pkcs12_set_bag (gnutls_pkcs12_t pkcs12, gnutls_pkcs12_bag_t bag)
       /* Encrypted packets are written directly.
        */
       result =
-        asn1_write_value (c2, "?LAST.content",
+        MHD__asn1_write_value (c2, "?LAST.content",
                           bag->element[0].data.data,
                           bag->element[0].data.size);
       if (result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          result = mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          result = MHD_gtls_asn2err (result);
           goto cleanup;
         }
     }
   else
     {
       result =
-        _gnutls_x509_der_encode_and_copy (safe_cont, "", c2,
+        MHD__gnutls_x509_der_encode_and_copy (safe_cont, "", c2,
                                           "?LAST.content", 1);
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           goto cleanup;
         }
     }
 
-  asn1_delete_structure (&safe_cont);
+  MHD__asn1_delete_structure (&safe_cont);
 
 
   /* Step 5. Reencode and copy the AuthenticatedSafe into the pkcs12
    * structure.
    */
   result =
-    _gnutls_x509_der_encode_and_copy (c2, "", pkcs12->pkcs12,
+    MHD__gnutls_x509_der_encode_and_copy (c2, "", pkcs12->pkcs12,
                                       "authSafe.content", 1);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  asn1_delete_structure (&c2);
+  MHD__asn1_delete_structure (&c2);
 
   return 0;
 
 cleanup:
-  asn1_delete_structure (&c2);
-  asn1_delete_structure (&safe_cont);
+  MHD__asn1_delete_structure (&c2);
+  MHD__asn1_delete_structure (&safe_cont);
   return result;
 }
 
 /**
-  * gnutls_pkcs12_generate_mac - This function generates the MAC of the PKCS12 structure
-  * @pkcs12: should contain a gnutls_pkcs12_t structure
+  * MHD_gnutlsMHD_pkcs12_generate_mac - This function generates the MAC of the PKCS12 structure
+  * @pkcs12: should contain a MHD_gnutlsMHD_pkcs12_t structure
   * @pass: The password for the MAC
   *
   * This function will generate a MAC for the PKCS12 structure.
@@ -854,115 +854,115 @@ cleanup:
   *
   **/
 int
-gnutls_pkcs12_generate_mac (gnutls_pkcs12_t pkcs12, const char *pass)
+MHD_gnutlsMHD_pkcs12_generate_mac (MHD_gnutlsMHD_pkcs12_t pkcs12, const char *pass)
 {
   opaque salt[8], key[20];
   int result;
   mac_hd_t td1 = NULL;
-  gnutls_datum_t tmp = { NULL, 0 };
+  MHD_gnutls_datum_t tmp = { NULL, 0 };
   opaque sha_mac[20];
 
   if (pkcs12 == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   /* Generate the salt.
    */
-  if (gc_nonce (salt, sizeof (salt)) != GC_OK)
+  if (MHD_gc_nonce (salt, sizeof (salt)) != GC_OK)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_RANDOM_FAILED;
     }
 
   /* Write the salt into the structure.
    */
   result =
-    asn1_write_value (pkcs12->pkcs12, "macData.macSalt", salt, sizeof (salt));
+    MHD__asn1_write_value (pkcs12->pkcs12, "macData.macSalt", salt, sizeof (salt));
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   /* Generate the key.
    */
-  result = _pkcs12_string_to_key (3 /*MAC*/, salt, sizeof (salt),
+  result = MHD_pkcs12_string_to_key (3 /*MAC*/, salt, sizeof (salt),
                                   1, pass, sizeof (key), key);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
   /* Get the data to be MACed
    */
-  result = _decode_pkcs12_auth_safe (pkcs12->pkcs12, NULL, &tmp);
+  result = _decodeMHD_pkcs12_auth_safe (pkcs12->pkcs12, NULL, &tmp);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
   /* MAC the data
    */
-  td1 = mhd_gtls_hmac_init (MHD_GNUTLS_MAC_SHA1, key, sizeof (key));
+  td1 = MHD_gtls_MHD_hmac_init (MHD_GNUTLS_MAC_SHA1, key, sizeof (key));
   if (td1 == GNUTLS_MAC_FAILED)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_INTERNAL_ERROR;
       goto cleanup;
     }
 
-  mhd_gnutls_hash (td1, tmp.data, tmp.size);
-  _gnutls_free_datum (&tmp);
+  MHD_gnutls_hash (td1, tmp.data, tmp.size);
+  MHD__gnutls_free_datum (&tmp);
 
-  mhd_gnutls_hmac_deinit (td1, sha_mac);
+  MHD_gnutls_MHD_hmac_deinit (td1, sha_mac);
 
 
   result =
-    asn1_write_value (pkcs12->pkcs12, "macData.mac.digest", sha_mac,
+    MHD__asn1_write_value (pkcs12->pkcs12, "macData.mac.digest", sha_mac,
                       sizeof (sha_mac));
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   result =
-    asn1_write_value (pkcs12->pkcs12,
+    MHD__asn1_write_value (pkcs12->pkcs12,
                       "macData.mac.digestAlgorithm.parameters", NULL, 0);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   result =
-    asn1_write_value (pkcs12->pkcs12,
+    MHD__asn1_write_value (pkcs12->pkcs12,
                       "macData.mac.digestAlgorithm.algorithm", HASH_OID_SHA1,
                       1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   return 0;
 
 cleanup:
-  _gnutls_free_datum (&tmp);
+  MHD__gnutls_free_datum (&tmp);
   return result;
 }
 
 /**
-  * gnutls_pkcs12_verify_mac - This function verifies the MAC of the PKCS12 structure
-  * @pkcs12: should contain a gnutls_pkcs12_t structure
+  * MHD_gnutlsMHD_pkcs12_verify_mac - This function verifies the MAC of the PKCS12 structure
+  * @pkcs12: should contain a MHD_gnutlsMHD_pkcs12_t structure
   * @pass: The password for the MAC
   *
   * This function will verify the MAC for the PKCS12 structure.
@@ -970,14 +970,14 @@ cleanup:
   *
   **/
 int
-gnutls_pkcs12_verify_mac (gnutls_pkcs12_t pkcs12, const char *pass)
+MHD_gnutlsMHD_pkcs12_verify_mac (MHD_gnutlsMHD_pkcs12_t pkcs12, const char *pass)
 {
   opaque key[20];
   int result;
   unsigned int iter;
   int len;
   mac_hd_t td1 = NULL;
-  gnutls_datum_t tmp = { NULL, 0 }, salt =
+  MHD_gnutls_datum_t tmp = { NULL, 0 }, salt =
   {
   NULL, 0};
   opaque sha_mac[20];
@@ -985,7 +985,7 @@ gnutls_pkcs12_verify_mac (gnutls_pkcs12_t pkcs12, const char *pass)
 
   if (pkcs12 == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -993,7 +993,7 @@ gnutls_pkcs12_verify_mac (gnutls_pkcs12_t pkcs12, const char *pass)
    */
 
   result =
-    _gnutls_x509_read_uint (pkcs12->pkcs12, "macData.iterations", &iter);
+    MHD__gnutls_x509_read_uint (pkcs12->pkcs12, "macData.iterations", &iter);
   if (result < 0)
     {
       iter = 1;                 /* the default */
@@ -1003,78 +1003,78 @@ gnutls_pkcs12_verify_mac (gnutls_pkcs12_t pkcs12, const char *pass)
   /* Read the salt from the structure.
    */
   result =
-    _gnutls_x509_read_value (pkcs12->pkcs12, "macData.macSalt", &salt, 0);
+    MHD__gnutls_x509_read_value (pkcs12->pkcs12, "macData.macSalt", &salt, 0);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   /* Generate the key.
    */
-  result = _pkcs12_string_to_key (3 /*MAC*/, salt.data, salt.size,
+  result = MHD_pkcs12_string_to_key (3 /*MAC*/, salt.data, salt.size,
                                   iter, pass, sizeof (key), key);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  _gnutls_free_datum (&salt);
+  MHD__gnutls_free_datum (&salt);
 
   /* Get the data to be MACed
    */
-  result = _decode_pkcs12_auth_safe (pkcs12->pkcs12, NULL, &tmp);
+  result = _decodeMHD_pkcs12_auth_safe (pkcs12->pkcs12, NULL, &tmp);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
   /* MAC the data
    */
-  td1 = mhd_gtls_hmac_init (MHD_GNUTLS_MAC_SHA1, key, sizeof (key));
+  td1 = MHD_gtls_MHD_hmac_init (MHD_GNUTLS_MAC_SHA1, key, sizeof (key));
   if (td1 == GNUTLS_MAC_FAILED)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_INTERNAL_ERROR;
       goto cleanup;
     }
 
-  mhd_gnutls_hash (td1, tmp.data, tmp.size);
-  _gnutls_free_datum (&tmp);
+  MHD_gnutls_hash (td1, tmp.data, tmp.size);
+  MHD__gnutls_free_datum (&tmp);
 
-  mhd_gnutls_hmac_deinit (td1, sha_mac);
+  MHD_gnutls_MHD_hmac_deinit (td1, sha_mac);
 
   len = sizeof (sha_mac_orig);
   result =
-    asn1_read_value (pkcs12->pkcs12, "macData.mac.digest", sha_mac_orig,
+    MHD__asn1_read_value (pkcs12->pkcs12, "macData.mac.digest", sha_mac_orig,
                      &len);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   if (memcmp (sha_mac_orig, sha_mac, sizeof (sha_mac)) != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MAC_VERIFY_FAILED;
     }
 
   return 0;
 
 cleanup:
-  _gnutls_free_datum (&tmp);
-  _gnutls_free_datum (&salt);
+  MHD__gnutls_free_datum (&tmp);
+  MHD__gnutls_free_datum (&salt);
   return result;
 }
 
 
 static int
-write_attributes (gnutls_pkcs12_bag_t bag, int elem,
+write_attributes (MHD_gnutlsMHD_pkcs12_bag_t bag, int elem,
                   ASN1_TYPE c2, const char *where)
 {
   int result;
@@ -1088,11 +1088,11 @@ write_attributes (gnutls_pkcs12_bag_t bag, int elem,
     {
       /* no attributes
        */
-      result = asn1_write_value (c2, where, NULL, 0);
+      result = MHD__asn1_write_value (c2, where, NULL, 0);
       if (result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          return mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          return MHD_gtls_asn2err (result);
         }
 
       return 0;
@@ -1103,25 +1103,25 @@ write_attributes (gnutls_pkcs12_bag_t bag, int elem,
 
       /* Add a new Attribute
        */
-      result = asn1_write_value (c2, where, "NEW", 1);
+      result = MHD__asn1_write_value (c2, where, "NEW", 1);
       if (result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          return mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          return MHD_gtls_asn2err (result);
         }
 
-      mhd_gtls_str_cpy (root, sizeof (root), where);
-      mhd_gtls_str_cat (root, sizeof (root), ".?LAST");
+      MHD_gtls_str_cpy (root, sizeof (root), where);
+      MHD_gtls_str_cat (root, sizeof (root), ".?LAST");
 
       result =
-        _gnutls_x509_encode_and_write_attribute (KEY_ID_OID, c2, root,
+        MHD__gnutls_x509_encode_and_write_attribute (KEY_ID_OID, c2, root,
                                                  bag->element[elem].
                                                  local_key_id.data,
                                                  bag->element[elem].
                                                  local_key_id.size, 1);
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return result;
         }
     }
@@ -1134,21 +1134,21 @@ write_attributes (gnutls_pkcs12_bag_t bag, int elem,
 
       /* Add a new Attribute
        */
-      result = asn1_write_value (c2, where, "NEW", 1);
+      result = MHD__asn1_write_value (c2, where, "NEW", 1);
       if (result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          return mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          return MHD_gtls_asn2err (result);
         }
 
       /* convert name to BMPString
        */
       size = strlen (bag->element[elem].friendly_name) * 2;
-      name = gnutls_malloc (size);
+      name = MHD_gnutls_malloc (size);
 
       if (name == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_MEMORY_ERROR;
         }
 
@@ -1160,18 +1160,18 @@ write_attributes (gnutls_pkcs12_bag_t bag, int elem,
           p++;
         }
 
-      mhd_gtls_str_cpy (root, sizeof (root), where);
-      mhd_gtls_str_cat (root, sizeof (root), ".?LAST");
+      MHD_gtls_str_cpy (root, sizeof (root), where);
+      MHD_gtls_str_cat (root, sizeof (root), ".?LAST");
 
       result =
-        _gnutls_x509_encode_and_write_attribute (FRIENDLY_NAME_OID, c2,
+        MHD__gnutls_x509_encode_and_write_attribute (FRIENDLY_NAME_OID, c2,
                                                  root, name, size, 1);
 
-      gnutls_free (name);
+      MHD_gnutls_free (name);
 
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return result;
         }
     }
@@ -1184,7 +1184,7 @@ write_attributes (gnutls_pkcs12_bag_t bag, int elem,
  * the given datum. Enc is set to non zero if the data are encrypted;
  */
 int
-_pkcs12_encode_safe_contents (gnutls_pkcs12_bag_t bag, ASN1_TYPE * contents,
+MHD_pkcs12_encode_safe_contents (MHD_gnutlsMHD_pkcs12_bag_t bag, ASN1_TYPE * contents,
                               int *enc)
 {
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
@@ -1203,12 +1203,12 @@ _pkcs12_encode_safe_contents (gnutls_pkcs12_bag_t bag, ASN1_TYPE * contents,
   /* Step 1. Create the SEQUENCE.
    */
 
-  if ((result = asn1_create_element
-       (_gnutls_get_pkix (), "PKIX1.pkcs-12-SafeContents",
+  if ((result = MHD__asn1_create_element
+       (MHD__gnutls_get_pkix (), "PKIX1.pkcs-12-SafeContents",
         &c2)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -1218,25 +1218,25 @@ _pkcs12_encode_safe_contents (gnutls_pkcs12_bag_t bag, ASN1_TYPE * contents,
       oid = bag_to_oid (bag->element[i].type);
       if (oid == NULL)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           continue;
         }
 
-      result = asn1_write_value (c2, "", "NEW", 1);
+      result = MHD__asn1_write_value (c2, "", "NEW", 1);
       if (result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          result = mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          result = MHD_gtls_asn2err (result);
           goto cleanup;
         }
 
       /* Copy the bag type.
        */
-      result = asn1_write_value (c2, "?LAST.bagId", oid, 1);
+      result = MHD__asn1_write_value (c2, "?LAST.bagId", oid, 1);
       if (result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          result = mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          result = MHD_gtls_asn2err (result);
           goto cleanup;
         }
 
@@ -1245,7 +1245,7 @@ _pkcs12_encode_safe_contents (gnutls_pkcs12_bag_t bag, ASN1_TYPE * contents,
       result = write_attributes (bag, i, c2, "?LAST.bagAttributes");
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           goto cleanup;
         }
 
@@ -1256,37 +1256,37 @@ _pkcs12_encode_safe_contents (gnutls_pkcs12_bag_t bag, ASN1_TYPE * contents,
       if (bag->element[i].type == GNUTLS_BAG_CERTIFICATE ||
           bag->element[i].type == GNUTLS_BAG_CRL)
         {
-          gnutls_datum_t tmp;
+          MHD_gnutls_datum_t tmp;
 
           /* in that case encode it to a CertBag or
            * a CrlBag.
            */
 
           result =
-            _pkcs12_encode_crt_bag (bag->element[i].type,
+            MHD_pkcs12_encode_crt_bag (bag->element[i].type,
                                     &bag->element[i].data, &tmp);
 
           if (result < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               goto cleanup;
             }
 
-          result = _gnutls_x509_write_value (c2, "?LAST.bagValue", &tmp, 0);
+          result = MHD__gnutls_x509_write_value (c2, "?LAST.bagValue", &tmp, 0);
 
-          _gnutls_free_datum (&tmp);
+          MHD__gnutls_free_datum (&tmp);
 
         }
       else
         {
 
-          result = _gnutls_x509_write_value (c2, "?LAST.bagValue",
+          result = MHD__gnutls_x509_write_value (c2, "?LAST.bagValue",
                                              &bag->element[i].data, 0);
         }
 
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           goto cleanup;
         }
 
@@ -1300,7 +1300,7 @@ _pkcs12_encode_safe_contents (gnutls_pkcs12_bag_t bag, ASN1_TYPE * contents,
 
 cleanup:
   if (c2)
-    asn1_delete_structure (&c2);
+    MHD__asn1_delete_structure (&c2);
   return result;
 
 }
diff --git a/src/daemon/https/x509/pkcs12.h b/src/daemon/https/x509/pkcs12.h
index 38131ece..565ed5e5 100644
--- a/src/daemon/https/x509/pkcs12.h
+++ b/src/daemon/https/x509/pkcs12.h
@@ -37,15 +37,15 @@ extern "C"
 
 /* PKCS12 structures handling
  */
-  struct gnutls_pkcs12_int;
+  struct MHD_gnutlsMHD_pkcs12_int;
 
-  struct gnutls_pkcs12_bag_int;
-  typedef struct gnutls_pkcs12_int
+  struct MHD_gnutlsMHD_pkcs12_bag_int;
+  typedef struct MHD_gnutlsMHD_pkcs12_int
   {
     ASN1_TYPE pkcs12;
-  } gnutls_pkcs12_int;
+  } MHD_gnutlsMHD_pkcs12_int;
 
-  typedef enum gnutls_pkcs12_bag_type_t
+  typedef enum MHD_gnutlsMHD_pkcs12_bag_type_t
   {
     GNUTLS_BAG_EMPTY = 0,
 
@@ -55,73 +55,73 @@ extern "C"
     GNUTLS_BAG_CRL,
     GNUTLS_BAG_ENCRYPTED = 10,
     GNUTLS_BAG_UNKNOWN = 20
-  } gnutls_pkcs12_bag_type_t;
+  } MHD_gnutlsMHD_pkcs12_bag_type_t;
 
   struct bag_element
   {
-    gnutls_datum_t data;
-    gnutls_pkcs12_bag_type_t type;
-    gnutls_datum_t local_key_id;
+    MHD_gnutls_datum_t data;
+    MHD_gnutlsMHD_pkcs12_bag_type_t type;
+    MHD_gnutls_datum_t local_key_id;
     char *friendly_name;
   };
 
-  typedef struct gnutls_pkcs12_bag_int
+  typedef struct MHD_gnutlsMHD_pkcs12_bag_int
   {
     struct bag_element element[MAX_BAG_ELEMENTS];
     int bag_elements;
-  } gnutls_pkcs12_bag_int;
+  } MHD_gnutlsMHD_pkcs12_bag_int;
 
 /* Bag attributes */
 #define FRIENDLY_NAME_OID "1.2.840.113549.1.9.20"
 #define KEY_ID_OID "1.2.840.113549.1.9.21"
 
-  typedef struct gnutls_pkcs12_int *gnutls_pkcs12_t;
-  typedef struct gnutls_pkcs12_bag_int *gnutls_pkcs12_bag_t;
+  typedef struct MHD_gnutlsMHD_pkcs12_int *MHD_gnutlsMHD_pkcs12_t;
+  typedef struct MHD_gnutlsMHD_pkcs12_bag_int *MHD_gnutlsMHD_pkcs12_bag_t;
 
-  int gnutls_pkcs12_init (gnutls_pkcs12_t * pkcs12);
-  void gnutls_pkcs12_deinit (gnutls_pkcs12_t pkcs12);
-  int gnutls_pkcs12_import (gnutls_pkcs12_t pkcs12,
-                            const gnutls_datum_t * data,
-                            gnutls_x509_crt_fmt_t format, unsigned int flags);
-  int gnutls_pkcs12_export (gnutls_pkcs12_t pkcs12,
-                            gnutls_x509_crt_fmt_t format,
+  int MHD_gnutlsMHD_pkcs12_init (MHD_gnutlsMHD_pkcs12_t * pkcs12);
+  void MHD_gnutlsMHD_pkcs12_deinit (MHD_gnutlsMHD_pkcs12_t pkcs12);
+  int MHD_gnutlsMHD_pkcs12_import (MHD_gnutlsMHD_pkcs12_t pkcs12,
+                            const MHD_gnutls_datum_t * data,
+                            MHD_gnutls_x509_crt_fmt_t format, unsigned int flags);
+  int MHD_gnutlsMHD_pkcs12_export (MHD_gnutlsMHD_pkcs12_t pkcs12,
+                            MHD_gnutls_x509_crt_fmt_t format,
                             void *output_data, size_t * output_data_size);
 
-  int gnutls_pkcs12_get_bag (gnutls_pkcs12_t pkcs12,
-                             int indx, gnutls_pkcs12_bag_t bag);
-  int gnutls_pkcs12_set_bag (gnutls_pkcs12_t pkcs12, gnutls_pkcs12_bag_t bag);
+  int MHD_gnutlsMHD_pkcs12_get_bag (MHD_gnutlsMHD_pkcs12_t pkcs12,
+                             int indx, MHD_gnutlsMHD_pkcs12_bag_t bag);
+  int MHD_gnutlsMHD_pkcs12_set_bag (MHD_gnutlsMHD_pkcs12_t pkcs12, MHD_gnutlsMHD_pkcs12_bag_t bag);
 
-  int gnutls_pkcs12_generate_mac (gnutls_pkcs12_t pkcs12, const char *pass);
-  int gnutls_pkcs12_verify_mac (gnutls_pkcs12_t pkcs12, const char *pass);
+  int MHD_gnutlsMHD_pkcs12_generate_mac (MHD_gnutlsMHD_pkcs12_t pkcs12, const char *pass);
+  int MHD_gnutlsMHD_pkcs12_verify_mac (MHD_gnutlsMHD_pkcs12_t pkcs12, const char *pass);
 
-  int gnutls_pkcs12_bag_decrypt (gnutls_pkcs12_bag_t bag, const char *pass);
-  int gnutls_pkcs12_bag_encrypt (gnutls_pkcs12_bag_t bag,
+  int MHD_gnutlsMHD_pkcs12_bag_decrypt (MHD_gnutlsMHD_pkcs12_bag_t bag, const char *pass);
+  int MHD_gnutlsMHD_pkcs12_bag_encrypt (MHD_gnutlsMHD_pkcs12_bag_t bag,
                                  const char *pass, unsigned int flags);
 
-  gnutls_pkcs12_bag_type_t gnutls_pkcs12_bag_get_type (gnutls_pkcs12_bag_t
+  MHD_gnutlsMHD_pkcs12_bag_type_t MHD_gnutlsMHD_pkcs12_bag_get_type (MHD_gnutlsMHD_pkcs12_bag_t
                                                        bag, int indx);
-  int gnutls_pkcs12_bag_get_data (gnutls_pkcs12_bag_t bag,
-                                  int indx, gnutls_datum_t * data);
-  int gnutls_pkcs12_bag_set_data (gnutls_pkcs12_bag_t bag,
-                                  gnutls_pkcs12_bag_type_t type,
-                                  const gnutls_datum_t * data);
-  int gnutls_pkcs12_bag_set_crl (gnutls_pkcs12_bag_t bag,
-                                 gnutls_x509_crl_t crl);
-  int gnutls_pkcs12_bag_set_crt (gnutls_pkcs12_bag_t bag,
-                                 gnutls_x509_crt_t crt);
-
-  int gnutls_pkcs12_bag_init (gnutls_pkcs12_bag_t * bag);
-  void gnutls_pkcs12_bag_deinit (gnutls_pkcs12_bag_t bag);
-  int gnutls_pkcs12_bag_get_count (gnutls_pkcs12_bag_t bag);
-
-  int gnutls_pkcs12_bag_get_key_id (gnutls_pkcs12_bag_t bag,
-                                    int indx, gnutls_datum_t * id);
-  int gnutls_pkcs12_bag_set_key_id (gnutls_pkcs12_bag_t bag,
-                                    int indx, const gnutls_datum_t * id);
-
-  int gnutls_pkcs12_bag_get_friendly_name (gnutls_pkcs12_bag_t bag,
+  int MHD_gnutlsMHD_pkcs12_bag_get_data (MHD_gnutlsMHD_pkcs12_bag_t bag,
+                                  int indx, MHD_gnutls_datum_t * data);
+  int MHD_gnutlsMHD_pkcs12_bag_set_data (MHD_gnutlsMHD_pkcs12_bag_t bag,
+                                  MHD_gnutlsMHD_pkcs12_bag_type_t type,
+                                  const MHD_gnutls_datum_t * data);
+  int MHD_gnutlsMHD_pkcs12_bag_set_crl (MHD_gnutlsMHD_pkcs12_bag_t bag,
+                                 MHD_gnutls_x509_crl_t crl);
+  int MHD_gnutlsMHD_pkcs12_bag_set_crt (MHD_gnutlsMHD_pkcs12_bag_t bag,
+                                 MHD_gnutls_x509_crt_t crt);
+
+  int MHD_gnutlsMHD_pkcs12_bag_init (MHD_gnutlsMHD_pkcs12_bag_t * bag);
+  void MHD_gnutlsMHD_pkcs12_bag_deinit (MHD_gnutlsMHD_pkcs12_bag_t bag);
+  int MHD_gnutlsMHD_pkcs12_bag_get_count (MHD_gnutlsMHD_pkcs12_bag_t bag);
+
+  int MHD_gnutlsMHD_pkcs12_bag_get_key_id (MHD_gnutlsMHD_pkcs12_bag_t bag,
+                                    int indx, MHD_gnutls_datum_t * id);
+  int MHD_gnutlsMHD_pkcs12_bag_set_key_id (MHD_gnutlsMHD_pkcs12_bag_t bag,
+                                    int indx, const MHD_gnutls_datum_t * id);
+
+  int MHD_gnutlsMHD_pkcs12_bag_get_friendly_name (MHD_gnutlsMHD_pkcs12_bag_t bag,
                                            int indx, char **name);
-  int gnutls_pkcs12_bag_set_friendly_name (gnutls_pkcs12_bag_t bag,
+  int MHD_gnutlsMHD_pkcs12_bag_set_friendly_name (MHD_gnutlsMHD_pkcs12_bag_t bag,
                                            int indx, const char *name);
 
 #ifdef __cplusplus
@@ -138,27 +138,27 @@ extern "C"
 #define DATA_OID "1.2.840.113549.1.7.1"
 #define ENC_DATA_OID "1.2.840.113549.1.7.6"
 
-int gnutls_pkcs12_init (gnutls_pkcs12_t * pkcs12);
-void gnutls_pkcs12_deinit (gnutls_pkcs12_t pkcs12);
-int gnutls_pkcs12_import (gnutls_pkcs12_t pkcs12,
-                          const gnutls_datum_t * data,
-                          gnutls_x509_crt_fmt_t format, unsigned int flags);
+int MHD_gnutlsMHD_pkcs12_init (MHD_gnutlsMHD_pkcs12_t * pkcs12);
+void MHD_gnutlsMHD_pkcs12_deinit (MHD_gnutlsMHD_pkcs12_t pkcs12);
+int MHD_gnutlsMHD_pkcs12_import (MHD_gnutlsMHD_pkcs12_t pkcs12,
+                          const MHD_gnutls_datum_t * data,
+                          MHD_gnutls_x509_crt_fmt_t format, unsigned int flags);
 
-int gnutls_pkcs12_get_bag (gnutls_pkcs12_t pkcs12,
-                           int indx, gnutls_pkcs12_bag_t bag);
+int MHD_gnutlsMHD_pkcs12_get_bag (MHD_gnutlsMHD_pkcs12_t pkcs12,
+                           int indx, MHD_gnutlsMHD_pkcs12_bag_t bag);
 
-int gnutls_pkcs12_bag_init (gnutls_pkcs12_bag_t * bag);
-void gnutls_pkcs12_bag_deinit (gnutls_pkcs12_bag_t bag);
+int MHD_gnutlsMHD_pkcs12_bag_init (MHD_gnutlsMHD_pkcs12_bag_t * bag);
+void MHD_gnutlsMHD_pkcs12_bag_deinit (MHD_gnutlsMHD_pkcs12_bag_t bag);
 
-int _pkcs12_string_to_key (unsigned int id,
+int MHD_pkcs12_string_to_key (unsigned int id,
                            const opaque * salt,
                            unsigned int salt_size,
                            unsigned int iter,
                            const char *pw,
                            unsigned int req_keylen, opaque * keybuf);
 
-int _gnutls_pkcs7_decrypt_data (const gnutls_datum_t * data,
-                                const char *password, gnutls_datum_t * dec);
+int MHD__gnutls_pkcs7_decrypt_data (const MHD_gnutls_datum_t * data,
+                                const char *password, MHD_gnutls_datum_t * dec);
 
 typedef enum schema_id
 {
@@ -168,18 +168,18 @@ typedef enum schema_id
   PKCS12_RC2_40_SHA1
 } schema_id;
 
-int _gnutls_pkcs7_encrypt_data (schema_id schema,
-                                const gnutls_datum_t * data,
-                                const char *password, gnutls_datum_t * enc);
-int _pkcs12_decode_safe_contents (const gnutls_datum_t * content,
-                                  gnutls_pkcs12_bag_t bag);
+int MHD__gnutls_pkcs7_encrypt_data (schema_id schema,
+                                const MHD_gnutls_datum_t * data,
+                                const char *password, MHD_gnutls_datum_t * enc);
+int MHD_pkcs12_decode_safe_contents (const MHD_gnutls_datum_t * content,
+                                  MHD_gnutlsMHD_pkcs12_bag_t bag);
 
-int _pkcs12_encode_safe_contents (gnutls_pkcs12_bag_t bag,
+int MHD_pkcs12_encode_safe_contents (MHD_gnutlsMHD_pkcs12_bag_t bag,
                                   ASN1_TYPE * content, int *enc);
 
-int _pkcs12_decode_crt_bag (gnutls_pkcs12_bag_type_t type,
-                            const gnutls_datum_t * in, gnutls_datum_t * out);
-int _pkcs12_encode_crt_bag (gnutls_pkcs12_bag_type_t type,
-                            const gnutls_datum_t * raw, gnutls_datum_t * out);
+int MHD_pkcs12_decode_crt_bag (MHD_gnutlsMHD_pkcs12_bag_type_t type,
+                            const MHD_gnutls_datum_t * in, MHD_gnutls_datum_t * out);
+int MHD_pkcs12_encode_crt_bag (MHD_gnutlsMHD_pkcs12_bag_type_t type,
+                            const MHD_gnutls_datum_t * raw, MHD_gnutls_datum_t * out);
 
 #endif /* GNUTLS_PKCS12_H */
diff --git a/src/daemon/https/x509/pkcs12_bag.c b/src/daemon/https/x509/pkcs12_bag.c
index 63b290bc..10529273 100644
--- a/src/daemon/https/x509/pkcs12_bag.c
+++ b/src/daemon/https/x509/pkcs12_bag.c
@@ -37,7 +37,7 @@
 #include <privkey.h>
 
 /**
-  * gnutls_pkcs12_bag_init - This function initializes a gnutls_pkcs12_bag_t  structure
+  * MHD_gnutlsMHD_pkcs12_bag_init - This function initializes a MHD_gnutlsMHD_pkcs12_bag_t  structure
   * @bag: The structure to be initialized
   *
   * This function will initialize a PKCS12 bag structure. PKCS12 Bags
@@ -48,9 +48,9 @@
   *
   **/
 int
-gnutls_pkcs12_bag_init (gnutls_pkcs12_bag_t * bag)
+MHD_gnutlsMHD_pkcs12_bag_init (MHD_gnutlsMHD_pkcs12_bag_t * bag)
 {
-  *bag = gnutls_calloc (1, sizeof (gnutls_pkcs12_bag_int));
+  *bag = MHD_gnutls_calloc (1, sizeof (MHD_gnutlsMHD_pkcs12_bag_int));
 
   if (*bag)
     {
@@ -60,15 +60,15 @@ gnutls_pkcs12_bag_init (gnutls_pkcs12_bag_t * bag)
 }
 
 static inline void
-_pkcs12_bag_free_data (gnutls_pkcs12_bag_t bag)
+MHD_pkcs12_bag_free_data (MHD_gnutlsMHD_pkcs12_bag_t bag)
 {
   int i;
 
   for (i = 0; i < bag->bag_elements; i++)
     {
-      _gnutls_free_datum (&bag->element[i].data);
-      _gnutls_free_datum (&bag->element[i].local_key_id);
-      gnutls_free (bag->element[i].friendly_name);
+      MHD__gnutls_free_datum (&bag->element[i].data);
+      MHD__gnutls_free_datum (&bag->element[i].local_key_id);
+      MHD_gnutls_free (bag->element[i].friendly_name);
       bag->element[i].friendly_name = NULL;
       bag->element[i].type = 0;
     }
@@ -77,38 +77,38 @@ _pkcs12_bag_free_data (gnutls_pkcs12_bag_t bag)
 
 
 /**
-  * gnutls_pkcs12_bag_deinit - This function deinitializes memory used by a gnutls_pkcs12_t structure
+  * MHD_gnutlsMHD_pkcs12_bag_deinit - This function deinitializes memory used by a MHD_gnutlsMHD_pkcs12_t structure
   * @bag: The structure to be initialized
   *
   * This function will deinitialize a PKCS12 Bag structure.
   *
   **/
 void
-gnutls_pkcs12_bag_deinit (gnutls_pkcs12_bag_t bag)
+MHD_gnutlsMHD_pkcs12_bag_deinit (MHD_gnutlsMHD_pkcs12_bag_t bag)
 {
   if (!bag)
     return;
 
-  _pkcs12_bag_free_data (bag);
+  MHD_pkcs12_bag_free_data (bag);
 
-  gnutls_free (bag);
+  MHD_gnutls_free (bag);
 }
 
 /**
-  * gnutls_pkcs12_bag_get_type - This function returns the bag's type
+  * MHD_gnutlsMHD_pkcs12_bag_get_type - This function returns the bag's type
   * @bag: The bag
   * @indx: The element of the bag to get the type
   *
-  * This function will return the bag's type. One of the gnutls_pkcs12_bag_type_t
+  * This function will return the bag's type. One of the MHD_gnutlsMHD_pkcs12_bag_type_t
   * enumerations.
   *
   **/
-gnutls_pkcs12_bag_type_t
-gnutls_pkcs12_bag_get_type (gnutls_pkcs12_bag_t bag, int indx)
+MHD_gnutlsMHD_pkcs12_bag_type_t
+MHD_gnutlsMHD_pkcs12_bag_get_type (MHD_gnutlsMHD_pkcs12_bag_t bag, int indx)
 {
   if (bag == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -118,18 +118,18 @@ gnutls_pkcs12_bag_get_type (gnutls_pkcs12_bag_t bag, int indx)
 }
 
 /**
-  * gnutls_pkcs12_bag_get_count - This function returns the bag's elements count
+  * MHD_gnutlsMHD_pkcs12_bag_get_count - This function returns the bag's elements count
   * @bag: The bag
   *
   * This function will return the number of the elements withing the bag.
   *
   **/
 int
-gnutls_pkcs12_bag_get_count (gnutls_pkcs12_bag_t bag)
+MHD_gnutlsMHD_pkcs12_bag_get_count (MHD_gnutlsMHD_pkcs12_bag_t bag)
 {
   if (bag == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -137,7 +137,7 @@ gnutls_pkcs12_bag_get_count (gnutls_pkcs12_bag_t bag)
 }
 
 /**
-  * gnutls_pkcs12_bag_get_data - This function returns the bag's data
+  * MHD_gnutlsMHD_pkcs12_bag_get_data - This function returns the bag's data
   * @bag: The bag
   * @indx: The element of the bag to get the data from
   * @data: where the bag's data will be. Should be treated as constant.
@@ -150,12 +150,12 @@ gnutls_pkcs12_bag_get_count (gnutls_pkcs12_bag_t bag)
   *
   **/
 int
-gnutls_pkcs12_bag_get_data (gnutls_pkcs12_bag_t bag, int indx,
-                            gnutls_datum_t * data)
+MHD_gnutlsMHD_pkcs12_bag_get_data (MHD_gnutlsMHD_pkcs12_bag_t bag, int indx,
+                            MHD_gnutls_datum_t * data)
 {
   if (bag == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -172,161 +172,161 @@ gnutls_pkcs12_bag_get_data (gnutls_pkcs12_bag_t bag, int indx,
 #define X509_CRL_OID  "1.2.840.113549.1.9.23.1"
 
 int
-_pkcs12_decode_crt_bag (gnutls_pkcs12_bag_type_t type,
-                        const gnutls_datum_t * in, gnutls_datum_t * out)
+MHD_pkcs12_decode_crt_bag (MHD_gnutlsMHD_pkcs12_bag_type_t type,
+                        const MHD_gnutls_datum_t * in, MHD_gnutls_datum_t * out)
 {
   int ret;
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
 
   if (type == GNUTLS_BAG_CERTIFICATE)
     {
-      if ((ret = asn1_create_element (_gnutls_get_pkix (),
+      if ((ret = MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                                       "PKIX1.pkcs-12-CertBag",
                                       &c2)) != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          ret = mhd_gtls_asn2err (ret);
+          MHD_gnutls_assert ();
+          ret = MHD_gtls_asn2err (ret);
           goto cleanup;
         }
 
-      ret = asn1_der_decoding (&c2, in->data, in->size, NULL);
+      ret = MHD__asn1_der_decoding (&c2, in->data, in->size, NULL);
       if (ret != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          ret = mhd_gtls_asn2err (ret);
+          MHD_gnutls_assert ();
+          ret = MHD_gtls_asn2err (ret);
           goto cleanup;
         }
 
-      ret = _gnutls_x509_read_value (c2, "certValue", out, 1);
+      ret = MHD__gnutls_x509_read_value (c2, "certValue", out, 1);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           goto cleanup;
         }
 
     }
   else
     {                           /* CRL */
-      if ((ret = asn1_create_element (_gnutls_get_pkix (),
+      if ((ret = MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                                       "PKIX1.pkcs-12-CRLBag",
                                       &c2)) != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          ret = mhd_gtls_asn2err (ret);
+          MHD_gnutls_assert ();
+          ret = MHD_gtls_asn2err (ret);
           goto cleanup;
         }
 
-      ret = asn1_der_decoding (&c2, in->data, in->size, NULL);
+      ret = MHD__asn1_der_decoding (&c2, in->data, in->size, NULL);
       if (ret != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          ret = mhd_gtls_asn2err (ret);
+          MHD_gnutls_assert ();
+          ret = MHD_gtls_asn2err (ret);
           goto cleanup;
         }
 
-      ret = _gnutls_x509_read_value (c2, "crlValue", out, 1);
+      ret = MHD__gnutls_x509_read_value (c2, "crlValue", out, 1);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           goto cleanup;
         }
     }
 
-  asn1_delete_structure (&c2);
+  MHD__asn1_delete_structure (&c2);
 
   return 0;
 
 
 cleanup:
 
-  asn1_delete_structure (&c2);
+  MHD__asn1_delete_structure (&c2);
   return ret;
 }
 
 
 int
-_pkcs12_encode_crt_bag (gnutls_pkcs12_bag_type_t type,
-                        const gnutls_datum_t * raw, gnutls_datum_t * out)
+MHD_pkcs12_encode_crt_bag (MHD_gnutlsMHD_pkcs12_bag_type_t type,
+                        const MHD_gnutls_datum_t * raw, MHD_gnutls_datum_t * out)
 {
   int ret;
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
 
   if (type == GNUTLS_BAG_CERTIFICATE)
     {
-      if ((ret = asn1_create_element (_gnutls_get_pkix (),
+      if ((ret = MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                                       "PKIX1.pkcs-12-CertBag",
                                       &c2)) != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          ret = mhd_gtls_asn2err (ret);
+          MHD_gnutls_assert ();
+          ret = MHD_gtls_asn2err (ret);
           goto cleanup;
         }
 
-      ret = asn1_write_value (c2, "certId", X509_CERT_OID, 1);
+      ret = MHD__asn1_write_value (c2, "certId", X509_CERT_OID, 1);
       if (ret != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          ret = mhd_gtls_asn2err (ret);
+          MHD_gnutls_assert ();
+          ret = MHD_gtls_asn2err (ret);
           goto cleanup;
         }
 
-      ret = _gnutls_x509_write_value (c2, "certValue", raw, 1);
+      ret = MHD__gnutls_x509_write_value (c2, "certValue", raw, 1);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           goto cleanup;
         }
 
     }
   else
     {                           /* CRL */
-      if ((ret = asn1_create_element (_gnutls_get_pkix (),
+      if ((ret = MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                                       "PKIX1.pkcs-12-CRLBag",
                                       &c2)) != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          ret = mhd_gtls_asn2err (ret);
+          MHD_gnutls_assert ();
+          ret = MHD_gtls_asn2err (ret);
           goto cleanup;
         }
 
-      ret = asn1_write_value (c2, "crlId", X509_CRL_OID, 1);
+      ret = MHD__asn1_write_value (c2, "crlId", X509_CRL_OID, 1);
       if (ret != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          ret = mhd_gtls_asn2err (ret);
+          MHD_gnutls_assert ();
+          ret = MHD_gtls_asn2err (ret);
           goto cleanup;
         }
 
-      ret = _gnutls_x509_write_value (c2, "crlValue", raw, 1);
+      ret = MHD__gnutls_x509_write_value (c2, "crlValue", raw, 1);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           goto cleanup;
         }
     }
 
-  ret = _gnutls_x509_der_encode (c2, "", out, 0);
+  ret = MHD__gnutls_x509_der_encode (c2, "", out, 0);
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  asn1_delete_structure (&c2);
+  MHD__asn1_delete_structure (&c2);
 
   return 0;
 
 
 cleanup:
 
-  asn1_delete_structure (&c2);
+  MHD__asn1_delete_structure (&c2);
   return ret;
 }
 
 
 /**
-  * gnutls_pkcs12_bag_set_data - This function inserts data into the bag
+  * MHD_gnutlsMHD_pkcs12_bag_set_data - This function inserts data into the bag
   * @bag: The bag
   * @type: The data's type
   * @data: the data to be copied.
@@ -339,20 +339,20 @@ cleanup:
   *
   **/
 int
-gnutls_pkcs12_bag_set_data (gnutls_pkcs12_bag_t bag,
-                            gnutls_pkcs12_bag_type_t type,
-                            const gnutls_datum_t * data)
+MHD_gnutlsMHD_pkcs12_bag_set_data (MHD_gnutlsMHD_pkcs12_bag_t bag,
+                            MHD_gnutlsMHD_pkcs12_bag_type_t type,
+                            const MHD_gnutls_datum_t * data)
 {
   int ret;
   if (bag == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   if (bag->bag_elements == MAX_BAG_ELEMENTS - 1)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       /* bag is full */
       return GNUTLS_E_MEMORY_ERROR;
     }
@@ -367,18 +367,18 @@ gnutls_pkcs12_bag_set_data (gnutls_pkcs12_bag_t bag,
           bag->element[0].type == GNUTLS_BAG_PKCS8_ENCRYPTED_KEY ||
           bag->element[0].type == GNUTLS_BAG_ENCRYPTED)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_INVALID_REQUEST;
         }
     }
 
   ret =
-    _gnutls_set_datum (&bag->element[bag->bag_elements].data,
+    MHD__gnutls_set_datum (&bag->element[bag->bag_elements].data,
                        data->data, data->size);
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -390,84 +390,84 @@ gnutls_pkcs12_bag_set_data (gnutls_pkcs12_bag_t bag,
 }
 
 /**
-  * gnutls_pkcs12_bag_set_crt - This function inserts a certificate into the bag
+  * MHD_gnutlsMHD_pkcs12_bag_set_crt - This function inserts a certificate into the bag
   * @bag: The bag
   * @crt: the certificate to be copied.
   *
   * This function will insert the given certificate into the
-  * bag. This is just a wrapper over gnutls_pkcs12_bag_set_data().
+  * bag. This is just a wrapper over MHD_gnutlsMHD_pkcs12_bag_set_data().
   *
   * Returns the index of the added bag on success, or a negative
   * value on failure.
   *
   **/
 int
-gnutls_pkcs12_bag_set_crt (gnutls_pkcs12_bag_t bag, gnutls_x509_crt_t crt)
+MHD_gnutlsMHD_pkcs12_bag_set_crt (MHD_gnutlsMHD_pkcs12_bag_t bag, MHD_gnutls_x509_crt_t crt)
 {
   int ret;
-  gnutls_datum_t data;
+  MHD_gnutls_datum_t data;
 
   if (bag == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  ret = _gnutls_x509_der_encode (crt->cert, "", &data, 0);
+  ret = MHD__gnutls_x509_der_encode (crt->cert, "", &data, 0);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  ret = gnutls_pkcs12_bag_set_data (bag, GNUTLS_BAG_CERTIFICATE, &data);
+  ret = MHD_gnutlsMHD_pkcs12_bag_set_data (bag, GNUTLS_BAG_CERTIFICATE, &data);
 
-  _gnutls_free_datum (&data);
+  MHD__gnutls_free_datum (&data);
 
   return ret;
 }
 
 /**
-  * gnutls_pkcs12_bag_set_crl - This function inserts the CRL into the bag
+  * MHD_gnutlsMHD_pkcs12_bag_set_crl - This function inserts the CRL into the bag
   * @bag: The bag
   * @crl: the CRL to be copied.
   *
   * This function will insert the given CRL into the
-  * bag. This is just a wrapper over gnutls_pkcs12_bag_set_data().
+  * bag. This is just a wrapper over MHD_gnutlsMHD_pkcs12_bag_set_data().
   *
   * Returns the index of the added bag on success, or a negative
   * value on failure.
   *
   **/
 int
-gnutls_pkcs12_bag_set_crl (gnutls_pkcs12_bag_t bag, gnutls_x509_crl_t crl)
+MHD_gnutlsMHD_pkcs12_bag_set_crl (MHD_gnutlsMHD_pkcs12_bag_t bag, MHD_gnutls_x509_crl_t crl)
 {
   int ret;
-  gnutls_datum_t data;
+  MHD_gnutls_datum_t data;
 
 
   if (bag == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  ret = _gnutls_x509_der_encode (crl->crl, "", &data, 0);
+  ret = MHD__gnutls_x509_der_encode (crl->crl, "", &data, 0);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  ret = gnutls_pkcs12_bag_set_data (bag, GNUTLS_BAG_CRL, &data);
+  ret = MHD_gnutlsMHD_pkcs12_bag_set_data (bag, GNUTLS_BAG_CRL, &data);
 
-  _gnutls_free_datum (&data);
+  MHD__gnutls_free_datum (&data);
 
   return ret;
 }
 
 /**
-  * gnutls_pkcs12_bag_set_key_id - This function sets a key ID into the bag element
+  * MHD_gnutlsMHD_pkcs12_bag_set_key_id - This function sets a key ID into the bag element
   * @bag: The bag
   * @indx: The bag's element to add the id
   * @id: the ID
@@ -480,30 +480,30 @@ gnutls_pkcs12_bag_set_crl (gnutls_pkcs12_bag_t bag, gnutls_x509_crl_t crl)
   *
   **/
 int
-gnutls_pkcs12_bag_set_key_id (gnutls_pkcs12_bag_t bag, int indx,
-                              const gnutls_datum_t * id)
+MHD_gnutlsMHD_pkcs12_bag_set_key_id (MHD_gnutlsMHD_pkcs12_bag_t bag, int indx,
+                              const MHD_gnutls_datum_t * id)
 {
   int ret;
 
 
   if (bag == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   if (indx > bag->bag_elements - 1)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  ret = _gnutls_set_datum (&bag->element[indx].local_key_id,
+  ret = MHD__gnutls_set_datum (&bag->element[indx].local_key_id,
                            id->data, id->size);
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -511,7 +511,7 @@ gnutls_pkcs12_bag_set_key_id (gnutls_pkcs12_bag_t bag, int indx,
 }
 
 /**
-  * gnutls_pkcs12_bag_get_key_id - This function gets the key ID from the bag element
+  * MHD_gnutlsMHD_pkcs12_bag_get_key_id - This function gets the key ID from the bag element
   * @bag: The bag
   * @indx: The bag's element to add the id
   * @id: where the ID will be copied (to be treated as const)
@@ -523,18 +523,18 @@ gnutls_pkcs12_bag_set_key_id (gnutls_pkcs12_bag_t bag, int indx,
   *
   **/
 int
-gnutls_pkcs12_bag_get_key_id (gnutls_pkcs12_bag_t bag, int indx,
-                              gnutls_datum_t * id)
+MHD_gnutlsMHD_pkcs12_bag_get_key_id (MHD_gnutlsMHD_pkcs12_bag_t bag, int indx,
+                              MHD_gnutls_datum_t * id)
 {
   if (bag == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   if (indx > bag->bag_elements - 1)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -545,7 +545,7 @@ gnutls_pkcs12_bag_get_key_id (gnutls_pkcs12_bag_t bag, int indx,
 }
 
 /**
-  * gnutls_pkcs12_bag_get_friendly_name - This function returns the friendly name of the bag element
+  * MHD_gnutlsMHD_pkcs12_bag_get_friendly_name - This function returns the friendly name of the bag element
   * @bag: The bag
   * @indx: The bag's element to add the id
   * @name: will hold a pointer to the name (to be treated as const)
@@ -557,18 +557,18 @@ gnutls_pkcs12_bag_get_key_id (gnutls_pkcs12_bag_t bag, int indx,
   *
   **/
 int
-gnutls_pkcs12_bag_get_friendly_name (gnutls_pkcs12_bag_t bag, int indx,
+MHD_gnutlsMHD_pkcs12_bag_get_friendly_name (MHD_gnutlsMHD_pkcs12_bag_t bag, int indx,
                                      char **name)
 {
   if (bag == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   if (indx > bag->bag_elements - 1)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -579,7 +579,7 @@ gnutls_pkcs12_bag_get_friendly_name (gnutls_pkcs12_bag_t bag, int indx,
 
 
 /**
-  * gnutls_pkcs12_bag_set_friendly_name - This function sets a friendly name into the bag element
+  * MHD_gnutlsMHD_pkcs12_bag_set_friendly_name - This function sets a friendly name into the bag element
   * @bag: The bag
   * @indx: The bag's element to add the id
   * @name: the name
@@ -592,26 +592,26 @@ gnutls_pkcs12_bag_get_friendly_name (gnutls_pkcs12_bag_t bag, int indx,
   *
   **/
 int
-gnutls_pkcs12_bag_set_friendly_name (gnutls_pkcs12_bag_t bag, int indx,
+MHD_gnutlsMHD_pkcs12_bag_set_friendly_name (MHD_gnutlsMHD_pkcs12_bag_t bag, int indx,
                                      const char *name)
 {
   if (bag == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   if (indx > bag->bag_elements - 1)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  bag->element[indx].friendly_name = gnutls_strdup (name);
+  bag->element[indx].friendly_name = MHD_gnutls_strdup (name);
 
   if (name == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
@@ -620,7 +620,7 @@ gnutls_pkcs12_bag_set_friendly_name (gnutls_pkcs12_bag_t bag, int indx,
 
 
 /**
-  * gnutls_pkcs12_bag_decrypt - This function will decrypt an encrypted bag
+  * MHD_gnutlsMHD_pkcs12_bag_decrypt - This function will decrypt an encrypted bag
   * @bag: The bag
   * @pass: The password used for encryption. This can only be ASCII.
   *
@@ -628,28 +628,28 @@ gnutls_pkcs12_bag_set_friendly_name (gnutls_pkcs12_bag_t bag, int indx,
   *
   **/
 int
-gnutls_pkcs12_bag_decrypt (gnutls_pkcs12_bag_t bag, const char *pass)
+MHD_gnutlsMHD_pkcs12_bag_decrypt (MHD_gnutlsMHD_pkcs12_bag_t bag, const char *pass)
 {
   int ret;
-  gnutls_datum_t dec;
+  MHD_gnutls_datum_t dec;
 
   if (bag == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   if (bag->element[0].type != GNUTLS_BAG_ENCRYPTED)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  ret = _gnutls_pkcs7_decrypt_data (&bag->element[0].data, pass, &dec);
+  ret = MHD__gnutls_pkcs7_decrypt_data (&bag->element[0].data, pass, &dec);
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -657,15 +657,15 @@ gnutls_pkcs12_bag_decrypt (gnutls_pkcs12_bag_t bag, const char *pass)
    * stuff, and parse it.
    */
 
-  _gnutls_free_datum (&bag->element[0].data);
+  MHD__gnutls_free_datum (&bag->element[0].data);
 
-  ret = _pkcs12_decode_safe_contents (&dec, bag);
+  ret = MHD_pkcs12_decode_safe_contents (&dec, bag);
 
-  _gnutls_free_datum (&dec);
+  MHD__gnutls_free_datum (&dec);
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -673,61 +673,61 @@ gnutls_pkcs12_bag_decrypt (gnutls_pkcs12_bag_t bag, const char *pass)
 }
 
 /**
-  * gnutls_pkcs12_bag_encrypt - This function will encrypt a bag
+  * MHD_gnutlsMHD_pkcs12_bag_encrypt - This function will encrypt a bag
   * @bag: The bag
   * @pass: The password used for encryption. This can only be ASCII.
-  * @flags: should be one of gnutls_pkcs_encrypt_flags_t elements bitwise or'd
+  * @flags: should be one of MHD_gnutls_pkcs_encrypt_flags_t elements bitwise or'd
   *
   * This function will encrypt the given bag and return 0 on success.
   *
   **/
 int
-gnutls_pkcs12_bag_encrypt (gnutls_pkcs12_bag_t bag, const char *pass,
+MHD_gnutlsMHD_pkcs12_bag_encrypt (MHD_gnutlsMHD_pkcs12_bag_t bag, const char *pass,
                            unsigned int flags)
 {
   int ret;
   ASN1_TYPE safe_cont = ASN1_TYPE_EMPTY;
-  gnutls_datum_t der = { NULL, 0 };
-  gnutls_datum_t enc = { NULL, 0 };
+  MHD_gnutls_datum_t der = { NULL, 0 };
+  MHD_gnutls_datum_t enc = { NULL, 0 };
   schema_id id;
 
   if (bag == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   if (bag->element[0].type == GNUTLS_BAG_ENCRYPTED)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   /* Encode the whole bag to a safe contents
    * structure.
    */
-  ret = _pkcs12_encode_safe_contents (bag, &safe_cont, NULL);
+  ret = MHD_pkcs12_encode_safe_contents (bag, &safe_cont, NULL);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
   /* DER encode the SafeContents.
    */
-  ret = _gnutls_x509_der_encode (safe_cont, "", &der, 0);
+  ret = MHD__gnutls_x509_der_encode (safe_cont, "", &der, 0);
 
-  asn1_delete_structure (&safe_cont);
+  MHD__asn1_delete_structure (&safe_cont);
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
   if (flags & GNUTLS_PKCS_PLAIN)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -742,20 +742,20 @@ gnutls_pkcs12_bag_encrypt (gnutls_pkcs12_bag_t bag, const char *pass,
 
   /* Now encrypt them.
    */
-  ret = _gnutls_pkcs7_encrypt_data (id, &der, pass, &enc);
+  ret = MHD__gnutls_pkcs7_encrypt_data (id, &der, pass, &enc);
 
-  _gnutls_free_datum (&der);
+  MHD__gnutls_free_datum (&der);
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
   /* encryption succeeded.
    */
 
-  _pkcs12_bag_free_data (bag);
+  MHD_pkcs12_bag_free_data (bag);
 
   bag->element[0].type = GNUTLS_BAG_ENCRYPTED;
   bag->element[0].data = enc;
diff --git a/src/daemon/https/x509/pkcs12_encr.c b/src/daemon/https/x509/pkcs12_encr.c
index 25a33641..b50520e7 100644
--- a/src/daemon/https/x509/pkcs12_encr.c
+++ b/src/daemon/https/x509/pkcs12_encr.c
@@ -33,7 +33,7 @@
  * code instead.
  */
 static int
-_pkcs12_check_pass (const char *pass, size_t plen)
+MHD_pkcs12_check_pass (const char *pass, size_t plen)
 {
   const unsigned char *p = pass;
   unsigned int i;
@@ -54,14 +54,14 @@ _pkcs12_check_pass (const char *pass, size_t plen)
  * 1 for encryption key
  */
 int
-_pkcs12_string_to_key (unsigned int id, const opaque * salt,
+MHD_pkcs12_string_to_key (unsigned int id, const opaque * salt,
                        unsigned int salt_size, unsigned int iter,
                        const char *pw, unsigned int req_keylen,
                        opaque * keybuf)
 {
   int rc;
   unsigned int i, j;
-  gc_hash_handle md;
+  MHD_gc_hash_handle md;
   mpi_t num_b1 = NULL;
   unsigned int pwlen;
   opaque hash[20], buf_b[64], buf_i[128], *p;
@@ -77,13 +77,13 @@ _pkcs12_string_to_key (unsigned int id, const opaque * salt,
 
   if (pwlen > 63 / 2)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  if ((rc = _pkcs12_check_pass (pw, pwlen)) < 0)
+  if ((rc = MHD_pkcs12_check_pass (pw, pwlen)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return rc;
     }
 
@@ -106,22 +106,22 @@ _pkcs12_string_to_key (unsigned int id, const opaque * salt,
 
   for (;;)
     {
-      rc = gc_hash_open (GC_SHA1, 0, &md);
+      rc = MHD_gc_hash_open (GC_SHA1, 0, &md);
       if (rc)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_DECRYPTION_FAILED;
         }
       for (i = 0; i < 64; i++)
         {
           unsigned char lid = id & 0xFF;
-          gc_hash_write (md, 1, &lid);
+          MHD_gc_hash_write (md, 1, &lid);
         }
-      gc_hash_write (md, pw ? 128 : 64, buf_i);
-      memcpy (hash, gc_hash_read (md), 20);
-      gc_hash_close (md);
+      MHD_gc_hash_write (md, pw ? 128 : 64, buf_i);
+      memcpy (hash, MHD_gc_hash_read (md), 20);
+      MHD_gc_hash_close (md);
       for (i = 1; i < iter; i++)
-        gc_hash_buffer (GC_SHA1, hash, 20, hash);
+        MHD_gc_hash_buffer (GC_SHA1, hash, 20, hash);
       for (i = 0; i < 20 && cur_keylen < req_keylen; i++)
         keybuf[cur_keylen++] = hash[i];
       if (cur_keylen == req_keylen)
@@ -134,10 +134,10 @@ _pkcs12_string_to_key (unsigned int id, const opaque * salt,
       for (i = 0; i < 64; i++)
         buf_b[i] = hash[i % 20];
       n = 64;
-      rc = mhd_gtls_mpi_scan (&num_b1, buf_b, &n);
+      rc = MHD_gtls_mpi_scan (&num_b1, buf_b, &n);
       if (rc < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return rc;
         }
       gcry_mpi_add_ui (num_b1, num_b1, 1);
@@ -146,19 +146,19 @@ _pkcs12_string_to_key (unsigned int id, const opaque * salt,
           mpi_t num_ij;
 
           n = 64;
-          rc = mhd_gtls_mpi_scan (&num_ij, buf_i + i, &n);
+          rc = MHD_gtls_mpi_scan (&num_ij, buf_i + i, &n);
           if (rc < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return rc;
             }
           gcry_mpi_add (num_ij, num_ij, num_b1);
           gcry_mpi_clear_highbit (num_ij, 64 * 8);
           n = 64;
-          rc = mhd_gtls_mpi_print (buf_i + i, &n, num_ij);
+          rc = MHD_gtls_mpi_print (buf_i + i, &n, num_ij);
           if (rc < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return rc;
             }
           gcry_mpi_release (num_ij);
diff --git a/src/daemon/https/x509/pkcs7.c b/src/daemon/https/x509/pkcs7.c
index 6af89425..8b0b6b54 100644
--- a/src/daemon/https/x509/pkcs7.c
+++ b/src/daemon/https/x509/pkcs7.c
@@ -46,7 +46,7 @@
  */
 static int
 _decode_pkcs7_signed_data (ASN1_TYPE pkcs7, ASN1_TYPE * sdata,
-                           gnutls_datum_t * raw)
+                           MHD_gnutls_datum_t * raw)
 {
   char oid[128];
   ASN1_TYPE c2;
@@ -54,52 +54,52 @@ _decode_pkcs7_signed_data (ASN1_TYPE pkcs7, ASN1_TYPE * sdata,
   int tmp_size, len, result;
 
   len = sizeof (oid) - 1;
-  result = asn1_read_value (pkcs7, "contentType", oid, &len);
+  result = MHD__asn1_read_value (pkcs7, "contentType", oid, &len);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   if (strcmp (oid, SIGNED_DATA_OID) != 0)
     {
-      gnutls_assert ();
-      _gnutls_x509_log ("Unknown PKCS7 Content OID '%s'\n", oid);
+      MHD_gnutls_assert ();
+      MHD__gnutls_x509_log ("Unknown PKCS7 Content OID '%s'\n", oid);
       return GNUTLS_E_UNKNOWN_PKCS_CONTENT_TYPE;
     }
 
-  if ((result = asn1_create_element
-       (_gnutls_get_pkix (), "PKIX1.pkcs-7-SignedData", &c2)) != ASN1_SUCCESS)
+  if ((result = MHD__asn1_create_element
+       (MHD__gnutls_get_pkix (), "PKIX1.pkcs-7-SignedData", &c2)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   /* the Signed-data has been created, so
    * decode them.
    */
   tmp_size = 0;
-  result = asn1_read_value (pkcs7, "content", NULL, &tmp_size);
+  result = MHD__asn1_read_value (pkcs7, "content", NULL, &tmp_size);
   if (result != ASN1_MEM_ERROR)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  tmp = gnutls_malloc (tmp_size);
+  tmp = MHD_gnutls_malloc (tmp_size);
   if (tmp == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_MEMORY_ERROR;
       goto cleanup;
     }
 
-  result = asn1_read_value (pkcs7, "content", tmp, &tmp_size);
+  result = MHD__asn1_read_value (pkcs7, "content", tmp, &tmp_size);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -110,17 +110,17 @@ _decode_pkcs7_signed_data (ASN1_TYPE pkcs7, ASN1_TYPE * sdata,
   /* Step 1. In case of a signed structure extract certificate set.
    */
 
-  result = asn1_der_decoding (&c2, tmp, tmp_size, NULL);
+  result = MHD__asn1_der_decoding (&c2, tmp, tmp_size, NULL);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   if (raw == NULL)
     {
-      gnutls_free (tmp);
+      MHD_gnutls_free (tmp);
     }
   else
     {
@@ -134,13 +134,13 @@ _decode_pkcs7_signed_data (ASN1_TYPE pkcs7, ASN1_TYPE * sdata,
 
 cleanup:
   if (c2)
-    asn1_delete_structure (&c2);
-  gnutls_free (tmp);
+    MHD__asn1_delete_structure (&c2);
+  MHD_gnutls_free (tmp);
   return result;
 }
 
 /**
-  * gnutls_pkcs7_init - This function initializes a gnutls_pkcs7_t structure
+  * MHD_gnutls_pkcs7_init - This function initializes a MHD_gnutls_pkcs7_t structure
   * @pkcs7: The structure to be initialized
   *
   * This function will initialize a PKCS7 structure. PKCS7 structures
@@ -151,20 +151,20 @@ cleanup:
   *
   **/
 int
-gnutls_pkcs7_init (gnutls_pkcs7_t * pkcs7)
+MHD_gnutls_pkcs7_init (MHD_gnutls_pkcs7_t * pkcs7)
 {
-  *pkcs7 = gnutls_calloc (1, sizeof (gnutls_pkcs7_int));
+  *pkcs7 = MHD_gnutls_calloc (1, sizeof (MHD_gnutls_pkcs7_int));
 
   if (*pkcs7)
     {
-      int result = asn1_create_element (_gnutls_get_pkix (),
+      int result = MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                                         "PKIX1.pkcs-7-ContentInfo",
                                         &(*pkcs7)->pkcs7);
       if (result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          gnutls_free (*pkcs7);
-          return mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          MHD_gnutls_free (*pkcs7);
+          return MHD_gtls_asn2err (result);
         }
       return 0;                 /* success */
     }
@@ -172,32 +172,32 @@ gnutls_pkcs7_init (gnutls_pkcs7_t * pkcs7)
 }
 
 /**
-  * gnutls_pkcs7_deinit - This function deinitializes memory used by a gnutls_pkcs7_t structure
+  * MHD_gnutls_pkcs7_deinit - This function deinitializes memory used by a MHD_gnutls_pkcs7_t structure
   * @pkcs7: The structure to be initialized
   *
   * This function will deinitialize a PKCS7 structure.
   *
   **/
 void
-gnutls_pkcs7_deinit (gnutls_pkcs7_t pkcs7)
+MHD_gnutls_pkcs7_deinit (MHD_gnutls_pkcs7_t pkcs7)
 {
   if (!pkcs7)
     return;
 
   if (pkcs7->pkcs7)
-    asn1_delete_structure (&pkcs7->pkcs7);
+    MHD__asn1_delete_structure (&pkcs7->pkcs7);
 
-  gnutls_free (pkcs7);
+  MHD_gnutls_free (pkcs7);
 }
 
 /**
-  * gnutls_pkcs7_import - This function will import a DER or PEM encoded PKCS7
+  * MHD_gnutls_pkcs7_import - This function will import a DER or PEM encoded PKCS7
   * @pkcs7: The structure to store the parsed PKCS7.
   * @data: The DER or PEM encoded PKCS7.
   * @format: One of DER or PEM
   *
   * This function will convert the given DER or PEM encoded PKCS7
-  * to the native gnutls_pkcs7_t format. The output will be stored in 'pkcs7'.
+  * to the native MHD_gnutls_pkcs7_t format. The output will be stored in 'pkcs7'.
   *
   * If the PKCS7 is PEM encoded it should have a header of "PKCS7".
   *
@@ -205,11 +205,11 @@ gnutls_pkcs7_deinit (gnutls_pkcs7_t pkcs7)
   *
   **/
 int
-gnutls_pkcs7_import (gnutls_pkcs7_t pkcs7, const gnutls_datum_t * data,
-                     gnutls_x509_crt_fmt_t format)
+MHD_gnutls_pkcs7_import (MHD_gnutls_pkcs7_t pkcs7, const MHD_gnutls_datum_t * data,
+                     MHD_gnutls_x509_crt_fmt_t format)
 {
   int result = 0, need_free = 0;
-  gnutls_datum_t _data;
+  MHD_gnutls_datum_t _data;
 
   if (pkcs7 == NULL)
     return GNUTLS_E_INVALID_REQUEST;
@@ -223,14 +223,14 @@ gnutls_pkcs7_import (gnutls_pkcs7_t pkcs7, const gnutls_datum_t * data,
     {
       opaque *out;
 
-      result = _gnutls_fbase64_decode (PEM_PKCS7, data->data, data->size,
+      result = MHD__gnutls_fbase64_decode (PEM_PKCS7, data->data, data->size,
                                        &out);
 
       if (result <= 0)
         {
           if (result == 0)
             result = GNUTLS_E_INTERNAL_ERROR;
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return result;
         }
 
@@ -241,28 +241,28 @@ gnutls_pkcs7_import (gnutls_pkcs7_t pkcs7, const gnutls_datum_t * data,
     }
 
 
-  result = asn1_der_decoding (&pkcs7->pkcs7, _data.data, _data.size, NULL);
+  result = MHD__asn1_der_decoding (&pkcs7->pkcs7, _data.data, _data.size, NULL);
   if (result != ASN1_SUCCESS)
     {
-      result = mhd_gtls_asn2err (result);
-      gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
   if (need_free)
-    _gnutls_free_datum (&_data);
+    MHD__gnutls_free_datum (&_data);
 
   return 0;
 
 cleanup:
   if (need_free)
-    _gnutls_free_datum (&_data);
+    MHD__gnutls_free_datum (&_data);
   return result;
 }
 
 /**
-  * gnutls_pkcs7_get_crt_raw - This function returns a certificate in a PKCS7 certificate set
-  * @pkcs7_struct: should contain a gnutls_pkcs7_t structure
+  * MHD_gnutls_pkcs7_get_crt_raw - This function returns a certificate in a PKCS7 certificate set
+  * @pkcs7_struct: should contain a MHD_gnutls_pkcs7_t structure
   * @indx: contains the index of the certificate to extract
   * @certificate: the contents of the certificate will be copied there (may be null)
   * @certificate_size: should hold the size of the certificate
@@ -276,7 +276,7 @@ cleanup:
   *
   **/
 int
-gnutls_pkcs7_get_crt_raw (gnutls_pkcs7_t pkcs7,
+MHD_gnutls_pkcs7_get_crt_raw (MHD_gnutls_pkcs7_t pkcs7,
                           int indx, void *certificate,
                           size_t * certificate_size)
 {
@@ -284,7 +284,7 @@ gnutls_pkcs7_get_crt_raw (gnutls_pkcs7_t pkcs7,
   int result, len;
   char root2[MAX_NAME_SIZE];
   char oid[128];
-  gnutls_datum_t tmp = { NULL, 0 };
+  MHD_gnutls_datum_t tmp = { NULL, 0 };
 
   if (certificate_size == NULL || pkcs7 == NULL)
     return GNUTLS_E_INVALID_REQUEST;
@@ -294,7 +294,7 @@ gnutls_pkcs7_get_crt_raw (gnutls_pkcs7_t pkcs7,
   result = _decode_pkcs7_signed_data (pkcs7->pkcs7, &c2, &tmp);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -305,7 +305,7 @@ gnutls_pkcs7_get_crt_raw (gnutls_pkcs7_t pkcs7,
 
   len = sizeof (oid) - 1;
 
-  result = asn1_read_value (c2, root2, oid, &len);
+  result = MHD__asn1_read_value (c2, root2, oid, &len);
 
   if (result == ASN1_VALUE_NOT_FOUND)
     {
@@ -315,8 +315,8 @@ gnutls_pkcs7_get_crt_raw (gnutls_pkcs7_t pkcs7,
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -326,13 +326,13 @@ gnutls_pkcs7_get_crt_raw (gnutls_pkcs7_t pkcs7,
     {
       int start, end;
 
-      result = asn1_der_decoding_startEnd (c2, tmp.data, tmp.size,
+      result = MHD__asn1_der_decoding_startEnd (c2, tmp.data, tmp.size,
                                            root2, &start, &end);
 
       if (result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          result = mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          result = MHD_gtls_asn2err (result);
           goto cleanup;
         }
 
@@ -359,15 +359,15 @@ gnutls_pkcs7_get_crt_raw (gnutls_pkcs7_t pkcs7,
     }
 
 cleanup:
-  _gnutls_free_datum (&tmp);
+  MHD__gnutls_free_datum (&tmp);
   if (c2)
-    asn1_delete_structure (&c2);
+    MHD__asn1_delete_structure (&c2);
   return result;
 }
 
 /**
-  * gnutls_pkcs7_get_crt_count - This function returns the number of certificates in a PKCS7 certificate set
-  * @pkcs7_struct: should contain a gnutls_pkcs7_t structure
+  * MHD_gnutls_pkcs7_get_crt_count - This function returns the number of certificates in a PKCS7 certificate set
+  * @pkcs7_struct: should contain a MHD_gnutls_pkcs7_t structure
   *
   * This function will return the number of certifcates in the PKCS7 or
   * RFC2630 certificate set.
@@ -376,7 +376,7 @@ cleanup:
   *
   **/
 int
-gnutls_pkcs7_get_crt_count (gnutls_pkcs7_t pkcs7)
+MHD_gnutls_pkcs7_get_crt_count (MHD_gnutls_pkcs7_t pkcs7)
 {
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
   int result, count;
@@ -389,19 +389,19 @@ gnutls_pkcs7_get_crt_count (gnutls_pkcs7_t pkcs7)
   result = _decode_pkcs7_signed_data (pkcs7->pkcs7, &c2, NULL);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
   /* Step 2. Count the CertificateSet */
 
-  result = asn1_number_of_elements (c2, "certificates", &count);
+  result = MHD__asn1_number_of_elements (c2, "certificates", &count);
 
-  asn1_delete_structure (&c2);
+  MHD__asn1_delete_structure (&c2);
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return 0;                 /* no certificates */
     }
 
@@ -410,7 +410,7 @@ gnutls_pkcs7_get_crt_count (gnutls_pkcs7_t pkcs7)
 }
 
 /**
-  * gnutls_pkcs7_export - This function will export the pkcs7 structure
+  * MHD_gnutls_pkcs7_export - This function will export the pkcs7 structure
   * @pkcs7: Holds the pkcs7 structure
   * @format: the format of output params. One of PEM or DER.
   * @output_data: will contain a structure PEM or DER encoded
@@ -431,14 +431,14 @@ gnutls_pkcs7_get_crt_count (gnutls_pkcs7_t pkcs7)
   *
   **/
 int
-gnutls_pkcs7_export (gnutls_pkcs7_t pkcs7,
-                     gnutls_x509_crt_fmt_t format, void *output_data,
+MHD_gnutls_pkcs7_export (MHD_gnutls_pkcs7_t pkcs7,
+                     MHD_gnutls_x509_crt_fmt_t format, void *output_data,
                      size_t * output_data_size)
 {
   if (pkcs7 == NULL)
     return GNUTLS_E_INVALID_REQUEST;
 
-  return _gnutls_x509_export_int (pkcs7->pkcs7, format, PEM_PKCS7,
+  return MHD__gnutls_x509_export_int (pkcs7->pkcs7, format, PEM_PKCS7,
                                   output_data, output_data_size);
 }
 
@@ -453,22 +453,22 @@ create_empty_signed_data (ASN1_TYPE pkcs7, ASN1_TYPE * sdata)
 
   *sdata = ASN1_TYPE_EMPTY;
 
-  if ((result = asn1_create_element
-       (_gnutls_get_pkix (), "PKIX1.pkcs-7-SignedData",
+  if ((result = MHD__asn1_create_element
+       (MHD__gnutls_get_pkix (), "PKIX1.pkcs-7-SignedData",
         sdata)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   /* Use version 1
    */
-  result = asn1_write_value (*sdata, "version", &one, 1);
+  result = MHD__asn1_write_value (*sdata, "version", &one, 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -477,20 +477,20 @@ create_empty_signed_data (ASN1_TYPE pkcs7, ASN1_TYPE * sdata)
 
   /* id-data */
   result =
-    asn1_write_value (*sdata, "encapContentInfo.eContentType",
+    MHD__asn1_write_value (*sdata, "encapContentInfo.eContentType",
                       "1.2.840.113549.1.7.5", 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  result = asn1_write_value (*sdata, "encapContentInfo.eContent", NULL, 0);
+  result = MHD__asn1_write_value (*sdata, "encapContentInfo.eContent", NULL, 0);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -505,25 +505,25 @@ create_empty_signed_data (ASN1_TYPE pkcs7, ASN1_TYPE * sdata)
 
   /* Write the content type of the signed data
    */
-  result = asn1_write_value (pkcs7, "contentType", SIGNED_DATA_OID, 1);
+  result = MHD__asn1_write_value (pkcs7, "contentType", SIGNED_DATA_OID, 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   return 0;
 
 cleanup:
-  asn1_delete_structure (sdata);
+  MHD__asn1_delete_structure (sdata);
   return result;
 
 }
 
 /**
-  * gnutls_pkcs7_set_crt_raw - This function adds a certificate in a PKCS7 certificate set
-  * @pkcs7_struct: should contain a gnutls_pkcs7_t structure
+  * MHD_gnutls_pkcs7_set_crt_raw - This function adds a certificate in a PKCS7 certificate set
+  * @pkcs7_struct: should contain a MHD_gnutls_pkcs7_t structure
   * @crt: the DER encoded certificate to be added
   *
   * This function will add a certificate to the PKCS7 or RFC2630 certificate set.
@@ -531,7 +531,7 @@ cleanup:
   *
   **/
 int
-gnutls_pkcs7_set_crt_raw (gnutls_pkcs7_t pkcs7, const gnutls_datum_t * crt)
+MHD_gnutls_pkcs7_set_crt_raw (MHD_gnutls_pkcs7_t pkcs7, const MHD_gnutls_datum_t * crt)
 {
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
   int result;
@@ -544,7 +544,7 @@ gnutls_pkcs7_set_crt_raw (gnutls_pkcs7_t pkcs7, const gnutls_datum_t * crt)
   result = _decode_pkcs7_signed_data (pkcs7->pkcs7, &c2, NULL);
   if (result < 0 && result != GNUTLS_E_ASN1_VALUE_NOT_FOUND)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -559,7 +559,7 @@ gnutls_pkcs7_set_crt_raw (gnutls_pkcs7_t pkcs7, const gnutls_datum_t * crt)
       result = create_empty_signed_data (pkcs7->pkcs7, &c2);
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return result;
         }
     }
@@ -567,86 +567,86 @@ gnutls_pkcs7_set_crt_raw (gnutls_pkcs7_t pkcs7, const gnutls_datum_t * crt)
   /* Step 2. Append the new certificate.
    */
 
-  result = asn1_write_value (c2, "certificates", "NEW", 1);
+  result = MHD__asn1_write_value (c2, "certificates", "NEW", 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  result = asn1_write_value (c2, "certificates.?LAST", "certificate", 1);
+  result = MHD__asn1_write_value (c2, "certificates.?LAST", "certificate", 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   result =
-    asn1_write_value (c2, "certificates.?LAST.certificate", crt->data,
+    MHD__asn1_write_value (c2, "certificates.?LAST.certificate", crt->data,
                       crt->size);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   /* Step 3. Replace the old content with the new
    */
   result =
-    _gnutls_x509_der_encode_and_copy (c2, "", pkcs7->pkcs7, "content", 0);
+    MHD__gnutls_x509_der_encode_and_copy (c2, "", pkcs7->pkcs7, "content", 0);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  asn1_delete_structure (&c2);
+  MHD__asn1_delete_structure (&c2);
 
   return 0;
 
 cleanup:
   if (c2)
-    asn1_delete_structure (&c2);
+    MHD__asn1_delete_structure (&c2);
   return result;
 }
 
 /**
-  * gnutls_pkcs7_set_crt - This function adds a parsed certificate in a PKCS7 certificate set
-  * @pkcs7_struct: should contain a gnutls_pkcs7_t structure
+  * MHD_gnutls_pkcs7_set_crt - This function adds a parsed certificate in a PKCS7 certificate set
+  * @pkcs7_struct: should contain a MHD_gnutls_pkcs7_t structure
   * @crt: the certificate to be copied.
   *
   * This function will add a parsed certificate to the PKCS7 or RFC2630 certificate set.
-  * This is a wrapper function over gnutls_pkcs7_set_crt_raw() .
+  * This is a wrapper function over MHD_gnutls_pkcs7_set_crt_raw() .
   *
   * Returns 0 on success.
   *
   **/
 int
-gnutls_pkcs7_set_crt (gnutls_pkcs7_t pkcs7, gnutls_x509_crt_t crt)
+MHD_gnutls_pkcs7_set_crt (MHD_gnutls_pkcs7_t pkcs7, MHD_gnutls_x509_crt_t crt)
 {
   int ret;
-  gnutls_datum_t data;
+  MHD_gnutls_datum_t data;
 
   if (pkcs7 == NULL)
     return GNUTLS_E_INVALID_REQUEST;
 
-  ret = _gnutls_x509_der_encode (crt->cert, "", &data, 0);
+  ret = MHD__gnutls_x509_der_encode (crt->cert, "", &data, 0);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  ret = gnutls_pkcs7_set_crt_raw (pkcs7, &data);
+  ret = MHD_gnutls_pkcs7_set_crt_raw (pkcs7, &data);
 
-  _gnutls_free_datum (&data);
+  MHD__gnutls_free_datum (&data);
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -655,8 +655,8 @@ gnutls_pkcs7_set_crt (gnutls_pkcs7_t pkcs7, gnutls_x509_crt_t crt)
 
 
 /**
-  * gnutls_pkcs7_delete_crt - This function deletes a certificate from a PKCS7 certificate set
-  * @pkcs7_struct: should contain a gnutls_pkcs7_t structure
+  * MHD_gnutls_pkcs7_delete_crt - This function deletes a certificate from a PKCS7 certificate set
+  * @pkcs7_struct: should contain a MHD_gnutls_pkcs7_t structure
   * @indx: the index of the certificate to delete
   *
   * This function will delete a certificate from a PKCS7 or RFC2630 certificate set.
@@ -664,7 +664,7 @@ gnutls_pkcs7_set_crt (gnutls_pkcs7_t pkcs7, gnutls_x509_crt_t crt)
   *
   **/
 int
-gnutls_pkcs7_delete_crt (gnutls_pkcs7_t pkcs7, int indx)
+MHD_gnutls_pkcs7_delete_crt (MHD_gnutls_pkcs7_t pkcs7, int indx)
 {
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
   int result;
@@ -678,7 +678,7 @@ gnutls_pkcs7_delete_crt (gnutls_pkcs7_t pkcs7, int indx)
   result = _decode_pkcs7_signed_data (pkcs7->pkcs7, &c2, NULL);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -687,31 +687,31 @@ gnutls_pkcs7_delete_crt (gnutls_pkcs7_t pkcs7, int indx)
 
   snprintf (root2, sizeof (root2), "certificates.?%u", indx + 1);
 
-  result = asn1_write_value (c2, root2, NULL, 0);
+  result = MHD__asn1_write_value (c2, root2, NULL, 0);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   /* Step 3. Replace the old content with the new
    */
   result =
-    _gnutls_x509_der_encode_and_copy (c2, "", pkcs7->pkcs7, "content", 0);
+    MHD__gnutls_x509_der_encode_and_copy (c2, "", pkcs7->pkcs7, "content", 0);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  asn1_delete_structure (&c2);
+  MHD__asn1_delete_structure (&c2);
 
   return 0;
 
 cleanup:
   if (c2)
-    asn1_delete_structure (&c2);
+    MHD__asn1_delete_structure (&c2);
   return result;
 }
 
@@ -719,8 +719,8 @@ cleanup:
  */
 
 /**
-  * gnutls_pkcs7_get_crl_raw - This function returns a crl in a PKCS7 crl set
-  * @pkcs7_struct: should contain a gnutls_pkcs7_t structure
+  * MHD_gnutls_pkcs7_get_crl_raw - This function returns a crl in a PKCS7 crl set
+  * @pkcs7_struct: should contain a MHD_gnutls_pkcs7_t structure
   * @indx: contains the index of the crl to extract
   * @crl: the contents of the crl will be copied there (may be null)
   * @crl_size: should hold the size of the crl
@@ -734,13 +734,13 @@ cleanup:
   *
   **/
 int
-gnutls_pkcs7_get_crl_raw (gnutls_pkcs7_t pkcs7,
+MHD_gnutls_pkcs7_get_crl_raw (MHD_gnutls_pkcs7_t pkcs7,
                           int indx, void *crl, size_t * crl_size)
 {
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
   int result;
   char root2[MAX_NAME_SIZE];
-  gnutls_datum_t tmp = { NULL, 0 };
+  MHD_gnutls_datum_t tmp = { NULL, 0 };
   int start, end;
 
   if (pkcs7 == NULL || crl_size == NULL)
@@ -751,7 +751,7 @@ gnutls_pkcs7_get_crl_raw (gnutls_pkcs7_t pkcs7,
   result = _decode_pkcs7_signed_data (pkcs7->pkcs7, &c2, &tmp);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -762,13 +762,13 @@ gnutls_pkcs7_get_crl_raw (gnutls_pkcs7_t pkcs7,
 
   /* Get the raw CRL
    */
-  result = asn1_der_decoding_startEnd (c2, tmp.data, tmp.size,
+  result = MHD__asn1_der_decoding_startEnd (c2, tmp.data, tmp.size,
                                        root2, &start, &end);
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -789,15 +789,15 @@ gnutls_pkcs7_get_crl_raw (gnutls_pkcs7_t pkcs7,
   result = 0;
 
 cleanup:
-  _gnutls_free_datum (&tmp);
+  MHD__gnutls_free_datum (&tmp);
   if (c2)
-    asn1_delete_structure (&c2);
+    MHD__asn1_delete_structure (&c2);
   return result;
 }
 
 /**
-  * gnutls_pkcs7_get_crl_count - This function returns the number of crls in a PKCS7 crl set
-  * @pkcs7_struct: should contain a gnutls_pkcs7_t structure
+  * MHD_gnutls_pkcs7_get_crl_count - This function returns the number of crls in a PKCS7 crl set
+  * @pkcs7_struct: should contain a MHD_gnutls_pkcs7_t structure
   *
   * This function will return the number of certifcates in the PKCS7 or
   * RFC2630 crl set.
@@ -806,7 +806,7 @@ cleanup:
   *
   **/
 int
-gnutls_pkcs7_get_crl_count (gnutls_pkcs7_t pkcs7)
+MHD_gnutls_pkcs7_get_crl_count (MHD_gnutls_pkcs7_t pkcs7)
 {
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
   int result, count;
@@ -819,19 +819,19 @@ gnutls_pkcs7_get_crl_count (gnutls_pkcs7_t pkcs7)
   result = _decode_pkcs7_signed_data (pkcs7->pkcs7, &c2, NULL);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
   /* Step 2. Count the CertificateSet */
 
-  result = asn1_number_of_elements (c2, "crls", &count);
+  result = MHD__asn1_number_of_elements (c2, "crls", &count);
 
-  asn1_delete_structure (&c2);
+  MHD__asn1_delete_structure (&c2);
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return 0;                 /* no crls */
     }
 
@@ -840,8 +840,8 @@ gnutls_pkcs7_get_crl_count (gnutls_pkcs7_t pkcs7)
 }
 
 /**
-  * gnutls_pkcs7_set_crl_raw - This function adds a crl in a PKCS7 crl set
-  * @pkcs7_struct: should contain a gnutls_pkcs7_t structure
+  * MHD_gnutls_pkcs7_set_crl_raw - This function adds a crl in a PKCS7 crl set
+  * @pkcs7_struct: should contain a MHD_gnutls_pkcs7_t structure
   * @crl: the DER encoded crl to be added
   *
   * This function will add a crl to the PKCS7 or RFC2630 crl set.
@@ -849,7 +849,7 @@ gnutls_pkcs7_get_crl_count (gnutls_pkcs7_t pkcs7)
   *
   **/
 int
-gnutls_pkcs7_set_crl_raw (gnutls_pkcs7_t pkcs7, const gnutls_datum_t * crl)
+MHD_gnutls_pkcs7_set_crl_raw (MHD_gnutls_pkcs7_t pkcs7, const MHD_gnutls_datum_t * crl)
 {
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
   int result;
@@ -862,7 +862,7 @@ gnutls_pkcs7_set_crl_raw (gnutls_pkcs7_t pkcs7, const gnutls_datum_t * crl)
   result = _decode_pkcs7_signed_data (pkcs7->pkcs7, &c2, NULL);
   if (result < 0 && result != GNUTLS_E_ASN1_VALUE_NOT_FOUND)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -877,7 +877,7 @@ gnutls_pkcs7_set_crl_raw (gnutls_pkcs7_t pkcs7, const gnutls_datum_t * crl)
       result = create_empty_signed_data (pkcs7->pkcs7, &c2);
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return result;
         }
     }
@@ -885,45 +885,45 @@ gnutls_pkcs7_set_crl_raw (gnutls_pkcs7_t pkcs7, const gnutls_datum_t * crl)
   /* Step 2. Append the new crl.
    */
 
-  result = asn1_write_value (c2, "crls", "NEW", 1);
+  result = MHD__asn1_write_value (c2, "crls", "NEW", 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  result = asn1_write_value (c2, "crls.?LAST", crl->data, crl->size);
+  result = MHD__asn1_write_value (c2, "crls.?LAST", crl->data, crl->size);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   /* Step 3. Replace the old content with the new
    */
   result =
-    _gnutls_x509_der_encode_and_copy (c2, "", pkcs7->pkcs7, "content", 0);
+    MHD__gnutls_x509_der_encode_and_copy (c2, "", pkcs7->pkcs7, "content", 0);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  asn1_delete_structure (&c2);
+  MHD__asn1_delete_structure (&c2);
 
   return 0;
 
 cleanup:
   if (c2)
-    asn1_delete_structure (&c2);
+    MHD__asn1_delete_structure (&c2);
   return result;
 }
 
 /**
-  * gnutls_pkcs7_set_crl - This function adds a parsed crl in a PKCS7 crl set
-  * @pkcs7_struct: should contain a gnutls_pkcs7_t structure
+  * MHD_gnutls_pkcs7_set_crl - This function adds a parsed crl in a PKCS7 crl set
+  * @pkcs7_struct: should contain a MHD_gnutls_pkcs7_t structure
   * @crl: the DER encoded crl to be added
   *
   * This function will add a parsed crl to the PKCS7 or RFC2630 crl set.
@@ -931,28 +931,28 @@ cleanup:
   *
   **/
 int
-gnutls_pkcs7_set_crl (gnutls_pkcs7_t pkcs7, gnutls_x509_crl_t crl)
+MHD_gnutls_pkcs7_set_crl (MHD_gnutls_pkcs7_t pkcs7, MHD_gnutls_x509_crl_t crl)
 {
   int ret;
-  gnutls_datum_t data;
+  MHD_gnutls_datum_t data;
 
   if (pkcs7 == NULL)
     return GNUTLS_E_INVALID_REQUEST;
 
-  ret = _gnutls_x509_der_encode (crl->crl, "", &data, 0);
+  ret = MHD__gnutls_x509_der_encode (crl->crl, "", &data, 0);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  ret = gnutls_pkcs7_set_crl_raw (pkcs7, &data);
+  ret = MHD_gnutls_pkcs7_set_crl_raw (pkcs7, &data);
 
-  _gnutls_free_datum (&data);
+  MHD__gnutls_free_datum (&data);
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -960,8 +960,8 @@ gnutls_pkcs7_set_crl (gnutls_pkcs7_t pkcs7, gnutls_x509_crl_t crl)
 }
 
 /**
-  * gnutls_pkcs7_delete_crl - This function deletes a crl from a PKCS7 crl set
-  * @pkcs7_struct: should contain a gnutls_pkcs7_t structure
+  * MHD_gnutls_pkcs7_delete_crl - This function deletes a crl from a PKCS7 crl set
+  * @pkcs7_struct: should contain a MHD_gnutls_pkcs7_t structure
   * @indx: the index of the crl to delete
   *
   * This function will delete a crl from a PKCS7 or RFC2630 crl set.
@@ -969,7 +969,7 @@ gnutls_pkcs7_set_crl (gnutls_pkcs7_t pkcs7, gnutls_x509_crl_t crl)
   *
   **/
 int
-gnutls_pkcs7_delete_crl (gnutls_pkcs7_t pkcs7, int indx)
+MHD_gnutls_pkcs7_delete_crl (MHD_gnutls_pkcs7_t pkcs7, int indx)
 {
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
   int result;
@@ -983,7 +983,7 @@ gnutls_pkcs7_delete_crl (gnutls_pkcs7_t pkcs7, int indx)
   result = _decode_pkcs7_signed_data (pkcs7->pkcs7, &c2, NULL);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -992,31 +992,31 @@ gnutls_pkcs7_delete_crl (gnutls_pkcs7_t pkcs7, int indx)
 
   snprintf (root2, sizeof (root2), "crls.?%u", indx + 1);
 
-  result = asn1_write_value (c2, root2, NULL, 0);
+  result = MHD__asn1_write_value (c2, root2, NULL, 0);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   /* Step 3. Replace the old content with the new
    */
   result =
-    _gnutls_x509_der_encode_and_copy (c2, "", pkcs7->pkcs7, "content", 0);
+    MHD__gnutls_x509_der_encode_and_copy (c2, "", pkcs7->pkcs7, "content", 0);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  asn1_delete_structure (&c2);
+  MHD__asn1_delete_structure (&c2);
 
   return 0;
 
 cleanup:
   if (c2)
-    asn1_delete_structure (&c2);
+    MHD__asn1_delete_structure (&c2);
   return result;
 }
 
diff --git a/src/daemon/https/x509/pkcs7.h b/src/daemon/https/x509/pkcs7.h
index ee1990c3..24e4a415 100644
--- a/src/daemon/https/x509/pkcs7.h
+++ b/src/daemon/https/x509/pkcs7.h
@@ -24,7 +24,7 @@
 
 #include "x509.h"
 
-typedef struct gnutls_pkcs7_int
+typedef struct MHD_gnutls_pkcs7_int
 {
   ASN1_TYPE pkcs7;
-} gnutls_pkcs7_int;
+} MHD_gnutls_pkcs7_int;
diff --git a/src/daemon/https/x509/privkey.h b/src/daemon/https/x509/privkey.h
index 59dc936b..ab29ec1c 100644
--- a/src/daemon/https/x509/privkey.h
+++ b/src/daemon/https/x509/privkey.h
@@ -24,8 +24,8 @@
 
 #include "x509.h"
 
-ASN1_TYPE _gnutls_privkey_decode_pkcs1_rsa_key (const gnutls_datum_t *
+ASN1_TYPE MHD__gnutls_privkey_decode_pkcs1_rsa_key (const MHD_gnutls_datum_t *
                                                 raw_key,
-                                                gnutls_x509_privkey_t pkey);
+                                                MHD_gnutls_x509_privkey_t pkey);
 
-int _gnutls_asn1_encode_dsa (ASN1_TYPE * c2, mpi_t * params);
+int MHD__gnutlsMHD__asn1_encode_dsa (ASN1_TYPE * c2, mpi_t * params);
diff --git a/src/daemon/https/x509/privkey_pkcs8.c b/src/daemon/https/x509/privkey_pkcs8.c
index ae2c50dd..447dca15 100644
--- a/src/daemon/https/x509/privkey_pkcs8.c
+++ b/src/daemon/https/x509/privkey_pkcs8.c
@@ -71,31 +71,31 @@ struct pbe_enc_params
 static int generate_key (schema_id schema, const char *password,
                          struct pbkdf2_params *kdf_params,
                          struct pbe_enc_params *enc_params,
-                         gnutls_datum_t * key);
+                         MHD_gnutls_datum_t * key);
 static int read_pbkdf2_params (ASN1_TYPE pbes2_asn,
-                               const gnutls_datum_t * der,
+                               const MHD_gnutls_datum_t * der,
                                struct pbkdf2_params *params);
 static int read_pbe_enc_params (ASN1_TYPE pbes2_asn,
-                                const gnutls_datum_t * der,
+                                const MHD_gnutls_datum_t * der,
                                 struct pbe_enc_params *params);
 static int decrypt_data (schema_id, ASN1_TYPE pkcs8_asn, const char *root,
                          const char *password,
                          const struct pbkdf2_params *kdf_params,
                          const struct pbe_enc_params *enc_params,
-                         gnutls_datum_t * decrypted_data);
-static int decode_private_key_info (const gnutls_datum_t * der,
-                                    gnutls_x509_privkey_t pkey);
+                         MHD_gnutls_datum_t * decrypted_data);
+static int decode_private_key_info (const MHD_gnutls_datum_t * der,
+                                    MHD_gnutls_x509_privkey_t pkey);
 static int write_schema_params (schema_id schema, ASN1_TYPE pkcs8_asn,
                                 const char *where,
                                 const struct pbkdf2_params *kdf_params,
                                 const struct pbe_enc_params *enc_params);
-static int encrypt_data (const gnutls_datum_t * plain,
+static int encrypt_data (const MHD_gnutls_datum_t * plain,
                          const struct pbe_enc_params *enc_params,
-                         gnutls_datum_t * key, gnutls_datum_t * encrypted);
+                         MHD_gnutls_datum_t * key, MHD_gnutls_datum_t * encrypted);
 
-static int read_pkcs12_kdf_params (ASN1_TYPE pbes2_asn,
+static int readMHD_pkcs12_kdf_params (ASN1_TYPE pbes2_asn,
                                    struct pbkdf2_params *params);
-static int write_pkcs12_kdf_params (ASN1_TYPE pbes2_asn,
+static int writeMHD_pkcs12_kdf_params (ASN1_TYPE pbes2_asn,
                                     const struct pbkdf2_params *params);
 
 #define PEM_PKCS8 "ENCRYPTED PRIVATE KEY"
@@ -120,7 +120,7 @@ check_schema (const char *oid)
   if (strcmp (oid, PKCS12_PBE_RC2_40_SHA1_OID) == 0)
     return PKCS12_RC2_40_SHA1;
 
-  _gnutls_x509_log ("PKCS encryption schema OID '%s' is unsupported.\n", oid);
+  MHD__gnutls_x509_log ("PKCS encryption schema OID '%s' is unsupported.\n", oid);
 
   return GNUTLS_E_UNKNOWN_CIPHER_TYPE;
 }
@@ -136,7 +136,7 @@ read_pkcs_schema_params (schema_id schema, const char *password,
 {
   ASN1_TYPE pbes2_asn = ASN1_TYPE_EMPTY;
   int result;
-  gnutls_datum_t tmp;
+  MHD_gnutls_datum_t tmp;
 
   switch (schema)
     {
@@ -147,22 +147,22 @@ read_pkcs_schema_params (schema_id schema, const char *password,
        * functions.
        */
       if ((result =
-           asn1_create_element (_gnutls_get_pkix (),
+           MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                                 "PKIX1.pkcs-5-PBES2-params",
                                 &pbes2_asn)) != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          result = mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          result = MHD_gtls_asn2err (result);
           goto error;
         }
 
       /* Decode the parameters.
        */
-      result = asn1_der_decoding (&pbes2_asn, data, data_size, NULL);
+      result = MHD__asn1_der_decoding (&pbes2_asn, data, data_size, NULL);
       if (result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          result = mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          result = MHD_gtls_asn2err (result);
           goto error;
         }
 
@@ -172,20 +172,20 @@ read_pkcs_schema_params (schema_id schema, const char *password,
       result = read_pbkdf2_params (pbes2_asn, &tmp, kdf_params);
       if (result < 0)
         {
-          gnutls_assert ();
-          result = mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          result = MHD_gtls_asn2err (result);
           goto error;
         }
 
       result = read_pbe_enc_params (pbes2_asn, &tmp, enc_params);
       if (result < 0)
         {
-          gnutls_assert ();
-          result = mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          result = MHD_gtls_asn2err (result);
           goto error;
         }
 
-      asn1_delete_structure (&pbes2_asn);
+      MHD__asn1_delete_structure (&pbes2_asn);
       return 0;
       break;
 
@@ -210,48 +210,48 @@ read_pkcs_schema_params (schema_id schema, const char *password,
         }
 
       if ((result =
-           asn1_create_element (_gnutls_get_pkix (),
+           MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                                 "PKIX1.pkcs-12-PbeParams",
                                 &pbes2_asn)) != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          result = mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          result = MHD_gtls_asn2err (result);
           goto error;
         }
 
       /* Decode the parameters.
        */
-      result = asn1_der_decoding (&pbes2_asn, data, data_size, NULL);
+      result = MHD__asn1_der_decoding (&pbes2_asn, data, data_size, NULL);
       if (result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          result = mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          result = MHD_gtls_asn2err (result);
           goto error;
         }
 
-      result = read_pkcs12_kdf_params (pbes2_asn, kdf_params);
+      result = readMHD_pkcs12_kdf_params (pbes2_asn, kdf_params);
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           goto error;
         }
 
       if (enc_params->iv_size)
         {
           result =
-            _pkcs12_string_to_key (2 /*IV*/, kdf_params->salt,
+            MHD_pkcs12_string_to_key (2 /*IV*/, kdf_params->salt,
                                    kdf_params->salt_size,
                                    kdf_params->iter_count, password,
                                    enc_params->iv_size, enc_params->iv);
           if (result < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               goto error;
             }
 
         }
 
-      asn1_delete_structure (&pbes2_asn);
+      MHD__asn1_delete_structure (&pbes2_asn);
 
       return 0;
       break;
@@ -261,21 +261,21 @@ read_pkcs_schema_params (schema_id schema, const char *password,
   return GNUTLS_E_UNKNOWN_CIPHER_TYPE;
 
 error:
-  asn1_delete_structure (&pbes2_asn);
+  MHD__asn1_delete_structure (&pbes2_asn);
   return result;
 }
 
 /* Converts a PKCS #8 key to
- * an internal structure (gnutls_private_key)
+ * an internal structure (MHD_gnutls_private_key)
  * (normally a PKCS #1 encoded RSA key)
  */
 static int
-decode_pkcs8_key (const gnutls_datum_t * raw_key,
-                  const char *password, gnutls_x509_privkey_t pkey)
+decode_pkcs8_key (const MHD_gnutls_datum_t * raw_key,
+                  const char *password, MHD_gnutls_x509_privkey_t pkey)
 {
   int result, len;
   char enc_oid[64];
-  gnutls_datum_t tmp;
+  MHD_gnutls_datum_t tmp;
   ASN1_TYPE pbes2_asn = ASN1_TYPE_EMPTY, pkcs8_asn = ASN1_TYPE_EMPTY;
   int params_start, params_end, params_len;
   struct pbkdf2_params kdf_params;
@@ -283,20 +283,20 @@ decode_pkcs8_key (const gnutls_datum_t * raw_key,
   schema_id schema;
 
   if ((result =
-       asn1_create_element (_gnutls_get_pkix (),
+       MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                             "PKIX1.pkcs-8-EncryptedPrivateKeyInfo",
                             &pkcs8_asn)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
 
-  result = asn1_der_decoding (&pkcs8_asn, raw_key->data, raw_key->size, NULL);
+  result = MHD__asn1_der_decoding (&pkcs8_asn, raw_key->data, raw_key->size, NULL);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
 
@@ -304,17 +304,17 @@ decode_pkcs8_key (const gnutls_datum_t * raw_key,
    */
   len = sizeof (enc_oid);
   result =
-    asn1_read_value (pkcs8_asn, "encryptionAlgorithm.algorithm",
+    MHD__asn1_read_value (pkcs8_asn, "encryptionAlgorithm.algorithm",
                      enc_oid, &len);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
 
   if ((result = check_schema (enc_oid)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
 
@@ -323,14 +323,14 @@ decode_pkcs8_key (const gnutls_datum_t * raw_key,
   /* Get the DER encoding of the parameters.
    */
   result =
-    asn1_der_decoding_startEnd (pkcs8_asn, raw_key->data,
+    MHD__asn1_der_decoding_startEnd (pkcs8_asn, raw_key->data,
                                 raw_key->size,
                                 "encryptionAlgorithm.parameters",
                                 &params_start, &params_end);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
   params_len = params_end - params_start + 1;
@@ -348,14 +348,14 @@ decode_pkcs8_key (const gnutls_datum_t * raw_key,
                   &kdf_params, &enc_params, &tmp);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
 
-  asn1_delete_structure (&pkcs8_asn);
+  MHD__asn1_delete_structure (&pkcs8_asn);
 
   result = decode_private_key_info (&tmp, pkey);
-  _gnutls_free_datum (&tmp);
+  MHD__gnutls_free_datum (&tmp);
 
   if (result < 0)
     {
@@ -378,106 +378,106 @@ decode_pkcs8_key (const gnutls_datum_t * raw_key,
           result = GNUTLS_E_DECRYPTION_FAILED;
         }
 
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
 
   return 0;
 
 error:
-  asn1_delete_structure (&pbes2_asn);
-  asn1_delete_structure (&pkcs8_asn);
+  MHD__asn1_delete_structure (&pbes2_asn);
+  MHD__asn1_delete_structure (&pkcs8_asn);
   return result;
 }
 
 /* Decodes an RSA privateKey from a PKCS8 structure.
  */
 static int
-_decode_pkcs8_rsa_key (ASN1_TYPE pkcs8_asn, gnutls_x509_privkey_t pkey)
+_decode_pkcs8_rsa_key (ASN1_TYPE pkcs8_asn, MHD_gnutls_x509_privkey_t pkey)
 {
   int ret;
-  gnutls_datum_t tmp;
+  MHD_gnutls_datum_t tmp;
 
-  ret = _gnutls_x509_read_value (pkcs8_asn, "privateKey", &tmp, 0);
+  ret = MHD__gnutls_x509_read_value (pkcs8_asn, "privateKey", &tmp, 0);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
 
-  pkey->key = _gnutls_privkey_decode_pkcs1_rsa_key (&tmp, pkey);
-  _gnutls_free_datum (&tmp);
+  pkey->key = MHD__gnutls_privkey_decode_pkcs1_rsa_key (&tmp, pkey);
+  MHD__gnutls_free_datum (&tmp);
   if (pkey->key == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
 
   return 0;
 
 error:
-  gnutls_x509_privkey_deinit (pkey);
+  MHD_gnutls_x509_privkey_deinit (pkey);
   return ret;
 }
 
 /* TODO rm if unsed - we will probable support only RSA certificates */
 /* Decodes an DSA privateKey and params from a PKCS8 structure.
 static int
-_decode_pkcs8_dsa_key (ASN1_TYPE pkcs8_asn, gnutls_x509_privkey pkey)
+_decode_pkcs8_dsa_key (ASN1_TYPE pkcs8_asn, MHD_gnutls_x509_privkey pkey)
   {
     int ret;
-    gnutls_datum tmp;
+    MHD_gnutls_datum tmp;
 
-    ret = _gnutls_x509_read_value (pkcs8_asn, "privateKey", &tmp, 0);
+    ret = MHD__gnutls_x509_read_value (pkcs8_asn, "privateKey", &tmp, 0);
     if (ret < 0)
       {
-        gnutls_assert ();
+        MHD_gnutls_assert ();
         goto error;
       }
 
-    ret = _gnutls_x509_read_der_int (tmp.data, tmp.size, &pkey->params[4]);
-    _gnutls_free_datum (&tmp);
+    ret = MHD__gnutls_x509_read_der_int (tmp.data, tmp.size, &pkey->params[4]);
+    MHD__gnutls_free_datum (&tmp);
 
     if (ret < 0)
       {
-        gnutls_assert ();
+        MHD_gnutls_assert ();
         goto error;
       }
 
     ret =
-    _gnutls_x509_read_value (pkcs8_asn, "privateKeyAlgorithm.parameters",
+    MHD__gnutls_x509_read_value (pkcs8_asn, "privateKeyAlgorithm.parameters",
         &tmp, 0);
     if (ret < 0)
       {
-        gnutls_assert ();
+        MHD_gnutls_assert ();
         goto error;
       }
 
-    ret = _gnutls_x509_read_dsa_params (tmp.data, tmp.size, pkey->params);
-    _gnutls_free_datum (&tmp);
+    ret = MHD__gnutls_x509_read_dsa_params (tmp.data, tmp.size, pkey->params);
+    MHD__gnutls_free_datum (&tmp);
     if (ret < 0)
       {
-        gnutls_assert ();
+        MHD_gnutls_assert ();
         goto error;
       }
 
     the public key can be generated as g^x mod p
-    pkey->params[3] = _gnutls_mpi_alloc_like (pkey->params[0]);
+    pkey->params[3] = MHD__gnutls_mpi_alloc_like (pkey->params[0]);
     if (pkey->params[3] == NULL)
       {
-        gnutls_assert ();
+        MHD_gnutls_assert ();
         goto error;
       }
 
-    _gnutls_mpi_powm (pkey->params[3], pkey->params[2], pkey->params[4],
+    MHD__gnutls_mpi_powm (pkey->params[3], pkey->params[2], pkey->params[4],
         pkey->params[0]);
 
     if (!pkey->crippled)
       {
-        ret = _gnutls_asn1_encode_dsa (&pkey->key, pkey->params);
+        ret = MHD__gnutlsMHD__asn1_encode_dsa (&pkey->key, pkey->params);
         if (ret < 0)
           {
-            gnutls_assert ();
+            MHD_gnutls_assert ();
             goto error;
           }
       }
@@ -487,34 +487,34 @@ _decode_pkcs8_dsa_key (ASN1_TYPE pkcs8_asn, gnutls_x509_privkey pkey)
     return 0;
 
     error:
-    gnutls_x509_privkey_deinit (pkey);
+    MHD_gnutls_x509_privkey_deinit (pkey);
     return ret;
   }
 */
 
 static int
-decode_private_key_info (const gnutls_datum_t * der,
-                         gnutls_x509_privkey_t pkey)
+decode_private_key_info (const MHD_gnutls_datum_t * der,
+                         MHD_gnutls_x509_privkey_t pkey)
 {
   int result, len;
   opaque oid[64];
   ASN1_TYPE pkcs8_asn = ASN1_TYPE_EMPTY;
 
   if ((result =
-       asn1_create_element (_gnutls_get_pkix (),
+       MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                             "PKIX1.pkcs-8-PrivateKeyInfo",
                             &pkcs8_asn)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
 
-  result = asn1_der_decoding (&pkcs8_asn, der->data, der->size, NULL);
+  result = MHD__asn1_der_decoding (&pkcs8_asn, der->data, der->size, NULL);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
 
@@ -522,11 +522,11 @@ decode_private_key_info (const gnutls_datum_t * der,
    */
   len = sizeof (oid);
   result =
-    asn1_read_value (pkcs8_asn, "privateKeyAlgorithm.algorithm", oid, &len);
+    MHD__asn1_read_value (pkcs8_asn, "privateKeyAlgorithm.algorithm", oid, &len);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
 
@@ -536,8 +536,8 @@ decode_private_key_info (const gnutls_datum_t * der,
     pkey->pk_algorithm = MHD_GNUTLS_PK_RSA;
   else
     {
-      gnutls_assert ();
-      _gnutls_x509_log
+      MHD_gnutls_assert ();
+      MHD__gnutls_x509_log
         ("PKCS #8 private key OID '%s' is unsupported.\n", oid);
       result = GNUTLS_E_UNKNOWN_PK_ALGORITHM;
       goto error;
@@ -550,21 +550,21 @@ decode_private_key_info (const gnutls_datum_t * der,
     result = _decode_pkcs8_rsa_key (pkcs8_asn, pkey);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
   result = 0;
 
 error:
-  asn1_delete_structure (&pkcs8_asn);
+  MHD__asn1_delete_structure (&pkcs8_asn);
 
   return result;
 
 }
 
 /**
- * gnutls_x509_privkey_import_pkcs8 - This function will import a DER or PEM PKCS8 encoded key
+ * MHD_gnutls_x509_privkey_import_pkcs8 - This function will import a DER or PEM PKCS8 encoded key
  * @key: The structure to store the parsed key
  * @data: The DER or PEM encoded key.
  * @format: One of DER or PEM
@@ -572,7 +572,7 @@ error:
  * @flags: 0 if encrypted or GNUTLS_PKCS_PLAIN if not encrypted.
  *
  * This function will convert the given DER or PEM encoded PKCS8 2.0 encrypted key
- * to the native gnutls_x509_privkey_t format. The output will be stored in @key.
+ * to the native MHD_gnutls_x509_privkey_t format. The output will be stored in @key.
  * Both RSA and DSA keys can be imported, and flags can only be used to indicate
  * an unencrypted key.
  *
@@ -587,17 +587,17 @@ error:
  *
  **/
 int
-gnutls_x509_privkey_import_pkcs8 (gnutls_x509_privkey_t key,
-                                  const gnutls_datum_t * data,
-                                  gnutls_x509_crt_fmt_t format,
+MHD_gnutls_x509_privkey_import_pkcs8 (MHD_gnutls_x509_privkey_t key,
+                                  const MHD_gnutls_datum_t * data,
+                                  MHD_gnutls_x509_crt_fmt_t format,
                                   const char *password, unsigned int flags)
 {
   int result = 0, need_free = 0;
-  gnutls_datum_t _data;
+  MHD_gnutls_datum_t _data;
 
   if (key == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -615,20 +615,20 @@ gnutls_x509_privkey_import_pkcs8 (gnutls_x509_privkey_t key,
       /* Try the first header
        */
       result =
-        _gnutls_fbase64_decode (PEM_UNENCRYPTED_PKCS8,
+        MHD__gnutls_fbase64_decode (PEM_UNENCRYPTED_PKCS8,
                                 data->data, data->size, &out);
 
       if (result < 0)
         {                       /* Try the encrypted header
                                  */
           result =
-            _gnutls_fbase64_decode (PEM_PKCS8, data->data, data->size, &out);
+            MHD__gnutls_fbase64_decode (PEM_PKCS8, data->data, data->size, &out);
 
           if (result <= 0)
             {
               if (result == 0)
                 result = GNUTLS_E_INTERNAL_ERROR;
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return result;
             }
         }
@@ -652,12 +652,12 @@ gnutls_x509_privkey_import_pkcs8 (gnutls_x509_privkey_t key,
 
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
   if (need_free)
-    _gnutls_free_datum (&_data);
+    MHD__gnutls_free_datum (&_data);
 
   /* The key has now been decoded.
    */
@@ -667,7 +667,7 @@ gnutls_x509_privkey_import_pkcs8 (gnutls_x509_privkey_t key,
 cleanup:
   key->pk_algorithm = MHD_GNUTLS_PK_UNKNOWN;
   if (need_free)
-    _gnutls_free_datum (&_data);
+    MHD__gnutls_free_datum (&_data);
   return result;
 }
 
@@ -675,7 +675,7 @@ cleanup:
  */
 static int
 read_pbkdf2_params (ASN1_TYPE pbes2_asn,
-                    const gnutls_datum_t * der, struct pbkdf2_params *params)
+                    const MHD_gnutls_datum_t * der, struct pbkdf2_params *params)
 {
   int params_start, params_end;
   int params_len, len, result;
@@ -688,30 +688,30 @@ read_pbkdf2_params (ASN1_TYPE pbes2_asn,
    */
   len = sizeof (oid);
   result =
-    asn1_read_value (pbes2_asn, "keyDerivationFunc.algorithm", oid, &len);
+    MHD__asn1_read_value (pbes2_asn, "keyDerivationFunc.algorithm", oid, &len);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
-  _gnutls_hard_log ("keyDerivationFunc.algorithm: %s\n", oid);
+  MHD__gnutls_hard_log ("keyDerivationFunc.algorithm: %s\n", oid);
 
   if (strcmp (oid, PBKDF2_OID) != 0)
     {
-      gnutls_assert ();
-      _gnutls_x509_log
+      MHD_gnutls_assert ();
+      MHD__gnutls_x509_log
         ("PKCS #8 key derivation OID '%s' is unsupported.\n", oid);
-      return mhd_gtls_asn2err (result);
+      return MHD_gtls_asn2err (result);
     }
 
   result =
-    asn1_der_decoding_startEnd (pbes2_asn, der->data, der->size,
+    MHD__asn1_der_decoding_startEnd (pbes2_asn, der->data, der->size,
                                 "keyDerivationFunc.parameters",
                                 &params_start, &params_end);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
   params_len = params_end - params_start + 1;
 
@@ -719,58 +719,58 @@ read_pbkdf2_params (ASN1_TYPE pbes2_asn,
    * functions.
    */
   if ((result =
-       asn1_create_element (_gnutls_get_pkix (),
+       MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                             "PKIX1.pkcs-5-PBKDF2-params",
                             &pbkdf2_asn)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   result =
-    asn1_der_decoding (&pbkdf2_asn, &der->data[params_start],
+    MHD__asn1_der_decoding (&pbkdf2_asn, &der->data[params_start],
                        params_len, NULL);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
 
   /* read the salt */
   params->salt_size = sizeof (params->salt);
   result =
-    asn1_read_value (pbkdf2_asn, "salt.specified", params->salt,
+    MHD__asn1_read_value (pbkdf2_asn, "salt.specified", params->salt,
                      &params->salt_size);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
-  _gnutls_hard_log ("salt.specified.size: %d\n", params->salt_size);
+  MHD__gnutls_hard_log ("salt.specified.size: %d\n", params->salt_size);
 
   /* read the iteration count
    */
   result =
-    _gnutls_x509_read_uint (pbkdf2_asn, "iterationCount",
+    MHD__gnutls_x509_read_uint (pbkdf2_asn, "iterationCount",
                             &params->iter_count);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
-  _gnutls_hard_log ("iterationCount: %d\n", params->iter_count);
+  MHD__gnutls_hard_log ("iterationCount: %d\n", params->iter_count);
 
   /* read the keylength, if it is set.
    */
   result =
-    _gnutls_x509_read_uint (pbkdf2_asn, "keyLength", &params->key_size);
+    MHD__gnutls_x509_read_uint (pbkdf2_asn, "keyLength", &params->key_size);
   if (result < 0)
     {
       params->key_size = 0;
     }
-  _gnutls_hard_log ("keyLength: %d\n", params->key_size);
+  MHD__gnutls_hard_log ("keyLength: %d\n", params->key_size);
 
   /* We don't read the PRF. We only use the default.
    */
@@ -778,7 +778,7 @@ read_pbkdf2_params (ASN1_TYPE pbes2_asn,
   return 0;
 
 error:
-  asn1_delete_structure (&pbkdf2_asn);
+  MHD__asn1_delete_structure (&pbkdf2_asn);
   return result;
 
 }
@@ -786,7 +786,7 @@ error:
 /* Reads the PBE parameters from PKCS-12 schemas (*&#%*&#% RSA).
  */
 static int
-read_pkcs12_kdf_params (ASN1_TYPE pbes2_asn, struct pbkdf2_params *params)
+readMHD_pkcs12_kdf_params (ASN1_TYPE pbes2_asn, struct pbkdf2_params *params)
 {
   int result;
 
@@ -795,25 +795,25 @@ read_pkcs12_kdf_params (ASN1_TYPE pbes2_asn, struct pbkdf2_params *params)
   /* read the salt */
   params->salt_size = sizeof (params->salt);
   result =
-    asn1_read_value (pbes2_asn, "salt", params->salt, &params->salt_size);
+    MHD__asn1_read_value (pbes2_asn, "salt", params->salt, &params->salt_size);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
-  _gnutls_hard_log ("salt.size: %d\n", params->salt_size);
+  MHD__gnutls_hard_log ("salt.size: %d\n", params->salt_size);
 
   /* read the iteration count
    */
   result =
-    _gnutls_x509_read_uint (pbes2_asn, "iterations", &params->iter_count);
+    MHD__gnutls_x509_read_uint (pbes2_asn, "iterations", &params->iter_count);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
-  _gnutls_hard_log ("iterationCount: %d\n", params->iter_count);
+  MHD__gnutls_hard_log ("iterationCount: %d\n", params->iter_count);
 
   params->key_size = 0;
 
@@ -827,7 +827,7 @@ error:
 /* Writes the PBE parameters for PKCS-12 schemas.
  */
 static int
-write_pkcs12_kdf_params (ASN1_TYPE pbes2_asn,
+writeMHD_pkcs12_kdf_params (ASN1_TYPE pbes2_asn,
                          const struct pbkdf2_params *kdf_params)
 {
   int result;
@@ -835,27 +835,27 @@ write_pkcs12_kdf_params (ASN1_TYPE pbes2_asn,
   /* write the salt
    */
   result =
-    asn1_write_value (pbes2_asn, "salt",
+    MHD__asn1_write_value (pbes2_asn, "salt",
                       kdf_params->salt, kdf_params->salt_size);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
-  _gnutls_hard_log ("salt.size: %d\n", kdf_params->salt_size);
+  MHD__gnutls_hard_log ("salt.size: %d\n", kdf_params->salt_size);
 
   /* write the iteration count
    */
   result =
-    _gnutls_x509_write_uint32 (pbes2_asn, "iterations",
+    MHD__gnutls_x509_write_uint32 (pbes2_asn, "iterations",
                                kdf_params->iter_count);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
-  _gnutls_hard_log ("iterationCount: %d\n", kdf_params->iter_count);
+  MHD__gnutls_hard_log ("iterationCount: %d\n", kdf_params->iter_count);
 
   return 0;
 
@@ -884,13 +884,13 @@ oid2cipher (const char *oid, enum MHD_GNUTLS_CipherAlgorithm *algo)
       return 0;
     }
 
-  _gnutls_x509_log ("PKCS #8 encryption OID '%s' is unsupported.\n", oid);
+  MHD__gnutls_x509_log ("PKCS #8 encryption OID '%s' is unsupported.\n", oid);
   return GNUTLS_E_UNKNOWN_CIPHER_TYPE;
 }
 
 static int
 read_pbe_enc_params (ASN1_TYPE pbes2_asn,
-                     const gnutls_datum_t * der,
+                     const MHD_gnutls_datum_t * der,
                      struct pbe_enc_params *params)
 {
   int params_start, params_end;
@@ -904,66 +904,66 @@ read_pbe_enc_params (ASN1_TYPE pbes2_asn,
    */
   len = sizeof (oid);
   result =
-    asn1_read_value (pbes2_asn, "encryptionScheme.algorithm", oid, &len);
+    MHD__asn1_read_value (pbes2_asn, "encryptionScheme.algorithm", oid, &len);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
-  _gnutls_hard_log ("encryptionScheme.algorithm: %s\n", oid);
+  MHD__gnutls_hard_log ("encryptionScheme.algorithm: %s\n", oid);
 
   if ((result = oid2cipher (oid, &params->cipher)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
 
   result =
-    asn1_der_decoding_startEnd (pbes2_asn, der->data, der->size,
+    MHD__asn1_der_decoding_startEnd (pbes2_asn, der->data, der->size,
                                 "encryptionScheme.parameters",
                                 &params_start, &params_end);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
   params_len = params_end - params_start + 1;
 
   /* Now check the encryption parameters.
    */
   if ((result =
-       asn1_create_element (_gnutls_get_pkix (),
+       MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                             "PKIX1.pkcs-5-des-EDE3-CBC-params",
                             &pbe_asn)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   result =
-    asn1_der_decoding (&pbe_asn, &der->data[params_start], params_len, NULL);
+    MHD__asn1_der_decoding (&pbe_asn, &der->data[params_start], params_len, NULL);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
 
   /* read the IV */
   params->iv_size = sizeof (params->iv);
-  result = asn1_read_value (pbe_asn, "", params->iv, &params->iv_size);
+  result = MHD__asn1_read_value (pbe_asn, "", params->iv, &params->iv_size);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
-  _gnutls_hard_log ("IV.size: %d\n", params->iv_size);
+  MHD__gnutls_hard_log ("IV.size: %d\n", params->iv_size);
 
   return 0;
 
 error:
-  asn1_delete_structure (&pbe_asn);
+  MHD__asn1_delete_structure (&pbe_asn);
   return result;
 
 }
@@ -973,49 +973,49 @@ decrypt_data (schema_id schema, ASN1_TYPE pkcs8_asn,
               const char *root, const char *password,
               const struct pbkdf2_params *kdf_params,
               const struct pbe_enc_params *enc_params,
-              gnutls_datum_t * decrypted_data)
+              MHD_gnutls_datum_t * decrypted_data)
 {
   int result;
   int data_size;
   opaque *data = NULL, *key = NULL;
-  gnutls_datum_t dkey, d_iv;
+  MHD_gnutls_datum_t dkey, d_iv;
   cipher_hd_t ch = NULL;
   int key_size;
 
   data_size = 0;
-  result = asn1_read_value (pkcs8_asn, root, NULL, &data_size);
+  result = MHD__asn1_read_value (pkcs8_asn, root, NULL, &data_size);
   if (result != ASN1_MEM_ERROR)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  data = gnutls_malloc (data_size);
+  data = MHD_gnutls_malloc (data_size);
   if (data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
-  result = asn1_read_value (pkcs8_asn, root, data, &data_size);
+  result = MHD__asn1_read_value (pkcs8_asn, root, data, &data_size);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
 
   if (kdf_params->key_size == 0)
     {
-      key_size = MHD_gnutls_cipher_get_key_size (enc_params->cipher);
+      key_size = MHD__gnutls_cipher_get_key_size (enc_params->cipher);
     }
   else
     key_size = kdf_params->key_size;
 
-  key = gnutls_alloca (key_size);
+  key = MHD_gnutls_alloca (key_size);
   if (key == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_MEMORY_ERROR;
       goto error;
     }
@@ -1024,13 +1024,13 @@ decrypt_data (schema_id schema, ASN1_TYPE pkcs8_asn,
    */
   if (schema == PBES2)
     {
-      result = gc_pbkdf2_sha1 (password, strlen (password),
+      result = MHD_gc_pbkdf2_sha1 (password, strlen (password),
                                kdf_params->salt, kdf_params->salt_size,
                                kdf_params->iter_count, key, key_size);
 
       if (result != GC_OK)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           result = GNUTLS_E_DECRYPTION_FAILED;
           goto error;
         }
@@ -1038,14 +1038,14 @@ decrypt_data (schema_id schema, ASN1_TYPE pkcs8_asn,
   else
     {
       result =
-        _pkcs12_string_to_key (1 /*KEY*/, kdf_params->salt,
+        MHD_pkcs12_string_to_key (1 /*KEY*/, kdf_params->salt,
                                kdf_params->salt_size,
                                kdf_params->iter_count, password,
                                key_size, key);
 
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           goto error;
         }
     }
@@ -1057,41 +1057,41 @@ decrypt_data (schema_id schema, ASN1_TYPE pkcs8_asn,
 
   d_iv.data = (opaque *) enc_params->iv;
   d_iv.size = enc_params->iv_size;
-  ch = mhd_gtls_cipher_init (enc_params->cipher, &dkey, &d_iv);
+  ch = MHD_gtls_cipher_init (enc_params->cipher, &dkey, &d_iv);
 
-  gnutls_afree (key);
+  MHD_gnutls_afree (key);
   key = NULL;
 
   if (ch == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_DECRYPTION_FAILED;
       goto error;
     }
 
-  result = mhd_gtls_cipher_decrypt (ch, data, data_size);
+  result = MHD_gtls_cipher_decrypt (ch, data, data_size);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
 
   decrypted_data->data = data;
 
-  if (mhd_gtls_cipher_get_block_size (enc_params->cipher) != 1)
+  if (MHD_gtls_cipher_get_block_size (enc_params->cipher) != 1)
     decrypted_data->size = data_size - data[data_size - 1];
   else
     decrypted_data->size = data_size;
 
-  mhd_gnutls_cipher_deinit (ch);
+  MHD_gnutls_cipher_deinit (ch);
 
   return 0;
 
 error:
-  gnutls_free (data);
-  gnutls_afree (key);
+  MHD_gnutls_free (data);
+  MHD_gnutls_afree (key);
   if (ch != NULL)
-    mhd_gnutls_cipher_deinit (ch);
+    MHD_gnutls_cipher_deinit (ch);
   return result;
 }
 
@@ -1108,97 +1108,97 @@ write_pbkdf2_params (ASN1_TYPE pbes2_asn,
   /* Write the key derivation algorithm
    */
   result =
-    asn1_write_value (pbes2_asn, "keyDerivationFunc.algorithm",
+    MHD__asn1_write_value (pbes2_asn, "keyDerivationFunc.algorithm",
                       PBKDF2_OID, 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   /* Now write the key derivation and the encryption
    * functions.
    */
   if ((result =
-       asn1_create_element (_gnutls_get_pkix (),
+       MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                             "PKIX1.pkcs-5-PBKDF2-params",
                             &pbkdf2_asn)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  result = asn1_write_value (pbkdf2_asn, "salt", "specified", 1);
+  result = MHD__asn1_write_value (pbkdf2_asn, "salt", "specified", 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
 
   /* write the salt
    */
   result =
-    asn1_write_value (pbkdf2_asn, "salt.specified",
+    MHD__asn1_write_value (pbkdf2_asn, "salt.specified",
                       kdf_params->salt, kdf_params->salt_size);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
-  _gnutls_hard_log ("salt.specified.size: %d\n", kdf_params->salt_size);
+  MHD__gnutls_hard_log ("salt.specified.size: %d\n", kdf_params->salt_size);
 
   /* write the iteration count
    */
-  mhd_gtls_write_uint32 (kdf_params->iter_count, tmp);
+  MHD_gtls_write_uint32 (kdf_params->iter_count, tmp);
 
-  result = asn1_write_value (pbkdf2_asn, "iterationCount", tmp, 4);
+  result = MHD__asn1_write_value (pbkdf2_asn, "iterationCount", tmp, 4);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
-  _gnutls_hard_log ("iterationCount: %d\n", kdf_params->iter_count);
+  MHD__gnutls_hard_log ("iterationCount: %d\n", kdf_params->iter_count);
 
   /* write the keylength, if it is set.
    */
-  result = asn1_write_value (pbkdf2_asn, "keyLength", NULL, 0);
+  result = MHD__asn1_write_value (pbkdf2_asn, "keyLength", NULL, 0);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
 
   /* We write an emptry prf.
    */
-  result = asn1_write_value (pbkdf2_asn, "prf", NULL, 0);
+  result = MHD__asn1_write_value (pbkdf2_asn, "prf", NULL, 0);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
 
   /* now encode them an put the DER output
    * in the keyDerivationFunc.parameters
    */
-  result = _gnutls_x509_der_encode_and_copy (pbkdf2_asn, "",
+  result = MHD__gnutls_x509_der_encode_and_copy (pbkdf2_asn, "",
                                              pbes2_asn,
                                              "keyDerivationFunc.parameters",
                                              0);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
 
   return 0;
 
 error:
-  asn1_delete_structure (&pbkdf2_asn);
+  MHD__asn1_delete_structure (&pbkdf2_asn);
   return result;
 
 }
@@ -1213,53 +1213,53 @@ write_pbe_enc_params (ASN1_TYPE pbes2_asn,
   /* Write the encryption algorithm
    */
   result =
-    asn1_write_value (pbes2_asn, "encryptionScheme.algorithm",
+    MHD__asn1_write_value (pbes2_asn, "encryptionScheme.algorithm",
                       DES_EDE3_CBC_OID, 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
-  _gnutls_hard_log ("encryptionScheme.algorithm: %s\n", DES_EDE3_CBC_OID);
+  MHD__gnutls_hard_log ("encryptionScheme.algorithm: %s\n", DES_EDE3_CBC_OID);
 
   /* Now check the encryption parameters.
    */
   if ((result =
-       asn1_create_element (_gnutls_get_pkix (),
+       MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                             "PKIX1.pkcs-5-des-EDE3-CBC-params",
                             &pbe_asn)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   /* read the salt */
-  result = asn1_write_value (pbe_asn, "", params->iv, params->iv_size);
+  result = MHD__asn1_write_value (pbe_asn, "", params->iv, params->iv_size);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
-  _gnutls_hard_log ("IV.size: %d\n", params->iv_size);
+  MHD__gnutls_hard_log ("IV.size: %d\n", params->iv_size);
 
   /* now encode them an put the DER output
    * in the encryptionScheme.parameters
    */
-  result = _gnutls_x509_der_encode_and_copy (pbe_asn, "",
+  result = MHD__gnutls_x509_der_encode_and_copy (pbe_asn, "",
                                              pbes2_asn,
                                              "encryptionScheme.parameters",
                                              0);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
 
   return 0;
 
 error:
-  asn1_delete_structure (&pbe_asn);
+  MHD__asn1_delete_structure (&pbe_asn);
   return result;
 
 }
@@ -1270,7 +1270,7 @@ static int
 generate_key (schema_id schema,
               const char *password,
               struct pbkdf2_params *kdf_params,
-              struct pbe_enc_params *enc_params, gnutls_datum_t * key)
+              struct pbe_enc_params *enc_params, MHD_gnutls_datum_t * key)
 {
   opaque rnd[2];
   int ret;
@@ -1286,9 +1286,9 @@ generate_key (schema_id schema,
   else if (schema == PKCS12_RC2_40_SHA1)
     enc_params->cipher = MHD_GNUTLS_CIPHER_RC2_40_CBC;
 
-  if (gc_pseudo_random (rnd, 2) != GC_OK)
+  if (MHD_gc_pseudo_random (rnd, 2) != GC_OK)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_RANDOM_FAILED;
     }
 
@@ -1302,22 +1302,22 @@ generate_key (schema_id schema,
   else
     kdf_params->salt_size = 8;
 
-  if (gc_pseudo_random (kdf_params->salt, kdf_params->salt_size) != GC_OK)
+  if (MHD_gc_pseudo_random (kdf_params->salt, kdf_params->salt_size) != GC_OK)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_RANDOM_FAILED;
     }
 
   kdf_params->iter_count = 256 + rnd[0];
   key->size = kdf_params->key_size =
-    MHD_gnutls_cipher_get_key_size (enc_params->cipher);
+    MHD__gnutls_cipher_get_key_size (enc_params->cipher);
 
-  enc_params->iv_size = mhd_gtls_cipher_get_iv_size (enc_params->cipher);
+  enc_params->iv_size = MHD_gtls_cipher_get_iv_size (enc_params->cipher);
 
-  key->data = gnutls_secure_malloc (key->size);
+  key->data = MHD_gnutls_secure_malloc (key->size);
   if (key->data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
@@ -1327,33 +1327,33 @@ generate_key (schema_id schema,
   if (schema == PBES2)
     {
 
-      ret = gc_pbkdf2_sha1 (password, strlen (password),
+      ret = MHD_gc_pbkdf2_sha1 (password, strlen (password),
                             kdf_params->salt, kdf_params->salt_size,
                             kdf_params->iter_count,
                             key->data, kdf_params->key_size);
       if (ret != GC_OK)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_ENCRYPTION_FAILED;
         }
 
       if (enc_params->iv_size &&
-          gc_nonce (enc_params->iv, enc_params->iv_size) != GC_OK)
+          MHD_gc_nonce (enc_params->iv, enc_params->iv_size) != GC_OK)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_RANDOM_FAILED;
         }
     }
   else
     {                           /* PKCS12 schemas */
       ret =
-        _pkcs12_string_to_key (1 /*KEY*/, kdf_params->salt,
+        MHD_pkcs12_string_to_key (1 /*KEY*/, kdf_params->salt,
                                kdf_params->salt_size,
                                kdf_params->iter_count, password,
                                kdf_params->key_size, key->data);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
@@ -1362,13 +1362,13 @@ generate_key (schema_id schema,
       if (enc_params->iv_size)
         {
           ret =
-            _pkcs12_string_to_key (2 /*IV*/, kdf_params->salt,
+            MHD_pkcs12_string_to_key (2 /*IV*/, kdf_params->salt,
                                    kdf_params->salt_size,
                                    kdf_params->iter_count, password,
                                    enc_params->iv_size, enc_params->iv);
           if (ret < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return ret;
             }
         }
@@ -1392,99 +1392,99 @@ write_schema_params (schema_id schema, ASN1_TYPE pkcs8_asn,
   if (schema == PBES2)
     {
       if ((result =
-           asn1_create_element (_gnutls_get_pkix (),
+           MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                                 "PKIX1.pkcs-5-PBES2-params",
                                 &pbes2_asn)) != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          return mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          return MHD_gtls_asn2err (result);
         }
 
       result = write_pbkdf2_params (pbes2_asn, kdf_params);
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           goto error;
         }
 
       result = write_pbe_enc_params (pbes2_asn, enc_params);
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           goto error;
         }
 
-      result = _gnutls_x509_der_encode_and_copy (pbes2_asn, "",
+      result = MHD__gnutls_x509_der_encode_and_copy (pbes2_asn, "",
                                                  pkcs8_asn, where, 0);
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           goto error;
         }
 
-      asn1_delete_structure (&pbes2_asn);
+      MHD__asn1_delete_structure (&pbes2_asn);
     }
   else
     {                           /* PKCS12 schemas */
 
       if ((result =
-           asn1_create_element (_gnutls_get_pkix (),
+           MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                                 "PKIX1.pkcs-12-PbeParams",
                                 &pbes2_asn)) != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          result = mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          result = MHD_gtls_asn2err (result);
           goto error;
         }
 
-      result = write_pkcs12_kdf_params (pbes2_asn, kdf_params);
+      result = writeMHD_pkcs12_kdf_params (pbes2_asn, kdf_params);
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           goto error;
         }
 
-      result = _gnutls_x509_der_encode_and_copy (pbes2_asn, "",
+      result = MHD__gnutls_x509_der_encode_and_copy (pbes2_asn, "",
                                                  pkcs8_asn, where, 0);
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           goto error;
         }
 
-      asn1_delete_structure (&pbes2_asn);
+      MHD__asn1_delete_structure (&pbes2_asn);
 
     }
 
   return 0;
 
 error:
-  asn1_delete_structure (&pbes2_asn);
+  MHD__asn1_delete_structure (&pbes2_asn);
   return result;
 
 }
 
 static int
-encrypt_data (const gnutls_datum_t * plain,
+encrypt_data (const MHD_gnutls_datum_t * plain,
               const struct pbe_enc_params *enc_params,
-              gnutls_datum_t * key, gnutls_datum_t * encrypted)
+              MHD_gnutls_datum_t * key, MHD_gnutls_datum_t * encrypted)
 {
   int result;
   int data_size;
   opaque *data = NULL;
-  gnutls_datum_t d_iv;
+  MHD_gnutls_datum_t d_iv;
   cipher_hd_t ch = NULL;
   opaque pad, pad_size;
 
-  pad_size = mhd_gtls_cipher_get_block_size (enc_params->cipher);
+  pad_size = MHD_gtls_cipher_get_block_size (enc_params->cipher);
 
   if (pad_size == 1)            /* stream */
     pad_size = 0;
 
-  data = gnutls_malloc (plain->size + pad_size);
+  data = MHD_gnutls_malloc (plain->size + pad_size);
   if (data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
@@ -1504,33 +1504,33 @@ encrypt_data (const gnutls_datum_t * plain,
 
   d_iv.data = (opaque *) enc_params->iv;
   d_iv.size = enc_params->iv_size;
-  ch = mhd_gtls_cipher_init (enc_params->cipher, key, &d_iv);
+  ch = MHD_gtls_cipher_init (enc_params->cipher, key, &d_iv);
 
   if (ch == GNUTLS_CIPHER_FAILED)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_ENCRYPTION_FAILED;
       goto error;
     }
 
-  result = mhd_gtls_cipher_encrypt (ch, data, data_size);
+  result = MHD_gtls_cipher_encrypt (ch, data, data_size);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
 
   encrypted->data = data;
   encrypted->size = data_size;
 
-  mhd_gnutls_cipher_deinit (ch);
+  MHD_gnutls_cipher_deinit (ch);
 
   return 0;
 
 error:
-  gnutls_free (data);
+  MHD_gnutls_free (data);
   if (ch != NULL)
-    mhd_gnutls_cipher_deinit (ch);
+    MHD_gnutls_cipher_deinit (ch);
   return result;
 }
 
@@ -1538,12 +1538,12 @@ error:
  * and stored in dec.
  */
 int
-_gnutls_pkcs7_decrypt_data (const gnutls_datum_t * data,
-                            const char *password, gnutls_datum_t * dec)
+MHD__gnutls_pkcs7_decrypt_data (const MHD_gnutls_datum_t * data,
+                            const char *password, MHD_gnutls_datum_t * dec)
 {
   int result, len;
   char enc_oid[64];
-  gnutls_datum_t tmp;
+  MHD_gnutls_datum_t tmp;
   ASN1_TYPE pbes2_asn = ASN1_TYPE_EMPTY, pkcs7_asn = ASN1_TYPE_EMPTY;
   int params_start, params_end, params_len;
   struct pbkdf2_params kdf_params;
@@ -1551,20 +1551,20 @@ _gnutls_pkcs7_decrypt_data (const gnutls_datum_t * data,
   schema_id schema;
 
   if ((result =
-       asn1_create_element (_gnutls_get_pkix (),
+       MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                             "PKIX1.pkcs-7-EncryptedData",
                             &pkcs7_asn)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
 
-  result = asn1_der_decoding (&pkcs7_asn, data->data, data->size, NULL);
+  result = MHD__asn1_der_decoding (&pkcs7_asn, data->data, data->size, NULL);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
 
@@ -1572,19 +1572,19 @@ _gnutls_pkcs7_decrypt_data (const gnutls_datum_t * data,
    */
   len = sizeof (enc_oid);
   result =
-    asn1_read_value (pkcs7_asn,
+    MHD__asn1_read_value (pkcs7_asn,
                      "encryptedContentInfo.contentEncryptionAlgorithm.algorithm",
                      enc_oid, &len);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
 
   if ((result = check_schema (enc_oid)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
   schema = result;
@@ -1592,13 +1592,13 @@ _gnutls_pkcs7_decrypt_data (const gnutls_datum_t * data,
   /* Get the DER encoding of the parameters.
    */
   result =
-    asn1_der_decoding_startEnd (pkcs7_asn, data->data, data->size,
+    MHD__asn1_der_decoding_startEnd (pkcs7_asn, data->data, data->size,
                                 "encryptedContentInfo.contentEncryptionAlgorithm.parameters",
                                 &params_start, &params_end);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
   params_len = params_end - params_start + 1;
@@ -1609,8 +1609,8 @@ _gnutls_pkcs7_decrypt_data (const gnutls_datum_t * data,
                              params_len, &kdf_params, &enc_params);
   if (result < ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
 
@@ -1624,19 +1624,19 @@ _gnutls_pkcs7_decrypt_data (const gnutls_datum_t * data,
                   &kdf_params, &enc_params, &tmp);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
 
-  asn1_delete_structure (&pkcs7_asn);
+  MHD__asn1_delete_structure (&pkcs7_asn);
 
   *dec = tmp;
 
   return 0;
 
 error:
-  asn1_delete_structure (&pbes2_asn);
-  asn1_delete_structure (&pkcs7_asn);
+  MHD__asn1_delete_structure (&pbes2_asn);
+  MHD__asn1_delete_structure (&pkcs7_asn);
   return result;
 }
 
@@ -1644,24 +1644,24 @@ error:
  * and stored in enc.
  */
 int
-_gnutls_pkcs7_encrypt_data (schema_id schema,
-                            const gnutls_datum_t * data,
-                            const char *password, gnutls_datum_t * enc)
+MHD__gnutls_pkcs7_encrypt_data (schema_id schema,
+                            const MHD_gnutls_datum_t * data,
+                            const char *password, MHD_gnutls_datum_t * enc)
 {
   int result;
-  gnutls_datum_t key = { NULL, 0 };
-  gnutls_datum_t tmp = { NULL, 0 };
+  MHD_gnutls_datum_t key = { NULL, 0 };
+  MHD_gnutls_datum_t tmp = { NULL, 0 };
   ASN1_TYPE pkcs7_asn = ASN1_TYPE_EMPTY;
   struct pbkdf2_params kdf_params;
   struct pbe_enc_params enc_params;
 
   if ((result =
-       asn1_create_element (_gnutls_get_pkix (),
+       MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                             "PKIX1.pkcs-7-EncryptedData",
                             &pkcs7_asn)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
 
@@ -1671,25 +1671,25 @@ _gnutls_pkcs7_encrypt_data (schema_id schema,
     {
     case PBES2:
       result =
-        asn1_write_value (pkcs7_asn,
+        MHD__asn1_write_value (pkcs7_asn,
                           "encryptedContentInfo.contentEncryptionAlgorithm.algorithm",
                           PBES2_OID, 1);
       break;
     case PKCS12_3DES_SHA1:
       result =
-        asn1_write_value (pkcs7_asn,
+        MHD__asn1_write_value (pkcs7_asn,
                           "encryptedContentInfo.contentEncryptionAlgorithm.algorithm",
                           PKCS12_PBE_3DES_SHA1_OID, 1);
       break;
     case PKCS12_ARCFOUR_SHA1:
       result =
-        asn1_write_value (pkcs7_asn,
+        MHD__asn1_write_value (pkcs7_asn,
                           "encryptedContentInfo.contentEncryptionAlgorithm.algorithm",
                           PKCS12_PBE_ARCFOUR_SHA1_OID, 1);
       break;
     case PKCS12_RC2_40_SHA1:
       result =
-        asn1_write_value (pkcs7_asn,
+        MHD__asn1_write_value (pkcs7_asn,
                           "encryptedContentInfo.contentEncryptionAlgorithm.algorithm",
                           PKCS12_PBE_RC2_40_SHA1_OID, 1);
       break;
@@ -1698,8 +1698,8 @@ _gnutls_pkcs7_encrypt_data (schema_id schema,
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
 
@@ -1709,7 +1709,7 @@ _gnutls_pkcs7_encrypt_data (schema_id schema,
   result = generate_key (schema, password, &kdf_params, &enc_params, &key);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
 
@@ -1718,7 +1718,7 @@ _gnutls_pkcs7_encrypt_data (schema_id schema,
                                 &kdf_params, &enc_params);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
 
@@ -1728,70 +1728,70 @@ _gnutls_pkcs7_encrypt_data (schema_id schema,
   result = encrypt_data (data, &enc_params, &key, &tmp);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
 
   /* write the encrypted data.
    */
   result =
-    asn1_write_value (pkcs7_asn,
+    MHD__asn1_write_value (pkcs7_asn,
                       "encryptedContentInfo.encryptedContent", tmp.data,
                       tmp.size);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
 
-  _gnutls_free_datum (&tmp);
-  _gnutls_free_datum (&key);
+  MHD__gnutls_free_datum (&tmp);
+  MHD__gnutls_free_datum (&key);
 
   /* Now write the rest of the pkcs-7 stuff.
    */
 
-  result = _gnutls_x509_write_uint32 (pkcs7_asn, "version", 0);
+  result = MHD__gnutls_x509_write_uint32 (pkcs7_asn, "version", 0);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
 
   result =
-    asn1_write_value (pkcs7_asn, "encryptedContentInfo.contentType",
+    MHD__asn1_write_value (pkcs7_asn, "encryptedContentInfo.contentType",
                       DATA_OID, 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
 
-  result = asn1_write_value (pkcs7_asn, "unprotectedAttrs", NULL, 0);
+  result = MHD__asn1_write_value (pkcs7_asn, "unprotectedAttrs", NULL, 0);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto error;
     }
 
   /* Now encode and copy the DER stuff.
    */
-  result = _gnutls_x509_der_encode (pkcs7_asn, "", enc, 0);
+  result = MHD__gnutls_x509_der_encode (pkcs7_asn, "", enc, 0);
 
-  asn1_delete_structure (&pkcs7_asn);
+  MHD__asn1_delete_structure (&pkcs7_asn);
 
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
 
 error:
-  _gnutls_free_datum (&key);
-  _gnutls_free_datum (&tmp);
-  asn1_delete_structure (&pkcs7_asn);
+  MHD__gnutls_free_datum (&key);
+  MHD__gnutls_free_datum (&tmp);
+  MHD__asn1_delete_structure (&pkcs7_asn);
   return result;
 }
 
diff --git a/src/daemon/https/x509/rfc2818.h b/src/daemon/https/x509/rfc2818.h
index c3399145..c38bd8a9 100644
--- a/src/daemon/https/x509/rfc2818.h
+++ b/src/daemon/https/x509/rfc2818.h
@@ -22,5 +22,5 @@
  *
  */
 
-int _gnutls_hostname_compare (const char *certname, const char *hostname);
+int MHD__gnutls_hostname_compare (const char *certname, const char *hostname);
 #define MAX_CN 256
diff --git a/src/daemon/https/x509/rfc2818_hostname.c b/src/daemon/https/x509/rfc2818_hostname.c
index 93a96589..fe03af33 100644
--- a/src/daemon/https/x509/rfc2818_hostname.c
+++ b/src/daemon/https/x509/rfc2818_hostname.c
@@ -32,7 +32,7 @@
  * return 1 on success or 0 on error
  */
 int
-_gnutls_hostname_compare (const char *certname, const char *hostname)
+MHD__gnutls_hostname_compare (const char *certname, const char *hostname)
 {
   const char *cmpstr1, *cmpstr2;
 
@@ -71,8 +71,8 @@ _gnutls_hostname_compare (const char *certname, const char *hostname)
 }
 
 /**
-  * gnutls_x509_crt_check_hostname - This function compares the given hostname with the hostname in the certificate
-  * @cert: should contain an gnutls_x509_crt_t structure
+  * MHD_gnutls_x509_crt_check_hostname - This function compares the given hostname with the hostname in the certificate
+  * @cert: should contain an MHD_gnutls_x509_crt_t structure
   * @hostname: A null terminated string that contains a DNS name
   *
   * This function will check if the given certificate's subject
@@ -84,7 +84,7 @@ _gnutls_hostname_compare (const char *certname, const char *hostname)
   * Returns non zero for a successful match, and zero on failure.
   **/
 int
-gnutls_x509_crt_check_hostname (gnutls_x509_crt_t cert, const char *hostname)
+MHD_gnutls_x509_crt_check_hostname (MHD_gnutls_x509_crt_t cert, const char *hostname)
 {
 
   char dnsname[MAX_CN];
@@ -111,14 +111,14 @@ gnutls_x509_crt_check_hostname (gnutls_x509_crt_t cert, const char *hostname)
     {
 
       dnsnamesize = sizeof (dnsname);
-      ret = gnutls_x509_crt_get_subject_alt_name (cert, i,
+      ret = MHD_gnutls_x509_crt_get_subject_alt_name (cert, i,
                                                   dnsname, &dnsnamesize,
                                                   NULL);
 
       if (ret == GNUTLS_SAN_DNSNAME)
         {
           found_dnsname = 1;
-          if (_gnutls_hostname_compare (dnsname, hostname))
+          if (MHD__gnutls_hostname_compare (dnsname, hostname))
             {
               return 1;
             }
@@ -128,7 +128,7 @@ gnutls_x509_crt_check_hostname (gnutls_x509_crt_t cert, const char *hostname)
           found_dnsname = 1;    /* RFC 2818 is unclear whether the CN
                                    should be compared for IP addresses
                                    too, but we won't do it.  */
-          if (_gnutls_hostname_compare (dnsname, hostname))
+          if (MHD__gnutls_hostname_compare (dnsname, hostname))
             {
               return 1;
             }
@@ -140,7 +140,7 @@ gnutls_x509_crt_check_hostname (gnutls_x509_crt_t cert, const char *hostname)
       /* not got the necessary extension, use CN instead
        */
       dnsnamesize = sizeof (dnsname);
-      if (gnutls_x509_crt_get_dn_by_oid (cert, OID_X520_COMMON_NAME, 0,
+      if (MHD_gnutls_x509_crt_get_dn_by_oid (cert, OID_X520_COMMON_NAME, 0,
                                          0, dnsname, &dnsnamesize) < 0)
         {
           /* got an error, can't find a name
@@ -148,7 +148,7 @@ gnutls_x509_crt_check_hostname (gnutls_x509_crt_t cert, const char *hostname)
           return 0;
         }
 
-      if (_gnutls_hostname_compare (dnsname, hostname))
+      if (MHD__gnutls_hostname_compare (dnsname, hostname))
         {
           return 1;
         }
diff --git a/src/daemon/https/x509/sign.c b/src/daemon/https/x509/sign.c
index 2d367732..8b89b038 100644
--- a/src/daemon/https/x509/sign.c
+++ b/src/daemon/https/x509/sign.c
@@ -50,34 +50,34 @@
  */
 static int
 encode_ber_digest_info (enum MHD_GNUTLS_HashAlgorithm hash,
-                        const gnutls_datum_t * digest, gnutls_datum_t * info)
+                        const MHD_gnutls_datum_t * digest, MHD_gnutls_datum_t * info)
 {
   ASN1_TYPE dinfo = ASN1_TYPE_EMPTY;
   int result;
   const char *algo;
 
-  algo = mhd_gtls_x509_mac_to_oid ((enum MHD_GNUTLS_HashAlgorithm) hash);
+  algo = MHD_gtls_x509_mac_to_oid ((enum MHD_GNUTLS_HashAlgorithm) hash);
   if (algo == NULL)
     {
-      gnutls_assert ();
-      _gnutls_x509_log ("Hash algorithm: %d\n", hash);
+      MHD_gnutls_assert ();
+      MHD__gnutls_x509_log ("Hash algorithm: %d\n", hash);
       return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
     }
 
-  if ((result = asn1_create_element (_gnutls_get_gnutls_asn (),
+  if ((result = MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (),
                                      "GNUTLS.DigestInfo",
                                      &dinfo)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  result = asn1_write_value (dinfo, "digestAlgorithm.algorithm", algo, 1);
+  result = MHD__asn1_write_value (dinfo, "digestAlgorithm.algorithm", algo, 1);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&dinfo);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&dinfo);
+      return MHD_gtls_asn2err (result);
     }
 
   /* Write an ASN.1 NULL in the parameters field.  This matches RFC
@@ -85,43 +85,43 @@ encode_ber_digest_info (enum MHD_GNUTLS_HashAlgorithm hash,
      perspective (see those documents for more information).
      Regardless of what is correct, this appears to be what most
      implementations do.  */
-  result = asn1_write_value (dinfo, "digestAlgorithm.parameters",
+  result = MHD__asn1_write_value (dinfo, "digestAlgorithm.parameters",
                              "\x05\x00", 2);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&dinfo);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&dinfo);
+      return MHD_gtls_asn2err (result);
     }
 
-  result = asn1_write_value (dinfo, "digest", digest->data, digest->size);
+  result = MHD__asn1_write_value (dinfo, "digest", digest->data, digest->size);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&dinfo);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&dinfo);
+      return MHD_gtls_asn2err (result);
     }
 
   info->size = 0;
-  asn1_der_coding (dinfo, "", NULL, &info->size, NULL);
+  MHD__asn1_der_coding (dinfo, "", NULL, &info->size, NULL);
 
-  info->data = gnutls_malloc (info->size);
+  info->data = MHD_gnutls_malloc (info->size);
   if (info->data == NULL)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&dinfo);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&dinfo);
       return GNUTLS_E_MEMORY_ERROR;
     }
 
-  result = asn1_der_coding (dinfo, "", info->data, &info->size, NULL);
+  result = MHD__asn1_der_coding (dinfo, "", info->data, &info->size, NULL);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&dinfo);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&dinfo);
+      return MHD_gtls_asn2err (result);
     }
 
-  asn1_delete_structure (&dinfo);
+  MHD__asn1_delete_structure (&dinfo);
 
   return 0;
 }
@@ -133,45 +133,45 @@ encode_ber_digest_info (enum MHD_GNUTLS_HashAlgorithm hash,
  */
 static int
 pkcs1_rsa_sign (enum MHD_GNUTLS_HashAlgorithm hash,
-                const gnutls_datum_t * text, mpi_t * params, int params_len,
-                gnutls_datum_t * signature)
+                const MHD_gnutls_datum_t * text, mpi_t * params, int params_len,
+                MHD_gnutls_datum_t * signature)
 {
   int ret;
   opaque _digest[MAX_HASH_SIZE];
   GNUTLS_HASH_HANDLE hd;
-  gnutls_datum_t digest, info;
+  MHD_gnutls_datum_t digest, info;
 
-  hd = mhd_gtls_hash_init (HASH2MAC (hash));
+  hd = MHD_gtls_hash_init (HASH2MAC (hash));
   if (hd == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_HASH_FAILED;
     }
 
-  mhd_gnutls_hash (hd, text->data, text->size);
-  mhd_gnutls_hash_deinit (hd, _digest);
+  MHD_gnutls_hash (hd, text->data, text->size);
+  MHD_gnutls_hash_deinit (hd, _digest);
 
   digest.data = _digest;
-  digest.size = mhd_gnutls_hash_get_algo_len (HASH2MAC (hash));
+  digest.size = MHD_gnutls_hash_get_algo_len (HASH2MAC (hash));
 
   /* Encode the digest as a DigestInfo
    */
   if ((ret = encode_ber_digest_info (hash, &digest, &info)) != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
   if ((ret =
-       mhd_gtls_sign (MHD_GNUTLS_PK_RSA, params, params_len, &info,
+       MHD_gtls_sign (MHD_GNUTLS_PK_RSA, params, params_len, &info,
                       signature)) < 0)
     {
-      gnutls_assert ();
-      _gnutls_free_datum (&info);
+      MHD_gnutls_assert ();
+      MHD__gnutls_free_datum (&info);
       return ret;
     }
 
-  _gnutls_free_datum (&info);
+  MHD__gnutls_free_datum (&info);
 
   return 0;
 }
@@ -186,9 +186,9 @@ pkcs1_rsa_sign (enum MHD_GNUTLS_HashAlgorithm hash,
  * 'hash' is only used in PKCS1 RSA signing.
  */
 int
-_gnutls_x509_sign (const gnutls_datum_t * tbs,
+MHD__gnutls_x509_sign (const MHD_gnutls_datum_t * tbs,
                    enum MHD_GNUTLS_HashAlgorithm hash,
-                   gnutls_x509_privkey_t signer, gnutls_datum_t * signature)
+                   MHD_gnutls_x509_privkey_t signer, MHD_gnutls_datum_t * signature)
 {
   int ret;
 
@@ -200,63 +200,63 @@ _gnutls_x509_sign (const gnutls_datum_t * tbs,
                         signature);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
       return 0;
       break;
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
 }
 
-/* This is the same as the _gnutls_x509_sign, but this one will decode
+/* This is the same as the MHD__gnutls_x509_sign, but this one will decode
  * the ASN1_TYPE given, and sign the DER data. Actually used to get the DER
  * of the TBS and sign it on the fly.
  */
 int
-_gnutls_x509_sign_tbs (ASN1_TYPE cert, const char *tbs_name,
+MHD__gnutls_x509_sign_tbs (ASN1_TYPE cert, const char *tbs_name,
                        enum MHD_GNUTLS_HashAlgorithm hash,
-                       gnutls_x509_privkey_t signer,
-                       gnutls_datum_t * signature)
+                       MHD_gnutls_x509_privkey_t signer,
+                       MHD_gnutls_datum_t * signature)
 {
   int result;
   opaque *buf;
   int buf_size;
-  gnutls_datum_t tbs;
+  MHD_gnutls_datum_t tbs;
 
   buf_size = 0;
-  asn1_der_coding (cert, tbs_name, NULL, &buf_size, NULL);
+  MHD__asn1_der_coding (cert, tbs_name, NULL, &buf_size, NULL);
 
-  buf = gnutls_alloca (buf_size);
+  buf = MHD_gnutls_alloca (buf_size);
   if (buf == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
-  result = asn1_der_coding (cert, tbs_name, buf, &buf_size, NULL);
+  result = MHD__asn1_der_coding (cert, tbs_name, buf, &buf_size, NULL);
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      gnutls_afree (buf);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD_gnutls_afree (buf);
+      return MHD_gtls_asn2err (result);
     }
 
   tbs.data = buf;
   tbs.size = buf_size;
 
-  result = _gnutls_x509_sign (&tbs, hash, signer, signature);
-  gnutls_afree (buf);
+  result = MHD__gnutls_x509_sign (&tbs, hash, signer, signature);
+  MHD_gnutls_afree (buf);
 
   return result;
 }
 
 /*-
- * _gnutls_x509_pkix_sign - This function will sign a CRL or a certificate with a key
+ * MHD__gnutls_x509_pkix_sign - This function will sign a CRL or a certificate with a key
  * @src: should contain an ASN1_TYPE
  * @issuer: is the certificate of the certificate issuer
  * @issuer_key: holds the issuer's private key
@@ -268,76 +268,76 @@ _gnutls_x509_sign_tbs (ASN1_TYPE cert, const char *tbs_name,
  *
  -*/
 int
-_gnutls_x509_pkix_sign (ASN1_TYPE src, const char *src_name,
+MHD__gnutls_x509_pkix_sign (ASN1_TYPE src, const char *src_name,
                         enum MHD_GNUTLS_HashAlgorithm dig,
-                        gnutls_x509_crt_t issuer,
-                        gnutls_x509_privkey_t issuer_key)
+                        MHD_gnutls_x509_crt_t issuer,
+                        MHD_gnutls_x509_privkey_t issuer_key)
 {
   int result;
-  gnutls_datum_t signature;
+  MHD_gnutls_datum_t signature;
   char name[128];
 
   /* Step 1. Copy the issuer's name into the certificate.
    */
-  mhd_gtls_str_cpy (name, sizeof (name), src_name);
-  mhd_gtls_str_cat (name, sizeof (name), ".issuer");
+  MHD_gtls_str_cpy (name, sizeof (name), src_name);
+  MHD_gtls_str_cat (name, sizeof (name), ".issuer");
 
-  result = asn1_copy_node (src, name, issuer->cert, "tbsCertificate.subject");
+  result = MHD__asn1_copy_node (src, name, issuer->cert, "tbsCertificate.subject");
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   /* Step 1.5. Write the signature stuff in the tbsCertificate.
    */
-  mhd_gtls_str_cpy (name, sizeof (name), src_name);
-  mhd_gtls_str_cat (name, sizeof (name), ".signature");
+  MHD_gtls_str_cpy (name, sizeof (name), src_name);
+  MHD_gtls_str_cat (name, sizeof (name), ".signature");
 
-  result = _gnutls_x509_write_sig_params (src, name,
+  result = MHD__gnutls_x509_write_sig_params (src, name,
                                           issuer_key->pk_algorithm, dig,
                                           issuer_key->params,
                                           issuer_key->params_size);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
   /* Step 2. Sign the certificate.
    */
-  result = _gnutls_x509_sign_tbs (src, src_name, dig, issuer_key, &signature);
+  result = MHD__gnutls_x509_sign_tbs (src, src_name, dig, issuer_key, &signature);
 
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
   /* write the signature (bits)
    */
   result =
-    asn1_write_value (src, "signature", signature.data, signature.size * 8);
+    MHD__asn1_write_value (src, "signature", signature.data, signature.size * 8);
 
-  _gnutls_free_datum (&signature);
+  MHD__gnutls_free_datum (&signature);
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   /* Step 3. Move up and write the AlgorithmIdentifier, which is also
    * the same.
    */
 
-  result = _gnutls_x509_write_sig_params (src, "signatureAlgorithm",
+  result = MHD__gnutls_x509_write_sig_params (src, "signatureAlgorithm",
                                           issuer_key->pk_algorithm, dig,
                                           issuer_key->params,
                                           issuer_key->params_size);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
diff --git a/src/daemon/https/x509/sign.h b/src/daemon/https/x509/sign.h
index 86d9859c..b2f7d939 100644
--- a/src/daemon/https/x509/sign.h
+++ b/src/daemon/https/x509/sign.h
@@ -22,15 +22,15 @@
  *
  */
 
-int _gnutls_x509_sign (const gnutls_datum_t * tbs,
+int MHD__gnutls_x509_sign (const MHD_gnutls_datum_t * tbs,
                        enum MHD_GNUTLS_HashAlgorithm hash,
-                       gnutls_x509_privkey_t signer,
-                       gnutls_datum_t * signature);
-int _gnutls_x509_sign_tbs (ASN1_TYPE cert, const char *tbs_name,
+                       MHD_gnutls_x509_privkey_t signer,
+                       MHD_gnutls_datum_t * signature);
+int MHD__gnutls_x509_sign_tbs (ASN1_TYPE cert, const char *tbs_name,
                            enum MHD_GNUTLS_HashAlgorithm hash,
-                           gnutls_x509_privkey_t signer,
-                           gnutls_datum_t * signature);
-int _gnutls_x509_pkix_sign (ASN1_TYPE src, const char *src_name,
+                           MHD_gnutls_x509_privkey_t signer,
+                           MHD_gnutls_datum_t * signature);
+int MHD__gnutls_x509_pkix_sign (ASN1_TYPE src, const char *src_name,
                             enum MHD_GNUTLS_HashAlgorithm,
-                            gnutls_x509_crt_t issuer,
-                            gnutls_x509_privkey_t issuer_key);
+                            MHD_gnutls_x509_crt_t issuer,
+                            MHD_gnutls_x509_privkey_t issuer_key);
diff --git a/src/daemon/https/x509/verify.h b/src/daemon/https/x509/verify.h
index c7e3c63d..0a2e020c 100644
--- a/src/daemon/https/x509/verify.h
+++ b/src/daemon/https/x509/verify.h
@@ -24,11 +24,11 @@
 
 #include "x509.h"
 
-int gnutls_x509_crt_is_issuer (gnutls_x509_crt_t cert,
-                               gnutls_x509_crt_t issuer);
-int _gnutls_x509_verify_signature (const gnutls_datum_t * tbs,
-                                   const gnutls_datum_t * signature,
-                                   gnutls_x509_crt_t issuer);
-int _gnutls_x509_privkey_verify_signature (const gnutls_datum_t * tbs,
-                                           const gnutls_datum_t * signature,
-                                           gnutls_x509_privkey_t issuer);
+int MHD_gnutls_x509_crt_is_issuer (MHD_gnutls_x509_crt_t cert,
+                               MHD_gnutls_x509_crt_t issuer);
+int MHD__gnutls_x509_verify_signature (const MHD_gnutls_datum_t * tbs,
+                                   const MHD_gnutls_datum_t * signature,
+                                   MHD_gnutls_x509_crt_t issuer);
+int MHD__gnutls_x509_privkey_verify_signature (const MHD_gnutls_datum_t * tbs,
+                                           const MHD_gnutls_datum_t * signature,
+                                           MHD_gnutls_x509_privkey_t issuer);
diff --git a/src/daemon/https/x509/x509.c b/src/daemon/https/x509/x509.c
index 9db24be9..599902ca 100644
--- a/src/daemon/https/x509/x509.c
+++ b/src/daemon/https/x509/x509.c
@@ -40,7 +40,7 @@
 #include <verify.h>
 
 /**
- * gnutls_x509_crt_init - This function initializes a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_init - This function initializes a MHD_gnutls_x509_crt_t structure
  * @cert: The structure to be initialized
  *
  * This function will initialize an X.509 certificate structure.
@@ -49,21 +49,21 @@
  *
  **/
 int
-gnutls_x509_crt_init (gnutls_x509_crt_t * cert)
+MHD_gnutls_x509_crt_init (MHD_gnutls_x509_crt_t * cert)
 {
-  gnutls_x509_crt_t tmp = gnutls_calloc (1, sizeof (gnutls_x509_crt_int));
+  MHD_gnutls_x509_crt_t tmp = MHD_gnutls_calloc (1, sizeof (MHD_gnutls_x509_crt_int));
   int result;
 
   if (!tmp)
     return GNUTLS_E_MEMORY_ERROR;
 
-  result = asn1_create_element (_gnutls_get_pkix (),
+  result = MHD__asn1_create_element (MHD__gnutls_get_pkix (),
                                 "PKIX1.Certificate", &tmp->cert);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      gnutls_free (tmp);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD_gnutls_free (tmp);
+      return MHD_gtls_asn2err (result);
     }
 
   *cert = tmp;
@@ -72,7 +72,7 @@ gnutls_x509_crt_init (gnutls_x509_crt_t * cert)
 }
 
 /*-
- * _gnutls_x509_crt_cpy - This function copies a gnutls_x509_crt_t structure
+ * MHD__gnutls_x509_crt_cpy - This function copies a MHD_gnutls_x509_crt_t structure
  * @dest: The structure where to copy
  * @src: The structure to be copied
  *
@@ -82,44 +82,44 @@ gnutls_x509_crt_init (gnutls_x509_crt_t * cert)
  *
  -*/
 int
-_gnutls_x509_crt_cpy (gnutls_x509_crt_t dest, gnutls_x509_crt_t src)
+MHD__gnutls_x509_crt_cpy (MHD_gnutls_x509_crt_t dest, MHD_gnutls_x509_crt_t src)
 {
   int ret;
   size_t der_size;
   opaque *der;
-  gnutls_datum_t tmp;
+  MHD_gnutls_datum_t tmp;
 
-  ret = gnutls_x509_crt_export (src, GNUTLS_X509_FMT_DER, NULL, &der_size);
+  ret = MHD_gnutls_x509_crt_export (src, GNUTLS_X509_FMT_DER, NULL, &der_size);
   if (ret != GNUTLS_E_SHORT_MEMORY_BUFFER)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  der = gnutls_alloca (der_size);
+  der = MHD_gnutls_alloca (der_size);
   if (der == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
-  ret = gnutls_x509_crt_export (src, GNUTLS_X509_FMT_DER, der, &der_size);
+  ret = MHD_gnutls_x509_crt_export (src, GNUTLS_X509_FMT_DER, der, &der_size);
   if (ret < 0)
     {
-      gnutls_assert ();
-      gnutls_afree (der);
+      MHD_gnutls_assert ();
+      MHD_gnutls_afree (der);
       return ret;
     }
 
   tmp.data = der;
   tmp.size = der_size;
-  ret = gnutls_x509_crt_import (dest, &tmp, GNUTLS_X509_FMT_DER);
+  ret = MHD_gnutls_x509_crt_import (dest, &tmp, GNUTLS_X509_FMT_DER);
 
-  gnutls_afree (der);
+  MHD_gnutls_afree (der);
 
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -128,32 +128,32 @@ _gnutls_x509_crt_cpy (gnutls_x509_crt_t dest, gnutls_x509_crt_t src)
 }
 
 /**
- * gnutls_x509_crt_deinit - This function deinitializes memory used by a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_deinit - This function deinitializes memory used by a MHD_gnutls_x509_crt_t structure
  * @cert: The structure to be initialized
  *
  * This function will deinitialize a CRL structure.
  *
  **/
 void
-gnutls_x509_crt_deinit (gnutls_x509_crt_t cert)
+MHD_gnutls_x509_crt_deinit (MHD_gnutls_x509_crt_t cert)
 {
   if (!cert)
     return;
 
   if (cert->cert)
-    asn1_delete_structure (&cert->cert);
+    MHD__asn1_delete_structure (&cert->cert);
 
-  gnutls_free (cert);
+  MHD_gnutls_free (cert);
 }
 
 /**
- * gnutls_x509_crt_import - This function will import a DER or PEM encoded Certificate
+ * MHD_gnutls_x509_crt_import - This function will import a DER or PEM encoded Certificate
  * @cert: The structure to store the parsed certificate.
  * @data: The DER or PEM encoded certificate.
  * @format: One of DER or PEM
  *
  * This function will convert the given DER or PEM encoded Certificate
- * to the native gnutls_x509_crt_t format. The output will be stored in @cert.
+ * to the native MHD_gnutls_x509_crt_t format. The output will be stored in @cert.
  *
  * If the Certificate is PEM encoded it should have a header of "X509 CERTIFICATE", or
  * "CERTIFICATE".
@@ -162,17 +162,17 @@ gnutls_x509_crt_deinit (gnutls_x509_crt_t cert)
  *
  **/
 int
-gnutls_x509_crt_import (gnutls_x509_crt_t cert,
-                        const gnutls_datum_t * data,
-                        gnutls_x509_crt_fmt_t format)
+MHD_gnutls_x509_crt_import (MHD_gnutls_x509_crt_t cert,
+                        const MHD_gnutls_datum_t * data,
+                        MHD_gnutls_x509_crt_fmt_t format)
 {
   int result = 0, need_free = 0;
-  gnutls_datum_t _data;
+  MHD_gnutls_datum_t _data;
   opaque *signature = NULL;
 
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -186,20 +186,20 @@ gnutls_x509_crt_import (gnutls_x509_crt_t cert,
       opaque *out;
 
       /* Try the first header */
-      result = _gnutls_fbase64_decode (PEM_X509_CERT2, data->data, data->size,
+      result = MHD__gnutls_fbase64_decode (PEM_X509_CERT2, data->data, data->size,
                                        &out);
 
       if (result <= 0)
         {
           /* try for the second header */
-          result = _gnutls_fbase64_decode (PEM_X509_CERT, data->data,
+          result = MHD__gnutls_fbase64_decode (PEM_X509_CERT, data->data,
                                            data->size, &out);
 
           if (result <= 0)
             {
               if (result == 0)
                 result = GNUTLS_E_INTERNAL_ERROR;
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return result;
             }
         }
@@ -210,11 +210,11 @@ gnutls_x509_crt_import (gnutls_x509_crt_t cert,
       need_free = 1;
     }
 
-  result = asn1_der_decoding (&cert->cert, _data.data, _data.size, NULL);
+  result = MHD__asn1_der_decoding (&cert->cert, _data.data, _data.size, NULL);
   if (result != ASN1_SUCCESS)
     {
-      result = mhd_gtls_asn2err (result);
-      gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
@@ -222,19 +222,19 @@ gnutls_x509_crt_import (gnutls_x509_crt_t cert,
    */
   cert->use_extensions = 1;
   if (need_free)
-    _gnutls_free_datum (&_data);
+    MHD__gnutls_free_datum (&_data);
 
   return 0;
 
-cleanup:gnutls_free (signature);
+cleanup:MHD_gnutls_free (signature);
   if (need_free)
-    _gnutls_free_datum (&_data);
+    MHD__gnutls_free_datum (&_data);
   return result;
 }
 
 /**
- * gnutls_x509_crt_get_issuer_dn - This function returns the Certificate's issuer distinguished name
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_issuer_dn - This function returns the Certificate's issuer distinguished name
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @buf: a pointer to a structure to hold the name (may be null)
  * @sizeof_buf: initially holds the size of @buf
  *
@@ -251,23 +251,23 @@ cleanup:gnutls_free (signature);
  *
  **/
 int
-gnutls_x509_crt_get_issuer_dn (gnutls_x509_crt_t cert,
+MHD_gnutls_x509_crt_get_issuer_dn (MHD_gnutls_x509_crt_t cert,
                                char *buf, size_t * sizeof_buf)
 {
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  return _gnutls_x509_parse_dn (cert->cert,
+  return MHD__gnutls_x509_parse_dn (cert->cert,
                                 "tbsCertificate.issuer.rdnSequence", buf,
                                 sizeof_buf);
 }
 
 /**
- * gnutls_x509_crt_get_issuer_dn_by_oid - This function returns the Certificate's issuer distinguished name
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_issuer_dn_by_oid - This function returns the Certificate's issuer distinguished name
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @oid: holds an Object Identified in null terminated string
  * @indx: In case multiple same OIDs exist in the RDN, this specifies which to send. Use zero to get the first one.
  * @raw_flag: If non zero returns the raw DER data of the DN part.
@@ -283,7 +283,7 @@ gnutls_x509_crt_get_issuer_dn (gnutls_x509_crt_t cert,
  * If raw flag is zero, this function will only return known OIDs as
  * text. Other OIDs will be DER encoded, as described in RFC2253 --
  * in hex format with a '\#' prefix.  You can check about known OIDs
- * using gnutls_x509_dn_oid_known().
+ * using MHD_gnutls_x509_dn_oid_known().
  *
  * If @buf is null then only the size will be filled.
  *
@@ -293,7 +293,7 @@ gnutls_x509_crt_get_issuer_dn (gnutls_x509_crt_t cert,
  *
  **/
 int
-gnutls_x509_crt_get_issuer_dn_by_oid (gnutls_x509_crt_t cert,
+MHD_gnutls_x509_crt_get_issuer_dn_by_oid (MHD_gnutls_x509_crt_t cert,
                                       const char *oid,
                                       int indx,
                                       unsigned int raw_flag,
@@ -301,18 +301,18 @@ gnutls_x509_crt_get_issuer_dn_by_oid (gnutls_x509_crt_t cert,
 {
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  return _gnutls_x509_parse_dn_oid (cert->cert,
+  return MHD__gnutls_x509_parse_dn_oid (cert->cert,
                                     "tbsCertificate.issuer.rdnSequence", oid,
                                     indx, raw_flag, buf, sizeof_buf);
 }
 
 /**
- * gnutls_x509_crt_get_issuer_dn_oid - This function returns the Certificate's issuer distinguished name OIDs
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_issuer_dn_oid - This function returns the Certificate's issuer distinguished name OIDs
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @indx: This specifies which OID to return. Use zero to get the first one.
  * @oid: a pointer to a buffer to hold the OID (may be null)
  * @sizeof_oid: initially holds the size of @oid
@@ -328,23 +328,23 @@ gnutls_x509_crt_get_issuer_dn_by_oid (gnutls_x509_crt_t cert,
  *
  **/
 int
-gnutls_x509_crt_get_issuer_dn_oid (gnutls_x509_crt_t cert,
+MHD_gnutls_x509_crt_get_issuer_dn_oid (MHD_gnutls_x509_crt_t cert,
                                    int indx, void *oid, size_t * sizeof_oid)
 {
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  return _gnutls_x509_get_dn_oid (cert->cert,
+  return MHD__gnutls_x509_get_dn_oid (cert->cert,
                                   "tbsCertificate.issuer.rdnSequence", indx,
                                   oid, sizeof_oid);
 }
 
 /**
- * gnutls_x509_crt_get_dn - This function returns the Certificate's distinguished name
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_dn - This function returns the Certificate's distinguished name
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @buf: a pointer to a structure to hold the name (may be null)
  * @sizeof_buf: initially holds the size of @buf
  *
@@ -361,23 +361,23 @@ gnutls_x509_crt_get_issuer_dn_oid (gnutls_x509_crt_t cert,
  *
  **/
 int
-gnutls_x509_crt_get_dn (gnutls_x509_crt_t cert,
+MHD_gnutls_x509_crt_get_dn (MHD_gnutls_x509_crt_t cert,
                         char *buf, size_t * sizeof_buf)
 {
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  return _gnutls_x509_parse_dn (cert->cert,
+  return MHD__gnutls_x509_parse_dn (cert->cert,
                                 "tbsCertificate.subject.rdnSequence", buf,
                                 sizeof_buf);
 }
 
 /**
- * gnutls_x509_crt_get_dn_by_oid - This function returns the Certificate's distinguished name
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_dn_by_oid - This function returns the Certificate's distinguished name
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @oid: holds an Object Identified in null terminated string
  * @indx: In case multiple same OIDs exist in the RDN, this specifies which to send. Use zero to get the first one.
  * @raw_flag: If non zero returns the raw DER data of the DN part.
@@ -393,7 +393,7 @@ gnutls_x509_crt_get_dn (gnutls_x509_crt_t cert,
  * If raw flag is zero, this function will only return known OIDs as
  * text. Other OIDs will be DER encoded, as described in RFC2253 --
  * in hex format with a '\#' prefix.  You can check about known OIDs
- * using gnutls_x509_dn_oid_known().
+ * using MHD_gnutls_x509_dn_oid_known().
  *
  * If @buf is null then only the size will be filled.
  *
@@ -403,7 +403,7 @@ gnutls_x509_crt_get_dn (gnutls_x509_crt_t cert,
  *
  **/
 int
-gnutls_x509_crt_get_dn_by_oid (gnutls_x509_crt_t cert,
+MHD_gnutls_x509_crt_get_dn_by_oid (MHD_gnutls_x509_crt_t cert,
                                const char *oid,
                                int indx,
                                unsigned int raw_flag,
@@ -411,18 +411,18 @@ gnutls_x509_crt_get_dn_by_oid (gnutls_x509_crt_t cert,
 {
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  return _gnutls_x509_parse_dn_oid (cert->cert,
+  return MHD__gnutls_x509_parse_dn_oid (cert->cert,
                                     "tbsCertificate.subject.rdnSequence", oid,
                                     indx, raw_flag, buf, sizeof_buf);
 }
 
 /**
- * gnutls_x509_crt_get_dn_oid - This function returns the Certificate's subject distinguished name OIDs
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_dn_oid - This function returns the Certificate's subject distinguished name OIDs
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @indx: This specifies which OID to return. Use zero to get the first one.
  * @oid: a pointer to a buffer to hold the OID (may be null)
  * @sizeof_oid: initially holds the size of @oid
@@ -438,39 +438,39 @@ gnutls_x509_crt_get_dn_by_oid (gnutls_x509_crt_t cert,
  *
  **/
 int
-gnutls_x509_crt_get_dn_oid (gnutls_x509_crt_t cert,
+MHD_gnutls_x509_crt_get_dn_oid (MHD_gnutls_x509_crt_t cert,
                             int indx, void *oid, size_t * sizeof_oid)
 {
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  return _gnutls_x509_get_dn_oid (cert->cert,
+  return MHD__gnutls_x509_get_dn_oid (cert->cert,
                                   "tbsCertificate.subject.rdnSequence", indx,
                                   oid, sizeof_oid);
 }
 
 /**
- * gnutls_x509_crt_get_signature_algorithm - This function returns the Certificate's signature algorithm
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_signature_algorithm - This function returns the Certificate's signature algorithm
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  *
- * This function will return a value of the gnutls_sign_algorithm_t enumeration that
+ * This function will return a value of the MHD_gnutls_sign_algorithm_t enumeration that
  * is the signature algorithm.
  *
  * Returns a negative value on error.
  *
  **/
 int
-gnutls_x509_crt_get_signature_algorithm (gnutls_x509_crt_t cert)
+MHD_gnutls_x509_crt_get_signature_algorithm (MHD_gnutls_x509_crt_t cert)
 {
   int result;
-  gnutls_datum_t sa;
+  MHD_gnutls_datum_t sa;
 
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -478,25 +478,25 @@ gnutls_x509_crt_get_signature_algorithm (gnutls_x509_crt_t cert)
    * read. They will be read from the issuer's certificate if needed.
    */
   result =
-    _gnutls_x509_read_value (cert->cert, "signatureAlgorithm.algorithm", &sa,
+    MHD__gnutls_x509_read_value (cert->cert, "signatureAlgorithm.algorithm", &sa,
                              0);
 
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
-  result = mhd_gtls_x509_oid2sign_algorithm (sa.data);
+  result = MHD_gtls_x509_oid2sign_algorithm (sa.data);
 
-  _gnutls_free_datum (&sa);
+  MHD__gnutls_free_datum (&sa);
 
   return result;
 }
 
 /**
- * gnutls_x509_crt_get_signature - Returns the Certificate's signature
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_signature - Returns the Certificate's signature
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @sig: a pointer where the signature part will be copied (may be null).
  * @sizeof_sig: initially holds the size of @sig
  *
@@ -505,7 +505,7 @@ gnutls_x509_crt_get_signature_algorithm (gnutls_x509_crt_t cert)
  * Returns 0 on success, and a negative value on error.
  **/
 int
-gnutls_x509_crt_get_signature (gnutls_x509_crt_t cert,
+MHD_gnutls_x509_crt_get_signature (MHD_gnutls_x509_crt_t cert,
                                char *sig, size_t * sizeof_sig)
 {
   int result;
@@ -513,21 +513,21 @@ gnutls_x509_crt_get_signature (gnutls_x509_crt_t cert,
 
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   bits = 0;
-  result = asn1_read_value (cert->cert, "signature", NULL, &bits);
+  result = MHD__asn1_read_value (cert->cert, "signature", NULL, &bits);
   if (result != ASN1_MEM_ERROR)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   if (bits % 8 != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_CERTIFICATE_ERROR;
     }
 
@@ -539,19 +539,19 @@ gnutls_x509_crt_get_signature (gnutls_x509_crt_t cert,
       return GNUTLS_E_SHORT_MEMORY_BUFFER;
     }
 
-  result = asn1_read_value (cert->cert, "signature", sig, &len);
+  result = MHD__asn1_read_value (cert->cert, "signature", sig, &len);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   return 0;
 }
 
 /**
- * gnutls_x509_crt_get_version - This function returns the Certificate's version number
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_version - This function returns the Certificate's version number
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  *
  * This function will return the version of the specified Certificate.
  *
@@ -559,35 +559,35 @@ gnutls_x509_crt_get_signature (gnutls_x509_crt_t cert,
  *
  **/
 int
-gnutls_x509_crt_get_version (gnutls_x509_crt_t cert)
+MHD_gnutls_x509_crt_get_version (MHD_gnutls_x509_crt_t cert)
 {
   opaque version[5];
   int len, result;
 
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   len = sizeof (version);
   if ((result =
-       asn1_read_value (cert->cert, "tbsCertificate.version", version,
+       MHD__asn1_read_value (cert->cert, "tbsCertificate.version", version,
                         &len)) != ASN1_SUCCESS)
     {
 
       if (result == ASN1_ELEMENT_NOT_FOUND)
         return 1;               /* the DEFAULT version */
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   return (int) version[0] + 1;
 }
 
 /**
- * gnutls_x509_crt_get_activation_time - This function returns the Certificate's activation time
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_activation_time - This function returns the Certificate's activation time
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  *
  * This function will return the time this Certificate was or will be activated.
  *
@@ -595,21 +595,21 @@ gnutls_x509_crt_get_version (gnutls_x509_crt_t cert)
  *
  **/
 time_t
-gnutls_x509_crt_get_activation_time (gnutls_x509_crt_t cert)
+MHD_gnutls_x509_crt_get_activation_time (MHD_gnutls_x509_crt_t cert)
 {
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return (time_t) - 1;
     }
 
-  return _gnutls_x509_get_time (cert->cert,
+  return MHD__gnutls_x509_get_time (cert->cert,
                                 "tbsCertificate.validity.notBefore");
 }
 
 /**
- * gnutls_x509_crt_get_expiration_time - This function returns the Certificate's expiration time
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_expiration_time - This function returns the Certificate's expiration time
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  *
  * This function will return the time this Certificate was or will be expired.
  *
@@ -617,21 +617,21 @@ gnutls_x509_crt_get_activation_time (gnutls_x509_crt_t cert)
  *
  **/
 time_t
-gnutls_x509_crt_get_expiration_time (gnutls_x509_crt_t cert)
+MHD_gnutls_x509_crt_get_expiration_time (MHD_gnutls_x509_crt_t cert)
 {
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return (time_t) - 1;
     }
 
-  return _gnutls_x509_get_time (cert->cert,
+  return MHD__gnutls_x509_get_time (cert->cert,
                                 "tbsCertificate.validity.notAfter");
 }
 
 /**
- * gnutls_x509_crt_get_serial - This function returns the certificate's serial number
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_serial - This function returns the certificate's serial number
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @result: The place where the serial number will be copied
  * @result_size: Holds the size of the result field.
  *
@@ -645,35 +645,35 @@ gnutls_x509_crt_get_expiration_time (gnutls_x509_crt_t cert)
  *
  **/
 int
-gnutls_x509_crt_get_serial (gnutls_x509_crt_t cert,
+MHD_gnutls_x509_crt_get_serial (MHD_gnutls_x509_crt_t cert,
                             void *result, size_t * result_size)
 {
   int ret, len;
 
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   len = *result_size;
   ret
     =
-    asn1_read_value (cert->cert, "tbsCertificate.serialNumber", result, &len);
+    MHD__asn1_read_value (cert->cert, "tbsCertificate.serialNumber", result, &len);
   *result_size = len;
 
   if (ret != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (ret);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (ret);
     }
 
   return 0;
 }
 
 /**
- * gnutls_x509_crt_get_subject_key_id - This function returns the certificate's key identifier
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_subject_key_id - This function returns the certificate's key identifier
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @ret: The place where the identifier will be copied
  * @ret_size: Holds the size of the result field.
  * @critical: will be non zero if the extension is marked as critical (may be null)
@@ -686,17 +686,17 @@ gnutls_x509_crt_get_serial (gnutls_x509_crt_t cert,
  *
  **/
 int
-gnutls_x509_crt_get_subject_key_id (gnutls_x509_crt_t cert,
+MHD_gnutls_x509_crt_get_subject_key_id (MHD_gnutls_x509_crt_t cert,
                                     void *ret,
                                     size_t * ret_size, unsigned int *critical)
 {
   int result, len;
-  gnutls_datum_t id;
+  MHD_gnutls_datum_t id;
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
 
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -705,7 +705,7 @@ gnutls_x509_crt_get_subject_key_id (gnutls_x509_crt_t cert,
   else
     *ret_size = 0;
 
-  if ((result = _gnutls_x509_crt_get_extension (cert, "2.5.29.14", 0, &id,
+  if ((result = MHD__gnutls_x509_crt_get_extension (cert, "2.5.29.14", 0, &id,
                                                 critical)) < 0)
     {
       return result;
@@ -713,35 +713,35 @@ gnutls_x509_crt_get_subject_key_id (gnutls_x509_crt_t cert,
 
   if (id.size == 0 || id.data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE;
     }
 
   result =
-    asn1_create_element (_gnutls_get_pkix (), "PKIX1.SubjectKeyIdentifier",
+    MHD__asn1_create_element (MHD__gnutls_get_pkix (), "PKIX1.SubjectKeyIdentifier",
                          &c2);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      _gnutls_free_datum (&id);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__gnutls_free_datum (&id);
+      return MHD_gtls_asn2err (result);
     }
 
-  result = asn1_der_decoding (&c2, id.data, id.size, NULL);
-  _gnutls_free_datum (&id);
+  result = MHD__asn1_der_decoding (&c2, id.data, id.size, NULL);
+  MHD__gnutls_free_datum (&id);
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&c2);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&c2);
+      return MHD_gtls_asn2err (result);
     }
 
   len = *ret_size;
-  result = asn1_read_value (c2, "", ret, &len);
+  result = MHD__asn1_read_value (c2, "", ret, &len);
 
   *ret_size = len;
-  asn1_delete_structure (&c2);
+  MHD__asn1_delete_structure (&c2);
 
   if (result == ASN1_VALUE_NOT_FOUND || result == ASN1_ELEMENT_NOT_FOUND)
     {
@@ -750,16 +750,16 @@ gnutls_x509_crt_get_subject_key_id (gnutls_x509_crt_t cert,
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   return 0;
 }
 
 /**
- * gnutls_x509_crt_get_authority_key_id - This function returns the certificate authority's identifier
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_authority_key_id - This function returns the certificate authority's identifier
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @result: The place where the identifier will be copied
  * @result_size: Holds the size of the result field.
  * @critical: will be non zero if the extension is marked as critical (may be null)
@@ -773,18 +773,18 @@ gnutls_x509_crt_get_subject_key_id (gnutls_x509_crt_t cert,
  *
  **/
 int
-gnutls_x509_crt_get_authority_key_id (gnutls_x509_crt_t cert,
+MHD_gnutls_x509_crt_get_authority_key_id (MHD_gnutls_x509_crt_t cert,
                                       void *ret,
                                       size_t * ret_size,
                                       unsigned int *critical)
 {
   int result, len;
-  gnutls_datum_t id;
+  MHD_gnutls_datum_t id;
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
 
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -793,7 +793,7 @@ gnutls_x509_crt_get_authority_key_id (gnutls_x509_crt_t cert,
   else
     *ret_size = 0;
 
-  if ((result = _gnutls_x509_crt_get_extension (cert, "2.5.29.35", 0, &id,
+  if ((result = MHD__gnutls_x509_crt_get_extension (cert, "2.5.29.35", 0, &id,
                                                 critical)) < 0)
     {
       return result;
@@ -801,35 +801,35 @@ gnutls_x509_crt_get_authority_key_id (gnutls_x509_crt_t cert,
 
   if (id.size == 0 || id.data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE;
     }
 
   result =
-    asn1_create_element (_gnutls_get_pkix (), "PKIX1.AuthorityKeyIdentifier",
+    MHD__asn1_create_element (MHD__gnutls_get_pkix (), "PKIX1.AuthorityKeyIdentifier",
                          &c2);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      _gnutls_free_datum (&id);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__gnutls_free_datum (&id);
+      return MHD_gtls_asn2err (result);
     }
 
-  result = asn1_der_decoding (&c2, id.data, id.size, NULL);
-  _gnutls_free_datum (&id);
+  result = MHD__asn1_der_decoding (&c2, id.data, id.size, NULL);
+  MHD__gnutls_free_datum (&id);
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&c2);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&c2);
+      return MHD_gtls_asn2err (result);
     }
 
   len = *ret_size;
-  result = asn1_read_value (c2, "keyIdentifier", ret, &len);
+  result = MHD__asn1_read_value (c2, "keyIdentifier", ret, &len);
 
   *ret_size = len;
-  asn1_delete_structure (&c2);
+  MHD__asn1_delete_structure (&c2);
 
   if (result == ASN1_VALUE_NOT_FOUND || result == ASN1_ELEMENT_NOT_FOUND)
     {
@@ -838,16 +838,16 @@ gnutls_x509_crt_get_authority_key_id (gnutls_x509_crt_t cert,
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   return 0;
 }
 
 /**
- * gnutls_x509_crt_get_pk_algorithm - This function returns the certificate's PublicKey algorithm
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_pk_algorithm - This function returns the certificate's PublicKey algorithm
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @bits: if bits is non null it will hold the size of the parameters' in bits
  *
  * This function will return the public key algorithm of an X.509
@@ -863,23 +863,23 @@ gnutls_x509_crt_get_authority_key_id (gnutls_x509_crt_t cert,
  *
  **/
 int
-gnutls_x509_crt_get_pk_algorithm (gnutls_x509_crt_t cert, unsigned int *bits)
+MHD_gnutls_x509_crt_get_pk_algorithm (MHD_gnutls_x509_crt_t cert, unsigned int *bits)
 {
   int result;
 
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  result = _gnutls_x509_get_pk_algorithm (cert->cert,
+  result = MHD__gnutls_x509_get_pk_algorithm (cert->cert,
                                           "tbsCertificate.subjectPublicKeyInfo",
                                           bits);
 
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -914,7 +914,7 @@ parse_general_name (ASN1_TYPE src,
   char nptr[MAX_NAME_SIZE];
   int result;
   opaque choice_type[128];
-  gnutls_x509_subject_alt_name_t type;
+  MHD_gnutls_x509_subject_alt_name_t type;
 
   seq++;                        /* 0->1, 1->2 etc */
 
@@ -924,7 +924,7 @@ parse_general_name (ASN1_TYPE src,
     snprintf (nptr, sizeof (nptr), "?%u", seq);
 
   len = sizeof (choice_type);
-  result = asn1_read_value (src, nptr, choice_type, &len);
+  result = MHD__asn1_read_value (src, nptr, choice_type, &len);
 
   if (result == ASN1_VALUE_NOT_FOUND || result == ASN1_ELEMENT_NOT_FOUND)
     {
@@ -933,14 +933,14 @@ parse_general_name (ASN1_TYPE src,
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  type = _gnutls_x509_san_find_type (choice_type);
-  if (type == (gnutls_x509_subject_alt_name_t) - 1)
+  type = MHD__gnutls_x509_san_find_type (choice_type);
+  if (type == (MHD_gnutls_x509_subject_alt_name_t) - 1)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_X509_UNKNOWN_SAN;
     }
 
@@ -950,12 +950,12 @@ parse_general_name (ASN1_TYPE src,
   if (type == GNUTLS_SAN_OTHERNAME)
     {
       if (othername_oid)
-        mhd_gtls_str_cat (nptr, sizeof (nptr), ".otherName.type-id");
+        MHD_gtls_str_cat (nptr, sizeof (nptr), ".otherName.type-id");
       else
-        mhd_gtls_str_cat (nptr, sizeof (nptr), ".otherName.value");
+        MHD_gtls_str_cat (nptr, sizeof (nptr), ".otherName.value");
 
       len = *name_size;
-      result = asn1_read_value (src, nptr, name, &len);
+      result = MHD__asn1_read_value (src, nptr, name, &len);
       *name_size = len;
 
       if (result == ASN1_MEM_ERROR)
@@ -963,8 +963,8 @@ parse_general_name (ASN1_TYPE src,
 
       if (result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          return mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          return MHD_gtls_asn2err (result);
         }
 
       if (othername_oid)
@@ -983,11 +983,11 @@ parse_general_name (ASN1_TYPE src,
             snprintf (nptr, sizeof (nptr), "?%u.otherName.type-id", seq);
 
           len = sizeof (oid);
-          result = asn1_read_value (src, nptr, oid, &len);
+          result = MHD__asn1_read_value (src, nptr, oid, &len);
           if (result != ASN1_SUCCESS)
             {
-              gnutls_assert ();
-              return mhd_gtls_asn2err (result);
+              MHD_gnutls_assert ();
+              return MHD_gtls_asn2err (result);
             }
 
           if (len > strlen (XMPP_OID) && strcmp (oid, XMPP_OID) == 0)
@@ -995,41 +995,41 @@ parse_general_name (ASN1_TYPE src,
               ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
 
               result =
-                asn1_create_element (_gnutls_get_pkix (), "PKIX1.XmppAddr",
+                MHD__asn1_create_element (MHD__gnutls_get_pkix (), "PKIX1.XmppAddr",
                                      &c2);
               if (result != ASN1_SUCCESS)
                 {
-                  gnutls_assert ();
-                  return mhd_gtls_asn2err (result);
+                  MHD_gnutls_assert ();
+                  return MHD_gtls_asn2err (result);
                 }
 
-              result = asn1_der_decoding (&c2, name, *name_size, NULL);
+              result = MHD__asn1_der_decoding (&c2, name, *name_size, NULL);
               if (result != ASN1_SUCCESS)
                 {
-                  gnutls_assert ();
-                  asn1_delete_structure (&c2);
-                  return mhd_gtls_asn2err (result);
+                  MHD_gnutls_assert ();
+                  MHD__asn1_delete_structure (&c2);
+                  return MHD_gtls_asn2err (result);
                 }
 
-              result = asn1_read_value (c2, "", name, &len);
+              result = MHD__asn1_read_value (c2, "", name, &len);
               *name_size = len;
               if (result != ASN1_SUCCESS)
                 {
-                  gnutls_assert ();
-                  asn1_delete_structure (&c2);
-                  return mhd_gtls_asn2err (result);
+                  MHD_gnutls_assert ();
+                  MHD__asn1_delete_structure (&c2);
+                  return MHD_gtls_asn2err (result);
                 }
-              asn1_delete_structure (&c2);
+              MHD__asn1_delete_structure (&c2);
             }
         }
     }
   else if (type == GNUTLS_SAN_DN)
     {
-      mhd_gtls_str_cat (nptr, sizeof (nptr), ".directoryName");
-      result = _gnutls_x509_parse_dn (src, nptr, name, name_size);
+      MHD_gtls_str_cat (nptr, sizeof (nptr), ".directoryName");
+      result = MHD__gnutls_x509_parse_dn (src, nptr, name, name_size);
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return result;
         }
     }
@@ -1039,11 +1039,11 @@ parse_general_name (ASN1_TYPE src,
     {
       size_t orig_name_size = *name_size;
 
-      mhd_gtls_str_cat (nptr, sizeof (nptr), ".");
-      mhd_gtls_str_cat (nptr, sizeof (nptr), choice_type);
+      MHD_gtls_str_cat (nptr, sizeof (nptr), ".");
+      MHD_gtls_str_cat (nptr, sizeof (nptr), choice_type);
 
       len = *name_size;
-      result = asn1_read_value (src, nptr, name, &len);
+      result = MHD__asn1_read_value (src, nptr, name, &len);
       *name_size = len;
 
       if (result == ASN1_MEM_ERROR)
@@ -1055,8 +1055,8 @@ parse_general_name (ASN1_TYPE src,
 
       if (result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          return mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          return MHD_gtls_asn2err (result);
         }
 
       if (is_type_printable (type))
@@ -1064,7 +1064,7 @@ parse_general_name (ASN1_TYPE src,
 
           if (len + 1 > orig_name_size)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               (*name_size)++;
               return GNUTLS_E_SHORT_MEMORY_BUFFER;
             }
@@ -1079,7 +1079,7 @@ parse_general_name (ASN1_TYPE src,
 }
 
 static int
-get_subject_alt_name (gnutls_x509_crt_t cert,
+get_subject_alt_name (MHD_gnutls_x509_crt_t cert,
                       unsigned int seq,
                       void *ret,
                       size_t * ret_size,
@@ -1087,13 +1087,13 @@ get_subject_alt_name (gnutls_x509_crt_t cert,
                       unsigned int *critical, int othername_oid)
 {
   int result;
-  gnutls_datum_t dnsname;
+  MHD_gnutls_datum_t dnsname;
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
-  gnutls_x509_subject_alt_name_t type;
+  MHD_gnutls_x509_subject_alt_name_t type;
 
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -1103,7 +1103,7 @@ get_subject_alt_name (gnutls_x509_crt_t cert,
     *ret_size = 0;
 
   if ((result =
-       _gnutls_x509_crt_get_extension (cert, "2.5.29.17", 0, &dnsname,
+       MHD__gnutls_x509_crt_get_extension (cert, "2.5.29.17", 0, &dnsname,
                                        critical)) < 0)
     {
       return result;
@@ -1111,33 +1111,33 @@ get_subject_alt_name (gnutls_x509_crt_t cert,
 
   if (dnsname.size == 0 || dnsname.data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE;
     }
 
   result =
-    asn1_create_element (_gnutls_get_pkix (), "PKIX1.SubjectAltName", &c2);
+    MHD__asn1_create_element (MHD__gnutls_get_pkix (), "PKIX1.SubjectAltName", &c2);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      _gnutls_free_datum (&dnsname);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__gnutls_free_datum (&dnsname);
+      return MHD_gtls_asn2err (result);
     }
 
-  result = asn1_der_decoding (&c2, dnsname.data, dnsname.size, NULL);
-  _gnutls_free_datum (&dnsname);
+  result = MHD__asn1_der_decoding (&c2, dnsname.data, dnsname.size, NULL);
+  MHD__gnutls_free_datum (&dnsname);
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&c2);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&c2);
+      return MHD_gtls_asn2err (result);
     }
 
   result = parse_general_name (c2, "", seq, ret, ret_size, ret_type,
                                othername_oid);
 
-  asn1_delete_structure (&c2);
+  MHD__asn1_delete_structure (&c2);
 
   if (result < 0)
     {
@@ -1150,8 +1150,8 @@ get_subject_alt_name (gnutls_x509_crt_t cert,
 }
 
 /**
- * gnutls_x509_crt_get_subject_alt_name - Get certificate's alternative name, if any
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_subject_alt_name - Get certificate's alternative name, if any
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @seq: specifies the sequence number of the alt name (0 for the first one, 1 for the second etc.)
  * @ret: is the place where the alternative name will be copied to
  * @ret_size: holds the size of ret.
@@ -1165,7 +1165,7 @@ get_subject_alt_name (gnutls_x509_crt_t cert,
  *
  * When the SAN type is otherName, it will extract the data in the
  * otherName's value field, and %GNUTLS_SAN_OTHERNAME is returned.
- * You may use gnutls_x509_crt_get_subject_alt_othername_oid() to get
+ * You may use MHD_gnutls_x509_crt_get_subject_alt_othername_oid() to get
  * the corresponding OID and the "virtual" SAN types (e.g.,
  * %GNUTLS_SAN_OTHERNAME_XMPP).
  *
@@ -1175,7 +1175,7 @@ get_subject_alt_name (gnutls_x509_crt_t cert,
  * recognized.
  *
  * Returns the alternative subject name type on success.  The type is
- * one of the enumerated gnutls_x509_subject_alt_name_t.  It will
+ * one of the enumerated MHD_gnutls_x509_subject_alt_name_t.  It will
  * return %GNUTLS_E_SHORT_MEMORY_BUFFER if @ret_size is not large
  * enough to hold the value.  In that case @ret_size will be updated
  * with the required size.  If the certificate does not have an
@@ -1184,7 +1184,7 @@ get_subject_alt_name (gnutls_x509_crt_t cert,
  *
  **/
 int
-gnutls_x509_crt_get_subject_alt_name (gnutls_x509_crt_t cert,
+MHD_gnutls_x509_crt_get_subject_alt_name (MHD_gnutls_x509_crt_t cert,
                                       unsigned int seq,
                                       void *ret,
                                       size_t * ret_size,
@@ -1194,25 +1194,25 @@ gnutls_x509_crt_get_subject_alt_name (gnutls_x509_crt_t cert,
 }
 
 /**
- * gnutls_x509_crt_get_subject_alt_name2 - Get certificate's alternative name, if any
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_subject_alt_name2 - Get certificate's alternative name, if any
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @seq: specifies the sequence number of the alt name (0 for the first one, 1 for the second etc.)
  * @ret: is the place where the alternative name will be copied to
  * @ret_size: holds the size of ret.
- * @ret_type: holds the type of the alternative name (one of gnutls_x509_subject_alt_name_t).
+ * @ret_type: holds the type of the alternative name (one of MHD_gnutls_x509_subject_alt_name_t).
  * @critical: will be non zero if the extension is marked as critical (may be null)
  *
  * This function will return the alternative names, contained in the
- * given certificate. It is the same as gnutls_x509_crt_get_subject_alt_name()
+ * given certificate. It is the same as MHD_gnutls_x509_crt_get_subject_alt_name()
  * except for the fact that it will return the type of the alternative
  * name in @ret_type even if the function fails for some reason (i.e.
  * the buffer provided is not enough).
  *
- * The return values are the same as with gnutls_x509_crt_get_subject_alt_name().
+ * The return values are the same as with MHD_gnutls_x509_crt_get_subject_alt_name().
  *
  **/
 int
-gnutls_x509_crt_get_subject_alt_name2 (gnutls_x509_crt_t cert,
+MHD_gnutls_x509_crt_get_subject_alt_name2 (MHD_gnutls_x509_crt_t cert,
                                        unsigned int seq,
                                        void *ret,
                                        size_t * ret_size,
@@ -1224,8 +1224,8 @@ gnutls_x509_crt_get_subject_alt_name2 (gnutls_x509_crt_t cert,
 }
 
 /**
- * gnutls_x509_crt_get_subject_alt_othername_oid - Get SAN otherName OID
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_subject_alt_othername_oid - Get SAN otherName OID
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @seq: specifies the sequence number of the alt name (0 for the first one, 1 for the second etc.)
  * @ret: is the place where the otherName OID will be copied to
  * @ret_size: holds the size of ret.
@@ -1235,11 +1235,11 @@ gnutls_x509_crt_get_subject_alt_name2 (gnutls_x509_crt_t cert,
  * the type as an enumerated element.
  *
  * This function is only useful if
- * gnutls_x509_crt_get_subject_alt_name() returned
+ * MHD_gnutls_x509_crt_get_subject_alt_name() returned
  * %GNUTLS_SAN_OTHERNAME.
  *
  * Returns the alternative subject name type on success.  The type is
- * one of the enumerated gnutls_x509_subject_alt_name_t.  For
+ * one of the enumerated MHD_gnutls_x509_subject_alt_name_t.  For
  * supported OIDs, it will return one of the virtual
  * (GNUTLS_SAN_OTHERNAME_*) types, e.g. %GNUTLS_SAN_OTHERNAME_XMPP,
  * and %GNUTLS_SAN_OTHERNAME for unknown OIDs.  It will return
@@ -1250,7 +1250,7 @@ gnutls_x509_crt_get_subject_alt_name2 (gnutls_x509_crt_t cert,
  * then %GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE is returned.
  **/
 int
-gnutls_x509_crt_get_subject_alt_othername_oid (gnutls_x509_crt_t cert,
+MHD_gnutls_x509_crt_get_subject_alt_othername_oid (MHD_gnutls_x509_crt_t cert,
                                                unsigned int seq,
                                                void *ret, size_t * ret_size)
 {
@@ -1258,8 +1258,8 @@ gnutls_x509_crt_get_subject_alt_othername_oid (gnutls_x509_crt_t cert,
 }
 
 /**
- * gnutls_x509_crt_get_basic_constraints - This function returns the certificate basic constraints
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_basic_constraints - This function returns the certificate basic constraints
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @critical: will be non zero if the extension is marked as critical
  * @ca: pointer to output integer indicating CA status, may be NULL,
  *   value is 1 if the certificate CA flag is set, 0 otherwise.
@@ -1278,21 +1278,21 @@ gnutls_x509_crt_get_subject_alt_othername_oid (gnutls_x509_crt_t cert,
  * GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE will be returned.
  **/
 int
-gnutls_x509_crt_get_basic_constraints (gnutls_x509_crt_t cert,
+MHD_gnutls_x509_crt_get_basic_constraints (MHD_gnutls_x509_crt_t cert,
                                        unsigned int *critical,
                                        int *ca, int *pathlen)
 {
   int result;
-  gnutls_datum_t basicConstraints;
+  MHD_gnutls_datum_t basicConstraints;
   int tmp_ca;
 
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  if ((result = _gnutls_x509_crt_get_extension (cert, "2.5.29.19", 0,
+  if ((result = MHD__gnutls_x509_crt_get_extension (cert, "2.5.29.19", 0,
                                                 &basicConstraints, critical))
       < 0)
     {
@@ -1301,20 +1301,20 @@ gnutls_x509_crt_get_basic_constraints (gnutls_x509_crt_t cert,
 
   if (basicConstraints.size == 0 || basicConstraints.data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE;
     }
 
-  result = _gnutls_x509_ext_extract_basicConstraints (&tmp_ca, pathlen,
+  result = MHD__gnutls_x509_ext_extract_basicConstraints (&tmp_ca, pathlen,
                                                       basicConstraints.data,
                                                       basicConstraints.size);
   if (ca)
     *ca = tmp_ca;
-  _gnutls_free_datum (&basicConstraints);
+  MHD__gnutls_free_datum (&basicConstraints);
 
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -1322,8 +1322,8 @@ gnutls_x509_crt_get_basic_constraints (gnutls_x509_crt_t cert,
 }
 
 /**
- * gnutls_x509_crt_get_ca_status - This function returns the certificate CA status
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_ca_status - This function returns the certificate CA status
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @critical: will be non zero if the extension is marked as critical
  *
  * This function will return certificates CA status, by reading the
@@ -1331,7 +1331,7 @@ gnutls_x509_crt_get_basic_constraints (gnutls_x509_crt_t cert,
  * a CA a positive value will be returned, or zero if the certificate
  * does not have CA flag set.
  *
- * Use gnutls_x509_crt_get_basic_constraints() if you want to read the
+ * Use MHD_gnutls_x509_crt_get_basic_constraints() if you want to read the
  * pathLenConstraint field too.
  *
  * A negative value may be returned in case of parsing error.
@@ -1340,16 +1340,16 @@ gnutls_x509_crt_get_basic_constraints (gnutls_x509_crt_t cert,
  *
  **/
 int
-gnutls_x509_crt_get_ca_status (gnutls_x509_crt_t cert, unsigned int *critical)
+MHD_gnutls_x509_crt_get_ca_status (MHD_gnutls_x509_crt_t cert, unsigned int *critical)
 {
   int ca, pathlen;
-  return gnutls_x509_crt_get_basic_constraints (cert, critical, &ca,
+  return MHD_gnutls_x509_crt_get_basic_constraints (cert, critical, &ca,
                                                 &pathlen);
 }
 
 /**
- * gnutls_x509_crt_get_key_usage - This function returns the certificate's key usage
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_key_usage - This function returns the certificate's key usage
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @key_usage: where the key usage bits will be stored
  * @critical: will be non zero if the extension is marked as critical
  *
@@ -1367,22 +1367,22 @@ gnutls_x509_crt_get_ca_status (gnutls_x509_crt_t cert, unsigned int *critical)
  *
  **/
 int
-gnutls_x509_crt_get_key_usage (gnutls_x509_crt_t cert,
+MHD_gnutls_x509_crt_get_key_usage (MHD_gnutls_x509_crt_t cert,
                                unsigned int *key_usage,
                                unsigned int *critical)
 {
   int result;
-  gnutls_datum_t keyUsage;
+  MHD_gnutls_datum_t keyUsage;
   uint16_t _usage;
 
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   if ((result =
-       _gnutls_x509_crt_get_extension (cert, "2.5.29.15", 0, &keyUsage,
+       MHD__gnutls_x509_crt_get_extension (cert, "2.5.29.15", 0, &keyUsage,
                                        critical)) < 0)
     {
       return result;
@@ -1390,19 +1390,19 @@ gnutls_x509_crt_get_key_usage (gnutls_x509_crt_t cert,
 
   if (keyUsage.size == 0 || keyUsage.data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE;
     }
 
-  result = _gnutls_x509_ext_extract_keyUsage (&_usage, keyUsage.data,
+  result = MHD__gnutls_x509_ext_extract_keyUsage (&_usage, keyUsage.data,
                                               keyUsage.size);
-  _gnutls_free_datum (&keyUsage);
+  MHD__gnutls_free_datum (&keyUsage);
 
   *key_usage = _usage;
 
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -1410,8 +1410,8 @@ gnutls_x509_crt_get_key_usage (gnutls_x509_crt_t cert,
 }
 
 /**
- * gnutls_x509_crt_get_proxy - This function returns the proxy certificate info
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_proxy - This function returns the proxy certificate info
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @critical: will be non zero if the extension is marked as critical
  * @pathlen: pointer to output integer indicating path length (may be
  *   NULL), non-negative values indicate a present pCPathLenConstraint
@@ -1428,22 +1428,22 @@ gnutls_x509_crt_get_key_usage (gnutls_x509_crt_t cert,
  * GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE will be returned.
  **/
 int
-gnutls_x509_crt_get_proxy (gnutls_x509_crt_t cert,
+MHD_gnutls_x509_crt_get_proxy (MHD_gnutls_x509_crt_t cert,
                            unsigned int *critical,
                            int *pathlen,
                            char **policyLanguage,
                            char **policy, size_t * sizeof_policy)
 {
   int result;
-  gnutls_datum_t proxyCertInfo;
+  MHD_gnutls_datum_t proxyCertInfo;
 
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  if ((result = _gnutls_x509_crt_get_extension (cert, "1.3.6.1.5.5.7.1.14", 0,
+  if ((result = MHD__gnutls_x509_crt_get_extension (cert, "1.3.6.1.5.5.7.1.14", 0,
                                                 &proxyCertInfo,
                                                 critical)) < 0)
     {
@@ -1452,18 +1452,18 @@ gnutls_x509_crt_get_proxy (gnutls_x509_crt_t cert,
 
   if (proxyCertInfo.size == 0 || proxyCertInfo.data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE;
     }
 
-  result = _gnutls_x509_ext_extract_proxyCertInfo (pathlen, policyLanguage,
+  result = MHD__gnutls_x509_ext_extract_proxyCertInfo (pathlen, policyLanguage,
                                                    policy, sizeof_policy,
                                                    proxyCertInfo.data,
                                                    proxyCertInfo.size);
-  _gnutls_free_datum (&proxyCertInfo);
+  MHD__gnutls_free_datum (&proxyCertInfo);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -1471,8 +1471,8 @@ gnutls_x509_crt_get_proxy (gnutls_x509_crt_t cert,
 }
 
 /**
- * gnutls_x509_crt_get_extension_by_oid - This function returns the specified extension
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_extension_by_oid - This function returns the specified extension
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @oid: holds an Object Identified in null terminated string
  * @indx: In case multiple same OIDs exist in the extensions, this specifies which to send. Use zero to get the first one.
  * @buf: a pointer to a structure to hold the name (may be null)
@@ -1489,7 +1489,7 @@ gnutls_x509_crt_get_proxy (gnutls_x509_crt_t cert,
  *
  **/
 int
-gnutls_x509_crt_get_extension_by_oid (gnutls_x509_crt_t cert,
+MHD_gnutls_x509_crt_get_extension_by_oid (MHD_gnutls_x509_crt_t cert,
                                       const char *oid,
                                       int indx,
                                       void *buf,
@@ -1497,31 +1497,31 @@ gnutls_x509_crt_get_extension_by_oid (gnutls_x509_crt_t cert,
                                       unsigned int *critical)
 {
   int result;
-  gnutls_datum_t output;
+  MHD_gnutls_datum_t output;
 
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  if ((result = _gnutls_x509_crt_get_extension (cert, oid, indx, &output,
+  if ((result = MHD__gnutls_x509_crt_get_extension (cert, oid, indx, &output,
                                                 critical)) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
   if (output.size == 0 || output.data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE;
     }
 
   if (output.size > (unsigned int) *sizeof_buf)
     {
       *sizeof_buf = output.size;
-      _gnutls_free_datum (&output);
+      MHD__gnutls_free_datum (&output);
       return GNUTLS_E_SHORT_MEMORY_BUFFER;
     }
 
@@ -1530,15 +1530,15 @@ gnutls_x509_crt_get_extension_by_oid (gnutls_x509_crt_t cert,
   if (buf)
     memcpy (buf, output.data, output.size);
 
-  _gnutls_free_datum (&output);
+  MHD__gnutls_free_datum (&output);
 
   return 0;
 
 }
 
 /**
- * gnutls_x509_crt_get_extension_oid - This function returns the specified extension OID
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_extension_oid - This function returns the specified extension OID
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @indx: Specifies which extension OID to send. Use zero to get the first one.
  * @oid: a pointer to a structure to hold the OID (may be null)
  * @sizeof_oid: initially holds the size of @oid
@@ -1552,18 +1552,18 @@ gnutls_x509_crt_get_extension_by_oid (gnutls_x509_crt_t cert,
  *
  **/
 int
-gnutls_x509_crt_get_extension_oid (gnutls_x509_crt_t cert,
+MHD_gnutls_x509_crt_get_extension_oid (MHD_gnutls_x509_crt_t cert,
                                    int indx, void *oid, size_t * sizeof_oid)
 {
   int result;
 
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  result = _gnutls_x509_crt_get_extension_oid (cert, indx, oid, sizeof_oid);
+  result = MHD__gnutls_x509_crt_get_extension_oid (cert, indx, oid, sizeof_oid);
   if (result < 0)
     {
       return result;
@@ -1574,8 +1574,8 @@ gnutls_x509_crt_get_extension_oid (gnutls_x509_crt_t cert,
 }
 
 /**
- * gnutls_x509_crt_get_extension_info - Get extension id and criticality
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_extension_info - Get extension id and criticality
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @indx: Specifies which extension OID to send. Use zero to get the first one.
  * @oid: a pointer to a structure to hold the OID
  * @sizeof_oid: initially holds the size of @oid
@@ -1584,7 +1584,7 @@ gnutls_x509_crt_get_extension_oid (gnutls_x509_crt_t cert,
  * This function will return the requested extension OID in the
  * certificate, and the critical flag for it.  The extension OID will
  * be stored as a string in the provided buffer.  Use
- * gnutls_x509_crt_get_extension_data() to extract the data.
+ * MHD_gnutls_x509_crt_get_extension_data() to extract the data.
  *
  * Return 0 on success.  A negative value may be returned in case of
  * parsing error.  If you have reached the last extension available
@@ -1592,7 +1592,7 @@ gnutls_x509_crt_get_extension_oid (gnutls_x509_crt_t cert,
  *
  **/
 int
-gnutls_x509_crt_get_extension_info (gnutls_x509_crt_t cert,
+MHD_gnutls_x509_crt_get_extension_info (MHD_gnutls_x509_crt_t cert,
                                     int indx,
                                     void *oid,
                                     size_t * sizeof_oid, int *critical)
@@ -1604,7 +1604,7 @@ gnutls_x509_crt_get_extension_info (gnutls_x509_crt_t cert,
 
   if (!cert)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -1612,25 +1612,25 @@ gnutls_x509_crt_get_extension_info (gnutls_x509_crt_t cert,
             indx + 1);
 
   len = *sizeof_oid;
-  result = asn1_read_value (cert->cert, name, oid, &len);
+  result = MHD__asn1_read_value (cert->cert, name, oid, &len);
   *sizeof_oid = len;
 
   if (result == ASN1_ELEMENT_NOT_FOUND)
     return GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE;
   else if (result < 0)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   snprintf (name, sizeof (name), "tbsCertificate.extensions.?%u.critical",
             indx + 1);
   len = sizeof (str_critical);
-  result = asn1_read_value (cert->cert, name, str_critical, &len);
+  result = MHD__asn1_read_value (cert->cert, name, str_critical, &len);
   if (result < 0)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   if (critical)
@@ -1646,8 +1646,8 @@ gnutls_x509_crt_get_extension_info (gnutls_x509_crt_t cert,
 }
 
 /**
- * gnutls_x509_crt_get_extension_data - Get the specified extension data
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_extension_data - Get the specified extension data
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @indx: Specifies which extension OID to send. Use zero to get the first one.
  * @data: a pointer to a structure to hold the data (may be null)
  * @sizeof_data: initially holds the size of @oid
@@ -1656,8 +1656,8 @@ gnutls_x509_crt_get_extension_info (gnutls_x509_crt_t cert,
  * certificate.  The extension data will be stored as a string in the
  * provided buffer.
  *
- * Use gnutls_x509_crt_get_extension_info() to extract the OID and
- * critical flag.  Use gnutls_x509_crt_get_extension_by_oid() instead,
+ * Use MHD_gnutls_x509_crt_get_extension_info() to extract the OID and
+ * critical flag.  Use MHD_gnutls_x509_crt_get_extension_by_oid() instead,
  * if you want to get data indexed by the extension OID rather than
  * sequence.
  *
@@ -1666,7 +1666,7 @@ gnutls_x509_crt_get_extension_info (gnutls_x509_crt_t cert,
  * GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE will be returned.
  **/
 int
-gnutls_x509_crt_get_extension_data (gnutls_x509_crt_t cert,
+MHD_gnutls_x509_crt_get_extension_data (MHD_gnutls_x509_crt_t cert,
                                     int indx,
                                     void *data, size_t * sizeof_data)
 {
@@ -1675,7 +1675,7 @@ gnutls_x509_crt_get_extension_data (gnutls_x509_crt_t cert,
 
   if (!cert)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -1683,82 +1683,82 @@ gnutls_x509_crt_get_extension_data (gnutls_x509_crt_t cert,
             indx + 1);
 
   len = *sizeof_data;
-  result = asn1_read_value (cert->cert, name, data, &len);
+  result = MHD__asn1_read_value (cert->cert, name, data, &len);
   *sizeof_data = len;
 
   if (result == ASN1_ELEMENT_NOT_FOUND)
     return GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE;
   else if (result < 0)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   return 0;
 }
 
 static int
-_gnutls_x509_crt_get_raw_dn2 (gnutls_x509_crt_t cert,
-                              const char *whom, gnutls_datum_t * start)
+MHD__gnutls_x509_crt_get_raw_dn2 (MHD_gnutls_x509_crt_t cert,
+                              const char *whom, MHD_gnutls_datum_t * start)
 {
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
   int result, len1;
   int start1, end1;
-  gnutls_datum_t signed_data = { NULL,
+  MHD_gnutls_datum_t signed_data = { NULL,
     0
   };
 
   /* get the issuer of 'cert'
    */
   if ((result =
-       asn1_create_element (_gnutls_get_pkix (), "PKIX1.TBSCertificate",
+       MHD__asn1_create_element (MHD__gnutls_get_pkix (), "PKIX1.TBSCertificate",
                             &c2)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  result = _gnutls_x509_get_signed_data (cert->cert, "tbsCertificate",
+  result = MHD__gnutls_x509_get_signed_data (cert->cert, "tbsCertificate",
                                          &signed_data);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  result = asn1_der_decoding (&c2, signed_data.data, signed_data.size, NULL);
+  result = MHD__asn1_der_decoding (&c2, signed_data.data, signed_data.size, NULL);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&c2);
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&c2);
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  result = asn1_der_decoding_startEnd (c2, signed_data.data, signed_data.size,
+  result = MHD__asn1_der_decoding_startEnd (c2, signed_data.data, signed_data.size,
                                        whom, &start1, &end1);
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   len1 = end1 - start1 + 1;
 
-  _gnutls_set_datum (start, &signed_data.data[start1], len1);
+  MHD__gnutls_set_datum (start, &signed_data.data[start1], len1);
 
   result = 0;
 
-cleanup:asn1_delete_structure (&c2);
-  _gnutls_free_datum (&signed_data);
+cleanup:MHD__asn1_delete_structure (&c2);
+  MHD__gnutls_free_datum (&signed_data);
   return result;
 }
 
 /**
- * gnutls_x509_crt_get_raw_issuer_dn - This function returns the issuer's DN DER encoded
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_raw_issuer_dn - This function returns the issuer's DN DER encoded
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @start: will hold the starting point of the DN
  *
  * This function will return a pointer to the DER encoded DN structure
@@ -1768,15 +1768,15 @@ cleanup:asn1_delete_structure (&c2);
  *
  **/
 int
-gnutls_x509_crt_get_raw_issuer_dn (gnutls_x509_crt_t cert,
-                                   gnutls_datum_t * start)
+MHD_gnutls_x509_crt_get_raw_issuer_dn (MHD_gnutls_x509_crt_t cert,
+                                   MHD_gnutls_datum_t * start)
 {
-  return _gnutls_x509_crt_get_raw_dn2 (cert, "issuer", start);
+  return MHD__gnutls_x509_crt_get_raw_dn2 (cert, "issuer", start);
 }
 
 /**
- * gnutls_x509_crt_get_raw_dn - This function returns the subject's DN DER encoded
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_raw_dn - This function returns the subject's DN DER encoded
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @start: will hold the starting point of the DN
  *
  * This function will return a pointer to the DER encoded DN structure and
@@ -1786,43 +1786,43 @@ gnutls_x509_crt_get_raw_issuer_dn (gnutls_x509_crt_t cert,
  *
  **/
 int
-gnutls_x509_crt_get_raw_dn (gnutls_x509_crt_t cert, gnutls_datum_t * start)
+MHD_gnutls_x509_crt_get_raw_dn (MHD_gnutls_x509_crt_t cert, MHD_gnutls_datum_t * start)
 {
-  return _gnutls_x509_crt_get_raw_dn2 (cert, "subject", start);
+  return MHD__gnutls_x509_crt_get_raw_dn2 (cert, "subject", start);
 }
 
 static int
-get_dn (gnutls_x509_crt_t cert, const char *whom, gnutls_x509_dn_t * dn)
+get_dn (MHD_gnutls_x509_crt_t cert, const char *whom, MHD_gnutls_x509_dn_t * dn)
 {
-  *dn = asn1_find_node (cert->cert, whom);
+  *dn = MHD__asn1_find_node (cert->cert, whom);
   if (!*dn)
     return GNUTLS_E_ASN1_ELEMENT_NOT_FOUND;
   return 0;
 }
 
 /**
- * gnutls_x509_crt_get_subject: get opaque subject DN pointer
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_subject: get opaque subject DN pointer
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @dn: output variable with pointer to opaque DN.
  *
  * Return the Certificate's Subject DN as an opaque data type.  You
- * may use gnutls_x509_dn_get_rdn_ava() to decode the DN.
+ * may use MHD_gnutls_x509_dn_get_rdn_ava() to decode the DN.
  *
  * Returns: Returns 0 on success, or an error code.
  **/
 int
-gnutls_x509_crt_get_subject (gnutls_x509_crt_t cert, gnutls_x509_dn_t * dn)
+MHD_gnutls_x509_crt_get_subject (MHD_gnutls_x509_crt_t cert, MHD_gnutls_x509_dn_t * dn)
 {
   return get_dn (cert, "tbsCertificate.subject.rdnSequence", dn);
 }
 
 /**
- * gnutls_x509_crt_get_issuer: get opaque issuer DN pointer
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_issuer: get opaque issuer DN pointer
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @dn: output variable with pointer to opaque DN
  *
  * Return the Certificate's Issuer DN as an opaque data type.  You may
- * use gnutls_x509_dn_get_rdn_ava() to decode the DN.
+ * use MHD_gnutls_x509_dn_get_rdn_ava() to decode the DN.
  *
  * Note that @dn points into the @cert object, and thus you may not
  * deallocate @cert and continue to access @dn.
@@ -1830,13 +1830,13 @@ gnutls_x509_crt_get_subject (gnutls_x509_crt_t cert, gnutls_x509_dn_t * dn)
  * Returns: Returns 0 on success, or an error code.
  **/
 int
-gnutls_x509_crt_get_issuer (gnutls_x509_crt_t cert, gnutls_x509_dn_t * dn)
+MHD_gnutls_x509_crt_get_issuer (MHD_gnutls_x509_crt_t cert, MHD_gnutls_x509_dn_t * dn)
 {
   return get_dn (cert, "tbsCertificate.issuer.rdnSequence", dn);
 }
 
 /**
- * gnutls_x509_dn_get_rdn_ava:
+ * MHD_gnutls_x509_dn_get_rdn_ava:
  * @dn: input variable with opaque DN pointer
  * @irdn: index of RDN
  * @iava: index of AVA.
@@ -1852,8 +1852,8 @@ gnutls_x509_crt_get_issuer (gnutls_x509_crt_t cert, gnutls_x509_dn_t * dn)
  * Returns: Returns 0 on success, or an error code.
  **/
 int
-gnutls_x509_dn_get_rdn_ava (gnutls_x509_dn_t dn,
-                            int irdn, int iava, gnutls_x509_ava_st * ava)
+MHD_gnutls_x509_dn_get_rdn_ava (MHD_gnutls_x509_dn_t dn,
+                            int irdn, int iava, MHD_gnutls_x509_ava_st * ava)
 {
   ASN1_TYPE rdn, elem;
   long len;
@@ -1865,18 +1865,18 @@ gnutls_x509_dn_get_rdn_ava (gnutls_x509_dn_t dn,
   irdn++;                       /* 0->1, 1->2 etc */
 
   snprintf (rbuf, sizeof (rbuf), "rdnSequence.?%d.?%d", irdn, iava);
-  rdn = asn1_find_node (dn, rbuf);
+  rdn = MHD__asn1_find_node (dn, rbuf);
   if (!rdn)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_ASN1_ELEMENT_NOT_FOUND;
     }
 
   snprintf (rbuf, sizeof (rbuf), "?%d.type", iava);
-  elem = asn1_find_node (rdn, rbuf);
+  elem = MHD__asn1_find_node (rdn, rbuf);
   if (!elem)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_ASN1_ELEMENT_NOT_FOUND;
     }
 
@@ -1884,10 +1884,10 @@ gnutls_x509_dn_get_rdn_ava (gnutls_x509_dn_t dn,
   ava->oid.size = elem->value_len;
 
   snprintf (rbuf, sizeof (rbuf), "?%d.value", iava);
-  elem = asn1_find_node (rdn, rbuf);
+  elem = MHD__asn1_find_node (rdn, rbuf);
   if (!elem)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_ASN1_ELEMENT_NOT_FOUND;
     }
 
@@ -1897,34 +1897,34 @@ gnutls_x509_dn_get_rdn_ava (gnutls_x509_dn_t dn,
 
   ptr = elem->value;
   remlen = elem->value_len;
-  len = asn1_get_length_der (ptr, remlen, &lenlen);
+  len = MHD__asn1_get_length_der (ptr, remlen, &lenlen);
   if (len < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_ASN1_DER_ERROR;
     }
 
   ptr += lenlen;
   remlen -= lenlen;
-  ret = asn1_get_tag_der (ptr, remlen, &cls, &lenlen, &ava->value_tag);
+  ret = MHD__asn1_get_tag_der (ptr, remlen, &cls, &lenlen, &ava->value_tag);
   if (ret)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (ret);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (ret);
     }
 
   ptr += lenlen;
   remlen -= lenlen;
 
-  ava->value.size = asn1_get_length_der (ptr, remlen, &lenlen);
+  ava->value.size = MHD__asn1_get_length_der (ptr, remlen, &lenlen);
   ava->value.data = ptr + lenlen;
 
   return 0;
 }
 
 /**
- * gnutls_x509_crt_get_fingerprint - This function returns the Certificate's fingerprint
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_fingerprint - This function returns the Certificate's fingerprint
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @algo: is a digest algorithm
  * @buf: a pointer to a structure to hold the fingerprint (may be null)
  * @sizeof_buf: initially holds the size of @buf
@@ -1939,14 +1939,14 @@ gnutls_x509_dn_get_rdn_ava (gnutls_x509_dn_t dn,
  * with the required size.  On success 0 is returned.
  **/
 int
-gnutls_x509_crt_get_fingerprint (gnutls_x509_crt_t cert,
+MHD_gnutls_x509_crt_get_fingerprint (MHD_gnutls_x509_crt_t cert,
                                  enum MHD_GNUTLS_HashAlgorithm algo,
                                  void *buf, size_t * sizeof_buf)
 {
   opaque *cert_buf;
   int cert_buf_size;
   int result;
-  gnutls_datum_t tmp;
+  MHD_gnutls_datum_t tmp;
 
   if (sizeof_buf == 0 || cert == NULL)
     {
@@ -1954,35 +1954,35 @@ gnutls_x509_crt_get_fingerprint (gnutls_x509_crt_t cert,
     }
 
   cert_buf_size = 0;
-  asn1_der_coding (cert->cert, "", NULL, &cert_buf_size, NULL);
+  MHD__asn1_der_coding (cert->cert, "", NULL, &cert_buf_size, NULL);
 
-  cert_buf = gnutls_alloca (cert_buf_size);
+  cert_buf = MHD_gnutls_alloca (cert_buf_size);
   if (cert_buf == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
-  result = asn1_der_coding (cert->cert, "", cert_buf, &cert_buf_size, NULL);
+  result = MHD__asn1_der_coding (cert->cert, "", cert_buf, &cert_buf_size, NULL);
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      gnutls_afree (cert_buf);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD_gnutls_afree (cert_buf);
+      return MHD_gtls_asn2err (result);
     }
 
   tmp.data = cert_buf;
   tmp.size = cert_buf_size;
 
-  result = MHD_gnutls_fingerprint (algo, &tmp, buf, sizeof_buf);
-  gnutls_afree (cert_buf);
+  result = MHD__gnutls_fingerprint (algo, &tmp, buf, sizeof_buf);
+  MHD_gnutls_afree (cert_buf);
 
   return result;
 }
 
 /**
- * gnutls_x509_crt_export - This function will export the certificate
+ * MHD_gnutls_x509_crt_export - This function will export the certificate
  * @cert: Holds the certificate
  * @format: the format of output params. One of PEM or DER.
  * @output_data: will contain a certificate PEM or DER encoded
@@ -2002,82 +2002,82 @@ gnutls_x509_crt_get_fingerprint (gnutls_x509_crt_t cert,
  *   returned, and 0 on success.
  **/
 int
-gnutls_x509_crt_export (gnutls_x509_crt_t cert,
-                        gnutls_x509_crt_fmt_t format,
+MHD_gnutls_x509_crt_export (MHD_gnutls_x509_crt_t cert,
+                        MHD_gnutls_x509_crt_fmt_t format,
                         void *output_data, size_t * output_data_size)
 {
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  return _gnutls_x509_export_int (cert->cert, format, "CERTIFICATE",
+  return MHD__gnutls_x509_export_int (cert->cert, format, "CERTIFICATE",
                                   output_data, output_data_size);
 }
 
 static int
-rsadsa_get_key_id (gnutls_x509_crt_t crt,
+rsadsa_get_key_id (MHD_gnutls_x509_crt_t crt,
                    int pk,
                    unsigned char *output_data, size_t * output_data_size)
 {
   mpi_t params[MAX_PUBLIC_PARAMS_SIZE];
   int params_size = MAX_PUBLIC_PARAMS_SIZE;
   int i, result = 0;
-  gnutls_datum_t der = { NULL,
+  MHD_gnutls_datum_t der = { NULL,
     0
   };
   GNUTLS_HASH_HANDLE hd;
 
-  result = _gnutls_x509_crt_get_mpis (crt, params, &params_size);
+  result = MHD__gnutls_x509_crt_get_mpis (crt, params, &params_size);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
   if (pk == MHD_GNUTLS_PK_RSA)
     {
-      result = _gnutls_x509_write_rsa_params (params, params_size, &der);
+      result = MHD__gnutls_x509_write_rsa_params (params, params_size, &der);
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           goto cleanup;
         }
     }
   else
     return GNUTLS_E_INTERNAL_ERROR;
 
-  hd = mhd_gtls_hash_init (MHD_GNUTLS_MAC_SHA1);
+  hd = MHD_gtls_hash_init (MHD_GNUTLS_MAC_SHA1);
   if (hd == GNUTLS_HASH_FAILED)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_INTERNAL_ERROR;
       goto cleanup;
     }
 
-  mhd_gnutls_hash (hd, der.data, der.size);
+  MHD_gnutls_hash (hd, der.data, der.size);
 
-  mhd_gnutls_hash_deinit (hd, output_data);
+  MHD_gnutls_hash_deinit (hd, output_data);
   *output_data_size = 20;
 
   result = 0;
 
 cleanup:
 
-  _gnutls_free_datum (&der);
+  MHD__gnutls_free_datum (&der);
 
   /* release all allocated MPIs
    */
   for (i = 0; i < params_size; i++)
     {
-      mhd_gtls_mpi_release (&params[i]);
+      MHD_gtls_mpi_release (&params[i]);
     }
   return result;
 }
 
 /**
- * gnutls_x509_crt_get_key_id - Return unique ID of public key's parameters
+ * MHD_gnutls_x509_crt_get_key_id - Return unique ID of public key's parameters
  * @crt: Holds the certificate
  * @flags: should be 0 for now
  * @output_data: will contain the key ID
@@ -2097,31 +2097,31 @@ cleanup:
  *   returned, and 0 on success.
  **/
 int
-gnutls_x509_crt_get_key_id (gnutls_x509_crt_t crt,
+MHD_gnutls_x509_crt_get_key_id (MHD_gnutls_x509_crt_t crt,
                             unsigned int flags,
                             unsigned char *output_data,
                             size_t * output_data_size)
 {
   int pk, result = 0;
-  gnutls_datum_t pubkey;
+  MHD_gnutls_datum_t pubkey;
 
   if (crt == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   if (*output_data_size < 20)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       *output_data_size = 20;
       return GNUTLS_E_SHORT_MEMORY_BUFFER;
     }
 
-  pk = gnutls_x509_crt_get_pk_algorithm (crt, NULL);
+  pk = MHD_gnutls_x509_crt_get_pk_algorithm (crt, NULL);
   if (pk < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return pk;
     }
 
@@ -2136,34 +2136,34 @@ gnutls_x509_crt_get_key_id (gnutls_x509_crt_t crt,
     }
 
   pubkey.size = 0;
-  result = asn1_der_coding (crt->cert, "tbsCertificate.subjectPublicKeyInfo",
+  result = MHD__asn1_der_coding (crt->cert, "tbsCertificate.subjectPublicKeyInfo",
                             NULL, &pubkey.size, NULL);
   if (result != ASN1_MEM_ERROR)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  pubkey.data = gnutls_alloca (pubkey.size);
+  pubkey.data = MHD_gnutls_alloca (pubkey.size);
   if (pubkey.data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
     }
 
-  result = asn1_der_coding (crt->cert, "tbsCertificate.subjectPublicKeyInfo",
+  result = MHD__asn1_der_coding (crt->cert, "tbsCertificate.subjectPublicKeyInfo",
                             pubkey.data, &pubkey.size, NULL);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      gnutls_afree (pubkey.data);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD_gnutls_afree (pubkey.data);
+      return MHD_gtls_asn2err (result);
     }
 
-  result = MHD_gnutls_fingerprint (MHD_GNUTLS_MAC_SHA1, &pubkey, output_data,
+  result = MHD__gnutls_fingerprint (MHD_GNUTLS_MAC_SHA1, &pubkey, output_data,
                                    output_data_size);
 
-  gnutls_afree (pubkey.data);
+  MHD_gnutls_afree (pubkey.data);
 
   return result;
 }
@@ -2171,9 +2171,9 @@ gnutls_x509_crt_get_key_id (gnutls_x509_crt_t crt,
 #ifdef ENABLE_PKI
 
 /**
- * gnutls_x509_crt_check_revocation - This function checks if the given certificate is revoked
- * @cert: should contain a gnutls_x509_crt_t structure
- * @crl_list: should contain a list of gnutls_x509_crl_t structures
+ * MHD_gnutls_x509_crt_check_revocation - This function checks if the given certificate is revoked
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
+ * @crl_list: should contain a list of MHD_gnutls_x509_crl_t structures
  * @crl_list_length: the length of the crl_list
  *
  * This function will return check if the given certificate is
@@ -2183,19 +2183,19 @@ gnutls_x509_crt_get_key_id (gnutls_x509_crt_t crt,
  * negative value is returned on error.
  **/
 int
-gnutls_x509_crt_check_revocation (gnutls_x509_crt_t cert,
-                                  const gnutls_x509_crl_t * crl_list,
+MHD_gnutls_x509_crt_check_revocation (MHD_gnutls_x509_crt_t cert,
+                                  const MHD_gnutls_x509_crl_t * crl_list,
                                   int crl_list_length)
 {
   opaque serial[64];
   opaque cert_serial[64];
   size_t serial_size, cert_serial_size;
   int ncerts, ret, i, j;
-  gnutls_datum_t dn1, dn2;
+  MHD_gnutls_datum_t dn1, dn2;
 
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -2204,23 +2204,23 @@ gnutls_x509_crt_check_revocation (gnutls_x509_crt_t cert,
 
       /* Step 1. check if issuer's DN match
        */
-      ret = _gnutls_x509_crl_get_raw_issuer_dn (crl_list[j], &dn1);
+      ret = MHD__gnutls_x509_crl_get_raw_issuer_dn (crl_list[j], &dn1);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
-      ret = gnutls_x509_crt_get_raw_issuer_dn (cert, &dn2);
+      ret = MHD_gnutls_x509_crt_get_raw_issuer_dn (cert, &dn2);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
-      ret = _gnutls_x509_compare_raw_dn (&dn1, &dn2);
-      _gnutls_free_datum (&dn1);
-      _gnutls_free_datum (&dn2);
+      ret = MHD__gnutls_x509_compare_raw_dn (&dn1, &dn2);
+      MHD__gnutls_free_datum (&dn1);
+      MHD__gnutls_free_datum (&dn2);
       if (ret == 0)
         {
           /* issuers do not match so don't even
@@ -2232,10 +2232,10 @@ gnutls_x509_crt_check_revocation (gnutls_x509_crt_t cert,
       /* Step 2. Read the certificate's serial number
        */
       cert_serial_size = sizeof (cert_serial);
-      ret = gnutls_x509_crt_get_serial (cert, cert_serial, &cert_serial_size);
+      ret = MHD_gnutls_x509_crt_get_serial (cert, cert_serial, &cert_serial_size);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
@@ -2243,22 +2243,22 @@ gnutls_x509_crt_check_revocation (gnutls_x509_crt_t cert,
        *   certificate serial we have.
        */
 
-      ncerts = gnutls_x509_crl_get_crt_count (crl_list[j]);
+      ncerts = MHD_gnutls_x509_crl_get_crt_count (crl_list[j]);
       if (ncerts < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ncerts;
         }
 
       for (i = 0; i < ncerts; i++)
         {
           serial_size = sizeof (serial);
-          ret = gnutls_x509_crl_get_crt_serial (crl_list[j], i, serial,
+          ret = MHD_gnutls_x509_crl_get_crt_serial (crl_list[j], i, serial,
                                                 &serial_size, NULL);
 
           if (ret < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return ret;
             }
 
@@ -2277,7 +2277,7 @@ gnutls_x509_crt_check_revocation (gnutls_x509_crt_t cert,
 }
 
 /**
- * gnutls_x509_crt_verify_data - This function will verify the given signed data.
+ * MHD_gnutls_x509_crt_verify_data - This function will verify the given signed data.
  * @crt: Holds the certificate
  * @flags: should be 0 for now
  * @data: holds the data to be signed
@@ -2290,23 +2290,23 @@ gnutls_x509_crt_check_revocation (gnutls_x509_crt_t cert,
  * success.
  **/
 int
-gnutls_x509_crt_verify_data (gnutls_x509_crt_t crt,
+MHD_gnutls_x509_crt_verify_data (MHD_gnutls_x509_crt_t crt,
                              unsigned int flags,
-                             const gnutls_datum_t * data,
-                             const gnutls_datum_t * signature)
+                             const MHD_gnutls_datum_t * data,
+                             const MHD_gnutls_datum_t * signature)
 {
   int result;
 
   if (crt == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  result = _gnutls_x509_verify_signature (data, signature, crt);
+  result = MHD__gnutls_x509_verify_signature (data, signature, crt);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return 0;
     }
 
@@ -2314,8 +2314,8 @@ gnutls_x509_crt_verify_data (gnutls_x509_crt_t crt,
 }
 
 /**
- * gnutls_x509_crt_get_crl_dist_points - This function returns the CRL distribution points
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_crl_dist_points - This function returns the CRL distribution points
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @seq: specifies the sequence number of the distribution point (0 for the first one, 1 for the second etc.)
  * @ret: is the place where the distribution point will be copied to
  * @ret_size: holds the size of ret.
@@ -2342,13 +2342,13 @@ gnutls_x509_crt_verify_data (gnutls_x509_crt_t crt,
  * Returns %GNUTLS_E_SHORT_MEMORY_BUFFER and updates &@ret_size if
  * &@ret_size is not enough to hold the distribution point, or the
  * type of the distribution point if everything was ok. The type is
- * one of the enumerated %gnutls_x509_subject_alt_name_t.  If the
+ * one of the enumerated %MHD_gnutls_x509_subject_alt_name_t.  If the
  * certificate does not have an Alternative name with the specified
  * sequence number then %GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE is
  * returned.
  **/
 int
-gnutls_x509_crt_get_crl_dist_points (gnutls_x509_crt_t cert,
+MHD_gnutls_x509_crt_get_crl_dist_points (MHD_gnutls_x509_crt_t cert,
                                      unsigned int seq,
                                      void *ret,
                                      size_t * ret_size,
@@ -2356,18 +2356,18 @@ gnutls_x509_crt_get_crl_dist_points (gnutls_x509_crt_t cert,
                                      unsigned int *critical)
 {
   int result;
-  gnutls_datum_t dist_points = { NULL,
+  MHD_gnutls_datum_t dist_points = { NULL,
     0
   };
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
   char name[MAX_NAME_SIZE];
   int len;
-  gnutls_x509_subject_alt_name_t type;
+  MHD_gnutls_x509_subject_alt_name_t type;
   uint8_t reasons[2];
 
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -2379,7 +2379,7 @@ gnutls_x509_crt_get_crl_dist_points (gnutls_x509_crt_t cert,
   if (reason_flags)
     *reason_flags = 0;
 
-  result = _gnutls_x509_crt_get_extension (cert, "2.5.29.31", 0, &dist_points,
+  result = MHD__gnutls_x509_crt_get_extension (cert, "2.5.29.31", 0, &dist_points,
                                            critical);
   if (result < 0)
     {
@@ -2388,39 +2388,39 @@ gnutls_x509_crt_get_crl_dist_points (gnutls_x509_crt_t cert,
 
   if (dist_points.size == 0 || dist_points.data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE;
     }
 
   result =
-    asn1_create_element (_gnutls_get_pkix (), "PKIX1.CRLDistributionPoints",
+    MHD__asn1_create_element (MHD__gnutls_get_pkix (), "PKIX1.CRLDistributionPoints",
                          &c2);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      _gnutls_free_datum (&dist_points);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__gnutls_free_datum (&dist_points);
+      return MHD_gtls_asn2err (result);
     }
 
-  result = asn1_der_decoding (&c2, dist_points.data, dist_points.size, NULL);
-  _gnutls_free_datum (&dist_points);
+  result = MHD__asn1_der_decoding (&c2, dist_points.data, dist_points.size, NULL);
+  MHD__gnutls_free_datum (&dist_points);
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&c2);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&c2);
+      return MHD_gtls_asn2err (result);
     }
 
   /* Return the different names from the first CRLDistr. point.
    * The whole thing is a mess.
    */
-  mhd_gtls_str_cpy (name, sizeof (name), "?1.distributionPoint.fullName");
+  MHD_gtls_str_cpy (name, sizeof (name), "?1.distributionPoint.fullName");
 
   result = parse_general_name (c2, name, seq, ret, ret_size, NULL, 0);
   if (result < 0)
     {
-      asn1_delete_structure (&c2);
+      MHD__asn1_delete_structure (&c2);
       return result;
     }
 
@@ -2430,18 +2430,18 @@ gnutls_x509_crt_get_crl_dist_points (gnutls_x509_crt_t cert,
    */
   if (reason_flags)
     {
-      mhd_gtls_str_cpy (name, sizeof (name), "?1.reasons");
+      MHD_gtls_str_cpy (name, sizeof (name), "?1.reasons");
 
       reasons[0] = reasons[1] = 0;
 
       len = sizeof (reasons);
-      result = asn1_read_value (c2, name, reasons, &len);
+      result = MHD__asn1_read_value (c2, name, reasons, &len);
 
       if (result != ASN1_VALUE_NOT_FOUND && result != ASN1_SUCCESS)
         {
-          gnutls_assert ();
-          asn1_delete_structure (&c2);
-          return mhd_gtls_asn2err (result);
+          MHD_gnutls_assert ();
+          MHD__asn1_delete_structure (&c2);
+          return MHD_gtls_asn2err (result);
         }
 
       *reason_flags = reasons[0] | (reasons[1] << 8);
@@ -2451,8 +2451,8 @@ gnutls_x509_crt_get_crl_dist_points (gnutls_x509_crt_t cert,
 }
 
 /**
- * gnutls_x509_crt_get_key_purpose_oid - This function returns the Certificate's key purpose OIDs
- * @cert: should contain a gnutls_x509_crt_t structure
+ * MHD_gnutls_x509_crt_get_key_purpose_oid - This function returns the Certificate's key purpose OIDs
+ * @cert: should contain a MHD_gnutls_x509_crt_t structure
  * @indx: This specifies which OID to return. Use zero to get the first one.
  * @oid: a pointer to a buffer to hold the OID (may be null)
  * @sizeof_oid: initially holds the size of @oid
@@ -2469,7 +2469,7 @@ gnutls_x509_crt_get_crl_dist_points (gnutls_x509_crt_t cert,
  * with the required size.  On success 0 is returned.
  **/
 int
-gnutls_x509_crt_get_key_purpose_oid (gnutls_x509_crt_t cert,
+MHD_gnutls_x509_crt_get_key_purpose_oid (MHD_gnutls_x509_crt_t cert,
                                      int indx,
                                      void *oid,
                                      size_t * sizeof_oid,
@@ -2477,12 +2477,12 @@ gnutls_x509_crt_get_key_purpose_oid (gnutls_x509_crt_t cert,
 {
   char tmpstr[MAX_NAME_SIZE];
   int result, len;
-  gnutls_datum_t id;
+  MHD_gnutls_datum_t id;
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
 
   if (cert == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -2491,7 +2491,7 @@ gnutls_x509_crt_get_key_purpose_oid (gnutls_x509_crt_t cert,
   else
     *sizeof_oid = 0;
 
-  if ((result = _gnutls_x509_crt_get_extension (cert, "2.5.29.37", 0, &id,
+  if ((result = MHD__gnutls_x509_crt_get_extension (cert, "2.5.29.37", 0, &id,
                                                 critical)) < 0)
     {
       return result;
@@ -2499,27 +2499,27 @@ gnutls_x509_crt_get_key_purpose_oid (gnutls_x509_crt_t cert,
 
   if (id.size == 0 || id.data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE;
     }
 
   result =
-    asn1_create_element (_gnutls_get_pkix (), "PKIX1.ExtKeyUsageSyntax", &c2);
+    MHD__asn1_create_element (MHD__gnutls_get_pkix (), "PKIX1.ExtKeyUsageSyntax", &c2);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      _gnutls_free_datum (&id);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__gnutls_free_datum (&id);
+      return MHD_gtls_asn2err (result);
     }
 
-  result = asn1_der_decoding (&c2, id.data, id.size, NULL);
-  _gnutls_free_datum (&id);
+  result = MHD__asn1_der_decoding (&c2, id.data, id.size, NULL);
+  MHD__gnutls_free_datum (&id);
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&c2);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&c2);
+      return MHD_gtls_asn2err (result);
     }
 
   indx++;
@@ -2528,10 +2528,10 @@ gnutls_x509_crt_get_key_purpose_oid (gnutls_x509_crt_t cert,
   snprintf (tmpstr, sizeof (tmpstr), "?%u", indx);
 
   len = *sizeof_oid;
-  result = asn1_read_value (c2, tmpstr, oid, &len);
+  result = MHD__asn1_read_value (c2, tmpstr, oid, &len);
 
   *sizeof_oid = len;
-  asn1_delete_structure (&c2);
+  MHD__asn1_delete_structure (&c2);
 
   if (result == ASN1_VALUE_NOT_FOUND || result == ASN1_ELEMENT_NOT_FOUND)
     {
@@ -2540,8 +2540,8 @@ gnutls_x509_crt_get_key_purpose_oid (gnutls_x509_crt_t cert,
 
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
   return 0;
@@ -2549,20 +2549,20 @@ gnutls_x509_crt_get_key_purpose_oid (gnutls_x509_crt_t cert,
 }
 
 /**
- * gnutls_x509_crt_get_pk_rsa_raw - This function will export the RSA public key
+ * MHD_gnutls_x509_crt_get_pk_rsa_raw - This function will export the RSA public key
  * @crt: Holds the certificate
  * @m: will hold the modulus
  * @e: will hold the public exponent
  *
  * This function will export the RSA public key's parameters found in
  * the given structure.  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.
  *
  * Returns: %GNUTLS_E_SUCCESS on success, otherwise an error.
  **/
 int
-gnutls_x509_crt_get_pk_rsa_raw (gnutls_x509_crt_t crt,
-                                gnutls_datum_t * m, gnutls_datum_t * e)
+MHD_gnutls_x509_crt_get_pk_rsa_raw (MHD_gnutls_x509_crt_t crt,
+                                MHD_gnutls_datum_t * m, MHD_gnutls_datum_t * e)
 {
   int ret;
   mpi_t params[MAX_PUBLIC_PARAMS_SIZE];
@@ -2571,36 +2571,36 @@ gnutls_x509_crt_get_pk_rsa_raw (gnutls_x509_crt_t crt,
 
   if (crt == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  ret = gnutls_x509_crt_get_pk_algorithm (crt, NULL);
+  ret = MHD_gnutls_x509_crt_get_pk_algorithm (crt, NULL);
   if (ret != MHD_GNUTLS_PK_RSA)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  ret = _gnutls_x509_crt_get_mpis (crt, params, &params_size);
+  ret = MHD__gnutls_x509_crt_get_mpis (crt, params, &params_size);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  ret = mhd_gtls_mpi_dprint (m, params[0]);
+  ret = MHD_gtls_mpi_dprint (m, params[0]);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  ret = mhd_gtls_mpi_dprint (e, params[1]);
+  ret = MHD_gtls_mpi_dprint (e, params[1]);
   if (ret < 0)
     {
-      gnutls_assert ();
-      _gnutls_free_datum (m);
+      MHD_gnutls_assert ();
+      MHD__gnutls_free_datum (m);
       goto cleanup;
     }
 
@@ -2608,13 +2608,13 @@ gnutls_x509_crt_get_pk_rsa_raw (gnutls_x509_crt_t crt,
 
 cleanup:for (i = 0; i < params_size; i++)
     {
-      mhd_gtls_mpi_release (&params[i]);
+      MHD_gtls_mpi_release (&params[i]);
     }
   return ret;
 }
 
 /**
- * gnutls_x509_crt_get_pk_dsa_raw - This function will export the DSA public key
+ * MHD_gnutls_x509_crt_get_pk_dsa_raw - This function will export the DSA public key
  * @crt: Holds the certificate
  * @p: will hold the p
  * @q: will hold the q
@@ -2623,15 +2623,15 @@ cleanup:for (i = 0; i < params_size; i++)
  *
  * This function will export the DSA public key's parameters found in
  * the given certificate.  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.
  *
  * Returns: %GNUTLS_E_SUCCESS on success, otherwise an error.
  **/
 int
-gnutls_x509_crt_get_pk_dsa_raw (gnutls_x509_crt_t crt,
-                                gnutls_datum_t * p,
-                                gnutls_datum_t * q,
-                                gnutls_datum_t * g, gnutls_datum_t * y)
+MHD_gnutls_x509_crt_get_pk_dsa_raw (MHD_gnutls_x509_crt_t crt,
+                                MHD_gnutls_datum_t * p,
+                                MHD_gnutls_datum_t * q,
+                                MHD_gnutls_datum_t * g, MHD_gnutls_datum_t * y)
 {
   int ret;
   mpi_t params[MAX_PUBLIC_PARAMS_SIZE];
@@ -2640,54 +2640,54 @@ gnutls_x509_crt_get_pk_dsa_raw (gnutls_x509_crt_t crt,
 
   if (crt == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  ret = gnutls_x509_crt_get_pk_algorithm (crt, NULL);
+  ret = MHD_gnutls_x509_crt_get_pk_algorithm (crt, NULL);
 
-  ret = _gnutls_x509_crt_get_mpis (crt, params, &params_size);
+  ret = MHD__gnutls_x509_crt_get_mpis (crt, params, &params_size);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
   /* P */
-  ret = mhd_gtls_mpi_dprint (p, params[0]);
+  ret = MHD_gtls_mpi_dprint (p, params[0]);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
   /* Q */
-  ret = mhd_gtls_mpi_dprint (q, params[1]);
+  ret = MHD_gtls_mpi_dprint (q, params[1]);
   if (ret < 0)
     {
-      gnutls_assert ();
-      _gnutls_free_datum (p);
+      MHD_gnutls_assert ();
+      MHD__gnutls_free_datum (p);
       goto cleanup;
     }
 
   /* G */
-  ret = mhd_gtls_mpi_dprint (g, params[2]);
+  ret = MHD_gtls_mpi_dprint (g, params[2]);
   if (ret < 0)
     {
-      gnutls_assert ();
-      _gnutls_free_datum (p);
-      _gnutls_free_datum (q);
+      MHD_gnutls_assert ();
+      MHD__gnutls_free_datum (p);
+      MHD__gnutls_free_datum (q);
       goto cleanup;
     }
 
   /* Y */
-  ret = mhd_gtls_mpi_dprint (y, params[3]);
+  ret = MHD_gtls_mpi_dprint (y, params[3]);
   if (ret < 0)
     {
-      gnutls_assert ();
-      _gnutls_free_datum (p);
-      _gnutls_free_datum (g);
-      _gnutls_free_datum (q);
+      MHD_gnutls_assert ();
+      MHD__gnutls_free_datum (p);
+      MHD__gnutls_free_datum (g);
+      MHD__gnutls_free_datum (q);
       goto cleanup;
     }
 
@@ -2695,7 +2695,7 @@ gnutls_x509_crt_get_pk_dsa_raw (gnutls_x509_crt_t crt,
 
 cleanup:for (i = 0; i < params_size; i++)
     {
-      mhd_gtls_mpi_release (&params[i]);
+      MHD_gtls_mpi_release (&params[i]);
     }
   return ret;
 
@@ -2704,15 +2704,15 @@ cleanup:for (i = 0; i < params_size; i++)
 #endif
 
 /**
- * gnutls_x509_crt_list_import - This function will import a PEM encoded certificate list
+ * MHD_gnutls_x509_crt_list_import - This function will import a PEM encoded certificate list
  * @certs: The structures to store the parsed certificate. Must not be initialized.
  * @cert_max: Initially must hold the maximum number of certs. It will be updated with the number of certs available.
  * @data: The PEM encoded certificate.
  * @format: One of DER or PEM.
- * @flags: must be zero or an OR'd sequence of gnutls_certificate_import_flags.
+ * @flags: must be zero or an OR'd sequence of MHD_gnutls_certificate_import_flags.
  *
  * This function will convert the given PEM encoded certificate list
- * to the native gnutls_x509_crt_t format. The output will be stored
+ * to the native MHD_gnutls_x509_crt_t format. The output will be stored
  * in @certs.  They will be automatically initialized.
  *
  * If the Certificate is PEM encoded it should have a header of "X509
@@ -2721,14 +2721,14 @@ cleanup:for (i = 0; i < params_size; i++)
  * Returns: the number of certificates read or a negative error value.
  **/
 int
-gnutls_x509_crt_list_import (gnutls_x509_crt_t * certs,
+MHD_gnutls_x509_crt_list_import (MHD_gnutls_x509_crt_t * certs,
                              unsigned int *cert_max,
-                             const gnutls_datum_t * data,
-                             gnutls_x509_crt_fmt_t format, unsigned int flags)
+                             const MHD_gnutls_datum_t * data,
+                             MHD_gnutls_x509_crt_fmt_t format, unsigned int flags)
 {
   int size;
   const char *ptr;
-  gnutls_datum_t tmp;
+  MHD_gnutls_datum_t tmp;
   int ret, nocopy = 0;
   unsigned int count = 0, j;
 
@@ -2742,17 +2742,17 @@ gnutls_x509_crt_list_import (gnutls_x509_crt_t * certs,
 
       count = 1;                /* import only the first one */
 
-      ret = gnutls_x509_crt_init (&certs[0]);
+      ret = MHD_gnutls_x509_crt_init (&certs[0]);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           goto error;
         }
 
-      ret = gnutls_x509_crt_import (certs[0], data, format);
+      ret = MHD_gnutls_x509_crt_import (certs[0], data, format);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           goto error;
         }
 
@@ -2762,15 +2762,15 @@ gnutls_x509_crt_list_import (gnutls_x509_crt_t * certs,
 
   /* move to the certificate
    */
-  ptr = memmem (data->data, data->size,
+  ptr = MHD_memmem (data->data, data->size,
                 PEM_CERT_SEP, sizeof (PEM_CERT_SEP) - 1);
   if (ptr == NULL)
-    ptr = memmem (data->data, data->size,
+    ptr = MHD_memmem (data->data, data->size,
                   PEM_CERT_SEP2, sizeof (PEM_CERT_SEP2) - 1);
 
   if (ptr == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_BASE64_DECODING_ERROR;
     }
   size = data->size - (ptr - (char *) data->data);
@@ -2789,10 +2789,10 @@ gnutls_x509_crt_list_import (gnutls_x509_crt_t * certs,
 
       if (!nocopy)
         {
-          ret = gnutls_x509_crt_init (&certs[count]);
+          ret = MHD_gnutls_x509_crt_init (&certs[count]);
           if (ret < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               goto error;
             }
 
@@ -2800,10 +2800,10 @@ gnutls_x509_crt_list_import (gnutls_x509_crt_t * certs,
           tmp.size = size;
 
           ret =
-            gnutls_x509_crt_import (certs[count], &tmp, GNUTLS_X509_FMT_PEM);
+            MHD_gnutls_x509_crt_import (certs[count], &tmp, GNUTLS_X509_FMT_PEM);
           if (ret < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               goto error;
             }
         }
@@ -2819,10 +2819,10 @@ gnutls_x509_crt_list_import (gnutls_x509_crt_t * certs,
         {
           char *ptr2;
 
-          ptr2 = memmem (ptr, size, PEM_CERT_SEP, sizeof (PEM_CERT_SEP) - 1);
+          ptr2 = MHD_memmem (ptr, size, PEM_CERT_SEP, sizeof (PEM_CERT_SEP) - 1);
           if (ptr2 == NULL)
             ptr2 =
-              memmem (ptr, size, PEM_CERT_SEP2, sizeof (PEM_CERT_SEP2) - 1);
+              MHD_memmem (ptr, size, PEM_CERT_SEP2, sizeof (PEM_CERT_SEP2) - 1);
 
           ptr = ptr2;
         }
@@ -2841,6 +2841,6 @@ gnutls_x509_crt_list_import (gnutls_x509_crt_t * certs,
     return GNUTLS_E_SHORT_MEMORY_BUFFER;
 
 error:for (j = 0; j < count; j++)
-    gnutls_x509_crt_deinit (certs[j]);
+    MHD_gnutls_x509_crt_deinit (certs[j]);
   return ret;
 }
diff --git a/src/daemon/https/x509/x509.h b/src/daemon/https/x509/x509.h
index d718767a..90e2aa8c 100644
--- a/src/daemon/https/x509/x509.h
+++ b/src/daemon/https/x509/x509.h
@@ -78,67 +78,67 @@ extern "C"
 
 /* Certificate handling functions.
  */
-  typedef enum gnutls_certificate_import_flags
+  typedef enum MHD_gnutls_certificate_import_flags
   {
     /* Fail if the certificates in the buffer are more than the space
      * allocated for certificates. The error code will be
      * GNUTLS_E_SHORT_MEMORY_BUFFER.
      */
     GNUTLS_X509_CRT_LIST_IMPORT_FAIL_IF_EXCEED = 1
-  } gnutls_certificate_import_flags;
-
-  int gnutls_x509_crt_init (gnutls_x509_crt_t * cert);
-  void gnutls_x509_crt_deinit (gnutls_x509_crt_t cert);
-  int gnutls_x509_crt_import (gnutls_x509_crt_t cert,
-                              const gnutls_datum_t * data,
-                              gnutls_x509_crt_fmt_t format);
-  int gnutls_x509_crt_list_import (gnutls_x509_crt_t * certs,
+  } MHD_gnutls_certificate_import_flags;
+
+  int MHD_gnutls_x509_crt_init (MHD_gnutls_x509_crt_t * cert);
+  void MHD_gnutls_x509_crt_deinit (MHD_gnutls_x509_crt_t cert);
+  int MHD_gnutls_x509_crt_import (MHD_gnutls_x509_crt_t cert,
+                              const MHD_gnutls_datum_t * data,
+                              MHD_gnutls_x509_crt_fmt_t format);
+  int MHD_gnutls_x509_crt_list_import (MHD_gnutls_x509_crt_t * certs,
                                    unsigned int *cert_max,
-                                   const gnutls_datum_t * data,
-                                   gnutls_x509_crt_fmt_t format,
+                                   const MHD_gnutls_datum_t * data,
+                                   MHD_gnutls_x509_crt_fmt_t format,
                                    unsigned int flags);
-  int gnutls_x509_crt_export (gnutls_x509_crt_t cert,
-                              gnutls_x509_crt_fmt_t format,
+  int MHD_gnutls_x509_crt_export (MHD_gnutls_x509_crt_t cert,
+                              MHD_gnutls_x509_crt_fmt_t format,
                               void *output_data, size_t * output_data_size);
-  int gnutls_x509_crt_get_issuer_dn (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_get_issuer_dn (MHD_gnutls_x509_crt_t cert,
                                      char *buf, size_t * sizeof_buf);
-  int gnutls_x509_crt_get_issuer_dn_oid (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_get_issuer_dn_oid (MHD_gnutls_x509_crt_t cert,
                                          int indx,
                                          void *oid, size_t * sizeof_oid);
-  int gnutls_x509_crt_get_issuer_dn_by_oid (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_get_issuer_dn_by_oid (MHD_gnutls_x509_crt_t cert,
                                             const char *oid,
                                             int indx,
                                             unsigned int raw_flag,
                                             void *buf, size_t * sizeof_buf);
-  int gnutls_x509_crt_get_dn (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_get_dn (MHD_gnutls_x509_crt_t cert,
                               char *buf, size_t * sizeof_buf);
-  int gnutls_x509_crt_get_dn_oid (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_get_dn_oid (MHD_gnutls_x509_crt_t cert,
                                   int indx, void *oid, size_t * sizeof_oid);
-  int gnutls_x509_crt_get_dn_by_oid (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_get_dn_by_oid (MHD_gnutls_x509_crt_t cert,
                                      const char *oid,
                                      int indx,
                                      unsigned int raw_flag,
                                      void *buf, size_t * sizeof_buf);
-  int gnutls_x509_crt_check_hostname (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_check_hostname (MHD_gnutls_x509_crt_t cert,
                                       const char *hostname);
 
-  int gnutls_x509_crt_get_signature_algorithm (gnutls_x509_crt_t cert);
-  int gnutls_x509_crt_get_signature (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_get_signature_algorithm (MHD_gnutls_x509_crt_t cert);
+  int MHD_gnutls_x509_crt_get_signature (MHD_gnutls_x509_crt_t cert,
                                      char *sig, size_t * sizeof_sig);
-  int gnutls_x509_crt_get_version (gnutls_x509_crt_t cert);
-  int gnutls_x509_crt_get_key_id (gnutls_x509_crt_t crt,
+  int MHD_gnutls_x509_crt_get_version (MHD_gnutls_x509_crt_t cert);
+  int MHD_gnutls_x509_crt_get_key_id (MHD_gnutls_x509_crt_t crt,
                                   unsigned int flags,
                                   unsigned char *output_data,
                                   size_t * output_data_size);
 
-  int gnutls_x509_crt_set_authority_key_id (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_set_authority_key_id (MHD_gnutls_x509_crt_t cert,
                                             const void *id, size_t id_size);
-  int gnutls_x509_crt_get_authority_key_id (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_get_authority_key_id (MHD_gnutls_x509_crt_t cert,
                                             void *ret,
                                             size_t * ret_size,
                                             unsigned int *critical);
 
-  int gnutls_x509_crt_get_subject_key_id (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_get_subject_key_id (MHD_gnutls_x509_crt_t cert,
                                           void *ret,
                                           size_t * ret_size,
                                           unsigned int *critical);
@@ -153,79 +153,79 @@ extern "C"
 #define GNUTLS_CRL_REASON_PRIVILEGE_WITHDRAWN 1
 #define GNUTLS_CRL_REASON_AA_COMPROMISE 32768
 
-  int gnutls_x509_crt_get_crl_dist_points (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_get_crl_dist_points (MHD_gnutls_x509_crt_t cert,
                                            unsigned int seq,
                                            void *ret,
                                            size_t * ret_size,
                                            unsigned int *reason_flags,
                                            unsigned int *critical);
-  int gnutls_x509_crt_set_crl_dist_points (gnutls_x509_crt_t crt,
-                                           gnutls_x509_subject_alt_name_t
+  int MHD_gnutls_x509_crt_set_crl_dist_points (MHD_gnutls_x509_crt_t crt,
+                                           MHD_gnutls_x509_subject_alt_name_t
                                            type,
                                            const void *data_string,
                                            unsigned int reason_flags);
-  int gnutls_x509_crt_cpy_crl_dist_points (gnutls_x509_crt_t dst,
-                                           gnutls_x509_crt_t src);
+  int MHD_gnutls_x509_crt_cpy_crl_dist_points (MHD_gnutls_x509_crt_t dst,
+                                           MHD_gnutls_x509_crt_t src);
 
-  time_t gnutls_x509_crt_get_activation_time (gnutls_x509_crt_t cert);
-  time_t gnutls_x509_crt_get_expiration_time (gnutls_x509_crt_t cert);
-  int gnutls_x509_crt_get_serial (gnutls_x509_crt_t cert,
+  time_t MHD_gnutls_x509_crt_get_activation_time (MHD_gnutls_x509_crt_t cert);
+  time_t MHD_gnutls_x509_crt_get_expiration_time (MHD_gnutls_x509_crt_t cert);
+  int MHD_gnutls_x509_crt_get_serial (MHD_gnutls_x509_crt_t cert,
                                   void *result, size_t * result_size);
 
-  int gnutls_x509_crt_get_pk_algorithm (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_get_pk_algorithm (MHD_gnutls_x509_crt_t cert,
                                         unsigned int *bits);
-  int gnutls_x509_crt_get_pk_rsa_raw (gnutls_x509_crt_t crt,
-                                      gnutls_datum_t * m, gnutls_datum_t * e);
-  int gnutls_x509_crt_get_pk_dsa_raw (gnutls_x509_crt_t crt,
-                                      gnutls_datum_t * p,
-                                      gnutls_datum_t * q,
-                                      gnutls_datum_t * g, gnutls_datum_t * y);
-
-  int gnutls_x509_crt_get_subject_alt_name (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_get_pk_rsa_raw (MHD_gnutls_x509_crt_t crt,
+                                      MHD_gnutls_datum_t * m, MHD_gnutls_datum_t * e);
+  int MHD_gnutls_x509_crt_get_pk_dsa_raw (MHD_gnutls_x509_crt_t crt,
+                                      MHD_gnutls_datum_t * p,
+                                      MHD_gnutls_datum_t * q,
+                                      MHD_gnutls_datum_t * g, MHD_gnutls_datum_t * y);
+
+  int MHD_gnutls_x509_crt_get_subject_alt_name (MHD_gnutls_x509_crt_t cert,
                                             unsigned int seq,
                                             void *ret,
                                             size_t * ret_size,
                                             unsigned int *critical);
-  int gnutls_x509_crt_get_subject_alt_name2 (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_get_subject_alt_name2 (MHD_gnutls_x509_crt_t cert,
                                              unsigned int seq,
                                              void *ret,
                                              size_t * ret_size,
                                              unsigned int *ret_type,
                                              unsigned int *critical);
 
-  int gnutls_x509_crt_get_subject_alt_othername_oid (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_get_subject_alt_othername_oid (MHD_gnutls_x509_crt_t cert,
                                                      unsigned int seq,
                                                      void *ret,
                                                      size_t * ret_size);
 
-  int gnutls_x509_crt_get_ca_status (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_get_ca_status (MHD_gnutls_x509_crt_t cert,
                                      unsigned int *critical);
-  int gnutls_x509_crt_get_basic_constraints (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_get_basic_constraints (MHD_gnutls_x509_crt_t cert,
                                              unsigned int *critical,
                                              int *ca, int *pathlen);
 
 /* The key_usage flags are defined in gnutls.h. They are the
  * GNUTLS_KEY_* definitions.
  */
-  int gnutls_x509_crt_get_key_usage (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_get_key_usage (MHD_gnutls_x509_crt_t cert,
                                      unsigned int *key_usage,
                                      unsigned int *critical);
-  int gnutls_x509_crt_set_key_usage (gnutls_x509_crt_t crt,
+  int MHD_gnutls_x509_crt_set_key_usage (MHD_gnutls_x509_crt_t crt,
                                      unsigned int usage);
 
-  int gnutls_x509_crt_get_proxy (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_get_proxy (MHD_gnutls_x509_crt_t cert,
                                  unsigned int *critical,
                                  int *pathlen,
                                  char **policyLanguage,
                                  char **policy, size_t * sizeof_policy);
 
-  int gnutls_x509_dn_oid_known (const char *oid);
+  int MHD_gnutls_x509_dn_oid_known (const char *oid);
 
 /* Read extensions by OID. */
-  int gnutls_x509_crt_get_extension_oid (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_get_extension_oid (MHD_gnutls_x509_crt_t cert,
                                          int indx,
                                          void *oid, size_t * sizeof_oid);
-  int gnutls_x509_crt_get_extension_by_oid (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_get_extension_by_oid (MHD_gnutls_x509_crt_t cert,
                                             const char *oid,
                                             int indx,
                                             void *buf,
@@ -233,15 +233,15 @@ extern "C"
                                             unsigned int *critical);
 
 /* Read extensions by sequence number. */
-  int gnutls_x509_crt_get_extension_info (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_get_extension_info (MHD_gnutls_x509_crt_t cert,
                                           int indx,
                                           void *oid,
                                           size_t * sizeof_oid, int *critical);
-  int gnutls_x509_crt_get_extension_data (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_get_extension_data (MHD_gnutls_x509_crt_t cert,
                                           int indx,
                                           void *data, size_t * sizeof_data);
 
-  int gnutls_x509_crt_set_extension_by_oid (gnutls_x509_crt_t crt,
+  int MHD_gnutls_x509_crt_set_extension_by_oid (MHD_gnutls_x509_crt_t crt,
                                             const char *oid,
                                             const void *buf,
                                             size_t sizeof_buf,
@@ -249,207 +249,207 @@ extern "C"
 
 /* X.509 Certificate writing.
  */
-  int gnutls_x509_crt_set_dn_by_oid (gnutls_x509_crt_t crt,
+  int MHD_gnutls_x509_crt_set_dn_by_oid (MHD_gnutls_x509_crt_t crt,
                                      const char *oid,
                                      unsigned int raw_flag,
                                      const void *name,
                                      unsigned int sizeof_name);
-  int gnutls_x509_crt_set_issuer_dn_by_oid (gnutls_x509_crt_t crt,
+  int MHD_gnutls_x509_crt_set_issuer_dn_by_oid (MHD_gnutls_x509_crt_t crt,
                                             const char *oid,
                                             unsigned int raw_flag,
                                             const void *name,
                                             unsigned int sizeof_name);
-  int gnutls_x509_crt_set_version (gnutls_x509_crt_t crt,
+  int MHD_gnutls_x509_crt_set_version (MHD_gnutls_x509_crt_t crt,
                                    unsigned int version);
-  int gnutls_x509_crt_set_key (gnutls_x509_crt_t crt,
-                               gnutls_x509_privkey_t key);
-  int gnutls_x509_crt_set_ca_status (gnutls_x509_crt_t crt, unsigned int ca);
-  int gnutls_x509_crt_set_basic_constraints (gnutls_x509_crt_t crt,
+  int MHD_gnutls_x509_crt_set_key (MHD_gnutls_x509_crt_t crt,
+                               MHD_gnutls_x509_privkey_t key);
+  int MHD_gnutls_x509_crt_set_ca_status (MHD_gnutls_x509_crt_t crt, unsigned int ca);
+  int MHD_gnutls_x509_crt_set_basic_constraints (MHD_gnutls_x509_crt_t crt,
                                              unsigned int ca,
                                              int pathLenConstraint);
-  int gnutls_x509_crt_set_subject_alternative_name (gnutls_x509_crt_t crt,
-                                                    gnutls_x509_subject_alt_name_t
+  int MHD_gnutls_x509_crt_set_subject_alternative_name (MHD_gnutls_x509_crt_t crt,
+                                                    MHD_gnutls_x509_subject_alt_name_t
                                                     type,
                                                     const char *data_string);
-  int gnutls_x509_crt_sign (gnutls_x509_crt_t crt,
-                            gnutls_x509_crt_t issuer,
-                            gnutls_x509_privkey_t issuer_key);
-  int gnutls_x509_crt_sign2 (gnutls_x509_crt_t crt,
-                             gnutls_x509_crt_t issuer,
-                             gnutls_x509_privkey_t issuer_key,
+  int MHD_gnutls_x509_crt_sign (MHD_gnutls_x509_crt_t crt,
+                            MHD_gnutls_x509_crt_t issuer,
+                            MHD_gnutls_x509_privkey_t issuer_key);
+  int MHD_gnutls_x509_crt_sign2 (MHD_gnutls_x509_crt_t crt,
+                             MHD_gnutls_x509_crt_t issuer,
+                             MHD_gnutls_x509_privkey_t issuer_key,
                              enum MHD_GNUTLS_HashAlgorithm,
                              unsigned int flags);
-  int gnutls_x509_crt_set_activation_time (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_set_activation_time (MHD_gnutls_x509_crt_t cert,
                                            time_t act_time);
-  int gnutls_x509_crt_set_expiration_time (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_set_expiration_time (MHD_gnutls_x509_crt_t cert,
                                            time_t exp_time);
-  int gnutls_x509_crt_set_serial (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_set_serial (MHD_gnutls_x509_crt_t cert,
                                   const void *serial, size_t serial_size);
 
-  int gnutls_x509_crt_set_subject_key_id (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_set_subject_key_id (MHD_gnutls_x509_crt_t cert,
                                           const void *id, size_t id_size);
 
-  int gnutls_x509_crt_set_proxy_dn (gnutls_x509_crt_t crt,
-                                    gnutls_x509_crt_t eecrt,
+  int MHD_gnutls_x509_crt_set_proxy_dn (MHD_gnutls_x509_crt_t crt,
+                                    MHD_gnutls_x509_crt_t eecrt,
                                     unsigned int raw_flag,
                                     const void *name,
                                     unsigned int sizeof_name);
-  int gnutls_x509_crt_set_proxy (gnutls_x509_crt_t crt,
+  int MHD_gnutls_x509_crt_set_proxy (MHD_gnutls_x509_crt_t crt,
                                  int pathLenConstraint,
                                  const char *policyLanguage,
                                  const char *policy, size_t sizeof_policy);
 
-  typedef enum gnutls_certificate_print_formats
+  typedef enum MHD_gnutls_certificate_print_formats
   {
     GNUTLS_X509_CRT_FULL,
     GNUTLS_X509_CRT_ONELINE,
     GNUTLS_X509_CRT_UNSIGNED_FULL
-  } gnutls_certificate_print_formats_t;
+  } MHD_gnutls_certificate_print_formats_t;
 
-  int gnutls_x509_crt_print (gnutls_x509_crt_t cert,
-                             gnutls_certificate_print_formats_t format,
-                             gnutls_datum_t * out);
-  int gnutls_x509_crl_print (gnutls_x509_crl_t crl,
-                             gnutls_certificate_print_formats_t format,
-                             gnutls_datum_t * out);
+  int MHD_gnutls_x509_crt_print (MHD_gnutls_x509_crt_t cert,
+                             MHD_gnutls_certificate_print_formats_t format,
+                             MHD_gnutls_datum_t * out);
+  int MHD_gnutls_x509_crl_print (MHD_gnutls_x509_crl_t crl,
+                             MHD_gnutls_certificate_print_formats_t format,
+                             MHD_gnutls_datum_t * out);
 
 /* Access to internal Certificate fields.
  */
-  int gnutls_x509_crt_get_raw_issuer_dn (gnutls_x509_crt_t cert,
-                                         gnutls_datum_t * start);
-  int gnutls_x509_crt_get_raw_dn (gnutls_x509_crt_t cert,
-                                  gnutls_datum_t * start);
+  int MHD_gnutls_x509_crt_get_raw_issuer_dn (MHD_gnutls_x509_crt_t cert,
+                                         MHD_gnutls_datum_t * start);
+  int MHD_gnutls_x509_crt_get_raw_dn (MHD_gnutls_x509_crt_t cert,
+                                  MHD_gnutls_datum_t * start);
 
 /* RDN handling.
  */
-  int gnutls_x509_rdn_get (const gnutls_datum_t * idn,
+  int MHD_gnutls_x509_rdn_get (const MHD_gnutls_datum_t * idn,
                            char *buf, size_t * sizeof_buf);
-  int gnutls_x509_rdn_get_oid (const gnutls_datum_t * idn,
+  int MHD_gnutls_x509_rdn_get_oid (const MHD_gnutls_datum_t * idn,
                                int indx, void *buf, size_t * sizeof_buf);
 
-  int gnutls_x509_rdn_get_by_oid (const gnutls_datum_t * idn,
+  int MHD_gnutls_x509_rdn_get_by_oid (const MHD_gnutls_datum_t * idn,
                                   const char *oid,
                                   int indx,
                                   unsigned int raw_flag,
                                   void *buf, size_t * sizeof_buf);
 
-  typedef void *gnutls_x509_dn_t;
+  typedef void *MHD_gnutls_x509_dn_t;
 
-  typedef struct gnutls_x509_ava_st
+  typedef struct MHD_gnutls_x509_ava_st
   {
-    gnutls_datum_t oid;
-    gnutls_datum_t value;
+    MHD_gnutls_datum_t oid;
+    MHD_gnutls_datum_t value;
     unsigned long value_tag;
-  } gnutls_x509_ava_st;
+  } MHD_gnutls_x509_ava_st;
 
-  int gnutls_x509_crt_get_subject (gnutls_x509_crt_t cert,
-                                   gnutls_x509_dn_t * dn);
-  int gnutls_x509_crt_get_issuer (gnutls_x509_crt_t cert,
-                                  gnutls_x509_dn_t * dn);
-  int gnutls_x509_dn_get_rdn_ava (gnutls_x509_dn_t dn,
+  int MHD_gnutls_x509_crt_get_subject (MHD_gnutls_x509_crt_t cert,
+                                   MHD_gnutls_x509_dn_t * dn);
+  int MHD_gnutls_x509_crt_get_issuer (MHD_gnutls_x509_crt_t cert,
+                                  MHD_gnutls_x509_dn_t * dn);
+  int MHD_gnutls_x509_dn_get_rdn_ava (MHD_gnutls_x509_dn_t dn,
                                   int irdn,
-                                  int iava, gnutls_x509_ava_st * avast);
+                                  int iava, MHD_gnutls_x509_ava_st * avast);
 
 /* CRL handling functions.
  */
-  int gnutls_x509_crl_init (gnutls_x509_crl_t * crl);
-  void gnutls_x509_crl_deinit (gnutls_x509_crl_t crl);
-
-  int gnutls_x509_crl_import (gnutls_x509_crl_t crl,
-                              const gnutls_datum_t * data,
-                              gnutls_x509_crt_fmt_t format);
-  int gnutls_x509_crl_export (gnutls_x509_crl_t crl,
-                              gnutls_x509_crt_fmt_t format,
+  int MHD_gnutls_x509_crl_init (MHD_gnutls_x509_crl_t * crl);
+  void MHD_gnutls_x509_crl_deinit (MHD_gnutls_x509_crl_t crl);
+
+  int MHD_gnutls_x509_crl_import (MHD_gnutls_x509_crl_t crl,
+                              const MHD_gnutls_datum_t * data,
+                              MHD_gnutls_x509_crt_fmt_t format);
+  int MHD_gnutls_x509_crl_export (MHD_gnutls_x509_crl_t crl,
+                              MHD_gnutls_x509_crt_fmt_t format,
                               void *output_data, size_t * output_data_size);
 
-  int gnutls_x509_crl_get_issuer_dn (const gnutls_x509_crl_t crl,
+  int MHD_gnutls_x509_crl_get_issuer_dn (const MHD_gnutls_x509_crl_t crl,
                                      char *buf, size_t * sizeof_buf);
-  int gnutls_x509_crl_get_issuer_dn_by_oid (gnutls_x509_crl_t crl,
+  int MHD_gnutls_x509_crl_get_issuer_dn_by_oid (MHD_gnutls_x509_crl_t crl,
                                             const char *oid,
                                             int indx,
                                             unsigned int raw_flag,
                                             void *buf, size_t * sizeof_buf);
-  int gnutls_x509_crl_get_dn_oid (gnutls_x509_crl_t crl,
+  int MHD_gnutls_x509_crl_get_dn_oid (MHD_gnutls_x509_crl_t crl,
                                   int indx, void *oid, size_t * sizeof_oid);
 
-  int gnutls_x509_crl_get_signature_algorithm (gnutls_x509_crl_t crl);
-  int gnutls_x509_crl_get_signature (gnutls_x509_crl_t crl,
+  int MHD_gnutls_x509_crl_get_signature_algorithm (MHD_gnutls_x509_crl_t crl);
+  int MHD_gnutls_x509_crl_get_signature (MHD_gnutls_x509_crl_t crl,
                                      char *sig, size_t * sizeof_sig);
-  int gnutls_x509_crl_get_version (gnutls_x509_crl_t crl);
+  int MHD_gnutls_x509_crl_get_version (MHD_gnutls_x509_crl_t crl);
 
-  time_t gnutls_x509_crl_get_this_update (gnutls_x509_crl_t crl);
-  time_t gnutls_x509_crl_get_next_update (gnutls_x509_crl_t crl);
+  time_t MHD_gnutls_x509_crl_get_this_update (MHD_gnutls_x509_crl_t crl);
+  time_t MHD_gnutls_x509_crl_get_next_update (MHD_gnutls_x509_crl_t crl);
 
-  int gnutls_x509_crl_get_crt_count (gnutls_x509_crl_t crl);
-  int gnutls_x509_crl_get_crt_serial (gnutls_x509_crl_t crl,
+  int MHD_gnutls_x509_crl_get_crt_count (MHD_gnutls_x509_crl_t crl);
+  int MHD_gnutls_x509_crl_get_crt_serial (MHD_gnutls_x509_crl_t crl,
                                       int indx,
                                       unsigned char *serial,
                                       size_t * serial_size, time_t * t);
-#define gnutls_x509_crl_get_certificate_count gnutls_x509_crl_get_crt_count
-#define gnutls_x509_crl_get_certificate gnutls_x509_crl_get_crt_serial
+#define MHD_gnutls_x509_crl_get_certificate_count MHD_gnutls_x509_crl_get_crt_count
+#define MHD_gnutls_x509_crl_get_certificate MHD_gnutls_x509_crl_get_crt_serial
 
-  int gnutls_x509_crl_check_issuer (gnutls_x509_crl_t crl,
-                                    gnutls_x509_crt_t issuer);
+  int MHD_gnutls_x509_crl_check_issuer (MHD_gnutls_x509_crl_t crl,
+                                    MHD_gnutls_x509_crt_t issuer);
 
 /* CRL writing.
  */
-  int gnutls_x509_crl_set_version (gnutls_x509_crl_t crl,
+  int MHD_gnutls_x509_crl_set_version (MHD_gnutls_x509_crl_t crl,
                                    unsigned int version);
-  int gnutls_x509_crl_sign (gnutls_x509_crl_t crl,
-                            gnutls_x509_crt_t issuer,
-                            gnutls_x509_privkey_t issuer_key);
-  int gnutls_x509_crl_sign2 (gnutls_x509_crl_t crl,
-                             gnutls_x509_crt_t issuer,
-                             gnutls_x509_privkey_t issuer_key,
+  int MHD_gnutls_x509_crl_sign (MHD_gnutls_x509_crl_t crl,
+                            MHD_gnutls_x509_crt_t issuer,
+                            MHD_gnutls_x509_privkey_t issuer_key);
+  int MHD_gnutls_x509_crl_sign2 (MHD_gnutls_x509_crl_t crl,
+                             MHD_gnutls_x509_crt_t issuer,
+                             MHD_gnutls_x509_privkey_t issuer_key,
                              enum MHD_GNUTLS_HashAlgorithm,
                              unsigned int flags);
-  int gnutls_x509_crl_set_this_update (gnutls_x509_crl_t crl,
+  int MHD_gnutls_x509_crl_set_this_update (MHD_gnutls_x509_crl_t crl,
                                        time_t act_time);
-  int gnutls_x509_crl_set_next_update (gnutls_x509_crl_t crl,
+  int MHD_gnutls_x509_crl_set_next_update (MHD_gnutls_x509_crl_t crl,
                                        time_t exp_time);
-  int gnutls_x509_crl_set_crt_serial (gnutls_x509_crl_t crl,
+  int MHD_gnutls_x509_crl_set_crt_serial (MHD_gnutls_x509_crl_t crl,
                                       const void *serial,
                                       size_t serial_size,
                                       time_t revocation_time);
-  int gnutls_x509_crl_set_crt (gnutls_x509_crl_t crl,
-                               gnutls_x509_crt_t crt, time_t revocation_time);
+  int MHD_gnutls_x509_crl_set_crt (MHD_gnutls_x509_crl_t crl,
+                               MHD_gnutls_x509_crt_t crt, time_t revocation_time);
 
 /* PKCS7 structures handling
  */
-  struct gnutls_pkcs7_int;
-  typedef struct gnutls_pkcs7_int *gnutls_pkcs7_t;
-
-  int gnutls_pkcs7_init (gnutls_pkcs7_t * pkcs7);
-  void gnutls_pkcs7_deinit (gnutls_pkcs7_t pkcs7);
-  int gnutls_pkcs7_import (gnutls_pkcs7_t pkcs7,
-                           const gnutls_datum_t * data,
-                           gnutls_x509_crt_fmt_t format);
-  int gnutls_pkcs7_export (gnutls_pkcs7_t pkcs7,
-                           gnutls_x509_crt_fmt_t format,
+  struct MHD_gnutls_pkcs7_int;
+  typedef struct MHD_gnutls_pkcs7_int *MHD_gnutls_pkcs7_t;
+
+  int MHD_gnutls_pkcs7_init (MHD_gnutls_pkcs7_t * pkcs7);
+  void MHD_gnutls_pkcs7_deinit (MHD_gnutls_pkcs7_t pkcs7);
+  int MHD_gnutls_pkcs7_import (MHD_gnutls_pkcs7_t pkcs7,
+                           const MHD_gnutls_datum_t * data,
+                           MHD_gnutls_x509_crt_fmt_t format);
+  int MHD_gnutls_pkcs7_export (MHD_gnutls_pkcs7_t pkcs7,
+                           MHD_gnutls_x509_crt_fmt_t format,
                            void *output_data, size_t * output_data_size);
 
-  int gnutls_pkcs7_get_crt_count (gnutls_pkcs7_t pkcs7);
-  int gnutls_pkcs7_get_crt_raw (gnutls_pkcs7_t pkcs7,
+  int MHD_gnutls_pkcs7_get_crt_count (MHD_gnutls_pkcs7_t pkcs7);
+  int MHD_gnutls_pkcs7_get_crt_raw (MHD_gnutls_pkcs7_t pkcs7,
                                 int indx,
                                 void *certificate, size_t * certificate_size);
 
-  int gnutls_pkcs7_set_crt_raw (gnutls_pkcs7_t pkcs7,
-                                const gnutls_datum_t * crt);
-  int gnutls_pkcs7_set_crt (gnutls_pkcs7_t pkcs7, gnutls_x509_crt_t crt);
-  int gnutls_pkcs7_delete_crt (gnutls_pkcs7_t pkcs7, int indx);
+  int MHD_gnutls_pkcs7_set_crt_raw (MHD_gnutls_pkcs7_t pkcs7,
+                                const MHD_gnutls_datum_t * crt);
+  int MHD_gnutls_pkcs7_set_crt (MHD_gnutls_pkcs7_t pkcs7, MHD_gnutls_x509_crt_t crt);
+  int MHD_gnutls_pkcs7_delete_crt (MHD_gnutls_pkcs7_t pkcs7, int indx);
 
-  int gnutls_pkcs7_get_crl_raw (gnutls_pkcs7_t pkcs7,
+  int MHD_gnutls_pkcs7_get_crl_raw (MHD_gnutls_pkcs7_t pkcs7,
                                 int indx, void *crl, size_t * crl_size);
-  int gnutls_pkcs7_get_crl_count (gnutls_pkcs7_t pkcs7);
+  int MHD_gnutls_pkcs7_get_crl_count (MHD_gnutls_pkcs7_t pkcs7);
 
-  int gnutls_pkcs7_set_crl_raw (gnutls_pkcs7_t pkcs7,
-                                const gnutls_datum_t * crt);
-  int gnutls_pkcs7_set_crl (gnutls_pkcs7_t pkcs7, gnutls_x509_crl_t crl);
-  int gnutls_pkcs7_delete_crl (gnutls_pkcs7_t pkcs7, int indx);
+  int MHD_gnutls_pkcs7_set_crl_raw (MHD_gnutls_pkcs7_t pkcs7,
+                                const MHD_gnutls_datum_t * crt);
+  int MHD_gnutls_pkcs7_set_crl (MHD_gnutls_pkcs7_t pkcs7, MHD_gnutls_x509_crl_t crl);
+  int MHD_gnutls_pkcs7_delete_crl (MHD_gnutls_pkcs7_t pkcs7, int indx);
 
 /* X.509 Certificate verification functions.
  */
-  typedef enum gnutls_certificate_verify_flags
+  typedef enum MHD_gnutls_certificate_verify_flags
   {
     /* If set a signer does not have to be a certificate authority. This
      * flag should normaly be disabled, unless you know what this means.
@@ -482,51 +482,51 @@ extern "C"
     /* Allow certificates to be signed using the broken MD5 algorithm.
      */
     GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD5 = 32
-  } gnutls_certificate_verify_flags;
+  } MHD_gnutls_certificate_verify_flags;
 
-  int gnutls_x509_crt_check_issuer (gnutls_x509_crt_t cert,
-                                    gnutls_x509_crt_t issuer);
+  int MHD_gnutls_x509_crt_check_issuer (MHD_gnutls_x509_crt_t cert,
+                                    MHD_gnutls_x509_crt_t issuer);
 
-  int gnutls_x509_crt_list_verify (const gnutls_x509_crt_t * cert_list,
+  int MHD_gnutls_x509_crt_list_verify (const MHD_gnutls_x509_crt_t * cert_list,
                                    int cert_list_length,
-                                   const gnutls_x509_crt_t * CA_list,
+                                   const MHD_gnutls_x509_crt_t * CA_list,
                                    int CA_list_length,
-                                   const gnutls_x509_crl_t * CRL_list,
+                                   const MHD_gnutls_x509_crl_t * CRL_list,
                                    int CRL_list_length,
                                    unsigned int flags, unsigned int *verify);
 
-  int gnutls_x509_crt_verify (gnutls_x509_crt_t cert,
-                              const gnutls_x509_crt_t * CA_list,
+  int MHD_gnutls_x509_crt_verify (MHD_gnutls_x509_crt_t cert,
+                              const MHD_gnutls_x509_crt_t * CA_list,
                               int CA_list_length,
                               unsigned int flags, unsigned int *verify);
-  int gnutls_x509_crl_verify (gnutls_x509_crl_t crl,
-                              const gnutls_x509_crt_t * CA_list,
+  int MHD_gnutls_x509_crl_verify (MHD_gnutls_x509_crl_t crl,
+                              const MHD_gnutls_x509_crt_t * CA_list,
                               int CA_list_length,
                               unsigned int flags, unsigned int *verify);
 
-  int gnutls_x509_crt_check_revocation (gnutls_x509_crt_t cert,
-                                        const gnutls_x509_crl_t *
+  int MHD_gnutls_x509_crt_check_revocation (MHD_gnutls_x509_crt_t cert,
+                                        const MHD_gnutls_x509_crl_t *
                                         crl_list, int crl_list_length);
 
-  int gnutls_x509_crt_get_fingerprint (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_get_fingerprint (MHD_gnutls_x509_crt_t cert,
                                        enum MHD_GNUTLS_HashAlgorithm algo,
                                        void *buf, size_t * sizeof_buf);
 
-  int gnutls_x509_crt_get_key_purpose_oid (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_get_key_purpose_oid (MHD_gnutls_x509_crt_t cert,
                                            int indx,
                                            void *oid,
                                            size_t * sizeof_oid,
                                            unsigned int *critical);
-  int gnutls_x509_crt_set_key_purpose_oid (gnutls_x509_crt_t cert,
+  int MHD_gnutls_x509_crt_set_key_purpose_oid (MHD_gnutls_x509_crt_t cert,
                                            const void *oid,
                                            unsigned int critical);
 
 /* Private key handling.
  */
 
-/* Flags for the gnutls_x509_privkey_export_pkcs8() function.
+/* Flags for the MHD_gnutls_x509_privkey_export_pkcs8() function.
  */
-  typedef enum gnutls_pkcs_encrypt_flags_t
+  typedef enum MHD_gnutls_pkcs_encrypt_flags_t
   {
     GNUTLS_PKCS_PLAIN = 1,      /* if set the private key will not
                                  * be encrypted.
@@ -535,150 +535,150 @@ extern "C"
     GNUTLS_PKCS_USE_PKCS12_ARCFOUR = 4,
     GNUTLS_PKCS_USE_PKCS12_RC2_40 = 8,
     GNUTLS_PKCS_USE_PBES2_3DES = 16
-  } gnutls_pkcs_encrypt_flags_t;
+  } MHD_gnutls_pkcs_encrypt_flags_t;
 
 #define GNUTLS_PKCS8_PLAIN GNUTLS_PKCS_PLAIN
 #define GNUTLS_PKCS8_USE_PKCS12_3DES GNUTLS_PKCS_USE_PKCS12_3DES
 #define GNUTLS_PKCS8_USE_PKCS12_ARCFOUR GNUTLS_PKCS_USE_PKCS12_ARCFOUR
 #define GNUTLS_PKCS8_USE_PKCS12_RC2_40 GNUTLS_PKCS_USE_PKCS12_RC2_40
 
-  int gnutls_x509_privkey_init (gnutls_x509_privkey_t * key);
-  void gnutls_x509_privkey_deinit (gnutls_x509_privkey_t key);
-  int gnutls_x509_privkey_cpy (gnutls_x509_privkey_t dst,
-                               gnutls_x509_privkey_t src);
-  int gnutls_x509_privkey_import (gnutls_x509_privkey_t key,
-                                  const gnutls_datum_t * data,
-                                  gnutls_x509_crt_fmt_t format);
-  int gnutls_x509_privkey_import_pkcs8 (gnutls_x509_privkey_t key,
-                                        const gnutls_datum_t * data,
-                                        gnutls_x509_crt_fmt_t format,
+  int MHD_gnutls_x509_privkey_init (MHD_gnutls_x509_privkey_t * key);
+  void MHD_gnutls_x509_privkey_deinit (MHD_gnutls_x509_privkey_t key);
+  int MHD_gnutls_x509_privkey_cpy (MHD_gnutls_x509_privkey_t dst,
+                               MHD_gnutls_x509_privkey_t src);
+  int MHD_gnutls_x509_privkey_import (MHD_gnutls_x509_privkey_t key,
+                                  const MHD_gnutls_datum_t * data,
+                                  MHD_gnutls_x509_crt_fmt_t format);
+  int MHD_gnutls_x509_privkey_import_pkcs8 (MHD_gnutls_x509_privkey_t key,
+                                        const MHD_gnutls_datum_t * data,
+                                        MHD_gnutls_x509_crt_fmt_t format,
                                         const char *pass, unsigned int flags);
-  int gnutls_x509_privkey_import_rsa_raw (gnutls_x509_privkey_t key,
-                                          const gnutls_datum_t * m,
-                                          const gnutls_datum_t * e,
-                                          const gnutls_datum_t * d,
-                                          const gnutls_datum_t * p,
-                                          const gnutls_datum_t * q,
-                                          const gnutls_datum_t * u);
-  int gnutls_x509_privkey_fix (gnutls_x509_privkey_t key);
-
-  int gnutls_x509_privkey_export_dsa_raw (gnutls_x509_privkey_t key,
-                                          gnutls_datum_t * p,
-                                          gnutls_datum_t * q,
-                                          gnutls_datum_t * g,
-                                          gnutls_datum_t * y,
-                                          gnutls_datum_t * x);
-  int gnutls_x509_privkey_import_dsa_raw (gnutls_x509_privkey_t key,
-                                          const gnutls_datum_t * p,
-                                          const gnutls_datum_t * q,
-                                          const gnutls_datum_t * g,
-                                          const gnutls_datum_t * y,
-                                          const gnutls_datum_t * x);
-
-  int gnutls_x509_privkey_get_pk_algorithm (gnutls_x509_privkey_t key);
-  int gnutls_x509_privkey_get_key_id (gnutls_x509_privkey_t key,
+  int MHD_gnutls_x509_privkey_import_rsa_raw (MHD_gnutls_x509_privkey_t key,
+                                          const MHD_gnutls_datum_t * m,
+                                          const MHD_gnutls_datum_t * e,
+                                          const MHD_gnutls_datum_t * d,
+                                          const MHD_gnutls_datum_t * p,
+                                          const MHD_gnutls_datum_t * q,
+                                          const MHD_gnutls_datum_t * u);
+  int MHD_gnutls_x509_privkey_fix (MHD_gnutls_x509_privkey_t key);
+
+  int MHD_gnutls_x509_privkey_export_dsa_raw (MHD_gnutls_x509_privkey_t key,
+                                          MHD_gnutls_datum_t * p,
+                                          MHD_gnutls_datum_t * q,
+                                          MHD_gnutls_datum_t * g,
+                                          MHD_gnutls_datum_t * y,
+                                          MHD_gnutls_datum_t * x);
+  int MHD_gnutls_x509_privkey_import_dsa_raw (MHD_gnutls_x509_privkey_t key,
+                                          const MHD_gnutls_datum_t * p,
+                                          const MHD_gnutls_datum_t * q,
+                                          const MHD_gnutls_datum_t * g,
+                                          const MHD_gnutls_datum_t * y,
+                                          const MHD_gnutls_datum_t * x);
+
+  int MHD_gnutls_x509_privkey_get_pk_algorithm (MHD_gnutls_x509_privkey_t key);
+  int MHD_gnutls_x509_privkey_get_key_id (MHD_gnutls_x509_privkey_t key,
                                       unsigned int flags,
                                       unsigned char *output_data,
                                       size_t * output_data_size);
 
-  int gnutls_x509_privkey_generate (gnutls_x509_privkey_t key,
+  int MHD_gnutls_x509_privkey_generate (MHD_gnutls_x509_privkey_t key,
                                     enum MHD_GNUTLS_PublicKeyAlgorithm algo,
                                     unsigned int bits, unsigned int flags);
 
-  int gnutls_x509_privkey_export (gnutls_x509_privkey_t key,
-                                  gnutls_x509_crt_fmt_t format,
+  int MHD_gnutls_x509_privkey_export (MHD_gnutls_x509_privkey_t key,
+                                  MHD_gnutls_x509_crt_fmt_t format,
                                   void *output_data,
                                   size_t * output_data_size);
-  int gnutls_x509_privkey_export_pkcs8 (gnutls_x509_privkey_t key,
-                                        gnutls_x509_crt_fmt_t format,
+  int MHD_gnutls_x509_privkey_export_pkcs8 (MHD_gnutls_x509_privkey_t key,
+                                        MHD_gnutls_x509_crt_fmt_t format,
                                         const char *password,
                                         unsigned int flags,
                                         void *output_data,
                                         size_t * output_data_size);
-  int gnutls_x509_privkey_export_rsa_raw (gnutls_x509_privkey_t key,
-                                          gnutls_datum_t * m,
-                                          gnutls_datum_t * e,
-                                          gnutls_datum_t * d,
-                                          gnutls_datum_t * p,
-                                          gnutls_datum_t * q,
-                                          gnutls_datum_t * u);
+  int MHD_gnutls_x509_privkey_export_rsa_raw (MHD_gnutls_x509_privkey_t key,
+                                          MHD_gnutls_datum_t * m,
+                                          MHD_gnutls_datum_t * e,
+                                          MHD_gnutls_datum_t * d,
+                                          MHD_gnutls_datum_t * p,
+                                          MHD_gnutls_datum_t * q,
+                                          MHD_gnutls_datum_t * u);
 
 /* Signing stuff.
  */
-  int gnutls_x509_privkey_sign_data (gnutls_x509_privkey_t key,
+  int MHD_gnutls_x509_privkey_sign_data (MHD_gnutls_x509_privkey_t key,
                                      enum MHD_GNUTLS_HashAlgorithm digest,
                                      unsigned int flags,
-                                     const gnutls_datum_t * data,
+                                     const MHD_gnutls_datum_t * data,
                                      void *signature,
                                      size_t * signature_size);
-  int gnutls_x509_privkey_verify_data (gnutls_x509_privkey_t key,
+  int MHD_gnutls_x509_privkey_verify_data (MHD_gnutls_x509_privkey_t key,
                                        unsigned int flags,
-                                       const gnutls_datum_t * data,
-                                       const gnutls_datum_t * signature);
-  int gnutls_x509_crt_verify_data (gnutls_x509_crt_t crt,
+                                       const MHD_gnutls_datum_t * data,
+                                       const MHD_gnutls_datum_t * signature);
+  int MHD_gnutls_x509_crt_verify_data (MHD_gnutls_x509_crt_t crt,
                                    unsigned int flags,
-                                   const gnutls_datum_t * data,
-                                   const gnutls_datum_t * signature);
+                                   const MHD_gnutls_datum_t * data,
+                                   const MHD_gnutls_datum_t * signature);
 
-  int gnutls_x509_privkey_sign_hash (gnutls_x509_privkey_t key,
-                                     const gnutls_datum_t * hash,
-                                     gnutls_datum_t * signature);
+  int MHD_gnutls_x509_privkey_sign_hash (MHD_gnutls_x509_privkey_t key,
+                                     const MHD_gnutls_datum_t * hash,
+                                     MHD_gnutls_datum_t * signature);
 
 /* Certificate request stuff.
  */
-  struct gnutls_x509_crq_int;
-  typedef struct gnutls_x509_crq_int *gnutls_x509_crq_t;
-
-  int gnutls_x509_crq_init (gnutls_x509_crq_t * crq);
-  void gnutls_x509_crq_deinit (gnutls_x509_crq_t crq);
-  int gnutls_x509_crq_import (gnutls_x509_crq_t crq,
-                              const gnutls_datum_t * data,
-                              gnutls_x509_crt_fmt_t format);
-  int gnutls_x509_crq_get_pk_algorithm (gnutls_x509_crq_t crq,
+  struct MHD_gnutls_x509_crq_int;
+  typedef struct MHD_gnutls_x509_crq_int *MHD_gnutls_x509_crq_t;
+
+  int MHD_gnutls_x509_crq_init (MHD_gnutls_x509_crq_t * crq);
+  void MHD_gnutls_x509_crq_deinit (MHD_gnutls_x509_crq_t crq);
+  int MHD_gnutls_x509_crq_import (MHD_gnutls_x509_crq_t crq,
+                              const MHD_gnutls_datum_t * data,
+                              MHD_gnutls_x509_crt_fmt_t format);
+  int MHD_gnutls_x509_crq_get_pk_algorithm (MHD_gnutls_x509_crq_t crq,
                                         unsigned int *bits);
-  int gnutls_x509_crq_get_dn (gnutls_x509_crq_t crq,
+  int MHD_gnutls_x509_crq_get_dn (MHD_gnutls_x509_crq_t crq,
                               char *buf, size_t * sizeof_buf);
-  int gnutls_x509_crq_get_dn_oid (gnutls_x509_crq_t crq,
+  int MHD_gnutls_x509_crq_get_dn_oid (MHD_gnutls_x509_crq_t crq,
                                   int indx, void *oid, size_t * sizeof_oid);
-  int gnutls_x509_crq_get_dn_by_oid (gnutls_x509_crq_t crq,
+  int MHD_gnutls_x509_crq_get_dn_by_oid (MHD_gnutls_x509_crq_t crq,
                                      const char *oid,
                                      int indx,
                                      unsigned int raw_flag,
                                      void *buf, size_t * sizeof_buf);
-  int gnutls_x509_crq_set_dn_by_oid (gnutls_x509_crq_t crq,
+  int MHD_gnutls_x509_crq_set_dn_by_oid (MHD_gnutls_x509_crq_t crq,
                                      const char *oid,
                                      unsigned int raw_flag,
                                      const void *name,
                                      unsigned int sizeof_name);
-  int gnutls_x509_crq_set_version (gnutls_x509_crq_t crq,
+  int MHD_gnutls_x509_crq_set_version (MHD_gnutls_x509_crq_t crq,
                                    unsigned int version);
-  int gnutls_x509_crq_set_key (gnutls_x509_crq_t crq,
-                               gnutls_x509_privkey_t key);
-  int gnutls_x509_crq_sign2 (gnutls_x509_crq_t crq,
-                             gnutls_x509_privkey_t key,
+  int MHD_gnutls_x509_crq_set_key (MHD_gnutls_x509_crq_t crq,
+                               MHD_gnutls_x509_privkey_t key);
+  int MHD_gnutls_x509_crq_sign2 (MHD_gnutls_x509_crq_t crq,
+                             MHD_gnutls_x509_privkey_t key,
                              enum MHD_GNUTLS_HashAlgorithm,
                              unsigned int flags);
-  int gnutls_x509_crq_sign (gnutls_x509_crq_t crq, gnutls_x509_privkey_t key);
+  int MHD_gnutls_x509_crq_sign (MHD_gnutls_x509_crq_t crq, MHD_gnutls_x509_privkey_t key);
 
-  int gnutls_x509_crq_set_challenge_password (gnutls_x509_crq_t crq,
+  int MHD_gnutls_x509_crq_set_challenge_password (MHD_gnutls_x509_crq_t crq,
                                               const char *pass);
-  int gnutls_x509_crq_get_challenge_password (gnutls_x509_crq_t crq,
+  int MHD_gnutls_x509_crq_get_challenge_password (MHD_gnutls_x509_crq_t crq,
                                               char *pass,
                                               size_t * sizeof_pass);
 
-  int gnutls_x509_crq_set_attribute_by_oid (gnutls_x509_crq_t crq,
+  int MHD_gnutls_x509_crq_set_attribute_by_oid (MHD_gnutls_x509_crq_t crq,
                                             const char *oid,
                                             void *buf, size_t sizeof_buf);
-  int gnutls_x509_crq_get_attribute_by_oid (gnutls_x509_crq_t crq,
+  int MHD_gnutls_x509_crq_get_attribute_by_oid (MHD_gnutls_x509_crq_t crq,
                                             const char *oid,
                                             int indx,
                                             void *buf, size_t * sizeof_buf);
 
-  int gnutls_x509_crq_export (gnutls_x509_crq_t crq,
-                              gnutls_x509_crt_fmt_t format,
+  int MHD_gnutls_x509_crq_export (MHD_gnutls_x509_crq_t crq,
+                              MHD_gnutls_x509_crt_fmt_t format,
                               void *output_data, size_t * output_data_size);
 
-  int gnutls_x509_crt_set_crq (gnutls_x509_crt_t crt, gnutls_x509_crq_t crq);
+  int MHD_gnutls_x509_crt_set_crq (MHD_gnutls_x509_crt_t crt, MHD_gnutls_x509_crq_t crq);
 
 #ifdef __cplusplus
 }
@@ -692,16 +692,16 @@ extern "C"
 #define HASH_OID_SHA384 "2.16.840.1.101.3.4.2.2"
 #define HASH_OID_SHA512 "2.16.840.1.101.3.4.2.3"
 
-typedef struct gnutls_x509_crl_int
+typedef struct MHD_gnutls_x509_crl_int
 {
   ASN1_TYPE crl;
-} gnutls_x509_crl_int;
+} MHD_gnutls_x509_crl_int;
 
-typedef struct gnutls_x509_crt_int
+typedef struct MHD_gnutls_x509_crt_int
 {
   ASN1_TYPE cert;
   int use_extensions;
-} gnutls_x509_crt_int;
+} MHD_gnutls_x509_crt_int;
 
 #define MAX_PRIV_PARAMS_SIZE 6  /* ok for RSA and DSA */
 
@@ -749,100 +749,100 @@ typedef struct MHD_gtls_x509_privkey_int
                                  * the exported API (used internally only).
                                  */
   ASN1_TYPE key;
-} gnutls_x509_privkey_int;
+} MHD_gnutls_x509_privkey_int;
 
-int gnutls_x509_crt_get_issuer_dn_by_oid (gnutls_x509_crt_t cert,
+int MHD_gnutls_x509_crt_get_issuer_dn_by_oid (MHD_gnutls_x509_crt_t cert,
                                           const char *oid,
                                           int indx,
                                           unsigned int raw_flag,
                                           void *buf, size_t * sizeof_buf);
-int gnutls_x509_crt_get_subject_alt_name (gnutls_x509_crt_t cert,
+int MHD_gnutls_x509_crt_get_subject_alt_name (MHD_gnutls_x509_crt_t cert,
                                           unsigned int seq,
                                           void *ret,
                                           size_t * ret_size,
                                           unsigned int *critical);
-int gnutls_x509_crt_get_dn_by_oid (gnutls_x509_crt_t cert,
+int MHD_gnutls_x509_crt_get_dn_by_oid (MHD_gnutls_x509_crt_t cert,
                                    const char *oid,
                                    int indx,
                                    unsigned int raw_flag,
                                    void *buf, size_t * sizeof_buf);
-int gnutls_x509_crt_get_ca_status (gnutls_x509_crt_t cert,
+int MHD_gnutls_x509_crt_get_ca_status (MHD_gnutls_x509_crt_t cert,
                                    unsigned int *critical);
-int gnutls_x509_crt_get_pk_algorithm (gnutls_x509_crt_t cert,
+int MHD_gnutls_x509_crt_get_pk_algorithm (MHD_gnutls_x509_crt_t cert,
                                       unsigned int *bits);
 
-int _gnutls_x509_crt_cpy (gnutls_x509_crt_t dest, gnutls_x509_crt_t src);
+int MHD__gnutls_x509_crt_cpy (MHD_gnutls_x509_crt_t dest, MHD_gnutls_x509_crt_t src);
 
-int gnutls_x509_crt_get_serial (gnutls_x509_crt_t cert,
+int MHD_gnutls_x509_crt_get_serial (MHD_gnutls_x509_crt_t cert,
                                 void *result, size_t * result_size);
 
-int _gnutls_x509_compare_raw_dn (const gnutls_datum_t * dn1,
-                                 const gnutls_datum_t * dn2);
+int MHD__gnutls_x509_compare_raw_dn (const MHD_gnutls_datum_t * dn1,
+                                 const MHD_gnutls_datum_t * dn2);
 
-int gnutls_x509_crt_check_revocation (gnutls_x509_crt_t cert,
-                                      const gnutls_x509_crl_t * crl_list,
+int MHD_gnutls_x509_crt_check_revocation (MHD_gnutls_x509_crt_t cert,
+                                      const MHD_gnutls_x509_crl_t * crl_list,
                                       int crl_list_length);
 
-int _gnutls_x509_crl_cpy (gnutls_x509_crl_t dest, gnutls_x509_crl_t src);
-int _gnutls_x509_crl_get_raw_issuer_dn (gnutls_x509_crl_t crl,
-                                        gnutls_datum_t * dn);
-int gnutls_x509_crl_get_crt_count (gnutls_x509_crl_t crl);
-int gnutls_x509_crl_get_crt_serial (gnutls_x509_crl_t crl,
+int MHD__gnutls_x509_crl_cpy (MHD_gnutls_x509_crl_t dest, MHD_gnutls_x509_crl_t src);
+int MHD__gnutls_x509_crl_get_raw_issuer_dn (MHD_gnutls_x509_crl_t crl,
+                                        MHD_gnutls_datum_t * dn);
+int MHD_gnutls_x509_crl_get_crt_count (MHD_gnutls_x509_crl_t crl);
+int MHD_gnutls_x509_crl_get_crt_serial (MHD_gnutls_x509_crl_t crl,
                                     int indx,
                                     unsigned char *serial,
                                     size_t * serial_size, time_t * t);
 
-void gnutls_x509_crl_deinit (gnutls_x509_crl_t crl);
-int gnutls_x509_crl_init (gnutls_x509_crl_t * crl);
-int gnutls_x509_crl_import (gnutls_x509_crl_t crl,
-                            const gnutls_datum_t * data,
-                            gnutls_x509_crt_fmt_t format);
-int gnutls_x509_crl_export (gnutls_x509_crl_t crl,
-                            gnutls_x509_crt_fmt_t format,
+void MHD_gnutls_x509_crl_deinit (MHD_gnutls_x509_crl_t crl);
+int MHD_gnutls_x509_crl_init (MHD_gnutls_x509_crl_t * crl);
+int MHD_gnutls_x509_crl_import (MHD_gnutls_x509_crl_t crl,
+                            const MHD_gnutls_datum_t * data,
+                            MHD_gnutls_x509_crt_fmt_t format);
+int MHD_gnutls_x509_crl_export (MHD_gnutls_x509_crl_t crl,
+                            MHD_gnutls_x509_crt_fmt_t format,
                             void *output_data, size_t * output_data_size);
 
-int gnutls_x509_crt_init (gnutls_x509_crt_t * cert);
-void gnutls_x509_crt_deinit (gnutls_x509_crt_t cert);
-int gnutls_x509_crt_import (gnutls_x509_crt_t cert,
-                            const gnutls_datum_t * data,
-                            gnutls_x509_crt_fmt_t format);
-int gnutls_x509_crt_export (gnutls_x509_crt_t cert,
-                            gnutls_x509_crt_fmt_t format,
+int MHD_gnutls_x509_crt_init (MHD_gnutls_x509_crt_t * cert);
+void MHD_gnutls_x509_crt_deinit (MHD_gnutls_x509_crt_t cert);
+int MHD_gnutls_x509_crt_import (MHD_gnutls_x509_crt_t cert,
+                            const MHD_gnutls_datum_t * data,
+                            MHD_gnutls_x509_crt_fmt_t format);
+int MHD_gnutls_x509_crt_export (MHD_gnutls_x509_crt_t cert,
+                            MHD_gnutls_x509_crt_fmt_t format,
                             void *output_data, size_t * output_data_size);
 
-int gnutls_x509_crt_get_key_usage (gnutls_x509_crt_t cert,
+int MHD_gnutls_x509_crt_get_key_usage (MHD_gnutls_x509_crt_t cert,
                                    unsigned int *key_usage,
                                    unsigned int *critical);
-int gnutls_x509_crt_get_signature_algorithm (gnutls_x509_crt_t cert);
-int gnutls_x509_crt_get_version (gnutls_x509_crt_t cert);
+int MHD_gnutls_x509_crt_get_signature_algorithm (MHD_gnutls_x509_crt_t cert);
+int MHD_gnutls_x509_crt_get_version (MHD_gnutls_x509_crt_t cert);
 
-int gnutls_x509_privkey_init (gnutls_x509_privkey_t * key);
-void gnutls_x509_privkey_deinit (gnutls_x509_privkey_t key);
+int MHD_gnutls_x509_privkey_init (MHD_gnutls_x509_privkey_t * key);
+void MHD_gnutls_x509_privkey_deinit (MHD_gnutls_x509_privkey_t key);
 
-int gnutls_x509_privkey_generate (gnutls_x509_privkey_t key,
+int MHD_gnutls_x509_privkey_generate (MHD_gnutls_x509_privkey_t key,
                                   enum MHD_GNUTLS_PublicKeyAlgorithm algo,
                                   unsigned int bits, unsigned int flags);
 
-int gnutls_x509_privkey_import (gnutls_x509_privkey_t key,
-                                const gnutls_datum_t * data,
-                                gnutls_x509_crt_fmt_t format);
-int gnutls_x509_privkey_get_pk_algorithm (gnutls_x509_privkey_t key);
-int gnutls_x509_privkey_import_rsa_raw (gnutls_x509_privkey_t key,
-                                        const gnutls_datum_t * m,
-                                        const gnutls_datum_t * e,
-                                        const gnutls_datum_t * d,
-                                        const gnutls_datum_t * p,
-                                        const gnutls_datum_t * q,
-                                        const gnutls_datum_t * u);
-int gnutls_x509_privkey_export_rsa_raw (gnutls_x509_privkey_t key,
-                                        gnutls_datum_t * m,
-                                        gnutls_datum_t * e,
-                                        gnutls_datum_t * d,
-                                        gnutls_datum_t * p,
-                                        gnutls_datum_t * q,
-                                        gnutls_datum_t * u);
-int gnutls_x509_privkey_export (gnutls_x509_privkey_t key,
-                                gnutls_x509_crt_fmt_t format,
+int MHD_gnutls_x509_privkey_import (MHD_gnutls_x509_privkey_t key,
+                                const MHD_gnutls_datum_t * data,
+                                MHD_gnutls_x509_crt_fmt_t format);
+int MHD_gnutls_x509_privkey_get_pk_algorithm (MHD_gnutls_x509_privkey_t key);
+int MHD_gnutls_x509_privkey_import_rsa_raw (MHD_gnutls_x509_privkey_t key,
+                                        const MHD_gnutls_datum_t * m,
+                                        const MHD_gnutls_datum_t * e,
+                                        const MHD_gnutls_datum_t * d,
+                                        const MHD_gnutls_datum_t * p,
+                                        const MHD_gnutls_datum_t * q,
+                                        const MHD_gnutls_datum_t * u);
+int MHD_gnutls_x509_privkey_export_rsa_raw (MHD_gnutls_x509_privkey_t key,
+                                        MHD_gnutls_datum_t * m,
+                                        MHD_gnutls_datum_t * e,
+                                        MHD_gnutls_datum_t * d,
+                                        MHD_gnutls_datum_t * p,
+                                        MHD_gnutls_datum_t * q,
+                                        MHD_gnutls_datum_t * u);
+int MHD_gnutls_x509_privkey_export (MHD_gnutls_x509_privkey_t key,
+                                MHD_gnutls_x509_crt_fmt_t format,
                                 void *output_data, size_t * output_data_size);
 
 #define GNUTLS_CRL_REASON_UNUSED 128
diff --git a/src/daemon/https/x509/x509_privkey.c b/src/daemon/https/x509/x509_privkey.c
index 3f168eac..e01861b8 100644
--- a/src/daemon/https/x509/x509_privkey.c
+++ b/src/daemon/https/x509/x509_privkey.c
@@ -39,8 +39,8 @@
 #include <dsa.h>
 #include <verify.h>
 
-static int _gnutls_asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params);
-int _gnutls_asn1_encode_dsa (ASN1_TYPE * c2, mpi_t * params);
+static int MHD__gnutlsMHD__asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params);
+int MHD__gnutlsMHD__asn1_encode_dsa (ASN1_TYPE * c2, mpi_t * params);
 
 /* remove this when libgcrypt can handle the PKCS #1 coefficients from
  * rsa keys
@@ -48,7 +48,7 @@ int _gnutls_asn1_encode_dsa (ASN1_TYPE * c2, mpi_t * params);
 #define CALC_COEFF 1
 
 /**
- * gnutls_x509_privkey_init - This function initializes a gnutls_crl structure
+ * MHD_gnutls_x509_privkey_init - This function initializes a MHD_gnutls_crl structure
  * @key: The structure to be initialized
  *
  * This function will initialize an private key structure.
@@ -57,9 +57,9 @@ int _gnutls_asn1_encode_dsa (ASN1_TYPE * c2, mpi_t * params);
  *
  **/
 int
-gnutls_x509_privkey_init (gnutls_x509_privkey_t * key)
+MHD_gnutls_x509_privkey_init (MHD_gnutls_x509_privkey_t * key)
 {
-  *key = gnutls_calloc (1, sizeof (gnutls_x509_privkey_int));
+  *key = MHD_gnutls_calloc (1, sizeof (MHD_gnutls_x509_privkey_int));
 
   if (*key)
     {
@@ -72,14 +72,14 @@ gnutls_x509_privkey_init (gnutls_x509_privkey_t * key)
 }
 
 /**
- * gnutls_x509_privkey_deinit - This function deinitializes memory used by a gnutls_x509_privkey_t structure
+ * MHD_gnutls_x509_privkey_deinit - This function deinitializes memory used by a MHD_gnutls_x509_privkey_t structure
  * @key: The structure to be initialized
  *
  * This function will deinitialize a private key structure.
  *
  **/
 void
-gnutls_x509_privkey_deinit (gnutls_x509_privkey_t key)
+MHD_gnutls_x509_privkey_deinit (MHD_gnutls_x509_privkey_t key)
 {
   int i;
 
@@ -88,15 +88,15 @@ gnutls_x509_privkey_deinit (gnutls_x509_privkey_t key)
 
   for (i = 0; i < key->params_size; i++)
     {
-      mhd_gtls_mpi_release (&key->params[i]);
+      MHD_gtls_mpi_release (&key->params[i]);
     }
 
-  asn1_delete_structure (&key->key);
-  gnutls_free (key);
+  MHD__asn1_delete_structure (&key->key);
+  MHD_gnutls_free (key);
 }
 
 /**
- * gnutls_x509_privkey_cpy - This function copies a private key
+ * MHD_gnutls_x509_privkey_cpy - This function copies a private key
  * @dst: The destination key, which should be initialized.
  * @src: The source key
  *
@@ -104,7 +104,7 @@ gnutls_x509_privkey_deinit (gnutls_x509_privkey_t key)
  *
  **/
 int
-gnutls_x509_privkey_cpy (gnutls_x509_privkey_t dst, gnutls_x509_privkey_t src)
+MHD_gnutls_x509_privkey_cpy (MHD_gnutls_x509_privkey_t dst, MHD_gnutls_x509_privkey_t src)
 {
   int i, ret;
 
@@ -113,7 +113,7 @@ gnutls_x509_privkey_cpy (gnutls_x509_privkey_t dst, gnutls_x509_privkey_t src)
 
   for (i = 0; i < src->params_size; i++)
     {
-      dst->params[i] = _gnutls_mpi_copy (src->params[i]);
+      dst->params[i] = MHD__gnutls_mpi_copy (src->params[i]);
       if (dst->params[i] == NULL)
         return GNUTLS_E_MEMORY_ERROR;
     }
@@ -127,15 +127,15 @@ gnutls_x509_privkey_cpy (gnutls_x509_privkey_t dst, gnutls_x509_privkey_t src)
       switch (dst->pk_algorithm)
         {
         case MHD_GNUTLS_PK_RSA:
-          ret = _gnutls_asn1_encode_rsa (&dst->key, dst->params);
+          ret = MHD__gnutlsMHD__asn1_encode_rsa (&dst->key, dst->params);
           if (ret < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               return ret;
             }
           break;
         default:
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return GNUTLS_E_INVALID_REQUEST;
         }
     }
@@ -144,69 +144,69 @@ gnutls_x509_privkey_cpy (gnutls_x509_privkey_t dst, gnutls_x509_privkey_t src)
 }
 
 /* Converts an RSA PKCS#1 key to
- * an internal structure (gnutls_private_key)
+ * an internal structure (MHD_gnutls_private_key)
  */
 ASN1_TYPE
-_gnutls_privkey_decode_pkcs1_rsa_key (const gnutls_datum_t * raw_key,
-                                      gnutls_x509_privkey_t pkey)
+MHD__gnutls_privkey_decode_pkcs1_rsa_key (const MHD_gnutls_datum_t * raw_key,
+                                      MHD_gnutls_x509_privkey_t pkey)
 {
   int result;
   ASN1_TYPE pkey_asn;
 
-  if ((result = asn1_create_element (_gnutls_get_gnutls_asn (),
+  if ((result = MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (),
                                      "GNUTLS.RSAPrivateKey",
                                      &pkey_asn)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return NULL;
     }
 
   if ((sizeof (pkey->params) / sizeof (mpi_t)) < RSA_PRIVATE_PARAMS)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       /* internal error. Increase the mpi_ts in params */
       return NULL;
     }
 
-  result = asn1_der_decoding (&pkey_asn, raw_key->data, raw_key->size, NULL);
+  result = MHD__asn1_der_decoding (&pkey_asn, raw_key->data, raw_key->size, NULL);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
 
-  if ((result = _gnutls_x509_read_int (pkey_asn, "modulus", &pkey->params[0]))
+  if ((result = MHD__gnutls_x509_read_int (pkey_asn, "modulus", &pkey->params[0]))
       < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
 
-  if ((result = _gnutls_x509_read_int (pkey_asn, "publicExponent",
+  if ((result = MHD__gnutls_x509_read_int (pkey_asn, "publicExponent",
                                        &pkey->params[1])) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
 
-  if ((result = _gnutls_x509_read_int (pkey_asn, "privateExponent",
+  if ((result = MHD__gnutls_x509_read_int (pkey_asn, "privateExponent",
                                        &pkey->params[2])) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
 
-  if ((result = _gnutls_x509_read_int (pkey_asn, "prime1", &pkey->params[3]))
+  if ((result = MHD__gnutls_x509_read_int (pkey_asn, "prime1", &pkey->params[3]))
       < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
 
-  if ((result = _gnutls_x509_read_int (pkey_asn, "prime2", &pkey->params[4]))
+  if ((result = MHD__gnutls_x509_read_int (pkey_asn, "prime2", &pkey->params[4]))
       < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
 
@@ -215,21 +215,21 @@ _gnutls_privkey_decode_pkcs1_rsa_key (const gnutls_datum_t * raw_key,
    * library is uses the p,q in the reverse order.
    */
   pkey->params[5] =
-    _gnutls_mpi_snew (_gnutls_mpi_get_nbits (pkey->params[0]));
+    MHD__gnutls_mpi_snew (MHD__gnutls_mpi_get_nbits (pkey->params[0]));
 
   if (pkey->params[5] == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
 
-  _gnutls_mpi_invm (pkey->params[5], pkey->params[3], pkey->params[4]);
+  MHD__gnutls_mpi_invm (pkey->params[5], pkey->params[3], pkey->params[4]);
   /* p, q */
 #else
-  if ((result = _gnutls_x509_read_int (pkey_asn, "coefficient",
+  if ((result = MHD__gnutls_x509_read_int (pkey_asn, "coefficient",
                                        &pkey->params[5])) < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto error;
     }
 #endif
@@ -237,13 +237,13 @@ _gnutls_privkey_decode_pkcs1_rsa_key (const gnutls_datum_t * raw_key,
 
   return pkey_asn;
 
-error:asn1_delete_structure (&pkey_asn);
-  mhd_gtls_mpi_release (&pkey->params[0]);
-  mhd_gtls_mpi_release (&pkey->params[1]);
-  mhd_gtls_mpi_release (&pkey->params[2]);
-  mhd_gtls_mpi_release (&pkey->params[3]);
-  mhd_gtls_mpi_release (&pkey->params[4]);
-  mhd_gtls_mpi_release (&pkey->params[5]);
+error:MHD__asn1_delete_structure (&pkey_asn);
+  MHD_gtls_mpi_release (&pkey->params[0]);
+  MHD_gtls_mpi_release (&pkey->params[1]);
+  MHD_gtls_mpi_release (&pkey->params[2]);
+  MHD_gtls_mpi_release (&pkey->params[3]);
+  MHD_gtls_mpi_release (&pkey->params[4]);
+  MHD_gtls_mpi_release (&pkey->params[5]);
   return NULL;
 
 }
@@ -251,13 +251,13 @@ error:asn1_delete_structure (&pkey_asn);
 #define PEM_KEY_RSA "RSA PRIVATE KEY"
 
 /**
- * gnutls_x509_privkey_import - This function will import a DER or PEM encoded key
+ * MHD_gnutls_x509_privkey_import - This function will import a DER or PEM encoded key
  * @key: The structure to store the parsed key
  * @data: The DER or PEM encoded certificate.
  * @format: One of DER or PEM
  *
  * This function will convert the given DER or PEM encoded key
- * to the native gnutls_x509_privkey_t format. The output will be stored in @key .
+ * to the native MHD_gnutls_x509_privkey_t format. The output will be stored in @key .
  *
  * If the key is PEM encoded it should have a header of "RSA PRIVATE KEY", or
  * "DSA PRIVATE KEY".
@@ -266,16 +266,16 @@ error:asn1_delete_structure (&pkey_asn);
  *
  **/
 int
-gnutls_x509_privkey_import (gnutls_x509_privkey_t key,
-                            const gnutls_datum_t * data,
-                            gnutls_x509_crt_fmt_t format)
+MHD_gnutls_x509_privkey_import (MHD_gnutls_x509_privkey_t key,
+                            const MHD_gnutls_datum_t * data,
+                            MHD_gnutls_x509_crt_fmt_t format)
 {
   int result = 0, need_free = 0;
-  gnutls_datum_t _data;
+  MHD_gnutls_datum_t _data;
 
   if (key == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -291,7 +291,7 @@ gnutls_x509_privkey_import (gnutls_x509_privkey_t key,
 
       /* Try the first header */
       result
-        = _gnutls_fbase64_decode (PEM_KEY_RSA, data->data, data->size, &out);
+        = MHD__gnutls_fbase64_decode (PEM_KEY_RSA, data->data, data->size, &out);
       key->pk_algorithm = MHD_GNUTLS_PK_RSA;
 
       _data.data = out;
@@ -302,15 +302,15 @@ gnutls_x509_privkey_import (gnutls_x509_privkey_t key,
 
   if (key->pk_algorithm == MHD_GNUTLS_PK_RSA)
     {
-      key->key = _gnutls_privkey_decode_pkcs1_rsa_key (&_data, key);
+      key->key = MHD__gnutls_privkey_decode_pkcs1_rsa_key (&_data, key);
       if (key->key == NULL)
-        gnutls_assert ();
+        MHD_gnutls_assert ();
     }
   else
     {
       /* Try decoding with both, and accept the one that succeeds. */
       key->pk_algorithm = MHD_GNUTLS_PK_RSA;
-      key->key = _gnutls_privkey_decode_pkcs1_rsa_key (&_data, key);
+      key->key = MHD__gnutls_privkey_decode_pkcs1_rsa_key (&_data, key);
 
       // TODO rm
 //      if (key->key == NULL)
@@ -318,20 +318,20 @@ gnutls_x509_privkey_import (gnutls_x509_privkey_t key,
 //          key->pk_algorithm = GNUTLS_PK_DSA;
 //          key->key = decode_dsa_key(&_data, key);
 //          if (key->key == NULL)
-//            gnutls_assert();
+//            MHD_gnutls_assert();
 //        }
     }
 
   if (key->key == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_ASN1_DER_ERROR;
       key->pk_algorithm = MHD_GNUTLS_PK_UNKNOWN;
       return result;
     }
 
   if (need_free)
-    _gnutls_free_datum (&_data);
+    MHD__gnutls_free_datum (&_data);
 
   /* The key has now been decoded.
    */
@@ -340,12 +340,12 @@ gnutls_x509_privkey_import (gnutls_x509_privkey_t key,
 }
 
 #define FREE_RSA_PRIVATE_PARAMS for (i=0;i<RSA_PRIVATE_PARAMS;i++) \
-                mhd_gtls_mpi_release(&key->params[i])
+                MHD_gtls_mpi_release(&key->params[i])
 #define FREE_DSA_PRIVATE_PARAMS for (i=0;i<DSA_PRIVATE_PARAMS;i++) \
-                mhd_gtls_mpi_release(&key->params[i])
+                MHD_gtls_mpi_release(&key->params[i])
 
 /**
- * gnutls_x509_privkey_import_rsa_raw - This function will import a raw RSA key
+ * MHD_gnutls_x509_privkey_import_rsa_raw - This function will import a raw RSA key
  * @key: The structure to store the parsed key
  * @m: holds the modulus
  * @e: holds the public exponent
@@ -355,83 +355,83 @@ gnutls_x509_privkey_import (gnutls_x509_privkey_t key,
  * @u: holds the coefficient
  *
  * This function will convert the given RSA raw parameters
- * to the native gnutls_x509_privkey_t format. The output will be stored in @key.
+ * to the native MHD_gnutls_x509_privkey_t format. The output will be stored in @key.
  *
  **/
 int
-gnutls_x509_privkey_import_rsa_raw (gnutls_x509_privkey_t key,
-                                    const gnutls_datum_t * m,
-                                    const gnutls_datum_t * e,
-                                    const gnutls_datum_t * d,
-                                    const gnutls_datum_t * p,
-                                    const gnutls_datum_t * q,
-                                    const gnutls_datum_t * u)
+MHD_gnutls_x509_privkey_import_rsa_raw (MHD_gnutls_x509_privkey_t key,
+                                    const MHD_gnutls_datum_t * m,
+                                    const MHD_gnutls_datum_t * e,
+                                    const MHD_gnutls_datum_t * d,
+                                    const MHD_gnutls_datum_t * p,
+                                    const MHD_gnutls_datum_t * q,
+                                    const MHD_gnutls_datum_t * u)
 {
   int i = 0, ret;
   size_t siz = 0;
 
   if (key == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   siz = m->size;
-  if (mhd_gtls_mpi_scan_nz (&key->params[0], m->data, &siz))
+  if (MHD_gtls_mpi_scan_nz (&key->params[0], m->data, &siz))
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       FREE_RSA_PRIVATE_PARAMS;
       return GNUTLS_E_MPI_SCAN_FAILED;
     }
 
   siz = e->size;
-  if (mhd_gtls_mpi_scan_nz (&key->params[1], e->data, &siz))
+  if (MHD_gtls_mpi_scan_nz (&key->params[1], e->data, &siz))
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       FREE_RSA_PRIVATE_PARAMS;
       return GNUTLS_E_MPI_SCAN_FAILED;
     }
 
   siz = d->size;
-  if (mhd_gtls_mpi_scan_nz (&key->params[2], d->data, &siz))
+  if (MHD_gtls_mpi_scan_nz (&key->params[2], d->data, &siz))
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       FREE_RSA_PRIVATE_PARAMS;
       return GNUTLS_E_MPI_SCAN_FAILED;
     }
 
   siz = p->size;
-  if (mhd_gtls_mpi_scan_nz (&key->params[3], p->data, &siz))
+  if (MHD_gtls_mpi_scan_nz (&key->params[3], p->data, &siz))
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       FREE_RSA_PRIVATE_PARAMS;
       return GNUTLS_E_MPI_SCAN_FAILED;
     }
 
   siz = q->size;
-  if (mhd_gtls_mpi_scan_nz (&key->params[4], q->data, &siz))
+  if (MHD_gtls_mpi_scan_nz (&key->params[4], q->data, &siz))
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       FREE_RSA_PRIVATE_PARAMS;
       return GNUTLS_E_MPI_SCAN_FAILED;
     }
 
 #ifdef CALC_COEFF
-  key->params[5] = _gnutls_mpi_snew (_gnutls_mpi_get_nbits (key->params[0]));
+  key->params[5] = MHD__gnutls_mpi_snew (MHD__gnutls_mpi_get_nbits (key->params[0]));
 
   if (key->params[5] == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       FREE_RSA_PRIVATE_PARAMS;
       return GNUTLS_E_MEMORY_ERROR;
     }
 
-  _gnutls_mpi_invm (key->params[5], key->params[3], key->params[4]);
+  MHD__gnutls_mpi_invm (key->params[5], key->params[3], key->params[4]);
 #else
   siz = u->size;
-  if (mhd_gtls_mpi_scan_nz (&key->params[5], u->data, &siz))
+  if (MHD_gtls_mpi_scan_nz (&key->params[5], u->data, &siz))
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       FREE_RSA_PRIVATE_PARAMS;
       return GNUTLS_E_MPI_SCAN_FAILED;
     }
@@ -439,10 +439,10 @@ gnutls_x509_privkey_import_rsa_raw (gnutls_x509_privkey_t key,
 
   if (!key->crippled)
     {
-      ret = _gnutls_asn1_encode_rsa (&key->key, key->params);
+      ret = MHD__gnutlsMHD__asn1_encode_rsa (&key->key, key->params);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           FREE_RSA_PRIVATE_PARAMS;
           return ret;
         }
@@ -456,8 +456,8 @@ gnutls_x509_privkey_import_rsa_raw (gnutls_x509_privkey_t key,
 }
 
 /**
- * gnutls_x509_privkey_get_pk_algorithm - This function returns the key's PublicKey algorithm
- * @key: should contain a gnutls_x509_privkey_t structure
+ * MHD_gnutls_x509_privkey_get_pk_algorithm - This function returns the key's PublicKey algorithm
+ * @key: should contain a MHD_gnutls_x509_privkey_t structure
  *
  * This function will return the public key algorithm of a private
  * key.
@@ -467,11 +467,11 @@ gnutls_x509_privkey_import_rsa_raw (gnutls_x509_privkey_t key,
  *
  **/
 int
-gnutls_x509_privkey_get_pk_algorithm (gnutls_x509_privkey_t key)
+MHD_gnutls_x509_privkey_get_pk_algorithm (MHD_gnutls_x509_privkey_t key)
 {
   if (key == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -481,7 +481,7 @@ gnutls_x509_privkey_get_pk_algorithm (gnutls_x509_privkey_t key)
 /* Encodes the RSA parameters into an ASN.1 RSA private key structure.
  */
 static int
-_gnutls_asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params)
+MHD__gnutlsMHD__asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params)
 {
   int result, i;
   size_t size[8], total;
@@ -495,77 +495,77 @@ _gnutls_asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params)
   total = 0;
   for (i = 0; i < 5; i++)
     {
-      mhd_gtls_mpi_print_lz (NULL, &size[i], params[i]);
+      MHD_gtls_mpi_print_lz (NULL, &size[i], params[i]);
       total += size[i];
     }
 
   /* Now generate exp1 and exp2
    */
-  exp1 = _gnutls_mpi_salloc_like (params[0]);   /* like modulus */
+  exp1 = MHD__gnutls_mpi_salloc_like (params[0]);   /* like modulus */
   if (exp1 == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_MEMORY_ERROR;
       goto cleanup;
     }
 
-  exp2 = _gnutls_mpi_salloc_like (params[0]);
+  exp2 = MHD__gnutls_mpi_salloc_like (params[0]);
   if (exp2 == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_MEMORY_ERROR;
       goto cleanup;
     }
 
-  q1 = _gnutls_mpi_salloc_like (params[4]);
+  q1 = MHD__gnutls_mpi_salloc_like (params[4]);
   if (q1 == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_MEMORY_ERROR;
       goto cleanup;
     }
 
-  p1 = _gnutls_mpi_salloc_like (params[3]);
+  p1 = MHD__gnutls_mpi_salloc_like (params[3]);
   if (p1 == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_MEMORY_ERROR;
       goto cleanup;
     }
 
-  u = _gnutls_mpi_salloc_like (params[3]);
+  u = MHD__gnutls_mpi_salloc_like (params[3]);
   if (u == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_MEMORY_ERROR;
       goto cleanup;
     }
 
-  _gnutls_mpi_invm (u, params[4], params[3]);
+  MHD__gnutls_mpi_invm (u, params[4], params[3]);
   /* inverse of q mod p */
-  mhd_gtls_mpi_print_lz (NULL, &size[5], u);
+  MHD_gtls_mpi_print_lz (NULL, &size[5], u);
   total += size[5];
 
-  _gnutls_mpi_sub_ui (p1, params[3], 1);
-  _gnutls_mpi_sub_ui (q1, params[4], 1);
+  MHD__gnutls_mpi_sub_ui (p1, params[3], 1);
+  MHD__gnutls_mpi_sub_ui (q1, params[4], 1);
 
-  _gnutls_mpi_mod (exp1, params[2], p1);
-  _gnutls_mpi_mod (exp2, params[2], q1);
+  MHD__gnutls_mpi_mod (exp1, params[2], p1);
+  MHD__gnutls_mpi_mod (exp2, params[2], q1);
 
   /* calculate exp's size */
-  mhd_gtls_mpi_print_lz (NULL, &size[6], exp1);
+  MHD_gtls_mpi_print_lz (NULL, &size[6], exp1);
   total += size[6];
 
-  mhd_gtls_mpi_print_lz (NULL, &size[7], exp2);
+  MHD_gtls_mpi_print_lz (NULL, &size[7], exp2);
   total += size[7];
 
   /* Encoding phase.
    * allocate data enough to hold everything
    */
-  all_data = gnutls_secure_malloc (total);
+  all_data = MHD_gnutls_secure_malloc (total);
   if (all_data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_MEMORY_ERROR;
       goto cleanup;
     }
@@ -587,124 +587,124 @@ _gnutls_asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params)
   p += size[6];
   exp2_data = p;
 
-  mhd_gtls_mpi_print_lz (m_data, &size[0], params[0]);
-  mhd_gtls_mpi_print_lz (pube_data, &size[1], params[1]);
-  mhd_gtls_mpi_print_lz (prie_data, &size[2], params[2]);
-  mhd_gtls_mpi_print_lz (p1_data, &size[3], params[3]);
-  mhd_gtls_mpi_print_lz (p2_data, &size[4], params[4]);
-  mhd_gtls_mpi_print_lz (u_data, &size[5], u);
-  mhd_gtls_mpi_print_lz (exp1_data, &size[6], exp1);
-  mhd_gtls_mpi_print_lz (exp2_data, &size[7], exp2);
+  MHD_gtls_mpi_print_lz (m_data, &size[0], params[0]);
+  MHD_gtls_mpi_print_lz (pube_data, &size[1], params[1]);
+  MHD_gtls_mpi_print_lz (prie_data, &size[2], params[2]);
+  MHD_gtls_mpi_print_lz (p1_data, &size[3], params[3]);
+  MHD_gtls_mpi_print_lz (p2_data, &size[4], params[4]);
+  MHD_gtls_mpi_print_lz (u_data, &size[5], u);
+  MHD_gtls_mpi_print_lz (exp1_data, &size[6], exp1);
+  MHD_gtls_mpi_print_lz (exp2_data, &size[7], exp2);
 
   /* Ok. Now we have the data. Create the asn1 structures
    */
 
   if ((result =
-       asn1_create_element (_gnutls_get_gnutls_asn (), "GNUTLS.RSAPrivateKey",
+       MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (), "GNUTLS.RSAPrivateKey",
                             c2)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   /* Write PRIME
    */
-  if ((result = asn1_write_value (*c2, "modulus", m_data, size[0]))
+  if ((result = MHD__asn1_write_value (*c2, "modulus", m_data, size[0]))
       != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  if ((result = asn1_write_value (*c2, "publicExponent", pube_data, size[1]))
+  if ((result = MHD__asn1_write_value (*c2, "publicExponent", pube_data, size[1]))
       != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  if ((result = asn1_write_value (*c2, "privateExponent", prie_data, size[2]))
+  if ((result = MHD__asn1_write_value (*c2, "privateExponent", prie_data, size[2]))
       != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  if ((result = asn1_write_value (*c2, "prime1", p1_data, size[3]))
+  if ((result = MHD__asn1_write_value (*c2, "prime1", p1_data, size[3]))
       != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  if ((result = asn1_write_value (*c2, "prime2", p2_data, size[4]))
+  if ((result = MHD__asn1_write_value (*c2, "prime2", p2_data, size[4]))
       != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  if ((result = asn1_write_value (*c2, "exponent1", exp1_data, size[6]))
+  if ((result = MHD__asn1_write_value (*c2, "exponent1", exp1_data, size[6]))
       != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  if ((result = asn1_write_value (*c2, "exponent2", exp2_data, size[7]))
+  if ((result = MHD__asn1_write_value (*c2, "exponent2", exp2_data, size[7]))
       != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  if ((result = asn1_write_value (*c2, "coefficient", u_data, size[5]))
+  if ((result = MHD__asn1_write_value (*c2, "coefficient", u_data, size[5]))
       != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  mhd_gtls_mpi_release (&exp1);
-  mhd_gtls_mpi_release (&exp2);
-  mhd_gtls_mpi_release (&q1);
-  mhd_gtls_mpi_release (&p1);
-  mhd_gtls_mpi_release (&u);
-  gnutls_free (all_data);
+  MHD_gtls_mpi_release (&exp1);
+  MHD_gtls_mpi_release (&exp2);
+  MHD_gtls_mpi_release (&q1);
+  MHD_gtls_mpi_release (&p1);
+  MHD_gtls_mpi_release (&u);
+  MHD_gnutls_free (all_data);
 
-  if ((result = asn1_write_value (*c2, "otherPrimeInfos",
+  if ((result = MHD__asn1_write_value (*c2, "otherPrimeInfos",
                                   NULL, 0)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  if ((result = asn1_write_value (*c2, "version", &null, 1)) != ASN1_SUCCESS)
+  if ((result = MHD__asn1_write_value (*c2, "version", &null, 1)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   return 0;
 
-cleanup:mhd_gtls_mpi_release (&u);
-  mhd_gtls_mpi_release (&exp1);
-  mhd_gtls_mpi_release (&exp2);
-  mhd_gtls_mpi_release (&q1);
-  mhd_gtls_mpi_release (&p1);
-  asn1_delete_structure (c2);
-  gnutls_free (all_data);
+cleanup:MHD_gtls_mpi_release (&u);
+  MHD_gtls_mpi_release (&exp1);
+  MHD_gtls_mpi_release (&exp2);
+  MHD_gtls_mpi_release (&q1);
+  MHD_gtls_mpi_release (&p1);
+  MHD__asn1_delete_structure (c2);
+  MHD_gnutls_free (all_data);
 
   return result;
 }
@@ -712,7 +712,7 @@ cleanup:mhd_gtls_mpi_release (&u);
 /* Encodes the DSA parameters into an ASN.1 DSAPrivateKey structure.
  */
 int
-_gnutls_asn1_encode_dsa (ASN1_TYPE * c2, mpi_t * params)
+MHD__gnutlsMHD__asn1_encode_dsa (ASN1_TYPE * c2, mpi_t * params)
 {
   int result, i;
   size_t size[DSA_PRIVATE_PARAMS], total;
@@ -724,17 +724,17 @@ _gnutls_asn1_encode_dsa (ASN1_TYPE * c2, mpi_t * params)
   total = 0;
   for (i = 0; i < DSA_PRIVATE_PARAMS; i++)
     {
-      mhd_gtls_mpi_print_lz (NULL, &size[i], params[i]);
+      MHD_gtls_mpi_print_lz (NULL, &size[i], params[i]);
       total += size[i];
     }
 
   /* Encoding phase.
    * allocate data enough to hold everything
    */
-  all_data = gnutls_secure_malloc (total);
+  all_data = MHD_gnutls_secure_malloc (total);
   if (all_data == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_MEMORY_ERROR;
       goto cleanup;
     }
@@ -750,82 +750,82 @@ _gnutls_asn1_encode_dsa (ASN1_TYPE * c2, mpi_t * params)
   p += size[3];
   x_data = p;
 
-  mhd_gtls_mpi_print_lz (p_data, &size[0], params[0]);
-  mhd_gtls_mpi_print_lz (q_data, &size[1], params[1]);
-  mhd_gtls_mpi_print_lz (g_data, &size[2], params[2]);
-  mhd_gtls_mpi_print_lz (y_data, &size[3], params[3]);
-  mhd_gtls_mpi_print_lz (x_data, &size[4], params[4]);
+  MHD_gtls_mpi_print_lz (p_data, &size[0], params[0]);
+  MHD_gtls_mpi_print_lz (q_data, &size[1], params[1]);
+  MHD_gtls_mpi_print_lz (g_data, &size[2], params[2]);
+  MHD_gtls_mpi_print_lz (y_data, &size[3], params[3]);
+  MHD_gtls_mpi_print_lz (x_data, &size[4], params[4]);
 
   /* Ok. Now we have the data. Create the asn1 structures
    */
 
   if ((result =
-       asn1_create_element (_gnutls_get_gnutls_asn (), "GNUTLS.DSAPrivateKey",
+       MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (), "GNUTLS.DSAPrivateKey",
                             c2)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   /* Write PRIME
    */
-  if ((result = asn1_write_value (*c2, "p", p_data, size[0])) != ASN1_SUCCESS)
+  if ((result = MHD__asn1_write_value (*c2, "p", p_data, size[0])) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  if ((result = asn1_write_value (*c2, "q", q_data, size[1])) != ASN1_SUCCESS)
+  if ((result = MHD__asn1_write_value (*c2, "q", q_data, size[1])) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  if ((result = asn1_write_value (*c2, "g", g_data, size[2])) != ASN1_SUCCESS)
+  if ((result = MHD__asn1_write_value (*c2, "g", g_data, size[2])) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  if ((result = asn1_write_value (*c2, "Y", y_data, size[3])) != ASN1_SUCCESS)
+  if ((result = MHD__asn1_write_value (*c2, "Y", y_data, size[3])) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   if ((result =
-       asn1_write_value (*c2, "priv", x_data, size[4])) != ASN1_SUCCESS)
+       MHD__asn1_write_value (*c2, "priv", x_data, size[4])) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  gnutls_free (all_data);
+  MHD_gnutls_free (all_data);
 
-  if ((result = asn1_write_value (*c2, "version", &null, 1)) != ASN1_SUCCESS)
+  if ((result = MHD__asn1_write_value (*c2, "version", &null, 1)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      result = mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
   return 0;
 
-cleanup:asn1_delete_structure (c2);
-  gnutls_free (all_data);
+cleanup:MHD__asn1_delete_structure (c2);
+  MHD_gnutls_free (all_data);
 
   return result;
 }
 
 /**
- * gnutls_x509_privkey_generate - This function will generate a private key
- * @key: should contain a gnutls_x509_privkey_t structure
+ * MHD_gnutls_x509_privkey_generate - This function will generate a private key
+ * @key: should contain a MHD_gnutls_x509_privkey_t structure
  * @algo: is one of RSA or DSA.
  * @bits: the size of the modulus
  * @flags: unused for now. Must be 0.
@@ -837,7 +837,7 @@ cleanup:asn1_delete_structure (c2);
  *
  **/
 int
-gnutls_x509_privkey_generate (gnutls_x509_privkey_t key,
+MHD_gnutls_x509_privkey_generate (MHD_gnutls_x509_privkey_t key,
                               enum MHD_GNUTLS_PublicKeyAlgorithm algo,
                               unsigned int bits, unsigned int flags)
 {
@@ -846,26 +846,26 @@ gnutls_x509_privkey_generate (gnutls_x509_privkey_t key,
 
   if (key == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   switch (algo)
     {
     case MHD_GNUTLS_PK_RSA:
-      ret = _gnutls_rsa_generate_params (key->params, &params_len, bits);
+      ret = MHD__gnutls_rsa_generate_params (key->params, &params_len, bits);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
 
       if (!key->crippled)
         {
-          ret = _gnutls_asn1_encode_rsa (&key->key, key->params);
+          ret = MHD__gnutlsMHD__asn1_encode_rsa (&key->key, key->params);
           if (ret < 0)
             {
-              gnutls_assert ();
+              MHD_gnutls_assert ();
               goto cleanup;
             }
         }
@@ -875,7 +875,7 @@ gnutls_x509_privkey_generate (gnutls_x509_privkey_t key,
 
       break;
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -884,13 +884,13 @@ gnutls_x509_privkey_generate (gnutls_x509_privkey_t key,
 cleanup:key->pk_algorithm = MHD_GNUTLS_PK_UNKNOWN;
   key->params_size = 0;
   for (i = 0; i < params_len; i++)
-    mhd_gtls_mpi_release (&key->params[i]);
+    MHD_gtls_mpi_release (&key->params[i]);
 
   return ret;
 }
 
 /**
- * gnutls_x509_privkey_get_key_id - Return unique ID of the key's parameters
+ * MHD_gnutls_x509_privkey_get_key_id - Return unique ID of the key's parameters
  * @key: Holds the key
  * @flags: should be 0 for now
  * @output_data: will contain the key ID
@@ -911,68 +911,68 @@ cleanup:key->pk_algorithm = MHD_GNUTLS_PK_UNKNOWN;
  *
  **/
 int
-gnutls_x509_privkey_get_key_id (gnutls_x509_privkey_t key,
+MHD_gnutls_x509_privkey_get_key_id (MHD_gnutls_x509_privkey_t key,
                                 unsigned int flags,
                                 unsigned char *output_data,
                                 size_t * output_data_size)
 {
   int result;
   GNUTLS_HASH_HANDLE hd;
-  gnutls_datum_t der = { NULL,
+  MHD_gnutls_datum_t der = { NULL,
     0
   };
 
   if (key == NULL || key->crippled)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   if (*output_data_size < 20)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       *output_data_size = 20;
       return GNUTLS_E_SHORT_MEMORY_BUFFER;
     }
 
   if (key->pk_algorithm == MHD_GNUTLS_PK_RSA)
     {
-      result = _gnutls_x509_write_rsa_params (key->params, key->params_size,
+      result = MHD__gnutls_x509_write_rsa_params (key->params, key->params_size,
                                               &der);
       if (result < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           goto cleanup;
         }
     }
   else
     return GNUTLS_E_INTERNAL_ERROR;
 
-  hd = mhd_gtls_hash_init (MHD_GNUTLS_MAC_SHA1);
+  hd = MHD_gtls_hash_init (MHD_GNUTLS_MAC_SHA1);
   if (hd == GNUTLS_HASH_FAILED)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       result = GNUTLS_E_INTERNAL_ERROR;
       goto cleanup;
     }
 
-  mhd_gnutls_hash (hd, der.data, der.size);
+  MHD_gnutls_hash (hd, der.data, der.size);
 
-  mhd_gnutls_hash_deinit (hd, output_data);
+  MHD_gnutls_hash_deinit (hd, output_data);
   *output_data_size = 20;
 
   result = 0;
 
 cleanup:
 
-  _gnutls_free_datum (&der);
+  MHD__gnutls_free_datum (&der);
   return result;
 }
 
 #ifdef ENABLE_PKI
 
 /**
- * gnutls_x509_privkey_sign_data - This function will sign the given data using the private key params
+ * MHD_gnutls_x509_privkey_sign_data - This function will sign the given data using the private key params
  * @key: Holds the key
  * @digest: should be MD5 or SHA1
  * @flags: should be 0 for now
@@ -995,45 +995,45 @@ cleanup:
  *
  **/
 int
-gnutls_x509_privkey_sign_data (gnutls_x509_privkey_t key,
+MHD_gnutls_x509_privkey_sign_data (MHD_gnutls_x509_privkey_t key,
                                enum MHD_GNUTLS_HashAlgorithm digest,
                                unsigned int flags,
-                               const gnutls_datum_t * data,
+                               const MHD_gnutls_datum_t * data,
                                void *signature, size_t * signature_size)
 {
   int result;
-  gnutls_datum_t sig = { NULL, 0 };
+  MHD_gnutls_datum_t sig = { NULL, 0 };
 
   if (key == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  result = _gnutls_x509_sign (data, digest, key, &sig);
+  result = MHD__gnutls_x509_sign (data, digest, key, &sig);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
   if (*signature_size < sig.size)
     {
       *signature_size = sig.size;
-      _gnutls_free_datum (&sig);
+      MHD__gnutls_free_datum (&sig);
       return GNUTLS_E_SHORT_MEMORY_BUFFER;
     }
 
   *signature_size = sig.size;
   memcpy (signature, sig.data, sig.size);
 
-  _gnutls_free_datum (&sig);
+  MHD__gnutls_free_datum (&sig);
 
   return 0;
 }
 
 /**
- * gnutls_x509_privkey_sign_hash - This function will sign the given data using the private key params
+ * MHD_gnutls_x509_privkey_sign_hash - This function will sign the given data using the private key params
  * @key: Holds the key
  * @hash: holds the data to be signed
  * @signature: will contain newly allocated signature
@@ -1044,23 +1044,23 @@ gnutls_x509_privkey_sign_data (gnutls_x509_privkey_t key,
  * and 0 on success.
  **/
 int
-gnutls_x509_privkey_sign_hash (gnutls_x509_privkey_t key,
-                               const gnutls_datum_t * hash,
-                               gnutls_datum_t * signature)
+MHD_gnutls_x509_privkey_sign_hash (MHD_gnutls_x509_privkey_t key,
+                               const MHD_gnutls_datum_t * hash,
+                               MHD_gnutls_datum_t * signature)
 {
   int result;
 
   if (key == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  result = mhd_gtls_sign (key->pk_algorithm, key->params,
+  result = MHD_gtls_sign (key->pk_algorithm, key->params,
                           key->params_size, hash, signature);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return result;
     }
 
@@ -1068,7 +1068,7 @@ gnutls_x509_privkey_sign_hash (gnutls_x509_privkey_t key,
 }
 
 /**
- * gnutls_x509_privkey_verify_data - This function will verify the given signed data.
+ * MHD_gnutls_x509_privkey_verify_data - This function will verify the given signed data.
  * @key: Holds the key
  * @flags: should be 0 for now
  * @data: holds the data to be signed
@@ -1082,23 +1082,23 @@ gnutls_x509_privkey_sign_hash (gnutls_x509_privkey_t key,
  *
  **/
 int
-gnutls_x509_privkey_verify_data (gnutls_x509_privkey_t key,
+MHD_gnutls_x509_privkey_verify_data (MHD_gnutls_x509_privkey_t key,
                                  unsigned int flags,
-                                 const gnutls_datum_t * data,
-                                 const gnutls_datum_t * signature)
+                                 const MHD_gnutls_datum_t * data,
+                                 const MHD_gnutls_datum_t * signature)
 {
   int result;
 
   if (key == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  result = _gnutls_x509_privkey_verify_signature (data, signature, key);
+  result = MHD__gnutls_x509_privkey_verify_signature (data, signature, key);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return 0;
     }
 
@@ -1106,7 +1106,7 @@ gnutls_x509_privkey_verify_data (gnutls_x509_privkey_t key,
 }
 
 /**
- * gnutls_x509_privkey_fix - This function will recalculate some parameters of the key.
+ * MHD_gnutls_x509_privkey_fix - This function will recalculate some parameters of the key.
  * @key: Holds the key
  *
  * This function will recalculate the secondary parameters in a key.
@@ -1117,30 +1117,30 @@ gnutls_x509_privkey_verify_data (gnutls_x509_privkey_t key,
  *
  **/
 int
-gnutls_x509_privkey_fix (gnutls_x509_privkey_t key)
+MHD_gnutls_x509_privkey_fix (MHD_gnutls_x509_privkey_t key)
 {
   int ret;
 
   if (key == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
   if (!key->crippled)
-    asn1_delete_structure (&key->key);
+    MHD__asn1_delete_structure (&key->key);
   switch (key->pk_algorithm)
     {
     case MHD_GNUTLS_PK_RSA:
-      ret = _gnutls_asn1_encode_rsa (&key->key, key->params);
+      ret = MHD__gnutlsMHD__asn1_encode_rsa (&key->key, key->params);
       if (ret < 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return ret;
         }
       break;
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
 
diff --git a/src/daemon/https/x509/x509_verify.c b/src/daemon/https/x509/x509_verify.c
index e9d784ce..cbeb7670 100644
--- a/src/daemon/https/x509/x509_verify.c
+++ b/src/daemon/https/x509/x509_verify.c
@@ -41,19 +41,19 @@
 #include <common.h>
 #include <verify.h>
 
-static int _gnutls_verify_certificate2 (gnutls_x509_crt_t cert,
-                                        const gnutls_x509_crt_t * trusted_cas,
+static int MHD__gnutls_verify_certificate2 (MHD_gnutls_x509_crt_t cert,
+                                        const MHD_gnutls_x509_crt_t * trusted_cas,
                                         int tcas_size,
                                         unsigned int flags,
                                         unsigned int *output);
-int _gnutls_x509_verify_signature (const gnutls_datum_t * signed_data,
-                                   const gnutls_datum_t * signature,
-                                   gnutls_x509_crt_t issuer);
+int MHD__gnutls_x509_verify_signature (const MHD_gnutls_datum_t * signed_data,
+                                   const MHD_gnutls_datum_t * signature,
+                                   MHD_gnutls_x509_crt_t issuer);
 
 static
-  int is_crl_issuer (gnutls_x509_crl_t crl, gnutls_x509_crt_t issuer_cert);
-static int _gnutls_verify_crl2 (gnutls_x509_crl_t crl,
-                                const gnutls_x509_crt_t * trusted_cas,
+  int is_crl_issuer (MHD_gnutls_x509_crl_t crl, MHD_gnutls_x509_crt_t issuer_cert);
+static int MHD__gnutls_verify_crl2 (MHD_gnutls_x509_crl_t crl,
+                                const MHD_gnutls_x509_crt_t * trusted_cas,
                                 int tcas_size,
                                 unsigned int flags, unsigned int *output);
 
@@ -65,19 +65,19 @@ static int _gnutls_verify_crl2 (gnutls_x509_crl_t crl,
  * or not.
  */
 static int
-check_if_ca (gnutls_x509_crt_t cert,
-             gnutls_x509_crt_t issuer, unsigned int flags)
+check_if_ca (MHD_gnutls_x509_crt_t cert,
+             MHD_gnutls_x509_crt_t issuer, unsigned int flags)
 {
-  gnutls_datum_t cert_signed_data = { NULL,
+  MHD_gnutls_datum_t cert_signed_data = { NULL,
     0
   };
-  gnutls_datum_t issuer_signed_data = { NULL,
+  MHD_gnutls_datum_t issuer_signed_data = { NULL,
     0
   };
-  gnutls_datum_t cert_signature = { NULL,
+  MHD_gnutls_datum_t cert_signature = { NULL,
     0
   };
-  gnutls_datum_t issuer_signature = { NULL,
+  MHD_gnutls_datum_t issuer_signature = { NULL,
     0
   };
   int result;
@@ -87,35 +87,35 @@ check_if_ca (gnutls_x509_crt_t cert,
    * certificates to be able to verify themselves.
    */
 
-  result = _gnutls_x509_get_signed_data (issuer->cert, "tbsCertificate",
+  result = MHD__gnutls_x509_get_signed_data (issuer->cert, "tbsCertificate",
                                          &issuer_signed_data);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  result = _gnutls_x509_get_signed_data (cert->cert, "tbsCertificate",
+  result = MHD__gnutls_x509_get_signed_data (cert->cert, "tbsCertificate",
                                          &cert_signed_data);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  result = _gnutls_x509_get_signature (issuer->cert, "signature",
+  result = MHD__gnutls_x509_get_signature (issuer->cert, "signature",
                                        &issuer_signature);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
   result =
-    _gnutls_x509_get_signature (cert->cert, "signature", &cert_signature);
+    MHD__gnutls_x509_get_signature (cert->cert, "signature", &cert_signature);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
@@ -139,20 +139,20 @@ check_if_ca (gnutls_x509_crt_t cert,
           }
       }
 
-  if (gnutls_x509_crt_get_ca_status (issuer, NULL) == 1)
+  if (MHD_gnutls_x509_crt_get_ca_status (issuer, NULL) == 1)
     {
       result = 1;
       goto cleanup;
     }
   else
-    gnutls_assert ();
+    MHD_gnutls_assert ();
 
   result = 0;
 
-cleanup:_gnutls_free_datum (&cert_signed_data);
-  _gnutls_free_datum (&issuer_signed_data);
-  _gnutls_free_datum (&cert_signature);
-  _gnutls_free_datum (&issuer_signature);
+cleanup:MHD__gnutls_free_datum (&cert_signed_data);
+  MHD__gnutls_free_datum (&issuer_signed_data);
+  MHD__gnutls_free_datum (&cert_signature);
+  MHD__gnutls_free_datum (&issuer_signature);
   return result;
 }
 
@@ -164,40 +164,40 @@ cleanup:_gnutls_free_datum (&cert_signed_data);
  * a negative value is returned to indicate error.
  */
 static int
-is_issuer (gnutls_x509_crt_t cert, gnutls_x509_crt_t issuer_cert)
+is_issuer (MHD_gnutls_x509_crt_t cert, MHD_gnutls_x509_crt_t issuer_cert)
 {
-  gnutls_datum_t dn1 = { NULL,
+  MHD_gnutls_datum_t dn1 = { NULL,
     0
   }, dn2 =
   {
   NULL, 0};
   int ret;
 
-  ret = gnutls_x509_crt_get_raw_issuer_dn (cert, &dn1);
+  ret = MHD_gnutls_x509_crt_get_raw_issuer_dn (cert, &dn1);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  ret = gnutls_x509_crt_get_raw_dn (issuer_cert, &dn2);
+  ret = MHD_gnutls_x509_crt_get_raw_dn (issuer_cert, &dn2);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  ret = _gnutls_x509_compare_raw_dn (&dn1, &dn2);
+  ret = MHD__gnutls_x509_compare_raw_dn (&dn1, &dn2);
 
-cleanup:_gnutls_free_datum (&dn1);
-  _gnutls_free_datum (&dn2);
+cleanup:MHD__gnutls_free_datum (&dn1);
+  MHD__gnutls_free_datum (&dn2);
   return ret;
 
 }
 
-static inline gnutls_x509_crt_t
-find_issuer (gnutls_x509_crt_t cert,
-             const gnutls_x509_crt_t * trusted_cas, int tcas_size)
+static inline MHD_gnutls_x509_crt_t
+find_issuer (MHD_gnutls_x509_crt_t cert,
+             const MHD_gnutls_x509_crt_t * trusted_cas, int tcas_size)
 {
   int i;
 
@@ -210,7 +210,7 @@ find_issuer (gnutls_x509_crt_t cert,
         return trusted_cas[i];
     }
 
-  gnutls_assert ();
+  MHD_gnutls_assert ();
   return NULL;
 }
 
@@ -221,24 +221,24 @@ find_issuer (gnutls_x509_crt_t cert,
  * Returns only 0 or 1. If 1 it means that the certificate
  * was successfuly verified.
  *
- * 'flags': an OR of the gnutls_certificate_verify_flags enumeration.
+ * 'flags': an OR of the MHD_gnutls_certificate_verify_flags enumeration.
  *
  * Output will hold some extra information about the verification
  * procedure.
  */
 static int
-_gnutls_verify_certificate2 (gnutls_x509_crt_t cert,
-                             const gnutls_x509_crt_t * trusted_cas,
+MHD__gnutls_verify_certificate2 (MHD_gnutls_x509_crt_t cert,
+                             const MHD_gnutls_x509_crt_t * trusted_cas,
                              int tcas_size,
                              unsigned int flags, unsigned int *output)
 {
-  gnutls_datum_t cert_signed_data = { NULL,
+  MHD_gnutls_datum_t cert_signed_data = { NULL,
     0
   };
-  gnutls_datum_t cert_signature = { NULL,
+  MHD_gnutls_datum_t cert_signature = { NULL,
     0
   };
-  gnutls_x509_crt_t issuer;
+  MHD_gnutls_x509_crt_t issuer;
   int ret, issuer_version, result;
 
   if (output)
@@ -248,7 +248,7 @@ _gnutls_verify_certificate2 (gnutls_x509_crt_t cert,
     issuer = find_issuer (cert, trusted_cas, tcas_size);
   else
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       if (output)
         *output |= GNUTLS_CERT_SIGNER_NOT_FOUND | GNUTLS_CERT_INVALID;
       return 0;
@@ -261,14 +261,14 @@ _gnutls_verify_certificate2 (gnutls_x509_crt_t cert,
     {
       if (output)
         *output |= GNUTLS_CERT_SIGNER_NOT_FOUND | GNUTLS_CERT_INVALID;
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return 0;
     }
 
-  issuer_version = gnutls_x509_crt_get_version (issuer);
+  issuer_version = MHD_gnutls_x509_crt_get_version (issuer);
   if (issuer_version < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return issuer_version;
     }
 
@@ -279,38 +279,38 @@ _gnutls_verify_certificate2 (gnutls_x509_crt_t cert,
     {
       if (check_if_ca (cert, issuer, flags) == 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           if (output)
             *output |= GNUTLS_CERT_SIGNER_NOT_CA | GNUTLS_CERT_INVALID;
           return 0;
         }
     }
 
-  result = _gnutls_x509_get_signed_data (cert->cert, "tbsCertificate",
+  result = MHD__gnutls_x509_get_signed_data (cert->cert, "tbsCertificate",
                                          &cert_signed_data);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
   result =
-    _gnutls_x509_get_signature (cert->cert, "signature", &cert_signature);
+    MHD__gnutls_x509_get_signature (cert->cert, "signature", &cert_signature);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  ret = _gnutls_x509_verify_signature (&cert_signed_data, &cert_signature,
+  ret = MHD__gnutls_x509_verify_signature (&cert_signed_data, &cert_signature,
                                        issuer);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
     }
   else if (ret == 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       /* error. ignore it */
       if (output)
         *output |= GNUTLS_CERT_INVALID;
@@ -325,7 +325,7 @@ _gnutls_verify_certificate2 (gnutls_x509_crt_t cert,
     {
       int sigalg;
 
-      sigalg = gnutls_x509_crt_get_signature_algorithm (cert);
+      sigalg = MHD_gnutls_x509_crt_get_signature_algorithm (cert);
 
       if (((sigalg == GNUTLS_SIGN_RSA_MD2) && !(flags
                                                 &
@@ -340,14 +340,14 @@ _gnutls_verify_certificate2 (gnutls_x509_crt_t cert,
 
   result = ret;
 
-cleanup:_gnutls_free_datum (&cert_signed_data);
-  _gnutls_free_datum (&cert_signature);
+cleanup:MHD__gnutls_free_datum (&cert_signed_data);
+  MHD__gnutls_free_datum (&cert_signature);
 
   return result;
 }
 
 /**
- * gnutls_x509_crt_check_issuer - This function checks if the certificate given has the given issuer
+ * MHD_gnutls_x509_crt_check_issuer - This function checks if the certificate given has the given issuer
  * @cert: is the certificate to be checked
  * @issuer: is the certificate of a possible issuer
  *
@@ -359,8 +359,8 @@ cleanup:_gnutls_free_datum (&cert_signed_data);
  *
  **/
 int
-gnutls_x509_crt_check_issuer (gnutls_x509_crt_t cert,
-                              gnutls_x509_crt_t issuer)
+MHD_gnutls_x509_crt_check_issuer (MHD_gnutls_x509_crt_t cert,
+                              MHD_gnutls_x509_crt_t issuer)
 {
   return is_issuer (cert, issuer);
 }
@@ -377,11 +377,11 @@ gnutls_x509_crt_check_issuer (gnutls_x509_crt_t cert,
  * lead to a trusted CA in order to be trusted.
  */
 static unsigned int
-_gnutls_x509_verify_certificate (const gnutls_x509_crt_t * certificate_list,
+MHD__gnutls_x509_verify_certificate (const MHD_gnutls_x509_crt_t * certificate_list,
                                  int clist_size,
-                                 const gnutls_x509_crt_t * trusted_cas,
+                                 const MHD_gnutls_x509_crt_t * trusted_cas,
                                  int tcas_size,
-                                 const gnutls_x509_crl_t * CRLs,
+                                 const MHD_gnutls_x509_crl_t * CRLs,
                                  int crls_size, unsigned int flags)
 {
   int i = 0, ret;
@@ -393,7 +393,7 @@ _gnutls_x509_verify_certificate (const gnutls_x509_crt_t * certificate_list,
    * If no CAs are present returns CERT_INVALID. Thus works
    * in self signed etc certificates.
    */
-  ret = _gnutls_verify_certificate2 (certificate_list[clist_size - 1],
+  ret = MHD__gnutls_verify_certificate2 (certificate_list[clist_size - 1],
                                      trusted_cas, tcas_size, flags, &output);
 
   if (ret == 0)
@@ -402,7 +402,7 @@ _gnutls_x509_verify_certificate (const gnutls_x509_crt_t * certificate_list,
        * list is invalid, then the certificate is not
        * trusted.
        */
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       status |= output;
       status |= GNUTLS_CERT_INVALID;
       return status;
@@ -413,7 +413,7 @@ _gnutls_x509_verify_certificate (const gnutls_x509_crt_t * certificate_list,
 #ifdef ENABLE_PKI
   for (i = 0; i < clist_size; i++)
     {
-      ret = gnutls_x509_crt_check_revocation (certificate_list[i],
+      ret = MHD_gnutls_x509_crt_check_revocation (certificate_list[i],
                                               CRLs, crls_size);
       if (ret == 1)
         {                       /* revoked */
@@ -428,7 +428,7 @@ _gnutls_x509_verify_certificate (const gnutls_x509_crt_t * certificate_list,
    * In that case ignore it (a certificate is trusted only if it
    * leads to a trusted party by us, not the server's).
    */
-  if (gnutls_x509_crt_check_issuer (certificate_list[clist_size - 1],
+  if (MHD_gnutls_x509_crt_check_issuer (certificate_list[clist_size - 1],
                                     certificate_list[clist_size - 1]) > 0
       && clist_size > 0)
     {
@@ -447,7 +447,7 @@ _gnutls_x509_verify_certificate (const gnutls_x509_crt_t * certificate_list,
        */
       if (!(flags & GNUTLS_VERIFY_ALLOW_ANY_X509_V1_CA_CRT))
         flags ^= GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT;
-      if ((ret = _gnutls_verify_certificate2 (certificate_list[i - 1],
+      if ((ret = MHD__gnutls_verify_certificate2 (certificate_list[i - 1],
                                               &certificate_list[i], 1, flags,
                                               NULL)) == 0)
         {
@@ -464,7 +464,7 @@ _gnutls_x509_verify_certificate (const gnutls_x509_crt_t * certificate_list,
  * anyway.
  */
 static int
-decode_ber_digest_info (const gnutls_datum_t * info,
+decode_ber_digest_info (const MHD_gnutls_datum_t * info,
                         enum MHD_GNUTLS_HashAlgorithm *hash,
                         opaque * digest, int *digest_size)
 {
@@ -473,45 +473,45 @@ decode_ber_digest_info (const gnutls_datum_t * info,
   char str[1024];
   int len;
 
-  if ((result = asn1_create_element (_gnutls_get_gnutls_asn (),
+  if ((result = MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (),
                                      "GNUTLS.DigestInfo",
                                      &dinfo)) != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      return MHD_gtls_asn2err (result);
     }
 
-  result = asn1_der_decoding (&dinfo, info->data, info->size, NULL);
+  result = MHD__asn1_der_decoding (&dinfo, info->data, info->size, NULL);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&dinfo);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&dinfo);
+      return MHD_gtls_asn2err (result);
     }
 
   len = sizeof (str) - 1;
-  result = asn1_read_value (dinfo, "digestAlgorithm.algorithm", str, &len);
+  result = MHD__asn1_read_value (dinfo, "digestAlgorithm.algorithm", str, &len);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&dinfo);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&dinfo);
+      return MHD_gtls_asn2err (result);
     }
 
-  *hash = mhd_gtls_x509_oid2mac_algorithm (str);
+  *hash = MHD_gtls_x509_oid2mac_algorithm (str);
 
   if (*hash == MHD_GNUTLS_MAC_UNKNOWN)
     {
 
-      _gnutls_x509_log ("verify.c: HASH OID: %s\n", str);
+      MHD__gnutls_x509_log ("verify.c: HASH OID: %s\n", str);
 
-      gnutls_assert ();
-      asn1_delete_structure (&dinfo);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&dinfo);
       return GNUTLS_E_UNKNOWN_ALGORITHM;
     }
 
   len = sizeof (str) - 1;
-  result = asn1_read_value (dinfo, "digestAlgorithm.parameters", str, &len);
+  result = MHD__asn1_read_value (dinfo, "digestAlgorithm.parameters", str, &len);
   /* To avoid permitting garbage in the parameters field, either the
      parameters field is not present, or it contains 0x05 0x00. */
   if (!
@@ -519,20 +519,20 @@ decode_ber_digest_info (const gnutls_datum_t * info,
        || (result == ASN1_SUCCESS && len == 2 && str[0] == 0x05
            && str[1] == 0x00)))
     {
-      gnutls_assert ();
-      asn1_delete_structure (&dinfo);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&dinfo);
       return GNUTLS_E_ASN1_GENERIC_ERROR;
     }
 
-  result = asn1_read_value (dinfo, "digest", digest, digest_size);
+  result = MHD__asn1_read_value (dinfo, "digest", digest, digest_size);
   if (result != ASN1_SUCCESS)
     {
-      gnutls_assert ();
-      asn1_delete_structure (&dinfo);
-      return mhd_gtls_asn2err (result);
+      MHD_gnutls_assert ();
+      MHD__asn1_delete_structure (&dinfo);
+      return MHD_gtls_asn2err (result);
     }
 
-  asn1_delete_structure (&dinfo);
+  MHD__asn1_delete_structure (&dinfo);
 
   return 0;
 }
@@ -543,8 +543,8 @@ decode_ber_digest_info (const gnutls_datum_t * info,
  * params[1] is public key
  */
 static int
-_pkcs1_rsa_verify_sig (const gnutls_datum_t * text,
-                       const gnutls_datum_t * signature,
+_pkcs1_rsa_verify_sig (const MHD_gnutls_datum_t * text,
+                       const MHD_gnutls_datum_t * signature,
                        mpi_t * params, int params_len)
 {
   enum MHD_GNUTLS_HashAlgorithm hash = MHD_GNUTLS_MAC_UNKNOWN;
@@ -552,13 +552,13 @@ _pkcs1_rsa_verify_sig (const gnutls_datum_t * text,
   opaque digest[MAX_HASH_SIZE], md[MAX_HASH_SIZE];
   int digest_size;
   GNUTLS_HASH_HANDLE hd;
-  gnutls_datum_t decrypted;
+  MHD_gnutls_datum_t decrypted;
 
   ret =
-    mhd_gtls_pkcs1_rsa_decrypt (&decrypted, signature, params, params_len, 1);
+    MHD_gtls_pkcs1_rsa_decrypt (&decrypted, signature, params, params_len, 1);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -569,32 +569,32 @@ _pkcs1_rsa_verify_sig (const gnutls_datum_t * text,
   if ((ret = decode_ber_digest_info (&decrypted, &hash, digest, &digest_size))
       != 0)
     {
-      gnutls_assert ();
-      _gnutls_free_datum (&decrypted);
+      MHD_gnutls_assert ();
+      MHD__gnutls_free_datum (&decrypted);
       return ret;
     }
 
-  _gnutls_free_datum (&decrypted);
+  MHD__gnutls_free_datum (&decrypted);
 
-  if (digest_size != mhd_gnutls_hash_get_algo_len (hash))
+  if (digest_size != MHD_gnutls_hash_get_algo_len (hash))
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_ASN1_GENERIC_ERROR;
     }
 
-  hd = mhd_gtls_hash_init (hash);
+  hd = MHD_gtls_hash_init (hash);
   if (hd == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_HASH_FAILED;
     }
 
-  mhd_gnutls_hash (hd, text->data, text->size);
-  mhd_gnutls_hash_deinit (hd, md);
+  MHD_gnutls_hash (hd, text->data, text->size);
+  MHD_gnutls_hash_deinit (hd, md);
 
   if (memcmp (md, digest, digest_size) != 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_PK_SIG_VERIFY_FAILED;
     }
 
@@ -604,29 +604,29 @@ _pkcs1_rsa_verify_sig (const gnutls_datum_t * text,
 /* Hashes input data and verifies a DSA signature.
  */
 static int
-dsa_verify_sig (const gnutls_datum_t * text,
-                const gnutls_datum_t * signature,
+dsa_verify_sig (const MHD_gnutls_datum_t * text,
+                const MHD_gnutls_datum_t * signature,
                 mpi_t * params, int params_len)
 {
   int ret;
   opaque _digest[MAX_HASH_SIZE];
-  gnutls_datum_t digest;
+  MHD_gnutls_datum_t digest;
   GNUTLS_HASH_HANDLE hd;
 
-  hd = mhd_gtls_hash_init (MHD_GNUTLS_MAC_SHA1);
+  hd = MHD_gtls_hash_init (MHD_GNUTLS_MAC_SHA1);
   if (hd == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_HASH_FAILED;
     }
 
-  mhd_gnutls_hash (hd, text->data, text->size);
-  mhd_gnutls_hash_deinit (hd, _digest);
+  MHD_gnutls_hash (hd, text->data, text->size);
+  MHD_gnutls_hash_deinit (hd, _digest);
 
   digest.data = _digest;
   digest.size = 20;
 
-  ret = mhd_gtls_dsa_verify (&digest, signature, params, params_len);
+  ret = MHD_gtls_dsa_verify (&digest, signature, params, params_len);
 
   return ret;
 }
@@ -635,8 +635,8 @@ dsa_verify_sig (const gnutls_datum_t * text,
  * or 1 otherwise.
  */
 static int
-verify_sig (const gnutls_datum_t * tbs,
-            const gnutls_datum_t * signature,
+verify_sig (const MHD_gnutls_datum_t * tbs,
+            const MHD_gnutls_datum_t * signature,
             enum MHD_GNUTLS_PublicKeyAlgorithm pk,
             mpi_t * issuer_params, int issuer_params_size)
 {
@@ -648,7 +648,7 @@ verify_sig (const gnutls_datum_t * tbs,
       if (_pkcs1_rsa_verify_sig
           (tbs, signature, issuer_params, issuer_params_size) != 0)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           return 0;
         }
 
@@ -656,7 +656,7 @@ verify_sig (const gnutls_datum_t * tbs,
       break;
 
     default:
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
 
     }
@@ -669,9 +669,9 @@ verify_sig (const gnutls_datum_t * tbs,
  * 'signature' is the signature!
  */
 int
-_gnutls_x509_verify_signature (const gnutls_datum_t * tbs,
-                               const gnutls_datum_t * signature,
-                               gnutls_x509_crt_t issuer)
+MHD__gnutls_x509_verify_signature (const MHD_gnutls_datum_t * tbs,
+                               const MHD_gnutls_datum_t * signature,
+                               MHD_gnutls_x509_crt_t issuer)
 {
   mpi_t issuer_params[MAX_PUBLIC_PARAMS_SIZE];
   int ret, issuer_params_size, i;
@@ -680,26 +680,26 @@ _gnutls_x509_verify_signature (const gnutls_datum_t * tbs,
    */
   issuer_params_size = MAX_PUBLIC_PARAMS_SIZE;
   ret =
-    _gnutls_x509_crt_get_mpis (issuer, issuer_params, &issuer_params_size);
+    MHD__gnutls_x509_crt_get_mpis (issuer, issuer_params, &issuer_params_size);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  ret = verify_sig (tbs, signature, gnutls_x509_crt_get_pk_algorithm (issuer,
+  ret = verify_sig (tbs, signature, MHD_gnutls_x509_crt_get_pk_algorithm (issuer,
                                                                       NULL),
                     issuer_params, issuer_params_size);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
     }
 
   /* release all allocated MPIs
    */
   for (i = 0; i < issuer_params_size; i++)
     {
-      mhd_gtls_mpi_release (&issuer_params[i]);
+      MHD_gtls_mpi_release (&issuer_params[i]);
     }
 
   return ret;
@@ -712,9 +712,9 @@ _gnutls_x509_verify_signature (const gnutls_datum_t * tbs,
  * 'signature' is the signature!
  */
 int
-_gnutls_x509_privkey_verify_signature (const gnutls_datum_t * tbs,
-                                       const gnutls_datum_t * signature,
-                                       gnutls_x509_privkey_t issuer)
+MHD__gnutls_x509_privkey_verify_signature (const MHD_gnutls_datum_t * tbs,
+                                       const MHD_gnutls_datum_t * signature,
+                                       MHD_gnutls_x509_privkey_t issuer)
 {
   int ret;
 
@@ -722,21 +722,21 @@ _gnutls_x509_privkey_verify_signature (const gnutls_datum_t * tbs,
                     issuer->params_size);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
     }
 
   return ret;
 }
 
 /**
- * gnutls_x509_crt_list_verify - This function verifies the given certificate list
+ * MHD_gnutls_x509_crt_list_verify - This function verifies the given certificate list
  * @cert_list: is the certificate list to be verified
  * @cert_list_length: holds the number of certificate in cert_list
  * @CA_list: is the CA list which will be used in verification
  * @CA_list_length: holds the number of CA certificate in CA_list
  * @CRL_list: holds a list of CRLs.
  * @CRL_list_length: the length of CRL list.
- * @flags: Flags that may be used to change the verification algorithm. Use OR of the gnutls_certificate_verify_flags enumerations.
+ * @flags: Flags that may be used to change the verification algorithm. Use OR of the MHD_gnutls_certificate_verify_flags enumerations.
  * @verify: will hold the certificate verification output.
  *
  * This function will try to verify the given certificate list and return its status.
@@ -751,8 +751,8 @@ _gnutls_x509_privkey_verify_signature (const gnutls_datum_t * tbs,
  * certificate belongs to the actual peer.
  *
  * The certificate verification output will be put in @verify and will be
- * one or more of the gnutls_certificate_status_t enumerated elements bitwise or'd.
- * For a more detailed verification status use gnutls_x509_crt_verify() per list
+ * one or more of the MHD_gnutls_certificate_status_t enumerated elements bitwise or'd.
+ * For a more detailed verification status use MHD_gnutls_x509_crt_verify() per list
  * element.
  *
  * GNUTLS_CERT_INVALID: the certificate chain is not valid.
@@ -763,11 +763,11 @@ _gnutls_x509_privkey_verify_signature (const gnutls_datum_t * tbs,
  *
  **/
 int
-gnutls_x509_crt_list_verify (const gnutls_x509_crt_t * cert_list,
+MHD_gnutls_x509_crt_list_verify (const MHD_gnutls_x509_crt_t * cert_list,
                              int cert_list_length,
-                             const gnutls_x509_crt_t * CA_list,
+                             const MHD_gnutls_x509_crt_t * CA_list,
                              int CA_list_length,
-                             const gnutls_x509_crl_t * CRL_list,
+                             const MHD_gnutls_x509_crl_t * CRL_list,
                              int CRL_list_length,
                              unsigned int flags, unsigned int *verify)
 {
@@ -776,7 +776,7 @@ gnutls_x509_crt_list_verify (const gnutls_x509_crt_t * cert_list,
 
   /* Verify certificate
    */
-  *verify = _gnutls_x509_verify_certificate (cert_list, cert_list_length,
+  *verify = MHD__gnutls_x509_verify_certificate (cert_list, cert_list_length,
                                              CA_list, CA_list_length,
                                              CRL_list, CRL_list_length,
                                              flags);
@@ -785,11 +785,11 @@ gnutls_x509_crt_list_verify (const gnutls_x509_crt_t * cert_list,
 }
 
 /**
- * gnutls_x509_crt_verify - This function verifies the given certificate against a given trusted one
+ * MHD_gnutls_x509_crt_verify - This function verifies the given certificate against a given trusted one
  * @cert: is the certificate to be verified
  * @CA_list: is one certificate that is considered to be trusted one
  * @CA_list_length: holds the number of CA certificate in CA_list
- * @flags: Flags that may be used to change the verification algorithm. Use OR of the gnutls_certificate_verify_flags enumerations.
+ * @flags: Flags that may be used to change the verification algorithm. Use OR of the MHD_gnutls_certificate_verify_flags enumerations.
  * @verify: will hold the certificate verification output.
  *
  * This function will try to verify the given certificate and return its status.
@@ -799,19 +799,19 @@ gnutls_x509_crt_list_verify (const gnutls_x509_crt_t * cert_list,
  *
  **/
 int
-gnutls_x509_crt_verify (gnutls_x509_crt_t cert,
-                        const gnutls_x509_crt_t * CA_list,
+MHD_gnutls_x509_crt_verify (MHD_gnutls_x509_crt_t cert,
+                        const MHD_gnutls_x509_crt_t * CA_list,
                         int CA_list_length,
                         unsigned int flags, unsigned int *verify)
 {
   int ret;
   /* Verify certificate
    */
-  ret = _gnutls_verify_certificate2 (cert, CA_list, CA_list_length, flags,
+  ret = MHD__gnutls_verify_certificate2 (cert, CA_list, CA_list_length, flags,
                                      verify);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -821,7 +821,7 @@ gnutls_x509_crt_verify (gnutls_x509_crt_t cert,
 #ifdef ENABLE_PKI
 
 /**
- * gnutls_x509_crl_check_issuer - This function checks if the CRL given has the given issuer
+ * MHD_gnutls_x509_crl_check_issuer - This function checks if the CRL given has the given issuer
  * @crl: is the CRL to be checked
  * @issuer: is the certificate of a possible issuer
  *
@@ -833,40 +833,40 @@ gnutls_x509_crt_verify (gnutls_x509_crt_t cert,
  *
  **/
 int
-gnutls_x509_crl_check_issuer (gnutls_x509_crl_t cert,
-                              gnutls_x509_crt_t issuer)
+MHD_gnutls_x509_crl_check_issuer (MHD_gnutls_x509_crl_t cert,
+                              MHD_gnutls_x509_crt_t issuer)
 {
   return is_crl_issuer (cert, issuer);
 }
 
 /**
- * gnutls_x509_crl_verify - This function verifies the given crl against a given trusted one
+ * MHD_gnutls_x509_crl_verify - This function verifies the given crl against a given trusted one
  * @crl: is the crl to be verified
  * @CA_list: is a certificate list that is considered to be trusted one
  * @CA_list_length: holds the number of CA certificates in CA_list
- * @flags: Flags that may be used to change the verification algorithm. Use OR of the gnutls_certificate_verify_flags enumerations.
+ * @flags: Flags that may be used to change the verification algorithm. Use OR of the MHD_gnutls_certificate_verify_flags enumerations.
  * @verify: will hold the crl verification output.
  *
  * This function will try to verify the given crl and return its status.
- * See gnutls_x509_crt_list_verify() for a detailed description of
+ * See MHD_gnutls_x509_crt_list_verify() for a detailed description of
  * return values.
  *
  * Returns 0 on success and a negative value in case of an error.
  *
  **/
 int
-gnutls_x509_crl_verify (gnutls_x509_crl_t crl,
-                        const gnutls_x509_crt_t * CA_list,
+MHD_gnutls_x509_crl_verify (MHD_gnutls_x509_crl_t crl,
+                        const MHD_gnutls_x509_crt_t * CA_list,
                         int CA_list_length, unsigned int flags,
                         unsigned int *verify)
 {
   int ret;
   /* Verify crl
    */
-  ret = _gnutls_verify_crl2 (crl, CA_list, CA_list_length, flags, verify);
+  ret = MHD__gnutls_verify_crl2 (crl, CA_list, CA_list_length, flags, verify);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
@@ -876,39 +876,39 @@ gnutls_x509_crl_verify (gnutls_x509_crl_t crl,
 /* The same as above, but here we've got a CRL.
  */
 static int
-is_crl_issuer (gnutls_x509_crl_t crl, gnutls_x509_crt_t issuer_cert)
+is_crl_issuer (MHD_gnutls_x509_crl_t crl, MHD_gnutls_x509_crt_t issuer_cert)
 {
-  gnutls_datum_t dn1 = { NULL, 0 }, dn2 =
+  MHD_gnutls_datum_t dn1 = { NULL, 0 }, dn2 =
   {
   NULL, 0};
   int ret;
 
-  ret = _gnutls_x509_crl_get_raw_issuer_dn (crl, &dn1);
+  ret = MHD__gnutls_x509_crl_get_raw_issuer_dn (crl, &dn1);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  ret = gnutls_x509_crt_get_raw_dn (issuer_cert, &dn2);
+  ret = MHD_gnutls_x509_crt_get_raw_dn (issuer_cert, &dn2);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       return ret;
     }
 
-  ret = _gnutls_x509_compare_raw_dn (&dn1, &dn2);
+  ret = MHD__gnutls_x509_compare_raw_dn (&dn1, &dn2);
 
 cleanup:
-  _gnutls_free_datum (&dn1);
-  _gnutls_free_datum (&dn2);
+  MHD__gnutls_free_datum (&dn1);
+  MHD__gnutls_free_datum (&dn2);
 
   return ret;
 }
 
-static inline gnutls_x509_crt_t
-find_crl_issuer (gnutls_x509_crl_t crl,
-                 const gnutls_x509_crt_t * trusted_cas, int tcas_size)
+static inline MHD_gnutls_x509_crt_t
+find_crl_issuer (MHD_gnutls_x509_crl_t crl,
+                 const MHD_gnutls_x509_crt_t * trusted_cas, int tcas_size)
 {
   int i;
 
@@ -921,7 +921,7 @@ find_crl_issuer (gnutls_x509_crl_t crl,
         return trusted_cas[i];
     }
 
-  gnutls_assert ();
+  MHD_gnutls_assert ();
   return NULL;
 }
 
@@ -929,20 +929,20 @@ find_crl_issuer (gnutls_x509_crl_t crl,
  * Returns only 0 or 1. If 1 it means that the CRL
  * was successfuly verified.
  *
- * 'flags': an OR of the gnutls_certificate_verify_flags enumeration.
+ * 'flags': an OR of the MHD_gnutls_certificate_verify_flags enumeration.
  *
  * Output will hold information about the verification
  * procedure.
  */
 static int
-_gnutls_verify_crl2 (gnutls_x509_crl_t crl,
-                     const gnutls_x509_crt_t * trusted_cas,
+MHD__gnutls_verify_crl2 (MHD_gnutls_x509_crl_t crl,
+                     const MHD_gnutls_x509_crt_t * trusted_cas,
                      int tcas_size, unsigned int flags, unsigned int *output)
 {
   /* CRL is ignored for now */
-  gnutls_datum_t crl_signed_data = { NULL, 0 };
-  gnutls_datum_t crl_signature = { NULL, 0 };
-  gnutls_x509_crt_t issuer;
+  MHD_gnutls_datum_t crl_signed_data = { NULL, 0 };
+  MHD_gnutls_datum_t crl_signature = { NULL, 0 };
+  MHD_gnutls_x509_crt_t issuer;
   int ret, result;
 
   if (output)
@@ -952,7 +952,7 @@ _gnutls_verify_crl2 (gnutls_x509_crl_t crl,
     issuer = find_crl_issuer (crl, trusted_cas, tcas_size);
   else
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       if (output)
         *output |= GNUTLS_CERT_SIGNER_NOT_FOUND | GNUTLS_CERT_INVALID;
       return 0;
@@ -963,7 +963,7 @@ _gnutls_verify_crl2 (gnutls_x509_crl_t crl,
    */
   if (issuer == NULL)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       if (output)
         *output |= GNUTLS_CERT_SIGNER_NOT_FOUND | GNUTLS_CERT_INVALID;
       return 0;
@@ -971,9 +971,9 @@ _gnutls_verify_crl2 (gnutls_x509_crl_t crl,
 
   if (!(flags & GNUTLS_VERIFY_DISABLE_CA_SIGN))
     {
-      if (gnutls_x509_crt_get_ca_status (issuer, NULL) != 1)
+      if (MHD_gnutls_x509_crt_get_ca_status (issuer, NULL) != 1)
         {
-          gnutls_assert ();
+          MHD_gnutls_assert ();
           if (output)
             *output |= GNUTLS_CERT_SIGNER_NOT_CA | GNUTLS_CERT_INVALID;
           return 0;
@@ -981,29 +981,29 @@ _gnutls_verify_crl2 (gnutls_x509_crl_t crl,
     }
 
   result =
-    _gnutls_x509_get_signed_data (crl->crl, "tbsCertList", &crl_signed_data);
+    MHD__gnutls_x509_get_signed_data (crl->crl, "tbsCertList", &crl_signed_data);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  result = _gnutls_x509_get_signature (crl->crl, "signature", &crl_signature);
+  result = MHD__gnutls_x509_get_signature (crl->crl, "signature", &crl_signature);
   if (result < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       goto cleanup;
     }
 
   ret =
-    _gnutls_x509_verify_signature (&crl_signed_data, &crl_signature, issuer);
+    MHD__gnutls_x509_verify_signature (&crl_signed_data, &crl_signature, issuer);
   if (ret < 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
     }
   else if (ret == 0)
     {
-      gnutls_assert ();
+      MHD_gnutls_assert ();
       /* error. ignore it */
       if (output)
         *output |= GNUTLS_CERT_INVALID;
@@ -1013,7 +1013,7 @@ _gnutls_verify_crl2 (gnutls_x509_crl_t crl,
   {
     int sigalg;
 
-    sigalg = gnutls_x509_crl_get_signature_algorithm (crl);
+    sigalg = MHD_gnutls_x509_crl_get_signature_algorithm (crl);
 
     if (((sigalg == GNUTLS_SIGN_RSA_MD2) &&
          !(flags & GNUTLS_VERIFY_ALLOW_SIGN_RSA_MD2)) ||
@@ -1028,8 +1028,8 @@ _gnutls_verify_crl2 (gnutls_x509_crl_t crl,
   result = ret;
 
 cleanup:
-  _gnutls_free_datum (&crl_signed_data);
-  _gnutls_free_datum (&crl_signature);
+  MHD__gnutls_free_datum (&crl_signed_data);
+  MHD__gnutls_free_datum (&crl_signature);
 
   return result;
 }
diff --git a/src/daemon/internal.h b/src/daemon/internal.h
index 47d2963f..dcd9386d 100644
--- a/src/daemon/internal.h
+++ b/src/daemon/internal.h
@@ -571,7 +571,7 @@ struct MHD_Connection
 
 #if HTTPS_SUPPORT
   /* TODO rename as this might be an SSL connection */
-  mhd_gtls_session_t tls_session;
+  MHD_gtls_session_t tls_session;
 #endif
 };
 
@@ -652,16 +652,16 @@ struct MHD_Daemon
   enum MHD_GNUTLS_CredentialsType cred_type;
 
   /* server x509 credintials */
-  mhd_gtls_cert_credentials_t x509_cred;
+  MHD_gtls_cert_credentials_t x509_cred;
 
   /* credentials used for anonymous authentication */
-  mhd_gtls_anon_server_credentials_t anon_cred;
+  MHD_gtls_anon_server_credentials_t anon_cred;
 
   /* cipher priority cache */
-  gnutls_priority_t priority_cache;
+  MHD_gnutls_priority_t priority_cache;
 
   /* Diffie-Hellman parameters */
-  mhd_gtls_dh_params_t dh_params;
+  MHD_gtls_dh_params_t dh_params;
 
   const char *https_mem_key;