17 files changed, 154 insertions, 111 deletions

diff --git a/src/daemon/https/lgl/des.c b/src/daemon/https/lgl/des.c
index 7bc4c4d0..dbe5f3c6 100644
--- a/src/daemon/https/lgl/des.c
+++ b/src/daemon/https/lgl/des.c
@@ -543,7 +543,8 @@ MHD_gl_des_makekey (MHD_gl_des_ctx * ctx, const char *key, size_t keylen)
 }
 
 void
-MHD_gl_des_ecb_crypt (MHD_gl_des_ctx * ctx, const char *_from, char *_to, int mode)
+MHD_gl_des_ecb_crypt (MHD_gl_des_ctx * ctx, const char *_from, char *_to,
+                      int mode)
 {
   const unsigned char *from = (const unsigned char *) _from;
   unsigned char *to = (unsigned char *) _to;
@@ -565,7 +566,8 @@ READ_64BIT_DATA (from, left, right)
     FINAL_PERMUTATION (right, work, left) WRITE_64BIT_DATA (to, right, left)}
 
 void
-MHD_gl_3des_set2keys (MHD_gl_3des_ctx * ctx, const char *key1, const char *key2)
+MHD_gl_3des_set2keys (MHD_gl_3des_ctx * ctx, const char *key1,
+                      const char *key2)
 {
   int i;
 
@@ -590,7 +592,7 @@ MHD_gl_3des_set2keys (MHD_gl_3des_ctx * ctx, const char *key1, const char *key2)
 
 void
 MHD_gl_3des_set3keys (MHD_gl_3des_ctx * ctx, const char *key1,
-                  const char *key2, const char *key3)
+                      const char *key2, const char *key3)
 {
   int i;
 
@@ -612,7 +614,8 @@ MHD_gl_3des_set3keys (MHD_gl_3des_ctx * ctx, const char *key1,
 }
 
 void
-MHD_gl_3des_ecb_crypt (MHD_gl_3des_ctx * ctx, const char *_from, char *_to, int mode)
+MHD_gl_3des_ecb_crypt (MHD_gl_3des_ctx * ctx, const char *_from, char *_to,
+                       int mode)
 {
   const unsigned char *from = (const unsigned char *) _from;
   unsigned char *to = (unsigned char *) _to;
@@ -658,5 +661,6 @@ MHD_gl_3des_makekey (MHD_gl_3des_ctx * ctx, const char *key, size_t keylen)
   MHD_gl_3des_set3keys (ctx, key, key + 8, key + 16);
 
   return !(MHD_gl_des_is_weak_key (key)
-           || MHD_gl_des_is_weak_key (key + 8) || MHD_gl_des_is_weak_key (key + 16));
+           || MHD_gl_des_is_weak_key (key + 8)
+           || MHD_gl_des_is_weak_key (key + 16));
 }
diff --git a/src/daemon/https/lgl/des.h b/src/daemon/https/lgl/des.h
index 4d9eb20c..d2ad058e 100644
--- a/src/daemon/https/lgl/des.h
+++ b/src/daemon/https/lgl/des.h
@@ -62,12 +62,14 @@ extern void MHD_gl_des_setkey (MHD_gl_des_ctx * ctx, const char *key);
 /* Fill a DES context CTX with subkeys calculated from 64bit KEY, with
  * weak key checking.  Does not check parity bits, but simply ignore
  * them. */
-extern bool MHD_gl_des_makekey (MHD_gl_des_ctx * ctx, const char *key, size_t keylen);
+extern bool MHD_gl_des_makekey (MHD_gl_des_ctx * ctx, const char *key,
+                                size_t keylen);
 
 /* Electronic Codebook Mode DES encryption/decryption of data
  * according to 'mode'. */
 extern void
-MHD_gl_des_ecb_crypt (MHD_gl_des_ctx * ctx, const char *from, char *to, int mode);
+MHD_gl_des_ecb_crypt (MHD_gl_des_ctx * ctx, const char *from, char *to,
+                      int mode);
 
 #define MHD_gl_des_ecb_encrypt(ctx, from, to)  MHD_gl_des_ecb_crypt(ctx, from, to, 0)
 #define MHD_gl_des_ecb_decrypt(ctx, from, to)  MHD_gl_des_ecb_crypt(ctx, from, to, 1)
@@ -80,7 +82,8 @@ MHD_gl_des_ecb_crypt (MHD_gl_des_ctx * ctx, const char *from, char *to, int mode
  * 64bit keys in KEY1 and KEY2.  Does not check the parity bits of the
  * keys, but simply ignore them.  Does not check for weak keys. */
 extern void
-MHD_gl_3des_set2keys (MHD_gl_3des_ctx * ctx, const char *key1, const char *key2);
+MHD_gl_3des_set2keys (MHD_gl_3des_ctx * ctx, const char *key1,
+                      const char *key2);
 
 /*
  * Fill a Triple-DES context CTX with subkeys calculated from three
@@ -89,7 +92,7 @@ MHD_gl_3des_set2keys (MHD_gl_3des_ctx * ctx, const char *key1, const char *key2)
  * keys. */
 extern void
 MHD_gl_3des_set3keys (MHD_gl_3des_ctx * ctx,
-                  const char *key1, const char *key2, const char *key3);
+                      const char *key1, const char *key2, const char *key3);
 
 /* Fill a Triple-DES context CTX with subkeys calculated from three
  * concatenated 64bit keys in KEY, with weak key checking.  Does not
@@ -101,7 +104,8 @@ MHD_gl_3des_makekey (MHD_gl_3des_ctx * ctx, const char *key, size_t keylen);
  * according to 'mode'.  Sometimes this mode is named 'EDE' mode
  * (Encryption-Decryption-Encryption). */
 extern void
-MHD_gl_3des_ecb_crypt (MHD_gl_3des_ctx * ctx, const char *from, char *to, int mode);
+MHD_gl_3des_ecb_crypt (MHD_gl_3des_ctx * ctx, const char *from, char *to,
+                       int mode);
 
 #define MHD_gl_3des_ecb_encrypt(ctx, from, to) MHD_gl_3des_ecb_crypt(ctx,from,to,0)
 #define MHD_gl_3des_ecb_decrypt(ctx, from, to) MHD_gl_3des_ecb_crypt(ctx,from,to,1)
diff --git a/src/daemon/https/lgl/gc-gnulib.c b/src/daemon/https/lgl/gc-gnulib.c
index 7c16d443..52fce18b 100644
--- a/src/daemon/https/lgl/gc-gnulib.c
+++ b/src/daemon/https/lgl/gc-gnulib.c
@@ -161,9 +161,9 @@ MHD_gc_random (char *data, size_t datalen)
 /* Memory allocation. */
 void
 MHD_gc_set_allocators (MHD_gc_malloc_t func_malloc,
-                   MHD_gc_malloc_t secure_malloc,
-                   MHD_gc_secure_check_t secure_check,
-                   MHD_gc_realloc_t func_realloc, MHD_gc_free_t func_free)
+                       MHD_gc_malloc_t secure_malloc,
+                       MHD_gc_secure_check_t secure_check,
+                       MHD_gc_realloc_t func_realloc, MHD_gc_free_t func_free)
 {
   return;
 }
@@ -193,7 +193,7 @@ typedef struct _MHD_gc_cipher_ctx
 
 Gc_rc
 MHD_gc_cipher_open (Gc_cipher alg,
-                Gc_cipher_mode mode, MHD_gc_cipher_handle * outhandle)
+                    Gc_cipher_mode mode, MHD_gc_cipher_handle * outhandle)
 {
   _MHD_gc_cipher_ctx *ctx;
   Gc_rc rc = GC_OK;
@@ -277,7 +277,8 @@ MHD_gc_cipher_open (Gc_cipher alg,
 }
 
 Gc_rc
-MHD_gc_cipher_setkey (MHD_gc_cipher_handle handle, size_t keylen, const char *key)
+MHD_gc_cipher_setkey (MHD_gc_cipher_handle handle, size_t keylen,
+                      const char *key)
 {
   _MHD_gc_cipher_ctx *ctx = handle;
 
@@ -317,16 +318,18 @@ MHD_gc_cipher_setkey (MHD_gc_cipher_handle handle, size_t keylen, const char *ke
           sprintf (&keyMaterial[2 * i], "%02x", key[i] & 0xFF);
 
         rc = MHD_rijndaelMakeKey (&ctx->aesEncKey, RIJNDAEL_DIR_ENCRYPT,
-                              keylen * 8, keyMaterial);
+                                  keylen * 8, keyMaterial);
         if (rc < 0)
           return GC_INVALID_CIPHER;
 
         rc = MHD_rijndaelMakeKey (&ctx->aesDecKey, RIJNDAEL_DIR_DECRYPT,
-                              keylen * 8, keyMaterial);
+                                  keylen * 8, keyMaterial);
         if (rc < 0)
           return GC_INVALID_CIPHER;
 
-        rc = MHD_MHD_rijndaelCipherInit (&ctx->aesContext, RIJNDAEL_MODE_ECB, NULL);
+        rc =
+          MHD_MHD_rijndaelCipherInit (&ctx->aesContext, RIJNDAEL_MODE_ECB,
+                                      NULL);
         if (rc < 0)
           return GC_INVALID_CIPHER;
       }
@@ -341,7 +344,8 @@ MHD_gc_cipher_setkey (MHD_gc_cipher_handle handle, size_t keylen, const char *ke
 }
 
 Gc_rc
-MHD_gc_cipher_setiv (MHD_gc_cipher_handle handle, size_t ivlen, const char *iv)
+MHD_gc_cipher_setiv (MHD_gc_cipher_handle handle, size_t ivlen,
+                     const char *iv)
 {
   _MHD_gc_cipher_ctx *ctx = handle;
 
@@ -374,8 +378,9 @@ MHD_gc_cipher_setiv (MHD_gc_cipher_handle handle, size_t ivlen, const char *iv)
             for (i = 0; i < ivlen; i++)
               sprintf (&ivMaterial[2 * i], "%02x", iv[i] & 0xFF);
 
-            rc = MHD_MHD_rijndaelCipherInit (&ctx->aesContext, RIJNDAEL_MODE_CBC,
-                                     ivMaterial);
+            rc =
+              MHD_MHD_rijndaelCipherInit (&ctx->aesContext, RIJNDAEL_MODE_CBC,
+                                          ivMaterial);
             if (rc < 0)
               return GC_INVALID_CIPHER;
           }
@@ -395,7 +400,8 @@ MHD_gc_cipher_setiv (MHD_gc_cipher_handle handle, size_t ivlen, const char *iv)
 }
 
 Gc_rc
-MHD_gc_cipher_encrypt_inline (MHD_gc_cipher_handle handle, size_t len, char *data)
+MHD_gc_cipher_encrypt_inline (MHD_gc_cipher_handle handle, size_t len,
+                              char *data)
 {
   _MHD_gc_cipher_ctx *ctx = handle;
 
@@ -450,7 +456,7 @@ MHD_gc_cipher_encrypt_inline (MHD_gc_cipher_handle handle, size_t len, char *dat
         int nblocks;
 
         nblocks = MHD_rijndaelBlockEncrypt (&ctx->aesContext, &ctx->aesEncKey,
-                                        data, 8 * len, data);
+                                            data, 8 * len, data);
         if (nblocks < 0)
           return GC_INVALID_CIPHER;
       }
@@ -465,7 +471,8 @@ MHD_gc_cipher_encrypt_inline (MHD_gc_cipher_handle handle, size_t len, char *dat
 }
 
 Gc_rc
-MHD_gc_cipher_decrypt_inline (MHD_gc_cipher_handle handle, size_t len, char *data)
+MHD_gc_cipher_decrypt_inline (MHD_gc_cipher_handle handle, size_t len,
+                              char *data)
 {
   _MHD_gc_cipher_ctx *ctx = handle;
 
@@ -522,7 +529,7 @@ MHD_gc_cipher_decrypt_inline (MHD_gc_cipher_handle handle, size_t len, char *dat
         int nblocks;
 
         nblocks = MHD_rijndaelBlockDecrypt (&ctx->aesContext, &ctx->aesDecKey,
-                                        data, 8 * len, data);
+                                            data, 8 * len, data);
         if (nblocks < 0)
           return GC_INVALID_CIPHER;
       }
@@ -565,7 +572,8 @@ typedef struct _MHD_gc_hash_ctx
 } _MHD_gc_hash_ctx;
 
 Gc_rc
-MHD_gc_hash_open (Gc_hash hash, Gc_hash_mode mode, MHD_gc_hash_handle * outhandle)
+MHD_gc_hash_open (Gc_hash hash, Gc_hash_mode mode,
+                  MHD_gc_hash_handle * outhandle)
 {
   _MHD_gc_hash_ctx *ctx;
   Gc_rc rc = GC_OK;
@@ -769,7 +777,7 @@ MHD_gc_sha1 (const void *in, size_t inlen, void *resbuf)
 #ifdef GNULIB_GC_HMAC_MD5
 Gc_rc
 MHD_gc_MHD_hmac_md5 (const void *key, size_t keylen,
-             const void *in, size_t inlen, char *resbuf)
+                     const void *in, size_t inlen, char *resbuf)
 {
   MHD_hmac_md5 (key, keylen, in, inlen, resbuf);
   return GC_OK;
@@ -779,7 +787,8 @@ MHD_gc_MHD_hmac_md5 (const void *key, size_t keylen,
 #ifdef GNULIB_GC_HMAC_SHA1
 Gc_rc
 MHD_gc_MHD_hmac_sha1 (const void *key,
-              size_t keylen, const void *in, size_t inlen, char *resbuf)
+                      size_t keylen, const void *in, size_t inlen,
+                      char *resbuf)
 {
   MHD_hmac_sha1 (key, keylen, in, inlen, resbuf);
   return GC_OK;
diff --git a/src/daemon/https/lgl/gc-libgcrypt.c b/src/daemon/https/lgl/gc-libgcrypt.c
index a51a7bb4..e4429bd2 100644
--- a/src/daemon/https/lgl/gc-libgcrypt.c
+++ b/src/daemon/https/lgl/gc-libgcrypt.c
@@ -90,9 +90,9 @@ MHD_gc_random (char *data, size_t datalen)
 
 void
 MHD_gc_set_allocators (MHD_gc_malloc_t func_malloc,
-                   MHD_gc_malloc_t secure_malloc,
-                   MHD_gc_secure_check_t secure_check,
-                   MHD_gc_realloc_t func_realloc, MHD_gc_free_t func_free)
+                       MHD_gc_malloc_t secure_malloc,
+                       MHD_gc_secure_check_t secure_check,
+                       MHD_gc_realloc_t func_realloc, MHD_gc_free_t func_free)
 {
   gcry_set_allocation_handler (func_malloc, secure_malloc, secure_check,
                                func_realloc, func_free);
@@ -102,7 +102,7 @@ MHD_gc_set_allocators (MHD_gc_malloc_t func_malloc,
 
 Gc_rc
 MHD_gc_cipher_open (Gc_cipher alg,
-                Gc_cipher_mode mode, MHD_gc_cipher_handle * outhandle)
+                    Gc_cipher_mode mode, MHD_gc_cipher_handle * outhandle)
 {
   int gcryalg, gcrymode;
   gcry_error_t err;
@@ -179,7 +179,8 @@ MHD_gc_cipher_open (Gc_cipher alg,
 }
 
 Gc_rc
-MHD_gc_cipher_setkey (MHD_gc_cipher_handle handle, size_t keylen, const char *key)
+MHD_gc_cipher_setkey (MHD_gc_cipher_handle handle, size_t keylen,
+                      const char *key)
 {
   gcry_error_t err;
 
@@ -191,7 +192,8 @@ MHD_gc_cipher_setkey (MHD_gc_cipher_handle handle, size_t keylen, const char *ke
 }
 
 Gc_rc
-MHD_gc_cipher_setiv (MHD_gc_cipher_handle handle, size_t ivlen, const char *iv)
+MHD_gc_cipher_setiv (MHD_gc_cipher_handle handle, size_t ivlen,
+                     const char *iv)
 {
   gcry_error_t err;
 
@@ -203,7 +205,8 @@ MHD_gc_cipher_setiv (MHD_gc_cipher_handle handle, size_t ivlen, const char *iv)
 }
 
 Gc_rc
-MHD_gc_cipher_encrypt_inline (MHD_gc_cipher_handle handle, size_t len, char *data)
+MHD_gc_cipher_encrypt_inline (MHD_gc_cipher_handle handle, size_t len,
+                              char *data)
 {
   if (gcry_cipher_encrypt ((gcry_cipher_hd_t) handle, data, len, NULL, len) !=
       0)
@@ -213,7 +216,8 @@ MHD_gc_cipher_encrypt_inline (MHD_gc_cipher_handle handle, size_t len, char *dat
 }
 
 Gc_rc
-MHD_gc_cipher_decrypt_inline (MHD_gc_cipher_handle handle, size_t len, char *data)
+MHD_gc_cipher_decrypt_inline (MHD_gc_cipher_handle handle, size_t len,
+                              char *data)
 {
   if (gcry_cipher_decrypt ((gcry_cipher_hd_t) handle, data, len, NULL, len) !=
       0)
@@ -240,7 +244,8 @@ typedef struct _MHD_gc_hash_ctx
 } _MHD_gc_hash_ctx;
 
 Gc_rc
-MHD_gc_hash_open (Gc_hash hash, Gc_hash_mode mode, MHD_gc_hash_handle * outhandle)
+MHD_gc_hash_open (Gc_hash hash, Gc_hash_mode mode,
+                  MHD_gc_hash_handle * outhandle)
 {
   _MHD_gc_hash_ctx *ctx;
   int gcryalg = 0, gcrymode = 0;
@@ -391,7 +396,8 @@ MHD_gc_hash_digest_length (Gc_hash hash)
 }
 
 void
-MHD_gc_hash_MHD_hmac_setkey (MHD_gc_hash_handle handle, size_t len, const char *key)
+MHD_gc_hash_MHD_hmac_setkey (MHD_gc_hash_handle handle, size_t len,
+                             const char *key)
 {
   _MHD_gc_hash_ctx *ctx = handle;
   gcry_md_setkey (ctx->gch, key, len);
@@ -411,7 +417,7 @@ MHD_gc_hash_read (MHD_gc_hash_handle handle)
   const char *digest;
   {
     gcry_md_final (ctx->gch);
-    digest = (const char*) gcry_md_read (ctx->gch, 0);
+    digest = (const char *) gcry_md_read (ctx->gch, 0);
   }
 
   return digest;
@@ -547,7 +553,7 @@ MHD_gc_sha1 (const void *in, size_t inlen, void *resbuf)
 #ifdef GNULIB_GC_HMAC_MD5
 Gc_rc
 MHD_gc_MHD_hmac_md5 (const void *key, size_t keylen,
-             const void *in, size_t inlen, char *resbuf)
+                     const void *in, size_t inlen, char *resbuf)
 {
   size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
   gcry_md_hd_t mdh;
@@ -587,7 +593,8 @@ MHD_gc_MHD_hmac_md5 (const void *key, size_t keylen,
 #ifdef GNULIB_GC_HMAC_SHA1
 Gc_rc
 MHD_gc_MHD_hmac_sha1 (const void *key,
-              size_t keylen, const void *in, size_t inlen, char *resbuf)
+                      size_t keylen, const void *in, size_t inlen,
+                      char *resbuf)
 {
   size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
   gcry_md_hd_t mdh;
diff --git a/src/daemon/https/lgl/gc-pbkdf2-sha1.c b/src/daemon/https/lgl/gc-pbkdf2-sha1.c
index 98ac9f96..f58ba491 100644
--- a/src/daemon/https/lgl/gc-pbkdf2-sha1.c
+++ b/src/daemon/https/lgl/gc-pbkdf2-sha1.c
@@ -53,8 +53,8 @@
 
 Gc_rc
 MHD_gc_pbkdf2_sha1 (const char *P, size_t Plen,
-                const char *S, size_t Slen,
-                unsigned int c, char *DK, size_t dkLen)
+                    const char *S, size_t Slen,
+                    unsigned int c, char *DK, size_t dkLen)
 {
   unsigned int hLen = 20;
   char U[20];
diff --git a/src/daemon/https/lgl/gc.h b/src/daemon/https/lgl/gc.h
index ecc506fc..4d6b2c93 100644
--- a/src/daemon/https/lgl/gc.h
+++ b/src/daemon/https/lgl/gc.h
@@ -105,9 +105,10 @@ typedef int (*MHD_gc_secure_check_t) (const void *);
 typedef void *(*MHD_gc_realloc_t) (void *p, size_t n);
 typedef void (*MHD_gc_free_t) (void *);
 void MHD_gc_set_allocators (MHD_gc_malloc_t func_malloc,
-                        MHD_gc_malloc_t secure_malloc,
-                        MHD_gc_secure_check_t secure_check,
-                        MHD_gc_realloc_t func_realloc, MHD_gc_free_t func_free);
+                            MHD_gc_malloc_t secure_malloc,
+                            MHD_gc_secure_check_t secure_check,
+                            MHD_gc_realloc_t func_realloc,
+                            MHD_gc_free_t func_free);
 
 /* Randomness. */
 Gc_rc MHD_gc_nonce (char *data, size_t datalen);
@@ -116,24 +117,29 @@ Gc_rc MHD_gc_random (char *data, size_t datalen);
 
 /* Ciphers. */
 Gc_rc MHD_gc_cipher_open (Gc_cipher cipher,
-                      Gc_cipher_mode mode, MHD_gc_cipher_handle * outhandle);
-Gc_rc MHD_gc_cipher_setkey (MHD_gc_cipher_handle handle,
-                        size_t keylen, const char *key);
-Gc_rc MHD_gc_cipher_setiv (MHD_gc_cipher_handle handle, size_t ivlen, const char *iv);
-Gc_rc MHD_gc_cipher_encrypt_inline (MHD_gc_cipher_handle handle,
-                                size_t len, char *data);
-Gc_rc MHD_gc_cipher_decrypt_inline (MHD_gc_cipher_handle handle,
-                                size_t len, char *data);
+                          Gc_cipher_mode mode,
+                          MHD_gc_cipher_handle * outhandle);
+Gc_rc MHD_gc_cipher_setkey (MHD_gc_cipher_handle handle, size_t keylen,
+                            const char *key);
+Gc_rc MHD_gc_cipher_setiv (MHD_gc_cipher_handle handle, size_t ivlen,
+                           const char *iv);
+Gc_rc MHD_gc_cipher_encrypt_inline (MHD_gc_cipher_handle handle, size_t len,
+                                    char *data);
+Gc_rc MHD_gc_cipher_decrypt_inline (MHD_gc_cipher_handle handle, size_t len,
+                                    char *data);
 Gc_rc MHD_gc_cipher_close (MHD_gc_cipher_handle handle);
 
 /* Hashes. */
 
 Gc_rc MHD_gc_hash_open (Gc_hash hash,
-                    Gc_hash_mode mode, MHD_gc_hash_handle * outhandle);
-Gc_rc MHD_gc_hash_clone (MHD_gc_hash_handle handle, MHD_gc_hash_handle * outhandle);
+                        Gc_hash_mode mode, MHD_gc_hash_handle * outhandle);
+Gc_rc MHD_gc_hash_clone (MHD_gc_hash_handle handle,
+                         MHD_gc_hash_handle * outhandle);
 size_t MHD_gc_hash_digest_length (Gc_hash hash);
-void MHD_gc_hash_MHD_hmac_setkey (MHD_gc_hash_handle handle, size_t len, const char *key);
-void MHD_gc_hash_write (MHD_gc_hash_handle handle, size_t len, const char *data);
+void MHD_gc_hash_MHD_hmac_setkey (MHD_gc_hash_handle handle, size_t len,
+                                  const char *key);
+void MHD_gc_hash_write (MHD_gc_hash_handle handle, size_t len,
+                        const char *data);
 const char *MHD_gc_hash_read (MHD_gc_hash_handle handle);
 void MHD_gc_hash_close (MHD_gc_hash_handle handle);
 
@@ -143,7 +149,8 @@ void MHD_gc_hash_close (MHD_gc_hash_handle handle);
  GC_<HASH>_DIGEST_SIZE.  For example, for GC_MD5 the output buffer
  must be 16 bytes.  The return value is 0 (GC_OK) on success, or
  another Gc_rc error code. */
-Gc_rc MHD_gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *out);
+Gc_rc MHD_gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen,
+                          char *out);
 
 /* One-call interface. */
 Gc_rc MHD_gc_md2 (const void *in, size_t inlen, void *resbuf);
@@ -151,10 +158,10 @@ Gc_rc MHD_gc_md4 (const void *in, size_t inlen, void *resbuf);
 Gc_rc MHD_gc_md5 (const void *in, size_t inlen, void *resbuf);
 Gc_rc MHD_gc_sha1 (const void *in, size_t inlen, void *resbuf);
 Gc_rc MHD_gc_MHD_hmac_md5 (const void *key,
-                   size_t keylen, const void *in, size_t inlen, char *resbuf);
-Gc_rc MHD_gc_MHD_hmac_sha1 (const void *key,
-                    size_t keylen,
-                    const void *in, size_t inlen, char *resbuf);
+                           size_t keylen, const void *in, size_t inlen,
+                           char *resbuf);
+Gc_rc MHD_gc_MHD_hmac_sha1 (const void *key, size_t keylen, const void *in,
+                            size_t inlen, char *resbuf);
 
 /* Derive cryptographic keys from a password P of length PLEN, with
  salt S of length SLEN, placing the result in pre-allocated buffer
@@ -164,9 +171,10 @@ Gc_rc MHD_gc_MHD_hmac_sha1 (const void *key,
  exactly dkLen bytes long.  GC_OK is returned on success, otherwise
  an Gc_rc error code is returned.  */
 Gc_rc MHD_gc_pbkdf2_sha1 (const char *P,
-                      size_t Plen,
-                      const char *S,
-                      size_t Slen, unsigned int c, char *DK, size_t dkLen);
+                          size_t Plen,
+                          const char *S,
+                          size_t Slen, unsigned int c, char *DK,
+                          size_t dkLen);
 
 /*
  TODO:
diff --git a/src/daemon/https/lgl/hmac-md5.c b/src/daemon/https/lgl/hmac-md5.c
index fc6902a9..1fd943f0 100644
--- a/src/daemon/https/lgl/hmac-md5.c
+++ b/src/daemon/https/lgl/hmac-md5.c
@@ -31,7 +31,7 @@
 
 int
 MHD_hmac_md5 (const void *key, size_t keylen,
-          const void *in, size_t inlen, void *resbuf)
+              const void *in, size_t inlen, void *resbuf)
 {
   struct MHD_md5_ctx inner;
   struct MHD_md5_ctx outer;
diff --git a/src/daemon/https/lgl/hmac-sha1.c b/src/daemon/https/lgl/hmac-sha1.c
index 5d341cb4..4d2e4f37 100644
--- a/src/daemon/https/lgl/hmac-sha1.c
+++ b/src/daemon/https/lgl/hmac-sha1.c
@@ -31,7 +31,7 @@
 
 int
 MHD_hmac_sha1 (const void *key, size_t keylen,
-           const void *in, size_t inlen, void *resbuf)
+               const void *in, size_t inlen, void *resbuf)
 {
   struct MHD_sha1_ctx inner;
   struct MHD_sha1_ctx outer;
diff --git a/src/daemon/https/lgl/hmac.h b/src/daemon/https/lgl/hmac.h
index 29764056..c4791504 100644
--- a/src/daemon/https/lgl/hmac.h
+++ b/src/daemon/https/lgl/hmac.h
@@ -28,7 +28,7 @@
    RESBUF buffer.  Return 0 on success.  */
 int
 MHD_hmac_md5 (const void *key, size_t keylen,
-          const void *buffer, size_t buflen, void *resbuf);
+              const void *buffer, size_t buflen, void *resbuf);
 
 /* Compute Hashed Message Authentication Code with SHA-1, over BUFFER
    data of BUFLEN bytes using the KEY of KEYLEN bytes, writing the
@@ -36,6 +36,6 @@ MHD_hmac_md5 (const void *key, size_t keylen,
    success.  */
 int
 MHD_hmac_sha1 (const void *key, size_t keylen,
-           const void *in, size_t inlen, void *resbuf);
+               const void *in, size_t inlen, void *resbuf);
 
 #endif /* HMAC_H */
diff --git a/src/daemon/https/lgl/md5.c b/src/daemon/https/lgl/md5.c
index bc1fccbc..8cca27f5 100644
--- a/src/daemon/https/lgl/md5.c
+++ b/src/daemon/https/lgl/md5.c
@@ -212,7 +212,8 @@ MHD_md5_buffer (const char *buffer, size_t len, void *resblock)
 
 
 void
-MHD_md5_process_bytes (const void *buffer, size_t len, struct MHD_md5_ctx *ctx)
+MHD_md5_process_bytes (const void *buffer, size_t len,
+                       struct MHD_md5_ctx *ctx)
 {
   /* When we already have some bits in our internal buffer concatenate
      both inputs first.  */
@@ -292,7 +293,8 @@ MHD_md5_process_bytes (const void *buffer, size_t len, struct MHD_md5_ctx *ctx)
    It is assumed that LEN % 64 == 0.  */
 
 void
-MHD_md5_process_block (const void *buffer, size_t len, struct MHD_md5_ctx *ctx)
+MHD_md5_process_block (const void *buffer, size_t len,
+                       struct MHD_md5_ctx *ctx)
 {
   uint32_t correct_words[16];
   const uint32_t *words = buffer;
diff --git a/src/daemon/https/lgl/md5.h b/src/daemon/https/lgl/md5.h
index 80793b66..94247e46 100644
--- a/src/daemon/https/lgl/md5.h
+++ b/src/daemon/https/lgl/md5.h
@@ -83,14 +83,14 @@ __MHD_md5_init_ctx (struct MHD_md5_ctx *ctx)
    starting at BUFFER.
    It is necessary that LEN is a multiple of 64!!! */
      extern void __MHD_md5_process_block (const void *buffer, size_t len,
-                                      struct MHD_md5_ctx *ctx) __THROW;
+                                          struct MHD_md5_ctx *ctx) __THROW;
 
 /* Starting with the result of former calls of this function (or the
    initialization function update the context for the next LEN bytes
    starting at BUFFER.
    It is NOT required that LEN is a multiple of 64.  */
      extern void __MHD_md5_process_bytes (const void *buffer, size_t len,
-                                      struct MHD_md5_ctx *ctx) __THROW;
+                                          struct MHD_md5_ctx *ctx) __THROW;
 
 /* Process the remaining bytes in the buffer and put result from CTX
    in first 16 bytes following RESBUF.  The result is always in little
@@ -100,7 +100,7 @@ __MHD_md5_init_ctx (struct MHD_md5_ctx *ctx)
    IMPORTANT: On some systems, RESBUF must be aligned to a 32-bit
    boundary. */
      extern void *__MHD_md5_finish_ctx (struct MHD_md5_ctx *ctx,
-                                    void *resbuf) __THROW;
+                                        void *resbuf) __THROW;
 
 
 /* Put result from CTX in first 16 bytes following RESBUF.  The result is
@@ -110,7 +110,7 @@ __MHD_md5_init_ctx (struct MHD_md5_ctx *ctx)
    IMPORTANT: On some systems, RESBUF must be aligned to a 32-bit
    boundary. */
      extern void *__MHD_md5_read_ctx (const struct MHD_md5_ctx *ctx,
-                                  void *resbuf) __THROW;
+                                      void *resbuf) __THROW;
 
 
 /* Compute MD5 message digest for bytes read from STREAM.  The
@@ -123,6 +123,6 @@ __MHD_md5_init_ctx (struct MHD_md5_ctx *ctx)
    output yields to the wanted ASCII representation of the message
    digest.  */
      extern void *__MHD_md5_buffer (const char *buffer, size_t len,
-                                void *resblock) __THROW;
+                                    void *resblock) __THROW;
 
 #endif /* md5.h */
diff --git a/src/daemon/https/lgl/rijndael-alg-fst.c b/src/daemon/https/lgl/rijndael-alg-fst.c
index d17fbeed..516fff15 100644
--- a/src/daemon/https/lgl/rijndael-alg-fst.c
+++ b/src/daemon/https/lgl/rijndael-alg-fst.c
@@ -763,7 +763,7 @@ static const uint32_t rcon[] = {
  */
 int
 MHD_rijndaelKeySetupEnc (uint32_t rk[ /*4*(Nr + 1) */ ],
-                     const char cipherKey[], size_t keyBits)
+                         const char cipherKey[], size_t keyBits)
 {
   size_t i = 0;
   uint32_t temp;
@@ -858,7 +858,7 @@ MHD_rijndaelKeySetupEnc (uint32_t rk[ /*4*(Nr + 1) */ ],
  */
 int
 MHD_rijndaelKeySetupDec (uint32_t rk[ /*4*(Nr + 1) */ ],
-                     const char cipherKey[], size_t keyBits)
+                         const char cipherKey[], size_t keyBits)
 {
   size_t Nr, i, j;
   uint32_t temp;
@@ -912,7 +912,7 @@ MHD_rijndaelKeySetupDec (uint32_t rk[ /*4*(Nr + 1) */ ],
 
 void
 MHD_rijndaelEncrypt (const uint32_t rk[ /*4*(Nr + 1) */ ], size_t Nr,
-                 const char pt[16], char ct[16])
+                     const char pt[16], char ct[16])
 {
   uint32_t s0, s1, s2, s3, t0, t1, t2, t3;
   size_t r;
@@ -1003,7 +1003,7 @@ MHD_rijndaelEncrypt (const uint32_t rk[ /*4*(Nr + 1) */ ], size_t Nr,
 
 void
 MHD_rijndaelDecrypt (const uint32_t rk[ /*4*(Nr + 1) */ ], size_t Nr,
-                 const char ct[16], char pt[16])
+                     const char ct[16], char pt[16])
 {
   uint32_t s0, s1, s2, s3, t0, t1, t2, t3;
   size_t r;
diff --git a/src/daemon/https/lgl/rijndael-alg-fst.h b/src/daemon/https/lgl/rijndael-alg-fst.h
index c5496181..b04c1deb 100644
--- a/src/daemon/https/lgl/rijndael-alg-fst.h
+++ b/src/daemon/https/lgl/rijndael-alg-fst.h
@@ -56,12 +56,12 @@
 #define RIJNDAEL_MAXNR 14
 
 int MHD_rijndaelKeySetupEnc (uint32_t rk[ /*4*(Nr + 1) */ ],
-                         const char cipherKey[], size_t keyBits);
+                             const char cipherKey[], size_t keyBits);
 int MHD_rijndaelKeySetupDec (uint32_t rk[ /*4*(Nr + 1) */ ],
-                         const char cipherKey[], size_t keyBits);
+                             const char cipherKey[], size_t keyBits);
 void MHD_rijndaelEncrypt (const uint32_t rk[ /*4*(Nr + 1) */ ], size_t Nr,
-                      const char pt[16], char ct[16]);
+                          const char pt[16], char ct[16]);
 void MHD_rijndaelDecrypt (const uint32_t rk[ /*4*(Nr + 1) */ ], size_t Nr,
-                      const char ct[16], char pt[16]);
+                          const char ct[16], char pt[16]);
 
 #endif /* __RIJNDAEL_ALG_FST_H */
diff --git a/src/daemon/https/lgl/rijndael-api-fst.c b/src/daemon/https/lgl/rijndael-api-fst.c
index 62d2a4e6..d4196948 100644
--- a/src/daemon/https/lgl/rijndael-api-fst.c
+++ b/src/daemon/https/lgl/rijndael-api-fst.c
@@ -73,7 +73,7 @@
 
 rijndael_rc
 MHD_rijndaelMakeKey (rijndaelKeyInstance * key, rijndael_direction direction,
-                 size_t keyLen, const char *keyMaterial)
+                     size_t keyLen, const char *keyMaterial)
 {
   size_t i;
   char *keyMat;
@@ -149,8 +149,8 @@ MHD_rijndaelMakeKey (rijndaelKeyInstance * key, rijndael_direction direction,
 }
 
 rijndael_rc
-MHD_MHD_rijndaelCipherInit (rijndaelCipherInstance * cipher, rijndael_mode mode,
-                    const char *IV)
+MHD_MHD_rijndaelCipherInit (rijndaelCipherInstance * cipher,
+                            rijndael_mode mode, const char *IV)
 {
   if ((mode == RIJNDAEL_MODE_ECB) || (mode == RIJNDAEL_MODE_CBC)
       || (mode == RIJNDAEL_MODE_CFB1))
@@ -200,8 +200,8 @@ MHD_MHD_rijndaelCipherInit (rijndaelCipherInstance * cipher, rijndael_mode mode,
 
 int
 MHD_rijndaelBlockEncrypt (rijndaelCipherInstance * cipher,
-                      const rijndaelKeyInstance * key,
-                      const char *input, size_t inputLen, char *outBuffer)
+                          const rijndaelKeyInstance * key,
+                          const char *input, size_t inputLen, char *outBuffer)
 {
   size_t i, k, t, numBlocks;
   char block[16], *iv;
@@ -277,8 +277,9 @@ MHD_rijndaelBlockEncrypt (rijndaelCipherInstance * cipher,
 
 int
 MHD_rijndaelPadEncrypt (rijndaelCipherInstance * cipher,
-                    const rijndaelKeyInstance * key,
-                    const char *input, size_t inputOctets, char *outBuffer)
+                        const rijndaelKeyInstance * key,
+                        const char *input, size_t inputOctets,
+                        char *outBuffer)
 {
   size_t i, numBlocks, padLen;
   char block[16], *iv;
@@ -350,8 +351,8 @@ MHD_rijndaelPadEncrypt (rijndaelCipherInstance * cipher,
 
 int
 MHD_rijndaelBlockDecrypt (rijndaelCipherInstance * cipher,
-                      const rijndaelKeyInstance * key,
-                      const char *input, size_t inputLen, char *outBuffer)
+                          const rijndaelKeyInstance * key,
+                          const char *input, size_t inputLen, char *outBuffer)
 {
   size_t i, k, t, numBlocks;
   char block[16], *iv;
@@ -426,8 +427,9 @@ MHD_rijndaelBlockDecrypt (rijndaelCipherInstance * cipher,
 
 int
 MHD_rijndaelPadDecrypt (rijndaelCipherInstance * cipher,
-                    const rijndaelKeyInstance * key,
-                    const char *input, size_t inputOctets, char *outBuffer)
+                        const rijndaelKeyInstance * key,
+                        const char *input, size_t inputOctets,
+                        char *outBuffer)
 {
   size_t i, numBlocks, padLen;
   char block[16];
diff --git a/src/daemon/https/lgl/rijndael-api-fst.h b/src/daemon/https/lgl/rijndael-api-fst.h
index 088e6bfd..893021fc 100644
--- a/src/daemon/https/lgl/rijndael-api-fst.h
+++ b/src/daemon/https/lgl/rijndael-api-fst.h
@@ -138,7 +138,7 @@ typedef struct
    128, 192 or 256. Returns 0 on success, or an error code. */
 extern rijndael_rc
 MHD_rijndaelMakeKey (rijndaelKeyInstance * key, rijndael_direction direction,
-                 size_t keyLen, const char *keyMaterial);
+                     size_t keyLen, const char *keyMaterial);
 
 /* Initialize cipher state CIPHER for encryption MODE (e.g.,
    RIJNDAEL_MODE_CBC) with initialization vector IV, a hex string of
@@ -146,7 +146,7 @@ MHD_rijndaelMakeKey (rijndaelKeyInstance * key, rijndael_direction direction,
    not need an IV (i.e., RIJNDAEL_MODE_ECB).  */
 extern rijndael_rc
 MHD_MHD_rijndaelCipherInit (rijndaelCipherInstance * cipher,
-                    rijndael_mode mode, const char *IV);
+                            rijndael_mode mode, const char *IV);
 
 /* Encrypt data in INPUT, of INPUTLEN/8 bytes length, placing the
    output in the pre-allocated OUTBUFFER which must hold at least
@@ -157,8 +157,9 @@ MHD_MHD_rijndaelCipherInit (rijndaelCipherInstance * cipher,
    negative rijndael_rc error code. */
 extern int
 MHD_rijndaelBlockEncrypt (rijndaelCipherInstance * cipher,
-                      const rijndaelKeyInstance * key,
-                      const char *input, size_t inputLen, char *outBuffer);
+                          const rijndaelKeyInstance * key,
+                          const char *input, size_t inputLen,
+                          char *outBuffer);
 
 /* Encrypt data in INPUT, of INPUTOCTETS bytes length, placing the
    output in the pre-allocated OUTBUFFER which must hold at least
@@ -171,8 +172,9 @@ MHD_rijndaelBlockEncrypt (rijndaelCipherInstance * cipher,
    negative rijndael_rc error code. */
 extern int
 MHD_rijndaelPadEncrypt (rijndaelCipherInstance * cipher,
-                    const rijndaelKeyInstance * key,
-                    const char *input, size_t inputOctets, char *outBuffer);
+                        const rijndaelKeyInstance * key,
+                        const char *input, size_t inputOctets,
+                        char *outBuffer);
 
 /* Decrypt data in INPUT, of INPUTLEN/8 bytes length, placing the
    output in the pre-allocated OUTBUFFER which must hold at least
@@ -183,8 +185,9 @@ MHD_rijndaelPadEncrypt (rijndaelCipherInstance * cipher,
    negative rijndael_rc error code. */
 extern int
 MHD_rijndaelBlockDecrypt (rijndaelCipherInstance * cipher,
-                      const rijndaelKeyInstance * key,
-                      const char *input, size_t inputLen, char *outBuffer);
+                          const rijndaelKeyInstance * key,
+                          const char *input, size_t inputLen,
+                          char *outBuffer);
 
 /* Decrypt data in INPUT, of INPUTOCTETS bytes length, placing the
    output in the pre-allocated OUTBUFFER which must hold at least
@@ -197,7 +200,8 @@ MHD_rijndaelBlockDecrypt (rijndaelCipherInstance * cipher,
    negative rijndael_rc error code. */
 extern int
 MHD_rijndaelPadDecrypt (rijndaelCipherInstance * cipher,
-                    const rijndaelKeyInstance * key,
-                    const char *input, size_t inputOctets, char *outBuffer);
+                        const rijndaelKeyInstance * key,
+                        const char *input, size_t inputOctets,
+                        char *outBuffer);
 
 #endif /* __RIJNDAEL_API_FST_H */
diff --git a/src/daemon/https/lgl/sha1.c b/src/daemon/https/lgl/sha1.c
index c336cc4e..573e7c69 100644
--- a/src/daemon/https/lgl/sha1.c
+++ b/src/daemon/https/lgl/sha1.c
@@ -199,7 +199,8 @@ MHD_sha1_buffer (const char *buffer, size_t len, void *resblock)
 }
 
 void
-MHD_sha1_process_bytes (const void *buffer, size_t len, struct MHD_sha1_ctx *ctx)
+MHD_sha1_process_bytes (const void *buffer, size_t len,
+                        struct MHD_sha1_ctx *ctx)
 {
   /* When we already have some bits in our internal buffer concatenate
      both inputs first.  */
@@ -235,7 +236,8 @@ MHD_sha1_process_bytes (const void *buffer, size_t len, struct MHD_sha1_ctx *ctx
       if (UNALIGNED_P (buffer))
         while (len > 64)
           {
-            MHD_sha1_process_block (memcpy (ctx->buffer, buffer, 64), 64, ctx);
+            MHD_sha1_process_block (memcpy (ctx->buffer, buffer, 64), 64,
+                                    ctx);
             buffer = (const char *) buffer + 64;
             len -= 64;
           }
@@ -284,7 +286,8 @@ MHD_sha1_process_bytes (const void *buffer, size_t len, struct MHD_sha1_ctx *ctx
    Most of this code comes from GnuPG's cipher/sha1.c.  */
 
 void
-MHD_sha1_process_block (const void *buffer, size_t len, struct MHD_sha1_ctx *ctx)
+MHD_sha1_process_block (const void *buffer, size_t len,
+                        struct MHD_sha1_ctx *ctx)
 {
   const uint32_t *words = buffer;
   size_t nwords = len / sizeof (uint32_t);
diff --git a/src/daemon/https/lgl/sha1.h b/src/daemon/https/lgl/sha1.h
index 382d96cf..b6e40cdb 100644
--- a/src/daemon/https/lgl/sha1.h
+++ b/src/daemon/https/lgl/sha1.h
@@ -45,14 +45,14 @@ extern void MHD_sha1_init_ctx (struct MHD_sha1_ctx *ctx);
    starting at BUFFER.
    It is necessary that LEN is a multiple of 64!!! */
 extern void MHD_sha1_process_block (const void *buffer, size_t len,
-                                struct MHD_sha1_ctx *ctx);
+                                    struct MHD_sha1_ctx *ctx);
 
 /* Starting with the result of former calls of this function (or the
    initialization function update the context for the next LEN bytes
    starting at BUFFER.
    It is NOT required that LEN is a multiple of 64.  */
 extern void MHD_sha1_process_bytes (const void *buffer, size_t len,
-                                struct MHD_sha1_ctx *ctx);
+                                    struct MHD_sha1_ctx *ctx);
 
 /* Process the remaining bytes in the buffer and put result from CTX
    in first 20 bytes following RESBUF.  The result is always in little