indentation

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;

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;
 

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;

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 */
 };

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);
 }

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);

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;
         }
 

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;
         }
 

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;

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;

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;

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.
        */

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);
 

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;
 }

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);
 }
 
 

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;

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 ();

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);

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)

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);

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;

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;

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);

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;

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)
     {

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);

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)

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;
 

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)
         {

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;
 }

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));
 
         }
     }

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

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);

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);
 

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;

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 *

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;

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;

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);

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;

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);

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);
 }
-

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);
-

src/daemon/https/tls/gnutls_session.c

@@ -69,4 +69,3 @@ MHD_gtls_session_get_id (MHD_gtls_session_t session,
 
   return 0;
 }
-

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;
 }

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
     {

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

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;
 }

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

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

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)

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);

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;
 }

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;
 

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);

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;
 }
-

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)))