54 files changed, 577 insertions, 562 deletions

diff --git a/configure.ac b/configure.ac
index e467f0e7..c6b71330 100644
--- a/configure.ac
+++ b/configure.ac
@@ -130,12 +130,11 @@ AC_DEFINE_UNQUOTED([MHD_REQ_CURL_VERSION], "$MHD_REQ_CURL_VERSION", [required cU
 AC_DEFINE_UNQUOTED([MHD_REQ_CURL_OPENSSL_VERSION], "$MHD_REQ_CURL_OPENSSL_VERSION", [required cURL SSL version to run tests])
 AC_DEFINE_UNQUOTED([MHD_REQ_CURL_GNUTLS_VERSION], "$MHD_REQ_CURL_GNUTLS_VERSION", [gnuTLS lib version - used in conjunction with cURL])
 
-
 # large file support (> 4 GB)
 AC_SYS_LARGEFILE
 AC_FUNC_FSEEKO
 
-# optional: have error messages?
+# optional: have error messages ?
 AC_MSG_CHECKING(--enable-messages argument)
 AC_ARG_ENABLE(messages,
    [AS_HELP_STRING([--enable-messages],
@@ -148,6 +147,24 @@ then
  AC_DEFINE([HAVE_MESSAGES],[1],[Include error messages])
 fi
 
+# optional: compile TLS client side code [only for test running] ?
+AC_MSG_CHECKING(--enable-client-side argument)
+AC_ARG_ENABLE(client-side,
+   [AS_HELP_STRING([--enable-client-side],
+               [Compile client side code])],
+   [enable_client_side=$enableval],
+   [enable_client_side="no"])
+AC_MSG_RESULT($enable_client_side)
+if test "$enable_client_side" = "no"
+then
+ AC_DEFINE([MHD_DEBUG_TLS],[0],[Compile client side code. This will enable running some test cases.])
+ MSG_CLIENT_SIDE="disabled. running some test cases won't be possible"
+else
+ AC_DEFINE([MHD_DEBUG_TLS],[1],[Compile client side code. This will enable running some test cases.])
+ MSG_CLIENT_SIDE="enabled" 
+fi
+AM_CONDITIONAL(MHD_DEBUG_TLS, test "$enable_client_side" != "no")
+
 # optional: have zzuf, socat?
 AC_CHECK_PROG([HAVE_ZZUF],[zzuf], 1, 0)
 AC_CHECK_PROG([HAVE_SOCAT],[socat], 1, 0)
@@ -207,7 +224,7 @@ AC_ARG_ENABLE([OpenPGP],
    [AS_HELP_STRING([--enable-OpenPGP],
                [enable OpenPGP support (default is no)])],
    [enable_openpgp=$enableval],
-   [enable_openpgp="yes"])
+   [enable_openpgp="no"])
 AC_MSG_RESULT($enable_openpgp)
 if test "$enable_openpgp" = "yes"
 then
@@ -320,17 +337,18 @@ fi
 AC_MSG_NOTICE([Configured to build curl/libcurl:
   Configuration Summery:
   
-  os:              ${host_os}
-  target dir:      ${prefix}
-  messages:        ${enable_messages}
-  HTTPS support:   ${enable_HTTPS}      
-  TLS support:     ${enable_TLS}
-  SSLv3 support:   ${enable_SSL}
-  OpenGPG support: ${enable_openpgp}
-  x509 support:    ${enable_x509}
-  libgcrypt:       ${MSG_GCRYPT}
+  os:                ${host_os}
+  target dir:        ${prefix}
+  messages:          ${enable_messages}
+  HTTPS support:     ${enable_HTTPS}    
+  TLS support:       ${enable_TLS}
+  SSLv3 support:     ${enable_SSL}
+  OpenGPG support:   ${enable_openpgp}
+  x509 support:      ${enable_x509}
+  libgcrypt:         ${MSG_GCRYPT}
   
   # Testing
-  libcurl:         ${MSG_CURL}          
+  libcurl:           ${MSG_CURL}
+  client code dep.:  ${MSG_CLIENT_SIDE}                 
 ])
 
diff --git a/src/daemon/daemon.c b/src/daemon/daemon.c
index 9b31f115..2a26b5f5 100644
--- a/src/daemon/daemon.c
+++ b/src/daemon/daemon.c
@@ -109,12 +109,12 @@ MHD_init_daemon_certificate (struct MHD_Daemon *daemon)
 #if HAVE_MESSAGES
       MHD_DLOG (daemon, "Failed to load certificate\n");
 #endif
-      return MHD_NO;
+      return -1;
     }
 }
 
 /* initialize security aspects of the HTTPS daemon */
-int
+static int
 MHD_TLS_init (struct MHD_Daemon *daemon)
 {
   int ret;
@@ -129,24 +129,21 @@ MHD_TLS_init (struct MHD_Daemon *daemon)
           }
       MHD_gnutls_dh_params_generate2 (daemon->dh_params, 1024);
       MHD_gnutls_anon_set_server_dh_params (daemon->anon_cred, daemon->dh_params);
-      break;
+      return 0;
     case MHD_GNUTLS_CRD_CERTIFICATE:
       ret = MHD_gnutls_certificate_allocate_credentials (&daemon->x509_cred) ;
       if (ret != 0) {
                 return GNUTLS_E_MEMORY_ERROR;
           }
-      if ((ret = MHD_init_daemon_certificate (daemon)) != 0)
-        return ret;
+      return MHD_init_daemon_certificate (daemon);
     default:
 #if HAVE_MESSAGES
       MHD_DLOG (daemon,
                 "Error: no daemon credentials type found. f: %s, l: %d\n",
                 __FUNCTION__, __LINE__);
 #endif
-      break;
+      return -1;
     }
-
-  return MHD_NO;
 }
 
 inline static int
@@ -1028,7 +1025,7 @@ MHD_start_daemon_va (unsigned int options,
 
 #if HTTPS_SUPPORT
   /* initialize HTTPS daemon certificate aspects & send / recv functions */
-  if (options & MHD_USE_SSL && MHD_TLS_init (retVal) != 0)
+  if ((options & MHD_USE_SSL) && MHD_TLS_init (retVal))
     {
 #if HAVE_MESSAGES
       MHD_DLOG (retVal, "Failed to initialize HTTPS daemon\n");
diff --git a/src/daemon/https/openpgp/gnutls_ia.c b/src/daemon/https/openpgp/gnutls_ia.c
index b0751e85..ed810052 100644
--- a/src/daemon/https/openpgp/gnutls_ia.c
+++ b/src/daemon/https/openpgp/gnutls_ia.c
@@ -9,12 +9,12 @@
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
- *               
+ *
  * GNUTLS-EXTRA 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 General Public License for more details.
- *                               
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
@@ -448,10 +448,6 @@ gnutls_ia_recv (mhd_gtls_session_t session, char *data, size_t sizeofdata)
   return len;
 }
 
-/* XXX rewrite the following two functions as state machines, to
-   handle EAGAIN/EINTERRUPTED?  just add more problems to callers,
-   though.  */
-
 int
 _gnutls_ia_client_handshake (mhd_gtls_session_t session)
 {
@@ -617,7 +613,7 @@ gnutls_ia_handshake_p (mhd_gtls_session_t session)
   if (!ext->gnutls_ia_allowskip || !MHD_gtls_session_is_resumed (session))
     return 1;
 
-  /* If we're resuming and we and the peer both allow skipping on resumption: 
+  /* If we're resuming and we and the peer both allow skipping on resumption:
    * don't do IA */
 
   return !ext->gnutls_ia_peer_allowskip;
diff --git a/src/daemon/https/tls/auth_anon.c b/src/daemon/https/tls/auth_anon.c
index ae6346c3..9f1373dc 100644
--- a/src/daemon/https/tls/auth_anon.c
+++ b/src/daemon/https/tls/auth_anon.c
@@ -40,15 +40,15 @@
 #include <gnutls_state.h>
 #include <auth_dh_common.h>
 
-static int gen_anon_server_kx (mhd_gtls_session_t, opaque **);
-static int proc_anon_client_kx (mhd_gtls_session_t, opaque *, size_t);
+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 *, size_t);
 
-const mhd_gtls_mod_auth_st anon_auth_struct = {
+const mhd_gtls_mod_auth_st mhd_gtls_anon_auth_struct = {
   "ANON",
   NULL,
   NULL,
-  gen_anon_server_kx,
+  mhd_gtls_gen_anon_server_kx,
   mhd_gtls_gen_dh_common_client_kx,      /* this can be shared */
   NULL,
   NULL,
@@ -56,13 +56,13 @@ const mhd_gtls_mod_auth_st anon_auth_struct = {
   NULL,
   NULL,                         /* certificate */
   mhd_gtls_proc_anon_server_kx,
-  proc_anon_client_kx,
+  mhd_gtls_proc_anon_client_kx,
   NULL,
   NULL
 };
 
 static int
-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;
@@ -111,7 +111,7 @@ gen_anon_server_kx (mhd_gtls_session_t session, opaque ** data)
 
 
 static int
-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;
diff --git a/src/daemon/https/tls/auth_anon.h b/src/daemon/https/tls/auth_anon.h
index 631dd595..bdb0c1e4 100644
--- a/src/daemon/https/tls/auth_anon.h
+++ b/src/daemon/https/tls/auth_anon.h
@@ -42,7 +42,7 @@ typedef struct mhd_gtls_anon_client_credentials_st
 
 typedef struct mhd_gtls_anon_auth_info_st
 {
-  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;
diff --git a/src/daemon/https/tls/auth_cert.c b/src/daemon/https/tls/auth_cert.c
index 7fea2569..308c3878 100644
--- a/src/daemon/https/tls/auth_cert.c
+++ b/src/daemon/https/tls/auth_cert.c
@@ -147,7 +147,7 @@ _gnutls_cert_get_issuer_dn (gnutls_cert * cert, gnutls_datum_t * odn)
        (_gnutls_get_pkix (), "PKIX1.Certificate", &dn)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = asn1_der_decoding (&dn, cert->raw.data, cert->raw.size, NULL);
@@ -156,7 +156,7 @@ _gnutls_cert_get_issuer_dn (gnutls_cert * cert, gnutls_datum_t * odn)
       /* couldn't decode DER */
       gnutls_assert ();
       asn1_delete_structure (&dn);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = asn1_der_decoding_startEnd (dn, cert->raw.data, cert->raw.size,
@@ -167,7 +167,7 @@ _gnutls_cert_get_issuer_dn (gnutls_cert * cert, gnutls_datum_t * odn)
       /* couldn't decode DER */
       gnutls_assert ();
       asn1_delete_structure (&dn);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
   asn1_delete_structure (&dn);
 
@@ -613,7 +613,7 @@ cleanup:
  */
 
 int
-_gnutls_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;
@@ -671,7 +671,7 @@ enum PGPKeyDescriptorType
 { PGP_KEY_FINGERPRINT, PGP_KEY };
 
 int
-_gnutls_gen_openpgp_certificate (mhd_gtls_session_t session, opaque ** data)
+mhd_gtls_gen_openpgp_certificate (mhd_gtls_session_t session, opaque ** data)
 {
   int ret;
   opaque *pdata;
@@ -720,7 +720,7 @@ _gnutls_gen_openpgp_certificate (mhd_gtls_session_t session, opaque ** data)
 }
 
 int
-_gnutls_gen_openpgp_certificate_fpr (mhd_gtls_session_t session, opaque ** data)
+mhd_gtls_gen_openpgp_certificate_fpr (mhd_gtls_session_t session, opaque ** data)
 {
   int ret, packet_size;
   size_t fpr_size;
@@ -745,7 +745,7 @@ _gnutls_gen_openpgp_certificate_fpr (mhd_gtls_session_t session, opaque ** data)
   if (apr_cert_list_length > 0 && apr_cert_list[0].version == 4)
     packet_size += 20 + 1;
   else                          /* empty certificate case */
-    return _gnutls_gen_openpgp_certificate (session, data);
+    return mhd_gtls_gen_openpgp_certificate (session, data);
 
   (*data) = gnutls_malloc (packet_size);
   pdata = (*data);
@@ -793,12 +793,12 @@ mhd_gtls_gen_cert_client_certificate (mhd_gtls_session_t session, opaque ** data
     {
     case MHD_GNUTLS_CRT_OPENPGP:
       if (mhd_gtls_openpgp_send_fingerprint (session) == 0)
-        return _gnutls_gen_openpgp_certificate (session, data);
+        return mhd_gtls_gen_openpgp_certificate (session, data);
       else
-        return _gnutls_gen_openpgp_certificate_fpr (session, data);
+        return mhd_gtls_gen_openpgp_certificate_fpr (session, data);
 
     case MHD_GNUTLS_CRT_X509:
-      return _gnutls_gen_x509_crt (session, data);
+      return mhd_gtls_gen_x509_crt (session, data);
 
     default:
       gnutls_assert ();
@@ -812,9 +812,9 @@ mhd_gtls_gen_cert_server_certificate (mhd_gtls_session_t session, opaque ** data
   switch (session->security_parameters.cert_type)
     {
     case MHD_GNUTLS_CRT_OPENPGP:
-      return _gnutls_gen_openpgp_certificate (session, data);
+      return mhd_gtls_gen_openpgp_certificate (session, data);
     case MHD_GNUTLS_CRT_X509:
-      return _gnutls_gen_x509_crt (session, data);
+      return mhd_gtls_gen_x509_crt (session, data);
     default:
       gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
@@ -826,7 +826,7 @@ mhd_gtls_gen_cert_server_certificate (mhd_gtls_session_t session, opaque ** data
 
 #define CLEAR_CERTS for(x=0;x<peer_certificate_list_size;x++) mhd_gtls_gcert_deinit(&peer_certificate_list[x])
 int
-_gnutls_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;
@@ -968,7 +968,7 @@ cleanup:
 
 #define CLEAR_CERTS for(x=0;x<peer_certificate_list_size;x++) mhd_gtls_gcert_deinit(&peer_certificate_list[x])
 int
-_gnutls_proc_openpgp_server_certificate (mhd_gtls_session_t session,
+mhd_gtls_proc_openpgp_server_certificate (mhd_gtls_session_t session,
                                          opaque * data, size_t data_size)
 {
   int size, ret, len;
@@ -1153,10 +1153,10 @@ mhd_gtls_proc_cert_server_certificate (mhd_gtls_session_t session,
   switch (session->security_parameters.cert_type)
     {
     case MHD_GNUTLS_CRT_OPENPGP:
-      return _gnutls_proc_openpgp_server_certificate (session,
+      return mhd_gtls_proc_openpgp_server_certificate (session,
                                                       data, data_size);
     case MHD_GNUTLS_CRT_X509:
-      return _gnutls_proc_x509_server_certificate (session, data, data_size);
+      return mhd_gtls_proc_x509_server_certificate (session, data, data_size);
     default:
       gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
diff --git a/src/daemon/https/tls/auth_cert.h b/src/daemon/https/tls/auth_cert.h
index 979a698a..aa529b7e 100644
--- a/src/daemon/https/tls/auth_cert.h
+++ b/src/daemon/https/tls/auth_cert.h
@@ -98,7 +98,7 @@ typedef struct mhd_gtls_certificate_credentials_st
 
   gnutls_certificate_client_retrieve_function *client_get_cert_callback;
   gnutls_certificate_server_retrieve_function *server_get_cert_callback;
-} certificate_credentials_st;
+} mhd_gtls_cert_credentials_st;
 
 typedef struct mhd_gtls_rsa_info_st
 {
@@ -115,14 +115,14 @@ typedef struct mhd_gtls_cert_auth_info_st
   /* These (dh/rsa) are just copies from the credentials_t structure.
    * They must be freed.
    */
-  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
                                          * peer.
                                          */
   unsigned int ncerts;          /* holds the size of the list above */
-} *cert_auth_info_t;
+} * cert_auth_info_t;
 
 typedef struct mhd_gtls_cert_auth_info_st cert_auth_info_st;
 
diff --git a/src/daemon/https/tls/auth_dh_common.c b/src/daemon/https/tls/auth_dh_common.c
index 13e7987b..85f4a187 100644
--- a/src/daemon/https/tls/auth_dh_common.c
+++ b/src/daemon/https/tls/auth_dh_common.c
@@ -39,10 +39,10 @@
 #include <auth_dh_common.h>
 #include <gnutls_algorithms.h>
 
-/* Frees the dh_info_st structure.
+/* Frees the mhd_gtls_dh_info_st structure.
  */
 void
-mhd_gtls_free_dh_info (dh_info_st * dh)
+mhd_gtls_free_dh_info (mhd_gtls_dh_info_st * dh)
 {
   dh->secret_bits = 0;
   _gnutls_free_datum (&dh->prime);
diff --git a/src/daemon/https/tls/auth_dh_common.h b/src/daemon/https/tls/auth_dh_common.h
index 9d2d994a..440ab5b4 100644
--- a/src/daemon/https/tls/auth_dh_common.h
+++ b/src/daemon/https/tls/auth_dh_common.h
@@ -32,9 +32,9 @@ typedef struct
   gnutls_datum_t prime;
   gnutls_datum_t generator;
   gnutls_datum_t public_key;
-} dh_info_st;
+} mhd_gtls_dh_info_st;
 
-void mhd_gtls_free_dh_info (dh_info_st * dh);
+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,
diff --git a/src/daemon/https/tls/auth_dhe.c b/src/daemon/https/tls/auth_dhe.c
index ada5efe2..9cfdbb99 100644
--- a/src/daemon/https/tls/auth_dhe.c
+++ b/src/daemon/https/tls/auth_dhe.c
@@ -43,7 +43,7 @@ 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 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,
@@ -60,7 +60,7 @@ const mhd_gtls_mod_auth_st dhe_rsa_auth_struct = {
   mhd_gtls_proc_cert_cert_req    /* proc server cert request */
 };
 
-const mhd_gtls_mod_auth_st 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,
diff --git a/src/daemon/https/tls/auth_rsa.c b/src/daemon/https/tls/auth_rsa.c
index 40d1913f..556d3df1 100644
--- a/src/daemon/https/tls/auth_rsa.c
+++ b/src/daemon/https/tls/auth_rsa.c
@@ -45,7 +45,7 @@
 int _gnutls_gen_rsa_client_kx (mhd_gtls_session_t, opaque **);
 int _gnutls_proc_rsa_client_kx (mhd_gtls_session_t, opaque *, size_t);
 
-const mhd_gtls_mod_auth_st 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,
diff --git a/src/daemon/https/tls/ext_cert_type.c b/src/daemon/https/tls/ext_cert_type.c
index fbbbab79..8d37abae 100644
--- a/src/daemon/https/tls/ext_cert_type.c
+++ b/src/daemon/https/tls/ext_cert_type.c
@@ -52,6 +52,7 @@ mhd_gtls_cert_type_recv_params (mhd_gtls_session_t session,
   int new_type = -1, ret, i;
   ssize_t data_size = _data_size;
 
+#if MHD_DEBUG_TLS
   if (session->security_parameters.entity == GNUTLS_CLIENT)
     {
       if (data_size > 0)
@@ -82,6 +83,7 @@ mhd_gtls_cert_type_recv_params (mhd_gtls_session_t session,
         }
     }
   else
+#endif
     {                           /* SERVER SIDE - we must check if the sent cert type is the right one
                                  */
       if (data_size > 1)
@@ -147,6 +149,7 @@ mhd_gtls_cert_type_send_params (mhd_gtls_session_t session, opaque * data,
   unsigned len, i;
 
   /* this function sends the client extension data (dnsname) */
+#if MHD_DEBUG_TLS
   if (session->security_parameters.entity == GNUTLS_CLIENT)
     {
 
@@ -186,6 +189,7 @@ mhd_gtls_cert_type_send_params (mhd_gtls_session_t session, opaque * data,
 
     }
   else
+#endif
     {                           /* server side */
       if (session->security_parameters.cert_type != DEFAULT_CERT_TYPE)
         {
diff --git a/src/daemon/https/tls/ext_inner_application.c b/src/daemon/https/tls/ext_inner_application.c
index a2276589..2652c289 100644
--- a/src/daemon/https/tls/ext_inner_application.c
+++ b/src/daemon/https/tls/ext_inner_application.c
@@ -73,7 +73,7 @@ mhd_gtls_inner_app_send_params (mhd_gtls_session_t session,
 
   /* Set ext->gnutls_ia_enable depending on whether we have a TLS/IA
      credential in the session. */
-
+#if MHD_DEBUG_TLS
   if (session->security_parameters.entity == GNUTLS_CLIENT)
     {
       gnutls_ia_client_credentials_t cred = (gnutls_ia_client_credentials_t)
@@ -83,6 +83,7 @@ mhd_gtls_inner_app_send_params (mhd_gtls_session_t session,
         ext->gnutls_ia_enable = 1;
     }
   else
+#endif
     {
       gnutls_ia_server_credentials_t cred = (gnutls_ia_server_credentials_t)
         mhd_gtls_get_cred (session->key, MHD_GNUTLS_CRD_IA, NULL);
@@ -114,6 +115,7 @@ mhd_gtls_inner_app_send_params (mhd_gtls_session_t session,
 
   *data = YES;
 
+#if MHD_DEBUG_TLS
   if (session->security_parameters.entity == GNUTLS_CLIENT)
     {
 
@@ -123,6 +125,7 @@ mhd_gtls_inner_app_send_params (mhd_gtls_session_t session,
         *data = NO;
     }
   else
+#endif
     {
 
       /* Server: value follows local setting and client's setting, but only
diff --git a/src/daemon/https/tls/ext_max_record.c b/src/daemon/https/tls/ext_max_record.c
index 3f4ac68a..8c3de8f8 100644
--- a/src/daemon/https/tls/ext_max_record.c
+++ b/src/daemon/https/tls/ext_max_record.c
@@ -30,7 +30,7 @@
 #include "gnutls_num.h"
 #include <ext_max_record.h>
 
-/* 
+/*
  * 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(),
  * in order to access it.
@@ -66,7 +66,7 @@ mhd_gtls_max_record_recv_params (mhd_gtls_session_t session,
         }
     }
   else
-    {                           /* CLIENT SIDE - we must check if the sent record size is the right one 
+    {                           /* CLIENT SIDE - we must check if the sent record size is the right one
                                  */
       if (data_size > 0)
         {
@@ -107,6 +107,7 @@ mhd_gtls_max_record_send_params (mhd_gtls_session_t session, opaque * data,
 {
   uint16_t len;
   /* this function sends the client extension data (dnsname) */
+#if MHD_DEBUG_TLS
   if (session->security_parameters.entity == GNUTLS_CLIENT)
     {
 
@@ -127,6 +128,7 @@ mhd_gtls_max_record_send_params (mhd_gtls_session_t session, opaque * data,
 
     }
   else
+#endif
     {                           /* server side */
 
       if (session->security_parameters.max_record_recv_size !=
diff --git a/src/daemon/https/tls/ext_oprfi.c b/src/daemon/https/tls/ext_oprfi.c
index f8bd4953..67a5bcb2 100644
--- a/src/daemon/https/tls/ext_oprfi.c
+++ b/src/daemon/https/tls/ext_oprfi.c
@@ -114,9 +114,11 @@ int
 mhd_gtls_oprfi_recv_params (mhd_gtls_session_t session,
                            const opaque * data, size_t data_size)
 {
+#if MHD_DEBUG_TLS
   if (session->security_parameters.entity == GNUTLS_CLIENT)
     return oprfi_recv_client (session, data, data_size);
   else
+#endif
     return oprfi_recv_server (session, data, data_size);
 }
 
@@ -194,9 +196,6 @@ int
 mhd_gtls_oprfi_send_params (mhd_gtls_session_t session,
                            opaque * data, size_t data_size)
 {
-  if (session->security_parameters.entity == GNUTLS_CLIENT)
-    return oprfi_send_client (session, data, data_size);
-  else
     return oprfi_send_server (session, data, data_size);
 }
 
diff --git a/src/daemon/https/tls/ext_server_name.c b/src/daemon/https/tls/ext_server_name.c
index 9dc1f3bb..e0816259 100644
--- a/src/daemon/https/tls/ext_server_name.c
+++ b/src/daemon/https/tls/ext_server_name.c
@@ -28,7 +28,7 @@
 #include "gnutls_num.h"
 #include <ext_server_name.h>
 
-/* 
+/*
  * 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(),
  * in order to access it.
@@ -133,34 +133,34 @@ mhd_gtls_server_name_send_params (mhd_gtls_session_t session,
   ssize_t data_size = _data_size;
   int total_size = 0;
 
-  /* this function sends the client extension data (dnsname) 
-   */
+  /* this function sends the client extension data (dnsname) */
+#if MHD_DEBUG_TLS
   if (session->security_parameters.entity == GNUTLS_CLIENT)
     {
 
       if (session->security_parameters.extensions.server_names_size == 0)
         return 0;
 
-      /* uint16_t 
+      /* uint16_t
        */
       total_size = 2;
       for (i = 0;
            i < session->security_parameters.extensions.server_names_size; i++)
         {
-          /* count the total size 
+          /* count the total size
            */
           len =
             session->security_parameters.extensions.server_names[i].
             name_length;
 
-          /* uint8_t + uint16_t + size 
+          /* uint8_t + uint16_t + size
            */
           total_size += 1 + 2 + len;
         }
 
       p = data;
 
-      /* UINT16: write total size of all names 
+      /* 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);
@@ -205,7 +205,7 @@ mhd_gtls_server_name_send_params (mhd_gtls_session_t session,
             }
         }
     }
-
+#endif
   return total_size;
 }
 
@@ -238,13 +238,13 @@ MHD_gnutls_server_name_get (mhd_gtls_session_t session, void *data,
                         unsigned int *type, unsigned int indx)
 {
   char *_data = data;
-
+#if MHD_DEBUG_TLS
   if (session->security_parameters.entity == GNUTLS_CLIENT)
     {
       gnutls_assert ();
       return GNUTLS_E_INVALID_REQUEST;
     }
-
+#endif
   if (indx + 1 > session->security_parameters.extensions.server_names_size)
     {
       return GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE;
@@ -284,13 +284,13 @@ MHD_gnutls_server_name_get (mhd_gtls_session_t session, void *data,
   * @name: is a string that contains the server name.
   * @name_length: holds the length of name
   *
-  * This function is to be used by clients that want to inform 
+  * This function is to be used by clients that want to inform
   * (via a TLS extension mechanism) the server of the name they
   * connected to. This should be used by clients that connect
   * to servers that do virtual hosting.
   *
   * The value of @name depends on the @ind type. In case of GNUTLS_NAME_DNS,
-  * an ASCII or UTF-8 null terminated string, without the trailing dot, is expected. 
+  * an ASCII or UTF-8 null terminated string, without the trailing dot, is expected.
   * IPv4 or IPv6 addresses are not permitted.
   *
   **/
diff --git a/src/daemon/https/tls/gnutls_alert.c b/src/daemon/https/tls/gnutls_alert.c
index 3a97365f..cbea7b09 100644
--- a/src/daemon/https/tls/gnutls_alert.c
+++ b/src/daemon/https/tls/gnutls_alert.c
@@ -33,7 +33,7 @@ typedef struct
   const char *desc;
 } gnutls_alert_entry;
 
-static const gnutls_alert_entry sup_alerts[] = {
+static const 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"},
@@ -73,7 +73,7 @@ static const gnutls_alert_entry sup_alerts[] = {
 
 #define GNUTLS_ALERT_LOOP(b) \
         const gnutls_alert_entry *p; \
-                for(p = sup_alerts; p->desc != NULL; p++) { b ; }
+                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; })
diff --git a/src/daemon/https/tls/gnutls_algorithms.c b/src/daemon/https/tls/gnutls_algorithms.c
index 6f7fd8ce..5f0eb4cb 100644
--- a/src/daemon/https/tls/gnutls_algorithms.c
+++ b/src/daemon/https/tls/gnutls_algorithms.c
@@ -41,7 +41,7 @@ typedef struct
                                                  * needs to set */
 } gnutls_cred_map;
 
-static const gnutls_cred_map cred_mappings[] = {
+static const gnutls_cred_map mhd_gtls_cred_mappings[] = {
   {MHD_GNUTLS_KX_ANON_DH,
    MHD_GNUTLS_CRD_ANON,
    MHD_GNUTLS_CRD_ANON},
@@ -73,7 +73,7 @@ static const gnutls_cred_map cred_mappings[] = {
 
 #define GNUTLS_KX_MAP_LOOP(b) \
         const gnutls_cred_map *p; \
-                for(p = cred_mappings; p->algorithm != 0; p++) { b ; }
+                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; })
@@ -100,7 +100,7 @@ typedef struct
  * RSA algorithm in the certificate then we can
  * use GNUTLS_KX_RSA or GNUTLS_KX_DHE_RSA.
  */
-static const gnutls_pk_map pk_mappings[] = {
+static const gnutls_pk_map mhd_gtls_pk_mappings[] = {
   {MHD_GNUTLS_KX_RSA,
    MHD_GNUTLS_PK_RSA,
    CIPHER_ENCRYPT},
@@ -120,7 +120,7 @@ static const gnutls_pk_map pk_mappings[] = {
 
 #define GNUTLS_PK_MAP_LOOP(b) \
         const gnutls_pk_map *p; \
-                for(p = pk_mappings; p->kx_algorithm != 0; p++) { b }
+                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; })
@@ -136,7 +136,7 @@ typedef struct
   int supported;                /* 0 not supported, > 0 is supported */
 } gnutls_version_entry;
 
-static const gnutls_version_entry sup_versions[] = {
+static const gnutls_version_entry mhd_gtls_sup_versions[] = {
   {"SSL3.0",
    MHD_GNUTLS_SSL3,
    3,
@@ -165,7 +165,7 @@ static const gnutls_version_entry sup_versions[] = {
 };
 
 /* Keep the contents of this struct the same as the previous one. */
-static const gnutls_protocol_t supported_protocols[] = { MHD_GNUTLS_SSL3,
+static const gnutls_protocol_t mhd_gtls_supported_protocols[] = { MHD_GNUTLS_SSL3,
   MHD_GNUTLS_TLS1_0,
   MHD_GNUTLS_TLS1_1,
   MHD_GNUTLS_TLS1_2,
@@ -174,7 +174,7 @@ static const gnutls_protocol_t supported_protocols[] = { MHD_GNUTLS_SSL3,
 
 #define GNUTLS_VERSION_LOOP(b) \
         const gnutls_version_entry *p; \
-                for(p = sup_versions; p->name != NULL; p++) { b ; }
+                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; })
@@ -196,7 +196,7 @@ typedef struct gnutls_cipher_entry gnutls_cipher_entry;
  * View first: "The order of encryption and authentication for
  * protecting communications" by Hugo Krawczyk - CRYPTO 2001
  */
-static const gnutls_cipher_entry algorithms[] = {
+static const gnutls_cipher_entry mhd_gtls_algorithms[] = {
   {"AES-256-CBC",
    MHD_GNUTLS_CIPHER_AES_256_CBC,
    16,
@@ -271,7 +271,7 @@ static const gnutls_cipher_entry algorithms[] = {
 };
 
 /* Keep the contents of this struct the same as the previous one. */
-static const gnutls_cipher_algorithm_t supported_ciphers[] =
+static const gnutls_cipher_algorithm_t mhd_gtls_supported_ciphers[] =
   { MHD_GNUTLS_CIPHER_AES_256_CBC,
   MHD_GNUTLS_CIPHER_AES_128_CBC,
   MHD_GNUTLS_CIPHER_3DES_CBC,
@@ -289,7 +289,7 @@ static const gnutls_cipher_algorithm_t supported_ciphers[] =
 
 #define GNUTLS_LOOP(b) \
         const gnutls_cipher_entry *p; \
-                for(p = algorithms; p->name != NULL; p++) { b ; }
+                for(p = mhd_gtls_algorithms; p->name != NULL; p++) { b ; }
 
 #define GNUTLS_ALG_LOOP(a) \
                         GNUTLS_LOOP( if(p->id == algorithm) { a; break; } )
@@ -303,7 +303,7 @@ struct gnutls_hash_entry
 };
 typedef struct gnutls_hash_entry gnutls_hash_entry;
 
-static const gnutls_hash_entry hash_algorithms[] = {
+static const gnutls_hash_entry mhd_gtls_hash_algorithms[] = {
   {"SHA1",
    HASH_OID_SHA1,
    MHD_GNUTLS_MAC_SHA1,
@@ -327,7 +327,7 @@ static const gnutls_hash_entry hash_algorithms[] = {
 };
 
 /* Keep the contents of this struct the same as the previous one. */
-static const gnutls_mac_algorithm_t supported_macs[] = { MHD_GNUTLS_MAC_SHA1,
+static const gnutls_mac_algorithm_t mhd_gtls_supported_macs[] = { MHD_GNUTLS_MAC_SHA1,
   MHD_GNUTLS_MAC_MD5,
   MHD_GNUTLS_MAC_SHA256,
   MHD_GNUTLS_MAC_NULL,
@@ -336,7 +336,7 @@ static const gnutls_mac_algorithm_t supported_macs[] = { MHD_GNUTLS_MAC_SHA1,
 
 #define GNUTLS_HASH_LOOP(b) \
         const gnutls_hash_entry *p; \
-                for(p = hash_algorithms; p->name != NULL; p++) { b ; }
+                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; } )
@@ -364,7 +364,7 @@ gnutls_compression_entry _gnutls_compression_algorithms[MAX_COMP_METHODS] =
    0}
 };
 
-static const gnutls_compression_method_t supported_compressions[] = {
+static const gnutls_compression_method_t mhd_gtls_supported_compressions[] = {
 #ifdef HAVE_LIBZ
   MHD_GNUTLS_COMP_DEFLATE,
 #endif
@@ -381,11 +381,11 @@ static const gnutls_compression_method_t supported_compressions[] = {
                         GNUTLS_COMPRESSION_LOOP( if(p->num == num) { a; break; } )
 
 /* Key Exchange Section */
-extern mhd_gtls_mod_auth_st rsa_auth_struct;
+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 dhe_rsa_auth_struct;
-extern mhd_gtls_mod_auth_st dhe_dss_auth_struct;
-extern mhd_gtls_mod_auth_st anon_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;
@@ -403,11 +403,11 @@ typedef struct mhd_gtls_kx_algo_entry
 
 static const mhd_gtls_kx_algo_entry_t mhd_gtls_kx_algorithms[] = {
 #ifdef ENABLE_ANON
-  {"ANON-DH", MHD_GNUTLS_KX_ANON_DH, &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,
-   &rsa_auth_struct,
+   &mhd_gtls_rsa_auth_struct,
    0,
    0},
   {"RSA-EXPORT",
@@ -417,12 +417,12 @@ static const mhd_gtls_kx_algo_entry_t mhd_gtls_kx_algorithms[] = {
    1 /* needs RSA params */ },
   {"DHE-RSA",
    MHD_GNUTLS_KX_DHE_RSA,
-   &dhe_rsa_auth_struct,
+   &mhd_gtls_dhe_rsa_auth_struct,
    1,
    0},
   {"DHE-DSS",
    MHD_GNUTLS_KX_DHE_DSS,
-   &dhe_dss_auth_struct,
+   &mhd_gtls_dhe_dss_auth_struct,
    1,
    0},
 
@@ -444,7 +444,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 gnutls_kx_algorithm_t supported_kxs[] = {
+static const gnutls_kx_algorithm_t mhd_gtls_supported_kxs[] = {
 #ifdef ENABLE_ANON
   MHD_GNUTLS_KX_ANON_DH,
 #endif
@@ -485,7 +485,7 @@ typedef struct
   gnutls_protocol_t version;    /* this cipher suite is supported
                                  * from 'version' and above;
                                  */
-} gnutls_cipher_suite_entry;
+} mhd_gtls_cipher_suite_entry;
 
 /* RSA with NULL cipher and MD5 MAC
  * for test purposes.
@@ -581,9 +581,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(cs_algorithms)/sizeof(gnutls_cipher_suite_entry)-1
+#define CIPHER_SUITES_COUNT sizeof(mhd_gtls_cs_algorithms)/sizeof(mhd_gtls_cipher_suite_entry)-1
 
-static const gnutls_cipher_suite_entry 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,
@@ -753,8 +753,8 @@ static const gnutls_cipher_suite_entry cs_algorithms[] = {
 };
 
 #define GNUTLS_CIPHER_SUITE_LOOP(b) \
-        const gnutls_cipher_suite_entry *p; \
-                for(p = 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; } )
@@ -844,7 +844,7 @@ MHD_gnutls_mac_get_key_size (gnutls_mac_algorithm_t algorithm)
 const gnutls_mac_algorithm_t *
 MHD_gtls_mac_list (void)
 {
-  return supported_macs;
+  return mhd_gtls_supported_macs;
 }
 
 const char *
@@ -955,7 +955,7 @@ MHD_gtls_compression_get_id (const char *name)
 const gnutls_compression_method_t *
 MHD_gtls_compression_list (void)
 {
-  return supported_compressions;
+  return mhd_gtls_supported_compressions;
 }
 
 /* return the tls number of the specified algorithm */
@@ -1145,7 +1145,7 @@ MHD_gtls_cipher_get_id (const char *name)
 const gnutls_cipher_algorithm_t *
 MHD_gtls_cipher_list (void)
 {
-  return supported_ciphers;
+  return mhd_gtls_supported_ciphers;
 }
 
 int
@@ -1232,7 +1232,7 @@ MHD_gtls_kx_get_id (const char *name)
 const gnutls_kx_algorithm_t *
 MHD_gtls_kx_list (void)
 {
-  return supported_kxs;
+  return mhd_gtls_supported_kxs;
 }
 
 int
@@ -1376,7 +1376,7 @@ MHD_gtls_protocol_get_id (const char *name)
 const gnutls_protocol_t *
 MHD_gtls_protocol_list (void)
 {
-  return supported_protocols;
+  return mhd_gtls_supported_protocols;
 }
 
 int
@@ -1739,7 +1739,7 @@ mhd_gtls_supported_ciphersuites (mhd_gtls_session_t session,
 
   for (i = 0; i < count; i++)
     {
-      memcpy (&tmp_ciphers[i], &cs_algorithms[i].id,
+      memcpy (&tmp_ciphers[i], &mhd_gtls_cs_algorithms[i].id,
               sizeof (cipher_suite_st));
     }
 
@@ -1894,7 +1894,7 @@ MHD_gtls_certificate_type_get_id (const char *name)
   return ret;
 }
 
-static const gnutls_certificate_type_t supported_certificate_types[] =
+static const gnutls_certificate_type_t mhd_gtls_supported_certificate_types[] =
   { MHD_GNUTLS_CRT_X509,
   MHD_GNUTLS_CRT_OPENPGP,
   0
@@ -1914,7 +1914,7 @@ static const gnutls_certificate_type_t supported_certificate_types[] =
 const gnutls_certificate_type_t *
 MHD_gtls_certificate_type_list (void)
 {
-  return supported_certificate_types;
+  return mhd_gtls_supported_certificate_types;
 }
 
 /* returns the gnutls_pk_algorithm_t which is compatible with
@@ -1953,7 +1953,7 @@ struct gnutls_sign_entry
 };
 typedef struct gnutls_sign_entry gnutls_sign_entry;
 
-static const gnutls_sign_entry sign_algorithms[] = {
+static const gnutls_sign_entry mhd_gtls_sign_algorithms[] = {
   {"RSA-SHA",
    SIG_RSA_SHA1_OID,
    GNUTLS_SIGN_RSA_SHA1,
@@ -1989,7 +1989,7 @@ static const gnutls_sign_entry sign_algorithms[] = {
 #define GNUTLS_SIGN_LOOP(b) \
   do {                                                                 \
     const gnutls_sign_entry *p;                                        \
-    for(p = sign_algorithms; p->name != NULL; p++) { b ; }             \
+    for(p = mhd_gtls_sign_algorithms; p->name != NULL; p++) { b ; }            \
   } while (0)
 
 #define GNUTLS_SIGN_ALG_LOOP(a) \
@@ -2053,7 +2053,7 @@ struct gnutls_pk_entry
 };
 typedef struct gnutls_pk_entry gnutls_pk_entry;
 
-static const gnutls_pk_entry pk_algorithms[] = {
+static const gnutls_pk_entry mhd_gtls_pk_algorithms[] = {
   {"RSA",
    PK_PKIX1_RSA_OID,
    MHD_GNUTLS_PK_RSA},
@@ -2074,7 +2074,7 @@ mhd_gtls_x509_oid2pk_algorithm (const char *oid)
   gnutls_pk_algorithm_t ret = MHD_GNUTLS_PK_UNKNOWN;
   const gnutls_pk_entry *p;
 
-  for (p = 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;
@@ -2090,7 +2090,7 @@ mhd_gtls_x509_pk_to_oid (gnutls_pk_algorithm_t algorithm)
   const char *ret = NULL;
   const gnutls_pk_entry *p;
 
-  for (p = 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_auth.c b/src/daemon/https/tls/gnutls_auth.c
index cb2f42e0..b517c285 100644
--- a/src/daemon/https/tls/gnutls_auth.c
+++ b/src/daemon/https/tls/gnutls_auth.c
@@ -286,7 +286,7 @@ mhd_gtls_get_auth_info (mhd_gtls_session_t session)
 void
 mhd_gtls_free_auth_info (mhd_gtls_session_t session)
 {
-  dh_info_st *dh_info;
+  mhd_gtls_dh_info_st *dh_info;
   rsa_info_st *rsa_info;
 
   if (session == NULL || session->key == NULL)
diff --git a/src/daemon/https/tls/gnutls_cert.c b/src/daemon/https/tls/gnutls_cert.c
index ee169a75..d63628e3 100644
--- a/src/daemon/https/tls/gnutls_cert.c
+++ b/src/daemon/https/tls/gnutls_cert.c
@@ -216,7 +216,7 @@ int
 MHD_gnutls_certificate_allocate_credentials (mhd_gtls_cert_credentials_t *
                                          res)
 {
-  *res = gnutls_calloc (1, sizeof (certificate_credentials_st));
+  *res = gnutls_calloc (1, sizeof (mhd_gtls_cert_credentials_st));
 
   if (*res == NULL)
     return GNUTLS_E_MEMORY_ERROR;
diff --git a/src/daemon/https/tls/gnutls_constate.c b/src/daemon/https/tls/gnutls_constate.c
index 4e683de7..f2bbca43 100644
--- a/src/daemon/https/tls/gnutls_constate.c
+++ b/src/daemon/https/tls/gnutls_constate.c
@@ -50,7 +50,7 @@ static const int servwrite_length = sizeof (servwrite) - 1;
 #define EXPORT_FINAL_KEY_SIZE 16
 
 /* This function is to be called after handshake, when master_secret,
- *  client_random and server_random have been initialized. 
+ *  client_random and server_random have been initialized.
  * This function creates the keys and stores them into pending session.
  * (session->cipher_specs)
  */
@@ -475,7 +475,7 @@ mhd_gtls_connection_state_init (mhd_gtls_session_t session)
 {
   int ret;
 
-/* Setup the master secret 
+/* Setup the master secret
  */
   if ((ret = mhd_gtls_generate_master (session, 0), 0) < 0)
     {
@@ -621,7 +621,7 @@ mhd_gtls_read_connection_state_init (mhd_gtls_session_t session)
         }
 
       break;
-
+#if MHD_DEBUG_TLS
     case GNUTLS_CLIENT:
       session->connection_state.read_cipher_state =
         mhd_gtls_cipher_init (session->security_parameters.
@@ -657,7 +657,7 @@ mhd_gtls_read_connection_state_init (mhd_gtls_session_t session)
         }
 
       break;
-
+#endif
     default:                   /* this check is useless */
       gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
@@ -815,7 +815,7 @@ mhd_gtls_write_connection_state_init (mhd_gtls_session_t session)
 
 
       break;
-
+#if MHD_DEBUG_TLS
     case GNUTLS_CLIENT:
       session->connection_state.write_cipher_state =
         mhd_gtls_cipher_init (session->security_parameters.
@@ -850,7 +850,7 @@ mhd_gtls_write_connection_state_init (mhd_gtls_session_t session)
         }
 
       break;
-
+#endif
     default:
       gnutls_assert ();
       return GNUTLS_E_INTERNAL_ERROR;
@@ -870,7 +870,7 @@ mhd_gtls_write_connection_state_init (mhd_gtls_session_t session)
   return 0;
 }
 
-/* Sets the specified cipher into the pending session 
+/* Sets the specified cipher into the pending session
  */
 int
 mhd_gtls_set_read_cipher (mhd_gtls_session_t session,
@@ -925,7 +925,7 @@ mhd_gtls_set_write_cipher (mhd_gtls_session_t session,
 }
 
 
-/* Sets the specified algorithm into pending compression session 
+/* Sets the specified algorithm into pending compression session
  */
 int
 mhd_gtls_set_read_compression (mhd_gtls_session_t session,
@@ -963,7 +963,7 @@ mhd_gtls_set_write_compression (mhd_gtls_session_t session,
 
 }
 
-/* Sets the specified kx algorithm into pending session 
+/* Sets the specified kx algorithm into pending session
  */
 int
 mhd_gtls_set_kx (mhd_gtls_session_t session, gnutls_kx_algorithm_t algo)
diff --git a/src/daemon/https/tls/gnutls_errors.c b/src/daemon/https/tls/gnutls_errors.c
index 9ebf67df..f4436ece 100644
--- a/src/daemon/https/tls/gnutls_errors.c
+++ b/src/daemon/https/tls/gnutls_errors.c
@@ -48,7 +48,7 @@ struct gnutls_error_entry
 };
 typedef struct gnutls_error_entry gnutls_error_entry;
 
-static const gnutls_error_entry error_algorithms[] = {
+static const 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."),
@@ -255,7 +255,7 @@ static const gnutls_error_entry error_algorithms[] = {
 
 #define GNUTLS_ERROR_LOOP(b) \
         const gnutls_error_entry *p; \
-                for(p = error_algorithms; p->desc != NULL; p++) { b ; }
+                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; } )
@@ -348,7 +348,7 @@ _gnutls_strerror (int error)
 }
 
 int
-_gnutls_asn2err (int asn_err)
+mhd_gtls_asn2err (int asn_err)
 {
   switch (asn_err)
     {
@@ -390,7 +390,7 @@ _gnutls_asn2err (int asn_err)
  * caller provided function
  */
 void
-_gnutls_log (int level, const char *fmt, ...)
+mhd_gtls_log (int level, const char *fmt, ...)
 {
   va_list args;
   char str[MAX_LOG_SIZE];
diff --git a/src/daemon/https/tls/gnutls_errors.h b/src/daemon/https/tls/gnutls_errors.h
index 667bd62b..fcfc4c63 100644
--- a/src/daemon/https/tls/gnutls_errors.h
+++ b/src/daemon/https/tls/gnutls_errors.h
@@ -36,17 +36,17 @@
 # define gnutls_assert()
 #endif
 
-int _gnutls_asn2err (int asn_err);
-void _gnutls_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;
 
 #ifdef C99_MACROS
 #define LEVEL(l, ...) if (_gnutls_log_level >= l || _gnutls_log_level > 9) \
-        _gnutls_log( l, __VA_ARGS__)
+        mhd_gtls_log( l, __VA_ARGS__)
 
 #define LEVEL_EQ(l, ...) if (_gnutls_log_level == l || _gnutls_log_level > 9) \
-        _gnutls_log( l, __VA_ARGS__)
+        mhd_gtls_log( l, __VA_ARGS__)
 
 # define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__)
 # define _gnutls_handshake_log(...) LEVEL(3, __VA_ARGS__)
diff --git a/src/daemon/https/tls/gnutls_extensions.c b/src/daemon/https/tls/gnutls_extensions.c
index 5e09c911..6b2f00c8 100644
--- a/src/daemon/https/tls/gnutls_extensions.c
+++ b/src/daemon/https/tls/gnutls_extensions.c
@@ -119,12 +119,13 @@ mhd_gtls_extension_get_name (uint16_t type)
   return ret;
 }
 
-/* Checks if the extension we just received is one of the 
+/* Checks if the extension we just received is one of the
  * requested ones. Otherwise it's a fatal error.
  */
 static int
 _gnutls_extension_list_check (mhd_gtls_session_t session, uint16_t type)
 {
+#if MHD_DEBUG_TLS
   if (session->security_parameters.entity == GNUTLS_CLIENT)
     {
       int i;
@@ -135,7 +136,7 @@ _gnutls_extension_list_check (mhd_gtls_session_t session, uint16_t type)
         }
       return GNUTLS_E_RECEIVED_ILLEGAL_EXTENSION;
     }
-
+#endif
   return 0;
 }
 
@@ -153,7 +154,6 @@ mhd_gtls_parse_extensions (mhd_gtls_session_t session,
 
 #ifdef DEBUG
   int i;
-
   if (session->security_parameters.entity == GNUTLS_CLIENT)
     for (i = 0; i < session->internals.extensions_sent_size; i++)
       {
@@ -217,7 +217,7 @@ mhd_gtls_parse_extensions (mhd_gtls_session_t session,
 static void
 _gnutls_extension_list_add (mhd_gtls_session_t session, uint16_t type)
 {
-
+#if MHD_DEBUG_TLS
   if (session->security_parameters.entity == GNUTLS_CLIENT)
     {
       if (session->internals.extensions_sent_size < MAX_EXT_TYPES)
@@ -231,6 +231,7 @@ _gnutls_extension_list_add (mhd_gtls_session_t session, uint16_t type)
           _gnutls_debug_log ("extensions: Increase MAX_EXT_TYPES\n");
         }
     }
+#endif
 }
 
 int
diff --git a/src/daemon/https/tls/gnutls_global.c b/src/daemon/https/tls/gnutls_global.c
index 916e8117..87f92239 100644
--- a/src/daemon/https/tls/gnutls_global.c
+++ b/src/daemon/https/tls/gnutls_global.c
@@ -159,7 +159,7 @@ static void
 _gnutls_gcry_log_handler (void *dummy, int level,
                           const char *fmt, va_list list)
 {
-  _gnutls_log (level, fmt, list);
+  mhd_gtls_log (level, fmt, list);
 }
 #endif
 
@@ -288,7 +288,7 @@ MHD_gnutls_global_init (void)
   res = asn1_array2tree (pkix_asn1_tab, &_gnutls_pkix1_asn, NULL);
   if (res != ASN1_SUCCESS)
     {
-      result = _gnutls_asn2err (res);
+      result = mhd_gtls_asn2err (res);
       return result;
     }
 
@@ -296,7 +296,7 @@ MHD_gnutls_global_init (void)
   if (res != ASN1_SUCCESS)
     {
       asn1_delete_structure (&_gnutls_pkix1_asn);
-      result = _gnutls_asn2err (res);
+      result = mhd_gtls_asn2err (res);
       return result;
     }
 
diff --git a/src/daemon/https/tls/gnutls_handshake.c b/src/daemon/https/tls/gnutls_handshake.c
index 882b43e2..cbab8156 100644
--- a/src/daemon/https/tls/gnutls_handshake.c
+++ b/src/daemon/https/tls/gnutls_handshake.c
@@ -58,7 +58,7 @@
 #define TRUE 1
 #define FALSE 0
 
-int _gnutls_server_select_comp_method (mhd_gtls_session_t session,
+static int _gnutls_server_select_comp_method (mhd_gtls_session_t session,
                                        opaque * data, int datalen);
 
 
@@ -186,7 +186,7 @@ _gnutls_ssl3_finished (mhd_gtls_session_t session, int type, opaque * ret)
 #define SERVER_MSG "server finished"
 #define CLIENT_MSG "client finished"
 #define TLS_MSG_LEN 15
-int
+static int
 _gnutls_finished (mhd_gtls_session_t session, int type, void *ret)
 {
   const int siz = TLS_MSG_LEN;
@@ -332,7 +332,7 @@ mhd_gtls_user_hello_func (gnutls_session session,
  * or version 2.0 client hello (only for compatibility
  * since SSL version 2.0 is not supported).
  */
-int
+static int
 _gnutls_read_client_hello (mhd_gtls_session_t session, opaque * data,
                            int datalen)
 {
@@ -509,7 +509,7 @@ _gnutls_handshake_hash_pending (mhd_gtls_session_t session)
  * and initializing encryption. This is the first encrypted message
  * we send.
  */
-int
+static int
 _gnutls_send_finished (mhd_gtls_session_t session, int again)
 {
   uint8_t data[36];
@@ -562,7 +562,7 @@ _gnutls_send_finished (mhd_gtls_session_t session, int again)
 /* This is to be called after sending our finished message. If everything
  * went fine we have negotiated a secure connection
  */
-int
+static int
 _gnutls_recv_finished (mhd_gtls_session_t session)
 {
   uint8_t data[36], *vrfy;
@@ -796,7 +796,7 @@ finish:
 
 /* This selects the best supported compression method from the ones provided
  */
-int
+static int
 _gnutls_server_select_comp_method (mhd_gtls_session_t session,
                                    opaque * data, int datalen)
 {
@@ -850,7 +850,7 @@ _gnutls_server_select_comp_method (mhd_gtls_session_t session,
  * GNUTLS_E_AGAIN or GNUTLS_E_INTERRUPTED, then it must be called again
  * (until it returns ok), with NULL parameters.
  */
-int
+static int
 _gnutls_send_empty_handshake (mhd_gtls_session_t session,
                               gnutls_handshake_description_t type, int again)
 {
@@ -1964,13 +1964,14 @@ int
 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);
 
     }
   else
+#endif
     {                           /* SERVER */
       ret = _gnutls_send_server_hello (session, again);
     }
@@ -1986,7 +1987,7 @@ int
 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);
@@ -1997,6 +1998,7 @@ mhd_gtls_recv_hello (mhd_gtls_session_t session, opaque * data, int datalen)
         }
     }
   else
+#endif
     {                           /* Server side reading a client hello */
 
       ret = _gnutls_read_client_hello (session, data, datalen);
@@ -2126,7 +2128,7 @@ _gnutls_handshake_hash_init (mhd_gtls_session_t session)
   return 0;
 }
 
-int
+static int
 _gnutls_send_supplemental (mhd_gtls_session_t session, int again)
 {
   int ret = 0;
@@ -2156,7 +2158,7 @@ _gnutls_send_supplemental (mhd_gtls_session_t session, int again)
   return ret;
 }
 
-int
+static int
 _gnutls_recv_supplemental (mhd_gtls_session_t session)
 {
   uint8_t *data = NULL;
@@ -2223,12 +2225,13 @@ MHD_gnutls_handshake (mhd_gtls_session_t session)
       gnutls_assert ();
       return ret;
     }
-
+#if MHD_DEBUG_TLS
   if (session->security_parameters.entity == GNUTLS_CLIENT)
     {
       ret = mhd_gtls_handshake_client (session);
     }
   else
+#endif
     {
       ret = mhd_gtls_handshake_server (session);
     }
diff --git a/src/daemon/https/tls/gnutls_handshake.h b/src/daemon/https/tls/gnutls_handshake.h
index 9917fdc7..4651d7fb 100644
--- a/src/daemon/https/tls/gnutls_handshake.h
+++ b/src/daemon/https/tls/gnutls_handshake.h
@@ -37,7 +37,6 @@ int mhd_gtls_recv_handshake (mhd_gtls_session_t session, uint8_t **, int *,
                             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_client (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);
@@ -53,6 +52,10 @@ int mhd_gtls_server_select_suite (mhd_gtls_session_t session, opaque * data,
 int mhd_gtls_negotiate_version( mhd_gtls_session_t session, gnutls_protocol_t adv_version);
 int mhd_gtls_user_hello_func( gnutls_session, gnutls_protocol_t adv_version);
 
+#if MHD_DEBUG_TLS
+int mhd_gtls_handshake_client (mhd_gtls_session_t session);
+#endif
+
 #define STATE session->internals.handshake_state
 /* This returns true if we have got there
  * before (and not finished due to an interrupt).
diff --git a/src/daemon/https/tls/gnutls_mpi.c b/src/daemon/https/tls/gnutls_mpi.c
index 6e2b5c4f..250c9c77 100644
--- a/src/daemon/https/tls/gnutls_mpi.c
+++ b/src/daemon/https/tls/gnutls_mpi.c
@@ -206,7 +206,7 @@ _gnutls_x509_read_int (ASN1_TYPE node, const char *value, mpi_t * ret_mpi)
   if (result != ASN1_MEM_ERROR)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   tmpstr = gnutls_alloca (tmpstr_size);
@@ -221,7 +221,7 @@ _gnutls_x509_read_int (ASN1_TYPE node, const char *value, mpi_t * ret_mpi)
     {
       gnutls_assert ();
       gnutls_afree (tmpstr);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   s_len = tmpstr_size;
@@ -278,7 +278,7 @@ _gnutls_x509_write_int (ASN1_TYPE node, const char *value, mpi_t mpi, int lz)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   return 0;
diff --git a/src/daemon/https/tls/gnutls_pk.c b/src/daemon/https/tls/gnutls_pk.c
index 2e748bab..b1361c0b 100644
--- a/src/daemon/https/tls/gnutls_pk.c
+++ b/src/daemon/https/tls/gnutls_pk.c
@@ -395,7 +395,7 @@ encode_ber_rs (gnutls_datum_t * sig_value, mpi_t r, mpi_t s)
                             &sig)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = _gnutls_x509_write_int (sig, "r", r, 1);
@@ -493,7 +493,7 @@ decode_ber_rs (const gnutls_datum_t * sig_value, mpi_t * r, mpi_t * s)
                             &sig)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = asn1_der_decoding (&sig, sig_value->data, sig_value->size, NULL);
@@ -501,7 +501,7 @@ decode_ber_rs (const gnutls_datum_t * sig_value, mpi_t * r, mpi_t * s)
     {
       gnutls_assert ();
       asn1_delete_structure (&sig);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = _gnutls_x509_read_int (sig, "r", r);
diff --git a/src/daemon/https/tls/gnutls_priority.c b/src/daemon/https/tls/gnutls_priority.c
index e865fd27..c36f898a 100644
--- a/src/daemon/https/tls/gnutls_priority.c
+++ b/src/daemon/https/tls/gnutls_priority.c
@@ -208,30 +208,30 @@ MHD_gnutls_certificate_type_set_priority (mhd_gtls_session_t session,
 #endif
 }
 
-static const int protocol_priority[] = { MHD_GNUTLS_TLS1_1,
+static const int mhd_gtls_protocol_priority[] = { MHD_GNUTLS_TLS1_1,
   MHD_GNUTLS_TLS1_0,
   MHD_GNUTLS_SSL3,
   0
 };
 
-static const int cipher_priority_secure256[] =
+static const int mhd_gtls_cipher_priority_secure256[] =
   { MHD_GNUTLS_CIPHER_AES_256_CBC,
   0
 };
 
-static const int kx_priority_secure[] = { MHD_GNUTLS_KX_RSA,
+static const int mhd_gtls_kx_priority_secure[] = { MHD_GNUTLS_KX_RSA,
   0
 };
 
-static const int mac_priority_secure[] = { MHD_GNUTLS_MAC_SHA1,
+static const int mhd_gtls_mac_priority_secure[] = { MHD_GNUTLS_MAC_SHA1,
   0
 };
 
-static int cert_type_priority[] = { MHD_GNUTLS_CRT_X509,
+static int mhd_gtls_cert_type_priority[] = { MHD_GNUTLS_CRT_X509,
   0
 };
 
-static const int comp_priority[] = { MHD_GNUTLS_COMP_NULL,
+static const int mhd_gtls_comp_priority[] = { MHD_GNUTLS_COMP_NULL,
   0
 };
 
@@ -340,12 +340,12 @@ MHD_tls_set_default_priority (gnutls_priority_t * priority_cache,
     }
 
   /* set mode to "SECURE256" */
-  _set_priority (&(*priority_cache)->protocol, protocol_priority);
-  _set_priority (&(*priority_cache)->cipher, cipher_priority_secure256);
-  _set_priority (&(*priority_cache)->kx, kx_priority_secure);
-  _set_priority (&(*priority_cache)->mac, mac_priority_secure);
-  _set_priority (&(*priority_cache)->cert_type, cert_type_priority);
-  _set_priority (&(*priority_cache)->compression, comp_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);
 
   (*priority_cache)->no_padding = 0;
   return 0;
diff --git a/src/daemon/https/tls/gnutls_session.c b/src/daemon/https/tls/gnutls_session.c
index 94c7405b..afc00966 100644
--- a/src/daemon/https/tls/gnutls_session.c
+++ b/src/daemon/https/tls/gnutls_session.c
@@ -55,7 +55,7 @@
 //
 //  psession.data = session_data;
 //
-//  ret = _gnutls_session_pack (session, &psession);
+//  ret = mhd_gtls_session_pack (session, &psession);
 //  if (ret < 0)
 //    {
 //      gnutls_assert ();
@@ -106,7 +106,7 @@
 //  if (session->internals.resumable == RESUME_FALSE)
 //    return GNUTLS_E_INVALID_SESSION;
 //
-//  ret = _gnutls_session_pack (session, data);
+//  ret = mhd_gtls_session_pack (session, data);
 //  if (ret < 0)
 //    {
 //      gnutls_assert ();
@@ -190,7 +190,7 @@ MHD_gtls_session_get_id (mhd_gtls_session_t session,
 //      gnutls_assert ();
 //      return GNUTLS_E_INVALID_REQUEST;
 //    }
-//  ret = _gnutls_session_unpack (session, &psession);
+//  ret = mhd_gtls_session_unpack (session, &psession);
 //  if (ret < 0)
 //    {
 //      gnutls_assert ();
diff --git a/src/daemon/https/tls/gnutls_session_pack.c b/src/daemon/https/tls/gnutls_session_pack.c
index c11f6d77..545e4a0c 100644
--- a/src/daemon/https/tls/gnutls_session_pack.c
+++ b/src/daemon/https/tls/gnutls_session_pack.c
@@ -227,7 +227,7 @@ error:
  * The data will be in a platform independent format.
  */
 int
-_gnutls_session_pack (mhd_gtls_session_t session,
+mhd_gtls_session_pack (mhd_gtls_session_t session,
                       gnutls_datum_t * packed_session)
 {
   int ret;
@@ -302,7 +302,7 @@ _gnutls_session_pack (mhd_gtls_session_t session,
 /* Load session data from a buffer.
  */
 int
-_gnutls_session_unpack (mhd_gtls_session_t session,
+mhd_gtls_session_unpack (mhd_gtls_session_t session,
                         const gnutls_datum_t * packed_session)
 {
   int ret;
diff --git a/src/daemon/https/tls/gnutls_session_pack.h b/src/daemon/https/tls/gnutls_session_pack.h
index abc3fe46..fa47f9e1 100644
--- a/src/daemon/https/tls/gnutls_session_pack.h
+++ b/src/daemon/https/tls/gnutls_session_pack.h
@@ -22,7 +22,7 @@
  *
  */
 
-int _gnutls_session_pack (mhd_gtls_session_t session,
+int mhd_gtls_session_pack (mhd_gtls_session_t session,
                           gnutls_datum_t * packed_session);
-int _gnutls_session_unpack (mhd_gtls_session_t session,
+int mhd_gtls_session_unpack (mhd_gtls_session_t session,
                             const gnutls_datum_t * packed_session);
diff --git a/src/daemon/https/tls/gnutls_state.c b/src/daemon/https/tls/gnutls_state.c
index bb5b8390..02d87e05 100644
--- a/src/daemon/https/tls/gnutls_state.c
+++ b/src/daemon/https/tls/gnutls_state.c
@@ -429,7 +429,7 @@ mhd_gtls_dh_get_allowed_prime_bits (mhd_gtls_session_t session)
 int
 mhd_gtls_dh_set_peer_public (mhd_gtls_session_t session, mpi_t public)
 {
-  dh_info_st *dh;
+  mhd_gtls_dh_info_st *dh;
   int ret;
 
   switch (MHD_gtls_auth_get_type (session))
@@ -540,7 +540,7 @@ mhd_gtls_rsa_export_set_pubkey (mhd_gtls_session_t session,
 int
 mhd_gtls_dh_set_group (mhd_gtls_session_t session, mpi_t gen, mpi_t prime)
 {
-  dh_info_st *dh;
+  mhd_gtls_dh_info_st *dh;
   int ret;
 
   switch (MHD_gtls_auth_get_type (session))
@@ -1060,6 +1060,7 @@ MHD_gtls_session_get_master_secret (mhd_gtls_session_t session)
 int
 MHD_gtls_session_is_resumed (mhd_gtls_session_t session)
 {
+#if MHD_DEBUG_TLS
   if (session->security_parameters.entity == GNUTLS_CLIENT)
     {
       if (session->security_parameters.session_id_size > 0
@@ -1072,6 +1073,7 @@ MHD_gtls_session_is_resumed (mhd_gtls_session_t session)
         return 1;
     }
   else
+#endif
     {
       if (session->internals.resumed == RESUME_TRUE)
         return 1;
diff --git a/src/daemon/https/tls/gnutls_ui.c b/src/daemon/https/tls/gnutls_ui.c
index b5b0fbee..8a4d9c11 100644
--- a/src/daemon/https/tls/gnutls_ui.c
+++ b/src/daemon/https/tls/gnutls_ui.c
@@ -76,7 +76,7 @@ int
 MHD_gnutls_dh_get_group (mhd_gtls_session_t session,
                      gnutls_datum_t * raw_gen, gnutls_datum_t * raw_prime)
 {
-  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;
@@ -133,7 +133,7 @@ MHD_gnutls_dh_get_group (mhd_gtls_session_t session,
 int
 MHD_gnutls_dh_get_pubkey (mhd_gtls_session_t session, gnutls_datum_t * raw_key)
 {
-  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;
@@ -275,7 +275,7 @@ MHD_gnutls_dh_get_secret_bits (mhd_gtls_session_t session)
 int
 MHD_gnutls_dh_get_prime_bits (mhd_gtls_session_t session)
 {
-  dh_info_st *dh;
+  mhd_gtls_dh_info_st *dh;
 
   switch (MHD_gtls_auth_get_type (session))
     {
@@ -342,7 +342,7 @@ 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)
 {
-  dh_info_st *dh;
+  mhd_gtls_dh_info_st *dh;
 
   switch (MHD_gtls_auth_get_type (session))
     {
diff --git a/src/daemon/https/x509/common.c b/src/daemon/https/x509/common.c
index b31edcec..f3dde1d1 100644
--- a/src/daemon/https/x509/common.c
+++ b/src/daemon/https/x509/common.c
@@ -295,7 +295,7 @@ _gnutls_x509_oid_data2string (const char *oid,
                                      &tmpasn)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   if ((result = asn1_der_decoding (&tmpasn, value, value_size, asn1_err))
@@ -304,7 +304,7 @@ _gnutls_x509_oid_data2string (const char *oid,
       gnutls_assert ();
       _gnutls_x509_log ("asn1_der_decoding: %s:%s\n", str, asn1_err);
       asn1_delete_structure (&tmpasn);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   /* If this is a choice then we read the choice. Otherwise it
@@ -315,7 +315,7 @@ _gnutls_x509_oid_data2string (const char *oid,
     {                           /* CHOICE */
       gnutls_assert ();
       asn1_delete_structure (&tmpasn);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   if (CHOICE == 0)
@@ -352,7 +352,7 @@ _gnutls_x509_oid_data2string (const char *oid,
           != ASN1_SUCCESS)
         {
           asn1_delete_structure (&tmpasn);
-          return _gnutls_asn2err (result);
+          return mhd_gtls_asn2err (result);
         }
 
       asn1_delete_structure (&tmpasn);
@@ -750,7 +750,7 @@ _gnutls_x509_set_time (ASN1_TYPE c2, const char *where, time_t tim)
   if ((result = asn1_write_value (c2, name, "utcTime", 1)) < 0)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = _gnutls_x509_gtime2utcTime (tim, str_time, sizeof (str_time));
@@ -767,7 +767,7 @@ _gnutls_x509_set_time (ASN1_TYPE c2, const char *where, time_t tim)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   return 0;
@@ -820,7 +820,7 @@ _gnutls_x509_export_int (ASN1_TYPE asn1_data,
               return GNUTLS_E_SHORT_MEMORY_BUFFER;
             }
           gnutls_assert ();
-          return _gnutls_asn2err (result);
+          return mhd_gtls_asn2err (result);
         }
 
       *output_data_size = len;
@@ -906,7 +906,7 @@ _gnutls_x509_decode_octet_string (const char *string_type,
                             &c2)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -914,7 +914,7 @@ _gnutls_x509_decode_octet_string (const char *string_type,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -925,7 +925,7 @@ _gnutls_x509_decode_octet_string (const char *string_type,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -955,7 +955,7 @@ _gnutls_x509_read_value (ASN1_TYPE c,
   if (result != ASN1_MEM_ERROR)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       return result;
     }
 
@@ -974,7 +974,7 @@ _gnutls_x509_read_value (ASN1_TYPE c,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -1024,7 +1024,7 @@ _gnutls_x509_der_encode (ASN1_TYPE src,
   if (result != ASN1_MEM_ERROR)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -1047,7 +1047,7 @@ _gnutls_x509_der_encode (ASN1_TYPE src,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -1058,7 +1058,7 @@ _gnutls_x509_der_encode (ASN1_TYPE src,
                                 &c2)) != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          result = _gnutls_asn2err (result);
+          result = mhd_gtls_asn2err (result);
           goto cleanup;
         }
 
@@ -1066,7 +1066,7 @@ _gnutls_x509_der_encode (ASN1_TYPE src,
       if (result != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          result = _gnutls_asn2err (result);
+          result = mhd_gtls_asn2err (result);
           goto cleanup;
         }
 
@@ -1074,7 +1074,7 @@ _gnutls_x509_der_encode (ASN1_TYPE src,
       if (result != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          result = _gnutls_asn2err (result);
+          result = mhd_gtls_asn2err (result);
           goto cleanup;
         }
 
@@ -1124,7 +1124,7 @@ _gnutls_x509_der_encode_and_copy (ASN1_TYPE src,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   return 0;
@@ -1162,7 +1162,7 @@ _gnutls_x509_write_value (ASN1_TYPE c,
                                 &c2)) != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          result = _gnutls_asn2err (result);
+          result = mhd_gtls_asn2err (result);
           goto cleanup;
         }
 
@@ -1170,7 +1170,7 @@ _gnutls_x509_write_value (ASN1_TYPE c,
       if (result != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          result = _gnutls_asn2err (result);
+          result = mhd_gtls_asn2err (result);
           goto cleanup;
         }
 
@@ -1198,7 +1198,7 @@ _gnutls_x509_write_value (ASN1_TYPE c,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   return 0;
@@ -1241,7 +1241,7 @@ _gnutls_x509_encode_and_copy_PKI_params (ASN1_TYPE dst,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   if (pk_algorithm == MHD_GNUTLS_PK_RSA)
@@ -1254,7 +1254,7 @@ _gnutls_x509_encode_and_copy_PKI_params (ASN1_TYPE dst,
       if (result != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          return _gnutls_asn2err (result);
+          return mhd_gtls_asn2err (result);
         }
 
       result = _gnutls_x509_write_rsa_params (params, params_size, &der);
@@ -1275,7 +1275,7 @@ _gnutls_x509_encode_and_copy_PKI_params (ASN1_TYPE dst,
       if (result != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          return _gnutls_asn2err (result);
+          return mhd_gtls_asn2err (result);
         }
     }
   else
@@ -1308,7 +1308,7 @@ _gnutls_x509_get_pk_algorithm (ASN1_TYPE src,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   algo = mhd_gtls_x509_oid2pk_algorithm (oid);
@@ -1329,7 +1329,7 @@ _gnutls_x509_get_pk_algorithm (ASN1_TYPE src,
   if (result != ASN1_MEM_ERROR)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   if (len % 8 != 0)
@@ -1356,7 +1356,7 @@ _gnutls_x509_get_pk_algorithm (ASN1_TYPE src,
     {
       gnutls_assert ();
       gnutls_free (str);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   len /= 8;
@@ -1410,7 +1410,7 @@ _gnutls_x509_get_signed_data (ASN1_TYPE src,
                                        &start, &end);
   if (result != ASN1_SUCCESS)
     {
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       gnutls_assert ();
       goto cleanup;
     }
@@ -1449,7 +1449,7 @@ _gnutls_x509_get_signature (ASN1_TYPE src,
 
   if (result != ASN1_MEM_ERROR)
     {
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       gnutls_assert ();
       goto cleanup;
     }
@@ -1478,7 +1478,7 @@ _gnutls_x509_get_signature (ASN1_TYPE src,
 
   if (result != ASN1_SUCCESS)
     {
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       gnutls_assert ();
       goto cleanup;
     }
diff --git a/src/daemon/https/x509/crl.c b/src/daemon/https/x509/crl.c
index 80dd6f9e..98eb4806 100644
--- a/src/daemon/https/x509/crl.c
+++ b/src/daemon/https/x509/crl.c
@@ -62,7 +62,7 @@ gnutls_x509_crl_init (gnutls_x509_crl_t * crl)
         {
           gnutls_assert ();
           gnutls_free (*crl);
-          return _gnutls_asn2err (result);
+          return mhd_gtls_asn2err (result);
         }
       return 0;                 /* success */
     }
@@ -145,7 +145,7 @@ gnutls_x509_crl_import (gnutls_x509_crl_t crl,
   result = asn1_der_decoding (&crl->crl, _data.data, _data.size, NULL);
   if (result != ASN1_SUCCESS)
     {
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       gnutls_assert ();
       goto cleanup;
     }
@@ -340,7 +340,7 @@ gnutls_x509_crl_get_signature (gnutls_x509_crl_t crl,
   if (result != ASN1_MEM_ERROR)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   if (bits % 8 != 0)
@@ -361,7 +361,7 @@ gnutls_x509_crl_get_signature (gnutls_x509_crl_t crl,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   return 0;
@@ -394,7 +394,7 @@ gnutls_x509_crl_get_version (gnutls_x509_crl_t crl)
                         &len)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   return (int) version[0] + 1;
@@ -523,7 +523,7 @@ gnutls_x509_crl_get_crt_serial (gnutls_x509_crl_t crl, int indx,
       gnutls_assert ();
       if (result == ASN1_ELEMENT_NOT_FOUND)
         return GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE;
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   if (t)
@@ -567,7 +567,7 @@ _gnutls_x509_crl_get_raw_issuer_dn (gnutls_x509_crl_t crl,
                             &c2)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result =
@@ -585,7 +585,7 @@ _gnutls_x509_crl_get_raw_issuer_dn (gnutls_x509_crl_t crl,
       /* couldn't decode DER */
       gnutls_assert ();
       asn1_delete_structure (&c2);
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -597,7 +597,7 @@ _gnutls_x509_crl_get_raw_issuer_dn (gnutls_x509_crl_t crl,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
diff --git a/src/daemon/https/x509/crl_write.c b/src/daemon/https/x509/crl_write.c
index 465f1782..7f4e246a 100644
--- a/src/daemon/https/x509/crl_write.c
+++ b/src/daemon/https/x509/crl_write.c
@@ -76,7 +76,7 @@ gnutls_x509_crl_set_version (gnutls_x509_crl_t crl, unsigned int version)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   return 0;
@@ -220,7 +220,7 @@ gnutls_x509_crl_set_crt_serial (gnutls_x509_crl_t crl,
   if (ret != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (ret);
+      return mhd_gtls_asn2err (ret);
     }
 
   ret =
@@ -230,7 +230,7 @@ gnutls_x509_crl_set_crt_serial (gnutls_x509_crl_t crl,
   if (ret != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (ret);
+      return mhd_gtls_asn2err (ret);
     }
 
   ret =
@@ -250,7 +250,7 @@ gnutls_x509_crl_set_crt_serial (gnutls_x509_crl_t crl,
   if (ret != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (ret);
+      return mhd_gtls_asn2err (ret);
     }
 
   return 0;
@@ -295,7 +295,7 @@ gnutls_x509_crl_set_crt (gnutls_x509_crl_t crl, gnutls_x509_crt_t crt,
   if (ret < 0)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (ret);
+      return mhd_gtls_asn2err (ret);
     }
 
   return 0;
diff --git a/src/daemon/https/x509/crq.c b/src/daemon/https/x509/crq.c
index 6ce01583..5efbd5cc 100644
--- a/src/daemon/https/x509/crq.c
+++ b/src/daemon/https/x509/crq.c
@@ -65,7 +65,7 @@ gnutls_x509_crq_init (gnutls_x509_crq_t * crq)
         {
           gnutls_assert ();
           gnutls_free (*crq);
-          return _gnutls_asn2err (result);
+          return mhd_gtls_asn2err (result);
         }
       return 0;                 /* success */
     }
@@ -155,7 +155,7 @@ gnutls_x509_crq_import (gnutls_x509_crq_t crq,
   result = asn1_der_decoding (&crq->crq, _data.data, _data.size, NULL);
   if (result != ASN1_SUCCESS)
     {
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       gnutls_assert ();
       goto cleanup;
     }
@@ -330,7 +330,7 @@ parse_attribute (ASN1_TYPE asn1_struct,
       if (result != ASN1_VALUE_NOT_FOUND)
         {
           gnutls_assert ();
-          result = _gnutls_asn2err (result);
+          result = mhd_gtls_asn2err (result);
           goto cleanup;
         }
 
@@ -349,7 +349,7 @@ parse_attribute (ASN1_TYPE asn1_struct,
       else if (result != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          result = _gnutls_asn2err (result);
+          result = mhd_gtls_asn2err (result);
           goto cleanup;
         }
 
@@ -367,7 +367,7 @@ parse_attribute (ASN1_TYPE asn1_struct,
           if (result != ASN1_SUCCESS)
             {
               gnutls_assert ();
-              result = _gnutls_asn2err (result);
+              result = mhd_gtls_asn2err (result);
               goto cleanup;
             }
 
@@ -480,7 +480,7 @@ gnutls_x509_crq_set_attribute_by_oid (gnutls_x509_crq_t crq,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result =
@@ -594,7 +594,7 @@ gnutls_x509_crq_set_version (gnutls_x509_crq_t crq, unsigned int version)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   return 0;
@@ -630,7 +630,7 @@ gnutls_x509_crq_get_version (gnutls_x509_crq_t crq)
       if (result == ASN1_ELEMENT_NOT_FOUND)
         return 1;               /* the DEFAULT version */
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   return (int) version[0] + 1;
@@ -703,7 +703,7 @@ gnutls_x509_crq_set_challenge_password (gnutls_x509_crq_t crq,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result =
@@ -774,7 +774,7 @@ gnutls_x509_crq_sign2 (gnutls_x509_crq_t crq, gnutls_x509_privkey_t key,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   /* Step 3. Write the signatureAlgorithm field.
diff --git a/src/daemon/https/x509/dn.c b/src/daemon/https/x509/dn.c
index 57f71330..784ac4a7 100644
--- a/src/daemon/https/x509/dn.c
+++ b/src/daemon/https/x509/dn.c
@@ -141,7 +141,7 @@ _gnutls_x509_parse_dn (ASN1_TYPE asn1_struct,
       if (result != ASN1_VALUE_NOT_FOUND)
         {
           gnutls_assert ();
-          result = _gnutls_asn2err (result);
+          result = mhd_gtls_asn2err (result);
           goto cleanup;
         }
 
@@ -169,7 +169,7 @@ _gnutls_x509_parse_dn (ASN1_TYPE asn1_struct,
           if (result != ASN1_VALUE_NOT_FOUND)
             {
               gnutls_assert ();
-              result = _gnutls_asn2err (result);
+              result = mhd_gtls_asn2err (result);
               goto cleanup;
             }
 
@@ -186,7 +186,7 @@ _gnutls_x509_parse_dn (ASN1_TYPE asn1_struct,
           else if (result != ASN1_SUCCESS)
             {
               gnutls_assert ();
-              result = _gnutls_asn2err (result);
+              result = mhd_gtls_asn2err (result);
               goto cleanup;
             }
 
@@ -211,7 +211,7 @@ _gnutls_x509_parse_dn (ASN1_TYPE asn1_struct,
           if (result != ASN1_SUCCESS)
             {
               gnutls_assert ();
-              result = _gnutls_asn2err (result);
+              result = mhd_gtls_asn2err (result);
               goto cleanup;
             }
 #define STR_APPEND(y) if ((result=mhd_gtls_string_append_str( &out_str, y)) < 0) { \
@@ -382,7 +382,7 @@ _gnutls_x509_parse_dn_oid (ASN1_TYPE asn1_struct,
       if (result != ASN1_VALUE_NOT_FOUND)
         {
           gnutls_assert ();
-          result = _gnutls_asn2err (result);
+          result = mhd_gtls_asn2err (result);
           goto cleanup;
         }
 
@@ -412,7 +412,7 @@ _gnutls_x509_parse_dn_oid (ASN1_TYPE asn1_struct,
           if (result != ASN1_VALUE_NOT_FOUND)
             {
               gnutls_assert ();
-              result = _gnutls_asn2err (result);
+              result = mhd_gtls_asn2err (result);
               goto cleanup;
             }
 
@@ -429,7 +429,7 @@ _gnutls_x509_parse_dn_oid (ASN1_TYPE asn1_struct,
           else if (result != ASN1_SUCCESS)
             {
               gnutls_assert ();
-              result = _gnutls_asn2err (result);
+              result = mhd_gtls_asn2err (result);
               goto cleanup;
             }
 
@@ -449,7 +449,7 @@ _gnutls_x509_parse_dn_oid (ASN1_TYPE asn1_struct,
                   gnutls_assert ();
                   if (result == ASN1_MEM_ERROR)
                     *sizeof_buf = len;
-                  result = _gnutls_asn2err (result);
+                  result = mhd_gtls_asn2err (result);
                   goto cleanup;
                 }
 
@@ -551,7 +551,7 @@ _gnutls_x509_get_dn_oid (ASN1_TYPE asn1_struct,
       if (result != ASN1_VALUE_NOT_FOUND)
         {
           gnutls_assert ();
-          result = _gnutls_asn2err (result);
+          result = mhd_gtls_asn2err (result);
           goto cleanup;
         }
 
@@ -581,7 +581,7 @@ _gnutls_x509_get_dn_oid (ASN1_TYPE asn1_struct,
           if (result != ASN1_VALUE_NOT_FOUND)
             {
               gnutls_assert ();
-              result = _gnutls_asn2err (result);
+              result = mhd_gtls_asn2err (result);
               goto cleanup;
             }
 
@@ -598,7 +598,7 @@ _gnutls_x509_get_dn_oid (ASN1_TYPE asn1_struct,
           else if (result != ASN1_SUCCESS)
             {
               gnutls_assert ();
-              result = _gnutls_asn2err (result);
+              result = mhd_gtls_asn2err (result);
               goto cleanup;
             }
 
@@ -667,7 +667,7 @@ _gnutls_x509_encode_and_write_attribute (const char *given_oid,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   tmp[0] = 0;
@@ -699,7 +699,7 @@ _gnutls_x509_encode_and_write_attribute (const char *given_oid,
         {
           gnutls_assert ();
           asn1_delete_structure (&c2);
-          return _gnutls_asn2err (result);
+          return mhd_gtls_asn2err (result);
         }
 
       mhd_gtls_str_cpy (tmp, sizeof (tmp), string_type);
@@ -710,7 +710,7 @@ _gnutls_x509_encode_and_write_attribute (const char *given_oid,
     {
       gnutls_assert ();
       asn1_delete_structure (&c2);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
 
@@ -728,7 +728,7 @@ _gnutls_x509_encode_and_write_attribute (const char *given_oid,
       if (result != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          return _gnutls_asn2err (result);
+          return mhd_gtls_asn2err (result);
         }
 
       mhd_gtls_str_cat (tmp, sizeof (tmp), ".?LAST");
@@ -751,7 +751,7 @@ _gnutls_x509_encode_and_write_attribute (const char *given_oid,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   return 0;
@@ -783,7 +783,7 @@ _gnutls_x509_write_attribute (const char *given_oid,
       if (result != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          return _gnutls_asn2err (result);
+          return mhd_gtls_asn2err (result);
         }
 
       mhd_gtls_str_cat (tmp, sizeof (tmp), ".?LAST");
@@ -794,7 +794,7 @@ _gnutls_x509_write_attribute (const char *given_oid,
   if (result < 0)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   /* write the type
@@ -806,7 +806,7 @@ _gnutls_x509_write_attribute (const char *given_oid,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   return 0;
@@ -841,7 +841,7 @@ _gnutls_x509_decode_and_read_attribute (ASN1_TYPE asn1_struct,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       return result;
     }
 
@@ -893,7 +893,7 @@ _gnutls_x509_set_dn_oid (ASN1_TYPE asn1_struct,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   mhd_gtls_str_cpy (asn1_rdn_name, sizeof (asn1_rdn_name), asn1_name);
@@ -905,7 +905,7 @@ _gnutls_x509_set_dn_oid (ASN1_TYPE asn1_struct,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   mhd_gtls_str_cpy (tmp, sizeof (tmp), asn1_rdn_name);
@@ -917,7 +917,7 @@ _gnutls_x509_set_dn_oid (ASN1_TYPE asn1_struct,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
 
@@ -987,7 +987,7 @@ gnutls_x509_rdn_get (const gnutls_datum_t * idn,
                             "PKIX1.Name", &dn)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = asn1_der_decoding (&dn, idn->data, idn->size, NULL);
@@ -996,7 +996,7 @@ gnutls_x509_rdn_get (const gnutls_datum_t * idn,
       /* couldn't decode DER */
       gnutls_assert ();
       asn1_delete_structure (&dn);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = _gnutls_x509_parse_dn (dn, "rdnSequence", buf, sizeof_buf);
@@ -1042,7 +1042,7 @@ gnutls_x509_rdn_get_by_oid (const gnutls_datum_t * idn, const char *oid,
                             "PKIX1.Name", &dn)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = asn1_der_decoding (&dn, idn->data, idn->size, NULL);
@@ -1051,7 +1051,7 @@ gnutls_x509_rdn_get_by_oid (const gnutls_datum_t * idn, const char *oid,
       /* couldn't decode DER */
       gnutls_assert ();
       asn1_delete_structure (&dn);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result =
@@ -1094,7 +1094,7 @@ gnutls_x509_rdn_get_oid (const gnutls_datum_t * idn,
                             "PKIX1.Name", &dn)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = asn1_der_decoding (&dn, idn->data, idn->size, NULL);
@@ -1103,7 +1103,7 @@ gnutls_x509_rdn_get_oid (const gnutls_datum_t * idn,
       /* couldn't decode DER */
       gnutls_assert ();
       asn1_delete_structure (&dn);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = _gnutls_x509_get_dn_oid (dn, "rdnSequence", indx, buf, sizeof_buf);
diff --git a/src/daemon/https/x509/extensions.c b/src/daemon/https/x509/extensions.c
index ddabd429..ea3891b0 100644
--- a/src/daemon/https/x509/extensions.c
+++ b/src/daemon/https/x509/extensions.c
@@ -96,7 +96,7 @@ _gnutls_x509_crt_get_extension (gnutls_x509_crt_t cert,
           else if (result != ASN1_SUCCESS)
             {
               gnutls_assert ();
-              return _gnutls_asn2err (result);
+              return mhd_gtls_asn2err (result);
             }
 
           /* Handle Extension 
@@ -123,7 +123,7 @@ _gnutls_x509_crt_get_extension (gnutls_x509_crt_t cert,
               else if (result != ASN1_SUCCESS)
                 {
                   gnutls_assert ();
-                  return _gnutls_asn2err (result);
+                  return mhd_gtls_asn2err (result);
                 }
 
               if (str_critical[0] == 'T')
@@ -165,7 +165,7 @@ _gnutls_x509_crt_get_extension (gnutls_x509_crt_t cert,
   else
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 }
 
@@ -220,7 +220,7 @@ _gnutls_x509_crt_get_extension_oid (gnutls_x509_crt_t cert,
           else if (result != ASN1_SUCCESS)
             {
               gnutls_assert ();
-              return _gnutls_asn2err (result);
+              return mhd_gtls_asn2err (result);
             }
 
           /* Handle Extension 
@@ -255,7 +255,7 @@ _gnutls_x509_crt_get_extension_oid (gnutls_x509_crt_t cert,
   else
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 }
 
@@ -277,7 +277,7 @@ set_extension (ASN1_TYPE asn, const char *extension_id,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result =
@@ -286,7 +286,7 @@ set_extension (ASN1_TYPE asn, const char *extension_id,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   if (critical == 0)
@@ -301,7 +301,7 @@ set_extension (ASN1_TYPE asn, const char *extension_id,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result =
@@ -342,7 +342,7 @@ overwrite_extension (ASN1_TYPE asn, unsigned int indx,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   mhd_gtls_str_cpy (name2, sizeof (name2), name);
@@ -411,7 +411,7 @@ _gnutls_x509_crt_set_extension (gnutls_x509_crt_t cert,
           else if (result != ASN1_SUCCESS)
             {
               gnutls_assert ();
-              return _gnutls_asn2err (result);
+              return mhd_gtls_asn2err (result);
             }
 
           /* Handle Extension 
@@ -436,7 +436,7 @@ _gnutls_x509_crt_set_extension (gnutls_x509_crt_t cert,
   else
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
 
@@ -462,7 +462,7 @@ _gnutls_x509_ext_extract_keyUsage (uint16_t * keyUsage,
        (_gnutls_get_pkix (), "PKIX1.KeyUsage", &ext)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = asn1_der_decoding (&ext, extnValue, extnValueLen, NULL);
@@ -471,7 +471,7 @@ _gnutls_x509_ext_extract_keyUsage (uint16_t * keyUsage,
     {
       gnutls_assert ();
       asn1_delete_structure (&ext);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   len = sizeof (str);
@@ -506,7 +506,7 @@ _gnutls_x509_ext_extract_basicConstraints (int *CA,
        (_gnutls_get_pkix (), "PKIX1.BasicConstraints", &ext)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = asn1_der_decoding (&ext, extnValue, extnValueLen, NULL);
@@ -514,7 +514,7 @@ _gnutls_x509_ext_extract_basicConstraints (int *CA,
     {
       gnutls_assert ();
       asn1_delete_structure (&ext);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   if (pathLenConstraint)
@@ -527,7 +527,7 @@ _gnutls_x509_ext_extract_basicConstraints (int *CA,
         {
           gnutls_assert ();
           asn1_delete_structure (&ext);
-          return _gnutls_asn2err (result);
+          return mhd_gtls_asn2err (result);
         }
     }
 
@@ -569,7 +569,7 @@ _gnutls_x509_ext_gen_basicConstraints (int CA,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = asn1_write_value (ext, "cA", str, 1);
@@ -577,14 +577,14 @@ _gnutls_x509_ext_gen_basicConstraints (int CA,
     {
       gnutls_assert ();
       asn1_delete_structure (&ext);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   if (pathLenConstraint < 0)
     {
       result = asn1_write_value (ext, "pathLenConstraint", NULL, 0);
       if (result < 0)
-        result = _gnutls_asn2err (result);
+        result = mhd_gtls_asn2err (result);
     }
   else
     result = _gnutls_x509_write_uint32 (ext, "pathLenConstraint",
@@ -623,7 +623,7 @@ _gnutls_x509_ext_gen_keyUsage (uint16_t usage, gnutls_datum_t * der_ext)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   str[0] = usage & 0xff;
@@ -634,7 +634,7 @@ _gnutls_x509_ext_gen_keyUsage (uint16_t usage, gnutls_datum_t * der_ext)
     {
       gnutls_assert ();
       asn1_delete_structure (&ext);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = _gnutls_x509_der_encode (ext, "", der_ext, 0);
@@ -663,7 +663,7 @@ write_new_general_name (ASN1_TYPE ext, const char *ext_name,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   switch (type)
@@ -699,7 +699,7 @@ write_new_general_name (ASN1_TYPE ext, const char *ext_name,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   mhd_gtls_str_cat (name, sizeof (name), ".");
@@ -710,7 +710,7 @@ write_new_general_name (ASN1_TYPE ext, const char *ext_name,
     {
       gnutls_assert ();
       asn1_delete_structure (&ext);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   return 0;
@@ -732,7 +732,7 @@ _gnutls_x509_ext_gen_subject_alt_name (gnutls_x509_subject_alt_name_t
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = write_new_general_name (ext, "", type, data_string);
@@ -771,7 +771,7 @@ _gnutls_x509_ext_gen_key_id (const void *id, size_t id_size,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = asn1_write_value (ext, "", id, id_size);
@@ -779,7 +779,7 @@ _gnutls_x509_ext_gen_key_id (const void *id, size_t id_size,
     {
       gnutls_assert ();
       asn1_delete_structure (&ext);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = _gnutls_x509_der_encode (ext, "", der_ext, 0);
@@ -810,7 +810,7 @@ _gnutls_x509_ext_gen_auth_key_id (const void *id, size_t id_size,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = asn1_write_value (ext, "keyIdentifier", id, id_size);
@@ -818,7 +818,7 @@ _gnutls_x509_ext_gen_auth_key_id (const void *id, size_t id_size,
     {
       gnutls_assert ();
       asn1_delete_structure (&ext);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   asn1_write_value (ext, "authorityCertIssuer", NULL, 0);
@@ -863,7 +863,7 @@ _gnutls_x509_ext_gen_crl_dist_points (gnutls_x509_subject_alt_name_t
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -871,7 +871,7 @@ _gnutls_x509_ext_gen_crl_dist_points (gnutls_x509_subject_alt_name_t
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -881,7 +881,7 @@ _gnutls_x509_ext_gen_crl_dist_points (gnutls_x509_subject_alt_name_t
       if (result != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          result = _gnutls_asn2err (result);
+          result = mhd_gtls_asn2err (result);
           goto cleanup;
         }
     }
@@ -891,7 +891,7 @@ _gnutls_x509_ext_gen_crl_dist_points (gnutls_x509_subject_alt_name_t
       if (result != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          result = _gnutls_asn2err (result);
+          result = mhd_gtls_asn2err (result);
           goto cleanup;
         }
     }
@@ -900,7 +900,7 @@ _gnutls_x509_ext_gen_crl_dist_points (gnutls_x509_subject_alt_name_t
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -910,7 +910,7 @@ _gnutls_x509_ext_gen_crl_dist_points (gnutls_x509_subject_alt_name_t
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -964,7 +964,7 @@ _gnutls_x509_ext_extract_proxyCertInfo (int *pathLenConstraint,
        (_gnutls_get_pkix (), "PKIX1.ProxyCertInfo", &ext)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = asn1_der_decoding (&ext, extnValue, extnValueLen, NULL);
@@ -972,7 +972,7 @@ _gnutls_x509_ext_extract_proxyCertInfo (int *pathLenConstraint,
     {
       gnutls_assert ();
       asn1_delete_structure (&ext);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   if (pathLenConstraint)
@@ -984,7 +984,7 @@ _gnutls_x509_ext_extract_proxyCertInfo (int *pathLenConstraint,
       else if (result != GNUTLS_E_SUCCESS)
         {
           asn1_delete_structure (&ext);
-          return _gnutls_asn2err (result);
+          return mhd_gtls_asn2err (result);
         }
     }
 
@@ -1044,14 +1044,14 @@ _gnutls_x509_ext_gen_proxyCertInfo (int pathLenConstraint,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   if (pathLenConstraint < 0)
     {
       result = asn1_write_value (ext, "pCPathLenConstraint", NULL, 0);
       if (result < 0)
-        result = _gnutls_asn2err (result);
+        result = mhd_gtls_asn2err (result);
     }
   else
     result = _gnutls_x509_write_uint32 (ext, "pCPathLenConstraint",
@@ -1069,7 +1069,7 @@ _gnutls_x509_ext_gen_proxyCertInfo (int pathLenConstraint,
     {
       gnutls_assert ();
       asn1_delete_structure (&ext);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = asn1_write_value (ext, "proxyPolicy.policy",
@@ -1078,7 +1078,7 @@ _gnutls_x509_ext_gen_proxyCertInfo (int pathLenConstraint,
     {
       gnutls_assert ();
       asn1_delete_structure (&ext);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = _gnutls_x509_der_encode (ext, "", der_ext, 0);
diff --git a/src/daemon/https/x509/mpi.c b/src/daemon/https/x509/mpi.c
index b0ba7393..25a9443d 100644
--- a/src/daemon/https/x509/mpi.c
+++ b/src/daemon/https/x509/mpi.c
@@ -48,7 +48,7 @@ _gnutls_x509_read_rsa_params (opaque * der, int dersize, mpi_t * params)
                             &spk)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = asn1_der_decoding (&spk, der, dersize, NULL);
@@ -57,7 +57,7 @@ _gnutls_x509_read_rsa_params (opaque * der, int dersize, mpi_t * params)
     {
       gnutls_assert ();
       asn1_delete_structure (&spk);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   if ((result = _gnutls_x509_read_int (spk, "modulus", &params[0])) < 0)
@@ -97,7 +97,7 @@ _gnutls_x509_read_dsa_params (opaque * der, int dersize, mpi_t * params)
                             &spk)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = asn1_der_decoding (&spk, der, dersize, NULL);
@@ -106,7 +106,7 @@ _gnutls_x509_read_dsa_params (opaque * der, int dersize, mpi_t * params)
     {
       gnutls_assert ();
       asn1_delete_structure (&spk);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   /* FIXME: If the parameters are not included in the certificate
@@ -165,7 +165,7 @@ _gnutls_x509_read_der_int (opaque * der, int dersize, mpi_t * out)
                             &spk)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = asn1_der_decoding (&spk, der, dersize, NULL);
@@ -174,7 +174,7 @@ _gnutls_x509_read_der_int (opaque * der, int dersize, mpi_t * out)
     {
       gnutls_assert ();
       asn1_delete_structure (&spk);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   /* Read Y */
@@ -183,7 +183,7 @@ _gnutls_x509_read_der_int (opaque * der, int dersize, mpi_t * out)
     {
       gnutls_assert ();
       asn1_delete_structure (&spk);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   asn1_delete_structure (&spk);
@@ -296,7 +296,7 @@ _gnutls_x509_write_rsa_params (mpi_t * params,
                             &spk)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = _gnutls_x509_write_int (spk, "modulus", params[0], 0);
@@ -359,7 +359,7 @@ _gnutls_x509_write_sig_params (ASN1_TYPE dst,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   mhd_gtls_str_cpy (name, sizeof (name), dst_name);
@@ -375,7 +375,7 @@ _gnutls_x509_write_sig_params (ASN1_TYPE dst,
            * may have been disabled before.
            */
           gnutls_assert ();
-          return _gnutls_asn2err (result);
+          return mhd_gtls_asn2err (result);
         }
     }
 
@@ -410,7 +410,7 @@ _gnutls_x509_write_dsa_params (mpi_t * params,
                             &spk)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = _gnutls_x509_write_int (spk, "p", params[0], 0);
@@ -475,7 +475,7 @@ _gnutls_x509_write_dsa_public_key (mpi_t * params,
                             &spk)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = _gnutls_x509_write_int (spk, "", params[3], 0);
@@ -514,7 +514,7 @@ _gnutls_x509_read_uint (ASN1_TYPE node, const char *value, unsigned int *ret)
   if (result != ASN1_MEM_ERROR)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   tmpstr = gnutls_alloca (len);
@@ -530,7 +530,7 @@ _gnutls_x509_read_uint (ASN1_TYPE node, const char *value, unsigned int *ret)
     {
       gnutls_assert ();
       gnutls_afree (tmpstr);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   if (len == 1)
@@ -568,7 +568,7 @@ _gnutls_x509_write_uint32 (ASN1_TYPE node, const char *value, uint32_t num)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   return 0;
diff --git a/src/daemon/https/x509/pkcs12.c b/src/daemon/https/x509/pkcs12.c
index df4a2d99..3d1705ab 100644
--- a/src/daemon/https/x509/pkcs12.c
+++ b/src/daemon/https/x509/pkcs12.c
@@ -59,7 +59,7 @@ _decode_pkcs12_auth_safe (ASN1_TYPE pkcs12, ASN1_TYPE * authen_safe,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   if (strcmp (oid, DATA_OID) != 0)
@@ -89,7 +89,7 @@ _decode_pkcs12_auth_safe (ASN1_TYPE pkcs12, ASN1_TYPE * authen_safe,
         &c2)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -97,7 +97,7 @@ _decode_pkcs12_auth_safe (ASN1_TYPE pkcs12, ASN1_TYPE * authen_safe,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -150,7 +150,7 @@ gnutls_pkcs12_init (gnutls_pkcs12_t * pkcs12)
         {
           gnutls_assert ();
           gnutls_free (*pkcs12);
-          return _gnutls_asn2err (result);
+          return mhd_gtls_asn2err (result);
         }
       return 0;                 /* success */
     }
@@ -234,7 +234,7 @@ gnutls_pkcs12_import (gnutls_pkcs12_t pkcs12,
   result = asn1_der_decoding (&pkcs12->pkcs12, _data.data, _data.size, NULL);
   if (result != ASN1_SUCCESS)
     {
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       gnutls_assert ();
       goto cleanup;
     }
@@ -360,7 +360,7 @@ _pkcs12_decode_safe_contents (const gnutls_datum_t * content,
         &c2)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -368,7 +368,7 @@ _pkcs12_decode_safe_contents (const gnutls_datum_t * content,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -378,7 +378,7 @@ _pkcs12_decode_safe_contents (const gnutls_datum_t * content,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -394,7 +394,7 @@ _pkcs12_decode_safe_contents (const gnutls_datum_t * content,
       if (result != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          result = _gnutls_asn2err (result);
+          result = mhd_gtls_asn2err (result);
           goto cleanup;
         }
 
@@ -443,7 +443,7 @@ _pkcs12_decode_safe_contents (const gnutls_datum_t * content,
       if (result != ASN1_SUCCESS && result != ASN1_ELEMENT_NOT_FOUND)
         {
           gnutls_assert ();
-          result = _gnutls_asn2err (result);
+          result = mhd_gtls_asn2err (result);
           goto cleanup;
         }
 
@@ -619,7 +619,7 @@ gnutls_pkcs12_get_bag (gnutls_pkcs12_t pkcs12,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -669,7 +669,7 @@ create_empty_pfx (ASN1_TYPE pkcs12)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -679,7 +679,7 @@ create_empty_pfx (ASN1_TYPE pkcs12)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -692,7 +692,7 @@ create_empty_pfx (ASN1_TYPE pkcs12)
         &c2)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -777,7 +777,7 @@ gnutls_pkcs12_set_bag (gnutls_pkcs12_t pkcs12, gnutls_pkcs12_bag_t bag)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -788,7 +788,7 @@ gnutls_pkcs12_set_bag (gnutls_pkcs12_t pkcs12, gnutls_pkcs12_bag_t bag)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -803,7 +803,7 @@ gnutls_pkcs12_set_bag (gnutls_pkcs12_t pkcs12, gnutls_pkcs12_bag_t bag)
       if (result != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          result = _gnutls_asn2err (result);
+          result = mhd_gtls_asn2err (result);
           goto cleanup;
         }
     }
@@ -884,7 +884,7 @@ gnutls_pkcs12_generate_mac (gnutls_pkcs12_t pkcs12, const char *pass)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -944,7 +944,7 @@ gnutls_pkcs12_generate_mac (gnutls_pkcs12_t pkcs12, const char *pass)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -954,7 +954,7 @@ gnutls_pkcs12_generate_mac (gnutls_pkcs12_t pkcs12, const char *pass)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -965,7 +965,7 @@ gnutls_pkcs12_generate_mac (gnutls_pkcs12_t pkcs12, const char *pass)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -1023,7 +1023,7 @@ gnutls_pkcs12_verify_mac (gnutls_pkcs12_t pkcs12, const char *pass)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -1070,7 +1070,7 @@ gnutls_pkcs12_verify_mac (gnutls_pkcs12_t pkcs12, const char *pass)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -1108,7 +1108,7 @@ write_attributes (gnutls_pkcs12_bag_t bag, int elem,
       if (result != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          return _gnutls_asn2err (result);
+          return mhd_gtls_asn2err (result);
         }
 
       return 0;
@@ -1123,7 +1123,7 @@ write_attributes (gnutls_pkcs12_bag_t bag, int elem,
       if (result != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          return _gnutls_asn2err (result);
+          return mhd_gtls_asn2err (result);
         }
 
       mhd_gtls_str_cpy (root, sizeof (root), where);
@@ -1154,7 +1154,7 @@ write_attributes (gnutls_pkcs12_bag_t bag, int elem,
       if (result != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          return _gnutls_asn2err (result);
+          return mhd_gtls_asn2err (result);
         }
 
       /* convert name to BMPString
@@ -1224,7 +1224,7 @@ _pkcs12_encode_safe_contents (gnutls_pkcs12_bag_t bag, ASN1_TYPE * contents,
         &c2)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -1242,7 +1242,7 @@ _pkcs12_encode_safe_contents (gnutls_pkcs12_bag_t bag, ASN1_TYPE * contents,
       if (result != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          result = _gnutls_asn2err (result);
+          result = mhd_gtls_asn2err (result);
           goto cleanup;
         }
 
@@ -1252,7 +1252,7 @@ _pkcs12_encode_safe_contents (gnutls_pkcs12_bag_t bag, ASN1_TYPE * contents,
       if (result != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          result = _gnutls_asn2err (result);
+          result = mhd_gtls_asn2err (result);
           goto cleanup;
         }
 
diff --git a/src/daemon/https/x509/pkcs12_bag.c b/src/daemon/https/x509/pkcs12_bag.c
index c34ec757..780dfb52 100644
--- a/src/daemon/https/x509/pkcs12_bag.c
+++ b/src/daemon/https/x509/pkcs12_bag.c
@@ -185,7 +185,7 @@ _pkcs12_decode_crt_bag (gnutls_pkcs12_bag_type_t type,
                                       &c2)) != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          ret = _gnutls_asn2err (ret);
+          ret = mhd_gtls_asn2err (ret);
           goto cleanup;
         }
 
@@ -193,7 +193,7 @@ _pkcs12_decode_crt_bag (gnutls_pkcs12_bag_type_t type,
       if (ret != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          ret = _gnutls_asn2err (ret);
+          ret = mhd_gtls_asn2err (ret);
           goto cleanup;
         }
 
@@ -212,7 +212,7 @@ _pkcs12_decode_crt_bag (gnutls_pkcs12_bag_type_t type,
                                       &c2)) != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          ret = _gnutls_asn2err (ret);
+          ret = mhd_gtls_asn2err (ret);
           goto cleanup;
         }
 
@@ -220,7 +220,7 @@ _pkcs12_decode_crt_bag (gnutls_pkcs12_bag_type_t type,
       if (ret != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          ret = _gnutls_asn2err (ret);
+          ret = mhd_gtls_asn2err (ret);
           goto cleanup;
         }
 
@@ -258,7 +258,7 @@ _pkcs12_encode_crt_bag (gnutls_pkcs12_bag_type_t type,
                                       &c2)) != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          ret = _gnutls_asn2err (ret);
+          ret = mhd_gtls_asn2err (ret);
           goto cleanup;
         }
 
@@ -266,7 +266,7 @@ _pkcs12_encode_crt_bag (gnutls_pkcs12_bag_type_t type,
       if (ret != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          ret = _gnutls_asn2err (ret);
+          ret = mhd_gtls_asn2err (ret);
           goto cleanup;
         }
 
@@ -285,7 +285,7 @@ _pkcs12_encode_crt_bag (gnutls_pkcs12_bag_type_t type,
                                       &c2)) != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          ret = _gnutls_asn2err (ret);
+          ret = mhd_gtls_asn2err (ret);
           goto cleanup;
         }
 
@@ -293,7 +293,7 @@ _pkcs12_encode_crt_bag (gnutls_pkcs12_bag_type_t type,
       if (ret != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          ret = _gnutls_asn2err (ret);
+          ret = mhd_gtls_asn2err (ret);
           goto cleanup;
         }
 
diff --git a/src/daemon/https/x509/pkcs7.c b/src/daemon/https/x509/pkcs7.c
index 35f21b12..3cef67c2 100644
--- a/src/daemon/https/x509/pkcs7.c
+++ b/src/daemon/https/x509/pkcs7.c
@@ -58,7 +58,7 @@ _decode_pkcs7_signed_data (ASN1_TYPE pkcs7, ASN1_TYPE * sdata,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   if (strcmp (oid, SIGNED_DATA_OID) != 0)
@@ -72,7 +72,7 @@ _decode_pkcs7_signed_data (ASN1_TYPE pkcs7, ASN1_TYPE * sdata,
        (_gnutls_get_pkix (), "PKIX1.pkcs-7-SignedData", &c2)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   /* the Signed-data has been created, so
@@ -83,7 +83,7 @@ _decode_pkcs7_signed_data (ASN1_TYPE pkcs7, ASN1_TYPE * sdata,
   if (result != ASN1_MEM_ERROR)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -99,7 +99,7 @@ _decode_pkcs7_signed_data (ASN1_TYPE pkcs7, ASN1_TYPE * sdata,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -114,7 +114,7 @@ _decode_pkcs7_signed_data (ASN1_TYPE pkcs7, ASN1_TYPE * sdata,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -164,7 +164,7 @@ gnutls_pkcs7_init (gnutls_pkcs7_t * pkcs7)
         {
           gnutls_assert ();
           gnutls_free (*pkcs7);
-          return _gnutls_asn2err (result);
+          return mhd_gtls_asn2err (result);
         }
       return 0;                 /* success */
     }
@@ -244,7 +244,7 @@ gnutls_pkcs7_import (gnutls_pkcs7_t pkcs7, const gnutls_datum_t * data,
   result = asn1_der_decoding (&pkcs7->pkcs7, _data.data, _data.size, NULL);
   if (result != ASN1_SUCCESS)
     {
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       gnutls_assert ();
       goto cleanup;
     }
@@ -316,7 +316,7 @@ gnutls_pkcs7_get_crt_raw (gnutls_pkcs7_t pkcs7,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -332,7 +332,7 @@ gnutls_pkcs7_get_crt_raw (gnutls_pkcs7_t pkcs7,
       if (result != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          result = _gnutls_asn2err (result);
+          result = mhd_gtls_asn2err (result);
           goto cleanup;
         }
 
@@ -458,7 +458,7 @@ create_empty_signed_data (ASN1_TYPE pkcs7, ASN1_TYPE * sdata)
         sdata)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -468,7 +468,7 @@ create_empty_signed_data (ASN1_TYPE pkcs7, ASN1_TYPE * sdata)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -482,7 +482,7 @@ create_empty_signed_data (ASN1_TYPE pkcs7, ASN1_TYPE * sdata)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -490,7 +490,7 @@ create_empty_signed_data (ASN1_TYPE pkcs7, ASN1_TYPE * sdata)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -509,7 +509,7 @@ create_empty_signed_data (ASN1_TYPE pkcs7, ASN1_TYPE * sdata)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -571,7 +571,7 @@ gnutls_pkcs7_set_crt_raw (gnutls_pkcs7_t pkcs7, const gnutls_datum_t * crt)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -579,7 +579,7 @@ gnutls_pkcs7_set_crt_raw (gnutls_pkcs7_t pkcs7, const gnutls_datum_t * crt)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -589,7 +589,7 @@ gnutls_pkcs7_set_crt_raw (gnutls_pkcs7_t pkcs7, const gnutls_datum_t * crt)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -691,7 +691,7 @@ gnutls_pkcs7_delete_crt (gnutls_pkcs7_t pkcs7, int indx)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -768,7 +768,7 @@ gnutls_pkcs7_get_crl_raw (gnutls_pkcs7_t pkcs7,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -889,7 +889,7 @@ gnutls_pkcs7_set_crl_raw (gnutls_pkcs7_t pkcs7, const gnutls_datum_t * crl)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -897,7 +897,7 @@ gnutls_pkcs7_set_crl_raw (gnutls_pkcs7_t pkcs7, const gnutls_datum_t * crl)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -996,7 +996,7 @@ gnutls_pkcs7_delete_crl (gnutls_pkcs7_t pkcs7, int indx)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
diff --git a/src/daemon/https/x509/privkey_pkcs8.c b/src/daemon/https/x509/privkey_pkcs8.c
index 3b33720c..4812c29f 100644
--- a/src/daemon/https/x509/privkey_pkcs8.c
+++ b/src/daemon/https/x509/privkey_pkcs8.c
@@ -221,7 +221,7 @@ encode_to_private_key_info (gnutls_x509_privkey_t pkey,
                             pkey_info)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -231,7 +231,7 @@ encode_to_private_key_info (gnutls_x509_privkey_t pkey,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -243,7 +243,7 @@ encode_to_private_key_info (gnutls_x509_privkey_t pkey,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -254,7 +254,7 @@ encode_to_private_key_info (gnutls_x509_privkey_t pkey,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -275,7 +275,7 @@ encode_to_private_key_info (gnutls_x509_privkey_t pkey,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -285,7 +285,7 @@ encode_to_private_key_info (gnutls_x509_privkey_t pkey,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -296,7 +296,7 @@ encode_to_private_key_info (gnutls_x509_privkey_t pkey,
   if (result != ASN1_MEM_ERROR)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -314,7 +314,7 @@ encode_to_private_key_info (gnutls_x509_privkey_t pkey,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -348,7 +348,7 @@ encode_to_pkcs8_key (schema_id schema, const gnutls_datum_t * der_key,
                             &pkcs8_asn)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -382,7 +382,7 @@ encode_to_pkcs8_key (schema_id schema, const gnutls_datum_t * der_key,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -422,7 +422,7 @@ encode_to_pkcs8_key (schema_id schema, const gnutls_datum_t * der_key,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -569,7 +569,7 @@ read_pkcs_schema_params (schema_id schema, const char *password,
                                 &pbes2_asn)) != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          result = _gnutls_asn2err (result);
+          result = mhd_gtls_asn2err (result);
           goto error;
         }
 
@@ -579,7 +579,7 @@ read_pkcs_schema_params (schema_id schema, const char *password,
       if (result != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          result = _gnutls_asn2err (result);
+          result = mhd_gtls_asn2err (result);
           goto error;
         }
 
@@ -590,7 +590,7 @@ read_pkcs_schema_params (schema_id schema, const char *password,
       if (result < 0)
         {
           gnutls_assert ();
-          result = _gnutls_asn2err (result);
+          result = mhd_gtls_asn2err (result);
           goto error;
         }
 
@@ -598,7 +598,7 @@ read_pkcs_schema_params (schema_id schema, const char *password,
       if (result < 0)
         {
           gnutls_assert ();
-          result = _gnutls_asn2err (result);
+          result = mhd_gtls_asn2err (result);
           goto error;
         }
 
@@ -632,7 +632,7 @@ read_pkcs_schema_params (schema_id schema, const char *password,
                                 &pbes2_asn)) != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          result = _gnutls_asn2err (result);
+          result = mhd_gtls_asn2err (result);
           goto error;
         }
 
@@ -642,7 +642,7 @@ read_pkcs_schema_params (schema_id schema, const char *password,
       if (result != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          result = _gnutls_asn2err (result);
+          result = mhd_gtls_asn2err (result);
           goto error;
         }
 
@@ -705,7 +705,7 @@ decode_pkcs8_key (const gnutls_datum_t * raw_key,
                             &pkcs8_asn)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -713,7 +713,7 @@ decode_pkcs8_key (const gnutls_datum_t * raw_key,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -747,7 +747,7 @@ decode_pkcs8_key (const gnutls_datum_t * raw_key,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
   params_len = params_end - params_start + 1;
@@ -923,7 +923,7 @@ decode_private_key_info (const gnutls_datum_t * der,
                             &pkcs8_asn)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -931,7 +931,7 @@ decode_private_key_info (const gnutls_datum_t * der,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -943,7 +943,7 @@ decode_private_key_info (const gnutls_datum_t * der,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -1109,7 +1109,7 @@ read_pbkdf2_params (ASN1_TYPE pbes2_asn,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
   _gnutls_hard_log ("keyDerivationFunc.algorithm: %s\n", oid);
 
@@ -1118,7 +1118,7 @@ read_pbkdf2_params (ASN1_TYPE pbes2_asn,
       gnutls_assert ();
       _gnutls_x509_log
         ("PKCS #8 key derivation OID '%s' is unsupported.\n", oid);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result =
@@ -1128,7 +1128,7 @@ read_pbkdf2_params (ASN1_TYPE pbes2_asn,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
   params_len = params_end - params_start + 1;
 
@@ -1141,7 +1141,7 @@ read_pbkdf2_params (ASN1_TYPE pbes2_asn,
                             &pbkdf2_asn)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result =
@@ -1150,7 +1150,7 @@ read_pbkdf2_params (ASN1_TYPE pbes2_asn,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -1162,7 +1162,7 @@ read_pbkdf2_params (ASN1_TYPE pbes2_asn,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
   _gnutls_hard_log ("salt.specified.size: %d\n", params->salt_size);
@@ -1216,7 +1216,7 @@ read_pkcs12_kdf_params (ASN1_TYPE pbes2_asn, struct pbkdf2_params *params)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
   _gnutls_hard_log ("salt.size: %d\n", params->salt_size);
@@ -1257,7 +1257,7 @@ write_pkcs12_kdf_params (ASN1_TYPE pbes2_asn,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
   _gnutls_hard_log ("salt.size: %d\n", kdf_params->salt_size);
@@ -1342,7 +1342,7 @@ read_pbe_enc_params (ASN1_TYPE pbes2_asn,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
   params_len = params_end - params_start + 1;
 
@@ -1354,7 +1354,7 @@ read_pbe_enc_params (ASN1_TYPE pbes2_asn,
                             &pbe_asn)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result =
@@ -1362,7 +1362,7 @@ read_pbe_enc_params (ASN1_TYPE pbes2_asn,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -1372,7 +1372,7 @@ read_pbe_enc_params (ASN1_TYPE pbes2_asn,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
   _gnutls_hard_log ("IV.size: %d\n", params->iv_size);
@@ -1404,7 +1404,7 @@ decrypt_data (schema_id schema, ASN1_TYPE pkcs8_asn,
   if (result != ASN1_MEM_ERROR)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   data = gnutls_malloc (data_size);
@@ -1418,7 +1418,7 @@ decrypt_data (schema_id schema, ASN1_TYPE pkcs8_asn,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -1530,7 +1530,7 @@ write_pbkdf2_params (ASN1_TYPE pbes2_asn,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   /* Now write the key derivation and the encryption
@@ -1542,14 +1542,14 @@ write_pbkdf2_params (ASN1_TYPE pbes2_asn,
                             &pbkdf2_asn)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = asn1_write_value (pbkdf2_asn, "salt", "specified", 1);
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -1561,7 +1561,7 @@ write_pbkdf2_params (ASN1_TYPE pbes2_asn,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
   _gnutls_hard_log ("salt.specified.size: %d\n", kdf_params->salt_size);
@@ -1574,7 +1574,7 @@ write_pbkdf2_params (ASN1_TYPE pbes2_asn,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
   _gnutls_hard_log ("iterationCount: %d\n", kdf_params->iter_count);
@@ -1585,7 +1585,7 @@ write_pbkdf2_params (ASN1_TYPE pbes2_asn,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -1595,7 +1595,7 @@ write_pbkdf2_params (ASN1_TYPE pbes2_asn,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -1647,7 +1647,7 @@ write_pbe_enc_params (ASN1_TYPE pbes2_asn,
                             &pbe_asn)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   /* read the salt */
@@ -1655,7 +1655,7 @@ write_pbe_enc_params (ASN1_TYPE pbes2_asn,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
   _gnutls_hard_log ("IV.size: %d\n", params->iv_size);
@@ -1814,7 +1814,7 @@ write_schema_params (schema_id schema, ASN1_TYPE pkcs8_asn,
                                 &pbes2_asn)) != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          return _gnutls_asn2err (result);
+          return mhd_gtls_asn2err (result);
         }
 
       result = write_pbkdf2_params (pbes2_asn, kdf_params);
@@ -1850,7 +1850,7 @@ write_schema_params (schema_id schema, ASN1_TYPE pkcs8_asn,
                                 &pbes2_asn)) != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          result = _gnutls_asn2err (result);
+          result = mhd_gtls_asn2err (result);
           goto error;
         }
 
@@ -1973,7 +1973,7 @@ _gnutls_pkcs7_decrypt_data (const gnutls_datum_t * data,
                             &pkcs7_asn)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -1981,7 +1981,7 @@ _gnutls_pkcs7_decrypt_data (const gnutls_datum_t * data,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -1995,7 +1995,7 @@ _gnutls_pkcs7_decrypt_data (const gnutls_datum_t * data,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -2015,7 +2015,7 @@ _gnutls_pkcs7_decrypt_data (const gnutls_datum_t * data,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
   params_len = params_end - params_start + 1;
@@ -2027,7 +2027,7 @@ _gnutls_pkcs7_decrypt_data (const gnutls_datum_t * data,
   if (result < ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -2078,7 +2078,7 @@ _gnutls_pkcs7_encrypt_data (schema_id schema,
                             &pkcs7_asn)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -2116,7 +2116,7 @@ _gnutls_pkcs7_encrypt_data (schema_id schema,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -2158,7 +2158,7 @@ _gnutls_pkcs7_encrypt_data (schema_id schema,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -2181,7 +2181,7 @@ _gnutls_pkcs7_encrypt_data (schema_id schema,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
@@ -2189,7 +2189,7 @@ _gnutls_pkcs7_encrypt_data (schema_id schema,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto error;
     }
 
diff --git a/src/daemon/https/x509/sign.c b/src/daemon/https/x509/sign.c
index c316cf8a..672c2af6 100644
--- a/src/daemon/https/x509/sign.c
+++ b/src/daemon/https/x509/sign.c
@@ -69,7 +69,7 @@ encode_ber_digest_info (gnutls_digest_algorithm_t hash,
                                      &dinfo)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = asn1_write_value (dinfo, "digestAlgorithm.algorithm", algo, 1);
@@ -77,7 +77,7 @@ encode_ber_digest_info (gnutls_digest_algorithm_t hash,
     {
       gnutls_assert ();
       asn1_delete_structure (&dinfo);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   /* Write an ASN.1 NULL in the parameters field.  This matches RFC
@@ -91,7 +91,7 @@ encode_ber_digest_info (gnutls_digest_algorithm_t hash,
     {
       gnutls_assert ();
       asn1_delete_structure (&dinfo);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = asn1_write_value (dinfo, "digest", digest->data, digest->size);
@@ -99,7 +99,7 @@ encode_ber_digest_info (gnutls_digest_algorithm_t hash,
     {
       gnutls_assert ();
       asn1_delete_structure (&dinfo);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   info->size = 0;
@@ -118,7 +118,7 @@ encode_ber_digest_info (gnutls_digest_algorithm_t hash,
     {
       gnutls_assert ();
       asn1_delete_structure (&dinfo);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   asn1_delete_structure (&dinfo);
@@ -242,7 +242,7 @@ _gnutls_x509_sign_tbs (ASN1_TYPE cert, const char *tbs_name,
     {
       gnutls_assert ();
       gnutls_afree (buf);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   tbs.data = buf;
@@ -285,7 +285,7 @@ _gnutls_x509_pkix_sign (ASN1_TYPE src, const char *src_name,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   /* Step 1.5. Write the signature stuff in the tbsCertificate.
@@ -323,7 +323,7 @@ _gnutls_x509_pkix_sign (ASN1_TYPE src, const char *src_name,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   /* Step 3. Move up and write the AlgorithmIdentifier, which is also
diff --git a/src/daemon/https/x509/x509.c b/src/daemon/https/x509/x509.c
index 4b3f04ba..c682abe0 100644
--- a/src/daemon/https/x509/x509.c
+++ b/src/daemon/https/x509/x509.c
@@ -63,7 +63,7 @@ gnutls_x509_crt_init (gnutls_x509_crt_t * cert)
     {
       gnutls_assert ();
       gnutls_free (tmp);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   *cert = tmp;
@@ -213,7 +213,7 @@ gnutls_x509_crt_import (gnutls_x509_crt_t cert,
   result = asn1_der_decoding (&cert->cert, _data.data, _data.size, NULL);
   if (result != ASN1_SUCCESS)
     {
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       gnutls_assert ();
       goto cleanup;
     }
@@ -522,7 +522,7 @@ gnutls_x509_crt_get_signature (gnutls_x509_crt_t cert,
   if (result != ASN1_MEM_ERROR)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   if (bits % 8 != 0)
@@ -543,7 +543,7 @@ gnutls_x509_crt_get_signature (gnutls_x509_crt_t cert,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   return 0;
@@ -579,7 +579,7 @@ gnutls_x509_crt_get_version (gnutls_x509_crt_t cert)
       if (result == ASN1_ELEMENT_NOT_FOUND)
         return 1;               /* the DEFAULT version */
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   return (int) version[0] + 1;
@@ -665,7 +665,7 @@ gnutls_x509_crt_get_serial (gnutls_x509_crt_t cert,
   if (ret != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (ret);
+      return mhd_gtls_asn2err (ret);
     }
 
   return 0;
@@ -724,7 +724,7 @@ gnutls_x509_crt_get_subject_key_id (gnutls_x509_crt_t cert,
     {
       gnutls_assert ();
       _gnutls_free_datum (&id);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = asn1_der_decoding (&c2, id.data, id.size, NULL);
@@ -734,7 +734,7 @@ gnutls_x509_crt_get_subject_key_id (gnutls_x509_crt_t cert,
     {
       gnutls_assert ();
       asn1_delete_structure (&c2);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   len = *ret_size;
@@ -751,7 +751,7 @@ gnutls_x509_crt_get_subject_key_id (gnutls_x509_crt_t cert,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   return 0;
@@ -812,7 +812,7 @@ gnutls_x509_crt_get_authority_key_id (gnutls_x509_crt_t cert,
     {
       gnutls_assert ();
       _gnutls_free_datum (&id);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = asn1_der_decoding (&c2, id.data, id.size, NULL);
@@ -822,7 +822,7 @@ gnutls_x509_crt_get_authority_key_id (gnutls_x509_crt_t cert,
     {
       gnutls_assert ();
       asn1_delete_structure (&c2);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   len = *ret_size;
@@ -839,7 +839,7 @@ gnutls_x509_crt_get_authority_key_id (gnutls_x509_crt_t cert,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   return 0;
@@ -934,7 +934,7 @@ parse_general_name (ASN1_TYPE src,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   type = _gnutls_x509_san_find_type (choice_type);
@@ -964,7 +964,7 @@ parse_general_name (ASN1_TYPE src,
       if (result != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          return _gnutls_asn2err (result);
+          return mhd_gtls_asn2err (result);
         }
 
       if (othername_oid)
@@ -987,7 +987,7 @@ parse_general_name (ASN1_TYPE src,
           if (result != ASN1_SUCCESS)
             {
               gnutls_assert ();
-              return _gnutls_asn2err (result);
+              return mhd_gtls_asn2err (result);
             }
 
           if (len > strlen (XMPP_OID) && strcmp (oid, XMPP_OID) == 0)
@@ -1000,7 +1000,7 @@ parse_general_name (ASN1_TYPE src,
               if (result != ASN1_SUCCESS)
                 {
                   gnutls_assert ();
-                  return _gnutls_asn2err (result);
+                  return mhd_gtls_asn2err (result);
                 }
 
               result = asn1_der_decoding (&c2, name, *name_size, NULL);
@@ -1008,7 +1008,7 @@ parse_general_name (ASN1_TYPE src,
                 {
                   gnutls_assert ();
                   asn1_delete_structure (&c2);
-                  return _gnutls_asn2err (result);
+                  return mhd_gtls_asn2err (result);
                 }
 
               result = asn1_read_value (c2, "", name, &len);
@@ -1017,7 +1017,7 @@ parse_general_name (ASN1_TYPE src,
                 {
                   gnutls_assert ();
                   asn1_delete_structure (&c2);
-                  return _gnutls_asn2err (result);
+                  return mhd_gtls_asn2err (result);
                 }
               asn1_delete_structure (&c2);
             }
@@ -1056,7 +1056,7 @@ parse_general_name (ASN1_TYPE src,
       if (result != ASN1_SUCCESS)
         {
           gnutls_assert ();
-          return _gnutls_asn2err (result);
+          return mhd_gtls_asn2err (result);
         }
 
       if (is_type_printable (type))
@@ -1121,7 +1121,7 @@ get_subject_alt_name (gnutls_x509_crt_t cert,
     {
       gnutls_assert ();
       _gnutls_free_datum (&dnsname);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = asn1_der_decoding (&c2, dnsname.data, dnsname.size, NULL);
@@ -1131,7 +1131,7 @@ get_subject_alt_name (gnutls_x509_crt_t cert,
     {
       gnutls_assert ();
       asn1_delete_structure (&c2);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = parse_general_name (c2, "", seq, ret, ret_size, ret_type,
@@ -1620,7 +1620,7 @@ gnutls_x509_crt_get_extension_info (gnutls_x509_crt_t cert,
   else if (result < 0)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   snprintf (name, sizeof (name), "tbsCertificate.extensions.?%u.critical",
@@ -1630,7 +1630,7 @@ gnutls_x509_crt_get_extension_info (gnutls_x509_crt_t cert,
   if (result < 0)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   if (critical)
@@ -1691,7 +1691,7 @@ gnutls_x509_crt_get_extension_data (gnutls_x509_crt_t cert,
   else if (result < 0)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   return 0;
@@ -1715,7 +1715,7 @@ _gnutls_x509_crt_get_raw_dn2 (gnutls_x509_crt_t cert,
                             &c2)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = _gnutls_x509_get_signed_data (cert->cert, "tbsCertificate",
@@ -1731,7 +1731,7 @@ _gnutls_x509_crt_get_raw_dn2 (gnutls_x509_crt_t cert,
     {
       gnutls_assert ();
       asn1_delete_structure (&c2);
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -1741,7 +1741,7 @@ _gnutls_x509_crt_get_raw_dn2 (gnutls_x509_crt_t cert,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -1910,7 +1910,7 @@ gnutls_x509_dn_get_rdn_ava (gnutls_x509_dn_t dn,
   if (ret)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (ret);
+      return mhd_gtls_asn2err (ret);
     }
 
   ptr += lenlen;
@@ -1974,7 +1974,7 @@ gnutls_x509_crt_get_fingerprint (gnutls_x509_crt_t cert,
     {
       gnutls_assert ();
       gnutls_afree (cert_buf);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   tmp.data = cert_buf;
@@ -2146,7 +2146,7 @@ gnutls_x509_crt_get_key_id (gnutls_x509_crt_t crt,
   if (result != ASN1_MEM_ERROR)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   pubkey.data = gnutls_alloca (pubkey.size);
@@ -2162,7 +2162,7 @@ gnutls_x509_crt_get_key_id (gnutls_x509_crt_t crt,
     {
       gnutls_assert ();
       gnutls_afree (pubkey.data);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = MHD_gnutls_fingerprint (MHD_GNUTLS_DIG_SHA1, &pubkey, output_data,
@@ -2404,7 +2404,7 @@ gnutls_x509_crt_get_crl_dist_points (gnutls_x509_crt_t cert,
     {
       gnutls_assert ();
       _gnutls_free_datum (&dist_points);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = asn1_der_decoding (&c2, dist_points.data, dist_points.size, NULL);
@@ -2414,7 +2414,7 @@ gnutls_x509_crt_get_crl_dist_points (gnutls_x509_crt_t cert,
     {
       gnutls_assert ();
       asn1_delete_structure (&c2);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   /* Return the different names from the first CRLDistr. point.
@@ -2446,7 +2446,7 @@ gnutls_x509_crt_get_crl_dist_points (gnutls_x509_crt_t cert,
         {
           gnutls_assert ();
           asn1_delete_structure (&c2);
-          return _gnutls_asn2err (result);
+          return mhd_gtls_asn2err (result);
         }
 
       *reason_flags = reasons[0] | (reasons[1] << 8);
@@ -2514,7 +2514,7 @@ gnutls_x509_crt_get_key_purpose_oid (gnutls_x509_crt_t cert,
     {
       gnutls_assert ();
       _gnutls_free_datum (&id);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = asn1_der_decoding (&c2, id.data, id.size, NULL);
@@ -2524,7 +2524,7 @@ gnutls_x509_crt_get_key_purpose_oid (gnutls_x509_crt_t cert,
     {
       gnutls_assert ();
       asn1_delete_structure (&c2);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   indx++;
@@ -2546,7 +2546,7 @@ gnutls_x509_crt_get_key_purpose_oid (gnutls_x509_crt_t cert,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   return 0;
diff --git a/src/daemon/https/x509/x509_privkey.c b/src/daemon/https/x509/x509_privkey.c
index 2a690adb..2eade5d1 100644
--- a/src/daemon/https/x509/x509_privkey.c
+++ b/src/daemon/https/x509/x509_privkey.c
@@ -956,7 +956,7 @@ _gnutls_asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params)
                             c2)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -966,7 +966,7 @@ _gnutls_asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params)
       != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -974,7 +974,7 @@ _gnutls_asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params)
       != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -982,7 +982,7 @@ _gnutls_asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params)
       != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -990,7 +990,7 @@ _gnutls_asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params)
       != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -998,7 +998,7 @@ _gnutls_asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params)
       != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -1006,7 +1006,7 @@ _gnutls_asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params)
       != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -1014,7 +1014,7 @@ _gnutls_asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params)
       != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -1022,7 +1022,7 @@ _gnutls_asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params)
       != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -1037,14 +1037,14 @@ _gnutls_asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params)
                                   NULL, 0)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
   if ((result = asn1_write_value (*c2, "version", &null, 1)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -1116,7 +1116,7 @@ _gnutls_asn1_encode_dsa (ASN1_TYPE * c2, mpi_t * params)
                             c2)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -1125,28 +1125,28 @@ _gnutls_asn1_encode_dsa (ASN1_TYPE * c2, mpi_t * params)
   if ((result = asn1_write_value (*c2, "p", p_data, size[0])) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
   if ((result = asn1_write_value (*c2, "q", q_data, size[1])) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
   if ((result = asn1_write_value (*c2, "g", g_data, size[2])) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
   if ((result = asn1_write_value (*c2, "Y", y_data, size[3])) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -1154,7 +1154,7 @@ _gnutls_asn1_encode_dsa (ASN1_TYPE * c2, mpi_t * params)
        asn1_write_value (*c2, "priv", x_data, size[4])) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
@@ -1163,7 +1163,7 @@ _gnutls_asn1_encode_dsa (ASN1_TYPE * c2, mpi_t * params)
   if ((result = asn1_write_value (*c2, "version", &null, 1)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      result = _gnutls_asn2err (result);
+      result = mhd_gtls_asn2err (result);
       goto cleanup;
     }
 
diff --git a/src/daemon/https/x509/x509_verify.c b/src/daemon/https/x509/x509_verify.c
index b0d63727..3a27bfec 100644
--- a/src/daemon/https/x509/x509_verify.c
+++ b/src/daemon/https/x509/x509_verify.c
@@ -478,7 +478,7 @@ decode_ber_digest_info (const gnutls_datum_t * info,
                                      &dinfo)) != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = asn1_der_decoding (&dinfo, info->data, info->size, NULL);
@@ -486,7 +486,7 @@ decode_ber_digest_info (const gnutls_datum_t * info,
     {
       gnutls_assert ();
       asn1_delete_structure (&dinfo);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   len = sizeof (str) - 1;
@@ -495,7 +495,7 @@ decode_ber_digest_info (const gnutls_datum_t * info,
     {
       gnutls_assert ();
       asn1_delete_structure (&dinfo);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   *hash = mhd_gtls_x509_oid2mac_algorithm (str);
@@ -529,7 +529,7 @@ decode_ber_digest_info (const gnutls_datum_t * info,
     {
       gnutls_assert ();
       asn1_delete_structure (&dinfo);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   asn1_delete_structure (&dinfo);
diff --git a/src/daemon/https/x509/x509_write.c b/src/daemon/https/x509/x509_write.c
index 8855eadb..516f034f 100644
--- a/src/daemon/https/x509/x509_write.c
+++ b/src/daemon/https/x509/x509_write.c
@@ -151,7 +151,7 @@ gnutls_x509_crt_set_proxy_dn (gnutls_x509_crt_t crt, gnutls_x509_crt_t eecrt,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   if (name && sizeof_name)
@@ -200,7 +200,7 @@ gnutls_x509_crt_set_version (gnutls_x509_crt_t crt, unsigned int version)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   return 0;
@@ -273,7 +273,7 @@ gnutls_x509_crt_set_crq (gnutls_x509_crt_t crt, gnutls_x509_crq_t crq)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result =
@@ -282,7 +282,7 @@ gnutls_x509_crt_set_crq (gnutls_x509_crt_t crt, gnutls_x509_crq_t crq)
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   return 0;
@@ -714,7 +714,7 @@ gnutls_x509_crt_set_serial (gnutls_x509_crt_t cert, const void *serial,
   if (ret != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (ret);
+      return mhd_gtls_asn2err (ret);
     }
 
   return 0;
@@ -1020,7 +1020,7 @@ gnutls_x509_crt_set_key_purpose_oid (gnutls_x509_crt_t cert,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   /* Check if the extension already exists.
@@ -1039,7 +1039,7 @@ gnutls_x509_crt_set_key_purpose_oid (gnutls_x509_crt_t cert,
         {
           gnutls_assert ();
           asn1_delete_structure (&c2);
-          return _gnutls_asn2err (result);
+          return mhd_gtls_asn2err (result);
         }
 
     }
@@ -1053,7 +1053,7 @@ gnutls_x509_crt_set_key_purpose_oid (gnutls_x509_crt_t cert,
     {
       gnutls_assert ();
       asn1_delete_structure (&c2);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   /* 2. Add the OID.
@@ -1063,7 +1063,7 @@ gnutls_x509_crt_set_key_purpose_oid (gnutls_x509_crt_t cert,
     {
       gnutls_assert ();
       asn1_delete_structure (&c2);
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = _gnutls_x509_der_encode (c2, "", &der_data, 0);
@@ -1072,7 +1072,7 @@ gnutls_x509_crt_set_key_purpose_oid (gnutls_x509_crt_t cert,
   if (result != ASN1_SUCCESS)
     {
       gnutls_assert ();
-      return _gnutls_asn2err (result);
+      return mhd_gtls_asn2err (result);
     }
 
   result = _gnutls_x509_crt_set_extension (cert, "2.5.29.37",
diff --git a/src/testcurl/daemon_options_test.c b/src/testcurl/daemon_options_test.c
index 5851f958..739860dd 100644
--- a/src/testcurl/daemon_options_test.c
+++ b/src/testcurl/daemon_options_test.c
@@ -20,7 +20,7 @@
 
 /**
  * @file mhds_get_test.c
- * @brief  Testcase for libmicrohttpd daemon option arguments
+ * @brief  Testcase for libmicrohttpd HTTPS GET operations
  * @author Sagie Amir
  */
 
@@ -67,9 +67,6 @@ test_wrap (char *test_name, int (*test) (void ))
   return ret;
 }
 
-/**
- * Test the MHD_OPTION_IP_ADDR along with an IPv4 address
- */
 static int
 test_ipv4_option ()
 {
@@ -85,10 +82,6 @@ test_ipv4_option ()
         return 0;
 }
 
-/**
- * Test the MHD_OPTION_IP_ADDR along with an IPv6 address
- */
-
 static int
 test_ipv6_option ()
 {
diff --git a/src/testcurl/https/Makefile.am b/src/testcurl/https/Makefile.am
index 73698996..de1024f5 100644
--- a/src/testcurl/https/Makefile.am
+++ b/src/testcurl/https/Makefile.am
@@ -10,23 +10,21 @@ AM_CPPFLAGS = \
 $(LIBCURL_CPPFLAGS)
 
 check_PROGRAMS = \
-tls_session_time_out_test \
-tls_cipher_change_test \
-tls_daemon_options_test \
-tls_alert_test \
-tls_authentication_test \
-mhds_multi_daemon_test \
-mhds_session_info_test 
+  tls_daemon_options_test \
+  tls_authentication_test \
+  mhds_multi_daemon_test \
+  mhds_session_info_test
+
+if MHD_DEBUG_TLS
+  check_PROGRAMS += \
+  tls_session_time_out_test \
+  tls_cipher_change_test \
+  tls_alert_test
+endif  
    
 TESTS = $(check_PROGRAMS)
 
-tls_daemon_options_test_SOURCES = \
-  tls_daemon_options_test.c
-tls_daemon_options_test_LDADD = \
-  $(top_builddir)/src/testcurl/libcurl_version_check.a \
-  $(top_builddir)/src/daemon/libmicrohttpd.la \
-  @LIBCURL@
-
+# cURL independent tests
 tls_session_time_out_test_SOURCES = \
   tls_session_time_out_test.c
 tls_session_time_out_test_LDADD  = \
@@ -45,6 +43,14 @@ tls_alert_test_LDADD  = \
   $(top_builddir)/src/testcurl/libcurl_version_check.a \
   $(top_builddir)/src/daemon/libmicrohttpd.la
 
+# cURL dependent tests
+tls_daemon_options_test_SOURCES = \
+  tls_daemon_options_test.c
+tls_daemon_options_test_LDADD = \
+  $(top_builddir)/src/testcurl/libcurl_version_check.a \
+  $(top_builddir)/src/daemon/libmicrohttpd.la \
+  @LIBCURL@
+
 tls_authentication_test_SOURCES = \
   tls_authentication_test.c
 tls_authentication_test_LDADD  = \
diff --git a/src/testcurl/https/tls_daemon_options_test.c b/src/testcurl/https/tls_daemon_options_test.c
index 9df7a9e9..1418dac0 100644
--- a/src/testcurl/https/tls_daemon_options_test.c
+++ b/src/testcurl/https/tls_daemon_options_test.c
@@ -469,18 +469,6 @@ main (int argc, char *const *argv)
                  MHD_OPTION_KX_PRIORITY,
                  kx, MHD_OPTION_END);
 
-
-  /*gnutls_mac_algorithm_t mac[] = {
-     {MHD_GNUTLS_MAC_MD5, 0}, 0};
-     gnutls_mac_algorithm_t * cur_mac;
-
-     for ( cur_mac = &mac[0]; (*cur_mac) != 0; cur_mac++ ){
-     option[0] = MHD_GNUTLS_MAC_SHA1;
-     errorCount +=
-     test_wrap (&test_https_transfer, test_fd, "AES256-SHA",
-     CURL_SSLVERSION_TLSv1, MHD_OPTION_MAC_ALGO, option);
-     } */
-
   if (errorCount != 0)
     fprintf (stderr, "Failed test: %s.\n", argv[0]);