-fix many compiler warnings

14 files changed, 198 insertions, 161 deletions

diff --git a/contrib/gana b/contrib/gana
-Subproject ace673ed30067aa50ef5eebe16cc63ebe1ae066
+Subproject 4728c9e60ce121f439b3db30cc08f06ff0beff7
diff --git a/src/cli/reclaim/gnunet-did.c b/src/cli/reclaim/gnunet-did.c
index 2350b6958..a8ac7652e 100644
--- a/src/cli/reclaim/gnunet-did.c
+++ b/src/cli/reclaim/gnunet-did.c
@@ -31,8 +31,8 @@
  * @author Tristan Schwieren
  * @file src/did/gnunet-did.c
  * @brief DID Method Wrapper
- *
  */
+#include "platform.h"
 #include "gnunet_util_lib.h"
 #include "gnunet_namestore_service.h"
 #include "gnunet_identity_service.h"
@@ -145,6 +145,7 @@ cleanup (void *cls)
   GNUNET_SCHEDULER_shutdown ();
 }
 
+
 /**
  * @brief GNS lookup callback. Prints the DID Document to standard out.
  * Fails if there is more than one DID record.
@@ -170,6 +171,7 @@ print_did_document (
   return;
 }
 
+
 /**
  * @brief Resolve a DID given by the user.
  */
@@ -233,14 +235,16 @@ remove_did_document_namestore_cb (void *cls, enum GNUNET_ErrorCode ec)
       event->cont (event->cls);
       free (event);
     }
-    else {
+    else
+    {
       free (event);
       GNUNET_SCHEDULER_add_now (cleanup, NULL);
       ret = 0;
       return;
     }
   }
-  else {
+  else
+  {
     printf ("Something went wrong when deleting the DID Document\n");
 
     printf ("%s\n", GNUNET_ErrorCode_get_hint (ec));
@@ -251,6 +255,7 @@ remove_did_document_namestore_cb (void *cls, enum GNUNET_ErrorCode ec)
   }
 }
 
+
 /**
  * @brief Callback called after the ego has been locked up
  *
@@ -264,14 +269,15 @@ remove_did_document_ego_lookup_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego)
     GNUNET_IDENTITY_ego_get_private_key (ego);
 
   GNUNET_NAMESTORE_record_set_store (namestore_handle,
-                                  skey,
-                                  GNUNET_GNS_EMPTY_LABEL_AT,
-                                  0,
-                                  NULL,
-                                  &remove_did_document_namestore_cb,
-                                  cls);
+                                     skey,
+                                     GNUNET_GNS_EMPTY_LABEL_AT,
+                                     0,
+                                     NULL,
+                                     &remove_did_document_namestore_cb,
+                                     cls);
 }
 
+
 /**
  * @brief Remove a DID Document
  */
@@ -287,7 +293,8 @@ remove_did_document (remove_did_document_callback cont, void *cls)
     ret = 1;
     return;
   }
-  else {
+  else
+  {
     event = malloc (sizeof(*event));
     event->cont = cont;
     event->cls = cls;
@@ -299,6 +306,7 @@ remove_did_document (remove_did_document_callback cont, void *cls)
   }
 }
 
+
 // Needed because create_did_ego_lookup_cb() and
 // create_did_ego_create_cb() can call each other
 static void create_did_ego_lockup_cb ();
@@ -327,6 +335,7 @@ create_did_cb (enum GNUNET_GenericReturnValue status, void *cls)
   return;
 }
 
+
 /**
  * @brief Create a DID(-Document) - Called after a new Identity has been created.
  */
@@ -349,6 +358,7 @@ create_did_ego_create_cb (void *cls,
                               NULL);
 }
 
+
 /**
  * @brief Create a DID(-Document). Called after ego lookup
  *
@@ -405,6 +415,7 @@ create_did_ego_lockup_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego)
   }
 }
 
+
 /**
  * @brief Create a DID(-Document).
  *
@@ -440,6 +451,7 @@ replace_did_document_ego_lookup_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego)
   // create_did_store (didd, ego);
 }
 
+
 /**
  * @brief Replace a DID Document. Callback functiona after remove
  *
@@ -454,6 +466,7 @@ replace_did_document_remove_cb (void *cls)
                               NULL);
 }
 
+
 /**
  * @brief Replace a DID Docuemnt
  *
@@ -465,7 +478,8 @@ replace_did_document ()
   {
     remove_did_document (&replace_did_document_remove_cb, NULL);
   }
-  else {
+  else
+  {
     printf (
       "Set the DID Document and expiration time argument to replace the DID Document\n");
     GNUNET_SCHEDULER_add_now (&cleanup, NULL);
@@ -474,6 +488,7 @@ replace_did_document ()
   }
 }
 
+
 static void
 post_ego_iteration (void *cls)
 {
@@ -495,13 +510,15 @@ post_ego_iteration (void *cls)
   {
     create_did ();
   }
-  else {
+  else
+  {
     // No Argument found
     GNUNET_SCHEDULER_add_now (&cleanup, NULL);
     return;
   }
 }
 
+
 static void
 process_dids (void *cls, struct GNUNET_IDENTITY_Ego *ego,
               void **ctx, const char*name)
@@ -539,7 +556,6 @@ process_dids (void *cls, struct GNUNET_IDENTITY_Ego *ego,
 }
 
 
-
 static void
 run (void *cls,
      char *const *args,
@@ -574,6 +590,7 @@ run (void *cls,
   }
 }
 
+
 int
 main (int argc, char *const argv[])
 {
diff --git a/src/lib/gnsrecord/gnsrecord_misc.c b/src/lib/gnsrecord/gnsrecord_misc.c
index 0a94e1f78..ede3e23e4 100644
--- a/src/lib/gnsrecord/gnsrecord_misc.c
+++ b/src/lib/gnsrecord/gnsrecord_misc.c
@@ -122,9 +122,9 @@ GNUNET_GNSRECORD_records_cmp (const struct GNUNET_GNSRECORD_Data *a,
   if (a->data_size != b->data_size)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Data size %lu != %lu\n",
-         a->data_size,
-         b->data_size);
+         "Data size %llu != %llu\n",
+         (unsigned long long) a->data_size,
+         (unsigned long long) b->data_size);
     return GNUNET_NO;
   }
   if (0 != memcmp (a->data, b->data, a->data_size))
diff --git a/src/lib/util/crypto_pkey.c b/src/lib/util/crypto_pkey.c
index 0a55b3b65..a9d4831fb 100644
--- a/src/lib/util/crypto_pkey.c
+++ b/src/lib/util/crypto_pkey.c
@@ -45,7 +45,7 @@ check_key_type (uint32_t type)
 
 ssize_t
 GNUNET_CRYPTO_private_key_get_length (const struct
-                                        GNUNET_CRYPTO_PrivateKey *key)
+                                      GNUNET_CRYPTO_PrivateKey *key)
 {
   switch (ntohl (key->type))
   {
@@ -66,7 +66,7 @@ GNUNET_CRYPTO_private_key_get_length (const struct
 
 ssize_t
 GNUNET_CRYPTO_public_key_get_length (const struct
-                                       GNUNET_CRYPTO_PublicKey *key)
+                                     GNUNET_CRYPTO_PublicKey *key)
 {
   switch (ntohl (key->type))
   {
@@ -101,10 +101,10 @@ GNUNET_CRYPTO_private_key_length_by_type (enum GNUNET_CRYPTO_KeyType kt)
 
 enum GNUNET_GenericReturnValue
 GNUNET_CRYPTO_read_public_key_from_buffer (const void *buffer,
-                                             size_t len,
-                                             struct GNUNET_CRYPTO_PublicKey *
-                                             key,
-                                             size_t *kb_read)
+                                           size_t len,
+                                           struct GNUNET_CRYPTO_PublicKey *
+                                           key,
+                                           size_t *kb_read)
 {
   if (len < sizeof (key->type))
     return GNUNET_SYSERR;
@@ -126,9 +126,9 @@ GNUNET_CRYPTO_read_public_key_from_buffer (const void *buffer,
 
 ssize_t
 GNUNET_CRYPTO_write_public_key_to_buffer (const struct
-                                            GNUNET_CRYPTO_PublicKey *key,
-                                            void*buffer,
-                                            size_t len)
+                                          GNUNET_CRYPTO_PublicKey *key,
+                                          void*buffer,
+                                          size_t len)
 {
   const ssize_t length = GNUNET_CRYPTO_public_key_get_length (key);
   if (len < length)
@@ -144,10 +144,10 @@ GNUNET_CRYPTO_write_public_key_to_buffer (const struct
 
 enum GNUNET_GenericReturnValue
 GNUNET_CRYPTO_read_private_key_from_buffer (const void *buffer,
-                                              size_t len,
-                                              struct
-                                              GNUNET_CRYPTO_PrivateKey *key,
-                                              size_t *kb_read)
+                                            size_t len,
+                                            struct
+                                            GNUNET_CRYPTO_PrivateKey *key,
+                                            size_t *kb_read)
 {
   if (len < sizeof (key->type))
     return GNUNET_SYSERR;
@@ -169,9 +169,9 @@ GNUNET_CRYPTO_read_private_key_from_buffer (const void *buffer,
 
 ssize_t
 GNUNET_CRYPTO_write_private_key_to_buffer (const struct
-                                             GNUNET_CRYPTO_PrivateKey *key,
-                                             void *buffer,
-                                             size_t len)
+                                           GNUNET_CRYPTO_PrivateKey *key,
+                                           void *buffer,
+                                           size_t len)
 {
   const ssize_t length = GNUNET_CRYPTO_private_key_get_length (key);
   if (len < length)
@@ -187,7 +187,7 @@ GNUNET_CRYPTO_write_private_key_to_buffer (const struct
 
 ssize_t
 GNUNET_CRYPTO_signature_get_length (const struct
-                                      GNUNET_CRYPTO_Signature *sig)
+                                    GNUNET_CRYPTO_Signature *sig)
 {
   switch (ntohl (sig->type))
   {
@@ -224,9 +224,9 @@ GNUNET_CRYPTO_signature_get_raw_length_by_type (uint32_t type)
 
 ssize_t
 GNUNET_CRYPTO_read_signature_from_buffer (struct
-                                            GNUNET_CRYPTO_Signature *sig,
-                                            const void*buffer,
-                                            size_t len)
+                                          GNUNET_CRYPTO_Signature *sig,
+                                          const void*buffer,
+                                          size_t len)
 {
   if (len < sizeof (sig->type))
     return -1;
@@ -244,9 +244,9 @@ GNUNET_CRYPTO_read_signature_from_buffer (struct
 
 ssize_t
 GNUNET_CRYPTO_write_signature_to_buffer (const struct
-                                           GNUNET_CRYPTO_Signature *sig,
-                                           void*buffer,
-                                           size_t len)
+                                         GNUNET_CRYPTO_Signature *sig,
+                                         void*buffer,
+                                         size_t len)
 {
   const ssize_t length = GNUNET_CRYPTO_signature_get_length (sig);
   if (len < length)
@@ -262,10 +262,10 @@ GNUNET_CRYPTO_write_signature_to_buffer (const struct
 
 enum GNUNET_GenericReturnValue
 GNUNET_CRYPTO_sign_raw_ (const struct
-                           GNUNET_CRYPTO_PrivateKey *priv,
-                           const struct
-                           GNUNET_CRYPTO_EccSignaturePurpose *purpose,
-                           unsigned char *sig)
+                         GNUNET_CRYPTO_PrivateKey *priv,
+                         const struct
+                         GNUNET_CRYPTO_EccSignaturePurpose *purpose,
+                         unsigned char *sig)
 {
   switch (ntohl (priv->type))
   {
@@ -289,10 +289,10 @@ GNUNET_CRYPTO_sign_raw_ (const struct
 
 enum GNUNET_GenericReturnValue
 GNUNET_CRYPTO_sign_ (const struct
-                       GNUNET_CRYPTO_PrivateKey *priv,
-                       const struct
-                       GNUNET_CRYPTO_EccSignaturePurpose *purpose,
-                       struct GNUNET_CRYPTO_Signature *sig)
+                     GNUNET_CRYPTO_PrivateKey *priv,
+                     const struct
+                     GNUNET_CRYPTO_EccSignaturePurpose *purpose,
+                     struct GNUNET_CRYPTO_Signature *sig)
 {
   sig->type = priv->type;
   switch (ntohl (priv->type))
@@ -315,10 +315,10 @@ GNUNET_CRYPTO_sign_ (const struct
 
 enum GNUNET_GenericReturnValue
 GNUNET_CRYPTO_signature_verify_ (uint32_t purpose,
-                                   const struct
-                                   GNUNET_CRYPTO_EccSignaturePurpose *validate,
-                                   const struct GNUNET_CRYPTO_Signature *sig,
-                                   const struct GNUNET_CRYPTO_PublicKey *pub)
+                                 const struct
+                                 GNUNET_CRYPTO_EccSignaturePurpose *validate,
+                                 const struct GNUNET_CRYPTO_Signature *sig,
+                                 const struct GNUNET_CRYPTO_PublicKey *pub)
 {
   /* check type matching of 'sig' and 'pub' */
   GNUNET_assert (ntohl (pub->type) == ntohl (sig->type));
@@ -344,12 +344,12 @@ GNUNET_CRYPTO_signature_verify_ (uint32_t purpose,
 
 enum GNUNET_GenericReturnValue
 GNUNET_CRYPTO_signature_verify_raw_ (uint32_t purpose,
-                                       const struct
-                                       GNUNET_CRYPTO_EccSignaturePurpose *
-                                       validate,
-                                       const unsigned char *sig,
-                                       const struct
-                                       GNUNET_CRYPTO_PublicKey *pub)
+                                     const struct
+                                     GNUNET_CRYPTO_EccSignaturePurpose *
+                                     validate,
+                                     const unsigned char *sig,
+                                     const struct
+                                     GNUNET_CRYPTO_PublicKey *pub)
 {
   switch (ntohl (pub->type))
   {
@@ -375,10 +375,10 @@ GNUNET_CRYPTO_signature_verify_raw_ (uint32_t purpose,
 
 ssize_t
 GNUNET_CRYPTO_encrypt_old (const void *block,
-                             size_t size,
-                             const struct GNUNET_CRYPTO_PublicKey *pub,
-                             struct GNUNET_CRYPTO_EcdhePublicKey *ecc,
-                             void *result)
+                           size_t size,
+                           const struct GNUNET_CRYPTO_PublicKey *pub,
+                           struct GNUNET_CRYPTO_EcdhePublicKey *ecc,
+                           void *result)
 {
   struct GNUNET_CRYPTO_EcdhePrivateKey pk;
   GNUNET_CRYPTO_ecdhe_key_create (&pk);
@@ -414,10 +414,10 @@ GNUNET_CRYPTO_encrypt_old (const void *block,
 
 enum GNUNET_GenericReturnValue
 GNUNET_CRYPTO_encrypt (const void *pt,
-                         size_t pt_size,
-                         const struct GNUNET_CRYPTO_PublicKey *pub,
-                         void *ct_buf,
-                         size_t ct_size)
+                       size_t pt_size,
+                       const struct GNUNET_CRYPTO_PublicKey *pub,
+                       void *ct_buf,
+                       size_t ct_size)
 {
   struct GNUNET_HashCode k;
   struct GNUNET_CRYPTO_FoKemC kemc;
@@ -429,8 +429,10 @@ GNUNET_CRYPTO_encrypt (const void *pt,
   if (ct_size < pt_size + GNUNET_CRYPTO_ENCRYPT_OVERHEAD_BYTES)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Output buffer size for ciphertext too small: Got %lu, want >=%lu\n",
-                ct_size, pt_size + GNUNET_CRYPTO_ENCRYPT_OVERHEAD_BYTES);
+                "Output buffer size for ciphertext too small: Got %llu, want >= %llu\n",
+                (unsigned long long) ct_size,
+                (unsigned long long) (pt_size
+                                      + GNUNET_CRYPTO_ENCRYPT_OVERHEAD_BYTES));
     return GNUNET_SYSERR;
   }
   switch (ntohl (pub->type))
@@ -463,10 +465,10 @@ GNUNET_CRYPTO_encrypt (const void *pt,
 
 enum GNUNET_GenericReturnValue
 GNUNET_CRYPTO_decrypt (const void *ct_buf,
-                         size_t ct_size,
-                         const struct GNUNET_CRYPTO_PrivateKey *priv,
-                         void *pt,
-                         size_t pt_size)
+                       size_t ct_size,
+                       const struct GNUNET_CRYPTO_PrivateKey *priv,
+                       void *pt,
+                       size_t pt_size)
 {
   struct GNUNET_HashCode k;
   struct GNUNET_CRYPTO_FoKemC *kemc = (struct GNUNET_CRYPTO_FoKemC*) ct_buf;
@@ -478,8 +480,9 @@ GNUNET_CRYPTO_decrypt (const void *ct_buf,
   if (pt_size < expected_pt_len)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Output buffer size for plaintext too small: Got %lu, want >=%lu\n",
-                pt_size, expected_pt_len);
+                "Output buffer size for plaintext too small: Got %llu, want >= %llu\n",
+                (unsigned long long) pt_size,
+                (unsigned long long) expected_pt_len);
     return GNUNET_SYSERR;
   }
   switch (ntohl (priv->type))
@@ -511,10 +514,10 @@ GNUNET_CRYPTO_decrypt (const void *ct_buf,
 
 ssize_t
 GNUNET_CRYPTO_decrypt_old (const void *block,
-                             size_t size,
-                             const struct GNUNET_CRYPTO_PrivateKey *priv,
-                             const struct GNUNET_CRYPTO_EcdhePublicKey *ecc,
-                             void *result)
+                           size_t size,
+                           const struct GNUNET_CRYPTO_PrivateKey *priv,
+                           const struct GNUNET_CRYPTO_EcdhePublicKey *ecc,
+                           void *result)
 {
   struct GNUNET_HashCode hash;
   switch (ntohl (priv->type))
@@ -546,7 +549,7 @@ GNUNET_CRYPTO_decrypt_old (const void *block,
 
 char *
 GNUNET_CRYPTO_public_key_to_string (const struct
-                                      GNUNET_CRYPTO_PublicKey *key)
+                                    GNUNET_CRYPTO_PublicKey *key)
 {
   size_t size = GNUNET_CRYPTO_public_key_get_length (key);
   return GNUNET_STRINGS_data_to_string_alloc (key,
@@ -556,7 +559,7 @@ GNUNET_CRYPTO_public_key_to_string (const struct
 
 char *
 GNUNET_CRYPTO_private_key_to_string (const struct
-                                       GNUNET_CRYPTO_PrivateKey *key)
+                                     GNUNET_CRYPTO_PrivateKey *key)
 {
   size_t size = GNUNET_CRYPTO_private_key_get_length (key);
   return GNUNET_STRINGS_data_to_string_alloc (key,
@@ -566,7 +569,7 @@ GNUNET_CRYPTO_private_key_to_string (const struct
 
 enum GNUNET_GenericReturnValue
 GNUNET_CRYPTO_public_key_from_string (const char *str,
-                                        struct GNUNET_CRYPTO_PublicKey *key)
+                                      struct GNUNET_CRYPTO_PublicKey *key)
 {
   enum GNUNET_GenericReturnValue ret;
   ret = GNUNET_STRINGS_string_to_data (str,
@@ -582,7 +585,7 @@ GNUNET_CRYPTO_public_key_from_string (const char *str,
 
 enum GNUNET_GenericReturnValue
 GNUNET_CRYPTO_private_key_from_string (const char *str,
-                                         struct GNUNET_CRYPTO_PrivateKey *key)
+                                       struct GNUNET_CRYPTO_PrivateKey *key)
 {
   enum GNUNET_GenericReturnValue ret;
   ret = GNUNET_STRINGS_string_to_data (str,
@@ -594,10 +597,11 @@ GNUNET_CRYPTO_private_key_from_string (const char *str,
   return check_key_type (ntohl (key->type));
 }
 
+
 enum GNUNET_GenericReturnValue
 GNUNET_CRYPTO_key_get_public (const struct
-                                GNUNET_CRYPTO_PrivateKey *privkey,
-                                struct GNUNET_CRYPTO_PublicKey *key)
+                              GNUNET_CRYPTO_PrivateKey *privkey,
+                              struct GNUNET_CRYPTO_PublicKey *key)
 {
   key->type = privkey->type;
   switch (ntohl (privkey->type))
diff --git a/src/service/fs/fs_download.c b/src/service/fs/fs_download.c
index 2a21e4810..cee64466d 100644
--- a/src/service/fs/fs_download.c
+++ b/src/service/fs/fs_download.c
@@ -1041,13 +1041,12 @@ process_result_with_request (void *cls,
   {
     GNUNET_asprintf (
       &dc->emsg,
-      _ (
-        "Internal error or bogus download URI (expected %lu bytes at depth %u and offset %llu/%llu, got %lu bytes)"),
-      bs,
+      "Internal error or bogus download URI (expected %llu bytes at depth %u and offset %llu/%llu, got %llu bytes)",
+      (unsigned long long) bs,
       dr->depth,
       (unsigned long long) dr->offset,
       (unsigned long long) GNUNET_ntohll (dc->uri->data.chk.file_length),
-      prc->size);
+      (unsigned long long) prc->size);
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "%s\n", dc->emsg);
     while (NULL != dr->parent)
     {
diff --git a/src/service/fs/meta_data.c b/src/service/fs/meta_data.c
index 1e75ecf6c..b3db0e6c7 100644
--- a/src/service/fs/meta_data.c
+++ b/src/service/fs/meta_data.c
@@ -39,7 +39,6 @@
                                         __VA_ARGS__)
 
 
-
 /**
  * Meta data item.
  */
@@ -1039,6 +1038,7 @@ GNUNET_FS_meta_data_deserialize (const char *input, size_t size)
   return md;
 }
 
+
 /**
  * Read a metadata container.
  *
@@ -1097,6 +1097,7 @@ GNUNET_FS_read_meta_data (struct GNUNET_BIO_ReadHandle *h,
   return GNUNET_OK;
 }
 
+
 /**
  * Write a metadata container.
  *
@@ -1120,22 +1121,27 @@ GNUNET_FS_write_meta_data (struct GNUNET_BIO_WriteHandle *h,
                                         &buf,
                                         MAX_META_DATA,
                                         GNUNET_FS_META_DATA_SERIALIZE_PART);
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              _ ("Serialized %ld bytes of metadata"),
-              size);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Serialized %lld bytes of metadata",
+              (long long) size);
 
   if (-1 == size)
   {
     GNUNET_free (buf);
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _ ("Failed to serialize metadata `%s'"),
+                "Failed to serialize metadata `%s'",
                 what);
     return GNUNET_SYSERR;
   }
-  if ((GNUNET_OK != GNUNET_BIO_write_int32 (h,
-                                            _ ("metadata length"),
-                                            (uint32_t) size))
-      || (GNUNET_OK != GNUNET_BIO_write (h, what, buf, size)))
+  if ( (GNUNET_OK !=
+        GNUNET_BIO_write_int32 (h,
+                                "metadata length",
+                                (uint32_t) size)) ||
+       (GNUNET_OK !=
+        GNUNET_BIO_write (h,
+                          what,
+                          buf,
+                          size)) )
   {
     GNUNET_free (buf);
     return GNUNET_SYSERR;
@@ -1144,6 +1150,7 @@ GNUNET_FS_write_meta_data (struct GNUNET_BIO_WriteHandle *h,
   return GNUNET_OK;
 }
 
+
 /**
  * Function used internally to read a metadata container from within a read
  * spec.
@@ -1166,6 +1173,7 @@ read_spec_handler_meta_data (void *cls,
   return GNUNET_FS_read_meta_data (h, what, result);
 }
 
+
 /**
  * Create the specification to read a metadata container.
  *
@@ -1187,6 +1195,7 @@ GNUNET_FS_read_spec_meta_data (const char *what,
   return rs;
 }
 
+
 /**
  * Function used internally to write a metadata container from within a write
  * spec.
diff --git a/src/service/gns/gnunet-service-gns_resolver.c b/src/service/gns/gnunet-service-gns_resolver.c
index 0d7a1cee8..b14500ab7 100644
--- a/src/service/gns/gnunet-service-gns_resolver.c
+++ b/src/service/gns/gnunet-service-gns_resolver.c
@@ -2592,8 +2592,8 @@ handle_dht_response (void *cls,
     return;
   }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Decrypting DHT block of size %lu for `%s', expires %s\n",
-              GNUNET_GNSRECORD_block_get_size (block),
+              "Decrypting DHT block of size %llu for `%s', expires %s\n",
+              (unsigned long long) GNUNET_GNSRECORD_block_get_size (block),
               rh->name,
               GNUNET_STRINGS_absolute_time_to_string (exp));
   if (GNUNET_OK !=
diff --git a/src/service/messenger/messenger_api_cmd_join_room.c b/src/service/messenger/messenger_api_cmd_join_room.c
index 4e9cf1e22..8151dc88e 100644
--- a/src/service/messenger/messenger_api_cmd_join_room.c
+++ b/src/service/messenger/messenger_api_cmd_join_room.c
@@ -46,9 +46,9 @@ join_room_run (void *cls,
   struct GNUNET_HashCode key;
 
   if (jrs->room_key)
-    GNUNET_CRYPTO_hash(jrs->room_key, strlen(jrs->room_key), &key);
+    GNUNET_CRYPTO_hash (jrs->room_key, strlen (jrs->room_key), &key);
   else
-    memset(&key, 0, sizeof(key));
+    memset (&key, 0, sizeof(key));
 
   const struct GNUNET_TESTING_Command *service_cmd;
   service_cmd = GNUNET_TESTING_interpreter_lookup_command (is,
@@ -59,17 +59,17 @@ join_room_run (void *cls,
 
   unsigned int peer_index;
   unsigned int stage_index;
-
   struct GNUNET_MESSENGER_RoomState *rs;
-  rs = rs = GNUNET_CONTAINER_multihashmap_get (sss->rooms, &key);
+
+  rs = GNUNET_CONTAINER_multihashmap_get (sss->rooms, &key);
   if (rs)
     goto skip_room_state;
 
-  rs = GNUNET_MESSENGER_create_room_state(sss->topology);
-  if ((!rs) && (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (sss->rooms,
-                                                                &key,
-                                                                rs,
-                                                                GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
+  rs = GNUNET_MESSENGER_create_room_state (sss->topology);
+  if ((! rs) && (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (sss->rooms,
+                                                                 &key,
+                                                                 rs,
+                                                                 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Testing library failed to create a room state with key '%s'\n",
@@ -82,22 +82,24 @@ skip_room_state:
   peer_index = sss->peer_index;
   stage_index = sss->stage_index;
 
-  const unsigned int index = stage_index * sss->topology->peer_amount + peer_index;
-  const struct GNUNET_MESSENGER_TestStage *stage = &(sss->topology->peer_stages[index]);
+  const unsigned int index = stage_index * sss->topology->peer_amount
+                             + peer_index;
+  const struct GNUNET_MESSENGER_TestStage *stage =
+    &(sss->topology->peer_stages[index]);
 
   unsigned int door_index = stage->door_id;
 
   if (door_index == 0)
     door_index = (peer_index + GNUNET_CRYPTO_random_u32 (
-        GNUNET_CRYPTO_QUALITY_WEAK,
-        sss->topology->peer_amount - 1
-    ) + 1) % sss->topology->peer_amount;
+                    GNUNET_CRYPTO_QUALITY_WEAK,
+                    sss->topology->peer_amount - 1
+                    ) + 1) % sss->topology->peer_amount;
   else
     door_index = (door_index - 1) % sss->topology->peer_amount;
 
   struct GNUNET_PeerIdentity *door;
-  door = GNUNET_TESTING_get_peer(door_index, sss->tl_system);
-  if (!door)
+  door = GNUNET_TESTING_get_peer (door_index, sss->tl_system);
+  if (! door)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Testing library failed to get peer identity of index '%u'\n",
@@ -112,7 +114,7 @@ skip_room_state:
   case GNUNET_MESSENGER_STAGE_JOIN_OPEN_ROOM:
     room = GNUNET_MESSENGER_open_room (sss->msg, &key);
 
-    if (!room)
+    if (! room)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                   "Testing library failed to open room with key '%s'\n",
@@ -124,9 +126,9 @@ skip_room_state:
 
     break;
   case GNUNET_MESSENGER_STAGE_JOIN_ENTER_ROOM:
-    room = GNUNET_MESSENGER_enter_room(sss->msg, door, &key);
+    room = GNUNET_MESSENGER_enter_room (sss->msg, door, &key);
 
-    if (!room)
+    if (! room)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                   "Testing library failed to enter room with key '%s'\n",
@@ -143,11 +145,12 @@ skip_room_state:
   }
 
   jrs->room = room;
-  TODO: sss->stage_index++;
+TODO: sss->stage_index++;
 
   GNUNET_free (door);
 }
 
+
 static void
 join_room_cleanup (void *cls)
 {
@@ -158,6 +161,7 @@ join_room_cleanup (void *cls)
   GNUNET_free (jrs);
 }
 
+
 struct GNUNET_TESTING_Command
 GNUNET_MESSENGER_cmd_join_room (const char *label,
                                 const char *service_label,
diff --git a/src/service/peerstore/peerstore_api.c b/src/service/peerstore/peerstore_api.c
index 2f43db3f5..feb5aeb3c 100644
--- a/src/service/peerstore/peerstore_api.c
+++ b/src/service/peerstore/peerstore_api.c
@@ -540,8 +540,8 @@ GNUNET_PEERSTORE_store (struct GNUNET_PEERSTORE_Handle *h,
   struct GNUNET_PEERSTORE_StoreContext *sc;
 
   LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Storing value (size: %lu) for subsystem `%s', peer `%s', key `%s'\n",
-       size,
+       "Storing value (size: %llu) for subsystem `%s', peer `%s', key `%s'\n",
+       (unsigned long long) size,
        sub_system,
        GNUNET_i2s (peer),
        key);
@@ -596,7 +596,7 @@ handle_store_result (void *cls, const struct PeerstoreResultMessage *msg)
   if (NULL == sc)
   {
     LOG (GNUNET_ERROR_TYPE_WARNING,
-         _("Unexpected store response.\n"));
+         _ ("Unexpected store response.\n"));
     return;
   }
   if (NULL != sc->cont)
@@ -673,7 +673,8 @@ handle_iterate_result (void *cls, const struct StoreRecordMessage *msg)
   if (NULL == ic)
   {
     LOG (GNUNET_ERROR_TYPE_WARNING,
-         _ ("Unexpected iteration response, no iterating client found, discarding message.\n"));
+         _ (
+           "Unexpected iteration response, no iterating client found, discarding message.\n"));
     return;
   }
   if (NULL == ic->callback)
@@ -857,7 +858,7 @@ reconnect (void *cls)
   for (struct GNUNET_PEERSTORE_IterateContext *ic = h->iterate_head; NULL != ic;
        ic = ic->next)
   {
-    ic->rid = get_op_id(h);
+    ic->rid = get_op_id (h);
     ev =
       PEERSTORE_create_record_mq_envelope (ic->rid,
                                            ic->sub_system,
@@ -873,7 +874,7 @@ reconnect (void *cls)
   for (struct GNUNET_PEERSTORE_StoreContext *sc = h->store_head; NULL != sc;
        sc = sc->next)
   {
-    sc->rid = get_op_id(h);
+    sc->rid = get_op_id (h);
     ev =
       PEERSTORE_create_record_mq_envelope (sc->rid,
                                            sc->sub_system,
diff --git a/src/service/reclaim/gnunet-service-reclaim.c b/src/service/reclaim/gnunet-service-reclaim.c
index 858a86aa5..7743f85b4 100644
--- a/src/service/reclaim/gnunet-service-reclaim.c
+++ b/src/service/reclaim/gnunet-service-reclaim.c
@@ -21,8 +21,8 @@
  * @author Martin Schanzenbach
  * @file src/reclaim/gnunet-service-reclaim.c
  * @brief reclaim Service
- *
  */
+#include "platform.h"
 #include "gnunet_util_lib.h"
 #include "gnunet-service-reclaim_tickets.h"
 #include "gnunet_gnsrecord_lib.h"
@@ -2518,7 +2518,7 @@ ticket_iter_cb (void *cls, struct GNUNET_RECLAIM_Ticket *ticket)
   trm->id = htonl (ti->r_id);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending TICKET_RESULT message\n");
   trm->tkt_len = htons (tkt_len);
-  trm->presentations_len = htons(0);
+  trm->presentations_len = htons (0);
   GNUNET_MQ_send (ti->client->mq, env);
   if (NULL == ticket)
     GNUNET_free (ti);
diff --git a/src/service/regex/regex_internal_dht.c b/src/service/regex/regex_internal_dht.c
index 9850f106f..48850f87f 100644
--- a/src/service/regex/regex_internal_dht.c
+++ b/src/service/regex/regex_internal_dht.c
@@ -530,13 +530,15 @@ regex_result_iterator (void *cls,
     return GNUNET_YES;   // We found an accept state!
   }
   LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "* %lu, %lu, [%u]\n",
-       (unsigned long) ctx->position,
-       strlen (ctx->info->description),
-       GNUNET_BLOCK_is_accepting (block, result->size));
+       "* %llu, %llu, [%u]\n",
+       (unsigned long long) ctx->position,
+       (unsigned long long) strlen (ctx->info->description),
+       GNUNET_BLOCK_is_accepting (block,
+                                  result->size));
   regex_next_edge (block, result->size, ctx);
 
-  GNUNET_STATISTICS_update (ctx->info->stats, "# regex cadet blocks iterated",
+  GNUNET_STATISTICS_update (ctx->info->stats,
+                            "# regex cadet blocks iterated",
                             1, GNUNET_NO);
 
   return GNUNET_YES;
diff --git a/src/service/testing/gnunet-cmds-helper.c b/src/service/testing/gnunet-cmds-helper.c
index d262955cb..a54191abf 100644
--- a/src/service/testing/gnunet-cmds-helper.c
+++ b/src/service/testing/gnunet-cmds-helper.c
@@ -658,8 +658,8 @@ main (int argc, char **argv)
     for (i = 6; i<argc; i++)
       topology_data_length += strlen (argv[i]) + 1;
     LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "topo data length %lu\n",
-         topology_data_length);
+         "topo data length %llu\n",
+         (unsigned long long) topology_data_length);
     ni->topology_data = GNUNET_malloc (topology_data_length);
     memset (ni->topology_data, '\0', topology_data_length);
     for (i = 6; i<argc; i++)
diff --git a/src/service/transport/gnunet-communicator-udp.c b/src/service/transport/gnunet-communicator-udp.c
index d02043908..29beb4e37 100644
--- a/src/service/transport/gnunet-communicator-udp.c
+++ b/src/service/transport/gnunet-communicator-udp.c
@@ -67,7 +67,7 @@
  * How often do we scan for changes to our network interfaces?
  */
 #define INTERFACE_SCAN_FREQUENCY \
-        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
+  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
 
 /**
  * How long do we believe our addresses to remain up (before
@@ -76,7 +76,7 @@
 #define ADDRESS_VALIDITY_PERIOD GNUNET_TIME_UNIT_HOURS
 
 #define WORKING_QUEUE_INTERVALL \
-        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS,1)
+  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS,1)
 
 /**
  * AES key size.
@@ -1611,8 +1611,8 @@ try_handle_plaintext (struct SenderAddress *sender,
     return; /* no data left */
   }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "try_handle_plaintext of size %lu (%u %lu) and type %u\n",
-              bytes_remaining,
+              "try_handle_plaintext of size %llu (%u %lu) and type %u\n",
+              (unsigned long long) bytes_remaining,
               ntohs (hdr->size),
               sizeof(*hdr),
               ntohs (hdr->type));
@@ -1947,16 +1947,17 @@ sock_read (void *cls)
       if (EAGAIN == errno)
         break; // We are done reading data
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              "Failed to recv from %s family %d failed sock %p\n",
-              GNUNET_a2s ((struct sockaddr*) &sa,
-                          sizeof (addr)),
-              addr->sa_family,
-              udp_sock);
+                  "Failed to recv from %s family %d failed sock %p\n",
+                  GNUNET_a2s ((struct sockaddr*) &sa,
+                              sizeof (addr)),
+                  addr->sa_family,
+                  udp_sock);
       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "recv");
       return;
     }
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Read %lu bytes\n", rcvd);
+                "Read %llu bytes\n",
+                (unsigned long long) rcvd);
     if (0 == rcvd)
     {
       GNUNET_break_op (0);
@@ -2383,12 +2384,12 @@ send_msg_with_kx (const struct GNUNET_MessageHeader *msg, struct
   {
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send");
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              "Sending KX with payload size %u to %s family %d failed sock %p\n",
-              msize,
-              GNUNET_a2s (receiver->address,
-                          receiver->address_len),
+                "Sending KX with payload size %u to %s family %d failed sock %p\n",
+                msize,
+                GNUNET_a2s (receiver->address,
+                            receiver->address_len),
                 receiver->address->sa_family,
-              udp_sock);
+                udp_sock);
     GNUNET_MQ_impl_send_continue (mq);
     receiver_destroy (receiver);
     return;
@@ -2470,9 +2471,9 @@ mq_send_d (struct GNUNET_MQ_Handle *mq,
       (0 == receiver->acks_available))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "msize: %u, mtu: %lu, acks: %u\n",
-                msize,
-                receiver->d_mtu,
+                "msize: %u, mtu: %llu, acks: %u\n",
+                (unsigned int) msize,
+                (unsigned long long) receiver->d_mtu,
                 receiver->acks_available);
 
     GNUNET_break (0);
@@ -2562,11 +2563,11 @@ mq_send_d (struct GNUNET_MQ_Handle *mq,
     {
       GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send");
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Sending UDPBox to %s family %d failed sock %p failed\n",
-                GNUNET_a2s (receiver->address,
-                          receiver->address_len),
-                receiver->address->sa_family,
-                udp_sock);
+                  "Sending UDPBox to %s family %d failed sock %p failed\n",
+                  GNUNET_a2s (receiver->address,
+                              receiver->address_len),
+                  receiver->address->sa_family,
+                  udp_sock);
       receiver_destroy (receiver);
       return;
     }
diff --git a/src/service/transport/test_transport_plugin_cmd_simple_send_performance.c b/src/service/transport/test_transport_plugin_cmd_simple_send_performance.c
index f15311882..33deb3323 100644
--- a/src/service/transport/test_transport_plugin_cmd_simple_send_performance.c
+++ b/src/service/transport/test_transport_plugin_cmd_simple_send_performance.c
@@ -115,7 +115,7 @@ handle_test (void *cls,
 
 
   GNUNET_TRANSPORT_TESTING_get_trait_state (&start_peer,
-                                  &sps);
+                                            &sps);
   ch = sps->th;
   num = ntohl (message->num);
   GNUNET_TESTING_get_trait_async_context (&block_receive,
@@ -165,12 +165,12 @@ handle_test (void *cls,
   sender->num_received++;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "time traveled: %lu\n",
-              time_traveled.rel_value_us);
+              "time traveled: %llu\n",
+              (unsigned long long) time_traveled.rel_value_us);
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "mean time traveled: %s %llu messages received with message number %u\n",
               GNUNET_STRINGS_relative_time_to_string (sender->mean_time,
-                                                      GNUNET_NO),
+                                                      false),
               sender->num_received,
               num);
   if (floor (MAX_RECEIVED * (1 - 1.0 / 200)) < sender->num_received && NULL ==
@@ -255,7 +255,7 @@ notify_connect (struct GNUNET_TESTING_Interpreter *is,
   cmd = GNUNET_TESTING_interpreter_lookup_command (is,
                                                    "connect-peers");
   GNUNET_TRANSPORT_TESTING_get_trait_connect_peer_state (cmd,
-                                               &cps);
+                                                         &cps);
   void *ret = NULL;
 
   cps->notify_connect (is,