107 files changed, 2527 insertions, 2095 deletions

diff --git a/src/daemon/https/gnutls.h b/src/daemon/https/gnutls.h
index 3c17d803..217e0fb7 100644
--- a/src/daemon/https/gnutls.h
+++ b/src/daemon/https/gnutls.h
@@ -211,32 +211,36 @@ extern "C"
   } MHD_gnutls_params_st;
 
   typedef int MHD_gnutls_params_function (MHD_gtls_session_t,
-                                      MHD_gnutls_params_type_t,
-                                      MHD_gnutls_params_st *);
+                                          MHD_gnutls_params_type_t,
+                                          MHD_gnutls_params_st *);
 
 /* internal functions */
   int MHD__gnutls_global_init (void);
   void MHD__gnutls_global_deinit (void);
 
   int MHD__gnutls_init (MHD_gtls_session_t * session,
-                       MHD_gnutls_connection_end_t con_end);
+                        MHD_gnutls_connection_end_t con_end);
   void MHD__gnutls_deinit (MHD_gtls_session_t session);
 
-  int MHD__gnutls_bye (MHD_gtls_session_t session, MHD_gnutls_close_request_t how);
+  int MHD__gnutls_bye (MHD_gtls_session_t session,
+                       MHD_gnutls_close_request_t how);
   int MHD__gnutls_handshake (MHD_gtls_session_t session);
   int MHD__gnutls_rehandshake (MHD_gtls_session_t session);
 
   int MHD_gtls_handshake_client (MHD_gtls_session_t session);
 
-  MHD_gnutls_alert_description_t MHD_gnutls_alert_get (MHD_gtls_session_t session);
+  MHD_gnutls_alert_description_t MHD_gnutls_alert_get (MHD_gtls_session_t
+                                                       session);
   int MHD__gnutls_alert_send (MHD_gtls_session_t session,
-                             MHD_gnutls_alert_level_t level,
-                             MHD_gnutls_alert_description_t desc);
-  int MHD__gnutls_alert_send_appropriate (MHD_gtls_session_t session, int err);
-  const char *MHD__gnutls_alert_get_name (MHD_gnutls_alert_description_t alert);
-
-  enum MHD_GNUTLS_CompressionMethod MHD_gtls_compression_get (MHD_gtls_session_t
-                                                        session);
+                              MHD_gnutls_alert_level_t level,
+                              MHD_gnutls_alert_description_t desc);
+  int MHD__gnutls_alert_send_appropriate (MHD_gtls_session_t session,
+                                          int err);
+  const char *MHD__gnutls_alert_get_name (MHD_gnutls_alert_description_t
+                                          alert);
+
+  enum MHD_GNUTLS_CompressionMethod
+    MHD_gtls_compression_get (MHD_gtls_session_t session);
 //  enum MHD_GNUTLS_CipherAlgorithm MHD_gnutls_cipher_get (MHD_gtls_session_t session);
 //  enum MHD_GNUTLS_KeyExchangeAlgorithm MHD_gnutls_kx_get (MHD_gtls_session_t session);
 //  enum MHD_GNUTLS_HashAlgorithm MHD_gnutls_mac_get (MHD_gtls_session_t session);
@@ -244,23 +248,23 @@ extern "C"
 //                                                         session);
 
   size_t MHD__gnutls_cipher_get_key_size (enum MHD_GNUTLS_CipherAlgorithm
-                                         algorithm);
+                                          algorithm);
   size_t MHD__gnutls_mac_get_key_size (enum MHD_GNUTLS_HashAlgorithm
-                                      algorithm);
+                                       algorithm);
 
 /* the name of the specified algorithms */
   const char *MHD__gnutls_cipher_get_name (enum MHD_GNUTLS_CipherAlgorithm
-                                          algorithm);
+                                           algorithm);
   const char *MHD__gnutls_mac_get_name (enum MHD_GNUTLS_HashAlgorithm
-                                       algorithm);
+                                        algorithm);
   const char *MHD_gtls_compression_get_name (enum
-                                               MHD_GNUTLS_CompressionMethod
-                                               algorithm);
+                                             MHD_GNUTLS_CompressionMethod
+                                             algorithm);
   const char *MHD__gnutls_kx_get_name (enum MHD_GNUTLS_KeyExchangeAlgorithm
-                                      algorithm);
+                                       algorithm);
   const char *MHD__gnutls_certificate_type_get_name (enum
-                                                    MHD_GNUTLS_CertificateType
-                                                    type);
+                                                     MHD_GNUTLS_CertificateType
+                                                     type);
 
   enum MHD_GNUTLS_HashAlgorithm MHD_gtls_mac_get_id (const char *name);
   enum MHD_GNUTLS_CompressionMethod MHD_gtls_compression_get_id (const char
@@ -292,9 +296,9 @@ extern "C"
  * Record layer functions.
  */
   ssize_t MHD__gnutls_record_send (MHD_gtls_session_t session,
-                                  const void *data, size_t sizeofdata);
+                                   const void *data, size_t sizeofdata);
   ssize_t MHD__gnutls_record_recv (MHD_gtls_session_t session, void *data,
-                                  size_t sizeofdata);
+                                   size_t sizeofdata);
 
   /* provides extra compatibility */
   void MHD_gtls_record_disable_padding (MHD_gtls_session_t session);
@@ -303,19 +307,19 @@ extern "C"
   int MHD__gnutls_record_get_direction (MHD_gtls_session_t session);
   size_t MHD__gnutls_record_get_max_size (MHD_gtls_session_t session);
   ssize_t MHD__gnutls_record_set_max_size (MHD_gtls_session_t session,
-                                          size_t size);
+                                           size_t size);
 
 
   int MHD__gnutls_prf (MHD_gtls_session_t session,
-                      size_t label_size, const char *label,
-                      int server_random_first,
-                      size_t extra_size, const char *extra,
-                      size_t outsize, char *out);
+                       size_t label_size, const char *label,
+                       int server_random_first,
+                       size_t extra_size, const char *extra,
+                       size_t outsize, char *out);
 
   int MHD__gnutls_prf_raw (MHD_gtls_session_t session,
-                          size_t label_size, const char *label,
-                          size_t seed_size, const char *seed,
-                          size_t outsize, char *out);
+                           size_t label_size, const char *label,
+                           size_t seed_size, const char *seed,
+                           size_t outsize, char *out);
 
 /*
  * TLS Extensions
@@ -326,12 +330,12 @@ extern "C"
   } MHD_gnutls_server_name_type_t;
 
   int MHD__gnutls_server_name_set (MHD_gtls_session_t session,
-                                  MHD_gnutls_server_name_type_t type,
-                                  const void *name, size_t name_length);
+                                   MHD_gnutls_server_name_type_t type,
+                                   const void *name, size_t name_length);
 
   int MHD__gnutls_server_name_get (MHD_gtls_session_t session,
-                                  void *data, size_t * data_length,
-                                  unsigned int *type, unsigned int indx);
+                                   void *data, size_t * data_length,
+                                   unsigned int *type, unsigned int indx);
 
   /* Opaque PRF Input
    * http://tools.ietf.org/id/draft-rescorla-tls-opaque-prf-input-00.txt
@@ -342,10 +346,11 @@ extern "C"
                                   size_t len, unsigned char *data);
 
   typedef int (*MHD_gnutls_oprfi_callback_func) (MHD_gtls_session_t session,
-                                             void *userdata,
-                                             size_t oprfi_len,
-                                             const unsigned char *in_oprfi,
-                                             unsigned char *out_oprfi);
+                                                 void *userdata,
+                                                 size_t oprfi_len,
+                                                 const unsigned char
+                                                 *in_oprfi,
+                                                 unsigned char *out_oprfi);
 
   void
     MHD_gtls_oprfi_enable_server (MHD_gtls_session_t session,
@@ -362,32 +367,35 @@ extern "C"
     (MHD_gnutls_supplemental_data_format_type_t type);
 
   int MHD__gnutls_cipher_set_priority (MHD_gtls_session_t session,
-                                      const int *list);
+                                       const int *list);
   int MHD__gnutls_mac_set_priority (MHD_gtls_session_t session,
-                                   const int *list);
+                                    const int *list);
   int MHD__gnutls_compression_set_priority (MHD_gtls_session_t session,
-                                           const int *list);
+                                            const int *list);
   int MHD__gnutls_kx_set_priority (MHD_gtls_session_t session,
-                                  const int *list);
+                                   const int *list);
   int MHD__gnutls_protocol_set_priority (MHD_gtls_session_t session,
-                                        const int *list);
+                                         const int *list);
   int MHD__gnutls_certificate_type_set_priority (MHD_gtls_session_t session,
-                                                const int *list);
+                                                 const int *list);
 
-  int MHD_tls_set_default_priority (MHD_gnutls_priority_t *, const char *priority,
+  int MHD_tls_set_default_priority (MHD_gnutls_priority_t *,
+                                    const char *priority,
                                     const char **err_pos);
   void MHD__gnutls_priority_deinit (MHD_gnutls_priority_t);
 
-  int MHD__gnutls_priority_set (MHD_gtls_session_t session, MHD_gnutls_priority_t);
+  int MHD__gnutls_priority_set (MHD_gtls_session_t session,
+                                MHD_gnutls_priority_t);
   int MHD__gnutls_priority_set_direct (MHD_gtls_session_t session,
-                                      const char *priority,
-                                      const char **err_pos);
+                                       const char *priority,
+                                       const char **err_pos);
 
 /* get the currently used protocol version */
-  enum MHD_GNUTLS_Protocol MHD__gnutls_protocol_get_version (MHD_gtls_session_t
-                                                            session);
+  enum MHD_GNUTLS_Protocol
+    MHD__gnutls_protocol_get_version (MHD_gtls_session_t session);
 
-  const char *MHD__gnutls_protocol_get_name (enum MHD_GNUTLS_Protocol version);
+  const char *MHD__gnutls_protocol_get_name (enum MHD_GNUTLS_Protocol
+                                             version);
 
 /*
  * get/set session
@@ -412,13 +420,14 @@ extern "C"
 
   int MHD_gtls_session_is_resumed (MHD_gtls_session_t session);
 
-  typedef int (*MHD_gnutls_handshake_post_client_hello_func) (MHD_gtls_session_t);
+  typedef
+    int (*MHD_gnutls_handshake_post_client_hello_func) (MHD_gtls_session_t);
   void
     MHD__gnutls_handshake_set_post_client_hello_function (MHD_gtls_session_t,
-                                                         MHD_gnutls_handshake_post_client_hello_func);
+                                                          MHD_gnutls_handshake_post_client_hello_func);
 
-  void MHD__gnutls_handshake_set_max_packet_length (MHD_gtls_session_t session,
-                                                   size_t max);
+  void MHD__gnutls_handshake_set_max_packet_length (MHD_gtls_session_t
+                                                    session, size_t max);
 
 /*
  * Functions for setting/clearing credentials
@@ -429,8 +438,8 @@ extern "C"
  * cred is a structure defined by the kx algorithm
  */
   int MHD__gnutls_credentials_set (MHD_gtls_session_t session,
-                                  enum MHD_GNUTLS_CredentialsType type,
-                                  void *cred);
+                                   enum MHD_GNUTLS_CredentialsType type,
+                                   void *cred);
 
 /* Credential structures - used in MHD__gnutls_credentials_set(); */
   struct MHD_gtls_certificate_credentials_st;
@@ -453,12 +462,13 @@ extern "C"
 
   void
     MHD__gnutls_anon_set_server_dh_params (MHD_gtls_anon_server_credentials_t
-                                          res,
-                                          MHD_gtls_dh_params_t dh_params);
+                                           res,
+                                           MHD_gtls_dh_params_t dh_params);
 
   void
     MHD__gnutls_anon_set_server_params_function
-    (MHD_gtls_anon_server_credentials_t res, MHD_gnutls_params_function * func);
+    (MHD_gtls_anon_server_credentials_t res,
+     MHD_gnutls_params_function * func);
 
   void
     MHD__gnutls_anon_free_client_credentials
@@ -468,10 +478,10 @@ extern "C"
     (MHD_gtls_anon_client_credentials_t * sc);
 
   void MHD__gnutls_certificate_free_credentials (MHD_gtls_cert_credentials_t
-                                                sc);
+                                                 sc);
   int
     MHD__gnutls_certificate_allocate_credentials (MHD_gtls_cert_credentials_t
-                                                 * res);
+                                                  * res);
 
   void MHD__gnutls_certificate_free_keys (MHD_gtls_cert_credentials_t sc);
   void MHD__gnutls_certificate_free_cas (MHD_gtls_cert_credentials_t sc);
@@ -479,50 +489,60 @@ extern "C"
   void MHD__gnutls_certificate_free_crls (MHD_gtls_cert_credentials_t sc);
 
   void MHD__gnutls_certificate_set_dh_params (MHD_gtls_cert_credentials_t res,
-                                             MHD_gtls_dh_params_t dh_params);
+                                              MHD_gtls_dh_params_t dh_params);
   void
     MHD__gnutls_certificate_set_rsa_export_params (MHD_gtls_cert_credentials_t
-                                                  res,
-                                                  MHD_gtls_rsa_params_t
-                                                  rsa_params);
+                                                   res,
+                                                   MHD_gtls_rsa_params_t
+                                                   rsa_params);
   void MHD__gnutls_certificate_set_verify_flags (MHD_gtls_cert_credentials_t
-                                                res, unsigned int flags);
+                                                 res, unsigned int flags);
   void MHD__gnutls_certificate_set_verify_limits (MHD_gtls_cert_credentials_t
-                                                 res, unsigned int max_bits,
-                                                 unsigned int max_depth);
+                                                  res, unsigned int max_bits,
+                                                  unsigned int max_depth);
 
   int MHD__gnutls_certificate_set_x509_trust_file (MHD_gtls_cert_credentials_t
-                                                  res, const char *CAFILE,
-                                                  MHD_gnutls_x509_crt_fmt_t type);
+                                                   res, const char *CAFILE,
+                                                   MHD_gnutls_x509_crt_fmt_t
+                                                   type);
   int MHD__gnutls_certificate_set_x509_trust_mem (MHD_gtls_cert_credentials_t
-                                                 res,
-                                                 const MHD_gnutls_datum_t * CA,
-                                                 MHD_gnutls_x509_crt_fmt_t type);
+                                                  res,
+                                                  const MHD_gnutls_datum_t *
+                                                  CA,
+                                                  MHD_gnutls_x509_crt_fmt_t
+                                                  type);
 
   int MHD__gnutls_certificate_set_x509_crl_file (MHD_gtls_cert_credentials_t
-                                                res, const char *crlfile,
-                                                MHD_gnutls_x509_crt_fmt_t type);
+                                                 res, const char *crlfile,
+                                                 MHD_gnutls_x509_crt_fmt_t
+                                                 type);
   int MHD__gnutls_certificate_set_x509_crl_mem (MHD_gtls_cert_credentials_t
-                                               res,
-                                               const MHD_gnutls_datum_t * CRL,
-                                               MHD_gnutls_x509_crt_fmt_t type);
+                                                res,
+                                                const MHD_gnutls_datum_t *
+                                                CRL,
+                                                MHD_gnutls_x509_crt_fmt_t
+                                                type);
 
   /*
    * CERTFILE is an x509 certificate in PEM form.
    * KEYFILE is a pkcs-1 private key in PEM form (for RSA keys).
    */
   int MHD__gnutls_certificate_set_x509_key_file (MHD_gtls_cert_credentials_t
-                                                res, const char *CERTFILE,
-                                                const char *KEYFILE,
-                                                MHD_gnutls_x509_crt_fmt_t type);
+                                                 res, const char *CERTFILE,
+                                                 const char *KEYFILE,
+                                                 MHD_gnutls_x509_crt_fmt_t
+                                                 type);
   int MHD__gnutls_certificate_set_x509_key_mem (MHD_gtls_cert_credentials_t
-                                               res,
-                                               const MHD_gnutls_datum_t * CERT,
-                                               const MHD_gnutls_datum_t * KEY,
-                                               MHD_gnutls_x509_crt_fmt_t type);
+                                                res,
+                                                const MHD_gnutls_datum_t *
+                                                CERT,
+                                                const MHD_gnutls_datum_t *
+                                                KEY,
+                                                MHD_gnutls_x509_crt_fmt_t
+                                                type);
 
   void MHD__gnutls_certificate_send_x509_rdn_sequence (MHD_gtls_session_t
-                                                      session, int status);
+                                                       session, int status);
 
 /*
  * New functions to allow setting already parsed X.509 stuff.
@@ -558,7 +578,8 @@ extern "C"
   typedef void *(*MHD_gnutls_realloc_function) (void *, size_t);
 
   extern void
-    MHD_gtls_global_set_mem_functions (MHD_gnutls_alloc_function gt_alloc_func,
+    MHD_gtls_global_set_mem_functions (MHD_gnutls_alloc_function
+                                       gt_alloc_func,
                                        MHD_gnutls_alloc_function
                                        gt_secure_alloc_func,
                                        MHD_gnutls_is_secure_function
@@ -586,14 +607,14 @@ extern "C"
   int MHD__gnutls_dh_params_init (MHD_gtls_dh_params_t * dh_params);
   void MHD__gnutls_dh_params_deinit (MHD_gtls_dh_params_t dh_params);
   int MHD__gnutls_dh_params_generate2 (MHD_gtls_dh_params_t params,
-                                      unsigned int bits);
+                                       unsigned int bits);
 
 
 /* RSA params */
   int MHD__gnutls_rsa_params_init (MHD_gtls_rsa_params_t * rsa_params);
   void MHD__gnutls_rsa_params_deinit (MHD_gtls_rsa_params_t rsa_params);
   int MHD__gnutls_rsa_params_generate2 (MHD_gtls_rsa_params_t params,
-                                       unsigned int bits);
+                                        unsigned int bits);
 
 
 /*
@@ -601,21 +622,21 @@ extern "C"
  */
   typedef ssize_t (*MHD_gtls_pull_func) (MHD_gnutls_transport_ptr_t, void *,
                                          size_t);
-  typedef ssize_t (*MHD_gtls_push_func) (MHD_gnutls_transport_ptr_t, const void *,
-                                         size_t);
+  typedef ssize_t (*MHD_gtls_push_func) (MHD_gnutls_transport_ptr_t,
+                                         const void *, size_t);
   void MHD__gnutls_transport_set_ptr (MHD_gtls_session_t session,
-                                     MHD_gnutls_transport_ptr_t ptr);
+                                      MHD_gnutls_transport_ptr_t ptr);
   void MHD__gnutls_transport_set_ptr2 (MHD_gtls_session_t session,
-                                      MHD_gnutls_transport_ptr_t recv_ptr,
-                                      MHD_gnutls_transport_ptr_t send_ptr);
+                                       MHD_gnutls_transport_ptr_t recv_ptr,
+                                       MHD_gnutls_transport_ptr_t send_ptr);
 
   void MHD__gnutls_transport_set_lowat (MHD_gtls_session_t session, int num);
 
 
   void MHD__gnutls_transport_set_push_function (MHD_gtls_session_t session,
-                                               MHD_gtls_push_func push_func);
+                                                MHD_gtls_push_func push_func);
   void MHD__gnutls_transport_set_pull_function (MHD_gtls_session_t session,
-                                               MHD_gtls_pull_func pull_func);
+                                                MHD_gtls_pull_func pull_func);
 
   void MHD__gnutls_transport_set_errno (MHD_gtls_session_t session, int err);
   void MHD__gnutls_transport_set_global_errno (int err);
@@ -630,8 +651,8 @@ extern "C"
  * this function returns the hash of the given data.
  */
   int MHD__gnutls_fingerprint (enum MHD_GNUTLS_HashAlgorithm algo,
-                              const MHD_gnutls_datum_t * data, void *result,
-                              size_t * result_size);
+                               const MHD_gnutls_datum_t * data, void *result,
+                               size_t * result_size);
 
   typedef enum MHD_gnutls_x509_subject_alt_name_t
   {
@@ -664,21 +685,19 @@ extern "C"
     unsigned int deinit_all;    /* if non zero all keys will be deinited */
   } MHD_gnutls_retr_st;
 
-  typedef int MHD_gnutls_certificate_client_retrieve_function (MHD_gtls_session_t,
-                                                           const
-                                                           MHD_gnutls_datum_t *
-                                                           req_ca_rdn,
-                                                           int nreqs,
-                                                           const
-                                                           enum
-                                                           MHD_GNUTLS_PublicKeyAlgorithm
-                                                           *pk_algos,
-                                                           int
-                                                           pk_algos_length,
-                                                           MHD_gnutls_retr_st *);
-
-  typedef int MHD_gnutls_certificate_server_retrieve_function (MHD_gtls_session_t,
-                                                           MHD_gnutls_retr_st *);
+  typedef int
+    MHD_gnutls_certificate_client_retrieve_function (MHD_gtls_session_t,
+                                                     const MHD_gnutls_datum_t
+                                                     * req_ca_rdn, int nreqs,
+                                                     const enum
+                                                     MHD_GNUTLS_PublicKeyAlgorithm
+                                                     *pk_algos,
+                                                     int pk_algos_length,
+                                                     MHD_gnutls_retr_st *);
+
+  typedef int
+    MHD_gnutls_certificate_server_retrieve_function (MHD_gtls_session_t,
+                                                     MHD_gnutls_retr_st *);
 
   /*
    * Functions that allow auth_info_t structures handling
@@ -694,16 +713,16 @@ extern "C"
    * DH
    */
   void MHD__gnutls_dh_set_prime_bits (MHD_gtls_session_t session,
-                                     unsigned int bits);
+                                      unsigned int bits);
   int MHD__gnutls_dh_get_secret_bits (MHD_gtls_session_t session);
   int MHD__gnutls_dh_get_peers_public_bits (MHD_gtls_session_t session);
   int MHD__gnutls_dh_get_prime_bits (MHD_gtls_session_t session);
 
   int MHD__gnutls_dh_get_group (MHD_gtls_session_t session,
-                               MHD_gnutls_datum_t * raw_gen,
-                               MHD_gnutls_datum_t * raw_prime);
+                                MHD_gnutls_datum_t * raw_gen,
+                                MHD_gnutls_datum_t * raw_prime);
   int MHD__gnutls_dh_get_pubkey (MHD_gtls_session_t session,
-                                MHD_gnutls_datum_t * raw_key);
+                                 MHD_gnutls_datum_t * raw_key);
 
   /*
    * RSA
@@ -715,17 +734,18 @@ extern "C"
 
   /* External signing callback.  Experimental. */
   typedef int (*MHD_gnutls_sign_func) (MHD_gtls_session_t session,
-                                   void *userdata,
-                                   enum MHD_GNUTLS_CertificateType cert_type,
-                                   const MHD_gnutls_datum_t * cert,
-                                   const MHD_gnutls_datum_t * hash,
-                                   MHD_gnutls_datum_t * signature);
+                                       void *userdata,
+                                       enum MHD_GNUTLS_CertificateType
+                                       cert_type,
+                                       const MHD_gnutls_datum_t * cert,
+                                       const MHD_gnutls_datum_t * hash,
+                                       MHD_gnutls_datum_t * signature);
 
   void MHD_gtls_sign_callback_set (MHD_gtls_session_t session,
                                    MHD_gnutls_sign_func sign_func,
                                    void *userdata);
-    MHD_gnutls_sign_func MHD_gtls_sign_callback_get (MHD_gtls_session_t session,
-                                                 void **userdata);
+  MHD_gnutls_sign_func MHD_gtls_sign_callback_get (MHD_gtls_session_t session,
+                                                   void **userdata);
 
   /* These are set on the credentials structure.
    */
@@ -742,11 +762,11 @@ extern "C"
 
   /* get data from the session */
   const MHD_gnutls_datum_t *MHD_gtls_certificate_get_peers (MHD_gtls_session_t
-                                                        session,
-                                                        unsigned int
-                                                        *list_size);
+                                                            session,
+                                                            unsigned int
+                                                            *list_size);
   const MHD_gnutls_datum_t *MHD_gtls_certificate_get_ours (MHD_gtls_session_t
-                                                       session);
+                                                           session);
 
   time_t MHD_gtls_certificate_activation_time_peers (MHD_gtls_session_t
                                                      session);
@@ -762,8 +782,8 @@ extern "C"
   int MHD_gtls_certificate_verify_peers (MHD_gtls_session_t session);
 
   int MHD_gtls_pem_base64_encode (const char *msg,
-                                  const MHD_gnutls_datum_t * data, char *result,
-                                  size_t * result_size);
+                                  const MHD_gnutls_datum_t * data,
+                                  char *result, size_t * result_size);
   int MHD_gtls_pem_base64_decode (const char *header,
                                   const MHD_gnutls_datum_t * b64_data,
                                   unsigned char *result,
diff --git a/src/daemon/https/lgl/des.c b/src/daemon/https/lgl/des.c
index 7bc4c4d0..dbe5f3c6 100644
--- a/src/daemon/https/lgl/des.c
+++ b/src/daemon/https/lgl/des.c
@@ -543,7 +543,8 @@ MHD_gl_des_makekey (MHD_gl_des_ctx * ctx, const char *key, size_t keylen)
 }
 
 void
-MHD_gl_des_ecb_crypt (MHD_gl_des_ctx * ctx, const char *_from, char *_to, int mode)
+MHD_gl_des_ecb_crypt (MHD_gl_des_ctx * ctx, const char *_from, char *_to,
+                      int mode)
 {
   const unsigned char *from = (const unsigned char *) _from;
   unsigned char *to = (unsigned char *) _to;
@@ -565,7 +566,8 @@ READ_64BIT_DATA (from, left, right)
     FINAL_PERMUTATION (right, work, left) WRITE_64BIT_DATA (to, right, left)}
 
 void
-MHD_gl_3des_set2keys (MHD_gl_3des_ctx * ctx, const char *key1, const char *key2)
+MHD_gl_3des_set2keys (MHD_gl_3des_ctx * ctx, const char *key1,
+                      const char *key2)
 {
   int i;
 
@@ -590,7 +592,7 @@ MHD_gl_3des_set2keys (MHD_gl_3des_ctx * ctx, const char *key1, const char *key2)
 
 void
 MHD_gl_3des_set3keys (MHD_gl_3des_ctx * ctx, const char *key1,
-                  const char *key2, const char *key3)
+                      const char *key2, const char *key3)
 {
   int i;
 
@@ -612,7 +614,8 @@ MHD_gl_3des_set3keys (MHD_gl_3des_ctx * ctx, const char *key1,
 }
 
 void
-MHD_gl_3des_ecb_crypt (MHD_gl_3des_ctx * ctx, const char *_from, char *_to, int mode)
+MHD_gl_3des_ecb_crypt (MHD_gl_3des_ctx * ctx, const char *_from, char *_to,
+                       int mode)
 {
   const unsigned char *from = (const unsigned char *) _from;
   unsigned char *to = (unsigned char *) _to;
@@ -658,5 +661,6 @@ MHD_gl_3des_makekey (MHD_gl_3des_ctx * ctx, const char *key, size_t keylen)
   MHD_gl_3des_set3keys (ctx, key, key + 8, key + 16);
 
   return !(MHD_gl_des_is_weak_key (key)
-           || MHD_gl_des_is_weak_key (key + 8) || MHD_gl_des_is_weak_key (key + 16));
+           || MHD_gl_des_is_weak_key (key + 8)
+           || MHD_gl_des_is_weak_key (key + 16));
 }
diff --git a/src/daemon/https/lgl/des.h b/src/daemon/https/lgl/des.h
index 4d9eb20c..d2ad058e 100644
--- a/src/daemon/https/lgl/des.h
+++ b/src/daemon/https/lgl/des.h
@@ -62,12 +62,14 @@ extern void MHD_gl_des_setkey (MHD_gl_des_ctx * ctx, const char *key);
 /* Fill a DES context CTX with subkeys calculated from 64bit KEY, with
  * weak key checking.  Does not check parity bits, but simply ignore
  * them. */
-extern bool MHD_gl_des_makekey (MHD_gl_des_ctx * ctx, const char *key, size_t keylen);
+extern bool MHD_gl_des_makekey (MHD_gl_des_ctx * ctx, const char *key,
+                                size_t keylen);
 
 /* Electronic Codebook Mode DES encryption/decryption of data
  * according to 'mode'. */
 extern void
-MHD_gl_des_ecb_crypt (MHD_gl_des_ctx * ctx, const char *from, char *to, int mode);
+MHD_gl_des_ecb_crypt (MHD_gl_des_ctx * ctx, const char *from, char *to,
+                      int mode);
 
 #define MHD_gl_des_ecb_encrypt(ctx, from, to)  MHD_gl_des_ecb_crypt(ctx, from, to, 0)
 #define MHD_gl_des_ecb_decrypt(ctx, from, to)  MHD_gl_des_ecb_crypt(ctx, from, to, 1)
@@ -80,7 +82,8 @@ MHD_gl_des_ecb_crypt (MHD_gl_des_ctx * ctx, const char *from, char *to, int mode
  * 64bit keys in KEY1 and KEY2.  Does not check the parity bits of the
  * keys, but simply ignore them.  Does not check for weak keys. */
 extern void
-MHD_gl_3des_set2keys (MHD_gl_3des_ctx * ctx, const char *key1, const char *key2);
+MHD_gl_3des_set2keys (MHD_gl_3des_ctx * ctx, const char *key1,
+                      const char *key2);
 
 /*
  * Fill a Triple-DES context CTX with subkeys calculated from three
@@ -89,7 +92,7 @@ MHD_gl_3des_set2keys (MHD_gl_3des_ctx * ctx, const char *key1, const char *key2)
  * keys. */
 extern void
 MHD_gl_3des_set3keys (MHD_gl_3des_ctx * ctx,
-                  const char *key1, const char *key2, const char *key3);
+                      const char *key1, const char *key2, const char *key3);
 
 /* Fill a Triple-DES context CTX with subkeys calculated from three
  * concatenated 64bit keys in KEY, with weak key checking.  Does not
@@ -101,7 +104,8 @@ MHD_gl_3des_makekey (MHD_gl_3des_ctx * ctx, const char *key, size_t keylen);
  * according to 'mode'.  Sometimes this mode is named 'EDE' mode
  * (Encryption-Decryption-Encryption). */
 extern void
-MHD_gl_3des_ecb_crypt (MHD_gl_3des_ctx * ctx, const char *from, char *to, int mode);
+MHD_gl_3des_ecb_crypt (MHD_gl_3des_ctx * ctx, const char *from, char *to,
+                       int mode);
 
 #define MHD_gl_3des_ecb_encrypt(ctx, from, to) MHD_gl_3des_ecb_crypt(ctx,from,to,0)
 #define MHD_gl_3des_ecb_decrypt(ctx, from, to) MHD_gl_3des_ecb_crypt(ctx,from,to,1)
diff --git a/src/daemon/https/lgl/gc-gnulib.c b/src/daemon/https/lgl/gc-gnulib.c
index 7c16d443..52fce18b 100644
--- a/src/daemon/https/lgl/gc-gnulib.c
+++ b/src/daemon/https/lgl/gc-gnulib.c
@@ -161,9 +161,9 @@ MHD_gc_random (char *data, size_t datalen)
 /* Memory allocation. */
 void
 MHD_gc_set_allocators (MHD_gc_malloc_t func_malloc,
-                   MHD_gc_malloc_t secure_malloc,
-                   MHD_gc_secure_check_t secure_check,
-                   MHD_gc_realloc_t func_realloc, MHD_gc_free_t func_free)
+                       MHD_gc_malloc_t secure_malloc,
+                       MHD_gc_secure_check_t secure_check,
+                       MHD_gc_realloc_t func_realloc, MHD_gc_free_t func_free)
 {
   return;
 }
@@ -193,7 +193,7 @@ typedef struct _MHD_gc_cipher_ctx
 
 Gc_rc
 MHD_gc_cipher_open (Gc_cipher alg,
-                Gc_cipher_mode mode, MHD_gc_cipher_handle * outhandle)
+                    Gc_cipher_mode mode, MHD_gc_cipher_handle * outhandle)
 {
   _MHD_gc_cipher_ctx *ctx;
   Gc_rc rc = GC_OK;
@@ -277,7 +277,8 @@ MHD_gc_cipher_open (Gc_cipher alg,
 }
 
 Gc_rc
-MHD_gc_cipher_setkey (MHD_gc_cipher_handle handle, size_t keylen, const char *key)
+MHD_gc_cipher_setkey (MHD_gc_cipher_handle handle, size_t keylen,
+                      const char *key)
 {
   _MHD_gc_cipher_ctx *ctx = handle;
 
@@ -317,16 +318,18 @@ MHD_gc_cipher_setkey (MHD_gc_cipher_handle handle, size_t keylen, const char *ke
           sprintf (&keyMaterial[2 * i], "%02x", key[i] & 0xFF);
 
         rc = MHD_rijndaelMakeKey (&ctx->aesEncKey, RIJNDAEL_DIR_ENCRYPT,
-                              keylen * 8, keyMaterial);
+                                  keylen * 8, keyMaterial);
         if (rc < 0)
           return GC_INVALID_CIPHER;
 
         rc = MHD_rijndaelMakeKey (&ctx->aesDecKey, RIJNDAEL_DIR_DECRYPT,
-                              keylen * 8, keyMaterial);
+                                  keylen * 8, keyMaterial);
         if (rc < 0)
           return GC_INVALID_CIPHER;
 
-        rc = MHD_MHD_rijndaelCipherInit (&ctx->aesContext, RIJNDAEL_MODE_ECB, NULL);
+        rc =
+          MHD_MHD_rijndaelCipherInit (&ctx->aesContext, RIJNDAEL_MODE_ECB,
+                                      NULL);
         if (rc < 0)
           return GC_INVALID_CIPHER;
       }
@@ -341,7 +344,8 @@ MHD_gc_cipher_setkey (MHD_gc_cipher_handle handle, size_t keylen, const char *ke
 }
 
 Gc_rc
-MHD_gc_cipher_setiv (MHD_gc_cipher_handle handle, size_t ivlen, const char *iv)
+MHD_gc_cipher_setiv (MHD_gc_cipher_handle handle, size_t ivlen,
+                     const char *iv)
 {
   _MHD_gc_cipher_ctx *ctx = handle;
 
@@ -374,8 +378,9 @@ MHD_gc_cipher_setiv (MHD_gc_cipher_handle handle, size_t ivlen, const char *iv)
             for (i = 0; i < ivlen; i++)
               sprintf (&ivMaterial[2 * i], "%02x", iv[i] & 0xFF);
 
-            rc = MHD_MHD_rijndaelCipherInit (&ctx->aesContext, RIJNDAEL_MODE_CBC,
-                                     ivMaterial);
+            rc =
+              MHD_MHD_rijndaelCipherInit (&ctx->aesContext, RIJNDAEL_MODE_CBC,
+                                          ivMaterial);
             if (rc < 0)
               return GC_INVALID_CIPHER;
           }
@@ -395,7 +400,8 @@ MHD_gc_cipher_setiv (MHD_gc_cipher_handle handle, size_t ivlen, const char *iv)
 }
 
 Gc_rc
-MHD_gc_cipher_encrypt_inline (MHD_gc_cipher_handle handle, size_t len, char *data)
+MHD_gc_cipher_encrypt_inline (MHD_gc_cipher_handle handle, size_t len,
+                              char *data)
 {
   _MHD_gc_cipher_ctx *ctx = handle;
 
@@ -450,7 +456,7 @@ MHD_gc_cipher_encrypt_inline (MHD_gc_cipher_handle handle, size_t len, char *dat
         int nblocks;
 
         nblocks = MHD_rijndaelBlockEncrypt (&ctx->aesContext, &ctx->aesEncKey,
-                                        data, 8 * len, data);
+                                            data, 8 * len, data);
         if (nblocks < 0)
           return GC_INVALID_CIPHER;
       }
@@ -465,7 +471,8 @@ MHD_gc_cipher_encrypt_inline (MHD_gc_cipher_handle handle, size_t len, char *dat
 }
 
 Gc_rc
-MHD_gc_cipher_decrypt_inline (MHD_gc_cipher_handle handle, size_t len, char *data)
+MHD_gc_cipher_decrypt_inline (MHD_gc_cipher_handle handle, size_t len,
+                              char *data)
 {
   _MHD_gc_cipher_ctx *ctx = handle;
 
@@ -522,7 +529,7 @@ MHD_gc_cipher_decrypt_inline (MHD_gc_cipher_handle handle, size_t len, char *dat
         int nblocks;
 
         nblocks = MHD_rijndaelBlockDecrypt (&ctx->aesContext, &ctx->aesDecKey,
-                                        data, 8 * len, data);
+                                            data, 8 * len, data);
         if (nblocks < 0)
           return GC_INVALID_CIPHER;
       }
@@ -565,7 +572,8 @@ typedef struct _MHD_gc_hash_ctx
 } _MHD_gc_hash_ctx;
 
 Gc_rc
-MHD_gc_hash_open (Gc_hash hash, Gc_hash_mode mode, MHD_gc_hash_handle * outhandle)
+MHD_gc_hash_open (Gc_hash hash, Gc_hash_mode mode,
+                  MHD_gc_hash_handle * outhandle)
 {
   _MHD_gc_hash_ctx *ctx;
   Gc_rc rc = GC_OK;
@@ -769,7 +777,7 @@ MHD_gc_sha1 (const void *in, size_t inlen, void *resbuf)
 #ifdef GNULIB_GC_HMAC_MD5
 Gc_rc
 MHD_gc_MHD_hmac_md5 (const void *key, size_t keylen,
-             const void *in, size_t inlen, char *resbuf)
+                     const void *in, size_t inlen, char *resbuf)
 {
   MHD_hmac_md5 (key, keylen, in, inlen, resbuf);
   return GC_OK;
@@ -779,7 +787,8 @@ MHD_gc_MHD_hmac_md5 (const void *key, size_t keylen,
 #ifdef GNULIB_GC_HMAC_SHA1
 Gc_rc
 MHD_gc_MHD_hmac_sha1 (const void *key,
-              size_t keylen, const void *in, size_t inlen, char *resbuf)
+                      size_t keylen, const void *in, size_t inlen,
+                      char *resbuf)
 {
   MHD_hmac_sha1 (key, keylen, in, inlen, resbuf);
   return GC_OK;
diff --git a/src/daemon/https/lgl/gc-libgcrypt.c b/src/daemon/https/lgl/gc-libgcrypt.c
index a51a7bb4..e4429bd2 100644
--- a/src/daemon/https/lgl/gc-libgcrypt.c
+++ b/src/daemon/https/lgl/gc-libgcrypt.c
@@ -90,9 +90,9 @@ MHD_gc_random (char *data, size_t datalen)
 
 void
 MHD_gc_set_allocators (MHD_gc_malloc_t func_malloc,
-                   MHD_gc_malloc_t secure_malloc,
-                   MHD_gc_secure_check_t secure_check,
-                   MHD_gc_realloc_t func_realloc, MHD_gc_free_t func_free)
+                       MHD_gc_malloc_t secure_malloc,
+                       MHD_gc_secure_check_t secure_check,
+                       MHD_gc_realloc_t func_realloc, MHD_gc_free_t func_free)
 {
   gcry_set_allocation_handler (func_malloc, secure_malloc, secure_check,
                                func_realloc, func_free);
@@ -102,7 +102,7 @@ MHD_gc_set_allocators (MHD_gc_malloc_t func_malloc,
 
 Gc_rc
 MHD_gc_cipher_open (Gc_cipher alg,
-                Gc_cipher_mode mode, MHD_gc_cipher_handle * outhandle)
+                    Gc_cipher_mode mode, MHD_gc_cipher_handle * outhandle)
 {
   int gcryalg, gcrymode;
   gcry_error_t err;
@@ -179,7 +179,8 @@ MHD_gc_cipher_open (Gc_cipher alg,
 }
 
 Gc_rc
-MHD_gc_cipher_setkey (MHD_gc_cipher_handle handle, size_t keylen, const char *key)
+MHD_gc_cipher_setkey (MHD_gc_cipher_handle handle, size_t keylen,
+                      const char *key)
 {
   gcry_error_t err;
 
@@ -191,7 +192,8 @@ MHD_gc_cipher_setkey (MHD_gc_cipher_handle handle, size_t keylen, const char *ke
 }
 
 Gc_rc
-MHD_gc_cipher_setiv (MHD_gc_cipher_handle handle, size_t ivlen, const char *iv)
+MHD_gc_cipher_setiv (MHD_gc_cipher_handle handle, size_t ivlen,
+                     const char *iv)
 {
   gcry_error_t err;
 
@@ -203,7 +205,8 @@ MHD_gc_cipher_setiv (MHD_gc_cipher_handle handle, size_t ivlen, const char *iv)
 }
 
 Gc_rc
-MHD_gc_cipher_encrypt_inline (MHD_gc_cipher_handle handle, size_t len, char *data)
+MHD_gc_cipher_encrypt_inline (MHD_gc_cipher_handle handle, size_t len,
+                              char *data)
 {
   if (gcry_cipher_encrypt ((gcry_cipher_hd_t) handle, data, len, NULL, len) !=
       0)
@@ -213,7 +216,8 @@ MHD_gc_cipher_encrypt_inline (MHD_gc_cipher_handle handle, size_t len, char *dat
 }
 
 Gc_rc
-MHD_gc_cipher_decrypt_inline (MHD_gc_cipher_handle handle, size_t len, char *data)
+MHD_gc_cipher_decrypt_inline (MHD_gc_cipher_handle handle, size_t len,
+                              char *data)
 {
   if (gcry_cipher_decrypt ((gcry_cipher_hd_t) handle, data, len, NULL, len) !=
       0)
@@ -240,7 +244,8 @@ typedef struct _MHD_gc_hash_ctx
 } _MHD_gc_hash_ctx;
 
 Gc_rc
-MHD_gc_hash_open (Gc_hash hash, Gc_hash_mode mode, MHD_gc_hash_handle * outhandle)
+MHD_gc_hash_open (Gc_hash hash, Gc_hash_mode mode,
+                  MHD_gc_hash_handle * outhandle)
 {
   _MHD_gc_hash_ctx *ctx;
   int gcryalg = 0, gcrymode = 0;
@@ -391,7 +396,8 @@ MHD_gc_hash_digest_length (Gc_hash hash)
 }
 
 void
-MHD_gc_hash_MHD_hmac_setkey (MHD_gc_hash_handle handle, size_t len, const char *key)
+MHD_gc_hash_MHD_hmac_setkey (MHD_gc_hash_handle handle, size_t len,
+                             const char *key)
 {
   _MHD_gc_hash_ctx *ctx = handle;
   gcry_md_setkey (ctx->gch, key, len);
@@ -411,7 +417,7 @@ MHD_gc_hash_read (MHD_gc_hash_handle handle)
   const char *digest;
   {
     gcry_md_final (ctx->gch);
-    digest = (const char*) gcry_md_read (ctx->gch, 0);
+    digest = (const char *) gcry_md_read (ctx->gch, 0);
   }
 
   return digest;
@@ -547,7 +553,7 @@ MHD_gc_sha1 (const void *in, size_t inlen, void *resbuf)
 #ifdef GNULIB_GC_HMAC_MD5
 Gc_rc
 MHD_gc_MHD_hmac_md5 (const void *key, size_t keylen,
-             const void *in, size_t inlen, char *resbuf)
+                     const void *in, size_t inlen, char *resbuf)
 {
   size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
   gcry_md_hd_t mdh;
@@ -587,7 +593,8 @@ MHD_gc_MHD_hmac_md5 (const void *key, size_t keylen,
 #ifdef GNULIB_GC_HMAC_SHA1
 Gc_rc
 MHD_gc_MHD_hmac_sha1 (const void *key,
-              size_t keylen, const void *in, size_t inlen, char *resbuf)
+                      size_t keylen, const void *in, size_t inlen,
+                      char *resbuf)
 {
   size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
   gcry_md_hd_t mdh;
diff --git a/src/daemon/https/lgl/gc-pbkdf2-sha1.c b/src/daemon/https/lgl/gc-pbkdf2-sha1.c
index 98ac9f96..f58ba491 100644
--- a/src/daemon/https/lgl/gc-pbkdf2-sha1.c
+++ b/src/daemon/https/lgl/gc-pbkdf2-sha1.c
@@ -53,8 +53,8 @@
 
 Gc_rc
 MHD_gc_pbkdf2_sha1 (const char *P, size_t Plen,
-                const char *S, size_t Slen,
-                unsigned int c, char *DK, size_t dkLen)
+                    const char *S, size_t Slen,
+                    unsigned int c, char *DK, size_t dkLen)
 {
   unsigned int hLen = 20;
   char U[20];
diff --git a/src/daemon/https/lgl/gc.h b/src/daemon/https/lgl/gc.h
index ecc506fc..4d6b2c93 100644
--- a/src/daemon/https/lgl/gc.h
+++ b/src/daemon/https/lgl/gc.h
@@ -105,9 +105,10 @@ typedef int (*MHD_gc_secure_check_t) (const void *);
 typedef void *(*MHD_gc_realloc_t) (void *p, size_t n);
 typedef void (*MHD_gc_free_t) (void *);
 void MHD_gc_set_allocators (MHD_gc_malloc_t func_malloc,
-                        MHD_gc_malloc_t secure_malloc,
-                        MHD_gc_secure_check_t secure_check,
-                        MHD_gc_realloc_t func_realloc, MHD_gc_free_t func_free);
+                            MHD_gc_malloc_t secure_malloc,
+                            MHD_gc_secure_check_t secure_check,
+                            MHD_gc_realloc_t func_realloc,
+                            MHD_gc_free_t func_free);
 
 /* Randomness. */
 Gc_rc MHD_gc_nonce (char *data, size_t datalen);
@@ -116,24 +117,29 @@ Gc_rc MHD_gc_random (char *data, size_t datalen);
 
 /* Ciphers. */
 Gc_rc MHD_gc_cipher_open (Gc_cipher cipher,
-                      Gc_cipher_mode mode, MHD_gc_cipher_handle * outhandle);
-Gc_rc MHD_gc_cipher_setkey (MHD_gc_cipher_handle handle,
-                        size_t keylen, const char *key);
-Gc_rc MHD_gc_cipher_setiv (MHD_gc_cipher_handle handle, size_t ivlen, const char *iv);
-Gc_rc MHD_gc_cipher_encrypt_inline (MHD_gc_cipher_handle handle,
-                                size_t len, char *data);
-Gc_rc MHD_gc_cipher_decrypt_inline (MHD_gc_cipher_handle handle,
-                                size_t len, char *data);
+                          Gc_cipher_mode mode,
+                          MHD_gc_cipher_handle * outhandle);
+Gc_rc MHD_gc_cipher_setkey (MHD_gc_cipher_handle handle, size_t keylen,
+                            const char *key);
+Gc_rc MHD_gc_cipher_setiv (MHD_gc_cipher_handle handle, size_t ivlen,
+                           const char *iv);
+Gc_rc MHD_gc_cipher_encrypt_inline (MHD_gc_cipher_handle handle, size_t len,
+                                    char *data);
+Gc_rc MHD_gc_cipher_decrypt_inline (MHD_gc_cipher_handle handle, size_t len,
+                                    char *data);
 Gc_rc MHD_gc_cipher_close (MHD_gc_cipher_handle handle);
 
 /* Hashes. */
 
 Gc_rc MHD_gc_hash_open (Gc_hash hash,
-                    Gc_hash_mode mode, MHD_gc_hash_handle * outhandle);
-Gc_rc MHD_gc_hash_clone (MHD_gc_hash_handle handle, MHD_gc_hash_handle * outhandle);
+                        Gc_hash_mode mode, MHD_gc_hash_handle * outhandle);
+Gc_rc MHD_gc_hash_clone (MHD_gc_hash_handle handle,
+                         MHD_gc_hash_handle * outhandle);
 size_t MHD_gc_hash_digest_length (Gc_hash hash);
-void MHD_gc_hash_MHD_hmac_setkey (MHD_gc_hash_handle handle, size_t len, const char *key);
-void MHD_gc_hash_write (MHD_gc_hash_handle handle, size_t len, const char *data);
+void MHD_gc_hash_MHD_hmac_setkey (MHD_gc_hash_handle handle, size_t len,
+                                  const char *key);
+void MHD_gc_hash_write (MHD_gc_hash_handle handle, size_t len,
+                        const char *data);
 const char *MHD_gc_hash_read (MHD_gc_hash_handle handle);
 void MHD_gc_hash_close (MHD_gc_hash_handle handle);
 
@@ -143,7 +149,8 @@ void MHD_gc_hash_close (MHD_gc_hash_handle handle);
  GC_<HASH>_DIGEST_SIZE.  For example, for GC_MD5 the output buffer
  must be 16 bytes.  The return value is 0 (GC_OK) on success, or
  another Gc_rc error code. */
-Gc_rc MHD_gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *out);
+Gc_rc MHD_gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen,
+                          char *out);
 
 /* One-call interface. */
 Gc_rc MHD_gc_md2 (const void *in, size_t inlen, void *resbuf);
@@ -151,10 +158,10 @@ Gc_rc MHD_gc_md4 (const void *in, size_t inlen, void *resbuf);
 Gc_rc MHD_gc_md5 (const void *in, size_t inlen, void *resbuf);
 Gc_rc MHD_gc_sha1 (const void *in, size_t inlen, void *resbuf);
 Gc_rc MHD_gc_MHD_hmac_md5 (const void *key,
-                   size_t keylen, const void *in, size_t inlen, char *resbuf);
-Gc_rc MHD_gc_MHD_hmac_sha1 (const void *key,
-                    size_t keylen,
-                    const void *in, size_t inlen, char *resbuf);
+                           size_t keylen, const void *in, size_t inlen,
+                           char *resbuf);
+Gc_rc MHD_gc_MHD_hmac_sha1 (const void *key, size_t keylen, const void *in,
+                            size_t inlen, char *resbuf);
 
 /* Derive cryptographic keys from a password P of length PLEN, with
  salt S of length SLEN, placing the result in pre-allocated buffer
@@ -164,9 +171,10 @@ Gc_rc MHD_gc_MHD_hmac_sha1 (const void *key,
  exactly dkLen bytes long.  GC_OK is returned on success, otherwise
  an Gc_rc error code is returned.  */
 Gc_rc MHD_gc_pbkdf2_sha1 (const char *P,
-                      size_t Plen,
-                      const char *S,
-                      size_t Slen, unsigned int c, char *DK, size_t dkLen);
+                          size_t Plen,
+                          const char *S,
+                          size_t Slen, unsigned int c, char *DK,
+                          size_t dkLen);
 
 /*
  TODO:
diff --git a/src/daemon/https/lgl/hmac-md5.c b/src/daemon/https/lgl/hmac-md5.c
index fc6902a9..1fd943f0 100644
--- a/src/daemon/https/lgl/hmac-md5.c
+++ b/src/daemon/https/lgl/hmac-md5.c
@@ -31,7 +31,7 @@
 
 int
 MHD_hmac_md5 (const void *key, size_t keylen,
-          const void *in, size_t inlen, void *resbuf)
+              const void *in, size_t inlen, void *resbuf)
 {
   struct MHD_md5_ctx inner;
   struct MHD_md5_ctx outer;
diff --git a/src/daemon/https/lgl/hmac-sha1.c b/src/daemon/https/lgl/hmac-sha1.c
index 5d341cb4..4d2e4f37 100644
--- a/src/daemon/https/lgl/hmac-sha1.c
+++ b/src/daemon/https/lgl/hmac-sha1.c
@@ -31,7 +31,7 @@
 
 int
 MHD_hmac_sha1 (const void *key, size_t keylen,
-           const void *in, size_t inlen, void *resbuf)
+               const void *in, size_t inlen, void *resbuf)
 {
   struct MHD_sha1_ctx inner;
   struct MHD_sha1_ctx outer;
diff --git a/src/daemon/https/lgl/hmac.h b/src/daemon/https/lgl/hmac.h
index 29764056..c4791504 100644
--- a/src/daemon/https/lgl/hmac.h
+++ b/src/daemon/https/lgl/hmac.h
@@ -28,7 +28,7 @@
    RESBUF buffer.  Return 0 on success.  */
 int
 MHD_hmac_md5 (const void *key, size_t keylen,
-          const void *buffer, size_t buflen, void *resbuf);
+              const void *buffer, size_t buflen, void *resbuf);
 
 /* Compute Hashed Message Authentication Code with SHA-1, over BUFFER
    data of BUFLEN bytes using the KEY of KEYLEN bytes, writing the
@@ -36,6 +36,6 @@ MHD_hmac_md5 (const void *key, size_t keylen,
    success.  */
 int
 MHD_hmac_sha1 (const void *key, size_t keylen,
-           const void *in, size_t inlen, void *resbuf);
+               const void *in, size_t inlen, void *resbuf);
 
 #endif /* HMAC_H */
diff --git a/src/daemon/https/lgl/md5.c b/src/daemon/https/lgl/md5.c
index bc1fccbc..8cca27f5 100644
--- a/src/daemon/https/lgl/md5.c
+++ b/src/daemon/https/lgl/md5.c
@@ -212,7 +212,8 @@ MHD_md5_buffer (const char *buffer, size_t len, void *resblock)
 
 
 void
-MHD_md5_process_bytes (const void *buffer, size_t len, struct MHD_md5_ctx *ctx)
+MHD_md5_process_bytes (const void *buffer, size_t len,
+                       struct MHD_md5_ctx *ctx)
 {
   /* When we already have some bits in our internal buffer concatenate
      both inputs first.  */
@@ -292,7 +293,8 @@ MHD_md5_process_bytes (const void *buffer, size_t len, struct MHD_md5_ctx *ctx)
    It is assumed that LEN % 64 == 0.  */
 
 void
-MHD_md5_process_block (const void *buffer, size_t len, struct MHD_md5_ctx *ctx)
+MHD_md5_process_block (const void *buffer, size_t len,
+                       struct MHD_md5_ctx *ctx)
 {
   uint32_t correct_words[16];
   const uint32_t *words = buffer;
diff --git a/src/daemon/https/lgl/md5.h b/src/daemon/https/lgl/md5.h
index 80793b66..94247e46 100644
--- a/src/daemon/https/lgl/md5.h
+++ b/src/daemon/https/lgl/md5.h
@@ -83,14 +83,14 @@ __MHD_md5_init_ctx (struct MHD_md5_ctx *ctx)
    starting at BUFFER.
    It is necessary that LEN is a multiple of 64!!! */
      extern void __MHD_md5_process_block (const void *buffer, size_t len,
-                                      struct MHD_md5_ctx *ctx) __THROW;
+                                          struct MHD_md5_ctx *ctx) __THROW;
 
 /* Starting with the result of former calls of this function (or the
    initialization function update the context for the next LEN bytes
    starting at BUFFER.
    It is NOT required that LEN is a multiple of 64.  */
      extern void __MHD_md5_process_bytes (const void *buffer, size_t len,
-                                      struct MHD_md5_ctx *ctx) __THROW;
+                                          struct MHD_md5_ctx *ctx) __THROW;
 
 /* Process the remaining bytes in the buffer and put result from CTX
    in first 16 bytes following RESBUF.  The result is always in little
@@ -100,7 +100,7 @@ __MHD_md5_init_ctx (struct MHD_md5_ctx *ctx)
    IMPORTANT: On some systems, RESBUF must be aligned to a 32-bit
    boundary. */
      extern void *__MHD_md5_finish_ctx (struct MHD_md5_ctx *ctx,
-                                    void *resbuf) __THROW;
+                                        void *resbuf) __THROW;
 
 
 /* Put result from CTX in first 16 bytes following RESBUF.  The result is
@@ -110,7 +110,7 @@ __MHD_md5_init_ctx (struct MHD_md5_ctx *ctx)
    IMPORTANT: On some systems, RESBUF must be aligned to a 32-bit
    boundary. */
      extern void *__MHD_md5_read_ctx (const struct MHD_md5_ctx *ctx,
-                                  void *resbuf) __THROW;
+                                      void *resbuf) __THROW;
 
 
 /* Compute MD5 message digest for bytes read from STREAM.  The
@@ -123,6 +123,6 @@ __MHD_md5_init_ctx (struct MHD_md5_ctx *ctx)
    output yields to the wanted ASCII representation of the message
    digest.  */
      extern void *__MHD_md5_buffer (const char *buffer, size_t len,
-                                void *resblock) __THROW;
+                                    void *resblock) __THROW;
 
 #endif /* md5.h */
diff --git a/src/daemon/https/lgl/rijndael-alg-fst.c b/src/daemon/https/lgl/rijndael-alg-fst.c
index d17fbeed..516fff15 100644
--- a/src/daemon/https/lgl/rijndael-alg-fst.c
+++ b/src/daemon/https/lgl/rijndael-alg-fst.c
@@ -763,7 +763,7 @@ static const uint32_t rcon[] = {
  */
 int
 MHD_rijndaelKeySetupEnc (uint32_t rk[ /*4*(Nr + 1) */ ],
-                     const char cipherKey[], size_t keyBits)
+                         const char cipherKey[], size_t keyBits)
 {
   size_t i = 0;
   uint32_t temp;
@@ -858,7 +858,7 @@ MHD_rijndaelKeySetupEnc (uint32_t rk[ /*4*(Nr + 1) */ ],
  */
 int
 MHD_rijndaelKeySetupDec (uint32_t rk[ /*4*(Nr + 1) */ ],
-                     const char cipherKey[], size_t keyBits)
+                         const char cipherKey[], size_t keyBits)
 {
   size_t Nr, i, j;
   uint32_t temp;
@@ -912,7 +912,7 @@ MHD_rijndaelKeySetupDec (uint32_t rk[ /*4*(Nr + 1) */ ],
 
 void
 MHD_rijndaelEncrypt (const uint32_t rk[ /*4*(Nr + 1) */ ], size_t Nr,
-                 const char pt[16], char ct[16])
+                     const char pt[16], char ct[16])
 {
   uint32_t s0, s1, s2, s3, t0, t1, t2, t3;
   size_t r;
@@ -1003,7 +1003,7 @@ MHD_rijndaelEncrypt (const uint32_t rk[ /*4*(Nr + 1) */ ], size_t Nr,
 
 void
 MHD_rijndaelDecrypt (const uint32_t rk[ /*4*(Nr + 1) */ ], size_t Nr,
-                 const char ct[16], char pt[16])
+                     const char ct[16], char pt[16])
 {
   uint32_t s0, s1, s2, s3, t0, t1, t2, t3;
   size_t r;
diff --git a/src/daemon/https/lgl/rijndael-alg-fst.h b/src/daemon/https/lgl/rijndael-alg-fst.h
index c5496181..b04c1deb 100644
--- a/src/daemon/https/lgl/rijndael-alg-fst.h
+++ b/src/daemon/https/lgl/rijndael-alg-fst.h
@@ -56,12 +56,12 @@
 #define RIJNDAEL_MAXNR 14
 
 int MHD_rijndaelKeySetupEnc (uint32_t rk[ /*4*(Nr + 1) */ ],
-                         const char cipherKey[], size_t keyBits);
+                             const char cipherKey[], size_t keyBits);
 int MHD_rijndaelKeySetupDec (uint32_t rk[ /*4*(Nr + 1) */ ],
-                         const char cipherKey[], size_t keyBits);
+                             const char cipherKey[], size_t keyBits);
 void MHD_rijndaelEncrypt (const uint32_t rk[ /*4*(Nr + 1) */ ], size_t Nr,
-                      const char pt[16], char ct[16]);
+                          const char pt[16], char ct[16]);
 void MHD_rijndaelDecrypt (const uint32_t rk[ /*4*(Nr + 1) */ ], size_t Nr,
-                      const char ct[16], char pt[16]);
+                          const char ct[16], char pt[16]);
 
 #endif /* __RIJNDAEL_ALG_FST_H */
diff --git a/src/daemon/https/lgl/rijndael-api-fst.c b/src/daemon/https/lgl/rijndael-api-fst.c
index 62d2a4e6..d4196948 100644
--- a/src/daemon/https/lgl/rijndael-api-fst.c
+++ b/src/daemon/https/lgl/rijndael-api-fst.c
@@ -73,7 +73,7 @@
 
 rijndael_rc
 MHD_rijndaelMakeKey (rijndaelKeyInstance * key, rijndael_direction direction,
-                 size_t keyLen, const char *keyMaterial)
+                     size_t keyLen, const char *keyMaterial)
 {
   size_t i;
   char *keyMat;
@@ -149,8 +149,8 @@ MHD_rijndaelMakeKey (rijndaelKeyInstance * key, rijndael_direction direction,
 }
 
 rijndael_rc
-MHD_MHD_rijndaelCipherInit (rijndaelCipherInstance * cipher, rijndael_mode mode,
-                    const char *IV)
+MHD_MHD_rijndaelCipherInit (rijndaelCipherInstance * cipher,
+                            rijndael_mode mode, const char *IV)
 {
   if ((mode == RIJNDAEL_MODE_ECB) || (mode == RIJNDAEL_MODE_CBC)
       || (mode == RIJNDAEL_MODE_CFB1))
@@ -200,8 +200,8 @@ MHD_MHD_rijndaelCipherInit (rijndaelCipherInstance * cipher, rijndael_mode mode,
 
 int
 MHD_rijndaelBlockEncrypt (rijndaelCipherInstance * cipher,
-                      const rijndaelKeyInstance * key,
-                      const char *input, size_t inputLen, char *outBuffer)
+                          const rijndaelKeyInstance * key,
+                          const char *input, size_t inputLen, char *outBuffer)
 {
   size_t i, k, t, numBlocks;
   char block[16], *iv;
@@ -277,8 +277,9 @@ MHD_rijndaelBlockEncrypt (rijndaelCipherInstance * cipher,
 
 int
 MHD_rijndaelPadEncrypt (rijndaelCipherInstance * cipher,
-                    const rijndaelKeyInstance * key,
-                    const char *input, size_t inputOctets, char *outBuffer)
+                        const rijndaelKeyInstance * key,
+                        const char *input, size_t inputOctets,
+                        char *outBuffer)
 {
   size_t i, numBlocks, padLen;
   char block[16], *iv;
@@ -350,8 +351,8 @@ MHD_rijndaelPadEncrypt (rijndaelCipherInstance * cipher,
 
 int
 MHD_rijndaelBlockDecrypt (rijndaelCipherInstance * cipher,
-                      const rijndaelKeyInstance * key,
-                      const char *input, size_t inputLen, char *outBuffer)
+                          const rijndaelKeyInstance * key,
+                          const char *input, size_t inputLen, char *outBuffer)
 {
   size_t i, k, t, numBlocks;
   char block[16], *iv;
@@ -426,8 +427,9 @@ MHD_rijndaelBlockDecrypt (rijndaelCipherInstance * cipher,
 
 int
 MHD_rijndaelPadDecrypt (rijndaelCipherInstance * cipher,
-                    const rijndaelKeyInstance * key,
-                    const char *input, size_t inputOctets, char *outBuffer)
+                        const rijndaelKeyInstance * key,
+                        const char *input, size_t inputOctets,
+                        char *outBuffer)
 {
   size_t i, numBlocks, padLen;
   char block[16];
diff --git a/src/daemon/https/lgl/rijndael-api-fst.h b/src/daemon/https/lgl/rijndael-api-fst.h
index 088e6bfd..893021fc 100644
--- a/src/daemon/https/lgl/rijndael-api-fst.h
+++ b/src/daemon/https/lgl/rijndael-api-fst.h
@@ -138,7 +138,7 @@ typedef struct
    128, 192 or 256. Returns 0 on success, or an error code. */
 extern rijndael_rc
 MHD_rijndaelMakeKey (rijndaelKeyInstance * key, rijndael_direction direction,
-                 size_t keyLen, const char *keyMaterial);
+                     size_t keyLen, const char *keyMaterial);
 
 /* Initialize cipher state CIPHER for encryption MODE (e.g.,
    RIJNDAEL_MODE_CBC) with initialization vector IV, a hex string of
@@ -146,7 +146,7 @@ MHD_rijndaelMakeKey (rijndaelKeyInstance * key, rijndael_direction direction,
    not need an IV (i.e., RIJNDAEL_MODE_ECB).  */
 extern rijndael_rc
 MHD_MHD_rijndaelCipherInit (rijndaelCipherInstance * cipher,
-                    rijndael_mode mode, const char *IV);
+                            rijndael_mode mode, const char *IV);
 
 /* Encrypt data in INPUT, of INPUTLEN/8 bytes length, placing the
    output in the pre-allocated OUTBUFFER which must hold at least
@@ -157,8 +157,9 @@ MHD_MHD_rijndaelCipherInit (rijndaelCipherInstance * cipher,
    negative rijndael_rc error code. */
 extern int
 MHD_rijndaelBlockEncrypt (rijndaelCipherInstance * cipher,
-                      const rijndaelKeyInstance * key,
-                      const char *input, size_t inputLen, char *outBuffer);
+                          const rijndaelKeyInstance * key,
+                          const char *input, size_t inputLen,
+                          char *outBuffer);
 
 /* Encrypt data in INPUT, of INPUTOCTETS bytes length, placing the
    output in the pre-allocated OUTBUFFER which must hold at least
@@ -171,8 +172,9 @@ MHD_rijndaelBlockEncrypt (rijndaelCipherInstance * cipher,
    negative rijndael_rc error code. */
 extern int
 MHD_rijndaelPadEncrypt (rijndaelCipherInstance * cipher,
-                    const rijndaelKeyInstance * key,
-                    const char *input, size_t inputOctets, char *outBuffer);
+                        const rijndaelKeyInstance * key,
+                        const char *input, size_t inputOctets,
+                        char *outBuffer);
 
 /* Decrypt data in INPUT, of INPUTLEN/8 bytes length, placing the
    output in the pre-allocated OUTBUFFER which must hold at least
@@ -183,8 +185,9 @@ MHD_rijndaelPadEncrypt (rijndaelCipherInstance * cipher,
    negative rijndael_rc error code. */
 extern int
 MHD_rijndaelBlockDecrypt (rijndaelCipherInstance * cipher,
-                      const rijndaelKeyInstance * key,
-                      const char *input, size_t inputLen, char *outBuffer);
+                          const rijndaelKeyInstance * key,
+                          const char *input, size_t inputLen,
+                          char *outBuffer);
 
 /* Decrypt data in INPUT, of INPUTOCTETS bytes length, placing the
    output in the pre-allocated OUTBUFFER which must hold at least
@@ -197,7 +200,8 @@ MHD_rijndaelBlockDecrypt (rijndaelCipherInstance * cipher,
    negative rijndael_rc error code. */
 extern int
 MHD_rijndaelPadDecrypt (rijndaelCipherInstance * cipher,
-                    const rijndaelKeyInstance * key,
-                    const char *input, size_t inputOctets, char *outBuffer);
+                        const rijndaelKeyInstance * key,
+                        const char *input, size_t inputOctets,
+                        char *outBuffer);
 
 #endif /* __RIJNDAEL_API_FST_H */
diff --git a/src/daemon/https/lgl/sha1.c b/src/daemon/https/lgl/sha1.c
index c336cc4e..573e7c69 100644
--- a/src/daemon/https/lgl/sha1.c
+++ b/src/daemon/https/lgl/sha1.c
@@ -199,7 +199,8 @@ MHD_sha1_buffer (const char *buffer, size_t len, void *resblock)
 }
 
 void
-MHD_sha1_process_bytes (const void *buffer, size_t len, struct MHD_sha1_ctx *ctx)
+MHD_sha1_process_bytes (const void *buffer, size_t len,
+                        struct MHD_sha1_ctx *ctx)
 {
   /* When we already have some bits in our internal buffer concatenate
      both inputs first.  */
@@ -235,7 +236,8 @@ MHD_sha1_process_bytes (const void *buffer, size_t len, struct MHD_sha1_ctx *ctx
       if (UNALIGNED_P (buffer))
         while (len > 64)
           {
-            MHD_sha1_process_block (memcpy (ctx->buffer, buffer, 64), 64, ctx);
+            MHD_sha1_process_block (memcpy (ctx->buffer, buffer, 64), 64,
+                                    ctx);
             buffer = (const char *) buffer + 64;
             len -= 64;
           }
@@ -284,7 +286,8 @@ MHD_sha1_process_bytes (const void *buffer, size_t len, struct MHD_sha1_ctx *ctx
    Most of this code comes from GnuPG's cipher/sha1.c.  */
 
 void
-MHD_sha1_process_block (const void *buffer, size_t len, struct MHD_sha1_ctx *ctx)
+MHD_sha1_process_block (const void *buffer, size_t len,
+                        struct MHD_sha1_ctx *ctx)
 {
   const uint32_t *words = buffer;
   size_t nwords = len / sizeof (uint32_t);
diff --git a/src/daemon/https/lgl/sha1.h b/src/daemon/https/lgl/sha1.h
index 382d96cf..b6e40cdb 100644
--- a/src/daemon/https/lgl/sha1.h
+++ b/src/daemon/https/lgl/sha1.h
@@ -45,14 +45,14 @@ extern void MHD_sha1_init_ctx (struct MHD_sha1_ctx *ctx);
    starting at BUFFER.
    It is necessary that LEN is a multiple of 64!!! */
 extern void MHD_sha1_process_block (const void *buffer, size_t len,
-                                struct MHD_sha1_ctx *ctx);
+                                    struct MHD_sha1_ctx *ctx);
 
 /* Starting with the result of former calls of this function (or the
    initialization function update the context for the next LEN bytes
    starting at BUFFER.
    It is NOT required that LEN is a multiple of 64.  */
 extern void MHD_sha1_process_bytes (const void *buffer, size_t len,
-                                struct MHD_sha1_ctx *ctx);
+                                    struct MHD_sha1_ctx *ctx);
 
 /* Process the remaining bytes in the buffer and put result from CTX
    in first 20 bytes following RESBUF.  The result is always in little
diff --git a/src/daemon/https/minitasn1/coding.c b/src/daemon/https/minitasn1/coding.c
index 350828b3..aa2aecb6 100644
--- a/src/daemon/https/minitasn1/coding.c
+++ b/src/daemon/https/minitasn1/coding.c
@@ -47,15 +47,16 @@
 /******************************************************/
 static void
 MHD__asn1_error_description_value_not_found (node_asn * node,
-                                         char *ErrorDescription)
+                                             char *ErrorDescription)
 {
 
   if (ErrorDescription == NULL)
     return;
 
   Estrcpy (ErrorDescription, ":: value of element '");
-  MHD__asn1_hierarchical_name (node, ErrorDescription + strlen (ErrorDescription),
-                           MAX_ERROR_DESCRIPTION_SIZE - 40);
+  MHD__asn1_hierarchical_name (node,
+                               ErrorDescription + strlen (ErrorDescription),
+                               MAX_ERROR_DESCRIPTION_SIZE - 40);
   Estrcat (ErrorDescription, "' not found");
 
 }
@@ -115,7 +116,7 @@ MHD__asn1_length_der (unsigned long int len, unsigned char *ans, int *ans_len)
 /******************************************************/
 static void
 MHD__asn1_tag_der (unsigned char class, unsigned int tag_value,
-               unsigned char *ans, int *ans_len)
+                   unsigned char *ans, int *ans_len)
 {
   int k;
   unsigned char temp[SIZEOF_UNSIGNED_INT];
@@ -154,7 +155,7 @@ MHD__asn1_tag_der (unsigned char class, unsigned int tag_value,
  **/
 void
 MHD__asn1_octet_der (const unsigned char *str, int str_len,
-                unsigned char *der, int *der_len)
+                     unsigned char *der, int *der_len)
 {
   int len_len;
 
@@ -187,11 +188,12 @@ MHD__asn1_time_der (unsigned char *str, unsigned char *der, int *der_len)
 
   max_len = *der_len;
 
-  MHD__asn1_length_der (strlen ((const char*) str), (max_len > 0) ? der : NULL, &len_len);
+  MHD__asn1_length_der (strlen ((const char *) str),
+                        (max_len > 0) ? der : NULL, &len_len);
 
-  if ((len_len + (int) strlen ((const char*) str)) <= max_len)
-    memcpy (der + len_len, str, strlen ((const char*) str));
-  *der_len = len_len + strlen ((const char*) str);
+  if ((len_len + (int) strlen ((const char *) str)) <= max_len)
+    memcpy (der + len_len, str, strlen ((const char *) str));
+  *der_len = len_len + strlen ((const char *) str);
 
   if ((*der_len) > max_len)
     return ASN1_MEM_ERROR;
@@ -223,11 +225,11 @@ MHD__asn1_objectid_der (unsigned char *str, unsigned char *der, int *der_len)
 
   max_len = *der_len;
 
-  temp = (char *) MHD__asn1_alloca (strlen ((const char*)str) + 2);
+  temp = (char *) MHD__asn1_alloca (strlen ((const char *) str) + 2);
   if (temp == NULL)
     return ASN1_MEM_ALLOC_ERROR;
 
-  strcpy (temp, (const char*) str);
+  strcpy (temp, (const char *) str);
   strcat (temp, ".");
 
   counter = 0;
@@ -284,7 +286,8 @@ MHD__asn1_objectid_der (unsigned char *str, unsigned char *der, int *der_len)
 }
 
 
-const char MHD_bit_mask[] = { 0xFF, 0xFE, 0xFC, 0xF8, 0xF0, 0xE0, 0xC0, 0x80 };
+const char MHD_bit_mask[] =
+  { 0xFF, 0xFE, 0xFC, 0xF8, 0xF0, 0xE0, 0xC0, 0x80 };
 
 /**
  * MHD__asn1_bit_der:
@@ -299,7 +302,7 @@ const char MHD_bit_mask[] = { 0xFF, 0xFE, 0xFC, 0xF8, 0xF0, 0xE0, 0xC0, 0x80 };
  **/
 void
 MHD__asn1_bit_der (const unsigned char *str, int bit_len,
-              unsigned char *der, int *der_len)
+                   unsigned char *der, int *der_len)
 {
   int len_len, len_byte, len_pad;
 
@@ -335,7 +338,7 @@ MHD__asn1_bit_der (const unsigned char *str, int bit_len,
 /******************************************************/
 static MHD__asn1_retCode
 MHD__asn1_complete_explicit_tag (node_asn * node, unsigned char *der,
-                             int *counter, int *max_len)
+                                 int *counter, int *max_len)
 {
   node_asn *p;
   int is_tag_implicit, len2, len3;
@@ -408,7 +411,7 @@ MHD__asn1_complete_explicit_tag (node_asn * node, unsigned char *der,
 /******************************************************/
 static MHD__asn1_retCode
 MHD__asn1_insert_tag_der (node_asn * node, unsigned char *der, int *counter,
-                      int *max_len)
+                          int *max_len)
 {
   node_asn *p;
   int tag_len, is_tag_implicit;
@@ -438,21 +441,20 @@ MHD__asn1_insert_tag_der (node_asn * node, unsigned char *der, int *counter,
                 {
                   if (is_tag_implicit)
                     MHD__asn1_tag_der (class_implicit, tag_implicit,
-                                       (unsigned char*) tag_der,
-                                       &tag_len);
+                                       (unsigned char *) tag_der, &tag_len);
                   else
                     MHD__asn1_tag_der (class | ASN1_CLASS_STRUCTURED,
-                                       strtoul ( (const char*) p->value, NULL, 10), 
-                                       (unsigned char*) tag_der,
-                                       &tag_len);
+                                       strtoul ((const char *) p->value, NULL,
+                                                10),
+                                       (unsigned char *) tag_der, &tag_len);
 
                   *max_len -= tag_len;
                   if (*max_len >= 0)
                     memcpy (der + *counter, tag_der, tag_len);
                   *counter += tag_len;
 
-                  MHD__asn1_ltostr (*counter, (char*) temp);
-                  MHD__asn1_set_name (p, (const char*) temp);
+                  MHD__asn1_ltostr (*counter, (char *) temp);
+                  MHD__asn1_set_name (p, (const char *) temp);
 
                   is_tag_implicit = 0;
                 }
@@ -466,7 +468,8 @@ MHD__asn1_insert_tag_der (node_asn * node, unsigned char *der, int *counter,
                           (type_field (node->type) == TYPE_SET_OF))
                         class |= ASN1_CLASS_STRUCTURED;
                       class_implicit = class;
-                      tag_implicit = strtoul ( (const char*) p->value, NULL, 10);
+                      tag_implicit =
+                        strtoul ((const char *) p->value, NULL, 10);
                       is_tag_implicit = 1;
                     }
                 }
@@ -477,63 +480,66 @@ MHD__asn1_insert_tag_der (node_asn * node, unsigned char *der, int *counter,
 
   if (is_tag_implicit)
     {
-      MHD__asn1_tag_der (class_implicit, tag_implicit, (unsigned char*) tag_der, &tag_len);
+      MHD__asn1_tag_der (class_implicit, tag_implicit,
+                         (unsigned char *) tag_der, &tag_len);
     }
   else
     {
       switch (type_field (node->type))
         {
         case TYPE_NULL:
-          MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_NULL, (unsigned char*) tag_der,
-                         &tag_len);
+          MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_NULL,
+                             (unsigned char *) tag_der, &tag_len);
           break;
         case TYPE_BOOLEAN:
-          MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_BOOLEAN, (unsigned char*) tag_der,
-                         &tag_len);
+          MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_BOOLEAN,
+                             (unsigned char *) tag_der, &tag_len);
           break;
         case TYPE_INTEGER:
-          MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_INTEGER, (unsigned char*) tag_der,
-                         &tag_len);
+          MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_INTEGER,
+                             (unsigned char *) tag_der, &tag_len);
           break;
         case TYPE_ENUMERATED:
-          MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_ENUMERATED, (unsigned char*) tag_der,
-                         &tag_len);
+          MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_ENUMERATED,
+                             (unsigned char *) tag_der, &tag_len);
           break;
         case TYPE_OBJECT_ID:
-          MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_OBJECT_ID, (unsigned char*) tag_der,
-                         &tag_len);
+          MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_OBJECT_ID,
+                             (unsigned char *) tag_der, &tag_len);
           break;
         case TYPE_TIME:
           if (node->type & CONST_UTC)
             {
-              MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_UTCTime, (unsigned char*) tag_der,
-                             &tag_len);
+              MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_UTCTime,
+                                 (unsigned char *) tag_der, &tag_len);
             }
           else
             MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_GENERALIZEDTime,
-                           (unsigned char*) tag_der, &tag_len);
+                               (unsigned char *) tag_der, &tag_len);
           break;
         case TYPE_OCTET_STRING:
-          MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_OCTET_STRING, (unsigned char*) tag_der,
-                         &tag_len);
+          MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_OCTET_STRING,
+                             (unsigned char *) tag_der, &tag_len);
           break;
         case TYPE_GENERALSTRING:
           MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_GENERALSTRING,
-                         (unsigned char*) tag_der, &tag_len);
+                             (unsigned char *) tag_der, &tag_len);
           break;
         case TYPE_BIT_STRING:
-          MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_BIT_STRING, (unsigned char*) tag_der,
-                         &tag_len);
+          MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL, ASN1_TAG_BIT_STRING,
+                             (unsigned char *) tag_der, &tag_len);
           break;
         case TYPE_SEQUENCE:
         case TYPE_SEQUENCE_OF:
           MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL | ASN1_CLASS_STRUCTURED,
-                         ASN1_TAG_SEQUENCE, (unsigned char*) tag_der, &tag_len);
+                             ASN1_TAG_SEQUENCE, (unsigned char *) tag_der,
+                             &tag_len);
           break;
         case TYPE_SET:
         case TYPE_SET_OF:
           MHD__asn1_tag_der (ASN1_CLASS_UNIVERSAL | ASN1_CLASS_STRUCTURED,
-                         ASN1_TAG_SET, (unsigned char*) tag_der, &tag_len);
+                             ASN1_TAG_SET, (unsigned char *) tag_der,
+                             &tag_len);
           break;
         case TYPE_TAG:
           tag_len = 0;
@@ -591,11 +597,11 @@ MHD__asn1_ordering_set (unsigned char *der, int der_len, node_asn * node)
     return;
 
   p = node->down;
-  while ( (p != NULL) &&
-          ((type_field (p->type) == TYPE_TAG)
-           || (type_field (p->type) == TYPE_SIZE)) )
+  while ((p != NULL) &&
+         ((type_field (p->type) == TYPE_TAG)
+          || (type_field (p->type) == TYPE_SIZE)))
     p = p->right;
-  
+
   if ((p == NULL) || (p->right == NULL))
     return;
 
@@ -623,7 +629,8 @@ MHD__asn1_ordering_set (unsigned char *der, int der_len, node_asn * node)
       counter += len2;
 
       /* extraction and length */
-      len2 = MHD__asn1_get_length_der (der + counter, der_len - counter, &len);
+      len2 =
+        MHD__asn1_get_length_der (der + counter, der_len - counter, &len);
       if (len2 < 0)
         return;
       counter += len + len2;
@@ -643,7 +650,8 @@ MHD__asn1_ordering_set (unsigned char *der, int der_len, node_asn * node)
           if (p_vet->value > p2_vet->value)
             {
               /* change position */
-              temp = (unsigned char *) MHD__asn1_alloca (p_vet->end - counter);
+              temp =
+                (unsigned char *) MHD__asn1_alloca (p_vet->end - counter);
               if (temp == NULL)
                 return;
 
@@ -738,7 +746,8 @@ MHD__asn1_ordering_set_of (unsigned char *der, int der_len, node_asn * node)
             return;
           counter += len;
 
-          len2 = MHD__asn1_get_length_der (der + counter, der_len - counter, &len);
+          len2 =
+            MHD__asn1_get_length_der (der + counter, der_len - counter, &len);
           if (len2 < 0)
             return;
           counter += len + len2;
@@ -781,7 +790,8 @@ MHD__asn1_ordering_set_of (unsigned char *der, int der_len, node_asn * node)
           if (change == 1)
             {
               /* change position */
-              temp = (unsigned char *) MHD__asn1_alloca (p_vet->end - counter);
+              temp =
+                (unsigned char *) MHD__asn1_alloca (p_vet->end - counter);
               if (temp == NULL)
                 return;
 
@@ -837,8 +847,8 @@ MHD__asn1_ordering_set_of (unsigned char *der, int der_len, node_asn * node)
   *
   **/
 MHD__asn1_retCode
-MHD__asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
-                 char *ErrorDescription)
+MHD__asn1_der_coding (ASN1_TYPE element, const char *name, void *ider,
+                      int *len, char *ErrorDescription)
 {
   node_asn *node, *p, *p2;
   char temp[SIZEOF_UNSIGNED_LONG_INT * 3 + 1];
@@ -894,7 +904,7 @@ MHD__asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
               if (p->value == NULL)
                 {
                   MHD__asn1_error_description_value_not_found (p,
-                                                           ErrorDescription);
+                                                               ErrorDescription);
                   err = ASN1_VALUE_NOT_FOUND;
                   goto error;
                 }
@@ -924,7 +934,7 @@ MHD__asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
               if (p->value == NULL)
                 {
                   MHD__asn1_error_description_value_not_found (p,
-                                                           ErrorDescription);
+                                                               ErrorDescription);
                   err = ASN1_VALUE_NOT_FOUND;
                   goto error;
                 }
@@ -952,7 +962,7 @@ MHD__asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
               if (p->value == NULL)
                 {
                   MHD__asn1_error_description_value_not_found (p,
-                                                           ErrorDescription);
+                                                               ErrorDescription);
                   err = ASN1_VALUE_NOT_FOUND;
                   goto error;
                 }
@@ -969,7 +979,8 @@ MHD__asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
         case TYPE_TIME:
           if (p->value == NULL)
             {
-              MHD__asn1_error_description_value_not_found (p, ErrorDescription);
+              MHD__asn1_error_description_value_not_found (p,
+                                                           ErrorDescription);
               err = ASN1_VALUE_NOT_FOUND;
               goto error;
             }
@@ -985,7 +996,8 @@ MHD__asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
         case TYPE_OCTET_STRING:
           if (p->value == NULL)
             {
-              MHD__asn1_error_description_value_not_found (p, ErrorDescription);
+              MHD__asn1_error_description_value_not_found (p,
+                                                           ErrorDescription);
               err = ASN1_VALUE_NOT_FOUND;
               goto error;
             }
@@ -1004,7 +1016,8 @@ MHD__asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
         case TYPE_GENERALSTRING:
           if (p->value == NULL)
             {
-              MHD__asn1_error_description_value_not_found (p, ErrorDescription);
+              MHD__asn1_error_description_value_not_found (p,
+                                                           ErrorDescription);
               err = ASN1_VALUE_NOT_FOUND;
               goto error;
             }
@@ -1023,7 +1036,8 @@ MHD__asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
         case TYPE_BIT_STRING:
           if (p->value == NULL)
             {
-              MHD__asn1_error_description_value_not_found (p, ErrorDescription);
+              MHD__asn1_error_description_value_not_found (p,
+                                                           ErrorDescription);
               err = ASN1_VALUE_NOT_FOUND;
               goto error;
             }
@@ -1069,11 +1083,12 @@ MHD__asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
             }
           else
             {                   /* move==UP */
-              len2 = strtol ( (const char*) p->value, NULL, 10);
+              len2 = strtol ((const char *) p->value, NULL, 10);
               MHD__asn1_set_value (p, NULL, 0);
               if ((type_field (p->type) == TYPE_SET) && (max_len >= 0))
                 MHD__asn1_ordering_set (der + len2, max_len - len2, p);
-              MHD__asn1_length_der (counter - len2, (unsigned char*) temp, &len3);
+              MHD__asn1_length_der (counter - len2, (unsigned char *) temp,
+                                    &len3);
               max_len -= len3;
               if (max_len >= 0)
                 {
@@ -1109,14 +1124,15 @@ MHD__asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
             }
           if (move == UP)
             {
-              len2 = strtol ( (const char*) p->value, NULL, 10);
+              len2 = strtol ((const char *) p->value, NULL, 10);
               MHD__asn1_set_value (p, NULL, 0);
               if ((type_field (p->type) == TYPE_SET_OF)
                   && (max_len - len2 > 0))
                 {
                   MHD__asn1_ordering_set_of (der + len2, max_len - len2, p);
                 }
-              MHD__asn1_length_der (counter - len2, (unsigned char*) temp, &len3);
+              MHD__asn1_length_der (counter - len2, (unsigned char *) temp,
+                                    &len3);
               max_len -= len3;
               if (max_len >= 0)
                 {
@@ -1130,7 +1146,8 @@ MHD__asn1_der_coding (ASN1_TYPE element, const char *name, void *ider, int *len,
         case TYPE_ANY:
           if (p->value == NULL)
             {
-              MHD__asn1_error_description_value_not_found (p, ErrorDescription);
+              MHD__asn1_error_description_value_not_found (p,
+                                                           ErrorDescription);
               err = ASN1_VALUE_NOT_FOUND;
               goto error;
             }
diff --git a/src/daemon/https/minitasn1/decoding.c b/src/daemon/https/minitasn1/decoding.c
index fcee0797..fe0eaef7 100644
--- a/src/daemon/https/minitasn1/decoding.c
+++ b/src/daemon/https/minitasn1/decoding.c
@@ -35,12 +35,14 @@
 
 
 static void
-MHD__asn1_error_description_tag_error (node_asn * node, char *ErrorDescription)
+MHD__asn1_error_description_tag_error (node_asn * node,
+                                       char *ErrorDescription)
 {
 
   Estrcpy (ErrorDescription, ":: tag error near element '");
-  MHD__asn1_hierarchical_name (node, ErrorDescription + strlen (ErrorDescription),
-                           MAX_ERROR_DESCRIPTION_SIZE - 40);
+  MHD__asn1_hierarchical_name (node,
+                               ErrorDescription + strlen (ErrorDescription),
+                               MAX_ERROR_DESCRIPTION_SIZE - 40);
   Estrcat (ErrorDescription, "'");
 
 }
@@ -117,7 +119,7 @@ MHD__asn1_get_length_der (const unsigned char *der, int der_len, int *len)
  **/
 int
 MHD__asn1_get_tag_der (const unsigned char *der, int der_len,
-                  unsigned char *cls, int *len, unsigned long *tag)
+                       unsigned char *cls, int *len, unsigned long *tag)
 {
   int punt, ris;
 
@@ -178,8 +180,8 @@ MHD__asn1_get_tag_der (const unsigned char *der, int der_len,
  **/
 int
 MHD__asn1_get_octet_der (const unsigned char *der, int der_len,
-                    int *ret_len, unsigned char *str, int str_size,
-                    int *str_len)
+                         int *ret_len, unsigned char *str, int str_size,
+                         int *str_len)
 {
   int len_len;
 
@@ -209,7 +211,7 @@ MHD__asn1_get_octet_der (const unsigned char *der, int der_len,
  */
 static int
 MHD__asn1_get_time_der (const unsigned char *der, int der_len, int *ret_len,
-                    char *str, int str_size)
+                        char *str, int str_size)
 {
   int len_len, str_len;
 
@@ -228,8 +230,8 @@ MHD__asn1_get_time_der (const unsigned char *der, int der_len, int *ret_len,
 
 
 static void
-MHD__asn1_get_objectid_der (const unsigned char *der, int der_len, int *ret_len,
-                        char *str, int str_size)
+MHD__asn1_get_objectid_der (const unsigned char *der, int der_len,
+                            int *ret_len, char *str, int str_size)
 {
   int len_len, len, k;
   char temp[20];
@@ -286,8 +288,8 @@ MHD__asn1_get_objectid_der (const unsigned char *der, int der_len, int *ret_len,
  **/
 int
 MHD__asn1_get_bit_der (const unsigned char *der, int der_len,
-                  int *ret_len, unsigned char *str, int str_size,
-                  int *bit_len)
+                       int *ret_len, unsigned char *str, int str_size,
+                       int *bit_len)
 {
   int len_len, len_byte;
 
@@ -314,8 +316,8 @@ MHD__asn1_get_bit_der (const unsigned char *der, int der_len,
 
 
 static int
-MHD__asn1_extract_tag_der (node_asn * node, const unsigned char *der, int der_len,
-                       int *ret_len)
+MHD__asn1_extract_tag_der (node_asn * node, const unsigned char *der,
+                           int der_len, int *ret_len)
 {
   node_asn *p;
   int counter, len2, len3, is_tag_implicit;
@@ -353,8 +355,8 @@ MHD__asn1_extract_tag_der (node_asn * node, const unsigned char *der, int der_le
                     return ASN1_DER_ERROR;
                   counter += len2;
                   len3 =
-                    MHD__asn1_get_length_der (der + counter, der_len - counter,
-                                         &len2);
+                    MHD__asn1_get_length_der (der + counter,
+                                              der_len - counter, &len2);
                   if (len3 < 0)
                     return ASN1_DER_ERROR;
                   counter += len2;
@@ -567,7 +569,8 @@ MHD__asn1_delete_not_used (node_asn * node)
 
 
 static MHD__asn1_retCode
-MHD__asn1_get_octet_string (const unsigned char *der, node_asn * node, int *len)
+MHD__asn1_get_octet_string (const unsigned char *der, node_asn * node,
+                            int *len)
 {
   int len2, len3, counter, counter2, counter_end, tot_len, indefinite;
   unsigned char *temp, *temp2;
@@ -606,7 +609,8 @@ MHD__asn1_get_octet_string (const unsigned char *der, node_asn * node, int *len)
 
           counter++;
 
-          len2 = MHD__asn1_get_length_der (der + counter, *len - counter, &len3);
+          len2 =
+            MHD__asn1_get_length_der (der + counter, *len - counter, &len3);
           if (len2 <= 0)
             return ASN1_DER_ERROR;
 
@@ -629,10 +633,10 @@ MHD__asn1_get_octet_string (const unsigned char *der, node_asn * node, int *len)
           temp2 = temp + len2;
           len2 = MHD__asn1_get_length_der (der, *len, &len3);
           if (len2 < -1)
-            {
-              MHD__asn1_afree (temp);
-              return ASN1_DER_ERROR;
-            }
+            {
+              MHD__asn1_afree (temp);
+              return ASN1_DER_ERROR;
+            }
           counter2 = len3 + 1;
 
           if (indefinite == -1)
@@ -643,12 +647,13 @@ MHD__asn1_get_octet_string (const unsigned char *der, node_asn * node, int *len)
           while (counter2 < counter_end)
             {
               len2 =
-                MHD__asn1_get_length_der (der + counter2, *len - counter, &len3);
+                MHD__asn1_get_length_der (der + counter2, *len - counter,
+                                          &len3);
               if (len2 < -1)
-                {
-                  MHD__asn1_afree (temp);
-                  return ASN1_DER_ERROR;
-                }
+                {
+                  MHD__asn1_afree (temp);
+                  return ASN1_DER_ERROR;
+                }
 
               /* FIXME: to be checked. Is this ok? Has the
                * size been checked before?
@@ -757,7 +762,7 @@ MHD__asn1_get_indefinite_length_string (const unsigned char *der, int *len)
 
 MHD__asn1_retCode
 MHD__asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
-                   char *errorDescription)
+                        char *errorDescription)
 {
   node_asn *node, *p, *p2, *p3;
   char temp[128];
@@ -789,7 +794,7 @@ MHD__asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
           if (p->type & CONST_SET)
             {
               p2 = MHD__asn1_find_up (p);
-              len2 = strtol ((const char*) p2->value, NULL, 10);
+              len2 = strtol ((const char *) p2->value, NULL, 10);
               if (len2 == -1)
                 {
                   if (!der[counter] && !der[counter + 1])
@@ -819,7 +824,7 @@ MHD__asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
                       if (type_field (p2->type) != TYPE_CHOICE)
                         ris =
                           MHD__asn1_extract_tag_der (p2, der + counter,
-                                                 len - counter, &len2);
+                                                     len - counter, &len2);
                       else
                         {
                           p3 = p2->down;
@@ -827,7 +832,8 @@ MHD__asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
                             {
                               ris =
                                 MHD__asn1_extract_tag_der (p3, der + counter,
-                                                       len - counter, &len2);
+                                                           len - counter,
+                                                           &len2);
                               if (ris == ASN1_SUCCESS)
                                 break;
                               p3 = p3->right;
@@ -852,7 +858,7 @@ MHD__asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
           if ((p->type & CONST_OPTION) || (p->type & CONST_DEFAULT))
             {
               p2 = MHD__asn1_find_up (p);
-              len2 = strtol ((const char*) p2->value, NULL, 10);
+              len2 = strtol ((const char *) p2->value, NULL, 10);
               if (counter == len2)
                 {
                   if (p->right)
@@ -878,7 +884,7 @@ MHD__asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
                   if (counter < len)
                     ris =
                       MHD__asn1_extract_tag_der (p->down, der + counter,
-                                             len - counter, &len2);
+                                                 len - counter, &len2);
                   else
                     ris = ASN1_DER_ERROR;
                   if (ris == ASN1_SUCCESS)
@@ -917,14 +923,15 @@ MHD__asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
           if ((p->type & CONST_OPTION) || (p->type & CONST_DEFAULT))
             {
               p2 = MHD__asn1_find_up (p);
-              len2 = strtol ((const char*) p2->value, NULL, 10);
+              len2 = strtol ((const char *) p2->value, NULL, 10);
               if ((len2 != -1) && (counter > len2))
                 ris = ASN1_TAG_ERROR;
             }
 
           if (ris == ASN1_SUCCESS)
             ris =
-              MHD__asn1_extract_tag_der (p, der + counter, len - counter, &len2);
+              MHD__asn1_extract_tag_der (p, der + counter, len - counter,
+                                         &len2);
           if (ris != ASN1_SUCCESS)
             {
               if (p->type & CONST_OPTION)
@@ -940,7 +947,8 @@ MHD__asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
               else
                 {
                   if (errorDescription != NULL)
-                    MHD__asn1_error_description_tag_error (p, errorDescription);
+                    MHD__asn1_error_description_tag_error (p,
+                                                           errorDescription);
 
                   MHD__asn1_delete_structure (element);
                   return ASN1_TAG_ERROR;
@@ -978,7 +986,8 @@ MHD__asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
             case TYPE_INTEGER:
             case TYPE_ENUMERATED:
               len2 =
-                MHD__asn1_get_length_der (der + counter, len - counter, &len3);
+                MHD__asn1_get_length_der (der + counter, len - counter,
+                                          &len3);
               if (len2 < 0)
                 return ASN1_DER_ERROR;
               if (len2 + len3 > len - counter)
@@ -989,7 +998,7 @@ MHD__asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
               break;
             case TYPE_OBJECT_ID:
               MHD__asn1_get_objectid_der (der + counter, len - counter, &len2,
-                                      temp, sizeof (temp));
+                                          temp, sizeof (temp));
               tlen = strlen (temp);
               if (tlen > 0)
                 MHD__asn1_set_value (p, temp, tlen + 1);
@@ -998,8 +1007,8 @@ MHD__asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
               break;
             case TYPE_TIME:
               result =
-                MHD__asn1_get_time_der (der + counter, len - counter, &len2, temp,
-                                    sizeof (temp) - 1);
+                MHD__asn1_get_time_der (der + counter, len - counter, &len2,
+                                        temp, sizeof (temp) - 1);
               if (result != ASN1_SUCCESS)
                 {
                   MHD__asn1_delete_structure (element);
@@ -1021,7 +1030,8 @@ MHD__asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
               break;
             case TYPE_GENERALSTRING:
               len2 =
-                MHD__asn1_get_length_der (der + counter, len - counter, &len3);
+                MHD__asn1_get_length_der (der + counter, len - counter,
+                                          &len3);
               if (len2 < 0)
                 return ASN1_DER_ERROR;
               if (len3 + len2 > len - counter)
@@ -1032,7 +1042,8 @@ MHD__asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
               break;
             case TYPE_BIT_STRING:
               len2 =
-                MHD__asn1_get_length_der (der + counter, len - counter, &len3);
+                MHD__asn1_get_length_der (der + counter, len - counter,
+                                          &len3);
               if (len2 < 0)
                 return ASN1_DER_ERROR;
               if (len3 + len2 > len - counter)
@@ -1045,7 +1056,7 @@ MHD__asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
             case TYPE_SET:
               if (move == UP)
                 {
-                  len2 = strtol ( (const char*) p->value, NULL, 10);
+                  len2 = strtol ((const char *) p->value, NULL, 10);
                   MHD__asn1_set_value (p, NULL, 0);
                   if (len2 == -1)
                     {           /* indefinite length method */
@@ -1074,7 +1085,8 @@ MHD__asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
               else
                 {               /* move==DOWN || move==RIGHT */
                   len3 =
-                    MHD__asn1_get_length_der (der + counter, len - counter, &len2);
+                    MHD__asn1_get_length_der (der + counter, len - counter,
+                                              &len2);
                   if (len3 < -1)
                     return ASN1_DER_ERROR;
                   counter += len2;
@@ -1113,7 +1125,7 @@ MHD__asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
             case TYPE_SET_OF:
               if (move == UP)
                 {
-                  len2 = strtol ( (const char*) p->value, NULL, 10);
+                  len2 = strtol ((const char *) p->value, NULL, 10);
                   if (len2 == -1)
                     {           /* indefinite length method */
                       if ((counter + 2) > len)
@@ -1152,7 +1164,8 @@ MHD__asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
               else
                 {               /* move==DOWN || move==RIGHT */
                   len3 =
-                    MHD__asn1_get_length_der (der + counter, len - counter, &len2);
+                    MHD__asn1_get_length_der (der + counter, len - counter,
+                                              &len2);
                   if (len3 < -1)
                     return ASN1_DER_ERROR;
                   counter += len2;
@@ -1190,7 +1203,7 @@ MHD__asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
                 return ASN1_DER_ERROR;
               len4 =
                 MHD__asn1_get_length_der (der + counter + len2,
-                                     len - counter - len2, &len3);
+                                          len - counter - len2, &len3);
               if (len4 < -1)
                 return ASN1_DER_ERROR;
               if (len4 > len - counter + len2 + len3)
@@ -1199,14 +1212,16 @@ MHD__asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
                 {
                   len2 += len4;
                   MHD__asn1_length_der (len2 + len3, NULL, &len4);
-                  temp2 = (unsigned char *) MHD__asn1_alloca (len2 + len3 + len4);
+                  temp2 =
+                    (unsigned char *) MHD__asn1_alloca (len2 + len3 + len4);
                   if (temp2 == NULL)
                     {
                       MHD__asn1_delete_structure (element);
                       return ASN1_MEM_ALLOC_ERROR;
                     }
 
-                  MHD__asn1_octet_der (der + counter, len2 + len3, temp2, &len4);
+                  MHD__asn1_octet_der (der + counter, len2 + len3, temp2,
+                                       &len4);
                   MHD__asn1_set_value (p, temp2, len4);
                   MHD__asn1_afree (temp2);
                   counter += len2 + len3;
@@ -1221,7 +1236,8 @@ MHD__asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
 
                   len2 = len - counter;
                   ris =
-                    MHD__asn1_get_indefinite_length_string (der + counter, &len2);
+                    MHD__asn1_get_indefinite_length_string (der + counter,
+                                                            &len2);
                   if (ris != ASN1_SUCCESS)
                     {
                       MHD__asn1_delete_structure (element);
@@ -1328,7 +1344,8 @@ MHD__asn1_der_decoding (ASN1_TYPE * element, const void *ider, int len,
   **/
 MHD__asn1_retCode
 MHD__asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
-                            const char *name_element, int *start, int *end)
+                                 const char *name_element, int *start,
+                                 int *end)
 {
   node_asn *node, *node_to_find, *p, *p2, *p3;
   int counter, len2, len3, len4, move, ris;
@@ -1369,7 +1386,7 @@ MHD__asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
           if (p->type & CONST_SET)
             {
               p2 = MHD__asn1_find_up (p);
-              len2 = strtol ( (const char* ) p2->value, NULL, 10);
+              len2 = strtol ((const char *) p2->value, NULL, 10);
               if (len2 == -1)
                 {
                   if (!der[counter] && !der[counter + 1])
@@ -1396,13 +1413,13 @@ MHD__asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
                       if (type_field (p2->type) != TYPE_CHOICE)
                         ris =
                           MHD__asn1_extract_tag_der (p2, der + counter,
-                                                 len - counter, &len2);
+                                                     len - counter, &len2);
                       else
                         {
                           p3 = p2->down;
                           ris =
                             MHD__asn1_extract_tag_der (p3, der + counter,
-                                                   len - counter, &len2);
+                                                       len - counter, &len2);
                         }
                       if (ris == ASN1_SUCCESS)
                         {
@@ -1425,14 +1442,15 @@ MHD__asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
               p = p->down;
               ris =
                 MHD__asn1_extract_tag_der (p, der + counter, len - counter,
-                                       &len2);
+                                           &len2);
               if (p == node_to_find)
                 *start = counter;
             }
 
           if (ris == ASN1_SUCCESS)
             ris =
-              MHD__asn1_extract_tag_der (p, der + counter, len - counter, &len2);
+              MHD__asn1_extract_tag_der (p, der + counter, len - counter,
+                                         &len2);
           if (ris != ASN1_SUCCESS)
             {
               if (p->type & CONST_OPTION)
@@ -1472,7 +1490,8 @@ MHD__asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
             case TYPE_INTEGER:
             case TYPE_ENUMERATED:
               len2 =
-                MHD__asn1_get_length_der (der + counter, len - counter, &len3);
+                MHD__asn1_get_length_der (der + counter, len - counter,
+                                          &len3);
               if (len2 < 0)
                 return ASN1_DER_ERROR;
               counter += len3 + len2;
@@ -1480,7 +1499,8 @@ MHD__asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
               break;
             case TYPE_OBJECT_ID:
               len2 =
-                MHD__asn1_get_length_der (der + counter, len - counter, &len3);
+                MHD__asn1_get_length_der (der + counter, len - counter,
+                                          &len3);
               if (len2 < 0)
                 return ASN1_DER_ERROR;
               counter += len2 + len3;
@@ -1488,7 +1508,8 @@ MHD__asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
               break;
             case TYPE_TIME:
               len2 =
-                MHD__asn1_get_length_der (der + counter, len - counter, &len3);
+                MHD__asn1_get_length_der (der + counter, len - counter,
+                                          &len3);
               if (len2 < 0)
                 return ASN1_DER_ERROR;
               counter += len2 + len3;
@@ -1504,7 +1525,8 @@ MHD__asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
               break;
             case TYPE_GENERALSTRING:
               len2 =
-                MHD__asn1_get_length_der (der + counter, len - counter, &len3);
+                MHD__asn1_get_length_der (der + counter, len - counter,
+                                          &len3);
               if (len2 < 0)
                 return ASN1_DER_ERROR;
               counter += len3 + len2;
@@ -1512,7 +1534,8 @@ MHD__asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
               break;
             case TYPE_BIT_STRING:
               len2 =
-                MHD__asn1_get_length_der (der + counter, len - counter, &len3);
+                MHD__asn1_get_length_der (der + counter, len - counter,
+                                          &len3);
               if (len2 < 0)
                 return ASN1_DER_ERROR;
               counter += len3 + len2;
@@ -1523,7 +1546,8 @@ MHD__asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
               if (move != UP)
                 {
                   len3 =
-                    MHD__asn1_get_length_der (der + counter, len - counter, &len2);
+                    MHD__asn1_get_length_der (der + counter, len - counter,
+                                              &len2);
                   if (len3 < -1)
                     return ASN1_DER_ERROR;
                   counter += len2;
@@ -1544,7 +1568,8 @@ MHD__asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
               if (move != UP)
                 {
                   len3 =
-                    MHD__asn1_get_length_der (der + counter, len - counter, &len2);
+                    MHD__asn1_get_length_der (der + counter, len - counter,
+                                              &len2);
                   if (len3 < -1)
                     return ASN1_DER_ERROR;
                   counter += len2;
@@ -1576,7 +1601,7 @@ MHD__asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
 
               len4 =
                 MHD__asn1_get_length_der (der + counter + len2,
-                                     len - counter - len2, &len3);
+                                          len - counter - len2, &len3);
               if (len4 < -1)
                 return ASN1_DER_ERROR;
 
@@ -1594,7 +1619,8 @@ MHD__asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
 
                   len2 = len - counter;
                   ris =
-                    MHD__asn1_get_indefinite_length_string (der + counter, &len2);
+                    MHD__asn1_get_indefinite_length_string (der + counter,
+                                                            &len2);
                   if (ris != ASN1_SUCCESS)
                     return ris;
                   counter += len2;
@@ -1646,5 +1672,3 @@ MHD__asn1_der_decoding_startEnd (ASN1_TYPE element, const void *ider, int len,
 
   return ASN1_ELEMENT_NOT_FOUND;
 }
-
-
diff --git a/src/daemon/https/minitasn1/element.c b/src/daemon/https/minitasn1/element.c
index 4e29772e..7cda2174 100644
--- a/src/daemon/https/minitasn1/element.c
+++ b/src/daemon/https/minitasn1/element.c
@@ -76,7 +76,7 @@ MHD__asn1_hierarchical_name (node_asn * node, char *name, int name_size)
 /******************************************************************/
 MHD__asn1_retCode
 MHD__asn1_convert_integer (const char *value, unsigned char *value_out,
-                       int value_out_size, int *len)
+                           int value_out_size, int *len)
 {
   char negative;
   unsigned char val[SIZEOF_UNSIGNED_LONG_INT];
@@ -117,7 +117,8 @@ MHD__asn1_convert_integer (const char *value, unsigned char *value_out,
 
 
 #ifdef LIBTASN1_DEBUG_INTEGER
-  MHD__libtasn1_log ("MHD__asn1_convert_integer: valueIn=%s, lenOut=%d", value, *len);
+  MHD__libtasn1_log ("MHD__asn1_convert_integer: valueIn=%s, lenOut=%d",
+                     value, *len);
   for (k = 0; k < SIZEOF_UNSIGNED_LONG_INT; k++)
     MHD__libtasn1_log (", vOut[%d]=%d", k, value_out[k]);
   MHD__libtasn1_log ("\n");
@@ -276,7 +277,7 @@ MHD__asn1_append_sequence_set (node_asn * node)
   **/
 MHD__asn1_retCode
 MHD__asn1_write_value (ASN1_TYPE node_root, const char *name,
-                  const void *ivalue, int len)
+                       const void *ivalue, int len)
 {
   node_asn *node, *p, *p2;
   unsigned char *temp, *value_temp = NULL, *default_temp = NULL;
@@ -355,7 +356,7 @@ MHD__asn1_write_value (ASN1_TYPE node_root, const char *name,
                 return ASN1_MEM_ALLOC_ERROR;
 
               MHD__asn1_convert_integer (value, value_temp,
-                                     SIZEOF_UNSIGNED_LONG_INT, &len);
+                                         SIZEOF_UNSIGNED_LONG_INT, &len);
             }
           else
             {                   /* is an identifier like v1 */
@@ -374,10 +375,10 @@ MHD__asn1_write_value (ASN1_TYPE node_root, const char *name,
                           if (value_temp == NULL)
                             return ASN1_MEM_ALLOC_ERROR;
 
-                          MHD__asn1_convert_integer ((const char*) p->value,
-                                                     value_temp,
-                                                     SIZEOF_UNSIGNED_LONG_INT,
-                                                     &len);
+                          MHD__asn1_convert_integer ((const char *) p->value,
+                                                     value_temp,
+                                                     SIZEOF_UNSIGNED_LONG_INT,
+                                                     &len);
                           break;
                         }
                     }
@@ -420,10 +421,10 @@ MHD__asn1_write_value (ASN1_TYPE node_root, const char *name,
       MHD__asn1_length_der (len - k, NULL, &len2);
       temp = (unsigned char *) MHD__asn1_alloca (len - k + len2);
       if (temp == NULL)
-        {
-          MHD__asn1_afree (value_temp);
-          return ASN1_MEM_ALLOC_ERROR;
-        }
+        {
+          MHD__asn1_afree (value_temp);
+          return ASN1_MEM_ALLOC_ERROR;
+        }
 
       MHD__asn1_octet_der (value_temp + k, len - k, temp, &len2);
       MHD__asn1_set_value (node, temp, len2);
@@ -441,51 +442,53 @@ MHD__asn1_write_value (ASN1_TYPE node_root, const char *name,
               default_temp =
                 (unsigned char *) MHD__asn1_alloca (SIZEOF_UNSIGNED_LONG_INT);
               if (default_temp == NULL)
-                {
-                  MHD__asn1_afree (value_temp);
-                  return ASN1_MEM_ALLOC_ERROR;
-                }
+                {
+                  MHD__asn1_afree (value_temp);
+                  return ASN1_MEM_ALLOC_ERROR;
+                }
 
-              MHD__asn1_convert_integer ((const char*) p->value, default_temp,
-                                     SIZEOF_UNSIGNED_LONG_INT, &len2);
+              MHD__asn1_convert_integer ((const char *) p->value,
+                                         default_temp,
+                                         SIZEOF_UNSIGNED_LONG_INT, &len2);
             }
           else
             {                   /* is an identifier like v1 */
               if (!(node->type & CONST_LIST))
-                {
-                  MHD__asn1_afree (value_temp);
-                  return ASN1_VALUE_NOT_VALID;
-                }
+                {
+                  MHD__asn1_afree (value_temp);
+                  return ASN1_VALUE_NOT_VALID;
+                }
               p2 = node->down;
               while (p2)
                 {
                   if (type_field (p2->type) == TYPE_CONSTANT)
                     {
-                      if ((p2->name) && (!strcmp (p2->name,(const char*)  p->value)))
+                      if ((p2->name)
+                          && (!strcmp (p2->name, (const char *) p->value)))
                         {
                           default_temp =
                             (unsigned char *)
                             MHD__asn1_alloca (SIZEOF_UNSIGNED_LONG_INT);
                           if (default_temp == NULL)
-                            {
-                              MHD__asn1_afree (value_temp);
-                              return ASN1_MEM_ALLOC_ERROR;
-                            }
-
-                          MHD__asn1_convert_integer ((const char*) p2->value,
-                                                 default_temp,
-                                                 SIZEOF_UNSIGNED_LONG_INT,
-                                                 &len2);
+                            {
+                              MHD__asn1_afree (value_temp);
+                              return ASN1_MEM_ALLOC_ERROR;
+                            }
+
+                          MHD__asn1_convert_integer ((const char *) p2->value,
+                                                     default_temp,
+                                                     SIZEOF_UNSIGNED_LONG_INT,
+                                                     &len2);
                           break;
                         }
                     }
                   p2 = p2->right;
                 }
               if (p2 == NULL)
-                {
-                  MHD__asn1_afree (value_temp);
-                  return ASN1_VALUE_NOT_VALID;
-                }
+                {
+                  MHD__asn1_afree (value_temp);
+                  return ASN1_VALUE_NOT_VALID;
+                }
             }
 
 
@@ -512,7 +515,7 @@ MHD__asn1_write_value (ASN1_TYPE node_root, const char *name,
           p = node->down;
           while (type_field (p->type) != TYPE_DEFAULT)
             p = p->right;
-          if (!strcmp (value,(const char*)  p->value))
+          if (!strcmp (value, (const char *) p->value))
             {
               MHD__asn1_set_value (node, NULL, 0);
               break;
@@ -574,7 +577,7 @@ MHD__asn1_write_value (ASN1_TYPE node_root, const char *name,
       if (temp == NULL)
         return ASN1_MEM_ALLOC_ERROR;
 
-      MHD__asn1_octet_der ((const unsigned char*) value, len, temp, &len2);
+      MHD__asn1_octet_der ((const unsigned char *) value, len, temp, &len2);
       MHD__asn1_set_value (node, temp, len2);
       MHD__asn1_afree (temp);
       break;
@@ -586,7 +589,7 @@ MHD__asn1_write_value (ASN1_TYPE node_root, const char *name,
       if (temp == NULL)
         return ASN1_MEM_ALLOC_ERROR;
 
-      MHD__asn1_octet_der ((const unsigned char*)value, len, temp, &len2);
+      MHD__asn1_octet_der ((const unsigned char *) value, len, temp, &len2);
       MHD__asn1_set_value (node, temp, len2);
       MHD__asn1_afree (temp);
       break;
@@ -598,7 +601,7 @@ MHD__asn1_write_value (ASN1_TYPE node_root, const char *name,
       if (temp == NULL)
         return ASN1_MEM_ALLOC_ERROR;
 
-      MHD__asn1_bit_der ((const unsigned char*)value, len, temp, &len2);
+      MHD__asn1_bit_der ((const unsigned char *) value, len, temp, &len2);
       MHD__asn1_set_value (node, temp, len2);
       MHD__asn1_afree (temp);
       break;
@@ -632,7 +635,7 @@ MHD__asn1_write_value (ASN1_TYPE node_root, const char *name,
       if (temp == NULL)
         return ASN1_MEM_ALLOC_ERROR;
 
-      MHD__asn1_octet_der ((const unsigned char*)value, len, temp, &len2);
+      MHD__asn1_octet_der ((const unsigned char *) value, len, temp, &len2);
       MHD__asn1_set_value (node, temp, len2);
       MHD__asn1_afree (temp);
       break;
@@ -744,7 +747,8 @@ MHD__asn1_write_value (ASN1_TYPE node_root, const char *name,
   *
   **/
 MHD__asn1_retCode
-MHD__asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
+MHD__asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue,
+                      int *len)
 {
   node_asn *node, *p, *p2;
   int len2, len3;
@@ -801,7 +805,8 @@ MHD__asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
               || (p->value[0] == '+'))
             {
               if (MHD__asn1_convert_integer
-                  ((const char*) p->value, (unsigned char*) value, value_size, len) != ASN1_SUCCESS)
+                  ((const char *) p->value, (unsigned char *) value,
+                   value_size, len) != ASN1_SUCCESS)
                 return ASN1_MEM_ERROR;
             }
           else
@@ -811,10 +816,12 @@ MHD__asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
                 {
                   if (type_field (p2->type) == TYPE_CONSTANT)
                     {
-                      if ((p2->name) && (!strcmp (p2->name, (const char*) p->value)))
+                      if ((p2->name)
+                          && (!strcmp (p2->name, (const char *) p->value)))
                         {
                           if (MHD__asn1_convert_integer
-                              ((const char*) p2->value, (unsigned char*) value, value_size,
+                              ((const char *) p2->value,
+                               (unsigned char *) value, value_size,
                                len) != ASN1_SUCCESS)
                             return ASN1_MEM_ERROR;
                           break;
@@ -828,8 +835,8 @@ MHD__asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
         {
           len2 = -1;
           if (MHD__asn1_get_octet_der
-              (node->value, node->value_len, &len2, (unsigned char*) value, value_size,
-               len) != ASN1_SUCCESS)
+              (node->value, node->value_len, &len2, (unsigned char *) value,
+               value_size, len) != ASN1_SUCCESS)
             return ASN1_MEM_ERROR;
         }
       break;
@@ -842,7 +849,7 @@ MHD__asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
             {
               if (type_field (p->type) == TYPE_CONSTANT)
                 {
-                  ADD_STR_VALUE (value, value_size, (const char*) p->value);
+                  ADD_STR_VALUE (value, value_size, (const char *) p->value);
                   if (p->right)
                     {
                       ADD_STR_VALUE (value, value_size, ".");
@@ -857,35 +864,35 @@ MHD__asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
           p = node->down;
           while (type_field (p->type) != TYPE_DEFAULT)
             p = p->right;
-          PUT_STR_VALUE (value, value_size, (const char*)  p->value);
+          PUT_STR_VALUE (value, value_size, (const char *) p->value);
         }
       else
         {
-          PUT_STR_VALUE (value, value_size, (const char*)  node->value);
+          PUT_STR_VALUE (value, value_size, (const char *) node->value);
         }
       break;
     case TYPE_TIME:
-      PUT_STR_VALUE (value, value_size, (const char*) node->value);
+      PUT_STR_VALUE (value, value_size, (const char *) node->value);
       break;
     case TYPE_OCTET_STRING:
       len2 = -1;
       if (MHD__asn1_get_octet_der
-          (node->value, node->value_len, &len2, (unsigned char*) value, value_size,
-           len) != ASN1_SUCCESS)
+          (node->value, node->value_len, &len2, (unsigned char *) value,
+           value_size, len) != ASN1_SUCCESS)
         return ASN1_MEM_ERROR;
       break;
     case TYPE_GENERALSTRING:
       len2 = -1;
       if (MHD__asn1_get_octet_der
-          (node->value, node->value_len, &len2, (unsigned char*) value, value_size,
-           len) != ASN1_SUCCESS)
+          (node->value, node->value_len, &len2, (unsigned char *) value,
+           value_size, len) != ASN1_SUCCESS)
         return ASN1_MEM_ERROR;
       break;
     case TYPE_BIT_STRING:
       len2 = -1;
       if (MHD__asn1_get_bit_der
-          (node->value, node->value_len, &len2, (unsigned char*) value, value_size,
-           len) != ASN1_SUCCESS)
+          (node->value, node->value_len, &len2, (unsigned char *) value,
+           value_size, len) != ASN1_SUCCESS)
         return ASN1_MEM_ERROR;
       break;
     case TYPE_CHOICE:
@@ -904,5 +911,3 @@ MHD__asn1_read_value (ASN1_TYPE root, const char *name, void *ivalue, int *len)
     }
   return ASN1_SUCCESS;
 }
-
-
diff --git a/src/daemon/https/minitasn1/element.h b/src/daemon/https/minitasn1/element.h
index eea9839a..e4484925 100644
--- a/src/daemon/https/minitasn1/element.h
+++ b/src/daemon/https/minitasn1/element.h
@@ -6,8 +6,8 @@
 MHD__asn1_retCode MHD__asn1_append_sequence_set (node_asn * node);
 
 MHD__asn1_retCode MHD__asn1_convert_integer (const char *value,
-                                    unsigned char *value_out,
-                                    int value_out_size, int *len);
+                                             unsigned char *value_out,
+                                             int value_out_size, int *len);
 
 void MHD__asn1_hierarchical_name (node_asn * node, char *name, int name_size);
 
diff --git a/src/daemon/https/minitasn1/libtasn1.h b/src/daemon/https/minitasn1/libtasn1.h
index 7379db18..15292cd4 100644
--- a/src/daemon/https/minitasn1/libtasn1.h
+++ b/src/daemon/https/minitasn1/libtasn1.h
@@ -43,7 +43,7 @@ extern "C"
   /* (null character included)    */
 
 
-  typedef int MHD__asn1_retCode;     /* type returned by libtasn1 functions */
+  typedef int MHD__asn1_retCode;        /* type returned by libtasn1 functions */
 
   /*****************************************/
   /*  Errors returned by libtasn1 functions */
@@ -138,49 +138,53 @@ extern "C"
   /***********************************/
 
   MHD__asn1_retCode MHD__asn1_parser2tree (const char *file_name,
-                                 ASN1_TYPE * definitions,
-                                 char *errorDescription);
+                                           ASN1_TYPE * definitions,
+                                           char *errorDescription);
 
   MHD__asn1_retCode MHD__asn1_parser2array (const char *inputFileName,
-                                  const char *outputFileName,
-                                  const char *vectorName,
-                                  char *errorDescription);
+                                            const char *outputFileName,
+                                            const char *vectorName,
+                                            char *errorDescription);
 
   MHD__asn1_retCode MHD__asn1_array2tree (const ASN1_ARRAY_TYPE * array,
-                                ASN1_TYPE * definitions,
-                                char *errorDescription);
+                                          ASN1_TYPE * definitions,
+                                          char *errorDescription);
 
   MHD__asn1_retCode MHD__asn1_create_element (ASN1_TYPE definitions,
-                                    const char *source_name,
-                                    ASN1_TYPE * element);
+                                              const char *source_name,
+                                              ASN1_TYPE * element);
 
   MHD__asn1_retCode MHD__asn1_delete_structure (ASN1_TYPE * structure);
 
   MHD__asn1_retCode MHD__asn1_delete_element (ASN1_TYPE structure,
-                                    const char *element_name);
+                                              const char *element_name);
 
-  MHD__asn1_retCode MHD__asn1_write_value (ASN1_TYPE node_root, const char *name,
-                                 const void *ivalue, int len);
+  MHD__asn1_retCode MHD__asn1_write_value (ASN1_TYPE node_root,
+                                           const char *name,
+                                           const void *ivalue, int len);
 
   MHD__asn1_retCode MHD__asn1_read_value (ASN1_TYPE root, const char *name,
-                                void *ivalue, int *len);
+                                          void *ivalue, int *len);
 
-  MHD__asn1_retCode MHD__asn1_number_of_elements (ASN1_TYPE element, const char *name,
-                                        int *num);
+  MHD__asn1_retCode MHD__asn1_number_of_elements (ASN1_TYPE element,
+                                                  const char *name, int *num);
 
   MHD__asn1_retCode MHD__asn1_der_coding (ASN1_TYPE element, const char *name,
-                                void *ider, int *len, char *ErrorDescription);
+                                          void *ider, int *len,
+                                          char *ErrorDescription);
 
-  MHD__asn1_retCode MHD__asn1_der_decoding (ASN1_TYPE * element, const void *ider,
-                                  int len, char *errorDescription);
+  MHD__asn1_retCode MHD__asn1_der_decoding (ASN1_TYPE * element,
+                                            const void *ider, int len,
+                                            char *errorDescription);
 
   MHD__asn1_retCode MHD__asn1_der_decoding_startEnd (ASN1_TYPE element,
-                                           const void *ider, int len,
-                                           const char *name_element,
-                                           int *start, int *end);
+                                                     const void *ider,
+                                                     int len,
+                                                     const char *name_element,
+                                                     int *start, int *end);
 
   const char *MHD__asn1_find_structure_from_oid (ASN1_TYPE definitions,
-                                            const char *oidValue);
+                                                 const char *oidValue);
 
   const char *MHD__libtasn1_strerror (MHD__asn1_retCode error);
 
@@ -189,34 +193,37 @@ extern "C"
   /* DER utility functions. */
 
   int MHD__asn1_get_tag_der (const unsigned char *der, int der_len,
-                        unsigned char *cls, int *len, unsigned long *tag);
+                             unsigned char *cls, int *len,
+                             unsigned long *tag);
 
   void MHD__asn1_octet_der (const unsigned char *str, int str_len,
-                       unsigned char *der, int *der_len);
+                            unsigned char *der, int *der_len);
 
-  MHD__asn1_retCode MHD__asn1_get_octet_der (const unsigned char *der, int der_len,
-                                   int *ret_len, unsigned char *str,
-                                   int str_size, int *str_len);
+  MHD__asn1_retCode MHD__asn1_get_octet_der (const unsigned char *der,
+                                             int der_len, int *ret_len,
+                                             unsigned char *str, int str_size,
+                                             int *str_len);
 
   void MHD__asn1_bit_der (const unsigned char *str, int bit_len,
-                     unsigned char *der, int *der_len);
+                          unsigned char *der, int *der_len);
 
-  MHD__asn1_retCode MHD__asn1_get_bit_der (const unsigned char *der, int der_len,
-                                 int *ret_len, unsigned char *str,
-                                 int str_size, int *bit_len);
+  MHD__asn1_retCode MHD__asn1_get_bit_der (const unsigned char *der,
+                                           int der_len, int *ret_len,
+                                           unsigned char *str, int str_size,
+                                           int *bit_len);
 
   signed long MHD__asn1_get_length_der (const unsigned char *der, int der_len,
-                                   int *len);
+                                        int *len);
 
   void MHD__asn1_length_der (unsigned long int len, unsigned char *ans,
-                        int *ans_len);
+                             int *ans_len);
 
   /* Other utility functions. */
 
   ASN1_TYPE MHD__asn1_find_node (ASN1_TYPE pointer, const char *name);
 
   MHD__asn1_retCode MHD__asn1_copy_node (ASN1_TYPE dst, const char *dst_name,
-                               ASN1_TYPE src, const char *src_name);
+                                         ASN1_TYPE src, const char *src_name);
 
 #ifdef __cplusplus
 }
diff --git a/src/daemon/https/minitasn1/parser_aux.c b/src/daemon/https/minitasn1/parser_aux.c
index 5f36a5ff..438b8e76 100644
--- a/src/daemon/https/minitasn1/parser_aux.c
+++ b/src/daemon/https/minitasn1/parser_aux.c
@@ -29,7 +29,7 @@
 
 
 
-char MHD__asn1_identifierMissing[MAX_NAME_SIZE + 1];        /* identifier name not found */
+char MHD__asn1_identifierMissing[MAX_NAME_SIZE + 1];    /* identifier name not found */
 
 /***********************************************/
 /* Type: list_type                             */
@@ -443,7 +443,8 @@ MHD__asn1_change_integer_value (ASN1_TYPE node)
         {
           if (p->value)
             {
-              MHD__asn1_convert_integer ((const char*) p->value, val, sizeof (val), &len);
+              MHD__asn1_convert_integer ((const char *) p->value, val,
+                                         sizeof (val), &len);
               MHD__asn1_octet_der (val, len, val2, &len);
               MHD__asn1_set_value (p, val2, len);
             }
@@ -521,7 +522,8 @@ MHD__asn1_expand_object_id (ASN1_TYPE node)
                     {
                       MHD__asn1_str_cpy (name2, sizeof (name2), name_root);
                       MHD__asn1_str_cat (name2, sizeof (name2), ".");
-                      MHD__asn1_str_cat (name2, sizeof (name2), (const char*)  p2->value);
+                      MHD__asn1_str_cat (name2, sizeof (name2),
+                                         (const char *) p2->value);
                       p3 = MHD__asn1_find_node (node, name2);
                       if (!p3 || (type_field (p3->type) != TYPE_OBJECT_ID) ||
                           !(p3->type & CONST_ASSIGN))
@@ -536,7 +538,7 @@ MHD__asn1_expand_object_id (ASN1_TYPE node)
                             {
                               p5 = MHD__asn1_add_node_only (TYPE_CONSTANT);
                               MHD__asn1_set_name (p5, p4->name);
-                              tlen = strlen ( (const char*) p4->value);
+                              tlen = strlen ((const char *) p4->value);
                               if (tlen > 0)
                                 MHD__asn1_set_value (p5, p4->value, tlen + 1);
                               if (p2 == p)
@@ -607,7 +609,8 @@ MHD__asn1_expand_object_id (ASN1_TYPE node)
                 {
                   MHD__asn1_str_cpy (name2, sizeof (name2), name_root);
                   MHD__asn1_str_cat (name2, sizeof (name2), ".");
-                  MHD__asn1_str_cat (name2, sizeof (name2), (const char*) p2->value);
+                  MHD__asn1_str_cat (name2, sizeof (name2),
+                                     (const char *) p2->value);
                   p3 = MHD__asn1_find_node (node, name2);
                   if (!p3 || (type_field (p3->type) != TYPE_OBJECT_ID) ||
                       !(p3->type & CONST_ASSIGN))
@@ -620,7 +623,8 @@ MHD__asn1_expand_object_id (ASN1_TYPE node)
                         {
                           if (name2[0])
                             MHD__asn1_str_cat (name2, sizeof (name2), ".");
-                          MHD__asn1_str_cat (name2, sizeof (name2), (const char*) p4->value);
+                          MHD__asn1_str_cat (name2, sizeof (name2),
+                                             (const char *) p4->value);
                         }
                       p4 = p4->right;
                     }
@@ -691,11 +695,11 @@ MHD__asn1_check_identifier (ASN1_TYPE node)
         {
           MHD__asn1_str_cpy (name2, sizeof (name2), node->name);
           MHD__asn1_str_cat (name2, sizeof (name2), ".");
-          MHD__asn1_str_cat (name2, sizeof (name2), (const char*) p->value);
+          MHD__asn1_str_cat (name2, sizeof (name2), (const char *) p->value);
           p2 = MHD__asn1_find_node (node, name2);
           if (p2 == NULL)
             {
-              strcpy (MHD__asn1_identifierMissing, (const char*) p->value);
+              strcpy (MHD__asn1_identifierMissing, (const char *) p->value);
               return ASN1_IDENTIFIER_NOT_FOUND;
             }
         }
@@ -707,8 +711,9 @@ MHD__asn1_check_identifier (ASN1_TYPE node)
             {
               MHD__asn1_str_cpy (name2, sizeof (name2), node->name);
               MHD__asn1_str_cat (name2, sizeof (name2), ".");
-              MHD__asn1_str_cat (name2, sizeof (name2), (const char*) p2->value);
-              strcpy (MHD__asn1_identifierMissing, (const char*) p2->value);
+              MHD__asn1_str_cat (name2, sizeof (name2),
+                                 (const char *) p2->value);
+              strcpy (MHD__asn1_identifierMissing, (const char *) p2->value);
               p2 = MHD__asn1_find_node (node, name2);
               if (!p2 || (type_field (p2->type) != TYPE_OBJECT_ID) ||
                   !(p2->type & CONST_ASSIGN))
@@ -727,8 +732,10 @@ MHD__asn1_check_identifier (ASN1_TYPE node)
                 {
                   MHD__asn1_str_cpy (name2, sizeof (name2), node->name);
                   MHD__asn1_str_cat (name2, sizeof (name2), ".");
-                  MHD__asn1_str_cat (name2, sizeof (name2), (const char*) p2->value);
-                  strcpy (MHD__asn1_identifierMissing, (const char*) p2->value);
+                  MHD__asn1_str_cat (name2, sizeof (name2),
+                                     (const char *) p2->value);
+                  strcpy (MHD__asn1_identifierMissing,
+                          (const char *) p2->value);
                   p2 = MHD__asn1_find_node (node, name2);
                   if (!p2 || (type_field (p2->type) != TYPE_OBJECT_ID) ||
                       !(p2->type & CONST_ASSIGN))
diff --git a/src/daemon/https/minitasn1/parser_aux.h b/src/daemon/https/minitasn1/parser_aux.h
index ae54c3be..4437fb19 100644
--- a/src/daemon/https/minitasn1/parser_aux.h
+++ b/src/daemon/https/minitasn1/parser_aux.h
@@ -9,7 +9,7 @@
 node_asn *MHD__asn1_add_node (unsigned int type);
 
 node_asn *MHD__asn1_set_value (node_asn * node, const void *value,
-                           unsigned int len);
+                               unsigned int len);
 
 node_asn *MHD__asn1_set_name (node_asn * node, const char *name);
 
diff --git a/src/daemon/https/minitasn1/structure.c b/src/daemon/https/minitasn1/structure.c
index 6a910af6..8a5c899d 100644
--- a/src/daemon/https/minitasn1/structure.c
+++ b/src/daemon/https/minitasn1/structure.c
@@ -37,7 +37,8 @@
 
 extern char MHD__asn1_identifierMissing[];
 
-static node_asn *MHD__asn1_copy_structure2 (node_asn * root, const char *source_name);
+static node_asn *MHD__asn1_copy_structure2 (node_asn * root,
+                                            const char *source_name);
 
 
 
@@ -106,7 +107,7 @@ MHD__asn1_find_left (node_asn * node)
   **/
 MHD__asn1_retCode
 MHD__asn1_array2tree (const ASN1_ARRAY_TYPE * array, ASN1_TYPE * definitions,
-                 char *errorDescription)
+                      char *errorDescription)
 {
   node_asn *p, *p_last = NULL;
   unsigned long k;
@@ -421,7 +422,7 @@ MHD__asn1_type_choice_config (node_asn * node)
                           if (type_field (p3->type) == TYPE_TAG)
                             {
                               p4 = MHD__asn1_add_node_only (p3->type);
-                              tlen = strlen ((const char*) p3->value);
+                              tlen = strlen ((const char *) p3->value);
                               if (tlen > 0)
                                 MHD__asn1_set_value (p4, p3->value, tlen + 1);
                               MHD__asn1_set_right (p4, p2->down);
@@ -497,7 +498,8 @@ MHD__asn1_expand_identifier (node_asn ** node, node_asn * root)
             {
               MHD__asn1_str_cpy (name2, sizeof (name2), root->name);
               MHD__asn1_str_cat (name2, sizeof (name2), ".");
-              MHD__asn1_str_cat (name2, sizeof (name2), (const char*) p->value);
+              MHD__asn1_str_cat (name2, sizeof (name2),
+                                 (const char *) p->value);
               p2 = MHD__asn1_copy_structure2 (root, name2);
               if (p2 == NULL)
                 {
@@ -606,7 +608,7 @@ MHD__asn1_expand_identifier (node_asn ** node, node_asn * root)
   **/
 MHD__asn1_retCode
 MHD__asn1_create_element (ASN1_TYPE definitions, const char *source_name,
-                     ASN1_TYPE * element)
+                          ASN1_TYPE * element)
 {
   node_asn *dest_node;
   int res;
@@ -685,7 +687,8 @@ MHD__asn1_number_of_elements (ASN1_TYPE element, const char *name, int *num)
   *
   **/
 const char *
-MHD__asn1_find_structure_from_oid (ASN1_TYPE definitions, const char *oidValue)
+MHD__asn1_find_structure_from_oid (ASN1_TYPE definitions,
+                                   const char *oidValue)
 {
   char definitionsName[MAX_NAME_SIZE], name[2 * MAX_NAME_SIZE + 1];
   char value[MAX_NAME_SIZE];
@@ -741,7 +744,7 @@ MHD__asn1_find_structure_from_oid (ASN1_TYPE definitions, const char *oidValue)
  **/
 MHD__asn1_retCode
 MHD__asn1_copy_node (ASN1_TYPE dst, const char *dst_name,
-                ASN1_TYPE src, const char *src_name)
+                     ASN1_TYPE src, const char *src_name)
 {
 /* FIXME: rewrite using copy_structure().
  * It seems quite hard to do.
diff --git a/src/daemon/https/tls/auth_cert.c b/src/daemon/https/tls/auth_cert.c
index 6f34a120..d0191f24 100644
--- a/src/daemon/https/tls/auth_cert.c
+++ b/src/daemon/https/tls/auth_cert.c
@@ -45,9 +45,10 @@
 #include <gnutls_x509.h>
 #include "debug.h"
 
-static MHD_gnutls_cert *alloc_and_load_x509_certs (MHD_gnutls_x509_crt_t * certs,
-                                               unsigned);
-static MHD_gnutls_privkey *alloc_and_load_x509_key (MHD_gnutls_x509_privkey_t key);
+static MHD_gnutls_cert *alloc_and_load_x509_certs (MHD_gnutls_x509_crt_t *
+                                                   certs, unsigned);
+static MHD_gnutls_privkey *alloc_and_load_x509_key (MHD_gnutls_x509_privkey_t
+                                                    key);
 
 
 /* Copies data from a internal certificate struct (MHD_gnutls_cert) to
@@ -55,7 +56,7 @@ static MHD_gnutls_privkey *alloc_and_load_x509_key (MHD_gnutls_x509_privkey_t ke
  */
 static int
 MHD__gnutls_copy_certificate_auth_info (cert_auth_info_t info,
-                                    MHD_gnutls_cert * cert, int ncerts)
+                                        MHD_gnutls_cert * cert, int ncerts)
 {
   /* Copy peer's information to auth_info_t
    */
@@ -82,7 +83,7 @@ MHD__gnutls_copy_certificate_auth_info (cert_auth_info_t info,
         {
           ret =
             MHD__gnutls_set_datum (&info->raw_certificate_list[i],
-                               cert[i].raw.data, cert[i].raw.size);
+                                   cert[i].raw.data, cert[i].raw.size);
           if (ret < 0)
             {
               MHD_gnutls_assert ();
@@ -113,9 +114,9 @@ clear:
  */
 inline static int
 MHD__gnutls_check_pk_algo_in_list (const enum MHD_GNUTLS_PublicKeyAlgorithm
-                               *pk_algos, int pk_algos_length,
-                               enum MHD_GNUTLS_PublicKeyAlgorithm
-                               algo_to_check)
+                                   *pk_algos, int pk_algos_length,
+                                   enum MHD_GNUTLS_PublicKeyAlgorithm
+                                   algo_to_check)
 {
   int i;
   for (i = 0; i < pk_algos_length; i++)
@@ -133,7 +134,8 @@ MHD__gnutls_check_pk_algo_in_list (const enum MHD_GNUTLS_PublicKeyAlgorithm
  * specified in cert.
  */
 static int
-MHD__gnutls_cert_get_issuer_dn (MHD_gnutls_cert * cert, MHD_gnutls_datum_t * odn)
+MHD__gnutls_cert_get_issuer_dn (MHD_gnutls_cert * cert,
+                                MHD_gnutls_datum_t * odn)
 {
   ASN1_TYPE dn;
   int len, result;
@@ -155,8 +157,9 @@ MHD__gnutls_cert_get_issuer_dn (MHD_gnutls_cert * cert, MHD_gnutls_datum_t * odn
       return MHD_gtls_asn2err (result);
     }
 
-  result = MHD__asn1_der_decoding_startEnd (dn, cert->raw.data, cert->raw.size,
-                                       "tbsCertificate.issuer", &start, &end);
+  result =
+    MHD__asn1_der_decoding_startEnd (dn, cert->raw.data, cert->raw.size,
+                                     "tbsCertificate.issuer", &start, &end);
 
   if (result != ASN1_SUCCESS)
     {
@@ -211,7 +214,7 @@ _find_x509_cert (const MHD_gtls_cert_credentials_t cred,
             {
               if ((result =
                    MHD__gnutls_cert_get_issuer_dn (&cred->cert_list[i][j],
-                                               &odn)) < 0)
+                                                   &odn)) < 0)
                 {
                   MHD_gnutls_assert ();
                   return result;
@@ -483,7 +486,8 @@ _select_client_cert (MHD_gtls_session_t session,
           if (issuers_dn_length > 0)
             {
               issuers_dn =
-                MHD_gnutls_malloc (sizeof (MHD_gnutls_datum_t) * issuers_dn_length);
+                MHD_gnutls_malloc (sizeof (MHD_gnutls_datum_t) *
+                                   issuers_dn_length);
               if (issuers_dn == NULL)
                 {
                   MHD_gnutls_assert ();
@@ -712,7 +716,8 @@ MHD_gtls_proc_x509_server_certificate (MHD_gtls_session_t session,
    */
 
   peer_certificate_list =
-    MHD_gnutls_malloc (sizeof (MHD_gnutls_cert) * (peer_certificate_list_size));
+    MHD_gnutls_malloc (sizeof (MHD_gnutls_cert) *
+                       (peer_certificate_list_size));
 
   if (peer_certificate_list == NULL)
     {
@@ -752,8 +757,9 @@ MHD_gtls_proc_x509_server_certificate (MHD_gtls_session_t session,
 
   if ((ret =
        MHD__gnutls_copy_certificate_auth_info (info,
-                                           peer_certificate_list,
-                                           peer_certificate_list_size)) < 0)
+                                               peer_certificate_list,
+                                               peer_certificate_list_size)) <
+      0)
     {
       MHD_gnutls_assert ();
       goto cleanup;
@@ -761,7 +767,7 @@ MHD_gtls_proc_x509_server_certificate (MHD_gtls_session_t session,
 
   if ((ret =
        MHD__gnutls_check_key_usage (&peer_certificate_list[0],
-                                MHD_gnutls_kx_get (session))) < 0)
+                                    MHD_gnutls_kx_get (session))) < 0)
     {
       MHD_gnutls_assert ();
       goto cleanup;
diff --git a/src/daemon/https/tls/auth_cert.h b/src/daemon/https/tls/auth_cert.h
index aabfac76..395fdd29 100644
--- a/src/daemon/https/tls/auth_cert.h
+++ b/src/daemon/https/tls/auth_cert.h
@@ -117,9 +117,9 @@ typedef struct MHD_gtls_cert_auth_info_st
   MHD_gtls_dh_info_st dh;
   rsa_info_st rsa_export;
 
-  MHD_gnutls_datum_t *raw_certificate_list; /* holds the raw certificate of the
-                                         * peer.
-                                         */
+  MHD_gnutls_datum_t *raw_certificate_list;     /* holds the raw certificate of the
+                                                 * peer.
+                                                 */
   unsigned int ncerts;          /* holds the size of the list above */
 } *cert_auth_info_t;
 
diff --git a/src/daemon/https/tls/auth_rsa.c b/src/daemon/https/tls/auth_rsa.c
index 97f1901d..f39a91fb 100644
--- a/src/daemon/https/tls/auth_rsa.c
+++ b/src/daemon/https/tls/auth_rsa.c
@@ -57,7 +57,7 @@ const MHD_gtls_mod_auth_st MHD_gtls_rsa_auth_struct = {
   MHD_gtls_proc_cert_server_certificate,
   MHD__gnutls_proc_cert_client_certificate,
   NULL,                         /* proc server kx */
-  MHD__gnutls_proc_rsa_client_kx,   /* proc client kx */
+  MHD__gnutls_proc_rsa_client_kx,       /* proc client kx */
   MHD_gtls_proc_cert_client_cert_vrfy,  /* proc client cert vrfy */
   MHD_gtls_proc_cert_cert_req   /* proc server cert request */
 };
@@ -66,8 +66,8 @@ const MHD_gtls_mod_auth_st MHD_gtls_rsa_auth_struct = {
  */
 int
 MHD__gnutls_get_public_rsa_params (MHD_gtls_session_t session,
-                               mpi_t params[MAX_PUBLIC_PARAMS_SIZE],
-                               int *params_len)
+                                   mpi_t params[MAX_PUBLIC_PARAMS_SIZE],
+                                   int *params_len)
 {
   int ret;
   cert_auth_info_t info;
@@ -148,7 +148,7 @@ MHD__gnutls_get_public_rsa_params (MHD_gtls_session_t session,
  */
 int
 MHD__gnutls_get_private_rsa_params (MHD_gtls_session_t session,
-                                mpi_t ** params, int *params_size)
+                                    mpi_t ** params, int *params_size)
 {
   int bits;
   MHD_gtls_cert_credentials_t cred;
@@ -169,8 +169,8 @@ MHD__gnutls_get_private_rsa_params (MHD_gtls_session_t session,
     }
 
   bits =
-    MHD__gnutls_mpi_get_nbits (session->internals.selected_cert_list[0].
-                           params[0]);
+    MHD__gnutls_mpi_get_nbits (session->internals.
+                               selected_cert_list[0].params[0]);
 
   if (MHD_gtls_cipher_suite_get_kx_algo
       (&session->security_parameters.current_cipher_suite)
@@ -207,7 +207,7 @@ MHD__gnutls_get_private_rsa_params (MHD_gtls_session_t session,
 
 int
 MHD__gnutls_proc_rsa_client_kx (MHD_gtls_session_t session, opaque * data,
-                            size_t _data_size)
+                                size_t _data_size)
 {
   MHD_gnutls_datum_t plaintext;
   MHD_gnutls_datum_t ciphertext;
@@ -291,7 +291,8 @@ MHD__gnutls_proc_rsa_client_kx (MHD_gtls_session_t session, opaque * data,
 
       /* we do not need strong random numbers here.
        */
-      if (MHD_gc_nonce ((char*) session->key->key.data, session->key->key.size) != GC_OK)
+      if (MHD_gc_nonce
+          ((char *) session->key->key.data, session->key->key.size) != GC_OK)
         {
           MHD_gnutls_assert ();
           return GNUTLS_E_RANDOM_FAILED;
@@ -321,7 +322,7 @@ int
 MHD__gnutls_gen_rsa_client_kx (MHD_gtls_session_t session, opaque ** data)
 {
   cert_auth_info_t auth;
-  MHD_gnutls_datum_t sdata;         /* data to send */
+  MHD_gnutls_datum_t sdata;     /* data to send */
   mpi_t params[MAX_PUBLIC_PARAMS_SIZE];
   int params_len = MAX_PUBLIC_PARAMS_SIZE;
   int ret, i;
@@ -330,7 +331,7 @@ MHD__gnutls_gen_rsa_client_kx (MHD_gtls_session_t session, opaque ** data)
   if (session->key == NULL)
     {
       MHD_gnutls_assert ();
-      return GNUTLS_E_INSUFFICIENT_CREDENTIALS;  
+      return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
     }
 
   auth = session->key->auth_info;
@@ -352,8 +353,8 @@ MHD__gnutls_gen_rsa_client_kx (MHD_gtls_session_t session, opaque ** data)
       return GNUTLS_E_MEMORY_ERROR;
     }
 
-  if (MHD_gc_pseudo_random ((char*) session->key->key.data,
-                        session->key->key.size) != GC_OK)
+  if (MHD_gc_pseudo_random ((char *) session->key->key.data,
+                            session->key->key.size) != GC_OK)
     {
       MHD_gnutls_assert ();
       return GNUTLS_E_RANDOM_FAILED;
diff --git a/src/daemon/https/tls/auth_rsa_export.c b/src/daemon/https/tls/auth_rsa_export.c
index 31a5f2a6..5fdce12e 100644
--- a/src/daemon/https/tls/auth_rsa_export.c
+++ b/src/daemon/https/tls/auth_rsa_export.c
@@ -60,7 +60,7 @@ const MHD_gtls_mod_auth_st MHD_rsa_export_auth_struct = {
   MHD_gtls_proc_cert_server_certificate,
   MHD__gnutls_proc_cert_client_certificate,
   proc_rsa_export_server_kx,
-  MHD__gnutls_proc_rsa_client_kx,   /* proc client kx */
+  MHD__gnutls_proc_rsa_client_kx,       /* proc client kx */
   MHD_gtls_proc_cert_client_cert_vrfy,  /* proc client cert vrfy */
   MHD_gtls_proc_cert_cert_req   /* proc server cert request */
 };
diff --git a/src/daemon/https/tls/debug.c b/src/daemon/https/tls/debug.c
index b7408e39..ac657504 100644
--- a/src/daemon/https/tls/debug.c
+++ b/src/daemon/https/tls/debug.c
@@ -37,13 +37,15 @@ MHD__gnutls_print_state (MHD_gtls_session_t session)
 
   MHD__gnutls_debug_log ("GNUTLS State:\n");
   MHD__gnutls_debug_log ("Connection End: %d\n",
-                     session->security_parameters.entity);
+                         session->security_parameters.entity);
   MHD__gnutls_debug_log ("Cipher Algorithm: %d\n",
-                     session->security_parameters.read_bulk_cipher_algorithm);
+                         session->security_parameters.
+                         read_bulk_cipher_algorithm);
   MHD__gnutls_debug_log ("MAC algorithm: %d\n",
-                     session->security_parameters.read_mac_algorithm);
+                         session->security_parameters.read_mac_algorithm);
   MHD__gnutls_debug_log ("Compression Algorithm: %d\n",
-                     session->security_parameters.read_compression_algorithm);
+                         session->security_parameters.
+                         read_compression_algorithm);
   MHD__gnutls_debug_log ("\n");
 
 }
@@ -123,6 +125,7 @@ MHD__gnutls_dump_mpi (const char *prefix, mpi_t a)
   size_t n = sizeof buf;
 
   if (gcry_mpi_print (GCRYMPI_FMT_HEX, buf, n, &n, a))
-    strcpy ((char*) buf, "[can't print value]");        /* Flawfinder: ignore */
-  MHD__gnutls_hard_log ("MPI: length: %d\n\t%s%s\n", (n - 1) / 2, prefix, buf);
+    strcpy ((char *) buf, "[can't print value]");       /* Flawfinder: ignore */
+  MHD__gnutls_hard_log ("MPI: length: %d\n\t%s%s\n", (n - 1) / 2, prefix,
+                        buf);
 }
diff --git a/src/daemon/https/tls/debug.h b/src/daemon/https/tls/debug.h
index 637beca8..69c6a06e 100644
--- a/src/daemon/https/tls/debug.h
+++ b/src/daemon/https/tls/debug.h
@@ -26,5 +26,6 @@
 void MHD__gnutls_print_state (MHD_gtls_session_t session);
 #endif
 const char *MHD__gnutls_packet2str (content_type_t packet);
-const char *MHD__gnutls_handshake2str (MHD_gnutls_handshake_description_t handshake);
+const char *MHD__gnutls_handshake2str (MHD_gnutls_handshake_description_t
+                                       handshake);
 void MHD__gnutls_dump_mpi (const char *prefix, mpi_t a);
diff --git a/src/daemon/https/tls/ext_cert_type.c b/src/daemon/https/tls/ext_cert_type.c
index a104b00b..5fc53167 100644
--- a/src/daemon/https/tls/ext_cert_type.c
+++ b/src/daemon/https/tls/ext_cert_type.c
@@ -183,8 +183,8 @@ MHD_gtls_cert_type_send_params (MHD_gtls_session_t session, opaque * data,
           for (i = 0; i < len; i++)
             {
               data[i + 1] =
-                MHD__gnutls_cert_type2num (session->internals.
-                                       priorities.cert_type.priority[i]);
+                MHD__gnutls_cert_type2num (session->internals.priorities.
+                                           cert_type.priority[i]);
             }
           return len + 1;
         }
@@ -203,7 +203,8 @@ MHD_gtls_cert_type_send_params (MHD_gtls_session_t session, opaque * data,
             }
 
           data[0] =
-            MHD__gnutls_cert_type2num (session->security_parameters.cert_type);
+            MHD__gnutls_cert_type2num (session->security_parameters.
+                                       cert_type);
           return len;
         }
 
diff --git a/src/daemon/https/tls/ext_max_record.c b/src/daemon/https/tls/ext_max_record.c
index 421a1739..5dcf2225 100644
--- a/src/daemon/https/tls/ext_max_record.c
+++ b/src/daemon/https/tls/ext_max_record.c
@@ -121,8 +121,8 @@ MHD_gtls_max_record_send_params (MHD_gtls_session_t session, opaque * data,
             }
 
           data[0] =
-            (uint8_t) MHD_gtls_mre_record2num (session->internals.
-                                               proposed_record_size);
+            (uint8_t) MHD_gtls_mre_record2num (session->
+                                               internals.proposed_record_size);
           return len;
         }
 
diff --git a/src/daemon/https/tls/ext_oprfi.c b/src/daemon/https/tls/ext_oprfi.c
index 913820da..8b245404 100644
--- a/src/daemon/https/tls/ext_oprfi.c
+++ b/src/daemon/https/tls/ext_oprfi.c
@@ -58,7 +58,8 @@ oprfi_recv_server (MHD_gtls_session_t session,
 
   /* Store incoming data. */
   session->security_parameters.extensions.oprfi_client_len = len;
-  session->security_parameters.extensions.oprfi_client = MHD_gnutls_malloc (len);
+  session->security_parameters.extensions.oprfi_client =
+    MHD_gnutls_malloc (len);
   if (!session->security_parameters.extensions.oprfi_client)
     {
       MHD_gnutls_assert ();
@@ -101,7 +102,8 @@ oprfi_recv_client (MHD_gtls_session_t session,
 
   /* Store incoming data. */
   session->security_parameters.extensions.oprfi_server_len = len;
-  session->security_parameters.extensions.oprfi_server = MHD_gnutls_malloc (len);
+  session->security_parameters.extensions.oprfi_server =
+    MHD_gnutls_malloc (len);
   if (!session->security_parameters.extensions.oprfi_server)
     {
       MHD_gnutls_assert ();
@@ -165,7 +167,8 @@ oprfi_send_server (MHD_gtls_session_t session, opaque * data,
   session->security_parameters.extensions.oprfi_server_len =
     session->security_parameters.extensions.oprfi_client_len;
   session->security_parameters.extensions.oprfi_server =
-    MHD_gnutls_malloc (session->security_parameters.extensions.oprfi_server_len);
+    MHD_gnutls_malloc (session->security_parameters.extensions.
+                       oprfi_server_len);
   if (!session->security_parameters.extensions.oprfi_server)
     {
       MHD_gnutls_assert ();
@@ -186,8 +189,8 @@ oprfi_send_server (MHD_gtls_session_t session, opaque * data,
     }
 
   DECR_LENGTH_RET (data_size, 2, GNUTLS_E_SHORT_MEMORY_BUFFER);
-  MHD_gtls_write_uint16 (session->security_parameters.
-                         extensions.oprfi_server_len, p);
+  MHD_gtls_write_uint16 (session->security_parameters.extensions.
+                         oprfi_server_len, p);
   p += 2;
 
   DECR_LENGTH_RET (data_size,
@@ -206,10 +209,10 @@ MHD_gtls_oprfi_send_params (MHD_gtls_session_t session,
 {
 #if MHD_DEBUG_TLS
   if (session->security_parameters.entity == GNUTLS_CLIENT)
-           return oprfi_send_client (session, data, data_size);
+    return oprfi_send_client (session, data, data_size);
   else
 #endif
-       return oprfi_send_server (session, data, data_size);
+    return oprfi_send_server (session, data, data_size);
 }
 
 /**
@@ -255,7 +258,8 @@ MHD_gtls_oprfi_enable_client (MHD_gtls_session_t session,
  **/
 void
 MHD_gtls_oprfi_enable_server (MHD_gtls_session_t session,
-                              MHD_gnutls_oprfi_callback_func cb, void *userdata)
+                              MHD_gnutls_oprfi_callback_func cb,
+                              void *userdata)
 {
   session->security_parameters.extensions.oprfi_cb = cb;
   session->security_parameters.extensions.oprfi_userdata = userdata;
diff --git a/src/daemon/https/tls/ext_server_name.c b/src/daemon/https/tls/ext_server_name.c
index 9878fe62..1e3cab02 100644
--- a/src/daemon/https/tls/ext_server_name.c
+++ b/src/daemon/https/tls/ext_server_name.c
@@ -104,12 +104,12 @@ MHD_gtls_server_name_recv_params (MHD_gtls_session_t session,
             case 0:            /* NAME_DNS */
               if (len <= MAX_SERVER_NAME_SIZE)
                 {
-                  memcpy (session->security_parameters.extensions.
-                          server_names[i].name, p, len);
-                  session->security_parameters.extensions.
-                    server_names[i].name_length = len;
-                  session->security_parameters.extensions.
-                    server_names[i].type = GNUTLS_NAME_DNS;
+                  memcpy (session->security_parameters.
+                          extensions.server_names[i].name, p, len);
+                  session->security_parameters.extensions.server_names[i].
+                    name_length = len;
+                  session->security_parameters.extensions.server_names[i].
+                    type = GNUTLS_NAME_DNS;
                   break;
                 }
             }
@@ -150,8 +150,8 @@ MHD_gtls_server_name_send_params (MHD_gtls_session_t session,
           /* count the total size
            */
           len =
-            session->security_parameters.extensions.server_names[i].
-            name_length;
+            session->security_parameters.extensions.
+            server_names[i].name_length;
 
           /* uint8_t + uint16_t + size
            */
@@ -170,14 +170,14 @@ MHD_gtls_server_name_send_params (MHD_gtls_session_t session,
            i < session->security_parameters.extensions.server_names_size; i++)
         {
 
-          switch (session->security_parameters.extensions.
-                  server_names[i].type)
+          switch (session->security_parameters.extensions.server_names[i].
+                  type)
             {
             case GNUTLS_NAME_DNS:
 
               len =
-                session->security_parameters.extensions.
-                server_names[i].name_length;
+                session->security_parameters.extensions.server_names[i].
+                name_length;
               if (len == 0)
                 break;
 
@@ -195,8 +195,8 @@ MHD_gtls_server_name_send_params (MHD_gtls_session_t session,
               p += 2;
 
               memcpy (p,
-                      session->security_parameters.extensions.
-                      server_names[0].name, len);
+                      session->security_parameters.extensions.server_names[0].
+                      name, len);
               p += len;
               break;
             default:
@@ -234,8 +234,8 @@ MHD_gtls_server_name_send_params (MHD_gtls_session_t session,
   **/
 int
 MHD__gnutls_server_name_get (MHD_gtls_session_t session, void *data,
-                            size_t * data_length,
-                            unsigned int *type, unsigned int indx)
+                             size_t * data_length,
+                             unsigned int *type, unsigned int indx)
 {
   char *_data = data;
 #if MHD_DEBUG_TLS
@@ -256,8 +256,8 @@ MHD__gnutls_server_name_get (MHD_gtls_session_t session, void *data,
       session->security_parameters.extensions.server_names[indx].name_length)
     {
       *data_length =
-        session->security_parameters.extensions.server_names[indx].
-        name_length;
+        session->security_parameters.extensions.
+        server_names[indx].name_length;
       memcpy (data,
               session->security_parameters.extensions.server_names[indx].name,
               *data_length);
@@ -269,8 +269,8 @@ MHD__gnutls_server_name_get (MHD_gtls_session_t session, void *data,
   else
     {
       *data_length =
-        session->security_parameters.extensions.server_names[indx].
-        name_length;
+        session->security_parameters.extensions.
+        server_names[indx].name_length;
       return GNUTLS_E_SHORT_MEMORY_BUFFER;
     }
 
@@ -296,8 +296,8 @@ MHD__gnutls_server_name_get (MHD_gtls_session_t session, void *data,
   **/
 int
 MHD__gnutls_server_name_set (MHD_gtls_session_t session,
-                            MHD_gnutls_server_name_type_t type,
-                            const void *name, size_t name_length)
+                             MHD_gnutls_server_name_type_t type,
+                             const void *name, size_t name_length)
 {
   int server_names;
 
@@ -318,8 +318,8 @@ MHD__gnutls_server_name_set (MHD_gtls_session_t session,
 
   session->security_parameters.extensions.server_names[server_names -
                                                        1].type = type;
-  memcpy (session->security_parameters.extensions.
-          server_names[server_names - 1].name, name, name_length);
+  memcpy (session->security_parameters.
+          extensions.server_names[server_names - 1].name, name, name_length);
   session->security_parameters.extensions.server_names[server_names -
                                                        1].name_length =
     name_length;
diff --git a/src/daemon/https/tls/gnutls_alert.c b/src/daemon/https/tls/gnutls_alert.c
index b3ad303d..4925f6e7 100644
--- a/src/daemon/https/tls/gnutls_alert.c
+++ b/src/daemon/https/tls/gnutls_alert.c
@@ -110,8 +110,9 @@ MHD__gnutls_alert_get_name (MHD_gnutls_alert_description_t alert)
   *
   **/
 int
-MHD__gnutls_alert_send (MHD_gtls_session_t session, MHD_gnutls_alert_level_t level,
-                       MHD_gnutls_alert_description_t desc)
+MHD__gnutls_alert_send (MHD_gtls_session_t session,
+                        MHD_gnutls_alert_level_t level,
+                        MHD_gnutls_alert_description_t desc)
 {
   uint8_t data[2];
   int ret;
@@ -124,7 +125,7 @@ MHD__gnutls_alert_send (MHD_gtls_session_t session, MHD_gnutls_alert_level_t lev
   if (name == NULL)
     name = "(unknown)";
   MHD__gnutls_record_log ("REC: Sending Alert[%d|%d] - %s\n", data[0],
-                      data[1], name);
+                          data[1], name);
 
   if ((ret = MHD_gtls_send_int (session, GNUTLS_ALERT, -1, data, 2)) >= 0)
     return 0;
diff --git a/src/daemon/https/tls/gnutls_algorithms.c b/src/daemon/https/tls/gnutls_algorithms.c
index d6e12f48..18ba0457 100644
--- a/src/daemon/https/tls/gnutls_algorithms.c
+++ b/src/daemon/https/tls/gnutls_algorithms.c
@@ -352,7 +352,8 @@ const int MHD__gnutls_comp_algorithms_size = MAX_COMP_METHODS;
 
 /* the compression entry is defined in MHD_gnutls_algorithms.h */
 
-MHD_gnutls_compression_entry MHD__gnutls_compression_algorithms[MAX_COMP_METHODS] =
+MHD_gnutls_compression_entry
+  MHD__gnutls_compression_algorithms[MAX_COMP_METHODS] =
   { GNUTLS_COMPRESSION_ENTRY (MHD_GNUTLS_COMP_NULL, 0x00, 0, 0, 0),
 #ifdef HAVE_LIBZ
   /* draft-ietf-tls-compression-02 */
@@ -1310,7 +1311,7 @@ MHD_gtls_version_lowest (MHD_gtls_session_t session)
       }
 
   if (min == 0xff)
-    return MHD_GNUTLS_PROTOCOL_VERSION_UNKNOWN;  /* unknown version */
+    return MHD_GNUTLS_PROTOCOL_VERSION_UNKNOWN; /* unknown version */
 
   return min;
 }
@@ -1333,7 +1334,7 @@ MHD_gtls_version_max (MHD_gtls_session_t session)
       }
 
   if (max == 0x00)
-    return MHD_GNUTLS_PROTOCOL_VERSION_UNKNOWN;  /* unknown version */
+    return MHD_GNUTLS_PROTOCOL_VERSION_UNKNOWN; /* unknown version */
 
   return max;
 }
@@ -1542,11 +1543,11 @@ MHD__gnutls_cipher_suite_is_ok (cipher_suite_st * suite)
 #define MAX_ELEM_SIZE 4
 static inline int
 MHD__gnutls_partition (MHD_gtls_session_t session,
-                   void *_base,
-                   size_t nmemb,
-                   size_t size,
-                   int (*compar) (MHD_gtls_session_t,
-                                  const void *, const void *))
+                       void *_base,
+                       size_t nmemb,
+                       size_t size,
+                       int (*compar) (MHD_gtls_session_t,
+                                      const void *, const void *))
 {
   uint8_t *base = _base;
   uint8_t tmp[MAX_ELEM_SIZE];
@@ -1590,10 +1591,11 @@ MHD__gnutls_partition (MHD_gtls_session_t session,
 
 static void
 MHD__gnutls_qsort (MHD_gtls_session_t session,
-               void *_base,
-               size_t nmemb,
-               size_t size,
-               int (*compar) (MHD_gtls_session_t, const void *, const void *))
+                   void *_base,
+                   size_t nmemb,
+                   size_t size,
+                   int (*compar) (MHD_gtls_session_t, const void *,
+                                  const void *))
 {
   unsigned int pivot;
   char *base = _base;
@@ -1613,9 +1615,9 @@ MHD__gnutls_qsort (MHD_gtls_session_t session,
   pivot = MHD__gnutls_partition (session, _base, nmemb, size, compar);
 
   MHD__gnutls_qsort (session, base, pivot < nmemb ? pivot + 1
-                 : pivot, size, compar);
-  MHD__gnutls_qsort (session, &base[(pivot + 1) * size], nmemb - pivot - 1, size,
-                 compar);
+                     : pivot, size, compar);
+  MHD__gnutls_qsort (session, &base[(pivot + 1) * size], nmemb - pivot - 1,
+                     size, compar);
 }
 
 /* a compare function for KX algorithms (using priorities).
@@ -1623,7 +1625,7 @@ MHD__gnutls_qsort (MHD_gtls_session_t session,
  */
 static int
 MHD__gnutls_compare_algo (MHD_gtls_session_t session,
-                      const void *i_A1, const void *i_A2)
+                          const void *i_A1, const void *i_A2)
 {
   enum MHD_GNUTLS_KeyExchangeAlgorithm kA1 =
     MHD_gtls_cipher_suite_get_kx_algo ((const cipher_suite_st *) i_A1);
@@ -1662,8 +1664,8 @@ MHD__gnutls_compare_algo (MHD_gtls_session_t session,
 #ifdef SORT_DEBUG
 static void
 MHD__gnutls_bsort (MHD_gtls_session_t session, void *_base, size_t nmemb,
-               size_t size, int (*compar) (MHD_gtls_session_t, const void *,
-                                           const void *))
+                   size_t size, int (*compar) (MHD_gtls_session_t,
+                                               const void *, const void *))
 {
   unsigned int i, j;
   int full = nmemb * size;
@@ -1704,17 +1706,17 @@ MHD_gtls_supported_ciphersuites_sorted (MHD_gtls_session_t session,
   MHD__gnutls_debug_log ("Unsorted: \n");
   for (i = 0; i < count; i++)
     MHD__gnutls_debug_log ("\t%d: %s\n", i,
-                       MHD_gtls_cipher_suite_get_name ((*ciphers)[i]));
+                           MHD_gtls_cipher_suite_get_name ((*ciphers)[i]));
 #endif
 
   MHD__gnutls_qsort (session, *ciphers, count, sizeof (cipher_suite_st),
-                 MHD__gnutls_compare_algo);
+                     MHD__gnutls_compare_algo);
 
 #ifdef SORT_DEBUG
   MHD__gnutls_debug_log ("Sorted: \n");
   for (i = 0; i < count; i++)
     MHD__gnutls_debug_log ("\t%d: %s\n", i,
-                       MHD_gtls_cipher_suite_get_name ((*ciphers)[i]));
+                           MHD_gtls_cipher_suite_get_name ((*ciphers)[i]));
 #endif
 
   return count;
@@ -1832,15 +1834,16 @@ MHD_gtls_supported_compression_methods (MHD_gtls_session_t session,
 {
   unsigned int i, j;
 
-  *comp = MHD_gnutls_malloc (sizeof (uint8_t) * SUPPORTED_COMPRESSION_METHODS);
+  *comp =
+    MHD_gnutls_malloc (sizeof (uint8_t) * SUPPORTED_COMPRESSION_METHODS);
   if (*comp == NULL)
     return GNUTLS_E_MEMORY_ERROR;
 
   for (i = j = 0; i < SUPPORTED_COMPRESSION_METHODS; i++)
     {
       int tmp =
-        MHD_gtls_compression_get_num (session->internals.priorities.
-                                      compression.priority[i]);
+        MHD_gtls_compression_get_num (session->internals.
+                                      priorities.compression.priority[i]);
 
       /* remove private compression algorithms, if requested.
        */
diff --git a/src/daemon/https/tls/gnutls_algorithms.h b/src/daemon/https/tls/gnutls_algorithms.h
index c0cb2332..ba4e83ba 100644
--- a/src/daemon/https/tls/gnutls_algorithms.h
+++ b/src/daemon/https/tls/gnutls_algorithms.h
@@ -93,7 +93,8 @@ int MHD_gtls_kx_is_ok (enum MHD_GNUTLS_KeyExchangeAlgorithm algorithm);
 int MHD_gtls_compression_is_ok (enum MHD_GNUTLS_CompressionMethod algorithm);
 int MHD_gtls_compression_get_num (enum MHD_GNUTLS_CompressionMethod
                                   algorithm);
-enum MHD_GNUTLS_CompressionMethod MHD_gtls_compression_get_id_from_int (int num);
+enum MHD_GNUTLS_CompressionMethod MHD_gtls_compression_get_id_from_int (int
+                                                                        num);
 int MHD_gtls_compression_get_mem_level (enum MHD_GNUTLS_CompressionMethod
                                         algorithm);
 int MHD_gtls_compression_get_comp_level (enum MHD_GNUTLS_CompressionMethod
@@ -140,13 +141,14 @@ struct MHD_gtls_compression_entry
 typedef struct MHD_gtls_compression_entry MHD_gnutls_compression_entry;
 
 /* Functions for sign algorithms. */
-MHD_gnutls_sign_algorithm_t MHD_gtls_x509_oid2sign_algorithm (const char *oid);
+MHD_gnutls_sign_algorithm_t MHD_gtls_x509_oid2sign_algorithm (const char
+                                                              *oid);
 MHD_gnutls_sign_algorithm_t MHD_gtls_x509_pk_to_sign (enum
-                                                  MHD_GNUTLS_PublicKeyAlgorithm
-                                                  pk,
-                                                  enum
-                                                  MHD_GNUTLS_HashAlgorithm
-                                                  mac);
+                                                      MHD_GNUTLS_PublicKeyAlgorithm
+                                                      pk,
+                                                      enum
+                                                      MHD_GNUTLS_HashAlgorithm
+                                                      mac);
 const char *MHD_gtls_x509_sign_to_oid (enum MHD_GNUTLS_PublicKeyAlgorithm,
                                        enum MHD_GNUTLS_HashAlgorithm mac);
 
diff --git a/src/daemon/https/tls/gnutls_anon_cred.c b/src/daemon/https/tls/gnutls_anon_cred.c
index 665a0758..d73c0edd 100644
--- a/src/daemon/https/tls/gnutls_anon_cred.c
+++ b/src/daemon/https/tls/gnutls_anon_cred.c
@@ -44,7 +44,7 @@ static const int anon_dummy;
   **/
 void
 MHD__gnutls_anon_free_server_credentials (MHD_gtls_anon_server_credentials_t
-                                         sc)
+                                          sc)
 {
 
   MHD_gnutls_free (sc);
@@ -80,7 +80,7 @@ int
   **/
 void
 MHD__gnutls_anon_free_client_credentials (MHD_gtls_anon_client_credentials_t
-                                         sc)
+                                          sc)
 {
 }
 
@@ -116,7 +116,7 @@ int
   **/
 void
 MHD__gnutls_anon_set_server_dh_params (MHD_gtls_anon_server_credentials_t res,
-                                      MHD_gtls_dh_params_t dh_params)
+                                       MHD_gtls_dh_params_t dh_params)
 {
   res->dh_params = dh_params;
 }
@@ -131,9 +131,8 @@ MHD__gnutls_anon_set_server_dh_params (MHD_gtls_anon_server_credentials_t res,
   * callback should return zero on success.
   **/
 void
-MHD__gnutls_anon_set_server_params_function (MHD_gtls_anon_server_credentials_t
-                                            res,
-                                            MHD_gnutls_params_function * func)
+MHD__gnutls_anon_set_server_params_function
+  (MHD_gtls_anon_server_credentials_t res, MHD_gnutls_params_function * func)
 {
   res->params_func = func;
 }
diff --git a/src/daemon/https/tls/gnutls_auth.c b/src/daemon/https/tls/gnutls_auth.c
index b1e1abe7..6f14d9c8 100644
--- a/src/daemon/https/tls/gnutls_auth.c
+++ b/src/daemon/https/tls/gnutls_auth.c
@@ -91,7 +91,7 @@ MHD__gnutls_credentials_clear (MHD_gtls_session_t session)
   **/
 int
 MHD__gnutls_credentials_set (MHD_gtls_session_t session,
-                            enum MHD_GNUTLS_CredentialsType type, void *cred)
+                             enum MHD_GNUTLS_CredentialsType type, void *cred)
 {
   auth_cred_st *ccred = NULL, *pcred = NULL;
   int exists = 0;
@@ -170,8 +170,9 @@ MHD_gtls_auth_get_type (MHD_gtls_session_t session)
 
   return
     MHD_gtls_map_kx_get_cred (MHD_gtls_cipher_suite_get_kx_algo
-                              (&session->security_parameters.
-                               current_cipher_suite), server);
+                              (&session->
+                               security_parameters.current_cipher_suite),
+                              server);
 }
 
 /**
@@ -188,8 +189,8 @@ MHD_gtls_auth_server_get_type (MHD_gtls_session_t session)
 {
   return
     MHD_gtls_map_kx_get_cred (MHD_gtls_cipher_suite_get_kx_algo
-                              (&session->security_parameters.
-                               current_cipher_suite), 1);
+                              (&session->
+                               security_parameters.current_cipher_suite), 1);
 }
 
 /**
@@ -206,8 +207,8 @@ MHD_gtls_auth_client_get_type (MHD_gtls_session_t session)
 {
   return
     MHD_gtls_map_kx_get_cred (MHD_gtls_cipher_suite_get_kx_algo
-                              (&session->security_parameters.
-                               current_cipher_suite), 0);
+                              (&session->
+                               security_parameters.current_cipher_suite), 0);
 }
 
 
diff --git a/src/daemon/https/tls/gnutls_buffers.c b/src/daemon/https/tls/gnutls_buffers.c
index 0a0f367b..8c6bb750 100644
--- a/src/daemon/https/tls/gnutls_buffers.c
+++ b/src/daemon/https/tls/gnutls_buffers.c
@@ -137,19 +137,19 @@ MHD_gnutls_record_buffer_put (content_type_t type,
     case GNUTLS_APPLICATION_DATA:
       buf = &session->internals.application_data_buffer;
       MHD__gnutls_buffers_log ("BUF[REC]: Inserted %d bytes of Data(%d)\n",
-                           length, type);
+                               length, type);
       break;
 
     case GNUTLS_HANDSHAKE:
       buf = &session->internals.handshake_data_buffer;
       MHD__gnutls_buffers_log ("BUF[HSK]: Inserted %d bytes of Data(%d)\n",
-                           length, type);
+                               length, type);
       break;
 
     case GNUTLS_INNER_APPLICATION:
       buf = &session->internals.ia_data_buffer;
-      MHD__gnutls_buffers_log ("BUF[IA]: Inserted %d bytes of Data(%d)\n", length,
-                           type);
+      MHD__gnutls_buffers_log ("BUF[IA]: Inserted %d bytes of Data(%d)\n",
+                               length, type);
       break;
 
     default:
@@ -223,7 +223,7 @@ MHD_gtls_record_buffer_get (content_type_t type, MHD_gtls_session_t session,
         }
 
       MHD__gnutls_buffers_log ("BUFFER[REC][AD]: Read %d bytes of Data(%d)\n",
-                           length, type);
+                               length, type);
 
       session->internals.application_data_buffer.length -= length;
       memcpy (data, session->internals.application_data_buffer.data, length);
@@ -246,7 +246,7 @@ MHD_gtls_record_buffer_get (content_type_t type, MHD_gtls_session_t session,
         }
 
       MHD__gnutls_buffers_log ("BUF[REC][HD]: Read %d bytes of Data(%d)\n",
-                           length, type);
+                               length, type);
 
       session->internals.handshake_data_buffer.length -= length;
       memcpy (data, session->internals.handshake_data_buffer.data, length);
@@ -263,7 +263,7 @@ MHD_gtls_record_buffer_get (content_type_t type, MHD_gtls_session_t session,
         length = session->internals.ia_data_buffer.length;
 
       MHD__gnutls_buffers_log ("BUF[REC][IA]: Read %d bytes of Data(%d)\n",
-                           length, type);
+                               length, type);
 
       session->internals.ia_data_buffer.length -= length;
       memcpy (data, session->internals.ia_data_buffer.data, length);
@@ -290,7 +290,7 @@ MHD_gtls_record_buffer_get (content_type_t type, MHD_gtls_session_t session,
  */
 static ssize_t
 MHD__gnutls_read (MHD_gtls_session_t session, void *iptr,
-              size_t sizeOfPtr, int flags)
+                  size_t sizeOfPtr, int flags)
 {
   size_t left;
   ssize_t i = 0;
@@ -333,16 +333,17 @@ MHD__gnutls_read (MHD_gtls_session_t session, void *iptr,
         }
       else
         i = session->internals.MHD__gnutls_pull_func (fd,
-                                                  &ptr[sizeOfPtr - left],
-                                                  left);
+                                                      &ptr[sizeOfPtr - left],
+                                                      left);
 
       if (i < 0)
         {
           int err = session->internals.errnum ? session->internals.errnum
             : errno;
 
-          MHD__gnutls_read_log ("READ: %d returned from %d, errno=%d gerrno=%d\n",
-                            i, fd, errno, session->internals.errnum);
+          MHD__gnutls_read_log
+            ("READ: %d returned from %d, errno=%d gerrno=%d\n", i, fd, errno,
+             session->internals.errnum);
 
           if (err == EAGAIN || err == EINTR)
             {
@@ -350,7 +351,7 @@ MHD__gnutls_read (MHD_gtls_session_t session, void *iptr,
                 {
 
                   MHD__gnutls_read_log ("READ: returning %d bytes from %d\n",
-                                    sizeOfPtr - left, fd);
+                                        sizeOfPtr - left, fd);
 
                   goto finish;
                 }
@@ -386,8 +387,8 @@ finish:
       char line[128];
       char tmp[16];
 
-      MHD__gnutls_read_log ("READ: read %d bytes from %d\n", (sizeOfPtr - left),
-                        fd);
+      MHD__gnutls_read_log ("READ: read %d bytes from %d\n",
+                            (sizeOfPtr - left), fd);
 
       for (x = 0; x < ((sizeOfPtr - left) / 16) + 1; x++)
         {
@@ -486,7 +487,7 @@ MHD_gtls_io_read_buffered (MHD_gtls_session_t session, opaque ** iptr,
 
   if (sizeOfPtr > MAX_RECV_SIZE || sizeOfPtr == 0)
     {
-      MHD_gnutls_assert ();         /* internal error */
+      MHD_gnutls_assert ();     /* internal error */
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -536,7 +537,7 @@ MHD_gtls_io_read_buffered (MHD_gtls_session_t session, opaque ** iptr,
   if ((session->internals.record_recv_buffer.length + recvdata)
       > MAX_RECV_SIZE)
     {
-      MHD_gnutls_assert ();         /* internal error */
+      MHD_gnutls_assert ();     /* internal error */
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -559,7 +560,8 @@ MHD_gtls_io_read_buffered (MHD_gtls_session_t session, opaque ** iptr,
   /* READ DATA - but leave RCVLOWAT bytes in the kernel buffer. */
   if (recvdata - recvlowat > 0)
     {
-      ret = MHD__gnutls_read (session, &buf[buf_pos], recvdata - recvlowat, 0);
+      ret =
+        MHD__gnutls_read (session, &buf[buf_pos], recvdata - recvlowat, 0);
 
       /* return immediately if we got an interrupt or eagain
        * error.
@@ -574,8 +576,9 @@ MHD_gtls_io_read_buffered (MHD_gtls_session_t session, opaque ** iptr,
    */
   if (ret > 0)
     {
-      MHD__gnutls_read_log ("RB: Have %d bytes into buffer. Adding %d bytes.\n",
-                        session->internals.record_recv_buffer.length, ret);
+      MHD__gnutls_read_log
+        ("RB: Have %d bytes into buffer. Adding %d bytes.\n",
+         session->internals.record_recv_buffer.length, ret);
       MHD__gnutls_read_log ("RB: Requested %d bytes\n", sizeOfPtr);
       session->internals.record_recv_buffer.length += ret;
     }
@@ -598,7 +601,8 @@ MHD_gtls_io_read_buffered (MHD_gtls_session_t session, opaque ** iptr,
 
       if (ret2 > 0)
         {
-          MHD__gnutls_read_log ("RB-PEEK: Read %d bytes in PEEK MODE.\n", ret2);
+          MHD__gnutls_read_log ("RB-PEEK: Read %d bytes in PEEK MODE.\n",
+                                ret2);
           MHD__gnutls_read_log
             ("RB-PEEK: Have %d bytes into buffer. Adding %d bytes.\nRB: Requested %d bytes\n",
              session->internals.record_recv_buffer.length, ret2, sizeOfPtr);
@@ -652,7 +656,7 @@ MHD_gtls_io_read_buffered (MHD_gtls_session_t session, opaque ** iptr,
 
 inline static int
 MHD__gnutls_buffer_insert (MHD_gtls_buffer * buffer,
-                       const opaque * _data, size_t data_size)
+                           const opaque * _data, size_t data_size)
 {
 
   if ((MEMSUB (_data, buffer->data) >= 0)
@@ -691,7 +695,7 @@ MHD__gnutls_buffer_insert (MHD_gtls_buffer * buffer,
 
 inline static int
 MHD__gnutls_buffer_get (MHD_gtls_buffer * buffer,
-                    const opaque ** ptr, size_t * ptr_size)
+                        const opaque ** ptr, size_t * ptr_size)
 {
   *ptr_size = buffer->length;
   *ptr = buffer->data;
@@ -742,7 +746,8 @@ MHD_gtls_io_write_buffered (MHD_gtls_session_t session,
   if (iptr == NULL)
     {
       /* checking is handled above */
-      ret = MHD__gnutls_buffer_get (&session->internals.record_send_buffer, &ptr,
+      ret =
+        MHD__gnutls_buffer_get (&session->internals.record_send_buffer, &ptr,
                                 &n);
       if (ret < 0)
         {
@@ -750,8 +755,8 @@ MHD_gtls_io_write_buffered (MHD_gtls_session_t session,
           return ret;
         }
 
-      MHD__gnutls_write_log ("WRITE: Restoring old write. (%d bytes to send)\n",
-                         n);
+      MHD__gnutls_write_log
+        ("WRITE: Restoring old write. (%d bytes to send)\n", n);
     }
 
   MHD__gnutls_write_log ("WRITE: Will write %d bytes to %d.\n", n, fd);
@@ -789,7 +794,8 @@ MHD_gtls_io_write_buffered (MHD_gtls_session_t session,
 #endif
         }
       else
-        i = session->internals.MHD__gnutls_push_func (fd, &ptr[n - left], left);
+        i =
+          session->internals.MHD__gnutls_push_func (fd, &ptr[n - left], left);
 
       if (i == -1)
         {
@@ -801,8 +807,9 @@ MHD_gtls_io_write_buffered (MHD_gtls_session_t session,
               session->internals.record_send_buffer_prev_size += n - left;
 
               retval =
-                MHD__gnutls_buffer_insert (&session->internals.record_send_buffer,
-                                       &ptr[n - left], left);
+                MHD__gnutls_buffer_insert (&session->internals.
+                                           record_send_buffer, &ptr[n - left],
+                                           left);
               if (retval < 0)
                 {
                   MHD_gnutls_assert ();
@@ -881,7 +888,7 @@ MHD_gtls_io_write_flush (MHD_gtls_session_t session)
 
   ret = MHD_gtls_io_write_buffered (session, NULL, 0);
   MHD__gnutls_write_log ("WRITE FLUSH: %d [buffer: %d]\n", ret,
-                     session->internals.record_send_buffer.length);
+                         session->internals.record_send_buffer.length);
 
   return ret;
 }
@@ -935,7 +942,7 @@ MHD_gtls_handshake_io_send_int (MHD_gtls_session_t session,
        */
       MHD_gnutls_assert ();
       ret = MHD__gnutls_buffer_get (&session->internals.handshake_send_buffer,
-                                &ptr, &n);
+                                    &ptr, &n);
       if (ret < 0)
         {
           MHD_gnutls_assert ();
@@ -957,7 +964,7 @@ MHD_gtls_handshake_io_send_int (MHD_gtls_session_t session,
       size_t sum = 0, x, j;
 
       MHD__gnutls_write_log ("HWRITE: will write %d bytes to %d.\n", n,
-                         MHD_gnutls_transport_get_ptr (session));
+                             MHD_gnutls_transport_get_ptr (session));
       for (x = 0; x < ((n) / 16) + 1; x++)
         {
           if (sum > n)
@@ -968,7 +975,8 @@ MHD_gtls_handshake_io_send_int (MHD_gtls_session_t session,
             {
               if (sum < n)
                 {
-                  MHD__gnutls_write_log ("%.2x ", ((unsigned char *) ptr)[sum++]);
+                  MHD__gnutls_write_log ("%.2x ",
+                                         ((unsigned char *) ptr)[sum++]);
                 }
               else
                 break;
@@ -1009,9 +1017,9 @@ MHD_gtls_handshake_io_send_int (MHD_gtls_session_t session,
               MHD_gnutls_assert ();
 
               retval =
-                MHD__gnutls_buffer_insert (&session->internals.
-                                       handshake_send_buffer, &ptr[n - left],
-                                       left);
+                MHD__gnutls_buffer_insert (&session->
+                                           internals.handshake_send_buffer,
+                                           &ptr[n - left], left);
               if (retval < 0)
                 {
                   MHD_gnutls_assert ();
@@ -1112,8 +1120,9 @@ MHD_gtls_handshake_io_recv_int (MHD_gtls_session_t session,
 
               session->internals.handshake_recv_buffer.data
                 =
-                MHD_gtls_realloc_fast (session->internals.
-                                       handshake_recv_buffer.data, dsize);
+                MHD_gtls_realloc_fast (session->
+                                       internals.handshake_recv_buffer.data,
+                                       dsize);
               if (session->internals.handshake_recv_buffer.data == NULL)
                 {
                   MHD_gnutls_assert ();
@@ -1164,13 +1173,9 @@ MHD_gtls_handshake_buffer_put (MHD_gtls_session_t session, opaque * data,
 
   if ((session->internals.max_handshake_data_buffer_size > 0) && ((length
                                                                    +
-                                                                   session->
-                                                                   internals.
-                                                                   handshake_hash_buffer.
-                                                                   length) >
-                                                                  session->
-                                                                  internals.
-                                                                  max_handshake_data_buffer_size))
+                                                                   session->internals.handshake_hash_buffer.length)
+                                                                  >
+                                                                  session->internals.max_handshake_data_buffer_size))
     {
       MHD_gnutls_assert ();
       return GNUTLS_E_MEMORY_ERROR;
@@ -1224,7 +1229,7 @@ MHD_gtls_handshake_buffer_get_ptr (MHD_gtls_session_t session,
     *length = session->internals.handshake_hash_buffer.length;
 
   MHD__gnutls_buffers_log ("BUF[HSK]: Peeked %d bytes of Data\n",
-                       session->internals.handshake_hash_buffer.length);
+                           session->internals.handshake_hash_buffer.length);
 
   if (data_ptr != NULL)
     *data_ptr = session->internals.handshake_hash_buffer.data;
diff --git a/src/daemon/https/tls/gnutls_cert.c b/src/daemon/https/tls/gnutls_cert.c
index 45e001d6..d01d3918 100644
--- a/src/daemon/https/tls/gnutls_cert.c
+++ b/src/daemon/https/tls/gnutls_cert.c
@@ -210,7 +210,7 @@ MHD__gnutls_certificate_free_credentials (MHD_gtls_cert_credentials_t sc)
   **/
 int
 MHD__gnutls_certificate_allocate_credentials (MHD_gtls_cert_credentials_t *
-                                             res)
+                                              res)
 {
   *res = MHD_gnutls_calloc (1, sizeof (MHD_gtls_cert_credentials_st));
 
@@ -271,7 +271,8 @@ MHD_gtls_selected_cert_supported_kx (MHD_gtls_session_t session,
       return GNUTLS_E_INVALID_REQUEST;
     }
 
-  *alg = MHD_gnutls_calloc (1, sizeof (enum MHD_GNUTLS_KeyExchangeAlgorithm) * i);
+  *alg =
+    MHD_gnutls_calloc (1, sizeof (enum MHD_GNUTLS_KeyExchangeAlgorithm) * i);
   if (*alg == NULL)
     return GNUTLS_E_MEMORY_ERROR;
 
@@ -550,8 +551,9 @@ MHD_gtls_certificate_expiration_time_peers (MHD_gtls_session_t session)
     {
     case MHD_GNUTLS_CRT_X509:
       return
-        MHD__gnutls_x509_get_raw_crt_expiration_time (&info->raw_certificate_list
-                                                  [0]);
+        MHD__gnutls_x509_get_raw_crt_expiration_time (&info->
+                                                      raw_certificate_list
+                                                      [0]);
     default:
       return (time_t) - 1;
     }
@@ -589,8 +591,9 @@ MHD_gtls_certificate_activation_time_peers (MHD_gtls_session_t session)
     {
     case MHD_GNUTLS_CRT_X509:
       return
-        MHD__gnutls_x509_get_raw_crt_activation_time (&info->raw_certificate_list
-                                                  [0]);
+        MHD__gnutls_x509_get_raw_crt_activation_time (&info->
+                                                      raw_certificate_list
+                                                      [0]);
     default:
       return (time_t) - 1;
     }
@@ -695,7 +698,8 @@ MHD_gtls_x509_crt_to_gcert (MHD_gnutls_cert * gcert,
         }
 
       ret =
-        MHD_gnutls_x509_crt_export (cert, GNUTLS_X509_FMT_DER, der, &der_size);
+        MHD_gnutls_x509_crt_export (cert, GNUTLS_X509_FMT_DER, der,
+                                    &der_size);
       if (ret < 0 && ret != GNUTLS_E_SHORT_MEMORY_BUFFER)
         {
           MHD_gnutls_assert ();
@@ -714,7 +718,7 @@ MHD_gtls_x509_crt_to_gcert (MHD_gnutls_cert * gcert,
 
           ret =
             MHD_gnutls_x509_crt_export (cert, GNUTLS_X509_FMT_DER, der,
-                                    &der_size);
+                                        &der_size);
           if (ret < 0)
             {
               MHD_gnutls_assert ();
@@ -736,13 +740,15 @@ MHD_gtls_x509_crt_to_gcert (MHD_gnutls_cert * gcert,
       MHD_gnutls_x509_crt_get_key_usage (cert, &gcert->key_usage, NULL);
       gcert->version = MHD_gnutls_x509_crt_get_version (cert);
     }
-  gcert->subject_pk_algorithm = MHD_gnutls_x509_crt_get_pk_algorithm (cert, NULL);
+  gcert->subject_pk_algorithm =
+    MHD_gnutls_x509_crt_get_pk_algorithm (cert, NULL);
 
   if (flags & CERT_ONLY_PUBKEY || flags == 0)
     {
       gcert->params_size = MAX_PUBLIC_PARAMS_SIZE;
       ret =
-        MHD__gnutls_x509_crt_get_mpis (cert, gcert->params, &gcert->params_size);
+        MHD__gnutls_x509_crt_get_mpis (cert, gcert->params,
+                                       &gcert->params_size);
       if (ret < 0)
         {
           MHD_gnutls_assert ();
diff --git a/src/daemon/https/tls/gnutls_cert.h b/src/daemon/https/tls/gnutls_cert.h
index b759fca5..ee3b3ca8 100644
--- a/src/daemon/https/tls/gnutls_cert.h
+++ b/src/daemon/https/tls/gnutls_cert.h
@@ -110,7 +110,8 @@ typedef enum ConvFlags
 int MHD_gtls_x509_raw_cert_to_gcert (MHD_gnutls_cert * gcert,
                                      const MHD_gnutls_datum_t * derCert,
                                      int flags);
-int MHD_gtls_x509_crt_to_gcert (MHD_gnutls_cert * gcert, MHD_gnutls_x509_crt_t cert,
+int MHD_gtls_x509_crt_to_gcert (MHD_gnutls_cert * gcert,
+                                MHD_gnutls_x509_crt_t cert,
                                 unsigned int flags);
 
 void MHD_gtls_gkey_deinit (MHD_gnutls_privkey * key);
diff --git a/src/daemon/https/tls/gnutls_cipher.c b/src/daemon/https/tls/gnutls_cipher.c
index 9ff19759..757fd06d 100644
--- a/src/daemon/https/tls/gnutls_cipher.c
+++ b/src/daemon/https/tls/gnutls_cipher.c
@@ -244,7 +244,7 @@ calc_enc_length (MHD_gtls_session_t session, int data_size,
 
       break;
     case CIPHER_BLOCK:
-      if (MHD_gc_nonce ((char*) &rnd, 1) != GC_OK)
+      if (MHD_gc_nonce ((char *) &rnd, 1) != GC_OK)
         {
           MHD_gnutls_assert ();
           return GNUTLS_E_RANDOM_FAILED;
@@ -302,15 +302,15 @@ MHD_gtls_compressed2ciphertext (MHD_gtls_session_t session,
   uint8_t type = _type;
   uint8_t major, minor;
   int hash_size =
-    MHD_gnutls_hash_get_algo_len (session->security_parameters.
-                                  write_mac_algorithm);
+    MHD_gnutls_hash_get_algo_len (session->
+                                  security_parameters.write_mac_algorithm);
   enum MHD_GNUTLS_Protocol ver;
   int blocksize =
-    MHD_gtls_cipher_get_block_size (session->security_parameters.
-                                    write_bulk_cipher_algorithm);
+    MHD_gtls_cipher_get_block_size (session->
+                                    security_parameters.write_bulk_cipher_algorithm);
   cipher_type_t block_algo =
-    MHD_gtls_cipher_is_block (session->security_parameters.
-                              write_bulk_cipher_algorithm);
+    MHD_gtls_cipher_is_block (session->
+                              security_parameters.write_bulk_cipher_algorithm);
   opaque *data_ptr;
 
 
@@ -337,8 +337,9 @@ MHD_gtls_compressed2ciphertext (MHD_gtls_session_t session,
   if (td != GNUTLS_MAC_FAILED)
     {                           /* actually when the algorithm in not the NULL one */
       MHD_gnutls_hash (td,
-                       UINT64DATA (session->connection_state.
-                                   write_sequence_number), 8);
+                       UINT64DATA (session->
+                                   connection_state.write_sequence_number),
+                       8);
 
       MHD_gnutls_hash (td, &type, 1);
       if (ver >= MHD_GNUTLS_PROTOCOL_TLS1_0)
@@ -377,7 +378,7 @@ MHD_gtls_compressed2ciphertext (MHD_gtls_session_t session,
     {
       /* copy the random IV.
        */
-      if (MHD_gc_nonce ((char*) data_ptr, blocksize) != GC_OK)
+      if (MHD_gc_nonce ((char *) data_ptr, blocksize) != GC_OK)
         {
           MHD_gnutls_assert ();
           return GNUTLS_E_RANDOM_FAILED;
@@ -432,16 +433,16 @@ MHD_gtls_ciphertext2compressed (MHD_gtls_session_t session,
   uint8_t major, minor;
   enum MHD_GNUTLS_Protocol ver;
   int hash_size =
-    MHD_gnutls_hash_get_algo_len (session->security_parameters.
-                                  read_mac_algorithm);
+    MHD_gnutls_hash_get_algo_len (session->
+                                  security_parameters.read_mac_algorithm);
 
   ver = MHD__gnutls_protocol_get_version (session);
   minor = MHD_gtls_version_get_minor (ver);
   major = MHD_gtls_version_get_major (ver);
 
   blocksize =
-    MHD_gtls_cipher_get_block_size (session->security_parameters.
-                                    read_bulk_cipher_algorithm);
+    MHD_gtls_cipher_get_block_size (session->
+                                    security_parameters.read_bulk_cipher_algorithm);
 
   /* initialize MAC
    */
@@ -465,9 +466,9 @@ MHD_gtls_ciphertext2compressed (MHD_gtls_session_t session,
     {
     case CIPHER_STREAM:
       if ((ret =
-           MHD_gtls_cipher_decrypt (session->connection_state.
-                                    read_cipher_state, ciphertext.data,
-                                    ciphertext.size)) < 0)
+           MHD_gtls_cipher_decrypt (session->
+                                    connection_state.read_cipher_state,
+                                    ciphertext.data, ciphertext.size)) < 0)
         {
           MHD_gnutls_assert ();
           return ret;
@@ -484,9 +485,9 @@ MHD_gtls_ciphertext2compressed (MHD_gtls_session_t session,
         }
 
       if ((ret =
-           MHD_gtls_cipher_decrypt (session->connection_state.
-                                    read_cipher_state, ciphertext.data,
-                                    ciphertext.size)) < 0)
+           MHD_gtls_cipher_decrypt (session->
+                                    connection_state.read_cipher_state,
+                                    ciphertext.data, ciphertext.size)) < 0)
         {
           MHD_gnutls_assert ();
           return ret;
@@ -544,8 +545,8 @@ MHD_gtls_ciphertext2compressed (MHD_gtls_session_t session,
   if (td != GNUTLS_MAC_FAILED)
     {
       MHD_gnutls_hash (td,
-                       UINT64DATA (session->connection_state.
-                                   read_sequence_number), 8);
+                       UINT64DATA (session->
+                                   connection_state.read_sequence_number), 8);
 
       MHD_gnutls_hash (td, &type, 1);
       if (ver >= MHD_GNUTLS_PROTOCOL_TLS1_0)
diff --git a/src/daemon/https/tls/gnutls_cipher.h b/src/daemon/https/tls/gnutls_cipher.h
index ab86d380..b8dc0070 100644
--- a/src/daemon/https/tls/gnutls_cipher.h
+++ b/src/daemon/https/tls/gnutls_cipher.h
@@ -37,4 +37,5 @@ int MHD_gtls_compressed2ciphertext (MHD_gtls_session_t session,
                                     content_type_t _type, int random_pad);
 int MHD_gtls_ciphertext2compressed (MHD_gtls_session_t session,
                                     opaque * compress_data, int compress_size,
-                                    MHD_gnutls_datum_t ciphertext, uint8_t type);
+                                    MHD_gnutls_datum_t ciphertext,
+                                    uint8_t type);
diff --git a/src/daemon/https/tls/gnutls_cipher_int.c b/src/daemon/https/tls/gnutls_cipher_int.c
index 21fda10c..9861fab1 100644
--- a/src/daemon/https/tls/gnutls_cipher_int.c
+++ b/src/daemon/https/tls/gnutls_cipher_int.c
@@ -29,7 +29,8 @@
 
 cipher_hd_t
 MHD_gtls_cipher_init (enum MHD_GNUTLS_CipherAlgorithm cipher,
-                      const MHD_gnutls_datum_t * key, const MHD_gnutls_datum_t * iv)
+                      const MHD_gnutls_datum_t * key,
+                      const MHD_gnutls_datum_t * iv)
 {
   cipher_hd_t ret = NULL;
   int err = GC_INVALID_CIPHER;  /* doesn't matter */
@@ -80,9 +81,9 @@ MHD_gtls_cipher_init (enum MHD_GNUTLS_CipherAlgorithm cipher,
 
   if (err == 0)
     {
-      MHD_gc_cipher_setkey (ret, key->size, (const char*) key->data);
+      MHD_gc_cipher_setkey (ret, key->size, (const char *) key->data);
       if (iv->data != NULL && iv->size > 0)
-        MHD_gc_cipher_setiv (ret, iv->size, (const char*) iv->data);
+        MHD_gc_cipher_setiv (ret, iv->size, (const char *) iv->data);
     }
   else if (cipher != MHD_GNUTLS_CIPHER_NULL)
     {
@@ -114,7 +115,8 @@ MHD_gtls_cipher_decrypt (cipher_hd_t handle, void *ciphertext,
 {
   if (handle != GNUTLS_CIPHER_FAILED)
     {
-      if (MHD_gc_cipher_decrypt_inline (handle, ciphertextlen, ciphertext) != 0)
+      if (MHD_gc_cipher_decrypt_inline (handle, ciphertextlen, ciphertext) !=
+          0)
         {
           MHD_gnutls_assert ();
           return GNUTLS_E_INTERNAL_ERROR;
diff --git a/src/daemon/https/tls/gnutls_compress.c b/src/daemon/https/tls/gnutls_compress.c
index 9552a72a..3fc4f41c 100644
--- a/src/daemon/https/tls/gnutls_compress.c
+++ b/src/daemon/https/tls/gnutls_compress.c
@@ -35,8 +35,8 @@
  */
 int
 MHD__gnutls_m_plaintext2compressed (MHD_gtls_session_t session,
-                                MHD_gnutls_datum_t * compressed,
-                                const MHD_gnutls_datum_t * plaintext)
+                                    MHD_gnutls_datum_t * compressed,
+                                    const MHD_gnutls_datum_t * plaintext)
 {
   int size;
   opaque *data;
@@ -58,8 +58,8 @@ MHD__gnutls_m_plaintext2compressed (MHD_gtls_session_t session,
 
 int
 MHD__gnutls_m_compressed2plaintext (MHD_gtls_session_t session,
-                                MHD_gnutls_datum_t * plain,
-                                const MHD_gnutls_datum_t * compressed)
+                                    MHD_gnutls_datum_t * plain,
+                                    const MHD_gnutls_datum_t * compressed)
 {
   int size;
   opaque *data;
diff --git a/src/daemon/https/tls/gnutls_compress.h b/src/daemon/https/tls/gnutls_compress.h
index c950e95d..c7a95c8b 100644
--- a/src/daemon/https/tls/gnutls_compress.h
+++ b/src/daemon/https/tls/gnutls_compress.h
@@ -23,8 +23,9 @@
  */
 
 int MHD__gnutls_m_plaintext2compressed (MHD_gtls_session_t session,
-                                    MHD_gnutls_datum_t * compressed,
-                                    const MHD_gnutls_datum_t * plaintext);
+                                        MHD_gnutls_datum_t * compressed,
+                                        const MHD_gnutls_datum_t * plaintext);
 int MHD__gnutls_m_compressed2plaintext (MHD_gtls_session_t session,
-                                    MHD_gnutls_datum_t * plain,
-                                    const MHD_gnutls_datum_t * compressed);
+                                        MHD_gnutls_datum_t * plain,
+                                        const MHD_gnutls_datum_t *
+                                        compressed);
diff --git a/src/daemon/https/tls/gnutls_compress_int.c b/src/daemon/https/tls/gnutls_compress_int.c
index 07ffd5e1..2006f8e6 100644
--- a/src/daemon/https/tls/gnutls_compress_int.c
+++ b/src/daemon/https/tls/gnutls_compress_int.c
@@ -52,7 +52,7 @@ MHD_gtls_comp_init (enum MHD_GNUTLS_CompressionMethod method, int d)
       {
         int window_bits, mem_level;
         int comp_level;
-        int err;
+        int err;
         z_stream *zhandle;
 
         window_bits = MHD_gtls_compression_get_wbits (method);
@@ -74,10 +74,10 @@ MHD_gtls_comp_init (enum MHD_GNUTLS_CompressionMethod method, int d)
 
         if (d)
           err = inflateInit2 (zhandle, window_bits);
-        else          
-          err = deflateInit2 (zhandle,
-                              comp_level, Z_DEFLATED,
-                              window_bits, mem_level, Z_DEFAULT_STRATEGY);          
+        else
+          err = deflateInit2 (zhandle,
+                              comp_level, Z_DEFLATED,
+                              window_bits, mem_level, Z_DEFAULT_STRATEGY);
         if (err != Z_OK)
           {
             MHD_gnutls_assert ();
@@ -111,7 +111,7 @@ MHD_gtls_comp_deinit (comp_hd_t handle, int d)
       switch (handle->algo)
         {
 #ifdef HAVE_LIBZ
-          int err;
+          int err;
         case MHD_GNUTLS_COMP_DEFLATE:
           if (d)
             err = inflateEnd (handle->handle);
@@ -154,7 +154,7 @@ MHD_gtls_compress (comp_hd_t handle, const opaque * plain,
       {
         uLongf size;
         z_stream *zhandle;
-        int err;
+        int err;
 
         size = (plain_size + plain_size) + 10;
         *compressed = MHD_gnutls_malloc (size);
@@ -192,7 +192,8 @@ MHD_gtls_compress (comp_hd_t handle, const opaque * plain,
 
 #ifdef COMPRESSION_DEBUG
   MHD__gnutls_debug_log ("Compression ratio: %f\n",
-                     (float) ((float) compressed_size / (float) plain_size));
+                         (float) ((float) compressed_size /
+                                  (float) plain_size));
 #endif
 
   if ((size_t) compressed_size > max_comp_size)
@@ -234,10 +235,10 @@ MHD_gtls_decompress (comp_hd_t handle, opaque * compressed,
 #ifdef HAVE_LIBZ
     case MHD_GNUTLS_COMP_DEFLATE:
       {
-        int err;
+        int err;
         uLongf out_size;
         z_stream *zhandle;
-        unsigned int cur_pos;
+        unsigned int cur_pos;
 
         *plain = NULL;
         out_size = compressed_size + compressed_size;
diff --git a/src/daemon/https/tls/gnutls_constate.c b/src/daemon/https/tls/gnutls_constate.c
index 41aff98c..11c8beca 100644
--- a/src/daemon/https/tls/gnutls_constate.c
+++ b/src/daemon/https/tls/gnutls_constate.c
@@ -57,7 +57,7 @@ static const int servwrite_length = sizeof (servwrite) - 1;
  */
 int
 MHD__gnutls_set_keys (MHD_gtls_session_t session, int hash_size, int IV_size,
-                  int key_size, int export_flag)
+                      int key_size, int export_flag)
 {
 
 /* FIXME: This function is too long
@@ -107,8 +107,9 @@ MHD__gnutls_set_keys (MHD_gtls_session_t session, int hash_size, int IV_size,
   else
     {                           /* TLS 1.0 */
       ret =
-        MHD_gtls_PRF (session, (const unsigned char*) session->security_parameters.master_secret,
-                      TLS_MASTER_SIZE, keyexp, keyexp_length,
+        MHD_gtls_PRF (session,
+                      (const unsigned char *) session->security_parameters.
+                      master_secret, TLS_MASTER_SIZE, keyexp, keyexp_length,
                       rnd, 2 * TLS_RANDOM_SIZE, block_size, key_block);
     }
 
@@ -120,8 +121,8 @@ MHD__gnutls_set_keys (MHD_gtls_session_t session, int hash_size, int IV_size,
     }
 
   MHD__gnutls_hard_log ("INT: KEY BLOCK[%d]: %s\n", block_size,
-                    MHD_gtls_bin2hex (key_block, block_size, buf,
-                                      sizeof (buf)));
+                        MHD_gtls_bin2hex (key_block, block_size, buf,
+                                          sizeof (buf)));
 
   pos = 0;
   if (hash_size > 0)
@@ -187,7 +188,8 @@ MHD__gnutls_set_keys (MHD_gtls_session_t session, int hash_size, int IV_size,
 
           /* generate the final keys */
 
-          if (session->security_parameters.version == MHD_GNUTLS_PROTOCOL_SSL3)
+          if (session->security_parameters.version ==
+              MHD_GNUTLS_PROTOCOL_SSL3)
             {                   /* SSL 3 */
               ret =
                 MHD_gnutls_ssl3_hash_md5 (&key_block[pos],
@@ -219,7 +221,8 @@ MHD__gnutls_set_keys (MHD_gtls_session_t session, int hash_size, int IV_size,
           client_write_key_size = EXPORT_FINAL_KEY_SIZE;
           pos += key_size;
 
-          if (session->security_parameters.version == MHD_GNUTLS_PROTOCOL_SSL3)
+          if (session->security_parameters.version ==
+              MHD_GNUTLS_PROTOCOL_SSL3)
             {                   /* SSL 3 */
               ret =
                 MHD_gnutls_ssl3_hash_md5 (&key_block[pos], key_size,
@@ -259,10 +262,10 @@ MHD__gnutls_set_keys (MHD_gtls_session_t session, int hash_size, int IV_size,
           return GNUTLS_E_MEMORY_ERROR;
         }
       MHD__gnutls_hard_log ("INT: CLIENT WRITE KEY [%d]: %s\n",
-                        client_write_key_size,
-                        MHD_gtls_bin2hex (client_write_key,
-                                          client_write_key_size, buf,
-                                          sizeof (buf)));
+                            client_write_key_size,
+                            MHD_gtls_bin2hex (client_write_key,
+                                              client_write_key_size, buf,
+                                              sizeof (buf)));
 
       if (MHD__gnutls_sset_datum
           (&session->cipher_specs.server_write_key,
@@ -275,10 +278,10 @@ MHD__gnutls_set_keys (MHD_gtls_session_t session, int hash_size, int IV_size,
         }
 
       MHD__gnutls_hard_log ("INT: SERVER WRITE KEY [%d]: %s\n",
-                        server_write_key_size,
-                        MHD_gtls_bin2hex (server_write_key,
-                                          server_write_key_size, buf,
-                                          sizeof (buf)));
+                            server_write_key_size,
+                            MHD_gtls_bin2hex (server_write_key,
+                                              server_write_key_size, buf,
+                                              sizeof (buf)));
 
       if (free_keys != 0)
         {
@@ -342,7 +345,7 @@ MHD__gnutls_set_keys (MHD_gtls_session_t session, int hash_size, int IV_size,
         }
       else
         {                       /* TLS 1.0 */
-          ret = MHD_gtls_PRF (session, (const unsigned char*) "", 0,
+          ret = MHD_gtls_PRF (session, (const unsigned char *) "", 0,
                               ivblock, ivblock_length, rrnd,
                               2 * TLS_RANDOM_SIZE, IV_size * 2, iv_block);
         }
@@ -400,7 +403,7 @@ MHD__gnutls_set_read_keys (MHD_gtls_session_t session)
   export_flag = MHD_gtls_cipher_get_export_flag (algo);
 
   return MHD__gnutls_set_keys (session, hash_size, IV_size, key_size,
-                           export_flag);
+                               export_flag);
 }
 
 int
@@ -421,7 +424,7 @@ MHD__gnutls_set_write_keys (MHD_gtls_session_t session)
   export_flag = MHD_gtls_cipher_get_export_flag (algo);
 
   return MHD__gnutls_set_keys (session, hash_size, IV_size, key_size,
-                           export_flag);
+                               export_flag);
 }
 
 #define CPY_COMMON dst->entity = src->entity; \
@@ -442,7 +445,8 @@ MHD__gnutls_set_write_keys (MHD_gtls_session_t session)
 
 static void
 MHD__gnutls_cpy_read_security_parameters (MHD_gtls_security_param_st *
-                                      dst, MHD_gtls_security_param_st * src)
+                                          dst,
+                                          MHD_gtls_security_param_st * src)
 {
   CPY_COMMON;
 
@@ -453,7 +457,8 @@ MHD__gnutls_cpy_read_security_parameters (MHD_gtls_security_param_st *
 
 static void
 MHD__gnutls_cpy_write_security_parameters (MHD_gtls_security_param_st *
-                                       dst, MHD_gtls_security_param_st * src)
+                                           dst,
+                                           MHD_gtls_security_param_st * src)
 {
   CPY_COMMON;
 
@@ -504,35 +509,35 @@ MHD_gtls_read_connection_state_init (MHD_gtls_session_t session)
     {
       rc = MHD_gtls_set_read_cipher (session,
                                      MHD_gtls_cipher_suite_get_cipher_algo
-                                     (&session->security_parameters.
-                                      current_cipher_suite));
+                                     (&session->
+                                      security_parameters.current_cipher_suite));
       if (rc < 0)
         return rc;
       rc = MHD_gtls_set_read_mac (session,
                                   MHD_gtls_cipher_suite_get_mac_algo
-                                  (&session->security_parameters.
-                                   current_cipher_suite));
+                                  (&session->
+                                   security_parameters.current_cipher_suite));
       if (rc < 0)
         return rc;
 
       rc = MHD_gtls_set_kx (session,
                             MHD_gtls_cipher_suite_get_kx_algo
-                            (&session->security_parameters.
-                             current_cipher_suite));
+                            (&session->
+                             security_parameters.current_cipher_suite));
       if (rc < 0)
         return rc;
 
       rc = MHD_gtls_set_read_compression (session,
-                                          session->internals.
-                                          compression_method);
+                                          session->
+                                          internals.compression_method);
       if (rc < 0)
         return rc;
     }
   else
     {                           /* RESUME_TRUE */
       MHD__gnutls_cpy_read_security_parameters (&session->security_parameters,
-                                            &session->internals.
-                                            resumed_security_parameters);
+                                                &session->
+                                                internals.resumed_security_parameters);
     }
 
 
@@ -541,10 +546,10 @@ MHD_gtls_read_connection_state_init (MHD_gtls_session_t session)
     return rc;
 
   MHD__gnutls_handshake_log ("HSK[%x]: Cipher Suite: %s\n",
-                         session,
-                         MHD_gtls_cipher_suite_get_name
-                         (&session->security_parameters.
-                          current_cipher_suite));
+                             session,
+                             MHD_gtls_cipher_suite_get_name
+                             (&session->
+                              security_parameters.current_cipher_suite));
 
   if (MHD_gtls_compression_is_ok
       (session->security_parameters.read_compression_algorithm) != 0)
@@ -574,8 +579,8 @@ MHD_gtls_read_connection_state_init (MHD_gtls_session_t session)
 
 
   mac_size =
-    MHD_gnutls_hash_get_algo_len (session->security_parameters.
-                                  read_mac_algorithm);
+    MHD_gnutls_hash_get_algo_len (session->
+                                  security_parameters.read_mac_algorithm);
 
   MHD__gnutls_handshake_log
     ("HSK[%x]: Initializing internal [read] cipher sessions\n", session);
@@ -586,8 +591,8 @@ MHD_gtls_read_connection_state_init (MHD_gtls_session_t session)
       /* initialize cipher session
        */
       session->connection_state.read_cipher_state =
-        MHD_gtls_cipher_init (session->security_parameters.
-                              read_bulk_cipher_algorithm,
+        MHD_gtls_cipher_init (session->
+                              security_parameters.read_bulk_cipher_algorithm,
                               &session->cipher_specs.client_write_key,
                               &session->cipher_specs.client_write_IV);
       if (session->connection_state.read_cipher_state == GNUTLS_CIPHER_FAILED
@@ -603,11 +608,10 @@ MHD_gtls_read_connection_state_init (MHD_gtls_session_t session)
        */
       if (mac_size > 0)
         {
-          if (MHD__gnutls_sset_datum (&session->connection_state.read_mac_secret,
-                                  session->cipher_specs.
-                                  client_write_mac_secret.data,
-                                  session->cipher_specs.
-                                  client_write_mac_secret.size) < 0)
+          if (MHD__gnutls_sset_datum
+              (&session->connection_state.read_mac_secret,
+               session->cipher_specs.client_write_mac_secret.data,
+               session->cipher_specs.client_write_mac_secret.size) < 0)
             {
               MHD_gnutls_assert ();
               return GNUTLS_E_MEMORY_ERROR;
@@ -619,8 +623,8 @@ MHD_gtls_read_connection_state_init (MHD_gtls_session_t session)
 #if MHD_DEBUG_TLS
     case GNUTLS_CLIENT:
       session->connection_state.read_cipher_state =
-        MHD_gtls_cipher_init (session->security_parameters.
-                              read_bulk_cipher_algorithm,
+        MHD_gtls_cipher_init (session->
+                              security_parameters.read_bulk_cipher_algorithm,
                               &session->cipher_specs.server_write_key,
                               &session->cipher_specs.server_write_IV);
 
@@ -638,11 +642,10 @@ MHD_gtls_read_connection_state_init (MHD_gtls_session_t session)
        */
       if (mac_size > 0)
         {
-          if (MHD__gnutls_sset_datum (&session->connection_state.read_mac_secret,
-                                  session->cipher_specs.
-                                  server_write_mac_secret.data,
-                                  session->cipher_specs.
-                                  server_write_mac_secret.size) < 0)
+          if (MHD__gnutls_sset_datum
+              (&session->connection_state.read_mac_secret,
+               session->cipher_specs.server_write_mac_secret.data,
+               session->cipher_specs.server_write_mac_secret.size) < 0)
             {
               MHD_gnutls_assert ();
               return GNUTLS_E_MEMORY_ERROR;
@@ -657,8 +660,8 @@ MHD_gtls_read_connection_state_init (MHD_gtls_session_t session)
     }
 
   session->connection_state.read_compression_state =
-    MHD_gtls_comp_init (session->security_parameters.
-                        read_compression_algorithm, 1);
+    MHD_gtls_comp_init (session->
+                        security_parameters.read_compression_algorithm, 1);
 
   if (session->connection_state.read_compression_state == GNUTLS_COMP_FAILED)
     {
@@ -689,35 +692,36 @@ MHD_gtls_write_connection_state_init (MHD_gtls_session_t session)
     {
       rc = MHD_gtls_set_write_cipher (session,
                                       MHD_gtls_cipher_suite_get_cipher_algo
-                                      (&session->security_parameters.
-                                       current_cipher_suite));
+                                      (&session->
+                                       security_parameters.current_cipher_suite));
       if (rc < 0)
         return rc;
       rc = MHD_gtls_set_write_mac (session,
                                    MHD_gtls_cipher_suite_get_mac_algo
-                                   (&session->security_parameters.
-                                    current_cipher_suite));
+                                   (&session->
+                                    security_parameters.current_cipher_suite));
       if (rc < 0)
         return rc;
 
       rc = MHD_gtls_set_kx (session,
                             MHD_gtls_cipher_suite_get_kx_algo
-                            (&session->security_parameters.
-                             current_cipher_suite));
+                            (&session->
+                             security_parameters.current_cipher_suite));
       if (rc < 0)
         return rc;
 
       rc = MHD_gtls_set_write_compression (session,
-                                           session->internals.
-                                           compression_method);
+                                           session->
+                                           internals.compression_method);
       if (rc < 0)
         return rc;
     }
   else
     {                           /* RESUME_TRUE */
-      MHD__gnutls_cpy_write_security_parameters (&session->security_parameters,
-                                             &session->internals.
-                                             resumed_security_parameters);
+      MHD__gnutls_cpy_write_security_parameters (&session->
+                                                 security_parameters,
+                                                 &session->
+                                                 internals.resumed_security_parameters);
     }
 
   rc = MHD__gnutls_set_write_keys (session);
@@ -725,9 +729,9 @@ MHD_gtls_write_connection_state_init (MHD_gtls_session_t session)
     return rc;
 
   MHD__gnutls_handshake_log ("HSK[%x]: Cipher Suite: %s\n", session,
-                         MHD_gtls_cipher_suite_get_name
-                         (&session->security_parameters.
-                          current_cipher_suite));
+                             MHD_gtls_cipher_suite_get_name
+                             (&session->
+                              security_parameters.current_cipher_suite));
 
   if (MHD_gtls_compression_is_ok
       (session->security_parameters.write_compression_algorithm) != 0)
@@ -758,8 +762,8 @@ MHD_gtls_write_connection_state_init (MHD_gtls_session_t session)
                           0);
 
   mac_size =
-    MHD_gnutls_hash_get_algo_len (session->security_parameters.
-                                  write_mac_algorithm);
+    MHD_gnutls_hash_get_algo_len (session->
+                                  security_parameters.write_mac_algorithm);
 
   MHD__gnutls_handshake_log
     ("HSK[%x]: Initializing internal [write] cipher sessions\n", session);
@@ -770,8 +774,8 @@ MHD_gtls_write_connection_state_init (MHD_gtls_session_t session)
       /* initialize cipher session
        */
       session->connection_state.write_cipher_state =
-        MHD_gtls_cipher_init (session->security_parameters.
-                              write_bulk_cipher_algorithm,
+        MHD_gtls_cipher_init (session->
+                              security_parameters.write_bulk_cipher_algorithm,
                               &session->cipher_specs.server_write_key,
                               &session->cipher_specs.server_write_IV);
 
@@ -790,11 +794,10 @@ MHD_gtls_write_connection_state_init (MHD_gtls_session_t session)
        */
       if (mac_size > 0)
         {
-          if (MHD__gnutls_sset_datum (&session->connection_state.write_mac_secret,
-                                  session->cipher_specs.
-                                  server_write_mac_secret.data,
-                                  session->cipher_specs.
-                                  server_write_mac_secret.size) < 0)
+          if (MHD__gnutls_sset_datum
+              (&session->connection_state.write_mac_secret,
+               session->cipher_specs.server_write_mac_secret.data,
+               session->cipher_specs.server_write_mac_secret.size) < 0)
             {
               MHD_gnutls_assert ();
               return GNUTLS_E_MEMORY_ERROR;
@@ -807,8 +810,8 @@ MHD_gtls_write_connection_state_init (MHD_gtls_session_t session)
 #if MHD_DEBUG_TLS
     case GNUTLS_CLIENT:
       session->connection_state.write_cipher_state =
-        MHD_gtls_cipher_init (session->security_parameters.
-                              write_bulk_cipher_algorithm,
+        MHD_gtls_cipher_init (session->
+                              security_parameters.write_bulk_cipher_algorithm,
                               &session->cipher_specs.client_write_key,
                               &session->cipher_specs.client_write_IV);
 
@@ -825,11 +828,10 @@ MHD_gtls_write_connection_state_init (MHD_gtls_session_t session)
        */
       if (mac_size > 0)
         {
-          if (MHD__gnutls_sset_datum (&session->connection_state.write_mac_secret,
-                                  session->cipher_specs.
-                                  client_write_mac_secret.data,
-                                  session->cipher_specs.
-                                  client_write_mac_secret.size) < 0)
+          if (MHD__gnutls_sset_datum
+              (&session->connection_state.write_mac_secret,
+               session->cipher_specs.client_write_mac_secret.data,
+               session->cipher_specs.client_write_mac_secret.size) < 0)
             {
               MHD_gnutls_assert ();
               return GNUTLS_E_MEMORY_ERROR;
@@ -845,8 +847,8 @@ MHD_gtls_write_connection_state_init (MHD_gtls_session_t session)
 
 
   session->connection_state.write_compression_state =
-    MHD_gtls_comp_init (session->security_parameters.
-                        write_compression_algorithm, 0);
+    MHD_gtls_comp_init (session->
+                        security_parameters.write_compression_algorithm, 0);
 
   if (session->connection_state.write_compression_state == GNUTLS_COMP_FAILED)
     {
diff --git a/src/daemon/https/tls/gnutls_datum.c b/src/daemon/https/tls/gnutls_datum.c
index e9a660a4..a62c4204 100644
--- a/src/daemon/https/tls/gnutls_datum.c
+++ b/src/daemon/https/tls/gnutls_datum.c
@@ -104,7 +104,8 @@ MHD_gtls_datum_append_m (MHD_gnutls_datum_t * dst, const void *data,
 }
 
 void
-MHD_gtls_free_datum_m (MHD_gnutls_datum_t * dat, MHD_gnutls_free_function gfree_func)
+MHD_gtls_free_datum_m (MHD_gnutls_datum_t * dat,
+                       MHD_gnutls_free_function gfree_func)
 {
   if (dat->data != NULL)
     gfree_func (dat->data);
diff --git a/src/daemon/https/tls/gnutls_datum.h b/src/daemon/https/tls/gnutls_datum.h
index 634d527e..3e787318 100644
--- a/src/daemon/https/tls/gnutls_datum.h
+++ b/src/daemon/https/tls/gnutls_datum.h
@@ -36,5 +36,6 @@ int MHD_gtls_datum_append_m (MHD_gnutls_datum_t * dat, const void *data,
                              size_t data_size, MHD_gnutls_realloc_function);
 #define MHD__gnutls_datum_append(x,y,z) MHD_gtls_datum_append_m(x,y,z, MHD_gnutls_realloc)
 
-void MHD_gtls_free_datum_m (MHD_gnutls_datum_t * dat, MHD_gnutls_free_function);
+void MHD_gtls_free_datum_m (MHD_gnutls_datum_t * dat,
+                            MHD_gnutls_free_function);
 #define MHD__gnutls_free_datum(x) MHD_gtls_free_datum_m(x, MHD_gnutls_free)
diff --git a/src/daemon/https/tls/gnutls_dh_primes.c b/src/daemon/https/tls/gnutls_dh_primes.c
index 83776c42..a25759b0 100644
--- a/src/daemon/https/tls/gnutls_dh_primes.c
+++ b/src/daemon/https/tls/gnutls_dh_primes.c
@@ -198,7 +198,7 @@ MHD__gnutls_dh_params_deinit (MHD_gtls_dh_params_t dh_params)
  **/
 int
 MHD__gnutls_dh_params_generate2 (MHD_gtls_dh_params_t params,
-                                unsigned int bits)
+                                 unsigned int bits)
 {
   int ret;
 
diff --git a/src/daemon/https/tls/gnutls_extensions.c b/src/daemon/https/tls/gnutls_extensions.c
index 1f9cf7d0..b8892324 100644
--- a/src/daemon/https/tls/gnutls_extensions.c
+++ b/src/daemon/https/tls/gnutls_extensions.c
@@ -154,9 +154,9 @@ MHD_gtls_parse_extensions (MHD_gtls_session_t session,
     for (i = 0; i < session->internals.extensions_sent_size; i++)
       {
         MHD__gnutls_debug_log ("EXT[%d]: expecting extension '%s'\n",
-                           session,
-                           MHD_gtls_extension_get_name
-                           (session->internals.extensions_sent[i]));
+                               session,
+                               MHD_gtls_extension_get_name
+                               (session->internals.extensions_sent[i]));
       }
 #endif
 
@@ -173,7 +173,7 @@ MHD_gtls_parse_extensions (MHD_gtls_session_t session,
       pos += 2;
 
       MHD__gnutls_debug_log ("EXT[%x]: Received extension '%s/%d'\n", session,
-                         MHD_gtls_extension_get_name (type), type);
+                             MHD_gtls_extension_get_name (type), type);
 
       if ((ret = MHD__gnutls_extension_list_check (session, type)) < 0)
         {
@@ -217,8 +217,9 @@ MHD__gnutls_extension_list_add (MHD_gtls_session_t session, uint16_t type)
     {
       if (session->internals.extensions_sent_size < MAX_EXT_TYPES)
         {
-          session->internals.extensions_sent[session->internals.
-                                             extensions_sent_size] = type;
+          session->internals.extensions_sent[session->
+                                             internals.extensions_sent_size] =
+            type;
           session->internals.extensions_sent_size++;
         }
       else
@@ -288,7 +289,7 @@ MHD_gtls_gen_extensions (MHD_gtls_session_t session, opaque * data,
           MHD__gnutls_extension_list_add (session, p->type);
 
           MHD__gnutls_debug_log ("EXT[%x]: Sending extension %s\n", session,
-                             MHD_gtls_extension_get_name (p->type));
+                                 MHD_gtls_extension_get_name (p->type));
         }
       else if (size < 0)
         {
diff --git a/src/daemon/https/tls/gnutls_global.c b/src/daemon/https/tls/gnutls_global.c
index 781d12fa..635b01eb 100644
--- a/src/daemon/https/tls/gnutls_global.c
+++ b/src/daemon/https/tls/gnutls_global.c
@@ -51,7 +51,7 @@ extern const ASN1_ARRAY_TYPE MHD_gnutlsMHD__asn1_tab[];
 extern const ASN1_ARRAY_TYPE MHD_pkix_asn1_tab[];
 
 LOG_FUNC MHD__gnutls_log_func;
-int MHD__gnutls_log_level = 0;      /* default log level */
+int MHD__gnutls_log_level = 0;  /* default log level */
 
 ASN1_TYPE MHD__gnutls_pkix1_asn;
 ASN1_TYPE MHD__gnutlsMHD__gnutls_asn;
@@ -148,7 +148,7 @@ MHD_gtls_global_set_mem_functions (MHD_gnutls_alloc_function alloc_func,
 #ifdef DEBUG
 static void
 MHD__gnutls_gcry_log_handler (void *dummy, int level,
-                          const char *fmt, va_list list)
+                              const char *fmt, va_list list)
 {
   MHD_gtls_log (level, fmt, list);
 }
@@ -213,7 +213,7 @@ MHD__gnutls_global_init (void)
     if (data.wVersion < requested)
       {
         MHD__gnutls_debug_log ("WSAStartup version check failed (%d < %d).\n",
-                           data.wVersion, requested);
+                               data.wVersion, requested);
         WSACleanup ();
         return GNUTLS_E_LIBRARY_VERSION_MISMATCH;
       }
@@ -245,9 +245,10 @@ MHD__gnutls_global_init (void)
         }
 
       /* for gcrypt in order to be able to allocate memory */
-      gcry_set_allocation_handler (MHD_gnutls_malloc, MHD_gnutls_secure_malloc,
-                                   MHD__gnutls_is_secure_memory, MHD_gnutls_realloc,
-                                   MHD_gnutls_free);
+      gcry_set_allocation_handler (MHD_gnutls_malloc,
+                                   MHD_gnutls_secure_malloc,
+                                   MHD__gnutls_is_secure_memory,
+                                   MHD_gnutls_realloc, MHD_gnutls_free);
 
       /* gcry_control (GCRYCTL_DISABLE_INTERNAL_LOCKING, NULL, 0); */
 
@@ -276,14 +277,17 @@ MHD__gnutls_global_init (void)
    * This should not deal with files in the final
    * version.
    */
-  res = MHD__asn1_array2tree (MHD_pkix_asn1_tab, &MHD__gnutls_pkix1_asn, NULL);
+  res =
+    MHD__asn1_array2tree (MHD_pkix_asn1_tab, &MHD__gnutls_pkix1_asn, NULL);
   if (res != ASN1_SUCCESS)
     {
       result = MHD_gtls_asn2err (res);
       return result;
     }
 
-  res = MHD__asn1_array2tree (MHD_gnutlsMHD__asn1_tab, &MHD__gnutlsMHD__gnutls_asn, NULL);
+  res =
+    MHD__asn1_array2tree (MHD_gnutlsMHD__asn1_tab,
+                          &MHD__gnutlsMHD__gnutls_asn, NULL);
   if (res != ASN1_SUCCESS)
     {
       MHD__asn1_delete_structure (&MHD__gnutls_pkix1_asn);
@@ -341,7 +345,7 @@ MHD__gnutls_global_deinit (void)
  **/
 void
 MHD__gnutls_transport_set_pull_function (MHD_gtls_session_t session,
-                                        MHD_gtls_pull_func pull_func)
+                                         MHD_gtls_pull_func pull_func)
 {
   session->internals.MHD__gnutls_pull_func = pull_func;
 }
@@ -362,7 +366,7 @@ MHD__gnutls_transport_set_pull_function (MHD_gtls_session_t session,
  **/
 void
 MHD__gnutls_transport_set_push_function (MHD_gtls_session_t session,
-                                        MHD_gtls_push_func push_func)
+                                         MHD_gtls_push_func push_func)
 {
   session->internals.MHD__gnutls_push_func = push_func;
 }
diff --git a/src/daemon/https/tls/gnutls_handshake.c b/src/daemon/https/tls/gnutls_handshake.c
index 84cb96cf..291ad03e 100644
--- a/src/daemon/https/tls/gnutls_handshake.c
+++ b/src/daemon/https/tls/gnutls_handshake.c
@@ -67,12 +67,13 @@
 
 
 static int MHD_gtls_remove_unwanted_ciphersuites (MHD_gtls_session_t session,
-                                           cipher_suite_st ** cipherSuites,
-                                           int numCipherSuites,
-                                           enum
-                                           MHD_GNUTLS_PublicKeyAlgorithm);
-static int MHD_gtls_server_select_suite (MHD_gtls_session_t session, opaque * data,
-                                  int datalen);
+                                                  cipher_suite_st **
+                                                  cipherSuites,
+                                                  int numCipherSuites,
+                                                  enum
+                                                  MHD_GNUTLS_PublicKeyAlgorithm);
+static int MHD_gtls_server_select_suite (MHD_gtls_session_t session,
+                                         opaque * data, int datalen);
 
 static int MHD_gtls_generate_session_id (opaque * session_id, uint8_t * len);
 
@@ -86,7 +87,7 @@ static int MHD_gtls_handshake_client (MHD_gtls_session_t session);
 
 
 static int MHD__gnutls_server_select_comp_method (MHD_gtls_session_t session,
-                                              opaque * data, int datalen);
+                                                  opaque * data, int datalen);
 
 
 /* Clears the handshake hash buffers and handles.
@@ -119,8 +120,8 @@ resume_copy_required_values (MHD_gtls_session_t session)
    * hello message.
    */
   memcpy (session->security_parameters.current_cipher_suite.suite,
-          session->internals.resumed_security_parameters.
-          current_cipher_suite.suite, 2);
+          session->internals.resumed_security_parameters.current_cipher_suite.
+          suite, 2);
 
   session->internals.compression_method =
     session->internals.resumed_security_parameters.read_compression_algorithm;
@@ -132,8 +133,9 @@ resume_copy_required_values (MHD_gtls_session_t session)
     session->internals.resumed_security_parameters.entity;
 
   MHD_gtls_set_current_version (session,
-                                session->internals.
-                                resumed_security_parameters.version);
+                                session->
+                                internals.resumed_security_parameters.
+                                version);
 
   session->security_parameters.cert_type =
     session->internals.resumed_security_parameters.cert_type;
@@ -157,7 +159,8 @@ resume_copy_required_values (MHD_gtls_session_t session)
   *
   **/
 void
-MHD__gnutls_handshake_set_max_packet_length (MHD_gtls_session_t session, size_t max)
+MHD__gnutls_handshake_set_max_packet_length (MHD_gtls_session_t session,
+                                             size_t max)
 {
   session->internals.max_handshake_data_buffer_size = max;
 }
@@ -215,11 +218,13 @@ MHD__gnutls_ssl3_finished (MHD_gtls_session_t session, int type, opaque * ret)
   MHD_gnutls_hash (td_sha, mesg, siz);
 
   MHD_gnutls_mac_deinit_ssl3_handshake (td_md5, ret,
-                                        session->security_parameters.
-                                        master_secret, TLS_MASTER_SIZE);
+                                        session->
+                                        security_parameters.master_secret,
+                                        TLS_MASTER_SIZE);
   MHD_gnutls_mac_deinit_ssl3_handshake (td_sha, &ret[16],
-                                        session->security_parameters.
-                                        master_secret, TLS_MASTER_SIZE);
+                                        session->
+                                        security_parameters.master_secret,
+                                        TLS_MASTER_SIZE);
 
   return 0;
 }
@@ -255,7 +260,7 @@ MHD__gnutls_finished (MHD_gtls_session_t session, int type, void *ret)
     {
       MHD_gnutls_assert ();
       if (td_md5 != NULL)
-        MHD_gnutls_hash_deinit (td_md5, NULL);
+        MHD_gnutls_hash_deinit (td_md5, NULL);
       return GNUTLS_E_HASH_FAILED;
     }
 
@@ -301,7 +306,7 @@ MHD_gtls_tls_create_random (opaque * dst)
   /* generate server random value */
   MHD_gtls_write_uint32 (tim, dst);
 
-  if (MHD_gc_nonce ((char*) &dst[4], TLS_RANDOM_SIZE - 4) != GC_OK)
+  if (MHD_gc_nonce ((char *) &dst[4], TLS_RANDOM_SIZE - 4) != GC_OK)
     {
       MHD_gnutls_assert ();
       return GNUTLS_E_RANDOM_FAILED;
@@ -377,7 +382,7 @@ MHD_gtls_user_hello_func (MHD_gtls_session_t session,
  */
 static int
 MHD__gnutls_read_client_hello (MHD_gtls_session_t session, opaque * data,
-                           int datalen)
+                               int datalen)
 {
   uint8_t session_id_len;
   int pos = 0, ret = 0;
@@ -390,7 +395,7 @@ MHD__gnutls_read_client_hello (MHD_gtls_session_t session, opaque * data,
   DECR_LEN (len, 2);
 
   MHD__gnutls_handshake_log ("HSK[%x]: Client's version: %d.%d\n", session,
-                         data[pos], data[pos + 1]);
+                             data[pos], data[pos + 1]);
 
   adv_version = MHD_gtls_version_get (data[pos], data[pos + 1]);
   set_adv_version (session, data[pos], data[pos + 1]);
@@ -437,8 +442,8 @@ MHD__gnutls_read_client_hello (MHD_gtls_session_t session, opaque * data,
   else
     {
       MHD_gtls_generate_session_id (session->security_parameters.session_id,
-                                    &session->security_parameters.
-                                    session_id_size);
+                                    &session->
+                                    security_parameters.session_id_size);
 
       session->internals.resumed = RESUME_FALSE;
     }
@@ -573,18 +578,20 @@ MHD__gnutls_send_finished (MHD_gtls_session_t session, int again)
           return ret;
         }
 
-      if (MHD__gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3)
+      if (MHD__gnutls_protocol_get_version (session) ==
+          MHD_GNUTLS_PROTOCOL_SSL3)
         {
           ret =
             MHD__gnutls_ssl3_finished (session,
-                                   session->security_parameters.entity, data);
+                                       session->security_parameters.entity,
+                                       data);
           data_size = 36;
         }
       else
         {                       /* TLS 1.0 */
           ret =
             MHD__gnutls_finished (session,
-                              session->security_parameters.entity, data);
+                                  session->security_parameters.entity, data);
           data_size = 12;
         }
 
@@ -645,15 +652,15 @@ MHD__gnutls_recv_finished (MHD_gtls_session_t session)
     {
       ret =
         MHD__gnutls_ssl3_finished (session,
-                               (session->security_parameters.entity + 1) % 2,
-                               data);
+                                   (session->security_parameters.entity +
+                                    1) % 2, data);
     }
   else
     {                           /* TLS 1.0 */
       ret =
         MHD__gnutls_finished (session,
-                          (session->security_parameters.entity +
-                           1) % 2, data);
+                              (session->security_parameters.entity +
+                               1) % 2, data);
     }
 
   if (ret < 0)
@@ -678,7 +685,7 @@ MHD__gnutls_recv_finished (MHD_gtls_session_t session)
  */
 static int
 MHD__gnutls_server_find_pk_algos_in_ciphersuites (const opaque *
-                                              data, int datalen)
+                                                  data, int datalen)
 {
   int j;
   enum MHD_GNUTLS_PublicKeyAlgorithm algo = GNUTLS_PK_NONE, prev_algo = 0;
@@ -763,12 +770,13 @@ MHD_gtls_server_select_suite (MHD_gtls_session_t session, opaque * data,
   for (j = 0; j < datalen; j += 2)
     {
       memcpy (&cs.suite, &data[j], 2);
-      MHD__gnutls_handshake_log ("\t%s\n", MHD_gtls_cipher_suite_get_name (&cs));
+      MHD__gnutls_handshake_log ("\t%s\n",
+                                 MHD_gtls_cipher_suite_get_name (&cs));
     }
   MHD__gnutls_handshake_log ("HSK[%x]: Supported cipher suites: \n", session);
   for (j = 0; j < x; j++)
     MHD__gnutls_handshake_log ("\t%s\n",
-                           MHD_gtls_cipher_suite_get_name (&ciphers[j]));
+                               MHD_gtls_cipher_suite_get_name (&ciphers[j]));
 #endif
   memset (session->security_parameters.current_cipher_suite.suite, '\0', 2);
 
@@ -806,9 +814,9 @@ finish:
    */
   if (MHD_gtls_get_kx_cred
       (session,
-       MHD_gtls_cipher_suite_get_kx_algo (&session->security_parameters.
-                                          current_cipher_suite), &err) == NULL
-      && err != 0)
+       MHD_gtls_cipher_suite_get_kx_algo (&session->
+                                          security_parameters.current_cipher_suite),
+       &err) == NULL && err != 0)
     {
       MHD_gnutls_assert ();
       return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
@@ -821,8 +829,8 @@ finish:
    */
   session->internals.auth_struct =
     MHD_gtls_kx_auth_struct (MHD_gtls_cipher_suite_get_kx_algo
-                             (&session->security_parameters.
-                              current_cipher_suite));
+                             (&session->
+                              security_parameters.current_cipher_suite));
   if (session->internals.auth_struct == NULL)
     {
 
@@ -842,7 +850,7 @@ finish:
  */
 static int
 MHD__gnutls_server_select_comp_method (MHD_gtls_session_t session,
-                                   opaque * data, int datalen)
+                                       opaque * data, int datalen)
 {
   int x, i, j;
   uint8_t *comps;
@@ -871,8 +879,8 @@ MHD__gnutls_server_select_comp_method (MHD_gtls_session_t session,
 
               MHD__gnutls_handshake_log
                 ("HSK[%x]: Selected Compression Method: %s\n", session,
-                 MHD_gtls_compression_get_name (session->internals.
-                                                  compression_method));
+                 MHD_gtls_compression_get_name (session->
+                                                internals.compression_method));
 
 
               return 0;
@@ -896,7 +904,8 @@ MHD__gnutls_server_select_comp_method (MHD_gtls_session_t session,
  */
 static int
 MHD__gnutls_send_empty_handshake (MHD_gtls_session_t session,
-                              MHD_gnutls_handshake_description_t type, int again)
+                                  MHD_gnutls_handshake_description_t type,
+                                  int again)
 {
   opaque data = 0;
   opaque *ptr;
@@ -913,8 +922,8 @@ MHD__gnutls_send_empty_handshake (MHD_gtls_session_t session,
 /* This function will hash the handshake message we sent. */
 static int
 MHD__gnutls_handshake_hash_add_sent (MHD_gtls_session_t session,
-                                 MHD_gnutls_handshake_description_t type,
-                                 opaque * dataptr, uint32_t datalen)
+                                     MHD_gnutls_handshake_description_t type,
+                                     opaque * dataptr, uint32_t datalen)
 {
   int ret;
 
@@ -987,7 +996,8 @@ MHD_gtls_send_handshake (MHD_gtls_session_t session, void *i_data,
    */
   if (type != GNUTLS_HANDSHAKE_HELLO_REQUEST)
     if ((ret =
-         MHD__gnutls_handshake_hash_add_sent (session, type, data, datasize)) < 0)
+         MHD__gnutls_handshake_hash_add_sent (session, type, data,
+                                              datasize)) < 0)
       {
         MHD_gnutls_assert ();
         MHD_gnutls_afree (data);
@@ -1001,7 +1011,8 @@ MHD_gtls_send_handshake (MHD_gtls_session_t session, void *i_data,
                                     data, datasize);
 
   MHD__gnutls_handshake_log ("HSK[%x]: %s was sent [%ld bytes]\n",
-                         session, MHD__gnutls_handshake2str (type), datasize);
+                             session, MHD__gnutls_handshake2str (type),
+                             datasize);
 
   MHD_gnutls_afree (data);
 
@@ -1017,8 +1028,9 @@ MHD_gtls_send_handshake (MHD_gtls_session_t session, void *i_data,
 #define SSL2_HEADERS 1
 static int
 MHD__gnutls_recv_handshake_header (MHD_gtls_session_t session,
-                               MHD_gnutls_handshake_description_t type,
-                               MHD_gnutls_handshake_description_t * recv_type)
+                                   MHD_gnutls_handshake_description_t type,
+                                   MHD_gnutls_handshake_description_t *
+                                   recv_type)
 {
   int ret;
   uint32_t length32 = 0;
@@ -1032,8 +1044,8 @@ MHD__gnutls_recv_handshake_header (MHD_gtls_session_t session,
   if (session->internals.handshake_header_buffer.header_size ==
       handshake_header_size || (session->internals.v2_hello != 0
                                 && type == GNUTLS_HANDSHAKE_CLIENT_HELLO
-                                && session->internals.
-                                handshake_header_buffer.packet_length > 0))
+                                && session->internals.handshake_header_buffer.
+                                packet_length > 0))
     {
 
       *recv_type = session->internals.handshake_header_buffer.recv_type;
@@ -1076,11 +1088,13 @@ MHD__gnutls_recv_handshake_header (MHD_gtls_session_t session,
         MHD_gtls_handshake_io_recv_int (session, GNUTLS_HANDSHAKE,
                                         type,
                                         &dataptr
-                                        [session->internals.
-                                         handshake_header_buffer.header_size],
+                                        [session->
+                                         internals.handshake_header_buffer.
+                                         header_size],
                                         HANDSHAKE_HEADER_SIZE -
-                                        session->internals.
-                                        handshake_header_buffer.header_size);
+                                        session->
+                                        internals.handshake_header_buffer.
+                                        header_size);
       if (ret <= 0)
         {
           MHD_gnutls_assert ();
@@ -1102,8 +1116,9 @@ MHD__gnutls_recv_handshake_header (MHD_gtls_session_t session,
       handshake_header_size = HANDSHAKE_HEADER_SIZE;
 
       MHD__gnutls_handshake_log ("HSK[%x]: %s was received [%ld bytes]\n",
-                             session, MHD__gnutls_handshake2str (dataptr[0]),
-                             length32 + HANDSHAKE_HEADER_SIZE);
+                                 session,
+                                 MHD__gnutls_handshake2str (dataptr[0]),
+                                 length32 + HANDSHAKE_HEADER_SIZE);
 
     }
   else
@@ -1115,8 +1130,9 @@ MHD__gnutls_recv_handshake_header (MHD_gtls_session_t session,
       *recv_type = dataptr[0];
 
       MHD__gnutls_handshake_log ("HSK[%x]: %s(v2) was received [%ld bytes]\n",
-                             session, MHD__gnutls_handshake2str (*recv_type),
-                             length32 + handshake_header_size);
+                                 session,
+                                 MHD__gnutls_handshake2str (*recv_type),
+                                 length32 + handshake_header_size);
 
       if (*recv_type != GNUTLS_HANDSHAKE_CLIENT_HELLO)
         {                       /* it should be one or nothing */
@@ -1147,9 +1163,10 @@ MHD__gnutls_recv_handshake_header (MHD_gtls_session_t session,
  */
 static int
 MHD__gnutls_handshake_hash_add_recvd (MHD_gtls_session_t session,
-                                  MHD_gnutls_handshake_description_t recv_type,
-                                  opaque * header, uint16_t header_size,
-                                  opaque * dataptr, uint32_t datalen)
+                                      MHD_gnutls_handshake_description_t
+                                      recv_type, opaque * header,
+                                      uint16_t header_size, opaque * dataptr,
+                                      uint32_t datalen)
 {
   int ret;
 
@@ -1195,7 +1212,8 @@ MHD__gnutls_handshake_hash_add_recvd (MHD_gtls_session_t session,
  */
 int
 MHD_gtls_recv_handshake (MHD_gtls_session_t session, uint8_t ** data,
-                         int *datalen, MHD_gnutls_handshake_description_t type,
+                         int *datalen,
+                         MHD_gnutls_handshake_description_t type,
                          Optional optional)
 {
   int ret;
@@ -1259,11 +1277,12 @@ MHD_gtls_recv_handshake (MHD_gtls_session_t session, uint8_t ** data,
 
 
   ret = MHD__gnutls_handshake_hash_add_recvd (session, recv_type,
-                                          session->internals.
-                                          handshake_header_buffer.header,
-                                          session->internals.
-                                          handshake_header_buffer.header_size,
-                                          dataptr, length32);
+                                              session->
+                                              internals.handshake_header_buffer.
+                                              header,
+                                              session->
+                                              internals.handshake_header_buffer.
+                                              header_size, dataptr, length32);
   if (ret < 0)
     {
       MHD_gnutls_assert ();
@@ -1319,7 +1338,8 @@ MHD_gtls_recv_handshake (MHD_gtls_session_t session, uint8_t ** data,
  * to the session;
  */
 static int
-MHD__gnutls_client_set_ciphersuite (MHD_gtls_session_t session, opaque suite[2])
+MHD__gnutls_client_set_ciphersuite (MHD_gtls_session_t session,
+                                    opaque suite[2])
 {
   uint8_t z;
   cipher_suite_st *cipher_suites;
@@ -1355,9 +1375,9 @@ MHD__gnutls_client_set_ciphersuite (MHD_gtls_session_t session, opaque suite[2])
   memcpy (session->security_parameters.current_cipher_suite.suite, suite, 2);
 
   MHD__gnutls_handshake_log ("HSK[%x]: Selected cipher suite: %s\n", session,
-                         MHD_gtls_cipher_suite_get_name
-                         (&session->security_parameters.
-                          current_cipher_suite));
+                             MHD_gtls_cipher_suite_get_name
+                             (&session->
+                              security_parameters.current_cipher_suite));
 
 
   /* check if the credentials (username, public key etc.) are ok.
@@ -1380,8 +1400,8 @@ MHD__gnutls_client_set_ciphersuite (MHD_gtls_session_t session, opaque suite[2])
    */
   session->internals.auth_struct =
     MHD_gtls_kx_auth_struct (MHD_gtls_cipher_suite_get_kx_algo
-                             (&session->security_parameters.
-                              current_cipher_suite));
+                             (&session->
+                              security_parameters.current_cipher_suite));
 
   if (session->internals.auth_struct == NULL)
     {
@@ -1402,7 +1422,7 @@ MHD__gnutls_client_set_ciphersuite (MHD_gtls_session_t session, opaque suite[2])
  */
 static int
 MHD__gnutls_client_set_comp_method (MHD_gtls_session_t session,
-                                opaque comp_method)
+                                    opaque comp_method)
 {
   int comp_methods_num;
   uint8_t *compression_methods;
@@ -1446,16 +1466,15 @@ MHD__gnutls_client_set_comp_method (MHD_gtls_session_t session,
  */
 static int
 MHD__gnutls_client_check_if_resuming (MHD_gtls_session_t session,
-                                  opaque * session_id, int session_id_len)
+                                      opaque * session_id, int session_id_len)
 {
   opaque buf[2 * TLS_MAX_SESSION_ID_SIZE + 1];
 
   MHD__gnutls_handshake_log ("HSK[%x]: SessionID length: %d\n", session,
-                         session_id_len);
+                             session_id_len);
   MHD__gnutls_handshake_log ("HSK[%x]: SessionID: %s\n", session,
-                         MHD_gtls_bin2hex (session_id, session_id_len, 
-                                           (char*) buf,
-                                           sizeof (buf)));
+                             MHD_gtls_bin2hex (session_id, session_id_len,
+                                               (char *) buf, sizeof (buf)));
 
   if (session_id_len > 0 &&
       session->internals.resumed_security_parameters.session_id_size ==
@@ -1491,7 +1510,7 @@ MHD__gnutls_client_check_if_resuming (MHD_gtls_session_t session,
  */
 static int
 MHD__gnutls_read_server_hello (MHD_gtls_session_t session,
-                           opaque * data, int datalen)
+                               opaque * data, int datalen)
 {
   uint8_t session_id_len = 0;
   int pos = 0;
@@ -1506,7 +1525,7 @@ MHD__gnutls_read_server_hello (MHD_gtls_session_t session,
     }
 
   MHD__gnutls_handshake_log ("HSK[%x]: Server's version: %d.%d\n",
-                         session, data[pos], data[pos + 1]);
+                             session, data[pos], data[pos + 1]);
 
   DECR_LEN (len, 2);
   version = MHD_gtls_version_get (data[pos], data[pos + 1]);
@@ -1594,7 +1613,7 @@ MHD__gnutls_read_server_hello (MHD_gtls_session_t session,
  */
 static int
 MHD__gnutls_copy_ciphersuites (MHD_gtls_session_t session,
-                           opaque * ret_data, size_t ret_data_size)
+                               opaque * ret_data, size_t ret_data_size)
 {
   int ret, i;
   cipher_suite_st *cipher_suites;
@@ -1662,7 +1681,7 @@ MHD__gnutls_copy_ciphersuites (MHD_gtls_session_t session,
  */
 static int
 MHD__gnutls_copy_comp_methods (MHD_gtls_session_t session,
-                           opaque * ret_data, size_t ret_data_size)
+                               opaque * ret_data, size_t ret_data_size)
 {
   int ret, i;
   uint8_t *compression_methods, comp_num;
@@ -1921,7 +1940,7 @@ MHD__gnutls_send_server_hello (MHD_gtls_session_t session, int again)
            */
           MHD_gnutls_assert ();
           ret = MHD__gnutls_alert_send (session, GNUTLS_AL_FATAL,
-                                       GNUTLS_A_UNKNOWN_PSK_IDENTITY);
+                                        GNUTLS_A_UNKNOWN_PSK_IDENTITY);
           if (ret < 0)
             {
               MHD_gnutls_assert ();
@@ -1969,16 +1988,17 @@ MHD__gnutls_send_server_hello (MHD_gtls_session_t session, int again)
       pos += session_id_len;
 
       MHD__gnutls_handshake_log ("HSK[%x]: SessionID: %s\n", session,
-                             MHD_gtls_bin2hex (SessionID, session_id_len,
-                                               (char*) buf, sizeof (buf)));
+                                 MHD_gtls_bin2hex (SessionID, session_id_len,
+                                                   (char *) buf,
+                                                   sizeof (buf)));
 
       memcpy (&data[pos],
               session->security_parameters.current_cipher_suite.suite, 2);
       pos += 2;
 
       comp =
-        (uint8_t) MHD_gtls_compression_get_num (session->
-                                                internals.compression_method);
+        (uint8_t) MHD_gtls_compression_get_num (session->internals.
+                                                compression_method);
       data[pos++] = comp;
 
 
@@ -2103,7 +2123,7 @@ MHD__gnutls_rehandshake (MHD_gtls_session_t session)
 
   ret =
     MHD__gnutls_send_empty_handshake (session, GNUTLS_HANDSHAKE_HELLO_REQUEST,
-                                  AGAIN (STATE50));
+                                      AGAIN (STATE50));
   STATE = STATE50;
 
   if (ret < 0)
@@ -2260,14 +2280,14 @@ MHD__gnutls_handshake (MHD_gtls_session_t session)
     }
 #if MHD_DEBUG_TLS
   if (session->security_parameters.entity == GNUTLS_CLIENT)
-      {
-        ret = MHD_gtls_handshake_client (session);
-      }
-    else
+    {
+      ret = MHD_gtls_handshake_client (session);
+    }
+  else
 #endif
-      {
-        ret = MHD_gtls_handshake_server (session);
-      }
+    {
+      ret = MHD_gtls_handshake_server (session);
+    }
 
   if (ret < 0)
     {
@@ -2323,13 +2343,11 @@ MHD_gtls_handshake_client (MHD_gtls_session_t session)
 
   if (session->internals.resumed_security_parameters.session_id_size > 0)
     MHD__gnutls_handshake_log ("HSK[%x]: Ask to resume: %s\n", session,
-                           MHD_gtls_bin2hex (session->internals.
-                                             resumed_security_parameters.
-                                             session_id,
-                                             session->internals.
-                                             resumed_security_parameters.
-                                             session_id_size, buf,
-                                             sizeof (buf)));
+                               MHD_gtls_bin2hex (session->
+                                                 internals.resumed_security_parameters.session_id,
+                                                 session->
+                                                 internals.resumed_security_parameters.session_id_size,
+                                                 buf, sizeof (buf)));
 #endif
 
   switch (STATE)
@@ -2613,8 +2631,8 @@ MHD_gtls_handshake_server (MHD_gtls_session_t session)
       if (session->internals.resumed == RESUME_FALSE)   /* if we are not resuming */
         ret =
           MHD__gnutls_send_empty_handshake (session,
-                                        GNUTLS_HANDSHAKE_SERVER_HELLO_DONE,
-                                        AGAIN (STATE6));
+                                            GNUTLS_HANDSHAKE_SERVER_HELLO_DONE,
+                                            AGAIN (STATE6));
       STATE = STATE6;
       IMED_RET ("send server hello done", ret);
 
@@ -2696,7 +2714,7 @@ MHD_gtls_generate_session_id (opaque * session_id, uint8_t * len)
 {
   *len = TLS_MAX_SESSION_ID_SIZE;
 
-  if (MHD_gc_nonce ((char*) session_id, *len) != GC_OK)
+  if (MHD_gc_nonce ((char *) session_id, *len) != GC_OK)
     {
       MHD_gnutls_assert ();
       return GNUTLS_E_RANDOM_FAILED;
@@ -2804,7 +2822,8 @@ check_server_params (MHD_gtls_session_t session,
     {
       MHD_gnutls_psk_server_credentials_t psk_cred =
         (MHD_gnutls_psk_server_credentials_t) MHD_gtls_get_cred (session->key,
-                                                             cred_type, NULL);
+                                                                 cred_type,
+                                                                 NULL);
 
       if (psk_cred != NULL)
         {
@@ -2889,8 +2908,9 @@ MHD_gtls_remove_unwanted_ciphersuites (MHD_gtls_session_t session,
       if (ret < 0)
         {
           MHD_gnutls_assert ();
-          MHD__gnutls_x509_log ("Could not find an appropriate certificate: %s\n",
-                            MHD_gtls_strerror (ret));
+          MHD__gnutls_x509_log
+            ("Could not find an appropriate certificate: %s\n",
+             MHD_gtls_strerror (ret));
           cert_cred = NULL;
         }
     }
@@ -2954,8 +2974,8 @@ MHD_gtls_remove_unwanted_ciphersuites (MHD_gtls_session_t session,
         {
 
           MHD__gnutls_handshake_log ("HSK[%x]: Keeping ciphersuite: %s\n",
-                                 session,
-                                 MHD_gtls_cipher_suite_get_name (&cs));
+                                     session,
+                                     MHD_gtls_cipher_suite_get_name (&cs));
 
           memcpy (newSuite[newSuiteSize].suite, (*cipherSuites)[i].suite, 2);
           newSuiteSize++;
@@ -2963,8 +2983,8 @@ MHD_gtls_remove_unwanted_ciphersuites (MHD_gtls_session_t session,
       else
         {
           MHD__gnutls_handshake_log ("HSK[%x]: Removing ciphersuite: %s\n",
-                                 session,
-                                 MHD_gtls_cipher_suite_get_name (&cs));
+                                     session,
+                                     MHD_gtls_cipher_suite_get_name (&cs));
 
         }
     }
diff --git a/src/daemon/https/tls/gnutls_handshake.h b/src/daemon/https/tls/gnutls_handshake.h
index 6ef002c6..58c95a84 100644
--- a/src/daemon/https/tls/gnutls_handshake.h
+++ b/src/daemon/https/tls/gnutls_handshake.h
@@ -37,7 +37,8 @@ int MHD_gtls_recv_handshake (MHD_gtls_session_t session, uint8_t **, int *,
                              MHD_gnutls_handshake_description_t,
                              Optional optional);
 void
-MHD__gnutls_handshake_set_max_packet_length (MHD_gtls_session_t session, size_t max);
+MHD__gnutls_handshake_set_max_packet_length (MHD_gtls_session_t session,
+                                             size_t max);
 
 #define STATE session->internals.handshake_state
 /* This returns true if we have got there
diff --git a/src/daemon/https/tls/gnutls_hash_int.c b/src/daemon/https/tls/gnutls_hash_int.c
index 97b6680d..cc61203d 100644
--- a/src/daemon/https/tls/gnutls_hash_int.c
+++ b/src/daemon/https/tls/gnutls_hash_int.c
@@ -133,7 +133,7 @@ MHD_gnutls_hash_deinit (GNUTLS_HASH_HANDLE handle, void *digest)
 
   maclen = MHD_gnutls_hash_get_algo_len (handle->algorithm);
 
-  mac = (unsigned char*) MHD_gc_hash_read (handle->handle);
+  mac = (unsigned char *) MHD_gc_hash_read (handle->handle);
   if (digest != NULL)
     memcpy (digest, mac, maclen);
 
@@ -145,7 +145,7 @@ MHD_gnutls_hash_deinit (GNUTLS_HASH_HANDLE handle, void *digest)
 
 mac_hd_t
 MHD_gtls_MHD_hmac_init (enum MHD_GNUTLS_HashAlgorithm algorithm,
-                    const void *key, int keylen)
+                        const void *key, int keylen)
 {
   mac_hd_t ret;
   int result;
@@ -154,7 +154,8 @@ MHD_gtls_MHD_hmac_init (enum MHD_GNUTLS_HashAlgorithm algorithm,
   if (ret == NULL)
     return GNUTLS_MAC_FAILED;
 
-  result = MHD_gc_hash_open (MHD__gnutls_mac2gc (algorithm), GC_HMAC, &ret->handle);
+  result =
+    MHD_gc_hash_open (MHD__gnutls_mac2gc (algorithm), GC_HMAC, &ret->handle);
   if (result)
     {
       MHD_gnutls_free (ret);
@@ -178,7 +179,7 @@ MHD_gnutls_MHD_hmac_deinit (mac_hd_t handle, void *digest)
 
   maclen = MHD_gnutls_hash_get_algo_len (handle->algorithm);
 
-  mac = (unsigned char*) MHD_gc_hash_read (handle->handle);
+  mac = (unsigned char *) MHD_gc_hash_read (handle->handle);
 
   if (digest != NULL)
     memcpy (digest, mac, maclen);
diff --git a/src/daemon/https/tls/gnutls_hash_int.h b/src/daemon/https/tls/gnutls_hash_int.h
index 72f805ee..bd3dec29 100644
--- a/src/daemon/https/tls/gnutls_hash_int.h
+++ b/src/daemon/https/tls/gnutls_hash_int.h
@@ -43,7 +43,7 @@ typedef mac_hd_t GNUTLS_HASH_HANDLE;
 #define GNUTLS_MAC_FAILED NULL
 
 mac_hd_t MHD_gtls_MHD_hmac_init (enum MHD_GNUTLS_HashAlgorithm algorithm,
-                             const void *key, int keylen);
+                                 const void *key, int keylen);
 
 void MHD_gnutls_MHD_hmac_deinit (mac_hd_t handle, void *digest);
 
diff --git a/src/daemon/https/tls/gnutls_kx.c b/src/daemon/https/tls/gnutls_kx.c
index 5f0966f8..58850318 100644
--- a/src/daemon/https/tls/gnutls_kx.c
+++ b/src/daemon/https/tls/gnutls_kx.c
@@ -62,14 +62,16 @@ generate_normal_master (MHD_gtls_session_t session, int keep_premaster)
   char buf[512];
 
   MHD__gnutls_hard_log ("INT: PREMASTER SECRET[%d]: %s\n", PREMASTER.size,
-                    MHD_gtls_bin2hex (PREMASTER.data, PREMASTER.size, buf,
-                                      sizeof (buf)));
+                        MHD_gtls_bin2hex (PREMASTER.data, PREMASTER.size, buf,
+                                          sizeof (buf)));
   MHD__gnutls_hard_log ("INT: CLIENT RANDOM[%d]: %s\n", 32,
-                    MHD_gtls_bin2hex (session->security_parameters.
-                                      client_random, 32, buf, sizeof (buf)));
+                        MHD_gtls_bin2hex (session->
+                                          security_parameters.client_random,
+                                          32, buf, sizeof (buf)));
   MHD__gnutls_hard_log ("INT: SERVER RANDOM[%d]: %s\n", 32,
-                    MHD_gtls_bin2hex (session->security_parameters.
-                                      server_random, 32, buf, sizeof (buf)));
+                        MHD_gtls_bin2hex (session->
+                                          security_parameters.server_random,
+                                          32, buf, sizeof (buf)));
 
   if (MHD__gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3)
     {
@@ -84,8 +86,8 @@ generate_normal_master (MHD_gtls_session_t session, int keep_premaster)
         MHD_gnutls_ssl3_generate_random (PREMASTER.data, PREMASTER.size,
                                          rnd, 2 * TLS_RANDOM_SIZE,
                                          TLS_MASTER_SIZE,
-                                         session->security_parameters.
-                                         master_secret);
+                                         session->
+                                         security_parameters.master_secret);
 
     }
   else if (session->security_parameters.extensions.oprfi_client_len > 0 &&
@@ -105,21 +107,25 @@ generate_normal_master (MHD_gtls_session_t session, int keep_premaster)
         }
 
       MHD__gnutls_hard_log ("INT: CLIENT OPRFI[%d]: %s\n",
-                        session->security_parameters.
-                        extensions.oprfi_server_len,
-                        MHD_gtls_bin2hex (session->security_parameters.
-                                          extensions.oprfi_client,
-                                          session->security_parameters.
-                                          extensions.oprfi_client_len, buf,
-                                          sizeof (buf)));
+                            session->security_parameters.extensions.
+                            oprfi_server_len,
+                            MHD_gtls_bin2hex (session->
+                                              security_parameters.extensions.
+                                              oprfi_client,
+                                              session->
+                                              security_parameters.extensions.
+                                              oprfi_client_len, buf,
+                                              sizeof (buf)));
       MHD__gnutls_hard_log ("INT: SERVER OPRFI[%d]: %s\n",
-                        session->security_parameters.
-                        extensions.oprfi_server_len,
-                        MHD_gtls_bin2hex (session->security_parameters.
-                                          extensions.oprfi_server,
-                                          session->security_parameters.
-                                          extensions.oprfi_server_len, buf,
-                                          sizeof (buf)));
+                            session->security_parameters.extensions.
+                            oprfi_server_len,
+                            MHD_gtls_bin2hex (session->
+                                              security_parameters.extensions.
+                                              oprfi_server,
+                                              session->
+                                              security_parameters.extensions.
+                                              oprfi_server_len, buf,
+                                              sizeof (buf)));
 
       memcpy (rnd, session->security_parameters.client_random,
               TLS_RANDOM_SIZE);
@@ -169,9 +175,10 @@ generate_normal_master (MHD_gtls_session_t session, int keep_premaster)
     return ret;
 
   MHD__gnutls_hard_log ("INT: MASTER SECRET: %s\n",
-                    MHD_gtls_bin2hex (session->security_parameters.
-                                      master_secret, TLS_MASTER_SIZE, buf,
-                                      sizeof (buf)));
+                        MHD_gtls_bin2hex (session->
+                                          security_parameters.master_secret,
+                                          TLS_MASTER_SIZE, buf,
+                                          sizeof (buf)));
 
   return ret;
 }
@@ -237,8 +244,8 @@ MHD_gtls_send_server_certificate_request (MHD_gtls_session_t session,
   int data_size = 0;
   int ret = 0;
 
-  if (session->internals.auth_struct->
-      MHD_gtls_gen_server_certificate_request == NULL)
+  if (session->internals.
+      auth_struct->MHD_gtls_gen_server_certificate_request == NULL)
     return 0;
 
   if (session->internals.send_cert_req <= 0)
@@ -250,8 +257,8 @@ MHD_gtls_send_server_certificate_request (MHD_gtls_session_t session,
   if (again == 0)
     {
       data_size =
-        session->internals.auth_struct->
-        MHD_gtls_gen_server_certificate_request (session, &data);
+        session->internals.
+        auth_struct->MHD_gtls_gen_server_certificate_request (session, &data);
 
       if (data_size < 0)
         {
@@ -350,8 +357,8 @@ MHD_gtls_send_client_certificate_verify (MHD_gtls_session_t session,
   if (again == 0)
     {
       data_size =
-        session->internals.auth_struct->
-        MHD_gtls_gen_client_cert_vrfy (session, &data);
+        session->internals.
+        auth_struct->MHD_gtls_gen_client_cert_vrfy (session, &data);
       if (data_size < 0)
         {
           MHD_gnutls_assert ();
@@ -423,8 +430,8 @@ MHD_gtls_recv_server_certificate_request (MHD_gtls_session_t session)
   int datasize;
   int ret = 0;
 
-  if (session->internals.auth_struct->
-      MHD_gtls_process_server_certificate_request != NULL)
+  if (session->internals.
+      auth_struct->MHD_gtls_process_server_certificate_request != NULL)
     {
 
       ret =
@@ -439,8 +446,10 @@ MHD_gtls_recv_server_certificate_request (MHD_gtls_session_t session)
         return 0;               /* ignored */
 
       ret =
-        session->internals.auth_struct->
-        MHD_gtls_process_server_certificate_request (session, data, datasize);
+        session->internals.
+        auth_struct->MHD_gtls_process_server_certificate_request (session,
+                                                                  data,
+                                                                  datasize);
       MHD_gnutls_free (data);
       if (ret < 0)
         return ret;
@@ -504,14 +513,15 @@ MHD_gtls_send_client_certificate (MHD_gtls_session_t session, int again)
 
   if (again == 0)
     {
-      if (MHD__gnutls_protocol_get_version (session) != MHD_GNUTLS_PROTOCOL_SSL3 ||
-          session->internals.selected_cert_list_length > 0)
+      if (MHD__gnutls_protocol_get_version (session) !=
+          MHD_GNUTLS_PROTOCOL_SSL3
+          || session->internals.selected_cert_list_length > 0)
         {
           /* TLS 1.0 or SSL 3.0 with a valid certificate
            */
           data_size =
-            session->internals.auth_struct->
-            MHD_gtls_gen_client_certificate (session, &data);
+            session->internals.
+            auth_struct->MHD_gtls_gen_client_certificate (session, &data);
 
           if (data_size < 0)
             {
@@ -525,12 +535,12 @@ MHD_gtls_send_client_certificate (MHD_gtls_session_t session, int again)
    * no certificate alert instead of an
    * empty certificate.
    */
-  if (MHD__gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3 &&
-      session->internals.selected_cert_list_length == 0)
+  if (MHD__gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3
+      && session->internals.selected_cert_list_length == 0)
     {
       ret =
         MHD__gnutls_alert_send (session, GNUTLS_AL_WARNING,
-                               GNUTLS_A_SSL3_NO_CERTIFICATE);
+                                GNUTLS_A_SSL3_NO_CERTIFICATE);
 
     }
   else
@@ -571,8 +581,8 @@ MHD_gtls_send_server_certificate (MHD_gtls_session_t session, int again)
   if (again == 0)
     {
       data_size =
-        session->internals.auth_struct->
-        MHD_gtls_gen_server_certificate (session, &data);
+        session->internals.
+        auth_struct->MHD_gtls_gen_server_certificate (session, &data);
 
       if (data_size < 0)
         {
@@ -632,8 +642,10 @@ MHD_gtls_recv_client_certificate (MHD_gtls_session_t session)
            */
           if (optional == OPTIONAL_PACKET &&
               ret == GNUTLS_E_WARNING_ALERT_RECEIVED &&
-              MHD__gnutls_protocol_get_version (session) == MHD_GNUTLS_PROTOCOL_SSL3 &&
-              MHD_gnutls_alert_get (session) == GNUTLS_A_SSL3_NO_CERTIFICATE)
+              MHD__gnutls_protocol_get_version (session) ==
+              MHD_GNUTLS_PROTOCOL_SSL3
+              && MHD_gnutls_alert_get (session) ==
+              GNUTLS_A_SSL3_NO_CERTIFICATE)
             {
 
               /* SSL3 does not send an empty certificate,
@@ -666,8 +678,9 @@ MHD_gtls_recv_client_certificate (MHD_gtls_session_t session)
           return 0;
         }
       ret =
-        session->internals.auth_struct->
-        MHD_gtls_process_client_certificate (session, data, datasize);
+        session->internals.
+        auth_struct->MHD_gtls_process_client_certificate (session, data,
+                                                          datasize);
 
       MHD_gnutls_free (data);
       if (ret < 0 && ret != GNUTLS_E_NO_CERTIFICATE_FOUND)
@@ -711,8 +724,9 @@ MHD_gtls_recv_server_certificate (MHD_gtls_session_t session)
         }
 
       ret =
-        session->internals.auth_struct->
-        MHD_gtls_process_server_certificate (session, data, datasize);
+        session->internals.
+        auth_struct->MHD_gtls_process_server_certificate (session, data,
+                                                          datasize);
       MHD_gnutls_free (data);
       if (ret < 0)
         {
@@ -763,8 +777,9 @@ MHD_gtls_recv_client_certificate_verify_message (MHD_gtls_session_t session)
         }
 
       ret =
-        session->internals.auth_struct->
-        MHD_gtls_process_client_cert_vrfy (session, data, datasize);
+        session->internals.
+        auth_struct->MHD_gtls_process_client_cert_vrfy (session, data,
+                                                        datasize);
       MHD_gnutls_free (data);
       if (ret < 0)
         return ret;
diff --git a/src/daemon/https/tls/gnutls_mem.c b/src/daemon/https/tls/gnutls_mem.c
index fda4099b..1f0a743d 100644
--- a/src/daemon/https/tls/gnutls_mem.c
+++ b/src/daemon/https/tls/gnutls_mem.c
@@ -40,7 +40,8 @@ MHD__gnutls_is_secure_mem_null (const void *ign)
   return 0;
 }
 
-int (*MHD__gnutls_is_secure_memory) (const void *) = MHD__gnutls_is_secure_mem_null;
+int (*MHD__gnutls_is_secure_memory) (const void *) =
+  MHD__gnutls_is_secure_mem_null;
 
 
 void *
diff --git a/src/daemon/https/tls/gnutls_mpi.c b/src/daemon/https/tls/gnutls_mpi.c
index 034b189f..918e6480 100644
--- a/src/daemon/https/tls/gnutls_mpi.c
+++ b/src/daemon/https/tls/gnutls_mpi.c
@@ -241,7 +241,8 @@ MHD__gnutls_x509_read_int (ASN1_TYPE node, const char *value, mpi_t * ret_mpi)
 /* Writes the specified integer into the specified node.
  */
 int
-MHD__gnutls_x509_write_int (ASN1_TYPE node, const char *value, mpi_t mpi, int lz)
+MHD__gnutls_x509_write_int (ASN1_TYPE node, const char *value, mpi_t mpi,
+                            int lz)
 {
   opaque *tmpstr;
   size_t s_len;
diff --git a/src/daemon/https/tls/gnutls_pk.c b/src/daemon/https/tls/gnutls_pk.c
index c4ec508a..7e170a32 100644
--- a/src/daemon/https/tls/gnutls_pk.c
+++ b/src/daemon/https/tls/gnutls_pk.c
@@ -41,13 +41,13 @@
 #include "mpi.h"
 
 static int MHD__gnutls_pk_encrypt (int algo, mpi_t * resarr, mpi_t data,
-                               mpi_t * pkey, int pkey_len);
+                                   mpi_t * pkey, int pkey_len);
 static int MHD__gnutls_pk_sign (int algo, mpi_t * data, mpi_t hash,
-                            mpi_t * pkey, int);
+                                mpi_t * pkey, int);
 static int MHD__gnutls_pk_verify (int algo, mpi_t hash, mpi_t * data,
-                              mpi_t * pkey, int);
+                                  mpi_t * pkey, int);
 static int MHD__gnutls_pk_decrypt (int algo, mpi_t * resarr, mpi_t data,
-                               mpi_t * pkey, int);
+                                   mpi_t * pkey, int);
 
 
 /* Do PKCS-1 RSA encryption.
@@ -104,7 +104,7 @@ MHD_gtls_pkcs1_rsa_encrypt (MHD_gnutls_datum_t * ciphertext,
           return GNUTLS_E_INTERNAL_ERROR;
         }
 
-      if (MHD_gc_pseudo_random ((char*)ps, psize) != GC_OK)
+      if (MHD_gc_pseudo_random ((char *) ps, psize) != GC_OK)
         {
           MHD_gnutls_assert ();
           MHD_gnutls_afree (edata);
@@ -113,7 +113,7 @@ MHD_gtls_pkcs1_rsa_encrypt (MHD_gnutls_datum_t * ciphertext,
       for (i = 0; i < psize; i++)
         while (ps[i] == 0)
           {
-            if (MHD_gc_pseudo_random ((char*) &ps[i], 1) != GC_OK)
+            if (MHD_gc_pseudo_random ((char *) &ps[i], 1) != GC_OK)
               {
                 MHD_gnutls_assert ();
                 MHD_gnutls_afree (edata);
@@ -391,8 +391,8 @@ encode_ber_rs (MHD_gnutls_datum_t * sig_value, mpi_t r, mpi_t s)
 
   if ((result =
        MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (),
-                            "GNUTLS.DSASignatureValue",
-                            &sig)) != ASN1_SUCCESS)
+                                 "GNUTLS.DSASignatureValue",
+                                 &sig)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       return MHD_gtls_asn2err (result);
@@ -489,14 +489,15 @@ decode_ber_rs (const MHD_gnutls_datum_t * sig_value, mpi_t * r, mpi_t * s)
 
   if ((result =
        MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (),
-                            "GNUTLS.DSASignatureValue",
-                            &sig)) != ASN1_SUCCESS)
+                                 "GNUTLS.DSASignatureValue",
+                                 &sig)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       return MHD_gtls_asn2err (result);
     }
 
-  result = MHD__asn1_der_decoding (&sig, sig_value->data, sig_value->size, NULL);
+  result =
+    MHD__asn1_der_decoding (&sig, sig_value->data, sig_value->size, NULL);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -585,7 +586,7 @@ MHD_gtls_dsa_verify (const MHD_gnutls_datum_t * vdata,
  */
 static int
 MHD__gnutls_pk_encrypt (int algo, mpi_t * resarr, mpi_t data,
-                    mpi_t * pkey, int pkey_len)
+                        mpi_t * pkey, int pkey_len)
 {
   gcry_sexp_t s_ciph, s_data, s_pkey;
   int rc = -1;
@@ -657,7 +658,7 @@ MHD__gnutls_pk_encrypt (int algo, mpi_t * resarr, mpi_t data,
 
 static int
 MHD__gnutls_pk_decrypt (int algo, mpi_t * resarr, mpi_t data, mpi_t * pkey,
-                    int pkey_len)
+                        int pkey_len)
 {
   gcry_sexp_t s_plain, s_data, s_pkey;
   int rc = -1;
@@ -724,7 +725,7 @@ MHD__gnutls_pk_decrypt (int algo, mpi_t * resarr, mpi_t data, mpi_t * pkey,
  */
 static int
 MHD__gnutls_pk_sign (int algo, mpi_t * data, mpi_t hash, mpi_t * pkey,
-                 int pkey_len)
+                     int pkey_len)
 {
   gcry_sexp_t s_hash, s_key, s_sig;
   int rc = -1;
@@ -834,7 +835,7 @@ MHD__gnutls_pk_sign (int algo, mpi_t * data, mpi_t hash, mpi_t * pkey,
 
 static int
 MHD__gnutls_pk_verify (int algo, mpi_t hash, mpi_t * data,
-                   mpi_t * pkey, int pkey_len)
+                       mpi_t * pkey, int pkey_len)
 {
   gcry_sexp_t s_sig, s_hash, s_pkey;
   int rc = -1;
diff --git a/src/daemon/https/tls/gnutls_pk.h b/src/daemon/https/tls/gnutls_pk.h
index bd153a45..9c4fa16f 100644
--- a/src/daemon/https/tls/gnutls_pk.h
+++ b/src/daemon/https/tls/gnutls_pk.h
@@ -37,8 +37,8 @@ int MHD_gtls_pkcs1_rsa_decrypt (MHD_gnutls_datum_t * plaintext,
                                 mpi_t * params, unsigned params_len,
                                 unsigned btype);
 int MHD_gtls_rsa_verify (const MHD_gnutls_datum_t * vdata,
-                         const MHD_gnutls_datum_t * ciphertext, mpi_t * params,
-                         int params_len, int btype);
+                         const MHD_gnutls_datum_t * ciphertext,
+                         mpi_t * params, int params_len, int btype);
 int MHD_gtls_dsa_verify (const MHD_gnutls_datum_t * vdata,
                          const MHD_gnutls_datum_t * sig_value, mpi_t * params,
                          int params_len);
diff --git a/src/daemon/https/tls/gnutls_priority.c b/src/daemon/https/tls/gnutls_priority.c
index 06398e83..62bf3489 100644
--- a/src/daemon/https/tls/gnutls_priority.c
+++ b/src/daemon/https/tls/gnutls_priority.c
@@ -71,11 +71,10 @@ _set_priority (MHD_gtls_priority_st * st, const int *list)
 {
   int num = 0;
 
-  while ( (list[num] != 0) &&
-          (num < MAX_ALGOS) )
+  while ((list[num] != 0) && (num < MAX_ALGOS))
     num++;
   st->num_algorithms = num;
-  memcpy(st->priority, list, num * sizeof(int));
+  memcpy (st->priority, list, num * sizeof (int));
   return 0;
 }
 
@@ -142,7 +141,7 @@ MHD__gnutls_mac_set_priority (MHD_gtls_session_t session, const int *list)
  **/
 int
 MHD__gnutls_compression_set_priority (MHD_gtls_session_t session,
-                                     const int *list)
+                                      const int *list)
 {
   return _set_priority (&session->internals.priorities.compression, list);
 }
@@ -160,7 +159,8 @@ MHD__gnutls_compression_set_priority (MHD_gtls_session_t session,
  *
  **/
 int
-MHD__gnutls_protocol_set_priority (MHD_gtls_session_t session, const int *list)
+MHD__gnutls_protocol_set_priority (MHD_gtls_session_t session,
+                                   const int *list)
 {
   int ret;
 
@@ -190,7 +190,7 @@ MHD__gnutls_protocol_set_priority (MHD_gtls_session_t session, const int *list)
  **/
 int
 MHD__gnutls_certificate_type_set_priority (MHD_gtls_session_t session,
-                                          const int *list)
+                                           const int *list)
 {
 #if ENABLE_OPENPGP
   return _set_priority (&session->internals.priorities.cert_type, list);
@@ -243,7 +243,7 @@ typedef void (rmadd_func) (MHD_gtls_priority_st * priority_list, int alg);
  **/
 int
 MHD__gnutls_priority_set (MHD_gtls_session_t session,
-                         MHD_gnutls_priority_t priority)
+                          MHD_gnutls_priority_t priority)
 {
   if (priority == NULL)
     {
@@ -326,7 +326,8 @@ int
 MHD_tls_set_default_priority (MHD_gnutls_priority_t * priority_cache,
                               const char *priorities, const char **err_pos)
 {
-  *priority_cache = MHD_gnutls_calloc (1, sizeof (struct MHD_gtls_priority_st));
+  *priority_cache =
+    MHD_gnutls_calloc (1, sizeof (struct MHD_gtls_priority_st));
   if (*priority_cache == NULL)
     {
       MHD_gnutls_assert ();
@@ -375,7 +376,7 @@ MHD__gnutls_priority_deinit (MHD_gnutls_priority_t priority_cache)
  **/
 int
 MHD__gnutls_priority_set_direct (MHD_gtls_session_t session,
-                                const char *priorities, const char **err_pos)
+                                 const char *priorities, const char **err_pos)
 {
   MHD_gnutls_priority_t prio;
   int ret;
diff --git a/src/daemon/https/tls/gnutls_record.c b/src/daemon/https/tls/gnutls_record.c
index 9ccdb1e3..80d5f70f 100644
--- a/src/daemon/https/tls/gnutls_record.c
+++ b/src/daemon/https/tls/gnutls_record.c
@@ -109,7 +109,7 @@ MHD_gtls_record_disable_padding (MHD_gtls_session_t session)
  **/
 void
 MHD__gnutls_transport_set_ptr (MHD_gtls_session_t session,
-                              MHD_gnutls_transport_ptr_t ptr)
+                               MHD_gnutls_transport_ptr_t ptr)
 {
   session->internals.transport_recv_ptr = ptr;
   session->internals.transport_send_ptr = ptr;
@@ -128,8 +128,8 @@ MHD__gnutls_transport_set_ptr (MHD_gtls_session_t session,
  **/
 void
 MHD__gnutls_transport_set_ptr2 (MHD_gtls_session_t session,
-                               MHD_gnutls_transport_ptr_t recv_ptr,
-                               MHD_gnutls_transport_ptr_t send_ptr)
+                                MHD_gnutls_transport_ptr_t recv_ptr,
+                                MHD_gnutls_transport_ptr_t send_ptr)
 {
   session->internals.transport_send_ptr = send_ptr;
   session->internals.transport_recv_ptr = recv_ptr;
@@ -188,7 +188,7 @@ MHD__gnutls_bye (MHD_gtls_session_t session, MHD_gnutls_close_request_t how)
     case STATE61:
       ret =
         MHD__gnutls_alert_send (session, GNUTLS_AL_WARNING,
-                               GNUTLS_A_CLOSE_NOTIFY);
+                                GNUTLS_A_CLOSE_NOTIFY);
       STATE = STATE61;
       if (ret < 0)
         {
@@ -258,7 +258,8 @@ session_is_valid (MHD_gtls_session_t session)
  */
 inline static void
 copy_record_version (MHD_gtls_session_t session,
-                     MHD_gnutls_handshake_description_t htype, opaque version[2])
+                     MHD_gnutls_handshake_description_t htype,
+                     opaque version[2])
 {
   enum MHD_GNUTLS_Protocol lver;
 
@@ -331,8 +332,8 @@ MHD_gtls_send_int (MHD_gtls_session_t session,
 
   MHD__gnutls_record_log
     ("REC[%x]: Sending Packet[%d] %s(%d) with length: %d\n", session,
-     (int) MHD_gtls_uint64touint32 (&session->connection_state.
-                                    write_sequence_number),
+     (int) MHD_gtls_uint64touint32 (&session->
+                                    connection_state.write_sequence_number),
      MHD__gnutls_packet2str (type), type, sizeofdata);
 
   if (sizeofdata > MAX_RECORD_SEND_SIZE)
@@ -424,11 +425,11 @@ MHD_gtls_send_int (MHD_gtls_session_t session,
   session->internals.record_send_buffer_user_size = 0;
 
   MHD__gnutls_record_log ("REC[%x]: Sent Packet[%d] %s(%d) with length: %d\n",
-                      session,
-                      (int)
-                      MHD_gtls_uint64touint32
-                      (&session->connection_state.write_sequence_number),
-                      MHD__gnutls_packet2str (type), type, cipher_size);
+                          session,
+                          (int)
+                          MHD_gtls_uint64touint32
+                          (&session->connection_state.write_sequence_number),
+                          MHD__gnutls_packet2str (type), type, cipher_size);
 
   return retval;
 }
@@ -547,7 +548,7 @@ record_check_headers (MHD_gtls_session_t session,
       session->internals.v2_hello = *length;
 
       MHD__gnutls_record_log ("REC[%x]: V2 packet received. Length: %d\n",
-                          session, *length);
+                              session, *length);
 
     }
   else
@@ -570,7 +571,8 @@ record_check_headers (MHD_gtls_session_t session,
  */
 inline static int
 record_check_version (MHD_gtls_session_t session,
-                      MHD_gnutls_handshake_description_t htype, opaque version[2])
+                      MHD_gnutls_handshake_description_t htype,
+                      opaque version[2])
 {
   if (htype == GNUTLS_HANDSHAKE_CLIENT_HELLO)
     {
@@ -595,7 +597,7 @@ record_check_version (MHD_gtls_session_t session,
        */
       MHD_gnutls_assert ();
       MHD__gnutls_record_log ("REC[%x]: INVALID VERSION PACKET: (%d) %d.%d\n",
-                          session, htype, version[0], version[1]);
+                              session, htype, version[0], version[1]);
 
       return GNUTLS_E_UNSUPPORTED_VERSION_PACKET;
     }
@@ -769,7 +771,8 @@ get_temp_recv_buffer (MHD_gtls_session_t session, MHD_gnutls_datum_t * tmp)
        */
       session->internals.recv_buffer.data
         =
-        MHD_gnutls_realloc (session->internals.recv_buffer.data, max_record_size);
+        MHD_gnutls_realloc (session->internals.recv_buffer.data,
+                            max_record_size);
 
       if (session->internals.recv_buffer.data == NULL)
         {
@@ -895,15 +898,14 @@ begin:
 
   MHD__gnutls_record_log
     ("REC[%x]: Expected Packet[%d] %s(%d) with length: %d\n", session,
-     (int) MHD_gtls_uint64touint32 (&session->connection_state.
-                                    read_sequence_number),
+     (int) MHD_gtls_uint64touint32 (&session->
+                                    connection_state.read_sequence_number),
      MHD__gnutls_packet2str (type), type, sizeofdata);
-  MHD__gnutls_record_log ("REC[%x]: Received Packet[%d] %s(%d) with length: %d\n",
-                      session,
-                      (int)
-                      MHD_gtls_uint64touint32 (&session->connection_state.
-                                               read_sequence_number),
-                      MHD__gnutls_packet2str (recv_type), recv_type, length);
+  MHD__gnutls_record_log
+    ("REC[%x]: Received Packet[%d] %s(%d) with length: %d\n", session,
+     (int) MHD_gtls_uint64touint32 (&session->
+                                    connection_state.read_sequence_number),
+     MHD__gnutls_packet2str (recv_type), recv_type, length);
 
   if (length > MAX_RECV_SIZE)
     {
@@ -978,8 +980,8 @@ begin:
 
   MHD__gnutls_record_log
     ("REC[%x]: Decrypted Packet[%d] %s(%d) with length: %d\n", session,
-     (int) MHD_gtls_uint64touint32 (&session->connection_state.
-                                    read_sequence_number),
+     (int) MHD_gtls_uint64touint32 (&session->
+                                    connection_state.read_sequence_number),
      MHD__gnutls_packet2str (recv_type), recv_type, decrypted_length);
 
   /* increase sequence number
@@ -1082,7 +1084,7 @@ begin:
  **/
 ssize_t
 MHD__gnutls_record_send (MHD_gtls_session_t session,
-                        const void *data, size_t sizeofdata)
+                         const void *data, size_t sizeofdata)
 {
   return MHD_gtls_send_int (session, GNUTLS_APPLICATION_DATA, -1, data,
                             sizeofdata);
@@ -1120,7 +1122,7 @@ MHD__gnutls_record_send (MHD_gtls_session_t session,
  **/
 ssize_t
 MHD__gnutls_record_recv (MHD_gtls_session_t session, void *data,
-                        size_t sizeofdata)
+                         size_t sizeofdata)
 {
   return MHD_gtls_recv_int (session, GNUTLS_APPLICATION_DATA, -1, data,
                             sizeofdata);
diff --git a/src/daemon/https/tls/gnutls_rsa_export.c b/src/daemon/https/tls/gnutls_rsa_export.c
index d48ee327..65f97c76 100644
--- a/src/daemon/https/tls/gnutls_rsa_export.c
+++ b/src/daemon/https/tls/gnutls_rsa_export.c
@@ -61,4 +61,3 @@ MHD__gnutls_rsa_params_deinit (MHD_gtls_rsa_params_t rsa_params)
 {
   MHD_gnutls_x509_privkey_deinit (rsa_params);
 }
-
diff --git a/src/daemon/https/tls/gnutls_rsa_export.h b/src/daemon/https/tls/gnutls_rsa_export.h
index a34dfe9d..a28f4297 100644
--- a/src/daemon/https/tls/gnutls_rsa_export.h
+++ b/src/daemon/https/tls/gnutls_rsa_export.h
@@ -24,4 +24,3 @@
 
 const mpi_t *MHD__gnutls_rsa_params_to_mpi (MHD_gtls_rsa_params_t);
 int MHD__gnutls_peers_cert_less_512 (MHD_gtls_session_t session);
-
diff --git a/src/daemon/https/tls/gnutls_session.c b/src/daemon/https/tls/gnutls_session.c
index 81a56d5c..b7ba3764 100644
--- a/src/daemon/https/tls/gnutls_session.c
+++ b/src/daemon/https/tls/gnutls_session.c
@@ -69,4 +69,3 @@ MHD_gtls_session_get_id (MHD_gtls_session_t session,
 
   return 0;
 }
-
diff --git a/src/daemon/https/tls/gnutls_session_pack.c b/src/daemon/https/tls/gnutls_session_pack.c
index 258cd9c2..ab359f6c 100644
--- a/src/daemon/https/tls/gnutls_session_pack.c
+++ b/src/daemon/https/tls/gnutls_session_pack.c
@@ -50,7 +50,8 @@ static int unpack_certificate_auth_info (MHD_gtls_session_t,
                                          packed_session);
 
 static int unpack_security_parameters (MHD_gtls_session_t session,
-                                       const MHD_gnutls_datum_t * packed_session);
+                                       const MHD_gnutls_datum_t *
+                                       packed_session);
 static int pack_security_parameters (MHD_gtls_session_t session,
                                      MHD_gnutls_datum_t * packed_session);
 
@@ -180,7 +181,8 @@ unpack_anon_auth_info (MHD_gtls_session_t session,
 
   size = MHD_gtls_read_uint32 (&packed_session->data[pos]);
   pos += 4;
-  ret = MHD__gnutls_set_datum (&info->dh.prime, &packed_session->data[pos], size);
+  ret =
+    MHD__gnutls_set_datum (&info->dh.prime, &packed_session->data[pos], size);
   if (ret < 0)
     {
       MHD_gnutls_assert ();
@@ -191,7 +193,8 @@ unpack_anon_auth_info (MHD_gtls_session_t session,
   size = MHD_gtls_read_uint32 (&packed_session->data[pos]);
   pos += 4;
   ret =
-    MHD__gnutls_set_datum (&info->dh.generator, &packed_session->data[pos], size);
+    MHD__gnutls_set_datum (&info->dh.generator, &packed_session->data[pos],
+                           size);
   if (ret < 0)
     {
       MHD_gnutls_assert ();
@@ -203,7 +206,7 @@ unpack_anon_auth_info (MHD_gtls_session_t session,
   pos += 4;
   ret =
     MHD__gnutls_set_datum (&info->dh.public_key, &packed_session->data[pos],
-                       size);
+                           size);
   if (ret < 0)
     {
       MHD_gnutls_assert ();
@@ -534,7 +537,8 @@ unpack_certificate_auth_info (MHD_gtls_session_t session,
 
   size = MHD_gtls_read_uint32 (&packed_session->data[pos]);
   pos += 4;
-  ret = MHD__gnutls_set_datum (&info->dh.prime, &packed_session->data[pos], size);
+  ret =
+    MHD__gnutls_set_datum (&info->dh.prime, &packed_session->data[pos], size);
   if (ret < 0)
     {
       MHD_gnutls_assert ();
@@ -545,7 +549,8 @@ unpack_certificate_auth_info (MHD_gtls_session_t session,
   size = MHD_gtls_read_uint32 (&packed_session->data[pos]);
   pos += 4;
   ret =
-    MHD__gnutls_set_datum (&info->dh.generator, &packed_session->data[pos], size);
+    MHD__gnutls_set_datum (&info->dh.generator, &packed_session->data[pos],
+                           size);
   if (ret < 0)
     {
       MHD_gnutls_assert ();
@@ -557,7 +562,7 @@ unpack_certificate_auth_info (MHD_gtls_session_t session,
   pos += 4;
   ret =
     MHD__gnutls_set_datum (&info->dh.public_key, &packed_session->data[pos],
-                       size);
+                           size);
   if (ret < 0)
     {
       MHD_gnutls_assert ();
@@ -569,7 +574,7 @@ unpack_certificate_auth_info (MHD_gtls_session_t session,
   pos += 4;
   ret =
     MHD__gnutls_set_datum (&info->rsa_export.modulus,
-                       &packed_session->data[pos], size);
+                           &packed_session->data[pos], size);
   if (ret < 0)
     {
       MHD_gnutls_assert ();
@@ -581,7 +586,7 @@ unpack_certificate_auth_info (MHD_gtls_session_t session,
   pos += 4;
   ret =
     MHD__gnutls_set_datum (&info->rsa_export.exponent,
-                       &packed_session->data[pos], size);
+                           &packed_session->data[pos], size);
   if (ret < 0)
     {
       MHD_gnutls_assert ();
@@ -611,7 +616,7 @@ unpack_certificate_auth_info (MHD_gtls_session_t session,
 
       ret =
         MHD__gnutls_set_datum (&info->raw_certificate_list[i],
-                           &packed_session->data[pos], size);
+                               &packed_session->data[pos], size);
       pos += size;
 
       if (ret < 0)
@@ -881,7 +886,8 @@ unpack_psk_auth_info (MHD_gtls_session_t session,
 
   size = MHD_gtls_read_uint32 (&packed_session->data[pos]);
   pos += 4;
-  ret = MHD__gnutls_set_datum (&info->dh.prime, &packed_session->data[pos], size);
+  ret =
+    MHD__gnutls_set_datum (&info->dh.prime, &packed_session->data[pos], size);
   if (ret < 0)
     {
       MHD_gnutls_assert ();
@@ -892,7 +898,8 @@ unpack_psk_auth_info (MHD_gtls_session_t session,
   size = MHD_gtls_read_uint32 (&packed_session->data[pos]);
   pos += 4;
   ret =
-    MHD__gnutls_set_datum (&info->dh.generator, &packed_session->data[pos], size);
+    MHD__gnutls_set_datum (&info->dh.generator, &packed_session->data[pos],
+                           size);
   if (ret < 0)
     {
       MHD_gnutls_assert ();
@@ -904,7 +911,7 @@ unpack_psk_auth_info (MHD_gtls_session_t session,
   pos += 4;
   ret =
     MHD__gnutls_set_datum (&info->dh.public_key, &packed_session->data[pos],
-                       size);
+                           size);
   if (ret < 0)
     {
       MHD_gnutls_assert ();
@@ -1045,8 +1052,9 @@ pack_security_parameters (MHD_gtls_session_t session,
           session->security_parameters.extensions.srp_username, len);
   pos += len;
 
-  MHD_gtls_write_uint16 (session->security_parameters.extensions.
-                         server_names_size, &packed_session->data[pos]);
+  MHD_gtls_write_uint16 (session->security_parameters.
+                         extensions.server_names_size,
+                         &packed_session->data[pos]);
   pos += 2;
 
   for (i = 0; i < session->security_parameters.extensions.server_names_size;
@@ -1054,15 +1062,15 @@ pack_security_parameters (MHD_gtls_session_t session,
     {
       packed_session->data[pos++] =
         session->security_parameters.extensions.server_names[i].type;
-      MHD_gtls_write_uint16 (session->security_parameters.extensions.
-                             server_names[i].name_length,
+      MHD_gtls_write_uint16 (session->security_parameters.
+                             extensions.server_names[i].name_length,
                              &packed_session->data[pos]);
       pos += 2;
 
       memcpy (&packed_session->data[pos],
               session->security_parameters.extensions.server_names[i].name,
-              session->security_parameters.extensions.server_names[i].
-              name_length);
+              session->security_parameters.extensions.
+              server_names[i].name_length);
       pos +=
         session->security_parameters.extensions.server_names[i].name_length;
     }
@@ -1121,10 +1129,10 @@ unpack_security_parameters (MHD_gtls_session_t session,
     packed_session->data[pos++];
   session->internals.resumed_security_parameters.write_compression_algorithm =
     packed_session->data[pos++];
-  session->internals.resumed_security_parameters.current_cipher_suite.
-    suite[0] = packed_session->data[pos++];
-  session->internals.resumed_security_parameters.current_cipher_suite.
-    suite[1] = packed_session->data[pos++];
+  session->internals.resumed_security_parameters.
+    current_cipher_suite.suite[0] = packed_session->data[pos++];
+  session->internals.resumed_security_parameters.
+    current_cipher_suite.suite[1] = packed_session->data[pos++];
 
   session->internals.resumed_security_parameters.cert_type =
     packed_session->data[pos++];
@@ -1173,34 +1181,35 @@ unpack_security_parameters (MHD_gtls_session_t session,
 
   /* SRP */
   len = packed_session->data[pos++];    /* srp username length */
-  memcpy (session->internals.resumed_security_parameters.extensions.
-          srp_username, &packed_session->data[pos], len);
-  session->internals.resumed_security_parameters.extensions.
-    srp_username[len] = 0;
+  memcpy (session->internals.resumed_security_parameters.
+          extensions.srp_username, &packed_session->data[pos], len);
+  session->internals.resumed_security_parameters.
+    extensions.srp_username[len] = 0;
   pos += len;
 
-  session->internals.resumed_security_parameters.extensions.
-    server_names_size = MHD_gtls_read_uint16 (&packed_session->data[pos]);
+  session->internals.resumed_security_parameters.
+    extensions.server_names_size =
+    MHD_gtls_read_uint16 (&packed_session->data[pos]);
   pos += 2;
   for (i = 0;
        i <
-       session->internals.resumed_security_parameters.extensions.
-       server_names_size; i++)
+       session->internals.resumed_security_parameters.
+       extensions.server_names_size; i++)
     {
-      session->internals.resumed_security_parameters.extensions.
-        server_names[i].type = packed_session->data[pos++];
-      session->internals.resumed_security_parameters.extensions.
-        server_names[i].name_length =
+      session->internals.resumed_security_parameters.
+        extensions.server_names[i].type = packed_session->data[pos++];
+      session->internals.resumed_security_parameters.
+        extensions.server_names[i].name_length =
         MHD_gtls_read_uint16 (&packed_session->data[pos]);
       pos += 2;
 
-      memcpy (session->internals.resumed_security_parameters.extensions.
-              server_names[i].name, &packed_session->data[pos],
-              session->internals.resumed_security_parameters.extensions.
-              server_names[i].name_length);
+      memcpy (session->internals.resumed_security_parameters.
+              extensions.server_names[i].name, &packed_session->data[pos],
+              session->internals.resumed_security_parameters.
+              extensions.server_names[i].name_length);
       pos +=
-        session->internals.resumed_security_parameters.extensions.
-        server_names[i].name_length;
+        session->internals.resumed_security_parameters.
+        extensions.server_names[i].name_length;
     }
   return 0;
 }
diff --git a/src/daemon/https/tls/gnutls_sig.c b/src/daemon/https/tls/gnutls_sig.c
index 0309e588..fcd756b5 100644
--- a/src/daemon/https/tls/gnutls_sig.c
+++ b/src/daemon/https/tls/gnutls_sig.c
@@ -38,10 +38,10 @@
 #include <gnutls_kx.h>
 
 static int MHD__gnutls_tls_sign (MHD_gtls_session_t session,
-                             MHD_gnutls_cert * cert,
-                             MHD_gnutls_privkey * pkey,
-                             const MHD_gnutls_datum_t * hash_concat,
-                             MHD_gnutls_datum_t * signature);
+                                 MHD_gnutls_cert * cert,
+                                 MHD_gnutls_privkey * pkey,
+                                 const MHD_gnutls_datum_t * hash_concat,
+                                 MHD_gnutls_datum_t * signature);
 
 /* Generates a signature of all the previous sent packets in the
  * handshake procedure. (20040227: now it works for SSL 3.0 as well)
@@ -49,7 +49,8 @@ static int MHD__gnutls_tls_sign (MHD_gtls_session_t session,
 int
 MHD_gtls_tls_sign_hdata (MHD_gtls_session_t session,
                          MHD_gnutls_cert * cert,
-                         MHD_gnutls_privkey * pkey, MHD_gnutls_datum_t * signature)
+                         MHD_gnutls_privkey * pkey,
+                         MHD_gnutls_datum_t * signature)
 {
   MHD_gnutls_datum_t dconcat;
   int ret;
@@ -75,8 +76,9 @@ MHD_gtls_tls_sign_hdata (MHD_gtls_session_t session,
         }
 
       MHD_gnutls_mac_deinit_ssl3_handshake (td_sha, &concat[16],
-                                            session->security_parameters.
-                                            master_secret, TLS_MASTER_SIZE);
+                                            session->
+                                            security_parameters.master_secret,
+                                            TLS_MASTER_SIZE);
     }
   else
     MHD_gnutls_hash_deinit (td_sha, &concat[16]);
@@ -94,8 +96,9 @@ MHD_gtls_tls_sign_hdata (MHD_gtls_session_t session,
 
       if (ver == MHD_GNUTLS_PROTOCOL_SSL3)
         MHD_gnutls_mac_deinit_ssl3_handshake (td_md5, concat,
-                                              session->security_parameters.
-                                              master_secret, TLS_MASTER_SIZE);
+                                              session->
+                                              security_parameters.master_secret,
+                                              TLS_MASTER_SIZE);
       else
         MHD_gnutls_hash_deinit (td_md5, concat);
 
@@ -122,7 +125,8 @@ int
 MHD_gtls_tls_sign_params (MHD_gtls_session_t session,
                           MHD_gnutls_cert * cert,
                           MHD_gnutls_privkey * pkey,
-                          MHD_gnutls_datum_t * params, MHD_gnutls_datum_t * signature)
+                          MHD_gnutls_datum_t * params,
+                          MHD_gnutls_datum_t * signature)
 {
   MHD_gnutls_datum_t dconcat;
   int ret;
@@ -207,7 +211,8 @@ int
 MHD_gtls_sign (enum MHD_GNUTLS_PublicKeyAlgorithm algo,
                mpi_t * params,
                int params_size,
-               const MHD_gnutls_datum_t * data, MHD_gnutls_datum_t * signature)
+               const MHD_gnutls_datum_t * data,
+               MHD_gnutls_datum_t * signature)
 {
   int ret;
 
@@ -239,10 +244,10 @@ MHD_gtls_sign (enum MHD_GNUTLS_PublicKeyAlgorithm algo,
  */
 static int
 MHD__gnutls_tls_sign (MHD_gtls_session_t session,
-                  MHD_gnutls_cert * cert,
-                  MHD_gnutls_privkey * pkey,
-                  const MHD_gnutls_datum_t * hash_concat,
-                  MHD_gnutls_datum_t * signature)
+                      MHD_gnutls_cert * cert,
+                      MHD_gnutls_privkey * pkey,
+                      const MHD_gnutls_datum_t * hash_concat,
+                      MHD_gnutls_datum_t * signature)
 {
 
   /* If our certificate supports signing
@@ -263,8 +268,8 @@ MHD__gnutls_tls_sign (MHD_gtls_session_t session,
         return GNUTLS_E_INSUFFICIENT_CREDENTIALS;
 
       return (*session->internals.sign_func) (session,
-                                              session->internals.
-                                              sign_func_userdata,
+                                              session->
+                                              internals.sign_func_userdata,
                                               cert->cert_type, &cert->raw,
                                               hash_concat, signature);
     }
@@ -275,13 +280,13 @@ MHD__gnutls_tls_sign (MHD_gtls_session_t session,
 
 static int
 MHD__gnutls_verify_sig (MHD_gnutls_cert * cert,
-                    const MHD_gnutls_datum_t * hash_concat,
-                    MHD_gnutls_datum_t * signature, size_t sha1pos)
+                        const MHD_gnutls_datum_t * hash_concat,
+                        MHD_gnutls_datum_t * signature, size_t sha1pos)
 {
   int ret;
   MHD_gnutls_datum_t vdata;
 
-  if ( (cert == NULL) || (cert->version == 0) )
+  if ((cert == NULL) || (cert->version == 0))
     {                           /* this is the only way to check
                                  * if it is initialized
                                  */
@@ -328,7 +333,8 @@ MHD__gnutls_verify_sig (MHD_gnutls_cert * cert,
  */
 int
 MHD_gtls_verify_sig_hdata (MHD_gtls_session_t session,
-                           MHD_gnutls_cert * cert, MHD_gnutls_datum_t * signature)
+                           MHD_gnutls_cert * cert,
+                           MHD_gnutls_datum_t * signature)
 {
   int ret;
   opaque concat[36];
@@ -362,11 +368,13 @@ MHD_gtls_verify_sig_hdata (MHD_gtls_session_t session,
         }
 
       MHD_gnutls_mac_deinit_ssl3_handshake (td_md5, concat,
-                                            session->security_parameters.
-                                            master_secret, TLS_MASTER_SIZE);
+                                            session->
+                                            security_parameters.master_secret,
+                                            TLS_MASTER_SIZE);
       MHD_gnutls_mac_deinit_ssl3_handshake (td_sha, &concat[16],
-                                            session->security_parameters.
-                                            master_secret, TLS_MASTER_SIZE);
+                                            session->
+                                            security_parameters.master_secret,
+                                            TLS_MASTER_SIZE);
     }
   else
     {
diff --git a/src/daemon/https/tls/gnutls_sig.h b/src/daemon/https/tls/gnutls_sig.h
index 6259191d..19793020 100644
--- a/src/daemon/https/tls/gnutls_sig.h
+++ b/src/daemon/https/tls/gnutls_sig.h
@@ -47,6 +47,7 @@ int MHD_gtls_verify_sig_params (MHD_gtls_session_t session,
 
 int MHD_gtls_sign (enum MHD_GNUTLS_PublicKeyAlgorithm algo,
                    mpi_t * params, int params_size,
-                   const MHD_gnutls_datum_t * data, MHD_gnutls_datum_t * signature);
+                   const MHD_gnutls_datum_t * data,
+                   MHD_gnutls_datum_t * signature);
 
 #endif
diff --git a/src/daemon/https/tls/gnutls_state.c b/src/daemon/https/tls/gnutls_state.c
index 49802b2e..4f4ea122 100644
--- a/src/daemon/https/tls/gnutls_state.c
+++ b/src/daemon/https/tls/gnutls_state.c
@@ -44,7 +44,7 @@
 
 void
 MHD__gnutls_session_cert_type_set (MHD_gtls_session_t session,
-                               enum MHD_GNUTLS_CertificateType ct)
+                                   enum MHD_GNUTLS_CertificateType ct)
 {
   session->security_parameters.cert_type = ct;
 }
@@ -236,7 +236,7 @@ MHD_gtls_handshake_internal_state_clear (MHD_gtls_session_t session)
 /* TODO rm redundent pointer ref */
 int
 MHD__gnutls_init (MHD_gtls_session_t * session,
-                 MHD_gnutls_connection_end_t con_end)
+                  MHD_gnutls_connection_end_t con_end)
 {
   *session = MHD_gnutls_calloc (1, sizeof (struct MHD_gtls_session_int));
   if (*session == NULL)
@@ -286,10 +286,10 @@ MHD__gnutls_init (MHD_gtls_session_t * session,
 
   MHD__gnutls_dh_set_prime_bits ((*session), MIN_DH_BITS);
 
-  MHD__gnutls_transport_set_lowat ((*session), DEFAULT_LOWAT);   /* the default for tcp */
+  MHD__gnutls_transport_set_lowat ((*session), DEFAULT_LOWAT);  /* the default for tcp */
 
   MHD__gnutls_handshake_set_max_packet_length ((*session),
-                                              MAX_HANDSHAKE_PACKET_SIZE);
+                                               MAX_HANDSHAKE_PACKET_SIZE);
 
   /* Allocate a minimum size for recv_data
    * This is allocated in order to avoid small messages, making
@@ -612,7 +612,7 @@ MHD_gtls_dh_set_group (MHD_gtls_session_t session, mpi_t gen, mpi_t prime)
  **/
 void
 MHD__gnutls_certificate_send_x509_rdn_sequence (MHD_gtls_session_t session,
-                                               int status)
+                                                int status)
 {
   session->internals.ignore_rdn_sequence = status;
 }
@@ -630,7 +630,8 @@ MHD__gnutls_certificate_send_x509_rdn_sequence (MHD_gtls_session_t session,
  -*/
 void
 MHD__gnutls_record_set_default_version (MHD_gtls_session_t session,
-                                    unsigned char major, unsigned char minor)
+                                        unsigned char major,
+                                        unsigned char minor)
 {
   session->internals.default_record_version[0] = major;
   session->internals.default_record_version[1] = minor;
@@ -661,9 +662,9 @@ MHD_gtls_handshake_set_private_extensions (MHD_gtls_session_t session,
 
 inline static int
 MHD__gnutls_cal_PRF_A (enum MHD_GNUTLS_HashAlgorithm algorithm,
-                   const void *secret,
-                   int secret_size,
-                   const void *seed, int seed_size, void *result)
+                       const void *secret,
+                       int secret_size,
+                       const void *seed, int seed_size, void *result)
 {
   mac_hd_t td1;
 
@@ -687,10 +688,10 @@ MHD__gnutls_cal_PRF_A (enum MHD_GNUTLS_HashAlgorithm algorithm,
  */
 static int
 MHD__gnutls_P_hash (enum MHD_GNUTLS_HashAlgorithm algorithm,
-                const opaque * secret,
-                int secret_size,
-                const opaque * seed,
-                int seed_size, int total_bytes, opaque * ret)
+                    const opaque * secret,
+                    int secret_size,
+                    const opaque * seed,
+                    int seed_size, int total_bytes, opaque * ret)
 {
 
   mac_hd_t td2;
@@ -730,8 +731,9 @@ MHD__gnutls_P_hash (enum MHD_GNUTLS_HashAlgorithm algorithm,
         }
 
       /* here we calculate A(i+1) */
-      if ((result = MHD__gnutls_cal_PRF_A (algorithm, secret, secret_size, Atmp,
-                                       A_size, Atmp)) < 0)
+      if ((result =
+           MHD__gnutls_cal_PRF_A (algorithm, secret, secret_size, Atmp,
+                                  A_size, Atmp)) < 0)
         {
           MHD_gnutls_assert ();
           MHD_gnutls_MHD_hmac_deinit (td2, final);
@@ -816,7 +818,7 @@ MHD_gtls_PRF (MHD_gtls_session_t session,
     {
       result =
         MHD__gnutls_P_hash (MHD_GNUTLS_MAC_SHA1, secret, secret_size, s_seed,
-                        s_seed_size, total_bytes, ret);
+                            s_seed_size, total_bytes, ret);
       if (result < 0)
         {
           MHD_gnutls_assert ();
@@ -837,7 +839,7 @@ MHD_gtls_PRF (MHD_gtls_session_t session,
 
       result =
         MHD__gnutls_P_hash (MHD_GNUTLS_MAC_MD5, s1, l_s, s_seed, s_seed_size,
-                        total_bytes, o1);
+                            total_bytes, o1);
       if (result < 0)
         {
           MHD_gnutls_assert ();
@@ -846,7 +848,7 @@ MHD_gtls_PRF (MHD_gtls_session_t session,
 
       result =
         MHD__gnutls_P_hash (MHD_GNUTLS_MAC_SHA1, s2, l_s, s_seed, s_seed_size,
-                        total_bytes, o2);
+                            total_bytes, o2);
       if (result < 0)
         {
           MHD_gnutls_assert ();
@@ -893,10 +895,10 @@ MHD_gtls_PRF (MHD_gtls_session_t session,
  **/
 int
 MHD__gnutls_prf_raw (MHD_gtls_session_t session,
-                    size_t label_size,
-                    const char *label,
-                    size_t seed_size, const char *seed, size_t outsize,
-                    char *out)
+                     size_t label_size,
+                     const char *label,
+                     size_t seed_size, const char *seed, size_t outsize,
+                     char *out)
 {
   int ret;
 
@@ -938,11 +940,11 @@ MHD__gnutls_prf_raw (MHD_gtls_session_t session,
  **/
 int
 MHD__gnutls_prf (MHD_gtls_session_t session,
-                size_t label_size,
-                const char *label,
-                int server_random_first,
-                size_t extra_size, const char *extra, size_t outsize,
-                char *out)
+                 size_t label_size,
+                 const char *label,
+                 int server_random_first,
+                 size_t extra_size, const char *extra, size_t outsize,
+                 char *out)
 {
   int ret;
   opaque *seed;
@@ -1050,8 +1052,8 @@ MHD_gtls_session_is_resumed (MHD_gtls_session_t session)
           && session->security_parameters.session_id_size
           == session->internals.resumed_security_parameters.session_id_size
           && memcmp (session->security_parameters.session_id,
-                     session->internals.resumed_security_parameters.
-                     session_id,
+                     session->internals.
+                     resumed_security_parameters.session_id,
                      session->security_parameters.session_id_size) == 0)
         return 1;
     }
@@ -1078,8 +1080,8 @@ MHD_gtls_session_is_export (MHD_gtls_session_t session)
   enum MHD_GNUTLS_CipherAlgorithm cipher;
 
   cipher =
-    MHD_gtls_cipher_suite_get_cipher_algo (&session->security_parameters.
-                                           current_cipher_suite);
+    MHD_gtls_cipher_suite_get_cipher_algo (&session->
+                                           security_parameters.current_cipher_suite);
 
   if (MHD_gtls_cipher_get_export_flag (cipher) != 0)
     return 1;
@@ -1151,7 +1153,7 @@ MHD__gnutls_record_get_direction (MHD_gtls_session_t session)
  -*/
 void
 MHD__gnutls_rsa_pms_set_version (MHD_gtls_session_t session,
-                             unsigned char major, unsigned char minor)
+                                 unsigned char major, unsigned char minor)
 {
   session->internals.rsa_pms_version[0] = major;
   session->internals.rsa_pms_version[1] = minor;
@@ -1181,9 +1183,9 @@ MHD__gnutls_rsa_pms_set_version (MHD_gtls_session_t session,
  **/
 void
 MHD__gnutls_handshake_set_post_client_hello_function (MHD_gtls_session_t
-                                                     session,
-                                                     MHD_gnutls_handshake_post_client_hello_func
-                                                     func)
+                                                      session,
+                                                      MHD_gnutls_handshake_post_client_hello_func
+                                                      func)
 {
   session->internals.user_hello_func = func;
 }
diff --git a/src/daemon/https/tls/gnutls_state.h b/src/daemon/https/tls/gnutls_state.h
index 34aeda93..a6ff5892 100644
--- a/src/daemon/https/tls/gnutls_state.h
+++ b/src/daemon/https/tls/gnutls_state.h
@@ -28,11 +28,11 @@
 #include <gnutls_int.h>
 
 void MHD__gnutls_session_cert_type_set (MHD_gtls_session_t session,
-                                    enum MHD_GNUTLS_CertificateType);
+                                        enum MHD_GNUTLS_CertificateType);
 enum MHD_GNUTLS_KeyExchangeAlgorithm MHD_gnutls_kx_get (MHD_gtls_session_t
-                                                    session);
+                                                        session);
 enum MHD_GNUTLS_CipherAlgorithm MHD_gnutls_cipher_get (MHD_gtls_session_t
-                                                   session);
+                                                       session);
 enum MHD_GNUTLS_CertificateType
 MHD_gnutls_certificate_type_get (MHD_gtls_session_t);
 
@@ -72,6 +72,6 @@ int MHD_gtls_PRF (MHD_gtls_session_t session,
                   int total_bytes, void *ret);
 
 int MHD__gnutls_init (MHD_gtls_session_t * session,
-                     MHD_gnutls_connection_end_t con_end);
+                      MHD_gnutls_connection_end_t con_end);
 
 #define DEFAULT_CERT_TYPE MHD_GNUTLS_CRT_X509
diff --git a/src/daemon/https/tls/gnutls_str.h b/src/daemon/https/tls/gnutls_str.h
index bedee1df..befa957e 100644
--- a/src/daemon/https/tls/gnutls_str.h
+++ b/src/daemon/https/tls/gnutls_str.h
@@ -43,7 +43,8 @@ typedef struct
 } MHD_gtls_string;
 
 void MHD_gtls_string_init (MHD_gtls_string *, MHD_gnutls_alloc_function,
-                           MHD_gnutls_realloc_function, MHD_gnutls_free_function);
+                           MHD_gnutls_realloc_function,
+                           MHD_gnutls_free_function);
 void MHD_gtls_string_clear (MHD_gtls_string *);
 
 /* Beware, do not clear the string, after calling this
diff --git a/src/daemon/https/tls/gnutls_supplemental.c b/src/daemon/https/tls/gnutls_supplemental.c
index 7b265031..0419917c 100644
--- a/src/daemon/https/tls/gnutls_supplemental.c
+++ b/src/daemon/https/tls/gnutls_supplemental.c
@@ -68,7 +68,8 @@ MHD_gnutls_supplemental_entry MHD__gnutls_supplemental[] = {
 };
 
 const char *
-MHD_gtls_supplemental_get_name (MHD_gnutls_supplemental_data_format_type_t type)
+MHD_gtls_supplemental_get_name (MHD_gnutls_supplemental_data_format_type_t
+                                type)
 {
   MHD_gnutls_supplemental_entry *p;
 
@@ -92,7 +93,8 @@ get_supp_func_recv (MHD_gnutls_supplemental_data_format_type_t type)
 }
 
 int
-MHD__gnutls_gen_supplemental (MHD_gtls_session_t session, MHD_gtls_buffer * buf)
+MHD__gnutls_gen_supplemental (MHD_gtls_session_t session,
+                              MHD_gtls_buffer * buf)
 {
   MHD_gnutls_supplemental_entry *p;
   int ret;
@@ -143,14 +145,14 @@ MHD__gnutls_gen_supplemental (MHD_gtls_session_t session, MHD_gtls_buffer * buf)
   buf->data[2] = (buf->length - 3) & 0xFF;
 
   MHD__gnutls_debug_log ("EXT[%x]: Sending %d bytes of supplemental data\n",
-                     session, buf->length);
+                         session, buf->length);
 
   return buf->length;
 }
 
 int
 MHD__gnutls_parse_supplemental (MHD_gtls_session_t session,
-                            const uint8_t * data, int datalen)
+                                const uint8_t * data, int datalen)
 {
   const opaque *p = data;
   ssize_t dsize = datalen;
@@ -180,8 +182,9 @@ MHD__gnutls_parse_supplemental (MHD_gtls_session_t session,
       supp_data_length = MHD_gtls_read_uint16 (p);
       p += 2;
 
-      MHD__gnutls_debug_log ("EXT[%x]: Got supplemental type=%02x length=%d\n",
-                         session, supp_data_type, supp_data_length);
+      MHD__gnutls_debug_log
+        ("EXT[%x]: Got supplemental type=%02x length=%d\n", session,
+         supp_data_type, supp_data_length);
 
       recv_func = get_supp_func_recv (supp_data_type);
       if (recv_func)
diff --git a/src/daemon/https/tls/gnutls_supplemental.h b/src/daemon/https/tls/gnutls_supplemental.h
index a215ab56..b7ad0c29 100644
--- a/src/daemon/https/tls/gnutls_supplemental.h
+++ b/src/daemon/https/tls/gnutls_supplemental.h
@@ -25,6 +25,6 @@
 #include <gnutls_int.h>
 
 int MHD__gnutls_parse_supplemental (MHD_gtls_session_t session,
-                                const uint8_t * data, int data_size);
+                                    const uint8_t * data, int data_size);
 int MHD__gnutls_gen_supplemental (MHD_gtls_session_t session,
-                              MHD_gtls_buffer * buf);
+                                  MHD_gtls_buffer * buf);
diff --git a/src/daemon/https/tls/gnutls_ui.c b/src/daemon/https/tls/gnutls_ui.c
index 7709b2b7..a2594332 100644
--- a/src/daemon/https/tls/gnutls_ui.c
+++ b/src/daemon/https/tls/gnutls_ui.c
@@ -74,7 +74,8 @@ MHD__gnutls_dh_set_prime_bits (MHD_gtls_session_t session, unsigned int bits)
  **/
 int
 MHD__gnutls_dh_get_group (MHD_gtls_session_t session,
-                         MHD_gnutls_datum_t * raw_gen, MHD_gnutls_datum_t * raw_prime)
+                          MHD_gnutls_datum_t * raw_gen,
+                          MHD_gnutls_datum_t * raw_prime)
 {
   MHD_gtls_dh_info_st *dh;
   int ret;
@@ -107,7 +108,8 @@ MHD__gnutls_dh_get_group (MHD_gtls_session_t session,
       return ret;
     }
 
-  ret = MHD__gnutls_set_datum (raw_gen, dh->generator.data, dh->generator.size);
+  ret =
+    MHD__gnutls_set_datum (raw_gen, dh->generator.data, dh->generator.size);
   if (ret < 0)
     {
       MHD_gnutls_assert ();
@@ -132,7 +134,7 @@ MHD__gnutls_dh_get_group (MHD_gtls_session_t session,
  **/
 int
 MHD__gnutls_dh_get_pubkey (MHD_gtls_session_t session,
-                          MHD_gnutls_datum_t * raw_key)
+                           MHD_gnutls_datum_t * raw_key)
 {
   MHD_gtls_dh_info_st *dh;
   mhd_anon_auth_info_t anon_info;
@@ -172,7 +174,7 @@ MHD__gnutls_dh_get_pubkey (MHD_gtls_session_t session,
     }
 
   return MHD__gnutls_set_datum (raw_key, dh->public_key.data,
-                            dh->public_key.size);
+                                dh->public_key.size);
 }
 
 /**
@@ -203,7 +205,7 @@ MHD_gtls_rsa_export_get_pubkey (MHD_gtls_session_t session,
         return GNUTLS_E_INTERNAL_ERROR;
 
       ret = MHD__gnutls_set_datum (modulus, info->rsa_export.modulus.data,
-                               info->rsa_export.modulus.size);
+                                   info->rsa_export.modulus.size);
       if (ret < 0)
         {
           MHD_gnutls_assert ();
@@ -211,7 +213,7 @@ MHD_gtls_rsa_export_get_pubkey (MHD_gtls_session_t session,
         }
 
       ret = MHD__gnutls_set_datum (exponent, info->rsa_export.exponent.data,
-                               info->rsa_export.exponent.size);
+                                   info->rsa_export.exponent.size);
       if (ret < 0)
         {
           MHD_gnutls_assert ();
@@ -491,8 +493,8 @@ MHD_gtls_certificate_client_get_request_status (MHD_gtls_session_t session)
  **/
 int
 MHD__gnutls_fingerprint (enum MHD_GNUTLS_HashAlgorithm algo,
-                        const MHD_gnutls_datum_t * data,
-                        void *result, size_t * result_size)
+                         const MHD_gnutls_datum_t * data,
+                         void *result, size_t * result_size)
 {
   GNUTLS_HASH_HANDLE td;
   int hash_len = MHD_gnutls_hash_get_algo_len (HASH2MAC (algo));
@@ -533,7 +535,7 @@ MHD__gnutls_fingerprint (enum MHD_GNUTLS_HashAlgorithm algo,
  **/
 void
 MHD__gnutls_certificate_set_dh_params (MHD_gtls_cert_credentials_t res,
-                                      MHD_gtls_dh_params_t dh_params)
+                                       MHD_gtls_dh_params_t dh_params)
 {
   res->dh_params = dh_params;
 }
@@ -550,7 +552,7 @@ MHD__gnutls_certificate_set_dh_params (MHD_gtls_cert_credentials_t res,
  **/
 void
 MHD_gnutls_certificate_set_params_function (MHD_gtls_cert_credentials_t res,
-                                        MHD_gnutls_params_function * func)
+                                            MHD_gnutls_params_function * func)
 {
   res->params_func = func;
 }
@@ -567,7 +569,7 @@ MHD_gnutls_certificate_set_params_function (MHD_gtls_cert_credentials_t res,
  **/
 void
 MHD__gnutls_certificate_set_verify_flags (MHD_gtls_cert_credentials_t
-                                         res, unsigned int flags)
+                                          res, unsigned int flags)
 {
   res->verify_flags = flags;
 }
@@ -585,9 +587,9 @@ MHD__gnutls_certificate_set_verify_flags (MHD_gtls_cert_credentials_t
  **/
 void
 MHD__gnutls_certificate_set_verify_limits (MHD_gtls_cert_credentials_t
-                                          res,
-                                          unsigned int max_bits,
-                                          unsigned int max_depth)
+                                           res,
+                                           unsigned int max_bits,
+                                           unsigned int max_depth)
 {
   res->verify_depth = max_depth;
   res->verify_bits = max_bits;
@@ -605,9 +607,9 @@ MHD__gnutls_certificate_set_verify_limits (MHD_gtls_cert_credentials_t
  **/
 void
 MHD__gnutls_certificate_set_rsa_export_params (MHD_gtls_cert_credentials_t
-                                              res,
-                                              MHD_gtls_rsa_params_t
-                                              rsa_params)
+                                               res,
+                                               MHD_gtls_rsa_params_t
+                                               rsa_params)
 {
   res->rsa_params = rsa_params;
 }
@@ -624,7 +626,7 @@ MHD__gnutls_certificate_set_rsa_export_params (MHD_gtls_cert_credentials_t
  **/
 void
 MHD_gnutls_anon_set_params_function (MHD_gtls_anon_server_credentials_t res,
-                                 MHD_gnutls_params_function * func)
+                                     MHD_gnutls_params_function * func)
 {
   res->params_func = func;
 }
diff --git a/src/daemon/https/tls/gnutls_x509.c b/src/daemon/https/tls/gnutls_x509.c
index 503bea9b..06ee8635 100644
--- a/src/daemon/https/tls/gnutls_x509.c
+++ b/src/daemon/https/tls/gnutls_x509.c
@@ -103,7 +103,7 @@ check_bits (MHD_gnutls_x509_crt_t crt, unsigned int max_bits)
   -*/
 int
 MHD__gnutls_x509_cert_verify_peers (MHD_gtls_session_t session,
-                                unsigned int *status)
+                                    unsigned int *status)
 {
   cert_auth_info_t info;
   MHD_gtls_cert_credentials_t cred;
@@ -142,7 +142,8 @@ MHD__gnutls_x509_cert_verify_peers (MHD_gtls_session_t session,
   peer_certificate_list_size = info->ncerts;
   peer_certificate_list =
     MHD_gnutls_calloc (1,
-                   peer_certificate_list_size * sizeof (MHD_gnutls_x509_crt_t));
+                       peer_certificate_list_size *
+                       sizeof (MHD_gnutls_x509_crt_t));
   if (peer_certificate_list == NULL)
     {
       MHD_gnutls_assert ();
@@ -161,8 +162,8 @@ MHD__gnutls_x509_cert_verify_peers (MHD_gtls_session_t session,
 
       ret =
         MHD_gnutls_x509_crt_import (peer_certificate_list[i],
-                                &info->raw_certificate_list[i],
-                                GNUTLS_X509_FMT_DER);
+                                    &info->raw_certificate_list[i],
+                                    GNUTLS_X509_FMT_DER);
       if (ret < 0)
         {
           MHD_gnutls_assert ();
@@ -184,10 +185,10 @@ MHD__gnutls_x509_cert_verify_peers (MHD_gtls_session_t session,
    */
   ret =
     MHD_gnutls_x509_crt_list_verify (peer_certificate_list,
-                                 peer_certificate_list_size,
-                                 cred->x509_ca_list, cred->x509_ncas,
-                                 cred->x509_crl_list, cred->x509_ncrls,
-                                 cred->verify_flags, status);
+                                     peer_certificate_list_size,
+                                     cred->x509_ca_list, cred->x509_ncas,
+                                     cred->x509_crl_list, cred->x509_ncrls,
+                                     cred->verify_flags, status);
 
   CLEAR_CERTS;
 
@@ -221,13 +222,14 @@ MHD__gnutls_check_key_cert_match (MHD_gtls_cert_credentials_t res)
     }
 
   MHD__gnutls_x509_write_rsa_params (res->pkey[res->ncerts - 1].params,
-                                 res->pkey[res->ncerts -
-                                           1].params_size, &kid);
+                                     res->pkey[res->ncerts -
+                                               1].params_size, &kid);
 
 
-  MHD__gnutls_x509_write_rsa_params (res->cert_list[res->ncerts - 1][0].params,
-                                 res->cert_list[res->ncerts -
-                                                1][0].params_size, &cid);
+  MHD__gnutls_x509_write_rsa_params (res->cert_list[res->ncerts - 1][0].
+                                     params,
+                                     res->cert_list[res->ncerts -
+                                                    1][0].params_size, &cid);
 
   if (cid.size != kid.size)
     {
@@ -265,7 +267,7 @@ parse_crt_mem (MHD_gnutls_cert ** cert_list, unsigned *ncerts,
 
   *cert_list =
     (MHD_gnutls_cert *) MHD_gtls_realloc_fast (*cert_list,
-                                           i * sizeof (MHD_gnutls_cert));
+                                               i * sizeof (MHD_gnutls_cert));
 
   if (*cert_list == NULL)
     {
@@ -286,7 +288,7 @@ parse_crt_mem (MHD_gnutls_cert ** cert_list, unsigned *ncerts,
 }
 
 /* Reads a DER encoded certificate list from memory and stores it to
- * a MHD_gnutls_cert structure. 
+ * a MHD_gnutls_cert structure.
  * Returns the number of certificates parsed.
  */
 static int
@@ -355,7 +357,9 @@ parse_pem_cert_mem (MHD_gnutls_cert ** cert_list, unsigned *ncerts,
   do
     {
 
-      siz2 = MHD__gnutls_fbase64_decode (NULL, (const unsigned char*) ptr, size, &ptr2);
+      siz2 =
+        MHD__gnutls_fbase64_decode (NULL, (const unsigned char *) ptr, size,
+                                    &ptr2);
 
       if (siz2 < 0)
         {
@@ -365,7 +369,8 @@ parse_pem_cert_mem (MHD_gnutls_cert ** cert_list, unsigned *ncerts,
 
       *cert_list =
         (MHD_gnutls_cert *) MHD_gtls_realloc_fast (*cert_list,
-                                               i * sizeof (MHD_gnutls_cert));
+                                                   i *
+                                                   sizeof (MHD_gnutls_cert));
 
       if (*cert_list == NULL)
         {
@@ -382,7 +387,7 @@ parse_pem_cert_mem (MHD_gnutls_cert ** cert_list, unsigned *ncerts,
           MHD_gnutls_assert ();
           return ret;
         }
-      MHD__gnutls_free_datum (&tmp);        /* free ptr2 */
+      MHD__gnutls_free_datum (&tmp);    /* free ptr2 */
 
       /* now we move ptr after the pem header
        */
@@ -453,8 +458,8 @@ read_cert_mem (MHD_gtls_cert_credentials_t res, const void *cert,
 
   if (type == GNUTLS_X509_FMT_DER)
     ret = parse_der_cert_mem (&res->cert_list[res->ncerts],
-                                &res->cert_list_length[res->ncerts],
-                              cert, cert_size);
+                              &res->cert_list_length[res->ncerts],
+                              cert, cert_size);
   else
     ret =
       parse_pem_cert_mem (&res->cert_list[res->ncerts],
@@ -473,7 +478,7 @@ read_cert_mem (MHD_gtls_cert_credentials_t res, const void *cert,
 
 int
 MHD__gnutls_x509_privkey_to_gkey (MHD_gnutls_privkey * dest,
-                              MHD_gnutls_x509_privkey_t src)
+                                  MHD_gnutls_x509_privkey_t src)
 {
   int i, ret;
 
@@ -519,8 +524,8 @@ MHD_gtls_gkey_deinit (MHD_gnutls_privkey * key)
 
 int
 MHD__gnutls_x509_raw_privkey_to_gkey (MHD_gnutls_privkey * privkey,
-                                  const MHD_gnutls_datum_t * raw_key,
-                                  MHD_gnutls_x509_crt_fmt_t type)
+                                      const MHD_gnutls_datum_t * raw_key,
+                                      MHD_gnutls_x509_crt_fmt_t type)
 {
   MHD_gnutls_x509_privkey_t tmpkey;
   int ret;
@@ -539,7 +544,7 @@ MHD__gnutls_x509_raw_privkey_to_gkey (MHD_gnutls_privkey * privkey,
   if (ret < 0)
     ret =
       MHD_gnutls_x509_privkey_import_pkcs8 (tmpkey, raw_key, type, NULL,
-                                        GNUTLS_PKCS_PLAIN);
+                                            GNUTLS_PKCS_PLAIN);
 #endif
 
   if (ret < 0)
@@ -591,7 +596,7 @@ read_key_mem (MHD_gtls_cert_credentials_t res,
 
       ret =
         MHD__gnutls_x509_raw_privkey_to_gkey (&res->pkey[res->ncerts], &tmp,
-                                          type);
+                                              type);
       if (ret < 0)
         {
           MHD_gnutls_assert ();
@@ -636,9 +641,10 @@ read_key_mem (MHD_gtls_cert_credentials_t res,
   **/
 int
 MHD__gnutls_certificate_set_x509_key_mem (MHD_gtls_cert_credentials_t
-                                         res, const MHD_gnutls_datum_t * cert,
-                                         const MHD_gnutls_datum_t * key,
-                                         MHD_gnutls_x509_crt_fmt_t type)
+                                          res,
+                                          const MHD_gnutls_datum_t * cert,
+                                          const MHD_gnutls_datum_t * key,
+                                          MHD_gnutls_x509_crt_fmt_t type)
 {
   int ret;
 
@@ -684,7 +690,8 @@ generate_rdn_seq (MHD_gtls_cert_credentials_t res)
   size = 0;
   for (i = 0; i < res->x509_ncas; i++)
     {
-      if ((ret = MHD_gnutls_x509_crt_get_raw_dn (res->x509_ca_list[i], &tmp)) < 0)
+      if ((ret =
+           MHD_gnutls_x509_crt_get_raw_dn (res->x509_ca_list[i], &tmp)) < 0)
         {
           MHD_gnutls_assert ();
           return ret;
@@ -708,7 +715,8 @@ generate_rdn_seq (MHD_gtls_cert_credentials_t res)
 
   for (i = 0; i < res->x509_ncas; i++)
     {
-      if ((ret = MHD_gnutls_x509_crt_get_raw_dn (res->x509_ca_list[i], &tmp)) < 0)
+      if ((ret =
+           MHD_gnutls_x509_crt_get_raw_dn (res->x509_ca_list[i], &tmp)) < 0)
         {
           MHD__gnutls_free_datum (&res->x509_rdn_sequence);
           MHD_gnutls_assert ();
@@ -728,7 +736,7 @@ generate_rdn_seq (MHD_gtls_cert_credentials_t res)
  */
 int
 MHD__gnutls_check_key_usage (const MHD_gnutls_cert * cert,
-                         enum MHD_GNUTLS_KeyExchangeAlgorithm alg)
+                             enum MHD_GNUTLS_KeyExchangeAlgorithm alg)
 {
   unsigned int key_usage = 0;
   int encipher_type;
@@ -814,9 +822,9 @@ parse_pem_ca_mem (MHD_gnutls_x509_crt_t ** cert_list, unsigned *ncerts,
 
       *cert_list =
         (MHD_gnutls_x509_crt_t *) MHD_gtls_realloc_fast (*cert_list,
-                                                     i *
-                                                     sizeof
-                                                     (MHD_gnutls_x509_crt_t));
+                                                         i *
+                                                         sizeof
+                                                         (MHD_gnutls_x509_crt_t));
 
       if (*cert_list == NULL)
         {
@@ -836,7 +844,7 @@ parse_pem_ca_mem (MHD_gnutls_x509_crt_t ** cert_list, unsigned *ncerts,
 
       ret =
         MHD_gnutls_x509_crt_import (cert_list[0][i - 1],
-                                &tmp, GNUTLS_X509_FMT_PEM);
+                                    &tmp, GNUTLS_X509_FMT_PEM);
       if (ret < 0)
         {
           MHD_gnutls_assert ();
@@ -892,8 +900,9 @@ parse_der_ca_mem (MHD_gnutls_x509_crt_t ** cert_list, unsigned *ncerts,
 
   *cert_list =
     (MHD_gnutls_x509_crt_t *) MHD_gtls_realloc_fast (*cert_list,
-                                                 i *
-                                                 sizeof (MHD_gnutls_x509_crt_t));
+                                                     i *
+                                                     sizeof
+                                                     (MHD_gnutls_x509_crt_t));
 
   if (*cert_list == NULL)
     {
@@ -912,7 +921,8 @@ parse_der_ca_mem (MHD_gnutls_x509_crt_t ** cert_list, unsigned *ncerts,
     }
 
   ret =
-    MHD_gnutls_x509_crt_import (cert_list[0][i - 1], &tmp, GNUTLS_X509_FMT_DER);
+    MHD_gnutls_x509_crt_import (cert_list[0][i - 1], &tmp,
+                                GNUTLS_X509_FMT_DER);
   if (ret < 0)
     {
       MHD_gnutls_assert ();
@@ -945,8 +955,9 @@ parse_der_ca_mem (MHD_gnutls_x509_crt_t ** cert_list, unsigned *ncerts,
   **/
 int
 MHD__gnutls_certificate_set_x509_trust_mem (MHD_gtls_cert_credentials_t
-                                           res, const MHD_gnutls_datum_t * ca,
-                                           MHD_gnutls_x509_crt_fmt_t type)
+                                            res,
+                                            const MHD_gnutls_datum_t * ca,
+                                            MHD_gnutls_x509_crt_fmt_t type)
 {
   int ret, ret2;
 
@@ -994,9 +1005,9 @@ parse_pem_crl_mem (MHD_gnutls_x509_crl_t ** crl_list, unsigned *ncrls,
 
       *crl_list =
         (MHD_gnutls_x509_crl_t *) MHD_gtls_realloc_fast (*crl_list,
-                                                     i *
-                                                     sizeof
-                                                     (MHD_gnutls_x509_crl_t));
+                                                         i *
+                                                         sizeof
+                                                         (MHD_gnutls_x509_crl_t));
 
       if (*crl_list == NULL)
         {
@@ -1010,13 +1021,13 @@ parse_pem_crl_mem (MHD_gnutls_x509_crl_t ** crl_list, unsigned *ncrls,
           MHD_gnutls_assert ();
           return ret;
         }
-      
+
       tmp.data = (unsigned char *) ptr;
       tmp.size = size;
 
       ret =
         MHD_gnutls_x509_crl_import (crl_list[0][i - 1],
-                                &tmp, GNUTLS_X509_FMT_PEM);
+                                    &tmp, GNUTLS_X509_FMT_PEM);
       if (ret < 0)
         {
           MHD_gnutls_assert ();
@@ -1062,8 +1073,9 @@ parse_der_crl_mem (MHD_gnutls_x509_crl_t ** crl_list, unsigned *ncrls,
 
   *crl_list =
     (MHD_gnutls_x509_crl_t *) MHD_gtls_realloc_fast (*crl_list,
-                                                 i *
-                                                 sizeof (MHD_gnutls_x509_crl_t));
+                                                     i *
+                                                     sizeof
+                                                     (MHD_gnutls_x509_crl_t));
 
   if (*crl_list == NULL)
     {
@@ -1082,7 +1094,8 @@ parse_der_crl_mem (MHD_gnutls_x509_crl_t ** crl_list, unsigned *ncrls,
     }
 
   ret =
-    MHD_gnutls_x509_crl_import (crl_list[0][i - 1], &tmp, GNUTLS_X509_FMT_DER);
+    MHD_gnutls_x509_crl_import (crl_list[0][i - 1], &tmp,
+                                GNUTLS_X509_FMT_DER);
   if (ret < 0)
     {
       MHD_gnutls_assert ();
@@ -1147,8 +1160,8 @@ read_crl_mem (MHD_gtls_cert_credentials_t res, const void *crl,
   **/
 int
 MHD__gnutls_certificate_set_x509_crl_mem (MHD_gtls_cert_credentials_t
-                                         res, const MHD_gnutls_datum_t * CRL,
-                                         MHD_gnutls_x509_crt_fmt_t type)
+                                          res, const MHD_gnutls_datum_t * CRL,
+                                          MHD_gnutls_x509_crt_fmt_t type)
 {
   int ret;
 
diff --git a/src/daemon/https/tls/gnutls_x509.h b/src/daemon/https/tls/gnutls_x509.h
index b2d92603..07269328 100644
--- a/src/daemon/https/tls/gnutls_x509.h
+++ b/src/daemon/https/tls/gnutls_x509.h
@@ -25,7 +25,7 @@
 #include <libtasn1.h>
 
 int MHD__gnutls_x509_cert_verify_peers (MHD_gtls_session_t session,
-                                    unsigned int *status);
+                                        unsigned int *status);
 
 #define PEM_CERT_SEP2 "-----BEGIN X509 CERTIFICATE"
 #define PEM_CERT_SEP "-----BEGIN CERTIFICATE"
@@ -36,13 +36,15 @@ int MHD__gnutls_x509_cert_verify_peers (MHD_gtls_session_t session,
 #define PEM_KEY_DSA_SEP "-----BEGIN DSA"
 
 int MHD__gnutls_check_key_usage (const MHD_gnutls_cert * cert,
-                             enum MHD_GNUTLS_KeyExchangeAlgorithm alg);
+                                 enum MHD_GNUTLS_KeyExchangeAlgorithm alg);
 
-int MHD__gnutls_x509_read_rsa_params (opaque * der, int dersize, mpi_t * params);
-int MHD__gnutls_x509_read_dsa_pubkey (opaque * der, int dersize, mpi_t * params);
+int MHD__gnutls_x509_read_rsa_params (opaque * der, int dersize,
+                                      mpi_t * params);
+int MHD__gnutls_x509_read_dsa_pubkey (opaque * der, int dersize,
+                                      mpi_t * params);
 
 int MHD__gnutls_x509_raw_privkey_to_gkey (MHD_gnutls_privkey * privkey,
-                                      const MHD_gnutls_datum_t * raw_key,
-                                      MHD_gnutls_x509_crt_fmt_t type);
+                                          const MHD_gnutls_datum_t * raw_key,
+                                          MHD_gnutls_x509_crt_fmt_t type);
 int MHD__gnutls_x509_privkey_to_gkey (MHD_gnutls_privkey * privkey,
-                                  MHD_gnutls_x509_privkey_t);
+                                      MHD_gnutls_x509_privkey_t);
diff --git a/src/daemon/https/tls/x509_b64.c b/src/daemon/https/tls/x509_b64.c
index abe3fb40..152f7409 100644
--- a/src/daemon/https/tls/x509_b64.c
+++ b/src/daemon/https/tls/x509_b64.c
@@ -154,7 +154,7 @@ decode (uint8_t * result, const opaque * data)
  */
 int
 MHD__gnutls_fbase64_encode (const char *msg, const uint8_t * data,
-                        int data_size, uint8_t ** result)
+                            int data_size, uint8_t ** result)
 {
   int i, ret, tmp, j;
   char tmpres[4];
@@ -173,16 +173,16 @@ MHD__gnutls_fbase64_encode (const char *msg, const uint8_t * data,
   memset (bottom, 0, sizeof (bottom));
   memset (top, 0, sizeof (top));
 
-  strcat ((char*) top, "-----BEGIN ");  /* Flawfinder: ignore */
-  strcat ((char*)top, msg);            /* Flawfinder: ignore */
-  strcat ((char*)top, "-----");        /* Flawfinder: ignore */
+  strcat ((char *) top, "-----BEGIN "); /* Flawfinder: ignore */
+  strcat ((char *) top, msg);   /* Flawfinder: ignore */
+  strcat ((char *) top, "-----");       /* Flawfinder: ignore */
 
-  strcat ((char*)bottom, "\n-----END ");       /* Flawfinder: ignore */
-  strcat ((char*)bottom, msg);         /* Flawfinder: ignore */
-  strcat ((char*)bottom, "-----\n");   /* Flawfinder: ignore */
+  strcat ((char *) bottom, "\n-----END ");      /* Flawfinder: ignore */
+  strcat ((char *) bottom, msg);        /* Flawfinder: ignore */
+  strcat ((char *) bottom, "-----\n");  /* Flawfinder: ignore */
 
-  top_len = strlen ((char*)top);
-  bottom_len = strlen ((char*)bottom);
+  top_len = strlen ((char *) top);
+  bottom_len = strlen ((char *) bottom);
 
   ret = B64FSIZE (msglen, data_size);
 
@@ -197,7 +197,7 @@ MHD__gnutls_fbase64_encode (const char *msg, const uint8_t * data,
   INCR (bytes, top_len);
   pos = top_len;
 
-  strcpy ((char*)*result,(char*) top);        /* Flawfinder: ignore */
+  strcpy ((char *) *result, (char *) top);      /* Flawfinder: ignore */
 
   for (i = j = 0; i < data_size; i += 3, j += 4)
     {
@@ -260,7 +260,7 @@ MHD__gnutls_fbase64_encode (const char *msg, const uint8_t * data,
  */
 int
 MHD__gnutls_base64_decode (const uint8_t * data, size_t data_size,
-                       uint8_t ** result)
+                           uint8_t ** result)
 {
   unsigned int i, j;
   int ret, tmp, est;
@@ -318,7 +318,7 @@ cpydata (const uint8_t * data, int data_size, uint8_t ** result)
 #define ENDSTR2 "-----\r"
 int
 MHD__gnutls_fbase64_decode (const char *header, const opaque * data,
-                        size_t data_size, uint8_t ** result)
+                            size_t data_size, uint8_t ** result)
 {
   int ret;
   static const char top[] = "-----BEGIN ";
@@ -411,4 +411,3 @@ MHD__gnutls_fbase64_decode (const char *header, const opaque * data,
 
   return ret;
 }
-
diff --git a/src/daemon/https/tls/x509_b64.h b/src/daemon/https/tls/x509_b64.h
index 9cb27c86..ebb48639 100644
--- a/src/daemon/https/tls/x509_b64.h
+++ b/src/daemon/https/tls/x509_b64.h
@@ -23,11 +23,11 @@
  */
 
 int MHD__gnutls_fbase64_encode (const char *msg, const uint8_t * data,
-                            int data_size, uint8_t ** result);
+                                int data_size, uint8_t ** result);
 int MHD__gnutls_base64_decode (const uint8_t * data, size_t data_size,
-                           uint8_t ** result);
+                               uint8_t ** result);
 int MHD__gnutls_fbase64_decode (const char *header, const uint8_t * data,
-                            size_t data_size, uint8_t ** result);
+                                size_t data_size, uint8_t ** result);
 
 #define B64SIZE( data_size) ((data_size%3==0)?((data_size*4)/3):(4+((data_size/3)*4)))
 
diff --git a/src/daemon/https/x509/common.c b/src/daemon/https/x509/common.c
index 6e7e0853..ca2e355f 100644
--- a/src/daemon/https/x509/common.c
+++ b/src/daemon/https/x509/common.c
@@ -258,8 +258,9 @@ MHD__gnutls_x509_oid2ldap_string (const char *oid)
  */
 int
 MHD__gnutls_x509_oid_data2string (const char *oid,
-                              void *value,
-                              int value_size, char *res, size_t * res_size)
+                                  void *value,
+                                  int value_size, char *res,
+                                  size_t * res_size)
 {
   char str[MAX_STRING_LEN], tmpname[128];
   const char *ANAME = NULL;
@@ -292,17 +293,19 @@ MHD__gnutls_x509_oid_data2string (const char *oid,
   MHD_gtls_str_cat (str, sizeof (str), ANAME);
 
   if ((result = MHD__asn1_create_element (MHD__gnutls_get_pkix (), str,
-                                     &tmpasn)) != ASN1_SUCCESS)
+                                          &tmpasn)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       return MHD_gtls_asn2err (result);
     }
 
-  if ((result = MHD__asn1_der_decoding (&tmpasn, value, value_size, MHD__asn1_err))
-      != ASN1_SUCCESS)
+  if ((result =
+       MHD__asn1_der_decoding (&tmpasn, value, value_size,
+                               MHD__asn1_err)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
-      MHD__gnutls_x509_log ("MHD__asn1_der_decoding: %s:%s\n", str, MHD__asn1_err);
+      MHD__gnutls_x509_log ("MHD__asn1_der_decoding: %s:%s\n", str,
+                            MHD__asn1_err);
       MHD__asn1_delete_structure (&tmpasn);
       return MHD_gtls_asn2err (result);
     }
@@ -381,7 +384,9 @@ MHD__gnutls_x509_oid_data2string (const char *oid,
             }
           else
             {
-              result = MHD__gnutls_x509_data2hex ((const unsigned char*) str, len, (unsigned char*) res, res_size);
+              result =
+                MHD__gnutls_x509_data2hex ((const unsigned char *) str, len,
+                                           (unsigned char *) res, res_size);
               if (result < 0)
                 {
                   MHD_gnutls_assert ();
@@ -400,7 +405,8 @@ MHD__gnutls_x509_oid_data2string (const char *oid,
  */
 int
 MHD__gnutls_x509_data2hex (const opaque * data,
-                       size_t data_size, opaque * out, size_t * sizeof_out)
+                           size_t data_size, opaque * out,
+                           size_t * sizeof_out)
 {
   char *res;
   char escaped[MAX_STRING_LEN];
@@ -425,8 +431,8 @@ MHD__gnutls_x509_data2hex (const opaque * data,
 
       if (out)
         {
-          strcpy ((char*) out, "#");
-          strcat ((char*) out, res);
+          strcpy ((char *) out, "#");
+          strcat ((char *) out, res);
         }
 
       return 0;
@@ -726,10 +732,10 @@ MHD__gnutls_x509_san_find_type (char *str_type)
  */
 int
 MHD__gnutls_x509_export_int (ASN1_TYPE MHD__asn1_data,
-                         MHD_gnutls_x509_crt_fmt_t format,
-                         char *pem_header,
-                         unsigned char *output_data,
-                         size_t * output_data_size)
+                             MHD_gnutls_x509_crt_fmt_t format,
+                             char *pem_header,
+                             unsigned char *output_data,
+                             size_t * output_data_size)
 {
   int result, len;
 
@@ -741,8 +747,9 @@ MHD__gnutls_x509_export_int (ASN1_TYPE MHD__asn1_data,
 
       len = *output_data_size;
 
-      if ((result = MHD__asn1_der_coding (MHD__asn1_data, "", output_data, &len,
-                                     NULL)) != ASN1_SUCCESS)
+      if ((result =
+           MHD__asn1_der_coding (MHD__asn1_data, "", output_data, &len,
+                                 NULL)) != ASN1_SUCCESS)
         {
           *output_data_size = len;
           if (result == ASN1_MEM_ERROR)
@@ -768,7 +775,8 @@ MHD__gnutls_x509_export_int (ASN1_TYPE MHD__asn1_data,
           return result;
         }
 
-      result = MHD__gnutls_fbase64_encode (pem_header, tmp.data, tmp.size, &out);
+      result =
+        MHD__gnutls_fbase64_encode (pem_header, tmp.data, tmp.size, &out);
 
       MHD__gnutls_free_datum (&tmp);
 
@@ -815,9 +823,9 @@ MHD__gnutls_x509_export_int (ASN1_TYPE MHD__asn1_data,
  */
 int
 MHD__gnutls_x509_decode_octet_string (const char *string_type,
-                                  const opaque * der,
-                                  size_t der_size,
-                                  opaque * output, size_t * output_size)
+                                      const opaque * der,
+                                      size_t der_size,
+                                      opaque * output, size_t * output_size)
 {
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
   int result, tmp_output_size;
@@ -833,7 +841,7 @@ MHD__gnutls_x509_decode_octet_string (const char *string_type,
 
   if ((result =
        MHD__asn1_create_element (MHD__gnutls_get_pkix (), strname,
-                            &c2)) != ASN1_SUCCESS)
+                                 &c2)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       result = MHD_gtls_asn2err (result);
@@ -875,7 +883,8 @@ cleanup:if (c2)
  */
 int
 MHD__gnutls_x509_read_value (ASN1_TYPE c,
-                         const char *root, MHD_gnutls_datum_t * ret, int flags)
+                             const char *root, MHD_gnutls_datum_t * ret,
+                             int flags)
 {
   int len = 0, result;
   size_t slen;
@@ -917,7 +926,8 @@ MHD__gnutls_x509_read_value (ASN1_TYPE c,
   if (flags == 1)
     {
       slen = len;
-      result = MHD__gnutls_x509_decode_octet_string (NULL, tmp, slen, tmp, &slen);
+      result =
+        MHD__gnutls_x509_decode_octet_string (NULL, tmp, slen, tmp, &slen);
       if (result < 0)
         {
           MHD_gnutls_assert ();
@@ -942,7 +952,8 @@ cleanup:MHD_gnutls_free (tmp);
  */
 int
 MHD__gnutls_x509_der_encode (ASN1_TYPE src,
-                         const char *src_name, MHD_gnutls_datum_t * res, int str)
+                             const char *src_name, MHD_gnutls_datum_t * res,
+                             int str)
 {
   int size, result;
   int asize;
@@ -984,8 +995,9 @@ MHD__gnutls_x509_der_encode (ASN1_TYPE src,
   if (str)
     {
       if ((result =
-           MHD__asn1_create_element (MHD__gnutls_get_pkix (), "PKIX1.pkcs-7-Data",
-                                &c2)) != ASN1_SUCCESS)
+           MHD__asn1_create_element (MHD__gnutls_get_pkix (),
+                                     "PKIX1.pkcs-7-Data",
+                                     &c2)) != ASN1_SUCCESS)
         {
           MHD_gnutls_assert ();
           result = MHD_gtls_asn2err (result);
@@ -1030,9 +1042,9 @@ cleanup:MHD_gnutls_free (data);
  */
 int
 MHD__gnutls_x509_der_encode_and_copy (ASN1_TYPE src,
-                                  const char *src_name,
-                                  ASN1_TYPE dest,
-                                  const char *dest_name, int str)
+                                      const char *src_name,
+                                      ASN1_TYPE dest,
+                                      const char *dest_name, int str)
 {
   int result;
   MHD_gnutls_datum_t encoded;
@@ -1047,7 +1059,8 @@ MHD__gnutls_x509_der_encode_and_copy (ASN1_TYPE src,
 
   /* Write the data.
    */
-  result = MHD__asn1_write_value (dest, dest_name, encoded.data, encoded.size);
+  result =
+    MHD__asn1_write_value (dest, dest_name, encoded.data, encoded.size);
 
   MHD__gnutls_free_datum (&encoded);
 
@@ -1065,8 +1078,8 @@ MHD__gnutls_x509_der_encode_and_copy (ASN1_TYPE src,
  */
 int
 MHD__gnutls_x509_write_value (ASN1_TYPE c,
-                          const char *root,
-                          const MHD_gnutls_datum_t * data, int str)
+                              const char *root,
+                              const MHD_gnutls_datum_t * data, int str)
 {
   int result;
   int asize;
@@ -1088,8 +1101,9 @@ MHD__gnutls_x509_write_value (ASN1_TYPE c,
       /* Convert it to OCTET STRING
        */
       if ((result =
-           MHD__asn1_create_element (MHD__gnutls_get_pkix (), "PKIX1.pkcs-7-Data",
-                                &c2)) != ASN1_SUCCESS)
+           MHD__asn1_create_element (MHD__gnutls_get_pkix (),
+                                     "PKIX1.pkcs-7-Data",
+                                     &c2)) != ASN1_SUCCESS)
         {
           MHD_gnutls_assert ();
           result = MHD_gtls_asn2err (result);
@@ -1144,10 +1158,11 @@ cleanup:if (val.data != data->data)
  */
 int
 MHD__gnutls_x509_encode_and_copy_PKI_params (ASN1_TYPE dst,
-                                         const char *dst_name,
-                                         enum MHD_GNUTLS_PublicKeyAlgorithm
-                                         pk_algorithm,
-                                         mpi_t * params, int params_size)
+                                             const char *dst_name,
+                                             enum
+                                             MHD_GNUTLS_PublicKeyAlgorithm
+                                             pk_algorithm, mpi_t * params,
+                                             int params_size)
 {
   const char *pk;
   MHD_gnutls_datum_t der = { NULL,
@@ -1219,7 +1234,7 @@ MHD__gnutls_x509_encode_and_copy_PKI_params (ASN1_TYPE dst,
  */
 int
 MHD__gnutls_x509_get_pk_algorithm (ASN1_TYPE src,
-                               const char *src_name, unsigned int *bits)
+                                   const char *src_name, unsigned int *bits)
 {
   int result;
   opaque *str = NULL;
@@ -1295,7 +1310,8 @@ MHD__gnutls_x509_get_pk_algorithm (ASN1_TYPE src,
     {
     case MHD_GNUTLS_PK_RSA:
       {
-        if ((result = MHD__gnutls_x509_read_rsa_params (str, len, params)) < 0)
+        if ((result =
+             MHD__gnutls_x509_read_rsa_params (str, len, params)) < 0)
           {
             MHD_gnutls_assert ();
             return result;
@@ -1321,8 +1337,8 @@ MHD__gnutls_x509_get_pk_algorithm (ASN1_TYPE src,
  */
 int
 MHD__gnutls_x509_get_signed_data (ASN1_TYPE src,
-                              const char *src_name,
-                              MHD_gnutls_datum_t * signed_data)
+                                  const char *src_name,
+                                  MHD_gnutls_datum_t * signed_data)
 {
   MHD_gnutls_datum_t der;
   int start, end, result;
@@ -1337,7 +1353,7 @@ MHD__gnutls_x509_get_signed_data (ASN1_TYPE src,
   /* Get the signed data
    */
   result = MHD__asn1_der_decoding_startEnd (src, der.data, der.size, src_name,
-                                       &start, &end);
+                                            &start, &end);
   if (result != ASN1_SUCCESS)
     {
       result = MHD_gtls_asn2err (result);
@@ -1345,7 +1361,8 @@ MHD__gnutls_x509_get_signed_data (ASN1_TYPE src,
       goto cleanup;
     }
 
-  result = MHD__gnutls_set_datum (signed_data, &der.data[start], end - start + 1);
+  result =
+    MHD__gnutls_set_datum (signed_data, &der.data[start], end - start + 1);
 
   if (result < 0)
     {
@@ -1365,7 +1382,8 @@ cleanup:MHD__gnutls_free_datum (&der);
  */
 int
 MHD__gnutls_x509_get_signature (ASN1_TYPE src,
-                            const char *src_name, MHD_gnutls_datum_t * signature)
+                                const char *src_name,
+                                MHD_gnutls_datum_t * signature)
 {
   int bits, result, len;
 
diff --git a/src/daemon/https/x509/common.h b/src/daemon/https/x509/common.h
index 0102c5a7..7ddb4b08 100644
--- a/src/daemon/https/x509/common.h
+++ b/src/daemon/https/x509/common.h
@@ -59,13 +59,14 @@
 #define SIG_GOST_R3410_2001_OID "1.2.643.2.2.3"
 
 int MHD__gnutls_x509_decode_octet_string (const char *string_type,
-                                      const opaque * der, size_t der_size,
-                                      opaque * output, size_t * output_size);
+                                          const opaque * der, size_t der_size,
+                                          opaque * output,
+                                          size_t * output_size);
 int MHD__gnutls_x509_oid_data2string (const char *OID, void *value,
-                                  int value_size, char *res,
-                                  size_t * res_size);
+                                      int value_size, char *res,
+                                      size_t * res_size);
 int MHD__gnutls_x509_data2hex (const opaque * data, size_t data_size,
-                           opaque * out, size_t * sizeof_out);
+                               opaque * out, size_t * sizeof_out);
 
 const char *MHD__gnutls_x509_oid2ldap_string (const char *OID);
 
@@ -74,50 +75,51 @@ int MHD__gnutls_x509_oid_data_printable (const char *OID);
 
 time_t MHD__gnutls_x509_get_time (ASN1_TYPE c2, const char *when);
 
-MHD_gnutls_x509_subject_alt_name_t MHD__gnutls_x509_san_find_type (char *str_type);
+MHD_gnutls_x509_subject_alt_name_t MHD__gnutls_x509_san_find_type (char
+                                                                   *str_type);
 
 int MHD__gnutls_x509_der_encode_and_copy (ASN1_TYPE src, const char *src_name,
-                                      ASN1_TYPE dest, const char *dest_name,
-                                      int str);
+                                          ASN1_TYPE dest,
+                                          const char *dest_name, int str);
 int MHD__gnutls_x509_der_encode (ASN1_TYPE src, const char *src_name,
-                             MHD_gnutls_datum_t * res, int str);
+                                 MHD_gnutls_datum_t * res, int str);
 
 int MHD__gnutls_x509_export_int (ASN1_TYPE MHD__asn1_data,
-                             MHD_gnutls_x509_crt_fmt_t format, char *pem_header,
-                             unsigned char *output_data,
-                             size_t * output_data_size);
+                                 MHD_gnutls_x509_crt_fmt_t format,
+                                 char *pem_header, unsigned char *output_data,
+                                 size_t * output_data_size);
 
 int MHD__gnutls_x509_read_value (ASN1_TYPE c, const char *root,
-                             MHD_gnutls_datum_t * ret, int str);
+                                 MHD_gnutls_datum_t * ret, int str);
 int MHD__gnutls_x509_write_value (ASN1_TYPE c, const char *root,
-                              const MHD_gnutls_datum_t * data, int str);
+                                  const MHD_gnutls_datum_t * data, int str);
 
 int MHD__gnutls_x509_encode_and_write_attribute (const char *given_oid,
-                                             ASN1_TYPE MHD__asn1_struct,
-                                             const char *where,
-                                             const void *data,
-                                             int sizeof_data, int multi);
+                                                 ASN1_TYPE MHD__asn1_struct,
+                                                 const char *where,
+                                                 const void *data,
+                                                 int sizeof_data, int multi);
 int MHD__gnutls_x509_decode_and_read_attribute (ASN1_TYPE MHD__asn1_struct,
-                                            const char *where, char *oid,
-                                            int oid_size,
-                                            MHD_gnutls_datum_t * value, int multi,
-                                            int octet);
+                                                const char *where, char *oid,
+                                                int oid_size,
+                                                MHD_gnutls_datum_t * value,
+                                                int multi, int octet);
 
 int MHD__gnutls_x509_get_pk_algorithm (ASN1_TYPE src, const char *src_name,
-                                   unsigned int *bits);
+                                       unsigned int *bits);
 
 int MHD__gnutls_x509_encode_and_copy_PKI_params (ASN1_TYPE dst,
-                                             const char *dst_name,
-                                             enum
-                                             MHD_GNUTLS_PublicKeyAlgorithm
-                                             pk_algorithm, mpi_t * params,
-                                             int params_size);
+                                                 const char *dst_name,
+                                                 enum
+                                                 MHD_GNUTLS_PublicKeyAlgorithm
+                                                 pk_algorithm, mpi_t * params,
+                                                 int params_size);
 int MHD__gnutls_asn1_copy_node (ASN1_TYPE * dst, const char *dst_name,
-                            ASN1_TYPE src, const char *src_name);
+                                ASN1_TYPE src, const char *src_name);
 
 int MHD__gnutls_x509_get_signed_data (ASN1_TYPE src, const char *src_name,
-                                  MHD_gnutls_datum_t * signed_data);
+                                      MHD_gnutls_datum_t * signed_data);
 int MHD__gnutls_x509_get_signature (ASN1_TYPE src, const char *src_name,
-                                MHD_gnutls_datum_t * signature);
+                                    MHD_gnutls_datum_t * signature);
 
 #endif
diff --git a/src/daemon/https/x509/crl.c b/src/daemon/https/x509/crl.c
index 17703b91..e023a193 100644
--- a/src/daemon/https/x509/crl.c
+++ b/src/daemon/https/x509/crl.c
@@ -56,8 +56,8 @@ MHD_gnutls_x509_crl_init (MHD_gnutls_x509_crl_t * crl)
   if (*crl)
     {
       int result = MHD__asn1_create_element (MHD__gnutls_get_pkix (),
-                                        "PKIX1.CertificateList",
-                                        &(*crl)->crl);
+                                             "PKIX1.CertificateList",
+                                             &(*crl)->crl);
       if (result != ASN1_SUCCESS)
         {
           MHD_gnutls_assert ();
@@ -104,8 +104,8 @@ MHD_gnutls_x509_crl_deinit (MHD_gnutls_x509_crl_t crl)
   **/
 int
 MHD_gnutls_x509_crl_import (MHD_gnutls_x509_crl_t crl,
-                        const MHD_gnutls_datum_t * data,
-                        MHD_gnutls_x509_crt_fmt_t format)
+                            const MHD_gnutls_datum_t * data,
+                            MHD_gnutls_x509_crt_fmt_t format)
 {
   int result = 0, need_free = 0;
   MHD_gnutls_datum_t _data;
@@ -125,7 +125,8 @@ MHD_gnutls_x509_crl_import (MHD_gnutls_x509_crl_t crl,
     {
       opaque *out;
 
-      result = MHD__gnutls_fbase64_decode (PEM_CRL, data->data, data->size, &out);
+      result =
+        MHD__gnutls_fbase64_decode (PEM_CRL, data->data, data->size, &out);
 
       if (result <= 0)
         {
@@ -181,7 +182,7 @@ cleanup:
   **/
 int
 MHD_gnutls_x509_crl_get_issuer_dn (const MHD_gnutls_x509_crl_t crl, char *buf,
-                               size_t * sizeof_buf)
+                                   size_t * sizeof_buf)
 {
   if (crl == NULL)
     {
@@ -190,8 +191,8 @@ MHD_gnutls_x509_crl_get_issuer_dn (const MHD_gnutls_x509_crl_t crl, char *buf,
     }
 
   return MHD__gnutls_x509_parse_dn (crl->crl,
-                                "tbsCertList.issuer.rdnSequence",
-                                buf, sizeof_buf);
+                                    "tbsCertList.issuer.rdnSequence",
+                                    buf, sizeof_buf);
 }
 
 /**
@@ -221,9 +222,9 @@ MHD_gnutls_x509_crl_get_issuer_dn (const MHD_gnutls_x509_crl_t crl, char *buf,
   **/
 int
 MHD_gnutls_x509_crl_get_issuer_dn_by_oid (MHD_gnutls_x509_crl_t crl,
-                                      const char *oid, int indx,
-                                      unsigned int raw_flag, void *buf,
-                                      size_t * sizeof_buf)
+                                          const char *oid, int indx,
+                                          unsigned int raw_flag, void *buf,
+                                          size_t * sizeof_buf)
 {
   if (crl == NULL)
     {
@@ -232,8 +233,8 @@ MHD_gnutls_x509_crl_get_issuer_dn_by_oid (MHD_gnutls_x509_crl_t crl,
     }
 
   return MHD__gnutls_x509_parse_dn_oid (crl->crl,
-                                    "tbsCertList.issuer.rdnSequence",
-                                    oid, indx, raw_flag, buf, sizeof_buf);
+                                        "tbsCertList.issuer.rdnSequence",
+                                        oid, indx, raw_flag, buf, sizeof_buf);
 }
 
 /**
@@ -255,7 +256,7 @@ MHD_gnutls_x509_crl_get_issuer_dn_by_oid (MHD_gnutls_x509_crl_t crl,
   **/
 int
 MHD_gnutls_x509_crl_get_dn_oid (MHD_gnutls_x509_crl_t crl,
-                            int indx, void *oid, size_t * sizeof_oid)
+                                int indx, void *oid, size_t * sizeof_oid)
 {
   if (crl == NULL)
     {
@@ -264,8 +265,8 @@ MHD_gnutls_x509_crl_get_dn_oid (MHD_gnutls_x509_crl_t crl,
     }
 
   return MHD__gnutls_x509_get_dn_oid (crl->crl,
-                                  "tbsCertList.issuer.rdnSequence", indx,
-                                  oid, sizeof_oid);
+                                      "tbsCertList.issuer.rdnSequence", indx,
+                                      oid, sizeof_oid);
 }
 
 
@@ -297,7 +298,7 @@ MHD_gnutls_x509_crl_get_signature_algorithm (MHD_gnutls_x509_crl_t crl)
 
   result =
     MHD__gnutls_x509_read_value (crl->crl, "signatureAlgorithm.algorithm",
-                             &sa, 0);
+                                 &sa, 0);
 
   if (result < 0)
     {
@@ -324,7 +325,7 @@ MHD_gnutls_x509_crl_get_signature_algorithm (MHD_gnutls_x509_crl_t crl)
  **/
 int
 MHD_gnutls_x509_crl_get_signature (MHD_gnutls_x509_crl_t crl,
-                               char *sig, size_t * sizeof_sig)
+                                   char *sig, size_t * sizeof_sig)
 {
   int result;
   int bits, len;
@@ -391,7 +392,7 @@ MHD_gnutls_x509_crl_get_version (MHD_gnutls_x509_crl_t crl)
   len = sizeof (version);
   if ((result =
        MHD__asn1_read_value (crl->crl, "tbsCertList.version", version,
-                        &len)) != ASN1_SUCCESS)
+                             &len)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       return MHD_gtls_asn2err (result);
@@ -468,7 +469,7 @@ MHD_gnutls_x509_crl_get_crt_count (MHD_gnutls_x509_crl_t crl)
 
   result =
     MHD__asn1_number_of_elements (crl->crl,
-                             "tbsCertList.revokedCertificates", &count);
+                                  "tbsCertList.revokedCertificates", &count);
 
   if (result != ASN1_SUCCESS)
     {
@@ -495,8 +496,8 @@ MHD_gnutls_x509_crl_get_crt_count (MHD_gnutls_x509_crl_t crl)
   **/
 int
 MHD_gnutls_x509_crl_get_crt_serial (MHD_gnutls_x509_crl_t crl, int indx,
-                                unsigned char *serial,
-                                size_t * serial_size, time_t * t)
+                                    unsigned char *serial,
+                                    size_t * serial_size, time_t * t)
 {
 
   int result, _serial_size;
@@ -515,7 +516,8 @@ MHD_gnutls_x509_crl_get_crt_serial (MHD_gnutls_x509_crl_t crl, int indx,
             "tbsCertList.revokedCertificates.?%u.revocationDate", indx + 1);
 
   _serial_size = *serial_size;
-  result = MHD__asn1_read_value (crl->crl, serial_name, serial, &_serial_size);
+  result =
+    MHD__asn1_read_value (crl->crl, serial_name, serial, &_serial_size);
 
   *serial_size = _serial_size;
   if (result != ASN1_SUCCESS)
@@ -547,7 +549,7 @@ MHD_gnutls_x509_crl_get_crt_serial (MHD_gnutls_x509_crl_t crl, int indx,
   -*/
 int
 MHD__gnutls_x509_crl_get_raw_issuer_dn (MHD_gnutls_x509_crl_t crl,
-                                    MHD_gnutls_datum_t * dn)
+                                        MHD_gnutls_datum_t * dn)
 {
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
   int result, len1;
@@ -564,14 +566,15 @@ MHD__gnutls_x509_crl_get_raw_issuer_dn (MHD_gnutls_x509_crl_t crl,
    */
   if ((result =
        MHD__asn1_create_element (MHD__gnutls_get_pkix (), "PKIX1.TBSCertList",
-                            &c2)) != ASN1_SUCCESS)
+                                 &c2)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       return MHD_gtls_asn2err (result);
     }
 
   result =
-    MHD__gnutls_x509_get_signed_data (crl->crl, "tbsCertList", &crl_signed_data);
+    MHD__gnutls_x509_get_signed_data (crl->crl, "tbsCertList",
+                                      &crl_signed_data);
   if (result < 0)
     {
       MHD_gnutls_assert ();
@@ -579,7 +582,8 @@ MHD__gnutls_x509_crl_get_raw_issuer_dn (MHD_gnutls_x509_crl_t crl,
     }
 
   result =
-    MHD__asn1_der_decoding (&c2, crl_signed_data.data, crl_signed_data.size, NULL);
+    MHD__asn1_der_decoding (&c2, crl_signed_data.data, crl_signed_data.size,
+                            NULL);
   if (result != ASN1_SUCCESS)
     {
       /* couldn't decode DER */
@@ -591,8 +595,8 @@ MHD__gnutls_x509_crl_get_raw_issuer_dn (MHD_gnutls_x509_crl_t crl,
 
   result =
     MHD__asn1_der_decoding_startEnd (c2, crl_signed_data.data,
-                                crl_signed_data.size, "issuer",
-                                &start1, &end1);
+                                     crl_signed_data.size, "issuer",
+                                     &start1, &end1);
 
   if (result != ASN1_SUCCESS)
     {
@@ -633,8 +637,8 @@ cleanup:
   **/
 int
 MHD_gnutls_x509_crl_export (MHD_gnutls_x509_crl_t crl,
-                        MHD_gnutls_x509_crt_fmt_t format, void *output_data,
-                        size_t * output_data_size)
+                            MHD_gnutls_x509_crt_fmt_t format,
+                            void *output_data, size_t * output_data_size)
 {
   if (crl == NULL)
     {
@@ -643,7 +647,7 @@ MHD_gnutls_x509_crl_export (MHD_gnutls_x509_crl_t crl,
     }
 
   return MHD__gnutls_x509_export_int (crl->crl, format, PEM_CRL,
-                                  output_data, output_data_size);
+                                      output_data, output_data_size);
 }
 
 /*-
@@ -657,14 +661,16 @@ MHD_gnutls_x509_crl_export (MHD_gnutls_x509_crl_t crl,
   *
   -*/
 int
-MHD__gnutls_x509_crl_cpy (MHD_gnutls_x509_crl_t dest, MHD_gnutls_x509_crl_t src)
+MHD__gnutls_x509_crl_cpy (MHD_gnutls_x509_crl_t dest,
+                          MHD_gnutls_x509_crl_t src)
 {
   int ret;
   size_t der_size;
   opaque *der;
   MHD_gnutls_datum_t tmp;
 
-  ret = MHD_gnutls_x509_crl_export (src, GNUTLS_X509_FMT_DER, NULL, &der_size);
+  ret =
+    MHD_gnutls_x509_crl_export (src, GNUTLS_X509_FMT_DER, NULL, &der_size);
   if (ret != GNUTLS_E_SHORT_MEMORY_BUFFER)
     {
       MHD_gnutls_assert ();
diff --git a/src/daemon/https/x509/crq.c b/src/daemon/https/x509/crq.c
index 147be276..88ac349d 100644
--- a/src/daemon/https/x509/crq.c
+++ b/src/daemon/https/x509/crq.c
@@ -59,8 +59,8 @@ MHD_gnutls_x509_crq_init (MHD_gnutls_x509_crq_t * crq)
   if (*crq)
     {
       int result = MHD__asn1_create_element (MHD__gnutls_get_pkix (),
-                                        "PKIX1.pkcs-10-CertificationRequest",
-                                        &((*crq)->crq));
+                                             "PKIX1.pkcs-10-CertificationRequest",
+                                             &((*crq)->crq));
       if (result != ASN1_SUCCESS)
         {
           MHD_gnutls_assert ();
@@ -110,8 +110,8 @@ MHD_gnutls_x509_crq_deinit (MHD_gnutls_x509_crq_t crq)
   **/
 int
 MHD_gnutls_x509_crq_import (MHD_gnutls_x509_crq_t crq,
-                        const MHD_gnutls_datum_t * data,
-                        MHD_gnutls_x509_crt_fmt_t format)
+                            const MHD_gnutls_datum_t * data,
+                            MHD_gnutls_x509_crt_fmt_t format)
 {
   int result = 0, need_free = 0;
   MHD_gnutls_datum_t _data;
@@ -132,7 +132,8 @@ MHD_gnutls_x509_crq_import (MHD_gnutls_x509_crq_t crq,
       opaque *out;
 
       /* Try the first header */
-      result = MHD__gnutls_fbase64_decode (PEM_CRQ, data->data, data->size, &out);
+      result =
+        MHD__gnutls_fbase64_decode (PEM_CRQ, data->data, data->size, &out);
 
       if (result <= 0)          /* Go for the second header */
         result =
@@ -189,7 +190,8 @@ cleanup:
   *
   **/
 int
-MHD_gnutls_x509_crq_get_dn (MHD_gnutls_x509_crq_t crq, char *buf, size_t * sizeof_buf)
+MHD_gnutls_x509_crq_get_dn (MHD_gnutls_x509_crq_t crq, char *buf,
+                            size_t * sizeof_buf)
 {
   if (crq == NULL)
     {
@@ -198,8 +200,8 @@ MHD_gnutls_x509_crq_get_dn (MHD_gnutls_x509_crq_t crq, char *buf, size_t * sizeo
     }
 
   return MHD__gnutls_x509_parse_dn (crq->crq,
-                                "certificationRequestInfo.subject.rdnSequence",
-                                buf, sizeof_buf);
+                                    "certificationRequestInfo.subject.rdnSequence",
+                                    buf, sizeof_buf);
 }
 
 /**
@@ -232,8 +234,8 @@ MHD_gnutls_x509_crq_get_dn (MHD_gnutls_x509_crq_t crq, char *buf, size_t * sizeo
   **/
 int
 MHD_gnutls_x509_crq_get_dn_by_oid (MHD_gnutls_x509_crq_t crq, const char *oid,
-                               int indx, unsigned int raw_flag,
-                               void *buf, size_t * sizeof_buf)
+                                   int indx, unsigned int raw_flag,
+                                   void *buf, size_t * sizeof_buf)
 {
   if (crq == NULL)
     {
@@ -242,8 +244,8 @@ MHD_gnutls_x509_crq_get_dn_by_oid (MHD_gnutls_x509_crq_t crq, const char *oid,
     }
 
   return MHD__gnutls_x509_parse_dn_oid (crq->crq,
-                                    "certificationRequestInfo.subject.rdnSequence",
-                                    oid, indx, raw_flag, buf, sizeof_buf);
+                                        "certificationRequestInfo.subject.rdnSequence",
+                                        oid, indx, raw_flag, buf, sizeof_buf);
 }
 
 /**
@@ -265,7 +267,7 @@ MHD_gnutls_x509_crq_get_dn_by_oid (MHD_gnutls_x509_crq_t crq, const char *oid,
   **/
 int
 MHD_gnutls_x509_crq_get_dn_oid (MHD_gnutls_x509_crq_t crq,
-                            int indx, void *oid, size_t * sizeof_oid)
+                                int indx, void *oid, size_t * sizeof_oid)
 {
   if (crq == NULL)
     {
@@ -274,8 +276,8 @@ MHD_gnutls_x509_crq_get_dn_oid (MHD_gnutls_x509_crq_t crq,
     }
 
   return MHD__gnutls_x509_get_dn_oid (crq->crq,
-                                  "certificationRequestInfo.subject.rdnSequence",
-                                  indx, oid, sizeof_oid);
+                                      "certificationRequestInfo.subject.rdnSequence",
+                                      indx, oid, sizeof_oid);
 }
 
 /* Parses an Attribute list in the MHD__asn1_struct, and searches for the
@@ -319,7 +321,8 @@ parse_attribute (ASN1_TYPE MHD__asn1_struct,
         snprintf (tmpbuffer1, sizeof (tmpbuffer1), "?%u", k1);
 
       len = sizeof (value) - 1;
-      result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer1, value, &len);
+      result =
+        MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer1, value, &len);
 
       if (result == ASN1_ELEMENT_NOT_FOUND)
         {
@@ -362,7 +365,8 @@ parse_attribute (ASN1_TYPE MHD__asn1_struct,
                     tmpbuffer1, indx + 1);
 
           len = sizeof (value) - 1;
-          result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer3, value, &len);
+          result =
+            MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer3, value, &len);
 
           if (result != ASN1_SUCCESS)
             {
@@ -434,7 +438,7 @@ cleanup:
   **/
 int
 MHD_gnutls_x509_crq_get_challenge_password (MHD_gnutls_x509_crq_t crq,
-                                        char *pass, size_t * sizeof_pass)
+                                            char *pass, size_t * sizeof_pass)
 {
   if (crq == NULL)
     {
@@ -461,8 +465,8 @@ MHD_gnutls_x509_crq_get_challenge_password (MHD_gnutls_x509_crq_t crq,
   **/
 int
 MHD_gnutls_x509_crq_set_attribute_by_oid (MHD_gnutls_x509_crq_t crq,
-                                      const char *oid, void *buf,
-                                      size_t sizeof_buf)
+                                          const char *oid, void *buf,
+                                          size_t sizeof_buf)
 {
   int result;
 
@@ -476,7 +480,7 @@ MHD_gnutls_x509_crq_set_attribute_by_oid (MHD_gnutls_x509_crq_t crq,
    */
   result =
     MHD__asn1_write_value (crq->crq, "certificationRequestInfo.attributes",
-                      "NEW", 1);
+                           "NEW", 1);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -485,9 +489,9 @@ MHD_gnutls_x509_crq_set_attribute_by_oid (MHD_gnutls_x509_crq_t crq,
 
   result =
     MHD__gnutls_x509_encode_and_write_attribute (oid,
-                                             crq->crq,
-                                             "certificationRequestInfo.attributes.?LAST",
-                                             buf, sizeof_buf, 1);
+                                                 crq->crq,
+                                                 "certificationRequestInfo.attributes.?LAST",
+                                                 buf, sizeof_buf, 1);
 
   if (result < 0)
     {
@@ -515,8 +519,8 @@ MHD_gnutls_x509_crq_set_attribute_by_oid (MHD_gnutls_x509_crq_t crq,
   **/
 int
 MHD_gnutls_x509_crq_get_attribute_by_oid (MHD_gnutls_x509_crq_t crq,
-                                      const char *oid, int indx, void *buf,
-                                      size_t * sizeof_buf)
+                                          const char *oid, int indx,
+                                          void *buf, size_t * sizeof_buf)
 {
   if (crq == NULL)
     {
@@ -550,8 +554,8 @@ MHD_gnutls_x509_crq_get_attribute_by_oid (MHD_gnutls_x509_crq_t crq,
   **/
 int
 MHD_gnutls_x509_crq_set_dn_by_oid (MHD_gnutls_x509_crq_t crq, const char *oid,
-                               unsigned int raw_flag, const void *data,
-                               unsigned int sizeof_data)
+                                   unsigned int raw_flag, const void *data,
+                                   unsigned int sizeof_data)
 {
   if (sizeof_data == 0 || data == NULL || crq == NULL)
     {
@@ -559,8 +563,8 @@ MHD_gnutls_x509_crq_set_dn_by_oid (MHD_gnutls_x509_crq_t crq, const char *oid,
     }
 
   return MHD__gnutls_x509_set_dn_oid (crq->crq,
-                                  "certificationRequestInfo.subject", oid,
-                                  raw_flag, data, sizeof_data);
+                                      "certificationRequestInfo.subject", oid,
+                                      raw_flag, data, sizeof_data);
 }
 
 /**
@@ -575,7 +579,8 @@ MHD_gnutls_x509_crq_set_dn_by_oid (MHD_gnutls_x509_crq_t crq, const char *oid,
   *
   **/
 int
-MHD_gnutls_x509_crq_set_version (MHD_gnutls_x509_crq_t crq, unsigned int version)
+MHD_gnutls_x509_crq_set_version (MHD_gnutls_x509_crq_t crq,
+                                 unsigned int version)
 {
   int result;
   unsigned char null = version;
@@ -590,7 +595,8 @@ MHD_gnutls_x509_crq_set_version (MHD_gnutls_x509_crq_t crq, unsigned int version
     null--;
 
   result =
-    MHD__asn1_write_value (crq->crq, "certificationRequestInfo.version", &null, 1);
+    MHD__asn1_write_value (crq->crq, "certificationRequestInfo.version",
+                           &null, 1);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -624,7 +630,7 @@ MHD_gnutls_x509_crq_get_version (MHD_gnutls_x509_crq_t crq)
   len = sizeof (version);
   if ((result =
        MHD__asn1_read_value (crq->crq, "certificationRequestInfo.version",
-                        version, &len)) != ASN1_SUCCESS)
+                             version, &len)) != ASN1_SUCCESS)
     {
 
       if (result == ASN1_ELEMENT_NOT_FOUND)
@@ -648,7 +654,8 @@ MHD_gnutls_x509_crq_get_version (MHD_gnutls_x509_crq_t crq)
   *
   **/
 int
-MHD_gnutls_x509_crq_set_key (MHD_gnutls_x509_crq_t crq, MHD_gnutls_x509_privkey_t key)
+MHD_gnutls_x509_crq_set_key (MHD_gnutls_x509_crq_t crq,
+                             MHD_gnutls_x509_privkey_t key)
 {
   int result;
 
@@ -659,10 +666,10 @@ MHD_gnutls_x509_crq_set_key (MHD_gnutls_x509_crq_t crq, MHD_gnutls_x509_privkey_
     }
 
   result = MHD__gnutls_x509_encode_and_copy_PKI_params (crq->crq,
-                                                    "certificationRequestInfo.subjectPKInfo",
-                                                    key->pk_algorithm,
-                                                    key->params,
-                                                    key->params_size);
+                                                        "certificationRequestInfo.subjectPKInfo",
+                                                        key->pk_algorithm,
+                                                        key->params,
+                                                        key->params_size);
 
   if (result < 0)
     {
@@ -685,7 +692,7 @@ MHD_gnutls_x509_crq_set_key (MHD_gnutls_x509_crq_t crq, MHD_gnutls_x509_privkey_
   **/
 int
 MHD_gnutls_x509_crq_set_challenge_password (MHD_gnutls_x509_crq_t crq,
-                                        const char *pass)
+                                            const char *pass)
 {
   int result;
 
@@ -699,7 +706,7 @@ MHD_gnutls_x509_crq_set_challenge_password (MHD_gnutls_x509_crq_t crq,
    */
   result =
     MHD__asn1_write_value (crq->crq, "certificationRequestInfo.attributes",
-                      "NEW", 1);
+                           "NEW", 1);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -708,9 +715,9 @@ MHD_gnutls_x509_crq_set_challenge_password (MHD_gnutls_x509_crq_t crq,
 
   result =
     MHD__gnutls_x509_encode_and_write_attribute ("1.2.840.113549.1.9.7",
-                                             crq->crq,
-                                             "certificationRequestInfo.attributes.?LAST",
-                                             pass, strlen (pass), 1);
+                                                 crq->crq,
+                                                 "certificationRequestInfo.attributes.?LAST",
+                                                 pass, strlen (pass), 1);
 
   if (result < 0)
     {
@@ -739,8 +746,10 @@ MHD_gnutls_x509_crq_set_challenge_password (MHD_gnutls_x509_crq_t crq,
   *
   **/
 int
-MHD_gnutls_x509_crq_sign2 (MHD_gnutls_x509_crq_t crq, MHD_gnutls_x509_privkey_t key,
-                       enum MHD_GNUTLS_HashAlgorithm dig, unsigned int flags)
+MHD_gnutls_x509_crq_sign2 (MHD_gnutls_x509_crq_t crq,
+                           MHD_gnutls_x509_privkey_t key,
+                           enum MHD_GNUTLS_HashAlgorithm dig,
+                           unsigned int flags)
 {
   int result;
   MHD_gnutls_datum_t signature;
@@ -755,7 +764,7 @@ MHD_gnutls_x509_crq_sign2 (MHD_gnutls_x509_crq_t crq, MHD_gnutls_x509_privkey_t
    */
   result =
     MHD__gnutls_x509_sign_tbs (crq->crq, "certificationRequestInfo",
-                           dig, key, &signature);
+                               dig, key, &signature);
 
   if (result < 0)
     {
@@ -767,7 +776,7 @@ MHD_gnutls_x509_crq_sign2 (MHD_gnutls_x509_crq_t crq, MHD_gnutls_x509_privkey_t
    */
   result =
     MHD__asn1_write_value (crq->crq, "signature", signature.data,
-                      signature.size * 8);
+                           signature.size * 8);
 
   MHD__gnutls_free_datum (&signature);
 
@@ -780,8 +789,8 @@ MHD_gnutls_x509_crq_sign2 (MHD_gnutls_x509_crq_t crq, MHD_gnutls_x509_privkey_t
   /* Step 3. Write the signatureAlgorithm field.
    */
   result = MHD__gnutls_x509_write_sig_params (crq->crq, "signatureAlgorithm",
-                                          key->pk_algorithm, dig, key->params,
-                                          key->params_size);
+                                              key->pk_algorithm, dig,
+                                              key->params, key->params_size);
   if (result < 0)
     {
       MHD_gnutls_assert ();
@@ -803,7 +812,8 @@ MHD_gnutls_x509_crq_sign2 (MHD_gnutls_x509_crq_t crq, MHD_gnutls_x509_privkey_t
   *
   **/
 int
-MHD_gnutls_x509_crq_sign (MHD_gnutls_x509_crq_t crq, MHD_gnutls_x509_privkey_t key)
+MHD_gnutls_x509_crq_sign (MHD_gnutls_x509_crq_t crq,
+                          MHD_gnutls_x509_privkey_t key)
 {
   return MHD_gnutls_x509_crq_sign2 (crq, key, MHD_GNUTLS_MAC_SHA1, 0);
 }
@@ -831,8 +841,8 @@ MHD_gnutls_x509_crq_sign (MHD_gnutls_x509_crq_t crq, MHD_gnutls_x509_privkey_t k
   **/
 int
 MHD_gnutls_x509_crq_export (MHD_gnutls_x509_crq_t crq,
-                        MHD_gnutls_x509_crt_fmt_t format, void *output_data,
-                        size_t * output_data_size)
+                            MHD_gnutls_x509_crt_fmt_t format,
+                            void *output_data, size_t * output_data_size)
 {
   if (crq == NULL)
     {
@@ -841,7 +851,7 @@ MHD_gnutls_x509_crq_export (MHD_gnutls_x509_crq_t crq,
     }
 
   return MHD__gnutls_x509_export_int (crq->crq, format, PEM_CRQ,
-                                  output_data, output_data_size);
+                                      output_data, output_data_size);
 }
 
 /**
@@ -862,7 +872,8 @@ MHD_gnutls_x509_crq_export (MHD_gnutls_x509_crq_t crq,
   *
   **/
 int
-MHD_gnutls_x509_crq_get_pk_algorithm (MHD_gnutls_x509_crq_t crq, unsigned int *bits)
+MHD_gnutls_x509_crq_get_pk_algorithm (MHD_gnutls_x509_crq_t crq,
+                                      unsigned int *bits)
 {
   int result;
 
@@ -874,8 +885,8 @@ MHD_gnutls_x509_crq_get_pk_algorithm (MHD_gnutls_x509_crq_t crq, unsigned int *b
 
   result =
     MHD__gnutls_x509_get_pk_algorithm (crq->crq,
-                                   "certificationRequestInfo.subjectPKInfo",
-                                   bits);
+                                       "certificationRequestInfo.subjectPKInfo",
+                                       bits);
   if (result < 0)
     {
       MHD_gnutls_assert ();
diff --git a/src/daemon/https/x509/dn.c b/src/daemon/https/x509/dn.c
index eac31f33..17b4ed76 100644
--- a/src/daemon/https/x509/dn.c
+++ b/src/daemon/https/x509/dn.c
@@ -88,8 +88,8 @@ str_escape (char *str, char *buffer, unsigned int buffer_size)
  */
 int
 MHD__gnutls_x509_parse_dn (ASN1_TYPE MHD__asn1_struct,
-                       const char *MHD__asn1_rdn_name, char *buf,
-                       size_t * sizeof_buf)
+                           const char *MHD__asn1_rdn_name, char *buf,
+                           size_t * sizeof_buf)
 {
   MHD_gtls_string out_str;
   int k2, k1, result;
@@ -115,7 +115,8 @@ MHD__gnutls_x509_parse_dn (ASN1_TYPE MHD__asn1_struct,
   else
     *sizeof_buf = 0;
 
-  MHD_gtls_string_init (&out_str, MHD_gnutls_malloc, MHD_gnutls_realloc, MHD_gnutls_free);
+  MHD_gtls_string_init (&out_str, MHD_gnutls_malloc, MHD_gnutls_realloc,
+                        MHD_gnutls_free);
 
   k1 = 0;
   do
@@ -125,13 +126,14 @@ MHD__gnutls_x509_parse_dn (ASN1_TYPE MHD__asn1_struct,
       /* create a string like "tbsCertList.issuer.rdnSequence.?1"
        */
       if (MHD__asn1_rdn_name[0] != 0)
-        snprintf (tmpbuffer1, sizeof (tmpbuffer1), "%s.?%u", MHD__asn1_rdn_name,
-                  k1);
+        snprintf (tmpbuffer1, sizeof (tmpbuffer1), "%s.?%u",
+                  MHD__asn1_rdn_name, k1);
       else
         snprintf (tmpbuffer1, sizeof (tmpbuffer1), "?%u", k1);
 
       len = sizeof (value) - 1;
-      result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer1, value, &len);
+      result =
+        MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer1, value, &len);
 
       if (result == ASN1_ELEMENT_NOT_FOUND)
         {
@@ -162,7 +164,8 @@ MHD__gnutls_x509_parse_dn (ASN1_TYPE MHD__asn1_struct,
            */
 
           len = sizeof (value) - 1;
-          result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer2, value, &len);
+          result =
+            MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer2, value, &len);
 
           if (result == ASN1_ELEMENT_NOT_FOUND)
             break;
@@ -179,7 +182,8 @@ MHD__gnutls_x509_parse_dn (ASN1_TYPE MHD__asn1_struct,
           MHD_gtls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".type");
 
           len = sizeof (oid) - 1;
-          result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer3, oid, &len);
+          result =
+            MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer3, oid, &len);
 
           if (result == ASN1_ELEMENT_NOT_FOUND)
             break;
@@ -196,7 +200,8 @@ MHD__gnutls_x509_parse_dn (ASN1_TYPE MHD__asn1_struct,
           MHD_gtls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".value");
 
           len = 0;
-          result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer3, NULL, &len);
+          result =
+            MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer3, NULL, &len);
 
           value2 = MHD_gnutls_malloc (len);
           if (value2 == NULL)
@@ -206,7 +211,8 @@ MHD__gnutls_x509_parse_dn (ASN1_TYPE MHD__asn1_struct,
               goto cleanup;
             }
 
-          result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer3, value2, &len);
+          result =
+            MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer3, value2, &len);
 
           if (result != ASN1_SUCCESS)
             {
@@ -268,12 +274,14 @@ MHD__gnutls_x509_parse_dn (ASN1_TYPE MHD__asn1_struct,
           if (printable)
             result =
               MHD__gnutls_x509_oid_data2string (oid,
-                                            value2, len,
-                                            string, &sizeof_string);
+                                                value2, len,
+                                                string, &sizeof_string);
 
           if (!printable || result < 0)
             result =
-              MHD__gnutls_x509_data2hex ((const unsigned char*) value2, len, (unsigned char*) string, &sizeof_string);
+              MHD__gnutls_x509_data2hex ((const unsigned char *) value2, len,
+                                         (unsigned char *) string,
+                                         &sizeof_string);
 
           if (result < 0)
             {
@@ -338,10 +346,10 @@ cleanup:
  */
 int
 MHD__gnutls_x509_parse_dn_oid (ASN1_TYPE MHD__asn1_struct,
-                           const char *MHD__asn1_rdn_name,
-                           const char *given_oid, int indx,
-                           unsigned int raw_flag,
-                           void *buf, size_t * sizeof_buf)
+                               const char *MHD__asn1_rdn_name,
+                               const char *given_oid, int indx,
+                               unsigned int raw_flag,
+                               void *buf, size_t * sizeof_buf)
 {
   int k2, k1, result;
   char tmpbuffer1[MAX_NAME_SIZE];
@@ -366,13 +374,14 @@ MHD__gnutls_x509_parse_dn_oid (ASN1_TYPE MHD__asn1_struct,
       /* create a string like "tbsCertList.issuer.rdnSequence.?1"
        */
       if (MHD__asn1_rdn_name[0] != 0)
-        snprintf (tmpbuffer1, sizeof (tmpbuffer1), "%s.?%u", MHD__asn1_rdn_name,
-                  k1);
+        snprintf (tmpbuffer1, sizeof (tmpbuffer1), "%s.?%u",
+                  MHD__asn1_rdn_name, k1);
       else
         snprintf (tmpbuffer1, sizeof (tmpbuffer1), "?%u", k1);
 
       len = sizeof (value) - 1;
-      result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer1, value, &len);
+      result =
+        MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer1, value, &len);
 
       if (result == ASN1_ELEMENT_NOT_FOUND)
         {
@@ -404,7 +413,8 @@ MHD__gnutls_x509_parse_dn_oid (ASN1_TYPE MHD__asn1_struct,
            */
 
           len = sizeof (value) - 1;
-          result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer2, value, &len);
+          result =
+            MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer2, value, &len);
 
           if (result == ASN1_ELEMENT_NOT_FOUND)
             {
@@ -423,7 +433,8 @@ MHD__gnutls_x509_parse_dn_oid (ASN1_TYPE MHD__asn1_struct,
           MHD_gtls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".type");
 
           len = sizeof (oid) - 1;
-          result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer3, oid, &len);
+          result =
+            MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer3, oid, &len);
 
           if (result == ASN1_ELEMENT_NOT_FOUND)
             break;
@@ -443,7 +454,9 @@ MHD__gnutls_x509_parse_dn_oid (ASN1_TYPE MHD__asn1_struct,
               MHD_gtls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".value");
 
               len = *sizeof_buf;
-              result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer3, buf, &len);
+              result =
+                MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer3, buf,
+                                      &len);
 
               if (result != ASN1_SUCCESS)
                 {
@@ -474,10 +487,12 @@ MHD__gnutls_x509_parse_dn_oid (ASN1_TYPE MHD__asn1_struct,
                   if (printable == 1)
                     result =
                       MHD__gnutls_x509_oid_data2string (oid, buf, len,
-                                                    cbuf, sizeof_buf);
+                                                        cbuf, sizeof_buf);
                   else
                     result =
-                      MHD__gnutls_x509_data2hex (buf, len, (unsigned char*) cbuf, sizeof_buf);
+                      MHD__gnutls_x509_data2hex (buf, len,
+                                                 (unsigned char *) cbuf,
+                                                 sizeof_buf);
 
                   if (result < 0)
                     {
@@ -515,8 +530,8 @@ cleanup:
  */
 int
 MHD__gnutls_x509_get_dn_oid (ASN1_TYPE MHD__asn1_struct,
-                         const char *MHD__asn1_rdn_name,
-                         int indx, void *_oid, size_t * sizeof_oid)
+                             const char *MHD__asn1_rdn_name,
+                             int indx, void *_oid, size_t * sizeof_oid)
 {
   int k2, k1, result;
   char tmpbuffer1[MAX_NAME_SIZE];
@@ -535,13 +550,14 @@ MHD__gnutls_x509_get_dn_oid (ASN1_TYPE MHD__asn1_struct,
       /* create a string like "tbsCertList.issuer.rdnSequence.?1"
        */
       if (MHD__asn1_rdn_name[0] != 0)
-        snprintf (tmpbuffer1, sizeof (tmpbuffer1), "%s.?%u", MHD__asn1_rdn_name,
-                  k1);
+        snprintf (tmpbuffer1, sizeof (tmpbuffer1), "%s.?%u",
+                  MHD__asn1_rdn_name, k1);
       else
         snprintf (tmpbuffer1, sizeof (tmpbuffer1), "?%u", k1);
 
       len = sizeof (value) - 1;
-      result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer1, value, &len);
+      result =
+        MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer1, value, &len);
 
       if (result == ASN1_ELEMENT_NOT_FOUND)
         {
@@ -573,7 +589,8 @@ MHD__gnutls_x509_get_dn_oid (ASN1_TYPE MHD__asn1_struct,
            */
 
           len = sizeof (value) - 1;
-          result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer2, value, &len);
+          result =
+            MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer2, value, &len);
 
           if (result == ASN1_ELEMENT_NOT_FOUND)
             {
@@ -592,7 +609,8 @@ MHD__gnutls_x509_get_dn_oid (ASN1_TYPE MHD__asn1_struct,
           MHD_gtls_str_cat (tmpbuffer3, sizeof (tmpbuffer3), ".type");
 
           len = sizeof (oid) - 1;
-          result = MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer3, oid, &len);
+          result =
+            MHD__asn1_read_value (MHD__asn1_struct, tmpbuffer3, oid, &len);
 
           if (result == ASN1_ELEMENT_NOT_FOUND)
             break;
@@ -640,10 +658,10 @@ cleanup:
  */
 int
 MHD__gnutls_x509_encode_and_write_attribute (const char *given_oid,
-                                         ASN1_TYPE MHD__asn1_struct,
-                                         const char *where,
-                                         const void *_data,
-                                         int sizeof_data, int multi)
+                                             ASN1_TYPE MHD__asn1_struct,
+                                             const char *where,
+                                             const void *_data,
+                                             int sizeof_data, int multi)
 {
   const char *val_name;
   const opaque *data = _data;
@@ -654,7 +672,8 @@ MHD__gnutls_x509_encode_and_write_attribute (const char *given_oid,
 
   /* Find how to encode the data.
    */
-  val_name = MHD__asn1_find_structure_from_oid (MHD__gnutls_get_pkix (), given_oid);
+  val_name =
+    MHD__asn1_find_structure_from_oid (MHD__gnutls_get_pkix (), given_oid);
   if (val_name == NULL)
     {
       MHD_gnutls_assert ();
@@ -736,7 +755,8 @@ MHD__gnutls_x509_encode_and_write_attribute (const char *given_oid,
 
     }
 
-  result = MHD__gnutls_x509_der_encode_and_copy (c2, "", MHD__asn1_struct, tmp, 0);
+  result =
+    MHD__gnutls_x509_der_encode_and_copy (c2, "", MHD__asn1_struct, tmp, 0);
   if (result < 0)
     {
       MHD_gnutls_assert ();
@@ -763,8 +783,9 @@ MHD__gnutls_x509_encode_and_write_attribute (const char *given_oid,
  */
 static int
 MHD__gnutls_x509_write_attribute (const char *given_oid,
-                              ASN1_TYPE MHD__asn1_struct, const char *where,
-                              const void *_data, int sizeof_data)
+                                  ASN1_TYPE MHD__asn1_struct,
+                                  const char *where, const void *_data,
+                                  int sizeof_data)
 {
   char tmp[128];
   int result;
@@ -808,9 +829,10 @@ MHD__gnutls_x509_write_attribute (const char *given_oid,
  */
 int
 MHD__gnutls_x509_decode_and_read_attribute (ASN1_TYPE MHD__asn1_struct,
-                                        const char *where, char *oid,
-                                        int oid_size, MHD_gnutls_datum_t * value,
-                                        int multi, int octet_string)
+                                            const char *where, char *oid,
+                                            int oid_size,
+                                            MHD_gnutls_datum_t * value,
+                                            int multi, int octet_string)
 {
   char tmpbuffer[128];
   int len, result;
@@ -840,7 +862,8 @@ MHD__gnutls_x509_decode_and_read_attribute (ASN1_TYPE MHD__asn1_struct,
     MHD_gtls_str_cat (tmpbuffer, sizeof (tmpbuffer), "s.?1");   /* .values.?1 */
 
   result =
-    MHD__gnutls_x509_read_value (MHD__asn1_struct, tmpbuffer, value, octet_string);
+    MHD__gnutls_x509_read_value (MHD__asn1_struct, tmpbuffer, value,
+                                 octet_string);
   if (result < 0)
     {
       MHD_gnutls_assert ();
@@ -860,8 +883,9 @@ MHD__gnutls_x509_decode_and_read_attribute (ASN1_TYPE MHD__asn1_struct,
  */
 int
 MHD__gnutls_x509_set_dn_oid (ASN1_TYPE MHD__asn1_struct,
-                         const char *MHD__asn1_name, const char *given_oid,
-                         int raw_flag, const char *name, int sizeof_name)
+                             const char *MHD__asn1_name,
+                             const char *given_oid, int raw_flag,
+                             const char *name, int sizeof_name)
 {
   int result;
   char tmp[MAX_NAME_SIZE], MHD__asn1_rdn_name[MAX_NAME_SIZE];
@@ -874,19 +898,24 @@ MHD__gnutls_x509_set_dn_oid (ASN1_TYPE MHD__asn1_struct,
 
   /* create the rdnSequence
    */
-  result = MHD__asn1_write_value (MHD__asn1_struct, MHD__asn1_name, "rdnSequence", 1);
+  result =
+    MHD__asn1_write_value (MHD__asn1_struct, MHD__asn1_name, "rdnSequence",
+                           1);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       return MHD_gtls_asn2err (result);
     }
 
-  MHD_gtls_str_cpy (MHD__asn1_rdn_name, sizeof (MHD__asn1_rdn_name), MHD__asn1_name);
-  MHD_gtls_str_cat (MHD__asn1_rdn_name, sizeof (MHD__asn1_rdn_name), ".rdnSequence");
+  MHD_gtls_str_cpy (MHD__asn1_rdn_name, sizeof (MHD__asn1_rdn_name),
+                    MHD__asn1_name);
+  MHD_gtls_str_cat (MHD__asn1_rdn_name, sizeof (MHD__asn1_rdn_name),
+                    ".rdnSequence");
 
   /* create a new element
    */
-  result = MHD__asn1_write_value (MHD__asn1_struct, MHD__asn1_rdn_name, "NEW", 1);
+  result =
+    MHD__asn1_write_value (MHD__asn1_struct, MHD__asn1_rdn_name, "NEW", 1);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -915,14 +944,15 @@ MHD__gnutls_x509_set_dn_oid (ASN1_TYPE MHD__asn1_struct,
     {
       result =
         MHD__gnutls_x509_encode_and_write_attribute (given_oid,
-                                                 MHD__asn1_struct,
-                                                 tmp, name, sizeof_name, 0);
+                                                     MHD__asn1_struct,
+                                                     tmp, name, sizeof_name,
+                                                     0);
     }
   else
     {
       result =
         MHD__gnutls_x509_write_attribute (given_oid, MHD__asn1_struct,
-                                      tmp, name, sizeof_name);
+                                          tmp, name, sizeof_name);
     }
 
   if (result < 0)
@@ -952,7 +982,7 @@ MHD__gnutls_x509_set_dn_oid (ASN1_TYPE MHD__asn1_struct,
   **/
 int
 MHD_gnutls_x509_rdn_get (const MHD_gnutls_datum_t * idn,
-                     char *buf, size_t * sizeof_buf)
+                         char *buf, size_t * sizeof_buf)
 {
   int result;
   ASN1_TYPE dn = ASN1_TYPE_EMPTY;
@@ -969,7 +999,7 @@ MHD_gnutls_x509_rdn_get (const MHD_gnutls_datum_t * idn,
 
   if ((result =
        MHD__asn1_create_element (MHD__gnutls_get_pkix (),
-                            "PKIX1.Name", &dn)) != ASN1_SUCCESS)
+                                 "PKIX1.Name", &dn)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       return MHD_gtls_asn2err (result);
@@ -1010,9 +1040,10 @@ MHD_gnutls_x509_rdn_get (const MHD_gnutls_datum_t * idn,
   *
   **/
 int
-MHD_gnutls_x509_rdn_get_by_oid (const MHD_gnutls_datum_t * idn, const char *oid,
-                            int indx, unsigned int raw_flag,
-                            void *buf, size_t * sizeof_buf)
+MHD_gnutls_x509_rdn_get_by_oid (const MHD_gnutls_datum_t * idn,
+                                const char *oid, int indx,
+                                unsigned int raw_flag, void *buf,
+                                size_t * sizeof_buf)
 {
   int result;
   ASN1_TYPE dn = ASN1_TYPE_EMPTY;
@@ -1024,7 +1055,7 @@ MHD_gnutls_x509_rdn_get_by_oid (const MHD_gnutls_datum_t * idn, const char *oid,
 
   if ((result =
        MHD__asn1_create_element (MHD__gnutls_get_pkix (),
-                            "PKIX1.Name", &dn)) != ASN1_SUCCESS)
+                                 "PKIX1.Name", &dn)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       return MHD_gtls_asn2err (result);
@@ -1041,7 +1072,7 @@ MHD_gnutls_x509_rdn_get_by_oid (const MHD_gnutls_datum_t * idn, const char *oid,
 
   result =
     MHD__gnutls_x509_parse_dn_oid (dn, "rdnSequence", oid, indx,
-                               raw_flag, buf, sizeof_buf);
+                                   raw_flag, buf, sizeof_buf);
 
   MHD__asn1_delete_structure (&dn);
   return result;
@@ -1064,7 +1095,7 @@ MHD_gnutls_x509_rdn_get_by_oid (const MHD_gnutls_datum_t * idn, const char *oid,
   **/
 int
 MHD_gnutls_x509_rdn_get_oid (const MHD_gnutls_datum_t * idn,
-                         int indx, void *buf, size_t * sizeof_buf)
+                             int indx, void *buf, size_t * sizeof_buf)
 {
   int result;
   ASN1_TYPE dn = ASN1_TYPE_EMPTY;
@@ -1076,7 +1107,7 @@ MHD_gnutls_x509_rdn_get_oid (const MHD_gnutls_datum_t * idn,
 
   if ((result =
        MHD__asn1_create_element (MHD__gnutls_get_pkix (),
-                            "PKIX1.Name", &dn)) != ASN1_SUCCESS)
+                                 "PKIX1.Name", &dn)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       return MHD_gtls_asn2err (result);
@@ -1091,7 +1122,8 @@ MHD_gnutls_x509_rdn_get_oid (const MHD_gnutls_datum_t * idn,
       return MHD_gtls_asn2err (result);
     }
 
-  result = MHD__gnutls_x509_get_dn_oid (dn, "rdnSequence", indx, buf, sizeof_buf);
+  result =
+    MHD__gnutls_x509_get_dn_oid (dn, "rdnSequence", indx, buf, sizeof_buf);
 
   MHD__asn1_delete_structure (&dn);
   return result;
@@ -1108,7 +1140,7 @@ MHD_gnutls_x509_rdn_get_oid (const MHD_gnutls_datum_t * idn,
  */
 int
 MHD__gnutls_x509_compare_raw_dn (const MHD_gnutls_datum_t * dn1,
-                             const MHD_gnutls_datum_t * dn2)
+                                 const MHD_gnutls_datum_t * dn2)
 {
 
   if (dn1->size != dn2->size)
diff --git a/src/daemon/https/x509/dn.h b/src/daemon/https/x509/dn.h
index 04352b10..a0c6ac45 100644
--- a/src/daemon/https/x509/dn.h
+++ b/src/daemon/https/x509/dn.h
@@ -38,21 +38,23 @@
 #define OID_PKCS9_EMAIL                         "1.2.840.113549.1.9.1"
 
 int MHD__gnutls_x509_parse_dn (ASN1_TYPE MHD__asn1_struct,
-                           const char *MHD__asn1_rdn_name, char *buf,
-                           size_t * sizeof_buf);
+                               const char *MHD__asn1_rdn_name, char *buf,
+                               size_t * sizeof_buf);
 
 int MHD__gnutls_x509_parse_dn_oid (ASN1_TYPE MHD__asn1_struct,
-                               const char *MHD__asn1_rdn_name, const char *oid,
-                               int indx, unsigned int raw_flag, void *buf,
-                               size_t * sizeof_buf);
+                                   const char *MHD__asn1_rdn_name,
+                                   const char *oid, int indx,
+                                   unsigned int raw_flag, void *buf,
+                                   size_t * sizeof_buf);
 
 int MHD__gnutls_x509_set_dn_oid (ASN1_TYPE MHD__asn1_struct,
-                             const char *MHD__asn1_rdn_name, const char *oid,
-                             int raw_flag, const char *name, int sizeof_name);
+                                 const char *MHD__asn1_rdn_name,
+                                 const char *oid, int raw_flag,
+                                 const char *name, int sizeof_name);
 
 int MHD__gnutls_x509_get_dn_oid (ASN1_TYPE MHD__asn1_struct,
-                             const char *MHD__asn1_rdn_name,
-                             int indx, void *_oid, size_t * sizeof_oid);
+                                 const char *MHD__asn1_rdn_name,
+                                 int indx, void *_oid, size_t * sizeof_oid);
 
 
 #endif
diff --git a/src/daemon/https/x509/dsa.h b/src/daemon/https/x509/dsa.h
index bed87a7d..bda01f83 100644
--- a/src/daemon/https/x509/dsa.h
+++ b/src/daemon/https/x509/dsa.h
@@ -22,4 +22,5 @@
  *
  */
 
-int MHD__gnutls_dsa_generate_params (mpi_t * resarr, int *resarr_len, int bits);
+int MHD__gnutls_dsa_generate_params (mpi_t * resarr, int *resarr_len,
+                                     int bits);
diff --git a/src/daemon/https/x509/extensions.c b/src/daemon/https/x509/extensions.c
index 8bf36000..3b8bf494 100644
--- a/src/daemon/https/x509/extensions.c
+++ b/src/daemon/https/x509/extensions.c
@@ -46,8 +46,9 @@
  */
 int
 MHD__gnutls_x509_crt_get_extension (MHD_gnutls_x509_crt_t cert,
-                                const char *extension_id, int indx,
-                                MHD_gnutls_datum_t * ret, unsigned int *_critical)
+                                    const char *extension_id, int indx,
+                                    MHD_gnutls_datum_t * ret,
+                                    unsigned int *_critical)
 {
   int k, result, len;
   char name[MAX_NAME_SIZE], name2[MAX_NAME_SIZE];
@@ -136,7 +137,8 @@ MHD__gnutls_x509_crt_get_extension (MHD_gnutls_x509_crt_t cert,
               MHD_gtls_str_cpy (name2, sizeof (name2), name);
               MHD_gtls_str_cat (name2, sizeof (name2), ".extnValue");
 
-              result = MHD__gnutls_x509_read_value (cert->cert, name2, &value, 0);
+              result =
+                MHD__gnutls_x509_read_value (cert->cert, name2, &value, 0);
               if (result < 0)
                 {
                   MHD_gnutls_assert ();
@@ -177,7 +179,8 @@ MHD__gnutls_x509_crt_get_extension (MHD_gnutls_x509_crt_t cert,
  */
 int
 MHD__gnutls_x509_crt_get_extension_oid (MHD_gnutls_x509_crt_t cert,
-                                    int indx, void *oid, size_t * sizeof_oid)
+                                        int indx, void *oid,
+                                        size_t * sizeof_oid)
 {
   int k, result, len;
   char name[MAX_NAME_SIZE], name2[MAX_NAME_SIZE];
@@ -264,7 +267,7 @@ MHD__gnutls_x509_crt_get_extension_oid (MHD_gnutls_x509_crt_t cert,
  */
 int
 MHD__gnutls_x509_ext_extract_keyUsage (uint16_t * keyUsage,
-                                   opaque * extnValue, int extnValueLen)
+                                       opaque * extnValue, int extnValueLen)
 {
   ASN1_TYPE ext = ASN1_TYPE_EMPTY;
   int len, result;
@@ -309,16 +312,17 @@ MHD__gnutls_x509_ext_extract_keyUsage (uint16_t * keyUsage,
  */
 int
 MHD__gnutls_x509_ext_extract_basicConstraints (int *CA,
-                                           int *pathLenConstraint,
-                                           opaque * extnValue,
-                                           int extnValueLen)
+                                               int *pathLenConstraint,
+                                               opaque * extnValue,
+                                               int extnValueLen)
 {
   ASN1_TYPE ext = ASN1_TYPE_EMPTY;
   char str[128];
   int len, result;
 
   if ((result = MHD__asn1_create_element
-       (MHD__gnutls_get_pkix (), "PKIX1.BasicConstraints", &ext)) != ASN1_SUCCESS)
+       (MHD__gnutls_get_pkix (), "PKIX1.BasicConstraints",
+        &ext)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       return MHD_gtls_asn2err (result);
@@ -335,7 +339,8 @@ MHD__gnutls_x509_ext_extract_basicConstraints (int *CA,
   if (pathLenConstraint)
     {
       result = MHD__gnutls_x509_read_uint (ext, "pathLenConstraint",
-                                           (unsigned int*) pathLenConstraint);
+                                           (unsigned int *)
+                                           pathLenConstraint);
       if (result == GNUTLS_E_ASN1_ELEMENT_NOT_FOUND)
         *pathLenConstraint = -1;
       else if (result != GNUTLS_E_SUCCESS)
diff --git a/src/daemon/https/x509/extensions.h b/src/daemon/https/x509/extensions.h
index a124290e..fe4372f8 100644
--- a/src/daemon/https/x509/extensions.h
+++ b/src/daemon/https/x509/extensions.h
@@ -23,16 +23,17 @@
  */
 
 int MHD__gnutls_x509_crt_get_extension (MHD_gnutls_x509_crt_t cert,
-                                    const char *extension_id, int indx,
-                                    MHD_gnutls_datum_t * ret,
-                                    unsigned int *critical);
+                                        const char *extension_id, int indx,
+                                        MHD_gnutls_datum_t * ret,
+                                        unsigned int *critical);
 
 int MHD__gnutls_x509_crt_get_extension_oid (MHD_gnutls_x509_crt_t cert,
-                                        int indx, void *ret,
-                                        size_t * ret_size);
+                                            int indx, void *ret,
+                                            size_t * ret_size);
 int MHD__gnutls_x509_ext_extract_keyUsage (uint16_t * keyUsage,
-                                       opaque * extnValue, int extnValueLen);
+                                           opaque * extnValue,
+                                           int extnValueLen);
 int MHD__gnutls_x509_ext_extract_basicConstraints (int *CA,
-                                               int *pathLenConstraint,
-                                               opaque * extnValue,
-                                               int extnValueLen);
+                                                   int *pathLenConstraint,
+                                                   opaque * extnValue,
+                                                   int extnValueLen);
diff --git a/src/daemon/https/x509/mpi.c b/src/daemon/https/x509/mpi.c
index 4e3c8cd1..76995fdb 100644
--- a/src/daemon/https/x509/mpi.c
+++ b/src/daemon/https/x509/mpi.c
@@ -44,8 +44,9 @@ MHD__gnutls_x509_read_rsa_params (opaque * der, int dersize, mpi_t * params)
   ASN1_TYPE spk = ASN1_TYPE_EMPTY;
 
   if ((result =
-       MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (), "GNUTLS.RSAPublicKey",
-                            &spk)) != ASN1_SUCCESS)
+       MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (),
+                                 "GNUTLS.RSAPublicKey",
+                                 &spk)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       return MHD_gtls_asn2err (result);
@@ -94,7 +95,7 @@ MHD__gnutls_x509_read_dsa_params (opaque * der, int dersize, mpi_t * params)
 
   if ((result =
        MHD__asn1_create_element (MHD__gnutls_get_pkix (), "PKIX1.Dss-Parms",
-                            &spk)) != ASN1_SUCCESS)
+                                 &spk)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       return MHD_gtls_asn2err (result);
@@ -161,8 +162,9 @@ MHD__gnutls_x509_read_der_int (opaque * der, int dersize, mpi_t * out)
 
   /* == INTEGER */
   if ((result =
-       MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (), "GNUTLS.DSAPublicKey",
-                            &spk)) != ASN1_SUCCESS)
+       MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (),
+                                 "GNUTLS.DSAPublicKey",
+                                 &spk)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       return MHD_gtls_asn2err (result);
@@ -206,7 +208,7 @@ MHD__gnutls_x509_read_dsa_pubkey (opaque * der, int dersize, mpi_t * params)
  */
 int
 MHD__gnutls_x509_crt_get_mpis (MHD_gnutls_x509_crt_t cert,
-                           mpi_t * params, int *params_size)
+                               mpi_t * params, int *params_size)
 {
   int result;
   int pk_algorithm;
@@ -220,8 +222,8 @@ MHD__gnutls_x509_crt_get_mpis (MHD_gnutls_x509_crt_t cert,
    */
   result
     = MHD__gnutls_x509_read_value (cert->cert,
-                               "tbsCertificate.subjectPublicKeyInfo.subjectPublicKey",
-                               &tmp, 2);
+                                   "tbsCertificate.subjectPublicKeyInfo.subjectPublicKey",
+                                   &tmp, 2);
 
   if (result < 0)
     {
@@ -276,7 +278,7 @@ error:MHD__gnutls_free_datum (&tmp);
  */
 int
 MHD__gnutls_x509_write_rsa_params (mpi_t * params,
-                               int params_size, MHD_gnutls_datum_t * der)
+                                   int params_size, MHD_gnutls_datum_t * der)
 {
   int result;
   ASN1_TYPE spk = ASN1_TYPE_EMPTY;
@@ -292,8 +294,9 @@ MHD__gnutls_x509_write_rsa_params (mpi_t * params,
     }
 
   if ((result =
-       MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (), "GNUTLS.RSAPublicKey",
-                            &spk)) != ASN1_SUCCESS)
+       MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (),
+                                 "GNUTLS.RSAPublicKey",
+                                 &spk)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       return MHD_gtls_asn2err (result);
@@ -334,11 +337,11 @@ cleanup:MHD__asn1_delete_structure (&spk);
  */
 int
 MHD__gnutls_x509_write_sig_params (ASN1_TYPE dst,
-                               const char *dst_name,
-                               enum MHD_GNUTLS_PublicKeyAlgorithm
-                               pk_algorithm,
-                               enum MHD_GNUTLS_HashAlgorithm dig,
-                               mpi_t * params, int params_size)
+                                   const char *dst_name,
+                                   enum MHD_GNUTLS_PublicKeyAlgorithm
+                                   pk_algorithm,
+                                   enum MHD_GNUTLS_HashAlgorithm dig,
+                                   mpi_t * params, int params_size)
 {
   int result;
   char name[128];
@@ -391,7 +394,7 @@ MHD__gnutls_x509_write_sig_params (ASN1_TYPE dst,
  */
 int
 MHD__gnutls_x509_write_dsa_params (mpi_t * params,
-                               int params_size, MHD_gnutls_datum_t * der)
+                                   int params_size, MHD_gnutls_datum_t * der)
 {
   int result;
   ASN1_TYPE spk = ASN1_TYPE_EMPTY;
@@ -407,8 +410,9 @@ MHD__gnutls_x509_write_dsa_params (mpi_t * params,
     }
 
   if ((result =
-       MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (), "GNUTLS.DSAParameters",
-                            &spk)) != ASN1_SUCCESS)
+       MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (),
+                                 "GNUTLS.DSAParameters",
+                                 &spk)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       return MHD_gtls_asn2err (result);
@@ -456,7 +460,8 @@ cleanup:MHD__asn1_delete_structure (&spk);
  */
 int
 MHD__gnutls_x509_write_dsa_public_key (mpi_t * params,
-                                   int params_size, MHD_gnutls_datum_t * der)
+                                       int params_size,
+                                       MHD_gnutls_datum_t * der)
 {
   int result;
   ASN1_TYPE spk = ASN1_TYPE_EMPTY;
@@ -472,8 +477,9 @@ MHD__gnutls_x509_write_dsa_public_key (mpi_t * params,
     }
 
   if ((result =
-       MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (), "GNUTLS.DSAPublicKey",
-                            &spk)) != ASN1_SUCCESS)
+       MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (),
+                                 "GNUTLS.DSAPublicKey",
+                                 &spk)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       return MHD_gtls_asn2err (result);
@@ -505,7 +511,8 @@ cleanup:MHD__asn1_delete_structure (&spk);
  * steps.
  */
 int
-MHD__gnutls_x509_read_uint (ASN1_TYPE node, const char *value, unsigned int *ret)
+MHD__gnutls_x509_read_uint (ASN1_TYPE node, const char *value,
+                            unsigned int *ret)
 {
   int len, result;
   opaque *tmpstr;
@@ -557,7 +564,8 @@ MHD__gnutls_x509_read_uint (ASN1_TYPE node, const char *value, unsigned int *ret
 /* Writes the specified integer into the specified node.
  */
 int
-MHD__gnutls_x509_write_uint32 (ASN1_TYPE node, const char *value, uint32_t num)
+MHD__gnutls_x509_write_uint32 (ASN1_TYPE node, const char *value,
+                               uint32_t num)
 {
   opaque tmpstr[4];
   int result;
diff --git a/src/daemon/https/x509/mpi.h b/src/daemon/https/x509/mpi.h
index 6c4534b4..edac2eee 100644
--- a/src/daemon/https/x509/mpi.h
+++ b/src/daemon/https/x509/mpi.h
@@ -26,32 +26,35 @@
 #include "x509.h"
 
 int MHD__gnutls_x509_crt_get_mpis (MHD_gnutls_x509_crt_t cert,
-                               mpi_t * params, int *params_size);
-int MHD__gnutls_x509_read_rsa_params (opaque * der, int dersize, mpi_t * params);
-int MHD__gnutls_x509_read_dsa_pubkey (opaque * der, int dersize, mpi_t * params);
-int MHD__gnutls_x509_read_dsa_params (opaque * der, int dersize, mpi_t * params);
+                                   mpi_t * params, int *params_size);
+int MHD__gnutls_x509_read_rsa_params (opaque * der, int dersize,
+                                      mpi_t * params);
+int MHD__gnutls_x509_read_dsa_pubkey (opaque * der, int dersize,
+                                      mpi_t * params);
+int MHD__gnutls_x509_read_dsa_params (opaque * der, int dersize,
+                                      mpi_t * params);
 
 int MHD__gnutls_x509_write_rsa_params (mpi_t * params, int params_size,
-                                   MHD_gnutls_datum_t * der);
+                                       MHD_gnutls_datum_t * der);
 int MHD__gnutls_x509_write_dsa_params (mpi_t * params, int params_size,
-                                   MHD_gnutls_datum_t * der);
-int MHD__gnutls_x509_write_dsa_public_key (mpi_t * params, int params_size,
                                        MHD_gnutls_datum_t * der);
+int MHD__gnutls_x509_write_dsa_public_key (mpi_t * params, int params_size,
+                                           MHD_gnutls_datum_t * der);
 
 int MHD__gnutls_x509_read_uint (ASN1_TYPE node, const char *value,
-                            unsigned int *ret);
+                                unsigned int *ret);
 
 int MHD__gnutls_x509_read_der_int (opaque * der, int dersize, mpi_t * out);
 
 int MHD__gnutls_x509_read_int (ASN1_TYPE node, const char *value,
-                           mpi_t * ret_mpi);
+                               mpi_t * ret_mpi);
 int MHD__gnutls_x509_write_int (ASN1_TYPE node, const char *value, mpi_t mpi,
-                            int lz);
+                                int lz);
 int MHD__gnutls_x509_write_uint32 (ASN1_TYPE node, const char *value,
-                               uint32_t num);
+                                   uint32_t num);
 
 int MHD__gnutls_x509_write_sig_params (ASN1_TYPE dst, const char *dst_name,
-                                   enum MHD_GNUTLS_PublicKeyAlgorithm
-                                   pk_algorithm,
-                                   enum MHD_GNUTLS_HashAlgorithm,
-                                   mpi_t * params, int params_size);
+                                       enum MHD_GNUTLS_PublicKeyAlgorithm
+                                       pk_algorithm,
+                                       enum MHD_GNUTLS_HashAlgorithm,
+                                       mpi_t * params, int params_size);
diff --git a/src/daemon/https/x509/pkcs12.h b/src/daemon/https/x509/pkcs12.h
index a9738b94..74d4d06b 100644
--- a/src/daemon/https/x509/pkcs12.h
+++ b/src/daemon/https/x509/pkcs12.h
@@ -81,37 +81,40 @@ extern "C"
   int MHD_gnutls_pkcs12_init (MHD_gnutls_pkcs12_t * pkcs12);
   void MHD_gnutls_pkcs12_deinit (MHD_gnutls_pkcs12_t pkcs12);
   int MHD_gnutls_pkcs12_import (MHD_gnutls_pkcs12_t pkcs12,
-                            const MHD_gnutls_datum_t * data,
-                            MHD_gnutls_x509_crt_fmt_t format, unsigned int flags);
+                                const MHD_gnutls_datum_t * data,
+                                MHD_gnutls_x509_crt_fmt_t format,
+                                unsigned int flags);
   int MHD_gnutls_pkcs12_export (MHD_gnutls_pkcs12_t pkcs12,
-                            MHD_gnutls_x509_crt_fmt_t format,
-                            void *output_data, size_t * output_data_size);
+                                MHD_gnutls_x509_crt_fmt_t format,
+                                void *output_data, size_t * output_data_size);
 
-  int MHD_gnutls_pkcs12_bag_decrypt (MHD_gnutls_pkcs12_bag_t bag, const char *pass);
+  int MHD_gnutls_pkcs12_bag_decrypt (MHD_gnutls_pkcs12_bag_t bag,
+                                     const char *pass);
   int MHD_gnutls_pkcs12_bag_encrypt (MHD_gnutls_pkcs12_bag_t bag,
-                                 const char *pass, unsigned int flags);
+                                     const char *pass, unsigned int flags);
 
   int MHD_gnutls_pkcs12_bag_get_data (MHD_gnutls_pkcs12_bag_t bag,
-                                  int indx, MHD_gnutls_datum_t * data);
+                                      int indx, MHD_gnutls_datum_t * data);
   int MHD_gnutls_pkcs12_bag_set_data (MHD_gnutls_pkcs12_bag_t bag,
-                                  MHD_gnutls_pkcs12_bag_type_t type,
-                                  const MHD_gnutls_datum_t * data);
+                                      MHD_gnutls_pkcs12_bag_type_t type,
+                                      const MHD_gnutls_datum_t * data);
   int MHD_gnutls_pkcs12_bag_set_crl (MHD_gnutls_pkcs12_bag_t bag,
-                                 MHD_gnutls_x509_crl_t crl);
+                                     MHD_gnutls_x509_crl_t crl);
   int MHD_gnutls_pkcs12_bag_set_crt (MHD_gnutls_pkcs12_bag_t bag,
-                                 MHD_gnutls_x509_crt_t crt);
+                                     MHD_gnutls_x509_crt_t crt);
 
   int MHD_gnutls_pkcs12_bag_get_count (MHD_gnutls_pkcs12_bag_t bag);
 
   int MHD_gnutls_pkcs12_bag_get_key_id (MHD_gnutls_pkcs12_bag_t bag,
-                                    int indx, MHD_gnutls_datum_t * id);
+                                        int indx, MHD_gnutls_datum_t * id);
   int MHD_gnutls_pkcs12_bag_set_key_id (MHD_gnutls_pkcs12_bag_t bag,
-                                    int indx, const MHD_gnutls_datum_t * id);
+                                        int indx,
+                                        const MHD_gnutls_datum_t * id);
 
   int MHD_gnutls_pkcs12_bag_get_friendly_name (MHD_gnutls_pkcs12_bag_t bag,
-                                           int indx, char **name);
+                                               int indx, char **name);
   int MHD_gnutls_pkcs12_bag_set_friendly_name (MHD_gnutls_pkcs12_bag_t bag,
-                                           int indx, const char *name);
+                                               int indx, const char *name);
 
 #ifdef __cplusplus
 }
@@ -136,10 +139,10 @@ typedef enum schema_id
 } schema_id;
 
 int MHD_pkcs12_string_to_key (unsigned int id,
-                           const opaque * salt,
-                           unsigned int salt_size,
-                           unsigned int iter,
-                           const char *pw,
-                           unsigned int req_keylen, opaque * keybuf);
+                              const opaque * salt,
+                              unsigned int salt_size,
+                              unsigned int iter,
+                              const char *pw,
+                              unsigned int req_keylen, opaque * keybuf);
 
 #endif /* GNUTLS_PKCS12_H */
diff --git a/src/daemon/https/x509/pkcs12_encr.c b/src/daemon/https/x509/pkcs12_encr.c
index 0cfb59e5..e534489c 100644
--- a/src/daemon/https/x509/pkcs12_encr.c
+++ b/src/daemon/https/x509/pkcs12_encr.c
@@ -55,9 +55,9 @@ MHD_pkcs12_check_pass (const char *pass, size_t plen)
  */
 int
 MHD_pkcs12_string_to_key (unsigned int id, const opaque * salt,
-                       unsigned int salt_size, unsigned int iter,
-                       const char *pw, unsigned int req_keylen,
-                       opaque * keybuf)
+                          unsigned int salt_size, unsigned int iter,
+                          const char *pw, unsigned int req_keylen,
+                          opaque * keybuf)
 {
   int rc;
   unsigned int i, j;
@@ -115,13 +115,13 @@ MHD_pkcs12_string_to_key (unsigned int id, const opaque * salt,
       for (i = 0; i < 64; i++)
         {
           unsigned char lid = id & 0xFF;
-          MHD_gc_hash_write (md, 1, (const char*) &lid);
+          MHD_gc_hash_write (md, 1, (const char *) &lid);
         }
-      MHD_gc_hash_write (md, pw ? 128 : 64, (const char*) buf_i);
+      MHD_gc_hash_write (md, pw ? 128 : 64, (const char *) buf_i);
       memcpy (hash, MHD_gc_hash_read (md), 20);
       MHD_gc_hash_close (md);
       for (i = 1; i < iter; i++)
-        MHD_gc_hash_buffer (GC_SHA1, hash, 20, (char*) hash);
+        MHD_gc_hash_buffer (GC_SHA1, hash, 20, (char *) hash);
       for (i = 0; i < 20 && cur_keylen < req_keylen; i++)
         keybuf[cur_keylen++] = hash[i];
       if (cur_keylen == req_keylen)
diff --git a/src/daemon/https/x509/pkcs7.c b/src/daemon/https/x509/pkcs7.c
index 8b0b6b54..45f2b03c 100644
--- a/src/daemon/https/x509/pkcs7.c
+++ b/src/daemon/https/x509/pkcs7.c
@@ -69,7 +69,8 @@ _decode_pkcs7_signed_data (ASN1_TYPE pkcs7, ASN1_TYPE * sdata,
     }
 
   if ((result = MHD__asn1_create_element
-       (MHD__gnutls_get_pkix (), "PKIX1.pkcs-7-SignedData", &c2)) != ASN1_SUCCESS)
+       (MHD__gnutls_get_pkix (), "PKIX1.pkcs-7-SignedData",
+        &c2)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       return MHD_gtls_asn2err (result);
@@ -158,8 +159,8 @@ MHD_gnutls_pkcs7_init (MHD_gnutls_pkcs7_t * pkcs7)
   if (*pkcs7)
     {
       int result = MHD__asn1_create_element (MHD__gnutls_get_pkix (),
-                                        "PKIX1.pkcs-7-ContentInfo",
-                                        &(*pkcs7)->pkcs7);
+                                             "PKIX1.pkcs-7-ContentInfo",
+                                             &(*pkcs7)->pkcs7);
       if (result != ASN1_SUCCESS)
         {
           MHD_gnutls_assert ();
@@ -205,8 +206,9 @@ MHD_gnutls_pkcs7_deinit (MHD_gnutls_pkcs7_t pkcs7)
   *
   **/
 int
-MHD_gnutls_pkcs7_import (MHD_gnutls_pkcs7_t pkcs7, const MHD_gnutls_datum_t * data,
-                     MHD_gnutls_x509_crt_fmt_t format)
+MHD_gnutls_pkcs7_import (MHD_gnutls_pkcs7_t pkcs7,
+                         const MHD_gnutls_datum_t * data,
+                         MHD_gnutls_x509_crt_fmt_t format)
 {
   int result = 0, need_free = 0;
   MHD_gnutls_datum_t _data;
@@ -224,7 +226,7 @@ MHD_gnutls_pkcs7_import (MHD_gnutls_pkcs7_t pkcs7, const MHD_gnutls_datum_t * da
       opaque *out;
 
       result = MHD__gnutls_fbase64_decode (PEM_PKCS7, data->data, data->size,
-                                       &out);
+                                           &out);
 
       if (result <= 0)
         {
@@ -241,7 +243,8 @@ MHD_gnutls_pkcs7_import (MHD_gnutls_pkcs7_t pkcs7, const MHD_gnutls_datum_t * da
     }
 
 
-  result = MHD__asn1_der_decoding (&pkcs7->pkcs7, _data.data, _data.size, NULL);
+  result =
+    MHD__asn1_der_decoding (&pkcs7->pkcs7, _data.data, _data.size, NULL);
   if (result != ASN1_SUCCESS)
     {
       result = MHD_gtls_asn2err (result);
@@ -277,8 +280,8 @@ cleanup:
   **/
 int
 MHD_gnutls_pkcs7_get_crt_raw (MHD_gnutls_pkcs7_t pkcs7,
-                          int indx, void *certificate,
-                          size_t * certificate_size)
+                              int indx, void *certificate,
+                              size_t * certificate_size)
 {
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
   int result, len;
@@ -327,7 +330,7 @@ MHD_gnutls_pkcs7_get_crt_raw (MHD_gnutls_pkcs7_t pkcs7,
       int start, end;
 
       result = MHD__asn1_der_decoding_startEnd (c2, tmp.data, tmp.size,
-                                           root2, &start, &end);
+                                                root2, &start, &end);
 
       if (result != ASN1_SUCCESS)
         {
@@ -432,14 +435,14 @@ MHD_gnutls_pkcs7_get_crt_count (MHD_gnutls_pkcs7_t pkcs7)
   **/
 int
 MHD_gnutls_pkcs7_export (MHD_gnutls_pkcs7_t pkcs7,
-                     MHD_gnutls_x509_crt_fmt_t format, void *output_data,
-                     size_t * output_data_size)
+                         MHD_gnutls_x509_crt_fmt_t format, void *output_data,
+                         size_t * output_data_size)
 {
   if (pkcs7 == NULL)
     return GNUTLS_E_INVALID_REQUEST;
 
   return MHD__gnutls_x509_export_int (pkcs7->pkcs7, format, PEM_PKCS7,
-                                  output_data, output_data_size);
+                                      output_data, output_data_size);
 }
 
 /* Creates an empty signed data structure in the pkcs7
@@ -478,7 +481,7 @@ create_empty_signed_data (ASN1_TYPE pkcs7, ASN1_TYPE * sdata)
   /* id-data */
   result =
     MHD__asn1_write_value (*sdata, "encapContentInfo.eContentType",
-                      "1.2.840.113549.1.7.5", 1);
+                           "1.2.840.113549.1.7.5", 1);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -486,7 +489,8 @@ create_empty_signed_data (ASN1_TYPE pkcs7, ASN1_TYPE * sdata)
       goto cleanup;
     }
 
-  result = MHD__asn1_write_value (*sdata, "encapContentInfo.eContent", NULL, 0);
+  result =
+    MHD__asn1_write_value (*sdata, "encapContentInfo.eContent", NULL, 0);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -531,7 +535,8 @@ cleanup:
   *
   **/
 int
-MHD_gnutls_pkcs7_set_crt_raw (MHD_gnutls_pkcs7_t pkcs7, const MHD_gnutls_datum_t * crt)
+MHD_gnutls_pkcs7_set_crt_raw (MHD_gnutls_pkcs7_t pkcs7,
+                              const MHD_gnutls_datum_t * crt)
 {
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
   int result;
@@ -585,7 +590,7 @@ MHD_gnutls_pkcs7_set_crt_raw (MHD_gnutls_pkcs7_t pkcs7, const MHD_gnutls_datum_t
 
   result =
     MHD__asn1_write_value (c2, "certificates.?LAST.certificate", crt->data,
-                      crt->size);
+                           crt->size);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -735,7 +740,7 @@ cleanup:
   **/
 int
 MHD_gnutls_pkcs7_get_crl_raw (MHD_gnutls_pkcs7_t pkcs7,
-                          int indx, void *crl, size_t * crl_size)
+                              int indx, void *crl, size_t * crl_size)
 {
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
   int result;
@@ -763,7 +768,7 @@ MHD_gnutls_pkcs7_get_crl_raw (MHD_gnutls_pkcs7_t pkcs7,
   /* Get the raw CRL
    */
   result = MHD__asn1_der_decoding_startEnd (c2, tmp.data, tmp.size,
-                                       root2, &start, &end);
+                                            root2, &start, &end);
 
   if (result != ASN1_SUCCESS)
     {
@@ -849,7 +854,8 @@ MHD_gnutls_pkcs7_get_crl_count (MHD_gnutls_pkcs7_t pkcs7)
   *
   **/
 int
-MHD_gnutls_pkcs7_set_crl_raw (MHD_gnutls_pkcs7_t pkcs7, const MHD_gnutls_datum_t * crl)
+MHD_gnutls_pkcs7_set_crl_raw (MHD_gnutls_pkcs7_t pkcs7,
+                              const MHD_gnutls_datum_t * crl)
 {
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
   int result;
diff --git a/src/daemon/https/x509/privkey.h b/src/daemon/https/x509/privkey.h
index 31fc2d72..37c68703 100644
--- a/src/daemon/https/x509/privkey.h
+++ b/src/daemon/https/x509/privkey.h
@@ -25,7 +25,8 @@
 #include "x509.h"
 
 ASN1_TYPE MHD__gnutls_privkey_decode_pkcs1_rsa_key (const MHD_gnutls_datum_t *
-                                                raw_key,
-                                                MHD_gnutls_x509_privkey_t pkey);
+                                                    raw_key,
+                                                    MHD_gnutls_x509_privkey_t
+                                                    pkey);
 
 int MHD__gnutls_asn1_encode_dsa (ASN1_TYPE * c2, mpi_t * params);
diff --git a/src/daemon/https/x509/privkey_pkcs8.c b/src/daemon/https/x509/privkey_pkcs8.c
index 741552e1..30f2caae 100644
--- a/src/daemon/https/x509/privkey_pkcs8.c
+++ b/src/daemon/https/x509/privkey_pkcs8.c
@@ -82,7 +82,7 @@ static int decrypt_data (schema_id, ASN1_TYPE pkcs8_asn, const char *root,
 static int decode_private_key_info (const MHD_gnutls_datum_t * der,
                                     MHD_gnutls_x509_privkey_t pkey);
 static int readMHD_pkcs12_kdf_params (ASN1_TYPE pbes2_asn,
-                                   struct pbkdf2_params *params);
+                                      struct pbkdf2_params *params);
 
 #define PEM_PKCS8 "ENCRYPTED PRIVATE KEY"
 #define PEM_UNENCRYPTED_PKCS8 "PRIVATE KEY"
@@ -106,7 +106,8 @@ check_schema (const char *oid)
   if (strcmp (oid, PKCS12_PBE_RC2_40_SHA1_OID) == 0)
     return PKCS12_RC2_40_SHA1;
 
-  MHD__gnutls_x509_log ("PKCS encryption schema OID '%s' is unsupported.\n", oid);
+  MHD__gnutls_x509_log ("PKCS encryption schema OID '%s' is unsupported.\n",
+                        oid);
 
   return GNUTLS_E_UNKNOWN_CIPHER_TYPE;
 }
@@ -134,8 +135,8 @@ read_pkcs_schema_params (schema_id schema, const char *password,
        */
       if ((result =
            MHD__asn1_create_element (MHD__gnutls_get_pkix (),
-                                "PKIX1.pkcs-5-PBES2-params",
-                                &pbes2_asn)) != ASN1_SUCCESS)
+                                     "PKIX1.pkcs-5-PBES2-params",
+                                     &pbes2_asn)) != ASN1_SUCCESS)
         {
           MHD_gnutls_assert ();
           result = MHD_gtls_asn2err (result);
@@ -197,8 +198,8 @@ read_pkcs_schema_params (schema_id schema, const char *password,
 
       if ((result =
            MHD__asn1_create_element (MHD__gnutls_get_pkix (),
-                                "PKIX1.pkcs-12-PbeParams",
-                                &pbes2_asn)) != ASN1_SUCCESS)
+                                     "PKIX1.pkcs-12-PbeParams",
+                                     &pbes2_asn)) != ASN1_SUCCESS)
         {
           MHD_gnutls_assert ();
           result = MHD_gtls_asn2err (result);
@@ -226,9 +227,9 @@ read_pkcs_schema_params (schema_id schema, const char *password,
         {
           result =
             MHD_pkcs12_string_to_key (2 /*IV*/, kdf_params->salt,
-                                   kdf_params->salt_size,
-                                   kdf_params->iter_count, password,
-                                   enc_params->iv_size, enc_params->iv);
+                                      kdf_params->salt_size,
+                                      kdf_params->iter_count, password,
+                                      enc_params->iv_size, enc_params->iv);
           if (result < 0)
             {
               MHD_gnutls_assert ();
@@ -270,15 +271,16 @@ decode_pkcs8_key (const MHD_gnutls_datum_t * raw_key,
 
   if ((result =
        MHD__asn1_create_element (MHD__gnutls_get_pkix (),
-                            "PKIX1.pkcs-8-EncryptedPrivateKeyInfo",
-                            &pkcs8_asn)) != ASN1_SUCCESS)
+                                 "PKIX1.pkcs-8-EncryptedPrivateKeyInfo",
+                                 &pkcs8_asn)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       result = MHD_gtls_asn2err (result);
       goto error;
     }
 
-  result = MHD__asn1_der_decoding (&pkcs8_asn, raw_key->data, raw_key->size, NULL);
+  result =
+    MHD__asn1_der_decoding (&pkcs8_asn, raw_key->data, raw_key->size, NULL);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -291,7 +293,7 @@ decode_pkcs8_key (const MHD_gnutls_datum_t * raw_key,
   len = sizeof (enc_oid);
   result =
     MHD__asn1_read_value (pkcs8_asn, "encryptionAlgorithm.algorithm",
-                     enc_oid, &len);
+                          enc_oid, &len);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -310,9 +312,9 @@ decode_pkcs8_key (const MHD_gnutls_datum_t * raw_key,
    */
   result =
     MHD__asn1_der_decoding_startEnd (pkcs8_asn, raw_key->data,
-                                raw_key->size,
-                                "encryptionAlgorithm.parameters",
-                                &params_start, &params_end);
+                                     raw_key->size,
+                                     "encryptionAlgorithm.parameters",
+                                     &params_start, &params_end);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -416,8 +418,8 @@ decode_private_key_info (const MHD_gnutls_datum_t * der,
 
   if ((result =
        MHD__asn1_create_element (MHD__gnutls_get_pkix (),
-                            "PKIX1.pkcs-8-PrivateKeyInfo",
-                            &pkcs8_asn)) != ASN1_SUCCESS)
+                                 "PKIX1.pkcs-8-PrivateKeyInfo",
+                                 &pkcs8_asn)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       result = MHD_gtls_asn2err (result);
@@ -436,7 +438,8 @@ decode_private_key_info (const MHD_gnutls_datum_t * der,
    */
   len = sizeof (oid);
   result =
-    MHD__asn1_read_value (pkcs8_asn, "privateKeyAlgorithm.algorithm", oid, &len);
+    MHD__asn1_read_value (pkcs8_asn, "privateKeyAlgorithm.algorithm", oid,
+                          &len);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -446,7 +449,7 @@ decode_private_key_info (const MHD_gnutls_datum_t * der,
 
   /* we only support RSA and DSA private keys.
    */
-  if (strcmp ((const char*) oid, PK_PKIX1_RSA_OID) == 0)
+  if (strcmp ((const char *) oid, PK_PKIX1_RSA_OID) == 0)
     pkey->pk_algorithm = MHD_GNUTLS_PK_RSA;
   else
     {
@@ -502,9 +505,10 @@ error:
  **/
 int
 MHD_gnutls_x509_privkey_import_pkcs8 (MHD_gnutls_x509_privkey_t key,
-                                  const MHD_gnutls_datum_t * data,
-                                  MHD_gnutls_x509_crt_fmt_t format,
-                                  const char *password, unsigned int flags)
+                                      const MHD_gnutls_datum_t * data,
+                                      MHD_gnutls_x509_crt_fmt_t format,
+                                      const char *password,
+                                      unsigned int flags)
 {
   int result = 0, need_free = 0;
   MHD_gnutls_datum_t _data;
@@ -530,13 +534,14 @@ MHD_gnutls_x509_privkey_import_pkcs8 (MHD_gnutls_x509_privkey_t key,
        */
       result =
         MHD__gnutls_fbase64_decode (PEM_UNENCRYPTED_PKCS8,
-                                data->data, data->size, &out);
+                                    data->data, data->size, &out);
 
       if (result < 0)
         {                       /* Try the encrypted header
                                  */
           result =
-            MHD__gnutls_fbase64_decode (PEM_PKCS8, data->data, data->size, &out);
+            MHD__gnutls_fbase64_decode (PEM_PKCS8, data->data, data->size,
+                                        &out);
 
           if (result <= 0)
             {
@@ -589,7 +594,8 @@ cleanup:
  */
 static int
 read_pbkdf2_params (ASN1_TYPE pbes2_asn,
-                    const MHD_gnutls_datum_t * der, struct pbkdf2_params *params)
+                    const MHD_gnutls_datum_t * der,
+                    struct pbkdf2_params *params)
 {
   int params_start, params_end;
   int params_len, len, result;
@@ -602,7 +608,8 @@ read_pbkdf2_params (ASN1_TYPE pbes2_asn,
    */
   len = sizeof (oid);
   result =
-    MHD__asn1_read_value (pbes2_asn, "keyDerivationFunc.algorithm", oid, &len);
+    MHD__asn1_read_value (pbes2_asn, "keyDerivationFunc.algorithm", oid,
+                          &len);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -620,8 +627,8 @@ read_pbkdf2_params (ASN1_TYPE pbes2_asn,
 
   result =
     MHD__asn1_der_decoding_startEnd (pbes2_asn, der->data, der->size,
-                                "keyDerivationFunc.parameters",
-                                &params_start, &params_end);
+                                     "keyDerivationFunc.parameters",
+                                     &params_start, &params_end);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -634,8 +641,8 @@ read_pbkdf2_params (ASN1_TYPE pbes2_asn,
    */
   if ((result =
        MHD__asn1_create_element (MHD__gnutls_get_pkix (),
-                            "PKIX1.pkcs-5-PBKDF2-params",
-                            &pbkdf2_asn)) != ASN1_SUCCESS)
+                                 "PKIX1.pkcs-5-PBKDF2-params",
+                                 &pbkdf2_asn)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       return MHD_gtls_asn2err (result);
@@ -643,7 +650,7 @@ read_pbkdf2_params (ASN1_TYPE pbes2_asn,
 
   result =
     MHD__asn1_der_decoding (&pbkdf2_asn, &der->data[params_start],
-                       params_len, NULL);
+                            params_len, NULL);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -655,7 +662,7 @@ read_pbkdf2_params (ASN1_TYPE pbes2_asn,
   params->salt_size = sizeof (params->salt);
   result =
     MHD__asn1_read_value (pbkdf2_asn, "salt.specified", params->salt,
-                     &params->salt_size);
+                          &params->salt_size);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -668,7 +675,7 @@ read_pbkdf2_params (ASN1_TYPE pbes2_asn,
    */
   result =
     MHD__gnutls_x509_read_uint (pbkdf2_asn, "iterationCount",
-                            &params->iter_count);
+                                &params->iter_count);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -709,7 +716,8 @@ readMHD_pkcs12_kdf_params (ASN1_TYPE pbes2_asn, struct pbkdf2_params *params)
   /* read the salt */
   params->salt_size = sizeof (params->salt);
   result =
-    MHD__asn1_read_value (pbes2_asn, "salt", params->salt, &params->salt_size);
+    MHD__asn1_read_value (pbes2_asn, "salt", params->salt,
+                          &params->salt_size);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -794,8 +802,8 @@ read_pbe_enc_params (ASN1_TYPE pbes2_asn,
 
   result =
     MHD__asn1_der_decoding_startEnd (pbes2_asn, der->data, der->size,
-                                "encryptionScheme.parameters",
-                                &params_start, &params_end);
+                                     "encryptionScheme.parameters",
+                                     &params_start, &params_end);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -807,15 +815,16 @@ read_pbe_enc_params (ASN1_TYPE pbes2_asn,
    */
   if ((result =
        MHD__asn1_create_element (MHD__gnutls_get_pkix (),
-                            "PKIX1.pkcs-5-des-EDE3-CBC-params",
-                            &pbe_asn)) != ASN1_SUCCESS)
+                                 "PKIX1.pkcs-5-des-EDE3-CBC-params",
+                                 &pbe_asn)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       return MHD_gtls_asn2err (result);
     }
 
   result =
-    MHD__asn1_der_decoding (&pbe_asn, &der->data[params_start], params_len, NULL);
+    MHD__asn1_der_decoding (&pbe_asn, &der->data[params_start], params_len,
+                            NULL);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -899,9 +908,10 @@ decrypt_data (schema_id schema, ASN1_TYPE pkcs8_asn,
   if (schema == PBES2)
     {
       result = MHD_gc_pbkdf2_sha1 (password, strlen (password),
-                                   (const char*) kdf_params->salt, kdf_params->salt_size,
-                                   kdf_params->iter_count,
-                                   (char*) key, key_size);
+                                   (const char *) kdf_params->salt,
+                                   kdf_params->salt_size,
+                                   kdf_params->iter_count, (char *) key,
+                                   key_size);
 
       if (result != GC_OK)
         {
@@ -914,9 +924,9 @@ decrypt_data (schema_id schema, ASN1_TYPE pkcs8_asn,
     {
       result =
         MHD_pkcs12_string_to_key (1 /*KEY*/, kdf_params->salt,
-                               kdf_params->salt_size,
-                               kdf_params->iter_count, password,
-                               key_size, key);
+                                  kdf_params->salt_size,
+                                  kdf_params->iter_count, password,
+                                  key_size, key);
 
       if (result < 0)
         {
diff --git a/src/daemon/https/x509/rfc2818_hostname.c b/src/daemon/https/x509/rfc2818_hostname.c
index fe03af33..be49a778 100644
--- a/src/daemon/https/x509/rfc2818_hostname.c
+++ b/src/daemon/https/x509/rfc2818_hostname.c
@@ -84,7 +84,8 @@ MHD__gnutls_hostname_compare (const char *certname, const char *hostname)
   * Returns non zero for a successful match, and zero on failure.
   **/
 int
-MHD_gnutls_x509_crt_check_hostname (MHD_gnutls_x509_crt_t cert, const char *hostname)
+MHD_gnutls_x509_crt_check_hostname (MHD_gnutls_x509_crt_t cert,
+                                    const char *hostname)
 {
 
   char dnsname[MAX_CN];
@@ -112,8 +113,8 @@ MHD_gnutls_x509_crt_check_hostname (MHD_gnutls_x509_crt_t cert, const char *host
 
       dnsnamesize = sizeof (dnsname);
       ret = MHD_gnutls_x509_crt_get_subject_alt_name (cert, i,
-                                                  dnsname, &dnsnamesize,
-                                                  NULL);
+                                                      dnsname, &dnsnamesize,
+                                                      NULL);
 
       if (ret == GNUTLS_SAN_DNSNAME)
         {
@@ -141,7 +142,7 @@ MHD_gnutls_x509_crt_check_hostname (MHD_gnutls_x509_crt_t cert, const char *host
        */
       dnsnamesize = sizeof (dnsname);
       if (MHD_gnutls_x509_crt_get_dn_by_oid (cert, OID_X520_COMMON_NAME, 0,
-                                         0, dnsname, &dnsnamesize) < 0)
+                                             0, dnsname, &dnsnamesize) < 0)
         {
           /* got an error, can't find a name
            */
diff --git a/src/daemon/https/x509/sign.c b/src/daemon/https/x509/sign.c
index eb3da891..1cc032be 100644
--- a/src/daemon/https/x509/sign.c
+++ b/src/daemon/https/x509/sign.c
@@ -50,7 +50,8 @@
  */
 static int
 encode_ber_digest_info (enum MHD_GNUTLS_HashAlgorithm hash,
-                        const MHD_gnutls_datum_t * digest, MHD_gnutls_datum_t * info)
+                        const MHD_gnutls_datum_t * digest,
+                        MHD_gnutls_datum_t * info)
 {
   ASN1_TYPE dinfo = ASN1_TYPE_EMPTY;
   int result;
@@ -65,14 +66,15 @@ encode_ber_digest_info (enum MHD_GNUTLS_HashAlgorithm hash,
     }
 
   if ((result = MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (),
-                                     "GNUTLS.DigestInfo",
-                                     &dinfo)) != ASN1_SUCCESS)
+                                          "GNUTLS.DigestInfo",
+                                          &dinfo)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       return MHD_gtls_asn2err (result);
     }
 
-  result = MHD__asn1_write_value (dinfo, "digestAlgorithm.algorithm", algo, 1);
+  result =
+    MHD__asn1_write_value (dinfo, "digestAlgorithm.algorithm", algo, 1);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -86,7 +88,7 @@ encode_ber_digest_info (enum MHD_GNUTLS_HashAlgorithm hash,
      Regardless of what is correct, this appears to be what most
      implementations do.  */
   result = MHD__asn1_write_value (dinfo, "digestAlgorithm.parameters",
-                             "\x05\x00", 2);
+                                  "\x05\x00", 2);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -94,7 +96,8 @@ encode_ber_digest_info (enum MHD_GNUTLS_HashAlgorithm hash,
       return MHD_gtls_asn2err (result);
     }
 
-  result = MHD__asn1_write_value (dinfo, "digest", digest->data, digest->size);
+  result =
+    MHD__asn1_write_value (dinfo, "digest", digest->data, digest->size);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -103,7 +106,7 @@ encode_ber_digest_info (enum MHD_GNUTLS_HashAlgorithm hash,
     }
 
   info->size = 0;
-  MHD__asn1_der_coding (dinfo, "", NULL, (int*) &info->size, NULL);
+  MHD__asn1_der_coding (dinfo, "", NULL, (int *) &info->size, NULL);
 
   info->data = MHD_gnutls_malloc (info->size);
   if (info->data == NULL)
@@ -113,7 +116,8 @@ encode_ber_digest_info (enum MHD_GNUTLS_HashAlgorithm hash,
       return GNUTLS_E_MEMORY_ERROR;
     }
 
-  result = MHD__asn1_der_coding (dinfo, "", info->data, (int*) &info->size, NULL);
+  result =
+    MHD__asn1_der_coding (dinfo, "", info->data, (int *) &info->size, NULL);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -133,8 +137,8 @@ encode_ber_digest_info (enum MHD_GNUTLS_HashAlgorithm hash,
  */
 static int
 pkcs1_rsa_sign (enum MHD_GNUTLS_HashAlgorithm hash,
-                const MHD_gnutls_datum_t * text, mpi_t * params, int params_len,
-                MHD_gnutls_datum_t * signature)
+                const MHD_gnutls_datum_t * text, mpi_t * params,
+                int params_len, MHD_gnutls_datum_t * signature)
 {
   int ret;
   opaque _digest[MAX_HASH_SIZE];
@@ -187,8 +191,9 @@ pkcs1_rsa_sign (enum MHD_GNUTLS_HashAlgorithm hash,
  */
 static int
 MHD__gnutls_x509_sign (const MHD_gnutls_datum_t * tbs,
-                   enum MHD_GNUTLS_HashAlgorithm hash,
-                   MHD_gnutls_x509_privkey_t signer, MHD_gnutls_datum_t * signature)
+                       enum MHD_GNUTLS_HashAlgorithm hash,
+                       MHD_gnutls_x509_privkey_t signer,
+                       MHD_gnutls_datum_t * signature)
 {
   int ret;
 
@@ -218,9 +223,9 @@ MHD__gnutls_x509_sign (const MHD_gnutls_datum_t * tbs,
  */
 int
 MHD__gnutls_x509_sign_tbs (ASN1_TYPE cert, const char *tbs_name,
-                       enum MHD_GNUTLS_HashAlgorithm hash,
-                       MHD_gnutls_x509_privkey_t signer,
-                       MHD_gnutls_datum_t * signature)
+                           enum MHD_GNUTLS_HashAlgorithm hash,
+                           MHD_gnutls_x509_privkey_t signer,
+                           MHD_gnutls_datum_t * signature)
 {
   int result;
   opaque *buf;
diff --git a/src/daemon/https/x509/sign.h b/src/daemon/https/x509/sign.h
index 03993157..51e51b92 100644
--- a/src/daemon/https/x509/sign.h
+++ b/src/daemon/https/x509/sign.h
@@ -23,6 +23,6 @@
  */
 
 int MHD__gnutls_x509_sign_tbs (ASN1_TYPE cert, const char *tbs_name,
-                           enum MHD_GNUTLS_HashAlgorithm hash,
-                           MHD_gnutls_x509_privkey_t signer,
-                           MHD_gnutls_datum_t * signature);
+                               enum MHD_GNUTLS_HashAlgorithm hash,
+                               MHD_gnutls_x509_privkey_t signer,
+                               MHD_gnutls_datum_t * signature);
diff --git a/src/daemon/https/x509/verify.h b/src/daemon/https/x509/verify.h
index 0a2e020c..bd9978e3 100644
--- a/src/daemon/https/x509/verify.h
+++ b/src/daemon/https/x509/verify.h
@@ -25,10 +25,12 @@
 #include "x509.h"
 
 int MHD_gnutls_x509_crt_is_issuer (MHD_gnutls_x509_crt_t cert,
-                               MHD_gnutls_x509_crt_t issuer);
-int MHD__gnutls_x509_verify_signature (const MHD_gnutls_datum_t * tbs,
-                                   const MHD_gnutls_datum_t * signature,
                                    MHD_gnutls_x509_crt_t issuer);
+int MHD__gnutls_x509_verify_signature (const MHD_gnutls_datum_t * tbs,
+                                       const MHD_gnutls_datum_t * signature,
+                                       MHD_gnutls_x509_crt_t issuer);
 int MHD__gnutls_x509_privkey_verify_signature (const MHD_gnutls_datum_t * tbs,
-                                           const MHD_gnutls_datum_t * signature,
-                                           MHD_gnutls_x509_privkey_t issuer);
+                                               const MHD_gnutls_datum_t *
+                                               signature,
+                                               MHD_gnutls_x509_privkey_t
+                                               issuer);
diff --git a/src/daemon/https/x509/x509.c b/src/daemon/https/x509/x509.c
index 7bb907ab..e64d34b2 100644
--- a/src/daemon/https/x509/x509.c
+++ b/src/daemon/https/x509/x509.c
@@ -51,14 +51,15 @@
 int
 MHD_gnutls_x509_crt_init (MHD_gnutls_x509_crt_t * cert)
 {
-  MHD_gnutls_x509_crt_t tmp = MHD_gnutls_calloc (1, sizeof (MHD_gnutls_x509_crt_int));
+  MHD_gnutls_x509_crt_t tmp =
+    MHD_gnutls_calloc (1, sizeof (MHD_gnutls_x509_crt_int));
   int result;
 
   if (!tmp)
     return GNUTLS_E_MEMORY_ERROR;
 
   result = MHD__asn1_create_element (MHD__gnutls_get_pkix (),
-                                "PKIX1.Certificate", &tmp->cert);
+                                     "PKIX1.Certificate", &tmp->cert);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -107,8 +108,8 @@ MHD_gnutls_x509_crt_deinit (MHD_gnutls_x509_crt_t cert)
  **/
 int
 MHD_gnutls_x509_crt_import (MHD_gnutls_x509_crt_t cert,
-                        const MHD_gnutls_datum_t * data,
-                        MHD_gnutls_x509_crt_fmt_t format)
+                            const MHD_gnutls_datum_t * data,
+                            MHD_gnutls_x509_crt_fmt_t format)
 {
   int result = 0, need_free = 0;
   MHD_gnutls_datum_t _data;
@@ -130,14 +131,15 @@ MHD_gnutls_x509_crt_import (MHD_gnutls_x509_crt_t cert,
       opaque *out;
 
       /* Try the first header */
-      result = MHD__gnutls_fbase64_decode (PEM_X509_CERT2, data->data, data->size,
-                                       &out);
+      result =
+        MHD__gnutls_fbase64_decode (PEM_X509_CERT2, data->data, data->size,
+                                    &out);
 
       if (result <= 0)
         {
           /* try for the second header */
           result = MHD__gnutls_fbase64_decode (PEM_X509_CERT, data->data,
-                                           data->size, &out);
+                                               data->size, &out);
 
           if (result <= 0)
             {
@@ -205,10 +207,10 @@ cleanup:MHD_gnutls_free (signature);
  **/
 int
 MHD_gnutls_x509_crt_get_dn_by_oid (MHD_gnutls_x509_crt_t cert,
-                               const char *oid,
-                               int indx,
-                               unsigned int raw_flag,
-                               void *buf, size_t * sizeof_buf)
+                                   const char *oid,
+                                   int indx,
+                                   unsigned int raw_flag,
+                                   void *buf, size_t * sizeof_buf)
 {
   if (cert == NULL)
     {
@@ -217,8 +219,8 @@ MHD_gnutls_x509_crt_get_dn_by_oid (MHD_gnutls_x509_crt_t cert,
     }
 
   return MHD__gnutls_x509_parse_dn_oid (cert->cert,
-                                    "tbsCertificate.subject.rdnSequence", oid,
-                                    indx, raw_flag, buf, sizeof_buf);
+                                        "tbsCertificate.subject.rdnSequence",
+                                        oid, indx, raw_flag, buf, sizeof_buf);
 }
 
 /**
@@ -247,8 +249,8 @@ MHD_gnutls_x509_crt_get_signature_algorithm (MHD_gnutls_x509_crt_t cert)
    * read. They will be read from the issuer's certificate if needed.
    */
   result =
-    MHD__gnutls_x509_read_value (cert->cert, "signatureAlgorithm.algorithm", &sa,
-                             0);
+    MHD__gnutls_x509_read_value (cert->cert, "signatureAlgorithm.algorithm",
+                                 &sa, 0);
 
   if (result < 0)
     {
@@ -256,7 +258,7 @@ MHD_gnutls_x509_crt_get_signature_algorithm (MHD_gnutls_x509_crt_t cert)
       return result;
     }
 
-  result = MHD_gtls_x509_oid2sign_algorithm ((const char*) sa.data);
+  result = MHD_gtls_x509_oid2sign_algorithm ((const char *) sa.data);
 
   MHD__gnutls_free_datum (&sa);
 
@@ -275,7 +277,7 @@ MHD_gnutls_x509_crt_get_signature_algorithm (MHD_gnutls_x509_crt_t cert)
  **/
 int
 MHD_gnutls_x509_crt_get_signature (MHD_gnutls_x509_crt_t cert,
-                               char *sig, size_t * sizeof_sig)
+                                   char *sig, size_t * sizeof_sig)
 {
   int result;
   int bits, len;
@@ -342,7 +344,7 @@ MHD_gnutls_x509_crt_get_version (MHD_gnutls_x509_crt_t cert)
   len = sizeof (version);
   if ((result =
        MHD__asn1_read_value (cert->cert, "tbsCertificate.version", version,
-                        &len)) != ASN1_SUCCESS)
+                             &len)) != ASN1_SUCCESS)
     {
 
       if (result == ASN1_ELEMENT_NOT_FOUND)
@@ -373,7 +375,7 @@ MHD_gnutls_x509_crt_get_activation_time (MHD_gnutls_x509_crt_t cert)
     }
 
   return MHD__gnutls_x509_get_time (cert->cert,
-                                "tbsCertificate.validity.notBefore");
+                                    "tbsCertificate.validity.notBefore");
 }
 
 /**
@@ -395,7 +397,7 @@ MHD_gnutls_x509_crt_get_expiration_time (MHD_gnutls_x509_crt_t cert)
     }
 
   return MHD__gnutls_x509_get_time (cert->cert,
-                                "tbsCertificate.validity.notAfter");
+                                    "tbsCertificate.validity.notAfter");
 }
 
 /**
@@ -415,7 +417,7 @@ MHD_gnutls_x509_crt_get_expiration_time (MHD_gnutls_x509_crt_t cert)
  **/
 int
 MHD_gnutls_x509_crt_get_serial (MHD_gnutls_x509_crt_t cert,
-                            void *result, size_t * result_size)
+                                void *result, size_t * result_size)
 {
   int ret, len;
 
@@ -428,7 +430,8 @@ MHD_gnutls_x509_crt_get_serial (MHD_gnutls_x509_crt_t cert,
   len = *result_size;
   ret
     =
-    MHD__asn1_read_value (cert->cert, "tbsCertificate.serialNumber", result, &len);
+    MHD__asn1_read_value (cert->cert, "tbsCertificate.serialNumber", result,
+                          &len);
   *result_size = len;
 
   if (ret != ASN1_SUCCESS)
@@ -459,7 +462,8 @@ MHD_gnutls_x509_crt_get_serial (MHD_gnutls_x509_crt_t cert,
  *
  **/
 int
-MHD_gnutls_x509_crt_get_pk_algorithm (MHD_gnutls_x509_crt_t cert, unsigned int *bits)
+MHD_gnutls_x509_crt_get_pk_algorithm (MHD_gnutls_x509_crt_t cert,
+                                      unsigned int *bits)
 {
   int result;
 
@@ -470,8 +474,8 @@ MHD_gnutls_x509_crt_get_pk_algorithm (MHD_gnutls_x509_crt_t cert, unsigned int *
     }
 
   result = MHD__gnutls_x509_get_pk_algorithm (cert->cert,
-                                          "tbsCertificate.subjectPublicKeyInfo",
-                                          bits);
+                                              "tbsCertificate.subjectPublicKeyInfo",
+                                              bits);
 
   if (result < 0)
     {
@@ -533,7 +537,7 @@ parse_general_name (ASN1_TYPE src,
       return MHD_gtls_asn2err (result);
     }
 
-  type = MHD__gnutls_x509_san_find_type ((char*) choice_type);
+  type = MHD__gnutls_x509_san_find_type ((char *) choice_type);
   if (type == (MHD_gnutls_x509_subject_alt_name_t) - 1)
     {
       MHD_gnutls_assert ();
@@ -591,8 +595,8 @@ parse_general_name (ASN1_TYPE src,
               ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
 
               result =
-                MHD__asn1_create_element (MHD__gnutls_get_pkix (), "PKIX1.XmppAddr",
-                                     &c2);
+                MHD__asn1_create_element (MHD__gnutls_get_pkix (),
+                                          "PKIX1.XmppAddr", &c2);
               if (result != ASN1_SUCCESS)
                 {
                   MHD_gnutls_assert ();
@@ -636,7 +640,7 @@ parse_general_name (ASN1_TYPE src,
       size_t orig_name_size = *name_size;
 
       MHD_gtls_str_cat (nptr, sizeof (nptr), ".");
-      MHD_gtls_str_cat (nptr, sizeof (nptr), (const char*) choice_type);
+      MHD_gtls_str_cat (nptr, sizeof (nptr), (const char *) choice_type);
 
       len = *name_size;
       result = MHD__asn1_read_value (src, nptr, name, &len);
@@ -700,7 +704,7 @@ get_subject_alt_name (MHD_gnutls_x509_crt_t cert,
 
   if ((result =
        MHD__gnutls_x509_crt_get_extension (cert, "2.5.29.17", 0, &dnsname,
-                                       critical)) < 0)
+                                           critical)) < 0)
     {
       return result;
     }
@@ -712,7 +716,8 @@ get_subject_alt_name (MHD_gnutls_x509_crt_t cert,
     }
 
   result =
-    MHD__asn1_create_element (MHD__gnutls_get_pkix (), "PKIX1.SubjectAltName", &c2);
+    MHD__asn1_create_element (MHD__gnutls_get_pkix (), "PKIX1.SubjectAltName",
+                              &c2);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -781,10 +786,10 @@ get_subject_alt_name (MHD_gnutls_x509_crt_t cert,
  **/
 int
 MHD_gnutls_x509_crt_get_subject_alt_name (MHD_gnutls_x509_crt_t cert,
-                                      unsigned int seq,
-                                      void *ret,
-                                      size_t * ret_size,
-                                      unsigned int *critical)
+                                          unsigned int seq,
+                                          void *ret,
+                                          size_t * ret_size,
+                                          unsigned int *critical)
 {
   return get_subject_alt_name (cert, seq, ret, ret_size, NULL, critical, 0);
 }
@@ -811,8 +816,8 @@ MHD_gnutls_x509_crt_get_subject_alt_name (MHD_gnutls_x509_crt_t cert,
  **/
 static int
 MHD_gnutls_x509_crt_get_basic_constraints (MHD_gnutls_x509_crt_t cert,
-                                       unsigned int *critical,
-                                       int *ca, int *pathlen)
+                                           unsigned int *critical,
+                                           int *ca, int *pathlen)
 {
   int result;
   MHD_gnutls_datum_t basicConstraints;
@@ -825,8 +830,8 @@ MHD_gnutls_x509_crt_get_basic_constraints (MHD_gnutls_x509_crt_t cert,
     }
 
   if ((result = MHD__gnutls_x509_crt_get_extension (cert, "2.5.29.19", 0,
-                                                &basicConstraints, critical))
-      < 0)
+                                                    &basicConstraints,
+                                                    critical)) < 0)
     {
       return result;
     }
@@ -838,8 +843,10 @@ MHD_gnutls_x509_crt_get_basic_constraints (MHD_gnutls_x509_crt_t cert,
     }
 
   result = MHD__gnutls_x509_ext_extract_basicConstraints (&tmp_ca, pathlen,
-                                                      basicConstraints.data,
-                                                      basicConstraints.size);
+                                                          basicConstraints.
+                                                          data,
+                                                          basicConstraints.
+                                                          size);
   if (ca)
     *ca = tmp_ca;
   MHD__gnutls_free_datum (&basicConstraints);
@@ -872,11 +879,12 @@ MHD_gnutls_x509_crt_get_basic_constraints (MHD_gnutls_x509_crt_t cert,
  *
  **/
 int
-MHD_gnutls_x509_crt_get_ca_status (MHD_gnutls_x509_crt_t cert, unsigned int *critical)
+MHD_gnutls_x509_crt_get_ca_status (MHD_gnutls_x509_crt_t cert,
+                                   unsigned int *critical)
 {
   int ca, pathlen;
   return MHD_gnutls_x509_crt_get_basic_constraints (cert, critical, &ca,
-                                                &pathlen);
+                                                    &pathlen);
 }
 
 /**
@@ -900,8 +908,8 @@ MHD_gnutls_x509_crt_get_ca_status (MHD_gnutls_x509_crt_t cert, unsigned int *cri
  **/
 int
 MHD_gnutls_x509_crt_get_key_usage (MHD_gnutls_x509_crt_t cert,
-                               unsigned int *key_usage,
-                               unsigned int *critical)
+                                   unsigned int *key_usage,
+                                   unsigned int *critical)
 {
   int result;
   MHD_gnutls_datum_t keyUsage;
@@ -915,7 +923,7 @@ MHD_gnutls_x509_crt_get_key_usage (MHD_gnutls_x509_crt_t cert,
 
   if ((result =
        MHD__gnutls_x509_crt_get_extension (cert, "2.5.29.15", 0, &keyUsage,
-                                       critical)) < 0)
+                                           critical)) < 0)
     {
       return result;
     }
@@ -927,7 +935,7 @@ MHD_gnutls_x509_crt_get_key_usage (MHD_gnutls_x509_crt_t cert,
     }
 
   result = MHD__gnutls_x509_ext_extract_keyUsage (&_usage, keyUsage.data,
-                                              keyUsage.size);
+                                                  keyUsage.size);
   MHD__gnutls_free_datum (&keyUsage);
 
   *key_usage = _usage;
@@ -944,7 +952,8 @@ MHD_gnutls_x509_crt_get_key_usage (MHD_gnutls_x509_crt_t cert,
 
 static int
 MHD__gnutls_x509_crt_get_raw_dn2 (MHD_gnutls_x509_crt_t cert,
-                              const char *whom, MHD_gnutls_datum_t * start)
+                                  const char *whom,
+                                  MHD_gnutls_datum_t * start)
 {
   ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
   int result, len1;
@@ -956,22 +965,24 @@ MHD__gnutls_x509_crt_get_raw_dn2 (MHD_gnutls_x509_crt_t cert,
   /* get the issuer of 'cert'
    */
   if ((result =
-       MHD__asn1_create_element (MHD__gnutls_get_pkix (), "PKIX1.TBSCertificate",
-                            &c2)) != ASN1_SUCCESS)
+       MHD__asn1_create_element (MHD__gnutls_get_pkix (),
+                                 "PKIX1.TBSCertificate",
+                                 &c2)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       return MHD_gtls_asn2err (result);
     }
 
   result = MHD__gnutls_x509_get_signed_data (cert->cert, "tbsCertificate",
-                                         &signed_data);
+                                             &signed_data);
   if (result < 0)
     {
       MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  result = MHD__asn1_der_decoding (&c2, signed_data.data, signed_data.size, NULL);
+  result =
+    MHD__asn1_der_decoding (&c2, signed_data.data, signed_data.size, NULL);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -980,8 +991,9 @@ MHD__gnutls_x509_crt_get_raw_dn2 (MHD_gnutls_x509_crt_t cert,
       goto cleanup;
     }
 
-  result = MHD__asn1_der_decoding_startEnd (c2, signed_data.data, signed_data.size,
-                                       whom, &start1, &end1);
+  result =
+    MHD__asn1_der_decoding_startEnd (c2, signed_data.data, signed_data.size,
+                                     whom, &start1, &end1);
 
   if (result != ASN1_SUCCESS)
     {
@@ -1014,7 +1026,7 @@ cleanup:MHD__asn1_delete_structure (&c2);
  **/
 int
 MHD_gnutls_x509_crt_get_raw_issuer_dn (MHD_gnutls_x509_crt_t cert,
-                                   MHD_gnutls_datum_t * start)
+                                       MHD_gnutls_datum_t * start)
 {
   return MHD__gnutls_x509_crt_get_raw_dn2 (cert, "issuer", start);
 }
@@ -1031,13 +1043,15 @@ MHD_gnutls_x509_crt_get_raw_issuer_dn (MHD_gnutls_x509_crt_t cert,
  *
  **/
 int
-MHD_gnutls_x509_crt_get_raw_dn (MHD_gnutls_x509_crt_t cert, MHD_gnutls_datum_t * start)
+MHD_gnutls_x509_crt_get_raw_dn (MHD_gnutls_x509_crt_t cert,
+                                MHD_gnutls_datum_t * start)
 {
   return MHD__gnutls_x509_crt_get_raw_dn2 (cert, "subject", start);
 }
 
 static int
-get_dn (MHD_gnutls_x509_crt_t cert, const char *whom, MHD_gnutls_x509_dn_t * dn)
+get_dn (MHD_gnutls_x509_crt_t cert, const char *whom,
+        MHD_gnutls_x509_dn_t * dn)
 {
   *dn = MHD__asn1_find_node (cert->cert, whom);
   if (!*dn)
@@ -1056,7 +1070,8 @@ get_dn (MHD_gnutls_x509_crt_t cert, const char *whom, MHD_gnutls_x509_dn_t * dn)
  * Returns: Returns 0 on success, or an error code.
  **/
 int
-MHD_gnutls_x509_crt_get_subject (MHD_gnutls_x509_crt_t cert, MHD_gnutls_x509_dn_t * dn)
+MHD_gnutls_x509_crt_get_subject (MHD_gnutls_x509_crt_t cert,
+                                 MHD_gnutls_x509_dn_t * dn)
 {
   return get_dn (cert, "tbsCertificate.subject.rdnSequence", dn);
 }
@@ -1083,8 +1098,8 @@ MHD_gnutls_x509_crt_get_subject (MHD_gnutls_x509_crt_t cert, MHD_gnutls_x509_dn_
  **/
 int
 MHD_gnutls_x509_crt_export (MHD_gnutls_x509_crt_t cert,
-                        MHD_gnutls_x509_crt_fmt_t format,
-                        void *output_data, size_t * output_data_size)
+                            MHD_gnutls_x509_crt_fmt_t format,
+                            void *output_data, size_t * output_data_size)
 {
   if (cert == NULL)
     {
@@ -1093,7 +1108,7 @@ MHD_gnutls_x509_crt_export (MHD_gnutls_x509_crt_t cert,
     }
 
   return MHD__gnutls_x509_export_int (cert->cert, format, "CERTIFICATE",
-                                  output_data, output_data_size);
+                                      output_data, output_data_size);
 }
 
 #ifdef ENABLE_PKI
@@ -1112,8 +1127,8 @@ MHD_gnutls_x509_crt_export (MHD_gnutls_x509_crt_t cert,
  **/
 int
 MHD_gnutls_x509_crt_check_revocation (MHD_gnutls_x509_crt_t cert,
-                                  const MHD_gnutls_x509_crl_t * crl_list,
-                                  int crl_list_length)
+                                      const MHD_gnutls_x509_crl_t * crl_list,
+                                      int crl_list_length)
 {
   opaque serial[64];
   opaque cert_serial[64];
@@ -1160,7 +1175,8 @@ MHD_gnutls_x509_crt_check_revocation (MHD_gnutls_x509_crt_t cert,
       /* Step 2. Read the certificate's serial number
        */
       cert_serial_size = sizeof (cert_serial);
-      ret = MHD_gnutls_x509_crt_get_serial (cert, cert_serial, &cert_serial_size);
+      ret =
+        MHD_gnutls_x509_crt_get_serial (cert, cert_serial, &cert_serial_size);
       if (ret < 0)
         {
           MHD_gnutls_assert ();
@@ -1182,7 +1198,7 @@ MHD_gnutls_x509_crt_check_revocation (MHD_gnutls_x509_crt_t cert,
         {
           serial_size = sizeof (serial);
           ret = MHD_gnutls_x509_crl_get_crt_serial (crl_list[j], i, serial,
-                                                &serial_size, NULL);
+                                                    &serial_size, NULL);
 
           if (ret < 0)
             {
@@ -1205,4 +1221,3 @@ MHD_gnutls_x509_crt_check_revocation (MHD_gnutls_x509_crt_t cert,
 }
 
 #endif
-
diff --git a/src/daemon/https/x509/x509.h b/src/daemon/https/x509/x509.h
index 87a81954..3afda0da 100644
--- a/src/daemon/https/x509/x509.h
+++ b/src/daemon/https/x509/x509.h
@@ -90,17 +90,19 @@ extern "C"
   int MHD_gnutls_x509_crt_init (MHD_gnutls_x509_crt_t * cert);
   void MHD_gnutls_x509_crt_deinit (MHD_gnutls_x509_crt_t cert);
   int MHD_gnutls_x509_crt_import (MHD_gnutls_x509_crt_t cert,
-                              const MHD_gnutls_datum_t * data,
-                              MHD_gnutls_x509_crt_fmt_t format);
+                                  const MHD_gnutls_datum_t * data,
+                                  MHD_gnutls_x509_crt_fmt_t format);
   int MHD_gnutls_x509_crt_export (MHD_gnutls_x509_crt_t cert,
-                              MHD_gnutls_x509_crt_fmt_t format,
-                              void *output_data, size_t * output_data_size);
+                                  MHD_gnutls_x509_crt_fmt_t format,
+                                  void *output_data,
+                                  size_t * output_data_size);
   int MHD_gnutls_x509_crt_check_hostname (MHD_gnutls_x509_crt_t cert,
-                                      const char *hostname);
+                                          const char *hostname);
 
-  int MHD_gnutls_x509_crt_get_signature_algorithm (MHD_gnutls_x509_crt_t cert);
+  int MHD_gnutls_x509_crt_get_signature_algorithm (MHD_gnutls_x509_crt_t
+                                                   cert);
   int MHD_gnutls_x509_crt_get_signature (MHD_gnutls_x509_crt_t cert,
-                                     char *sig, size_t * sizeof_sig);
+                                         char *sig, size_t * sizeof_sig);
   int MHD_gnutls_x509_crt_get_version (MHD_gnutls_x509_crt_t cert);
 
 #define GNUTLS_CRL_REASON_UNUSED 128
@@ -116,86 +118,90 @@ extern "C"
   time_t MHD_gnutls_x509_crt_get_activation_time (MHD_gnutls_x509_crt_t cert);
   time_t MHD_gnutls_x509_crt_get_expiration_time (MHD_gnutls_x509_crt_t cert);
   int MHD_gnutls_x509_crt_get_serial (MHD_gnutls_x509_crt_t cert,
-                                  void *result, size_t * result_size);
+                                      void *result, size_t * result_size);
 
   int MHD_gnutls_x509_crt_get_pk_algorithm (MHD_gnutls_x509_crt_t cert,
-                                        unsigned int *bits);
+                                            unsigned int *bits);
   int MHD_gnutls_x509_crt_get_subject_alt_name (MHD_gnutls_x509_crt_t cert,
-                                            unsigned int seq,
-                                            void *ret,
-                                            size_t * ret_size,
-                                            unsigned int *critical);
+                                                unsigned int seq,
+                                                void *ret,
+                                                size_t * ret_size,
+                                                unsigned int *critical);
   int MHD_gnutls_x509_crt_get_ca_status (MHD_gnutls_x509_crt_t cert,
-                                     unsigned int *critical);
+                                         unsigned int *critical);
 /* The key_usage flags are defined in gnutls.h. They are the
  * GNUTLS_KEY_* definitions.
  */
   int MHD_gnutls_x509_crt_get_key_usage (MHD_gnutls_x509_crt_t cert,
-                                     unsigned int *key_usage,
-                                     unsigned int *critical);
+                                         unsigned int *key_usage,
+                                         unsigned int *critical);
   int MHD_gnutls_x509_crt_set_key_usage (MHD_gnutls_x509_crt_t crt,
-                                     unsigned int usage);
+                                         unsigned int usage);
 
   int MHD_gnutls_x509_dn_oid_known (const char *oid);
 
 /* Read extensions by sequence number. */
   int MHD_gnutls_x509_crt_set_extension_by_oid (MHD_gnutls_x509_crt_t crt,
-                                            const char *oid,
-                                            const void *buf,
-                                            size_t sizeof_buf,
-                                            unsigned int critical);
+                                                const char *oid,
+                                                const void *buf,
+                                                size_t sizeof_buf,
+                                                unsigned int critical);
 
 /* X.509 Certificate writing.
  */
   int MHD_gnutls_x509_crt_set_dn_by_oid (MHD_gnutls_x509_crt_t crt,
-                                     const char *oid,
-                                     unsigned int raw_flag,
-                                     const void *name,
-                                     unsigned int sizeof_name);
+                                         const char *oid,
+                                         unsigned int raw_flag,
+                                         const void *name,
+                                         unsigned int sizeof_name);
   int MHD_gnutls_x509_crt_set_issuer_dn_by_oid (MHD_gnutls_x509_crt_t crt,
-                                            const char *oid,
-                                            unsigned int raw_flag,
-                                            const void *name,
-                                            unsigned int sizeof_name);
+                                                const char *oid,
+                                                unsigned int raw_flag,
+                                                const void *name,
+                                                unsigned int sizeof_name);
   int MHD_gnutls_x509_crt_set_version (MHD_gnutls_x509_crt_t crt,
-                                   unsigned int version);
+                                       unsigned int version);
   int MHD_gnutls_x509_crt_set_key (MHD_gnutls_x509_crt_t crt,
-                               MHD_gnutls_x509_privkey_t key);
-  int MHD_gnutls_x509_crt_set_ca_status (MHD_gnutls_x509_crt_t crt, unsigned int ca);
+                                   MHD_gnutls_x509_privkey_t key);
+  int MHD_gnutls_x509_crt_set_ca_status (MHD_gnutls_x509_crt_t crt,
+                                         unsigned int ca);
   int MHD_gnutls_x509_crt_set_basic_constraints (MHD_gnutls_x509_crt_t crt,
-                                             unsigned int ca,
-                                             int pathLenConstraint);
-  int MHD_gnutls_x509_crt_set_subject_alternative_name (MHD_gnutls_x509_crt_t crt,
-                                                    MHD_gnutls_x509_subject_alt_name_t
-                                                    type,
-                                                    const char *data_string);
+                                                 unsigned int ca,
+                                                 int pathLenConstraint);
+  int MHD_gnutls_x509_crt_set_subject_alternative_name (MHD_gnutls_x509_crt_t
+                                                        crt,
+                                                        MHD_gnutls_x509_subject_alt_name_t
+                                                        type,
+                                                        const char
+                                                        *data_string);
   int MHD_gnutls_x509_crt_sign (MHD_gnutls_x509_crt_t crt,
-                            MHD_gnutls_x509_crt_t issuer,
-                            MHD_gnutls_x509_privkey_t issuer_key);
+                                MHD_gnutls_x509_crt_t issuer,
+                                MHD_gnutls_x509_privkey_t issuer_key);
   int MHD_gnutls_x509_crt_sign2 (MHD_gnutls_x509_crt_t crt,
-                             MHD_gnutls_x509_crt_t issuer,
-                             MHD_gnutls_x509_privkey_t issuer_key,
-                             enum MHD_GNUTLS_HashAlgorithm,
-                             unsigned int flags);
+                                 MHD_gnutls_x509_crt_t issuer,
+                                 MHD_gnutls_x509_privkey_t issuer_key,
+                                 enum MHD_GNUTLS_HashAlgorithm,
+                                 unsigned int flags);
   int MHD_gnutls_x509_crt_set_activation_time (MHD_gnutls_x509_crt_t cert,
-                                           time_t act_time);
+                                               time_t act_time);
   int MHD_gnutls_x509_crt_set_expiration_time (MHD_gnutls_x509_crt_t cert,
-                                           time_t exp_time);
+                                               time_t exp_time);
   int MHD_gnutls_x509_crt_set_serial (MHD_gnutls_x509_crt_t cert,
-                                  const void *serial, size_t serial_size);
+                                      const void *serial, size_t serial_size);
 
   int MHD_gnutls_x509_crt_set_subject_key_id (MHD_gnutls_x509_crt_t cert,
-                                          const void *id, size_t id_size);
+                                              const void *id, size_t id_size);
 
   int MHD_gnutls_x509_crt_set_proxy_dn (MHD_gnutls_x509_crt_t crt,
-                                    MHD_gnutls_x509_crt_t eecrt,
-                                    unsigned int raw_flag,
-                                    const void *name,
-                                    unsigned int sizeof_name);
+                                        MHD_gnutls_x509_crt_t eecrt,
+                                        unsigned int raw_flag,
+                                        const void *name,
+                                        unsigned int sizeof_name);
   int MHD_gnutls_x509_crt_set_proxy (MHD_gnutls_x509_crt_t crt,
-                                 int pathLenConstraint,
-                                 const char *policyLanguage,
-                                 const char *policy, size_t sizeof_policy);
+                                     int pathLenConstraint,
+                                     const char *policyLanguage,
+                                     const char *policy,
+                                     size_t sizeof_policy);
 
   typedef enum MHD_gnutls_certificate_print_formats
   {
@@ -205,31 +211,31 @@ extern "C"
   } MHD_gnutls_certificate_print_formats_t;
 
   int MHD_gnutls_x509_crt_print (MHD_gnutls_x509_crt_t cert,
-                             MHD_gnutls_certificate_print_formats_t format,
-                             MHD_gnutls_datum_t * out);
+                                 MHD_gnutls_certificate_print_formats_t
+                                 format, MHD_gnutls_datum_t * out);
   int MHD_gnutls_x509_crl_print (MHD_gnutls_x509_crl_t crl,
-                             MHD_gnutls_certificate_print_formats_t format,
-                             MHD_gnutls_datum_t * out);
+                                 MHD_gnutls_certificate_print_formats_t
+                                 format, MHD_gnutls_datum_t * out);
 
 /* Access to internal Certificate fields.
  */
   int MHD_gnutls_x509_crt_get_raw_issuer_dn (MHD_gnutls_x509_crt_t cert,
-                                         MHD_gnutls_datum_t * start);
+                                             MHD_gnutls_datum_t * start);
   int MHD_gnutls_x509_crt_get_raw_dn (MHD_gnutls_x509_crt_t cert,
-                                  MHD_gnutls_datum_t * start);
+                                      MHD_gnutls_datum_t * start);
 
 /* RDN handling.
  */
   int MHD_gnutls_x509_rdn_get (const MHD_gnutls_datum_t * idn,
-                           char *buf, size_t * sizeof_buf);
+                               char *buf, size_t * sizeof_buf);
   int MHD_gnutls_x509_rdn_get_oid (const MHD_gnutls_datum_t * idn,
-                               int indx, void *buf, size_t * sizeof_buf);
+                                   int indx, void *buf, size_t * sizeof_buf);
 
   int MHD_gnutls_x509_rdn_get_by_oid (const MHD_gnutls_datum_t * idn,
-                                  const char *oid,
-                                  int indx,
-                                  unsigned int raw_flag,
-                                  void *buf, size_t * sizeof_buf);
+                                      const char *oid,
+                                      int indx,
+                                      unsigned int raw_flag,
+                                      void *buf, size_t * sizeof_buf);
 
   typedef void *MHD_gnutls_x509_dn_t;
 
@@ -241,30 +247,32 @@ extern "C"
   } MHD_gnutls_x509_ava_st;
 
   int MHD_gnutls_x509_crt_get_subject (MHD_gnutls_x509_crt_t cert,
-                                   MHD_gnutls_x509_dn_t * dn);
+                                       MHD_gnutls_x509_dn_t * dn);
 /* CRL handling functions.
  */
   int MHD_gnutls_x509_crl_init (MHD_gnutls_x509_crl_t * crl);
   void MHD_gnutls_x509_crl_deinit (MHD_gnutls_x509_crl_t crl);
 
   int MHD_gnutls_x509_crl_import (MHD_gnutls_x509_crl_t crl,
-                              const MHD_gnutls_datum_t * data,
-                              MHD_gnutls_x509_crt_fmt_t format);
+                                  const MHD_gnutls_datum_t * data,
+                                  MHD_gnutls_x509_crt_fmt_t format);
   int MHD_gnutls_x509_crl_export (MHD_gnutls_x509_crl_t crl,
-                              MHD_gnutls_x509_crt_fmt_t format,
-                              void *output_data, size_t * output_data_size);
+                                  MHD_gnutls_x509_crt_fmt_t format,
+                                  void *output_data,
+                                  size_t * output_data_size);
 
   int MHD_gnutls_x509_crl_get_issuer_dn_by_oid (MHD_gnutls_x509_crl_t crl,
-                                            const char *oid,
-                                            int indx,
-                                            unsigned int raw_flag,
-                                            void *buf, size_t * sizeof_buf);
-  int MHD_gnutls_x509_crl_get_dn_oid (MHD_gnutls_x509_crl_t crl,
-                                  int indx, void *oid, size_t * sizeof_oid);
+                                                const char *oid,
+                                                int indx,
+                                                unsigned int raw_flag,
+                                                void *buf,
+                                                size_t * sizeof_buf);
+  int MHD_gnutls_x509_crl_get_dn_oid (MHD_gnutls_x509_crl_t crl, int indx,
+                                      void *oid, size_t * sizeof_oid);
 
   int MHD_gnutls_x509_crl_get_signature_algorithm (MHD_gnutls_x509_crl_t crl);
   int MHD_gnutls_x509_crl_get_signature (MHD_gnutls_x509_crl_t crl,
-                                     char *sig, size_t * sizeof_sig);
+                                         char *sig, size_t * sizeof_sig);
   int MHD_gnutls_x509_crl_get_version (MHD_gnutls_x509_crl_t crl);
 
   time_t MHD_gnutls_x509_crl_get_this_update (MHD_gnutls_x509_crl_t crl);
@@ -272,37 +280,38 @@ extern "C"
 
   int MHD_gnutls_x509_crl_get_crt_count (MHD_gnutls_x509_crl_t crl);
   int MHD_gnutls_x509_crl_get_crt_serial (MHD_gnutls_x509_crl_t crl,
-                                      int indx,
-                                      unsigned char *serial,
-                                      size_t * serial_size, time_t * t);
+                                          int indx,
+                                          unsigned char *serial,
+                                          size_t * serial_size, time_t * t);
 #define MHD_gnutls_x509_crl_get_certificate_count MHD_gnutls_x509_crl_get_crt_count
 #define MHD_gnutls_x509_crl_get_certificate MHD_gnutls_x509_crl_get_crt_serial
 
   int MHD_gnutls_x509_crl_check_issuer (MHD_gnutls_x509_crl_t crl,
-                                    MHD_gnutls_x509_crt_t issuer);
+                                        MHD_gnutls_x509_crt_t issuer);
 
 /* CRL writing.
  */
   int MHD_gnutls_x509_crl_set_version (MHD_gnutls_x509_crl_t crl,
-                                   unsigned int version);
+                                       unsigned int version);
   int MHD_gnutls_x509_crl_sign (MHD_gnutls_x509_crl_t crl,
-                            MHD_gnutls_x509_crt_t issuer,
-                            MHD_gnutls_x509_privkey_t issuer_key);
+                                MHD_gnutls_x509_crt_t issuer,
+                                MHD_gnutls_x509_privkey_t issuer_key);
   int MHD_gnutls_x509_crl_sign2 (MHD_gnutls_x509_crl_t crl,
-                             MHD_gnutls_x509_crt_t issuer,
-                             MHD_gnutls_x509_privkey_t issuer_key,
-                             enum MHD_GNUTLS_HashAlgorithm,
-                             unsigned int flags);
+                                 MHD_gnutls_x509_crt_t issuer,
+                                 MHD_gnutls_x509_privkey_t issuer_key,
+                                 enum MHD_GNUTLS_HashAlgorithm,
+                                 unsigned int flags);
   int MHD_gnutls_x509_crl_set_this_update (MHD_gnutls_x509_crl_t crl,
-                                       time_t act_time);
+                                           time_t act_time);
   int MHD_gnutls_x509_crl_set_next_update (MHD_gnutls_x509_crl_t crl,
-                                       time_t exp_time);
+                                           time_t exp_time);
   int MHD_gnutls_x509_crl_set_crt_serial (MHD_gnutls_x509_crl_t crl,
-                                      const void *serial,
-                                      size_t serial_size,
-                                      time_t revocation_time);
+                                          const void *serial,
+                                          size_t serial_size,
+                                          time_t revocation_time);
   int MHD_gnutls_x509_crl_set_crt (MHD_gnutls_x509_crl_t crl,
-                               MHD_gnutls_x509_crt_t crt, time_t revocation_time);
+                                   MHD_gnutls_x509_crt_t crt,
+                                   time_t revocation_time);
 
 /* PKCS7 structures handling
  */
@@ -312,29 +321,32 @@ extern "C"
   int MHD_gnutls_pkcs7_init (MHD_gnutls_pkcs7_t * pkcs7);
   void MHD_gnutls_pkcs7_deinit (MHD_gnutls_pkcs7_t pkcs7);
   int MHD_gnutls_pkcs7_import (MHD_gnutls_pkcs7_t pkcs7,
-                           const MHD_gnutls_datum_t * data,
-                           MHD_gnutls_x509_crt_fmt_t format);
+                               const MHD_gnutls_datum_t * data,
+                               MHD_gnutls_x509_crt_fmt_t format);
   int MHD_gnutls_pkcs7_export (MHD_gnutls_pkcs7_t pkcs7,
-                           MHD_gnutls_x509_crt_fmt_t format,
-                           void *output_data, size_t * output_data_size);
+                               MHD_gnutls_x509_crt_fmt_t format,
+                               void *output_data, size_t * output_data_size);
 
   int MHD_gnutls_pkcs7_get_crt_count (MHD_gnutls_pkcs7_t pkcs7);
   int MHD_gnutls_pkcs7_get_crt_raw (MHD_gnutls_pkcs7_t pkcs7,
-                                int indx,
-                                void *certificate, size_t * certificate_size);
+                                    int indx,
+                                    void *certificate,
+                                    size_t * certificate_size);
 
   int MHD_gnutls_pkcs7_set_crt_raw (MHD_gnutls_pkcs7_t pkcs7,
-                                const MHD_gnutls_datum_t * crt);
-  int MHD_gnutls_pkcs7_set_crt (MHD_gnutls_pkcs7_t pkcs7, MHD_gnutls_x509_crt_t crt);
+                                    const MHD_gnutls_datum_t * crt);
+  int MHD_gnutls_pkcs7_set_crt (MHD_gnutls_pkcs7_t pkcs7,
+                                MHD_gnutls_x509_crt_t crt);
   int MHD_gnutls_pkcs7_delete_crt (MHD_gnutls_pkcs7_t pkcs7, int indx);
 
   int MHD_gnutls_pkcs7_get_crl_raw (MHD_gnutls_pkcs7_t pkcs7,
-                                int indx, void *crl, size_t * crl_size);
+                                    int indx, void *crl, size_t * crl_size);
   int MHD_gnutls_pkcs7_get_crl_count (MHD_gnutls_pkcs7_t pkcs7);
 
   int MHD_gnutls_pkcs7_set_crl_raw (MHD_gnutls_pkcs7_t pkcs7,
-                                const MHD_gnutls_datum_t * crt);
-  int MHD_gnutls_pkcs7_set_crl (MHD_gnutls_pkcs7_t pkcs7, MHD_gnutls_x509_crl_t crl);
+                                    const MHD_gnutls_datum_t * crt);
+  int MHD_gnutls_pkcs7_set_crl (MHD_gnutls_pkcs7_t pkcs7,
+                                MHD_gnutls_x509_crl_t crl);
   int MHD_gnutls_pkcs7_delete_crl (MHD_gnutls_pkcs7_t pkcs7, int indx);
 
 /* X.509 Certificate verification functions.
@@ -375,28 +387,29 @@ extern "C"
   } MHD_gnutls_certificate_verify_flags;
 
   int MHD_gnutls_x509_crt_check_issuer (MHD_gnutls_x509_crt_t cert,
-                                    MHD_gnutls_x509_crt_t issuer);
-
-  int MHD_gnutls_x509_crt_list_verify (const MHD_gnutls_x509_crt_t * cert_list,
-                                   int cert_list_length,
-                                   const MHD_gnutls_x509_crt_t * CA_list,
-                                   int CA_list_length,
-                                   const MHD_gnutls_x509_crl_t * CRL_list,
-                                   int CRL_list_length,
-                                   unsigned int flags, unsigned int *verify);
+                                        MHD_gnutls_x509_crt_t issuer);
+
+  int MHD_gnutls_x509_crt_list_verify (const MHD_gnutls_x509_crt_t *
+                                       cert_list, int cert_list_length,
+                                       const MHD_gnutls_x509_crt_t * CA_list,
+                                       int CA_list_length,
+                                       const MHD_gnutls_x509_crl_t * CRL_list,
+                                       int CRL_list_length,
+                                       unsigned int flags,
+                                       unsigned int *verify);
 
   int MHD_gnutls_x509_crt_verify (MHD_gnutls_x509_crt_t cert,
-                              const MHD_gnutls_x509_crt_t * CA_list,
-                              int CA_list_length,
-                              unsigned int flags, unsigned int *verify);
+                                  const MHD_gnutls_x509_crt_t * CA_list,
+                                  int CA_list_length,
+                                  unsigned int flags, unsigned int *verify);
   int MHD_gnutls_x509_crl_verify (MHD_gnutls_x509_crl_t crl,
-                              const MHD_gnutls_x509_crt_t * CA_list,
-                              int CA_list_length,
-                              unsigned int flags, unsigned int *verify);
+                                  const MHD_gnutls_x509_crt_t * CA_list,
+                                  int CA_list_length,
+                                  unsigned int flags, unsigned int *verify);
 
   int MHD_gnutls_x509_crt_check_revocation (MHD_gnutls_x509_crt_t cert,
-                                        const MHD_gnutls_x509_crl_t *
-                                        crl_list, int crl_list_length);
+                                            const MHD_gnutls_x509_crl_t *
+                                            crl_list, int crl_list_length);
 
 
 /* Flags for the MHD_gnutls_x509_privkey_export_pkcs8() function.
@@ -420,62 +433,65 @@ extern "C"
   int MHD_gnutls_x509_privkey_init (MHD_gnutls_x509_privkey_t * key);
   void MHD_gnutls_x509_privkey_deinit (MHD_gnutls_x509_privkey_t key);
   int MHD_gnutls_x509_privkey_cpy (MHD_gnutls_x509_privkey_t dst,
-                               MHD_gnutls_x509_privkey_t src);
+                                   MHD_gnutls_x509_privkey_t src);
   int MHD_gnutls_x509_privkey_import (MHD_gnutls_x509_privkey_t key,
-                                  const MHD_gnutls_datum_t * data,
-                                  MHD_gnutls_x509_crt_fmt_t format);
+                                      const MHD_gnutls_datum_t * data,
+                                      MHD_gnutls_x509_crt_fmt_t format);
   int MHD_gnutls_x509_privkey_import_pkcs8 (MHD_gnutls_x509_privkey_t key,
-                                        const MHD_gnutls_datum_t * data,
-                                        MHD_gnutls_x509_crt_fmt_t format,
-                                        const char *pass, unsigned int flags);
+                                            const MHD_gnutls_datum_t * data,
+                                            MHD_gnutls_x509_crt_fmt_t format,
+                                            const char *pass,
+                                            unsigned int flags);
   int MHD_gnutls_x509_privkey_import_rsa_raw (MHD_gnutls_x509_privkey_t key,
-                                          const MHD_gnutls_datum_t * m,
-                                          const MHD_gnutls_datum_t * e,
-                                          const MHD_gnutls_datum_t * d,
-                                          const MHD_gnutls_datum_t * p,
-                                          const MHD_gnutls_datum_t * q,
-                                          const MHD_gnutls_datum_t * u);
+                                              const MHD_gnutls_datum_t * m,
+                                              const MHD_gnutls_datum_t * e,
+                                              const MHD_gnutls_datum_t * d,
+                                              const MHD_gnutls_datum_t * p,
+                                              const MHD_gnutls_datum_t * q,
+                                              const MHD_gnutls_datum_t * u);
   int MHD_gnutls_x509_privkey_export_dsa_raw (MHD_gnutls_x509_privkey_t key,
-                                          MHD_gnutls_datum_t * p,
-                                          MHD_gnutls_datum_t * q,
-                                          MHD_gnutls_datum_t * g,
-                                          MHD_gnutls_datum_t * y,
-                                          MHD_gnutls_datum_t * x);
+                                              MHD_gnutls_datum_t * p,
+                                              MHD_gnutls_datum_t * q,
+                                              MHD_gnutls_datum_t * g,
+                                              MHD_gnutls_datum_t * y,
+                                              MHD_gnutls_datum_t * x);
   int MHD_gnutls_x509_privkey_import_dsa_raw (MHD_gnutls_x509_privkey_t key,
-                                          const MHD_gnutls_datum_t * p,
-                                          const MHD_gnutls_datum_t * q,
-                                          const MHD_gnutls_datum_t * g,
-                                          const MHD_gnutls_datum_t * y,
-                                          const MHD_gnutls_datum_t * x);
-
-  int MHD_gnutls_x509_privkey_get_pk_algorithm (MHD_gnutls_x509_privkey_t key);
+                                              const MHD_gnutls_datum_t * p,
+                                              const MHD_gnutls_datum_t * q,
+                                              const MHD_gnutls_datum_t * g,
+                                              const MHD_gnutls_datum_t * y,
+                                              const MHD_gnutls_datum_t * x);
+
+  int MHD_gnutls_x509_privkey_get_pk_algorithm (MHD_gnutls_x509_privkey_t
+                                                key);
   int MHD_gnutls_x509_privkey_get_key_id (MHD_gnutls_x509_privkey_t key,
-                                      unsigned int flags,
-                                      unsigned char *output_data,
-                                      size_t * output_data_size);
+                                          unsigned int flags,
+                                          unsigned char *output_data,
+                                          size_t * output_data_size);
 
   int MHD_gnutls_x509_privkey_export (MHD_gnutls_x509_privkey_t key,
-                                  MHD_gnutls_x509_crt_fmt_t format,
-                                  void *output_data,
-                                  size_t * output_data_size);
+                                      MHD_gnutls_x509_crt_fmt_t format,
+                                      void *output_data,
+                                      size_t * output_data_size);
   int MHD_gnutls_x509_privkey_export_pkcs8 (MHD_gnutls_x509_privkey_t key,
-                                        MHD_gnutls_x509_crt_fmt_t format,
-                                        const char *password,
-                                        unsigned int flags,
-                                        void *output_data,
-                                        size_t * output_data_size);
+                                            MHD_gnutls_x509_crt_fmt_t format,
+                                            const char *password,
+                                            unsigned int flags,
+                                            void *output_data,
+                                            size_t * output_data_size);
   int MHD_gnutls_x509_privkey_export_rsa_raw (MHD_gnutls_x509_privkey_t key,
-                                          MHD_gnutls_datum_t * m,
-                                          MHD_gnutls_datum_t * e,
-                                          MHD_gnutls_datum_t * d,
-                                          MHD_gnutls_datum_t * p,
-                                          MHD_gnutls_datum_t * q,
-                                          MHD_gnutls_datum_t * u);
+                                              MHD_gnutls_datum_t * m,
+                                              MHD_gnutls_datum_t * e,
+                                              MHD_gnutls_datum_t * d,
+                                              MHD_gnutls_datum_t * p,
+                                              MHD_gnutls_datum_t * q,
+                                              MHD_gnutls_datum_t * u);
 
   int MHD_gnutls_x509_privkey_verify_data (MHD_gnutls_x509_privkey_t key,
-                                       unsigned int flags,
-                                       const MHD_gnutls_datum_t * data,
-                                       const MHD_gnutls_datum_t * signature);
+                                           unsigned int flags,
+                                           const MHD_gnutls_datum_t * data,
+                                           const MHD_gnutls_datum_t *
+                                           signature);
 
 /* Certificate request stuff.
  */
@@ -485,53 +501,57 @@ extern "C"
   int MHD_gnutls_x509_crq_init (MHD_gnutls_x509_crq_t * crq);
   void MHD_gnutls_x509_crq_deinit (MHD_gnutls_x509_crq_t crq);
   int MHD_gnutls_x509_crq_import (MHD_gnutls_x509_crq_t crq,
-                              const MHD_gnutls_datum_t * data,
-                              MHD_gnutls_x509_crt_fmt_t format);
+                                  const MHD_gnutls_datum_t * data,
+                                  MHD_gnutls_x509_crt_fmt_t format);
   int MHD_gnutls_x509_crq_get_pk_algorithm (MHD_gnutls_x509_crq_t crq,
-                                        unsigned int *bits);
+                                            unsigned int *bits);
   int MHD_gnutls_x509_crq_get_dn (MHD_gnutls_x509_crq_t crq,
-                              char *buf, size_t * sizeof_buf);
+                                  char *buf, size_t * sizeof_buf);
   int MHD_gnutls_x509_crq_get_dn_oid (MHD_gnutls_x509_crq_t crq,
-                                  int indx, void *oid, size_t * sizeof_oid);
+                                      int indx, void *oid,
+                                      size_t * sizeof_oid);
   int MHD_gnutls_x509_crq_get_dn_by_oid (MHD_gnutls_x509_crq_t crq,
-                                     const char *oid,
-                                     int indx,
-                                     unsigned int raw_flag,
-                                     void *buf, size_t * sizeof_buf);
+                                         const char *oid, int indx,
+                                         unsigned int raw_flag, void *buf,
+                                         size_t * sizeof_buf);
   int MHD_gnutls_x509_crq_set_dn_by_oid (MHD_gnutls_x509_crq_t crq,
-                                     const char *oid,
-                                     unsigned int raw_flag,
-                                     const void *name,
-                                     unsigned int sizeof_name);
+                                         const char *oid,
+                                         unsigned int raw_flag,
+                                         const void *name,
+                                         unsigned int sizeof_name);
   int MHD_gnutls_x509_crq_set_version (MHD_gnutls_x509_crq_t crq,
-                                   unsigned int version);
+                                       unsigned int version);
   int MHD_gnutls_x509_crq_set_key (MHD_gnutls_x509_crq_t crq,
-                               MHD_gnutls_x509_privkey_t key);
+                                   MHD_gnutls_x509_privkey_t key);
   int MHD_gnutls_x509_crq_sign2 (MHD_gnutls_x509_crq_t crq,
-                             MHD_gnutls_x509_privkey_t key,
-                             enum MHD_GNUTLS_HashAlgorithm,
-                             unsigned int flags);
-  int MHD_gnutls_x509_crq_sign (MHD_gnutls_x509_crq_t crq, MHD_gnutls_x509_privkey_t key);
+                                 MHD_gnutls_x509_privkey_t key,
+                                 enum MHD_GNUTLS_HashAlgorithm,
+                                 unsigned int flags);
+  int MHD_gnutls_x509_crq_sign (MHD_gnutls_x509_crq_t crq,
+                                MHD_gnutls_x509_privkey_t key);
 
   int MHD_gnutls_x509_crq_set_challenge_password (MHD_gnutls_x509_crq_t crq,
-                                              const char *pass);
+                                                  const char *pass);
   int MHD_gnutls_x509_crq_get_challenge_password (MHD_gnutls_x509_crq_t crq,
-                                              char *pass,
-                                              size_t * sizeof_pass);
+                                                  char *pass,
+                                                  size_t * sizeof_pass);
 
   int MHD_gnutls_x509_crq_set_attribute_by_oid (MHD_gnutls_x509_crq_t crq,
-                                            const char *oid,
-                                            void *buf, size_t sizeof_buf);
+                                                const char *oid,
+                                                void *buf, size_t sizeof_buf);
   int MHD_gnutls_x509_crq_get_attribute_by_oid (MHD_gnutls_x509_crq_t crq,
-                                            const char *oid,
-                                            int indx,
-                                            void *buf, size_t * sizeof_buf);
+                                                const char *oid,
+                                                int indx,
+                                                void *buf,
+                                                size_t * sizeof_buf);
 
   int MHD_gnutls_x509_crq_export (MHD_gnutls_x509_crq_t crq,
-                              MHD_gnutls_x509_crt_fmt_t format,
-                              void *output_data, size_t * output_data_size);
+                                  MHD_gnutls_x509_crt_fmt_t format,
+                                  void *output_data,
+                                  size_t * output_data_size);
 
-  int MHD_gnutls_x509_crt_set_crq (MHD_gnutls_x509_crt_t crt, MHD_gnutls_x509_crq_t crq);
+  int MHD_gnutls_x509_crt_set_crq (MHD_gnutls_x509_crt_t crt,
+                                   MHD_gnutls_x509_crq_t crq);
 
 #ifdef __cplusplus
 }
@@ -605,65 +625,66 @@ typedef struct MHD_gtls_x509_privkey_int
 } MHD_gnutls_x509_privkey_int;
 
 int MHD_gnutls_x509_crt_get_issuer_dn_by_oid (MHD_gnutls_x509_crt_t cert,
-                                          const char *oid,
-                                          int indx,
-                                          unsigned int raw_flag,
-                                          void *buf, size_t * sizeof_buf);
+                                              const char *oid,
+                                              int indx,
+                                              unsigned int raw_flag,
+                                              void *buf, size_t * sizeof_buf);
 int MHD_gnutls_x509_crt_get_subject_alt_name (MHD_gnutls_x509_crt_t cert,
-                                          unsigned int seq,
-                                          void *ret,
-                                          size_t * ret_size,
-                                          unsigned int *critical);
+                                              unsigned int seq,
+                                              void *ret,
+                                              size_t * ret_size,
+                                              unsigned int *critical);
 int MHD_gnutls_x509_crt_get_dn_by_oid (MHD_gnutls_x509_crt_t cert,
-                                   const char *oid,
-                                   int indx,
-                                   unsigned int raw_flag,
-                                   void *buf, size_t * sizeof_buf);
+                                       const char *oid,
+                                       int indx,
+                                       unsigned int raw_flag,
+                                       void *buf, size_t * sizeof_buf);
 int MHD_gnutls_x509_crt_get_ca_status (MHD_gnutls_x509_crt_t cert,
-                                   unsigned int *critical);
+                                       unsigned int *critical);
 int MHD_gnutls_x509_crt_get_pk_algorithm (MHD_gnutls_x509_crt_t cert,
-                                      unsigned int *bits);
+                                          unsigned int *bits);
 
 int MHD_gnutls_x509_crt_get_serial (MHD_gnutls_x509_crt_t cert,
-                                void *result, size_t * result_size);
+                                    void *result, size_t * result_size);
 
 int MHD__gnutls_x509_compare_raw_dn (const MHD_gnutls_datum_t * dn1,
-                                 const MHD_gnutls_datum_t * dn2);
+                                     const MHD_gnutls_datum_t * dn2);
 
 int MHD_gnutls_x509_crt_check_revocation (MHD_gnutls_x509_crt_t cert,
-                                      const MHD_gnutls_x509_crl_t * crl_list,
-                                      int crl_list_length);
+                                          const MHD_gnutls_x509_crl_t *
+                                          crl_list, int crl_list_length);
 
-int MHD__gnutls_x509_crl_cpy (MHD_gnutls_x509_crl_t dest, MHD_gnutls_x509_crl_t src);
+int MHD__gnutls_x509_crl_cpy (MHD_gnutls_x509_crl_t dest,
+                              MHD_gnutls_x509_crl_t src);
 int MHD__gnutls_x509_crl_get_raw_issuer_dn (MHD_gnutls_x509_crl_t crl,
-                                        MHD_gnutls_datum_t * dn);
+                                            MHD_gnutls_datum_t * dn);
 int MHD_gnutls_x509_crl_get_crt_count (MHD_gnutls_x509_crl_t crl);
 int MHD_gnutls_x509_crl_get_crt_serial (MHD_gnutls_x509_crl_t crl,
-                                    int indx,
-                                    unsigned char *serial,
-                                    size_t * serial_size, time_t * t);
+                                        int indx,
+                                        unsigned char *serial,
+                                        size_t * serial_size, time_t * t);
 
 void MHD_gnutls_x509_crl_deinit (MHD_gnutls_x509_crl_t crl);
 int MHD_gnutls_x509_crl_init (MHD_gnutls_x509_crl_t * crl);
 int MHD_gnutls_x509_crl_import (MHD_gnutls_x509_crl_t crl,
-                            const MHD_gnutls_datum_t * data,
-                            MHD_gnutls_x509_crt_fmt_t format);
+                                const MHD_gnutls_datum_t * data,
+                                MHD_gnutls_x509_crt_fmt_t format);
 int MHD_gnutls_x509_crl_export (MHD_gnutls_x509_crl_t crl,
-                            MHD_gnutls_x509_crt_fmt_t format,
-                            void *output_data, size_t * output_data_size);
+                                MHD_gnutls_x509_crt_fmt_t format,
+                                void *output_data, size_t * output_data_size);
 
 int MHD_gnutls_x509_crt_init (MHD_gnutls_x509_crt_t * cert);
 void MHD_gnutls_x509_crt_deinit (MHD_gnutls_x509_crt_t cert);
 int MHD_gnutls_x509_crt_import (MHD_gnutls_x509_crt_t cert,
-                            const MHD_gnutls_datum_t * data,
-                            MHD_gnutls_x509_crt_fmt_t format);
+                                const MHD_gnutls_datum_t * data,
+                                MHD_gnutls_x509_crt_fmt_t format);
 int MHD_gnutls_x509_crt_export (MHD_gnutls_x509_crt_t cert,
-                            MHD_gnutls_x509_crt_fmt_t format,
-                            void *output_data, size_t * output_data_size);
+                                MHD_gnutls_x509_crt_fmt_t format,
+                                void *output_data, size_t * output_data_size);
 
 int MHD_gnutls_x509_crt_get_key_usage (MHD_gnutls_x509_crt_t cert,
-                                   unsigned int *key_usage,
-                                   unsigned int *critical);
+                                       unsigned int *key_usage,
+                                       unsigned int *critical);
 int MHD_gnutls_x509_crt_get_signature_algorithm (MHD_gnutls_x509_crt_t cert);
 int MHD_gnutls_x509_crt_get_version (MHD_gnutls_x509_crt_t cert);
 
@@ -671,30 +692,31 @@ int MHD_gnutls_x509_privkey_init (MHD_gnutls_x509_privkey_t * key);
 void MHD_gnutls_x509_privkey_deinit (MHD_gnutls_x509_privkey_t key);
 
 int MHD_gnutls_x509_privkey_generate (MHD_gnutls_x509_privkey_t key,
-                                  enum MHD_GNUTLS_PublicKeyAlgorithm algo,
-                                  unsigned int bits, unsigned int flags);
+                                      enum MHD_GNUTLS_PublicKeyAlgorithm algo,
+                                      unsigned int bits, unsigned int flags);
 
 int MHD_gnutls_x509_privkey_import (MHD_gnutls_x509_privkey_t key,
-                                const MHD_gnutls_datum_t * data,
-                                MHD_gnutls_x509_crt_fmt_t format);
+                                    const MHD_gnutls_datum_t * data,
+                                    MHD_gnutls_x509_crt_fmt_t format);
 int MHD_gnutls_x509_privkey_get_pk_algorithm (MHD_gnutls_x509_privkey_t key);
 int MHD_gnutls_x509_privkey_import_rsa_raw (MHD_gnutls_x509_privkey_t key,
-                                        const MHD_gnutls_datum_t * m,
-                                        const MHD_gnutls_datum_t * e,
-                                        const MHD_gnutls_datum_t * d,
-                                        const MHD_gnutls_datum_t * p,
-                                        const MHD_gnutls_datum_t * q,
-                                        const MHD_gnutls_datum_t * u);
+                                            const MHD_gnutls_datum_t * m,
+                                            const MHD_gnutls_datum_t * e,
+                                            const MHD_gnutls_datum_t * d,
+                                            const MHD_gnutls_datum_t * p,
+                                            const MHD_gnutls_datum_t * q,
+                                            const MHD_gnutls_datum_t * u);
 int MHD_gnutls_x509_privkey_export_rsa_raw (MHD_gnutls_x509_privkey_t key,
-                                        MHD_gnutls_datum_t * m,
-                                        MHD_gnutls_datum_t * e,
-                                        MHD_gnutls_datum_t * d,
-                                        MHD_gnutls_datum_t * p,
-                                        MHD_gnutls_datum_t * q,
-                                        MHD_gnutls_datum_t * u);
+                                            MHD_gnutls_datum_t * m,
+                                            MHD_gnutls_datum_t * e,
+                                            MHD_gnutls_datum_t * d,
+                                            MHD_gnutls_datum_t * p,
+                                            MHD_gnutls_datum_t * q,
+                                            MHD_gnutls_datum_t * u);
 int MHD_gnutls_x509_privkey_export (MHD_gnutls_x509_privkey_t key,
-                                MHD_gnutls_x509_crt_fmt_t format,
-                                void *output_data, size_t * output_data_size);
+                                    MHD_gnutls_x509_crt_fmt_t format,
+                                    void *output_data,
+                                    size_t * output_data_size);
 
 #define GNUTLS_CRL_REASON_UNUSED 128
 #define GNUTLS_CRL_REASON_KEY_COMPROMISE 64
diff --git a/src/daemon/https/x509/x509_privkey.c b/src/daemon/https/x509/x509_privkey.c
index 579ce664..d94a6a5d 100644
--- a/src/daemon/https/x509/x509_privkey.c
+++ b/src/daemon/https/x509/x509_privkey.c
@@ -104,7 +104,8 @@ MHD_gnutls_x509_privkey_deinit (MHD_gnutls_x509_privkey_t key)
  *
  **/
 int
-MHD_gnutls_x509_privkey_cpy (MHD_gnutls_x509_privkey_t dst, MHD_gnutls_x509_privkey_t src)
+MHD_gnutls_x509_privkey_cpy (MHD_gnutls_x509_privkey_t dst,
+                             MHD_gnutls_x509_privkey_t src)
 {
   int i, ret;
 
@@ -148,14 +149,14 @@ MHD_gnutls_x509_privkey_cpy (MHD_gnutls_x509_privkey_t dst, MHD_gnutls_x509_priv
  */
 ASN1_TYPE
 MHD__gnutls_privkey_decode_pkcs1_rsa_key (const MHD_gnutls_datum_t * raw_key,
-                                      MHD_gnutls_x509_privkey_t pkey)
+                                          MHD_gnutls_x509_privkey_t pkey)
 {
   int result;
   ASN1_TYPE pkey_asn;
 
   if ((result = MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (),
-                                     "GNUTLS.RSAPrivateKey",
-                                     &pkey_asn)) != ASN1_SUCCESS)
+                                          "GNUTLS.RSAPrivateKey",
+                                          &pkey_asn)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       return NULL;
@@ -168,43 +169,44 @@ MHD__gnutls_privkey_decode_pkcs1_rsa_key (const MHD_gnutls_datum_t * raw_key,
       return NULL;
     }
 
-  result = MHD__asn1_der_decoding (&pkey_asn, raw_key->data, raw_key->size, NULL);
+  result =
+    MHD__asn1_der_decoding (&pkey_asn, raw_key->data, raw_key->size, NULL);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       goto error;
     }
 
-  if ((result = MHD__gnutls_x509_read_int (pkey_asn, "modulus", &pkey->params[0]))
-      < 0)
+  if ((result =
+       MHD__gnutls_x509_read_int (pkey_asn, "modulus", &pkey->params[0])) < 0)
     {
       MHD_gnutls_assert ();
       goto error;
     }
 
   if ((result = MHD__gnutls_x509_read_int (pkey_asn, "publicExponent",
-                                       &pkey->params[1])) < 0)
+                                           &pkey->params[1])) < 0)
     {
       MHD_gnutls_assert ();
       goto error;
     }
 
   if ((result = MHD__gnutls_x509_read_int (pkey_asn, "privateExponent",
-                                       &pkey->params[2])) < 0)
+                                           &pkey->params[2])) < 0)
     {
       MHD_gnutls_assert ();
       goto error;
     }
 
-  if ((result = MHD__gnutls_x509_read_int (pkey_asn, "prime1", &pkey->params[3]))
-      < 0)
+  if ((result =
+       MHD__gnutls_x509_read_int (pkey_asn, "prime1", &pkey->params[3])) < 0)
     {
       MHD_gnutls_assert ();
       goto error;
     }
 
-  if ((result = MHD__gnutls_x509_read_int (pkey_asn, "prime2", &pkey->params[4]))
-      < 0)
+  if ((result =
+       MHD__gnutls_x509_read_int (pkey_asn, "prime2", &pkey->params[4])) < 0)
     {
       MHD_gnutls_assert ();
       goto error;
@@ -227,7 +229,7 @@ MHD__gnutls_privkey_decode_pkcs1_rsa_key (const MHD_gnutls_datum_t * raw_key,
   /* p, q */
 #else
   if ((result = MHD__gnutls_x509_read_int (pkey_asn, "coefficient",
-                                       &pkey->params[5])) < 0)
+                                           &pkey->params[5])) < 0)
     {
       MHD_gnutls_assert ();
       goto error;
@@ -267,8 +269,8 @@ error:MHD__asn1_delete_structure (&pkey_asn);
  **/
 int
 MHD_gnutls_x509_privkey_import (MHD_gnutls_x509_privkey_t key,
-                            const MHD_gnutls_datum_t * data,
-                            MHD_gnutls_x509_crt_fmt_t format)
+                                const MHD_gnutls_datum_t * data,
+                                MHD_gnutls_x509_crt_fmt_t format)
 {
   int result = 0, need_free = 0;
   MHD_gnutls_datum_t _data;
@@ -291,7 +293,9 @@ MHD_gnutls_x509_privkey_import (MHD_gnutls_x509_privkey_t key,
 
       /* Try the first header */
       result
-        = MHD__gnutls_fbase64_decode (PEM_KEY_RSA, data->data, data->size, &out);
+        =
+        MHD__gnutls_fbase64_decode (PEM_KEY_RSA, data->data, data->size,
+                                    &out);
       key->pk_algorithm = MHD_GNUTLS_PK_RSA;
 
       _data.data = out;
@@ -360,12 +364,12 @@ MHD_gnutls_x509_privkey_import (MHD_gnutls_x509_privkey_t key,
  **/
 int
 MHD_gnutls_x509_privkey_import_rsa_raw (MHD_gnutls_x509_privkey_t key,
-                                    const MHD_gnutls_datum_t * m,
-                                    const MHD_gnutls_datum_t * e,
-                                    const MHD_gnutls_datum_t * d,
-                                    const MHD_gnutls_datum_t * p,
-                                    const MHD_gnutls_datum_t * q,
-                                    const MHD_gnutls_datum_t * u)
+                                        const MHD_gnutls_datum_t * m,
+                                        const MHD_gnutls_datum_t * e,
+                                        const MHD_gnutls_datum_t * d,
+                                        const MHD_gnutls_datum_t * p,
+                                        const MHD_gnutls_datum_t * q,
+                                        const MHD_gnutls_datum_t * u)
 {
   int i = 0, ret;
   size_t siz = 0;
@@ -417,7 +421,8 @@ MHD_gnutls_x509_privkey_import_rsa_raw (MHD_gnutls_x509_privkey_t key,
     }
 
 #ifdef CALC_COEFF
-  key->params[5] = MHD__gnutls_mpi_snew (MHD__gnutls_mpi_get_nbits (key->params[0]));
+  key->params[5] =
+    MHD__gnutls_mpi_snew (MHD__gnutls_mpi_get_nbits (key->params[0]));
 
   if (key->params[5] == NULL)
     {
@@ -501,7 +506,7 @@ MHD__gnutls_asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params)
 
   /* Now generate exp1 and exp2
    */
-  exp1 = MHD__gnutls_mpi_salloc_like (params[0]);   /* like modulus */
+  exp1 = MHD__gnutls_mpi_salloc_like (params[0]);       /* like modulus */
   if (exp1 == NULL)
     {
       MHD_gnutls_assert ();
@@ -600,8 +605,8 @@ MHD__gnutls_asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params)
    */
 
   if ((result =
-       MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (), "GNUTLS.RSAPrivateKey",
-                            c2)) != ASN1_SUCCESS)
+       MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (),
+                                 "GNUTLS.RSAPrivateKey", c2)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       result = MHD_gtls_asn2err (result);
@@ -618,16 +623,18 @@ MHD__gnutls_asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params)
       goto cleanup;
     }
 
-  if ((result = MHD__asn1_write_value (*c2, "publicExponent", pube_data, size[1]))
-      != ASN1_SUCCESS)
+  if ((result =
+       MHD__asn1_write_value (*c2, "publicExponent", pube_data,
+                              size[1])) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  if ((result = MHD__asn1_write_value (*c2, "privateExponent", prie_data, size[2]))
-      != ASN1_SUCCESS)
+  if ((result =
+       MHD__asn1_write_value (*c2, "privateExponent", prie_data,
+                              size[2])) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       result = MHD_gtls_asn2err (result);
@@ -682,14 +689,15 @@ MHD__gnutls_asn1_encode_rsa (ASN1_TYPE * c2, mpi_t * params)
   MHD_gnutls_free (all_data);
 
   if ((result = MHD__asn1_write_value (*c2, "otherPrimeInfos",
-                                  NULL, 0)) != ASN1_SUCCESS)
+                                       NULL, 0)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  if ((result = MHD__asn1_write_value (*c2, "version", &null, 1)) != ASN1_SUCCESS)
+  if ((result =
+       MHD__asn1_write_value (*c2, "version", &null, 1)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       result = MHD_gtls_asn2err (result);
@@ -760,8 +768,8 @@ MHD__gnutls_asn1_encode_dsa (ASN1_TYPE * c2, mpi_t * params)
    */
 
   if ((result =
-       MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (), "GNUTLS.DSAPrivateKey",
-                            c2)) != ASN1_SUCCESS)
+       MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (),
+                                 "GNUTLS.DSAPrivateKey", c2)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       result = MHD_gtls_asn2err (result);
@@ -770,28 +778,32 @@ MHD__gnutls_asn1_encode_dsa (ASN1_TYPE * c2, mpi_t * params)
 
   /* Write PRIME
    */
-  if ((result = MHD__asn1_write_value (*c2, "p", p_data, size[0])) != ASN1_SUCCESS)
+  if ((result =
+       MHD__asn1_write_value (*c2, "p", p_data, size[0])) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  if ((result = MHD__asn1_write_value (*c2, "q", q_data, size[1])) != ASN1_SUCCESS)
+  if ((result =
+       MHD__asn1_write_value (*c2, "q", q_data, size[1])) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  if ((result = MHD__asn1_write_value (*c2, "g", g_data, size[2])) != ASN1_SUCCESS)
+  if ((result =
+       MHD__asn1_write_value (*c2, "g", g_data, size[2])) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       result = MHD_gtls_asn2err (result);
       goto cleanup;
     }
 
-  if ((result = MHD__asn1_write_value (*c2, "Y", y_data, size[3])) != ASN1_SUCCESS)
+  if ((result =
+       MHD__asn1_write_value (*c2, "Y", y_data, size[3])) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       result = MHD_gtls_asn2err (result);
@@ -808,7 +820,8 @@ MHD__gnutls_asn1_encode_dsa (ASN1_TYPE * c2, mpi_t * params)
 
   MHD_gnutls_free (all_data);
 
-  if ((result = MHD__asn1_write_value (*c2, "version", &null, 1)) != ASN1_SUCCESS)
+  if ((result =
+       MHD__asn1_write_value (*c2, "version", &null, 1)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       result = MHD_gtls_asn2err (result);
@@ -822,4 +835,3 @@ cleanup:MHD__asn1_delete_structure (c2);
 
   return result;
 }
-
diff --git a/src/daemon/https/x509/x509_verify.c b/src/daemon/https/x509/x509_verify.c
index c85aa52e..35513810 100644
--- a/src/daemon/https/x509/x509_verify.c
+++ b/src/daemon/https/x509/x509_verify.c
@@ -42,20 +42,21 @@
 #include <verify.h>
 
 static int MHD__gnutls_verify_certificate2 (MHD_gnutls_x509_crt_t cert,
-                                        const MHD_gnutls_x509_crt_t * trusted_cas,
-                                        int tcas_size,
-                                        unsigned int flags,
-                                        unsigned int *output);
+                                            const MHD_gnutls_x509_crt_t *
+                                            trusted_cas, int tcas_size,
+                                            unsigned int flags,
+                                            unsigned int *output);
 int MHD__gnutls_x509_verify_signature (const MHD_gnutls_datum_t * signed_data,
-                                   const MHD_gnutls_datum_t * signature,
-                                   MHD_gnutls_x509_crt_t issuer);
+                                       const MHD_gnutls_datum_t * signature,
+                                       MHD_gnutls_x509_crt_t issuer);
 
 static
-  int is_crl_issuer (MHD_gnutls_x509_crl_t crl, MHD_gnutls_x509_crt_t issuer_cert);
+  int is_crl_issuer (MHD_gnutls_x509_crl_t crl,
+                     MHD_gnutls_x509_crt_t issuer_cert);
 static int MHD__gnutls_verify_crl2 (MHD_gnutls_x509_crl_t crl,
-                                const MHD_gnutls_x509_crt_t * trusted_cas,
-                                int tcas_size,
-                                unsigned int flags, unsigned int *output);
+                                    const MHD_gnutls_x509_crt_t * trusted_cas,
+                                    int tcas_size, unsigned int flags,
+                                    unsigned int *output);
 
 /* Checks if the issuer of a certificate is a
  * Certificate Authority, or if the certificate is the same
@@ -88,7 +89,7 @@ check_if_ca (MHD_gnutls_x509_crt_t cert,
    */
 
   result = MHD__gnutls_x509_get_signed_data (issuer->cert, "tbsCertificate",
-                                         &issuer_signed_data);
+                                             &issuer_signed_data);
   if (result < 0)
     {
       MHD_gnutls_assert ();
@@ -96,7 +97,7 @@ check_if_ca (MHD_gnutls_x509_crt_t cert,
     }
 
   result = MHD__gnutls_x509_get_signed_data (cert->cert, "tbsCertificate",
-                                         &cert_signed_data);
+                                             &cert_signed_data);
   if (result < 0)
     {
       MHD_gnutls_assert ();
@@ -104,7 +105,7 @@ check_if_ca (MHD_gnutls_x509_crt_t cert,
     }
 
   result = MHD__gnutls_x509_get_signature (issuer->cert, "signature",
-                                       &issuer_signature);
+                                           &issuer_signature);
   if (result < 0)
     {
       MHD_gnutls_assert ();
@@ -228,9 +229,9 @@ find_issuer (MHD_gnutls_x509_crt_t cert,
  */
 static int
 MHD__gnutls_verify_certificate2 (MHD_gnutls_x509_crt_t cert,
-                             const MHD_gnutls_x509_crt_t * trusted_cas,
-                             int tcas_size,
-                             unsigned int flags, unsigned int *output)
+                                 const MHD_gnutls_x509_crt_t * trusted_cas,
+                                 int tcas_size,
+                                 unsigned int flags, unsigned int *output)
 {
   MHD_gnutls_datum_t cert_signed_data = { NULL,
     0
@@ -287,7 +288,7 @@ MHD__gnutls_verify_certificate2 (MHD_gnutls_x509_crt_t cert,
     }
 
   result = MHD__gnutls_x509_get_signed_data (cert->cert, "tbsCertificate",
-                                         &cert_signed_data);
+                                             &cert_signed_data);
   if (result < 0)
     {
       MHD_gnutls_assert ();
@@ -303,7 +304,7 @@ MHD__gnutls_verify_certificate2 (MHD_gnutls_x509_crt_t cert,
     }
 
   ret = MHD__gnutls_x509_verify_signature (&cert_signed_data, &cert_signature,
-                                       issuer);
+                                           issuer);
   if (ret < 0)
     {
       MHD_gnutls_assert ();
@@ -360,7 +361,7 @@ cleanup:MHD__gnutls_free_datum (&cert_signed_data);
  **/
 int
 MHD_gnutls_x509_crt_check_issuer (MHD_gnutls_x509_crt_t cert,
-                              MHD_gnutls_x509_crt_t issuer)
+                                  MHD_gnutls_x509_crt_t issuer)
 {
   return is_issuer (cert, issuer);
 }
@@ -377,12 +378,12 @@ MHD_gnutls_x509_crt_check_issuer (MHD_gnutls_x509_crt_t cert,
  * lead to a trusted CA in order to be trusted.
  */
 static unsigned int
-MHD__gnutls_x509_verify_certificate (const MHD_gnutls_x509_crt_t * certificate_list,
-                                 int clist_size,
-                                 const MHD_gnutls_x509_crt_t * trusted_cas,
-                                 int tcas_size,
-                                 const MHD_gnutls_x509_crl_t * CRLs,
-                                 int crls_size, unsigned int flags)
+MHD__gnutls_x509_verify_certificate (const MHD_gnutls_x509_crt_t *
+                                     certificate_list, int clist_size,
+                                     const MHD_gnutls_x509_crt_t *
+                                     trusted_cas, int tcas_size,
+                                     const MHD_gnutls_x509_crl_t * CRLs,
+                                     int crls_size, unsigned int flags)
 {
   int i = 0, ret;
   unsigned int status = 0, output;
@@ -394,7 +395,8 @@ MHD__gnutls_x509_verify_certificate (const MHD_gnutls_x509_crt_t * certificate_l
    * in self signed etc certificates.
    */
   ret = MHD__gnutls_verify_certificate2 (certificate_list[clist_size - 1],
-                                     trusted_cas, tcas_size, flags, &output);
+                                         trusted_cas, tcas_size, flags,
+                                         &output);
 
   if (ret == 0)
     {
@@ -414,7 +416,7 @@ MHD__gnutls_x509_verify_certificate (const MHD_gnutls_x509_crt_t * certificate_l
   for (i = 0; i < clist_size; i++)
     {
       ret = MHD_gnutls_x509_crt_check_revocation (certificate_list[i],
-                                              CRLs, crls_size);
+                                                  CRLs, crls_size);
       if (ret == 1)
         {                       /* revoked */
           status |= GNUTLS_CERT_REVOKED;
@@ -429,7 +431,7 @@ MHD__gnutls_x509_verify_certificate (const MHD_gnutls_x509_crt_t * certificate_l
    * leads to a trusted party by us, not the server's).
    */
   if (MHD_gnutls_x509_crt_check_issuer (certificate_list[clist_size - 1],
-                                    certificate_list[clist_size - 1]) > 0
+                                        certificate_list[clist_size - 1]) > 0
       && clist_size > 0)
     {
       clist_size--;
@@ -448,8 +450,8 @@ MHD__gnutls_x509_verify_certificate (const MHD_gnutls_x509_crt_t * certificate_l
       if (!(flags & GNUTLS_VERIFY_ALLOW_ANY_X509_V1_CA_CRT))
         flags ^= GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT;
       if ((ret = MHD__gnutls_verify_certificate2 (certificate_list[i - 1],
-                                              &certificate_list[i], 1, flags,
-                                              NULL)) == 0)
+                                                  &certificate_list[i], 1,
+                                                  flags, NULL)) == 0)
         {
           status |= GNUTLS_CERT_INVALID;
           return status;
@@ -474,8 +476,8 @@ decode_ber_digest_info (const MHD_gnutls_datum_t * info,
   int len;
 
   if ((result = MHD__asn1_create_element (MHD__gnutls_getMHD__gnutls_asn (),
-                                     "GNUTLS.DigestInfo",
-                                     &dinfo)) != ASN1_SUCCESS)
+                                          "GNUTLS.DigestInfo",
+                                          &dinfo)) != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
       return MHD_gtls_asn2err (result);
@@ -490,7 +492,8 @@ decode_ber_digest_info (const MHD_gnutls_datum_t * info,
     }
 
   len = sizeof (str) - 1;
-  result = MHD__asn1_read_value (dinfo, "digestAlgorithm.algorithm", str, &len);
+  result =
+    MHD__asn1_read_value (dinfo, "digestAlgorithm.algorithm", str, &len);
   if (result != ASN1_SUCCESS)
     {
       MHD_gnutls_assert ();
@@ -511,7 +514,8 @@ decode_ber_digest_info (const MHD_gnutls_datum_t * info,
     }
 
   len = sizeof (str) - 1;
-  result = MHD__asn1_read_value (dinfo, "digestAlgorithm.parameters", str, &len);
+  result =
+    MHD__asn1_read_value (dinfo, "digestAlgorithm.parameters", str, &len);
   /* To avoid permitting garbage in the parameters field, either the
      parameters field is not present, or it contains 0x05 0x00. */
   if (!
@@ -640,8 +644,8 @@ verify_sig (const MHD_gnutls_datum_t * tbs,
  */
 int
 MHD__gnutls_x509_verify_signature (const MHD_gnutls_datum_t * tbs,
-                               const MHD_gnutls_datum_t * signature,
-                               MHD_gnutls_x509_crt_t issuer)
+                                   const MHD_gnutls_datum_t * signature,
+                                   MHD_gnutls_x509_crt_t issuer)
 {
   mpi_t issuer_params[MAX_PUBLIC_PARAMS_SIZE];
   int ret, issuer_params_size, i;
@@ -650,16 +654,18 @@ MHD__gnutls_x509_verify_signature (const MHD_gnutls_datum_t * tbs,
    */
   issuer_params_size = MAX_PUBLIC_PARAMS_SIZE;
   ret =
-    MHD__gnutls_x509_crt_get_mpis (issuer, issuer_params, &issuer_params_size);
+    MHD__gnutls_x509_crt_get_mpis (issuer, issuer_params,
+                                   &issuer_params_size);
   if (ret < 0)
     {
       MHD_gnutls_assert ();
       return ret;
     }
 
-  ret = verify_sig (tbs, signature, MHD_gnutls_x509_crt_get_pk_algorithm (issuer,
-                                                                      NULL),
-                    issuer_params, issuer_params_size);
+  ret =
+    verify_sig (tbs, signature,
+                MHD_gnutls_x509_crt_get_pk_algorithm (issuer, NULL),
+                issuer_params, issuer_params_size);
   if (ret < 0)
     {
       MHD_gnutls_assert ();
@@ -683,8 +689,9 @@ MHD__gnutls_x509_verify_signature (const MHD_gnutls_datum_t * tbs,
  */
 int
 MHD__gnutls_x509_privkey_verify_signature (const MHD_gnutls_datum_t * tbs,
-                                       const MHD_gnutls_datum_t * signature,
-                                       MHD_gnutls_x509_privkey_t issuer)
+                                           const MHD_gnutls_datum_t *
+                                           signature,
+                                           MHD_gnutls_x509_privkey_t issuer)
 {
   int ret;
 
@@ -734,12 +741,12 @@ MHD__gnutls_x509_privkey_verify_signature (const MHD_gnutls_datum_t * tbs,
  **/
 int
 MHD_gnutls_x509_crt_list_verify (const MHD_gnutls_x509_crt_t * cert_list,
-                             int cert_list_length,
-                             const MHD_gnutls_x509_crt_t * CA_list,
-                             int CA_list_length,
-                             const MHD_gnutls_x509_crl_t * CRL_list,
-                             int CRL_list_length,
-                             unsigned int flags, unsigned int *verify)
+                                 int cert_list_length,
+                                 const MHD_gnutls_x509_crt_t * CA_list,
+                                 int CA_list_length,
+                                 const MHD_gnutls_x509_crl_t * CRL_list,
+                                 int CRL_list_length,
+                                 unsigned int flags, unsigned int *verify)
 {
   if (cert_list == NULL || cert_list_length == 0)
     return GNUTLS_E_NO_CERTIFICATE_FOUND;
@@ -747,9 +754,9 @@ MHD_gnutls_x509_crt_list_verify (const MHD_gnutls_x509_crt_t * cert_list,
   /* Verify certificate
    */
   *verify = MHD__gnutls_x509_verify_certificate (cert_list, cert_list_length,
-                                             CA_list, CA_list_length,
-                                             CRL_list, CRL_list_length,
-                                             flags);
+                                                 CA_list, CA_list_length,
+                                                 CRL_list, CRL_list_length,
+                                                 flags);
 
   return 0;
 }
@@ -770,15 +777,15 @@ MHD_gnutls_x509_crt_list_verify (const MHD_gnutls_x509_crt_t * cert_list,
  **/
 int
 MHD_gnutls_x509_crt_verify (MHD_gnutls_x509_crt_t cert,
-                        const MHD_gnutls_x509_crt_t * CA_list,
-                        int CA_list_length,
-                        unsigned int flags, unsigned int *verify)
+                            const MHD_gnutls_x509_crt_t * CA_list,
+                            int CA_list_length,
+                            unsigned int flags, unsigned int *verify)
 {
   int ret;
   /* Verify certificate
    */
   ret = MHD__gnutls_verify_certificate2 (cert, CA_list, CA_list_length, flags,
-                                     verify);
+                                         verify);
   if (ret < 0)
     {
       MHD_gnutls_assert ();
@@ -804,7 +811,7 @@ MHD_gnutls_x509_crt_verify (MHD_gnutls_x509_crt_t cert,
  **/
 int
 MHD_gnutls_x509_crl_check_issuer (MHD_gnutls_x509_crl_t cert,
-                              MHD_gnutls_x509_crt_t issuer)
+                                  MHD_gnutls_x509_crt_t issuer)
 {
   return is_crl_issuer (cert, issuer);
 }
@@ -826,9 +833,9 @@ MHD_gnutls_x509_crl_check_issuer (MHD_gnutls_x509_crl_t cert,
  **/
 int
 MHD_gnutls_x509_crl_verify (MHD_gnutls_x509_crl_t crl,
-                        const MHD_gnutls_x509_crt_t * CA_list,
-                        int CA_list_length, unsigned int flags,
-                        unsigned int *verify)
+                            const MHD_gnutls_x509_crt_t * CA_list,
+                            int CA_list_length, unsigned int flags,
+                            unsigned int *verify)
 {
   int ret;
   /* Verify crl
@@ -906,8 +913,9 @@ find_crl_issuer (MHD_gnutls_x509_crl_t crl,
  */
 static int
 MHD__gnutls_verify_crl2 (MHD_gnutls_x509_crl_t crl,
-                     const MHD_gnutls_x509_crt_t * trusted_cas,
-                     int tcas_size, unsigned int flags, unsigned int *output)
+                         const MHD_gnutls_x509_crt_t * trusted_cas,
+                         int tcas_size, unsigned int flags,
+                         unsigned int *output)
 {
   /* CRL is ignored for now */
   MHD_gnutls_datum_t crl_signed_data = { NULL, 0 };
@@ -951,14 +959,16 @@ MHD__gnutls_verify_crl2 (MHD_gnutls_x509_crl_t crl,
     }
 
   result =
-    MHD__gnutls_x509_get_signed_data (crl->crl, "tbsCertList", &crl_signed_data);
+    MHD__gnutls_x509_get_signed_data (crl->crl, "tbsCertList",
+                                      &crl_signed_data);
   if (result < 0)
     {
       MHD_gnutls_assert ();
       goto cleanup;
     }
 
-  result = MHD__gnutls_x509_get_signature (crl->crl, "signature", &crl_signature);
+  result =
+    MHD__gnutls_x509_get_signature (crl->crl, "signature", &crl_signature);
   if (result < 0)
     {
       MHD_gnutls_assert ();
@@ -966,7 +976,8 @@ MHD__gnutls_verify_crl2 (MHD_gnutls_x509_crl_t crl,
     }
 
   ret =
-    MHD__gnutls_x509_verify_signature (&crl_signed_data, &crl_signature, issuer);
+    MHD__gnutls_x509_verify_signature (&crl_signed_data, &crl_signature,
+                                       issuer);
   if (ret < 0)
     {
       MHD_gnutls_assert ();