curly wars / auto-indentation

12 files changed, 217 insertions, 281 deletions

diff --git a/src/fs/fs_file_information.c b/src/fs/fs_file_information.c
index ce4f189a9..bb84b948e 100644
--- a/src/fs/fs_file_information.c
+++ b/src/fs/fs_file_information.c
@@ -437,7 +437,7 @@ GNUNET_FS_directory_scanner_default (void *cls, struct GNUNET_FS_Handle *h,
  */
 struct MetaValueInformation
 {
-  
+
   /**
    * Mime-type of data.
    */
@@ -481,21 +481,17 @@ struct MetaValueInformation
  *        used in the main libextractor library and yielding
  *        meta data).
  * @param type libextractor-type describing the meta data
- * @param format basic format information about data 
+ * @param format basic format information about data
  * @param data_mime_type mime-type of data (not of the original file);
  *        can be NULL (if mime-type is not known)
  * @param data actual meta-data found
  * @param data_len number of bytes in data
  * @return 0 to continue extracting / iterating
- */ 
+ */
 static int
-update_metamap (void *cls,
-                const char *plugin_name,
-                enum EXTRACTOR_MetaType type,
-                enum EXTRACTOR_MetaFormat format,
-                const char *data_mime_type,
-                const char *data,
-                size_t data_len)
+update_metamap (void *cls, const char *plugin_name,
+                enum EXTRACTOR_MetaType type, enum EXTRACTOR_MetaFormat format,
+                const char *data_mime_type, const char *data, size_t data_len)
 {
   struct GNUNET_CONTAINER_MultiHashMap *map = cls;
   GNUNET_HashCode key;
@@ -512,10 +508,10 @@ update_metamap (void *cls,
     mvi->type = type;
     mvi->format = format;
     GNUNET_CONTAINER_multihashmap_put (map, &key, mvi,
-                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
   }
-  mvi->frequency++;  
-  return 0; 
+  mvi->frequency++;
+  return 0;
 }
 
 
@@ -524,7 +520,7 @@ update_metamap (void *cls,
  */
 struct KeywordInformation
 {
-  
+
   /**
    * Mime-type of keyword.
    */
@@ -581,37 +577,35 @@ struct EntryProcCls
  * @param fi information for publishing the file
  */
 static void
-dirproc_add (void *cls, const char *filename, 
-             struct GNUNET_FS_FileInformation *fi)
+dirproc_add (void *cls, const char *filename,
+             struct GNUNET_FS_FileInformation *fi)
 {
   struct EntryProcCls *dc = cls;
   unsigned int i;
   const char *kw;
   struct KeywordInformation *ki;
   GNUNET_HashCode key;
- 
+
   GNUNET_assert (fi->next == NULL);
   GNUNET_assert (fi->dir == NULL);
   fi->next = dc->entries;
   dc->entries = fi;
   dc->count++;
   if (NULL != fi->meta)
-    GNUNET_CONTAINER_meta_data_iterate (fi->meta,
-                                        &update_metamap,
-                                        dc->metamap);
-  for (i=0;i<fi->keywords->data.ksk.keywordCount;i++)
+    GNUNET_CONTAINER_meta_data_iterate (fi->meta, &update_metamap, dc->metamap);
+  for (i = 0; i < fi->keywords->data.ksk.keywordCount; i++)
   {
-    kw = fi->keywords->data.ksk.keywords[i];   
-    GNUNET_CRYPTO_hash (kw, strlen(kw), &key);
+    kw = fi->keywords->data.ksk.keywords[i];
+    GNUNET_CRYPTO_hash (kw, strlen (kw), &key);
     ki = GNUNET_CONTAINER_multihashmap_get (dc->keywordmap, &key);
     if (ki == NULL)
     {
       ki = GNUNET_malloc (sizeof (struct KeywordInformation));
       ki->keyword = &kw[1];
       GNUNET_CONTAINER_multihashmap_put (dc->keywordmap, &key, ki,
-                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
     }
-    ki->frequency++;  
+    ki->frequency++;
   }
 }
 
@@ -633,7 +627,7 @@ struct ComputeDirectoryMetadataContext
 
   /**
    * Threshold to apply for adding meta data.
-   */ 
+   */
   unsigned int threshold;
 };
 
@@ -650,29 +644,22 @@ struct ComputeDirectoryMetadataContext
  * @return GNUNET_OK
  */
 static int
-compute_directory_metadata (void *cls,
-                            const GNUNET_HashCode *key,
-                            void *value)
+compute_directory_metadata (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct ComputeDirectoryMetadataContext *cdmc = cls;
   struct MetaValueInformation *mvi = value;
 
-  if (mvi->frequency > cdmc->threshold) 
+  if (mvi->frequency > cdmc->threshold)
   {
     if (mvi->type != EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME)
-      (void) GNUNET_CONTAINER_meta_data_insert (cdmc->meta,
-                                                "<children>",
-                                                mvi->type,
-                                                mvi->format,
-                                                mvi->mime_type,
-                                                mvi->data,
-                                                mvi->data_size);
-    if ( (mvi->format == EXTRACTOR_METAFORMAT_UTF8) ||
-         (mvi->format == EXTRACTOR_METAFORMAT_C_STRING) )
-      GNUNET_FS_uri_ksk_add_keyword (cdmc->ksk,
-                                     mvi->data,
-                                     GNUNET_NO);
-  } 
+      (void) GNUNET_CONTAINER_meta_data_insert (cdmc->meta, "<children>",
+                                                mvi->type, mvi->format,
+                                                mvi->mime_type, mvi->data,
+                                                mvi->data_size);
+    if ((mvi->format == EXTRACTOR_METAFORMAT_UTF8) ||
+        (mvi->format == EXTRACTOR_METAFORMAT_C_STRING))
+      GNUNET_FS_uri_ksk_add_keyword (cdmc->ksk, mvi->data, GNUNET_NO);
+  }
   GNUNET_free (mvi);
   return GNUNET_OK;
 }
@@ -680,7 +667,7 @@ compute_directory_metadata (void *cls,
 
 /**
  * Add keywords that occur in more than the threshold entries of the
- * directory to the directory itself.  
+ * directory to the directory itself.
  *
  * @param cls the 'struct ComputeDirectoryMetadataContext'
  * @param key unused
@@ -688,17 +675,13 @@ compute_directory_metadata (void *cls,
  * @return GNUNET_OK
  */
 static int
-compute_directory_keywords (void *cls,
-                            const GNUNET_HashCode *key,
-                            void *value)
+compute_directory_keywords (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct ComputeDirectoryMetadataContext *cdmc = cls;
   struct KeywordInformation *ki = value;
 
-  if (ki->frequency > cdmc->threshold)       
-    (void) GNUNET_FS_uri_ksk_add_keyword (cdmc->ksk,
-                                          ki->keyword,
-                                          GNUNET_NO);
+  if (ki->frequency > cdmc->threshold)
+    (void) GNUNET_FS_uri_ksk_add_keyword (cdmc->ksk, ki->keyword, GNUNET_NO);
   GNUNET_free (ki);
   return GNUNET_OK;
 }
@@ -751,36 +734,31 @@ GNUNET_FS_file_information_create_from_directory (struct GNUNET_FS_Handle *h,
   dc.metamap = GNUNET_CONTAINER_multihashmap_create (64);
   dc.keywordmap = GNUNET_CONTAINER_multihashmap_create (64);
   /* update children to point to directory and generate statistics
-     on all meta data in children */
+   * on all meta data in children */
   scanner (scanner_cls, h, filename, do_index, bo, &dirproc_add, &dc, emsg);
   cdmc.meta = GNUNET_CONTAINER_meta_data_create ();
   cdmc.ksk = GNUNET_malloc (sizeof (struct GNUNET_FS_Uri));
   cdmc.ksk->type = ksk;
-  cdmc.threshold = 1 + dc.count / 2; /* 50% threshold for now */
+  cdmc.threshold = 1 + dc.count / 2;    /* 50% threshold for now */
   GNUNET_FS_meta_data_make_directory (cdmc.meta);
   GNUNET_CONTAINER_multihashmap_iterate (dc.metamap,
-                                         &compute_directory_metadata,
-                                         &cdmc);
+                                         &compute_directory_metadata, &cdmc);
   GNUNET_CONTAINER_multihashmap_iterate (dc.keywordmap,
-                                         &compute_directory_keywords,
-                                         &cdmc);
+                                         &compute_directory_keywords, &cdmc);
   GNUNET_CONTAINER_multihashmap_destroy (dc.metamap);
   GNUNET_CONTAINER_multihashmap_destroy (dc.keywordmap);
-  GNUNET_FS_uri_ksk_add_keyword (cdmc.ksk,
-                                 GNUNET_FS_DIRECTORY_MIME,
-                                 GNUNET_NO);
+  GNUNET_FS_uri_ksk_add_keyword (cdmc.ksk, GNUNET_FS_DIRECTORY_MIME, GNUNET_NO);
   cksk = GNUNET_FS_uri_ksk_canonicalize (cdmc.ksk);
 
   /* remove keywords in children that are already in the
-     parent */
+   * parent */
   for (epos = dc.entries; NULL != epos; epos = epos->next)
   {
-    for (i=0;i<cksk->data.ksk.keywordCount;i++)
-      {
-        kw = cksk->data.ksk.keywords[i];
-        GNUNET_FS_uri_ksk_remove_keyword (epos->keywords,
-                                          &kw[1]);
-      }
+    for (i = 0; i < cksk->data.ksk.keywordCount; i++)
+    {
+      kw = cksk->data.ksk.keywords[i];
+      GNUNET_FS_uri_ksk_remove_keyword (epos->keywords, &kw[1]);
+    }
   }
   ret =
       GNUNET_FS_file_information_create_empty_directory (h, client_info, cksk,
diff --git a/src/fs/fs_uri.c b/src/fs/fs_uri.c
index 2057a18f6..48fabc1fb 100644
--- a/src/fs/fs_uri.c
+++ b/src/fs/fs_uri.c
@@ -1033,9 +1033,8 @@ canonicalize_keyword (const char *in)
       wpos++;
       break;
     default:
-      if (isspace ((unsigned char) *rpos) || 
-          isdigit ((unsigned char) *rpos) )
-        break;
+      if (isspace ((unsigned char) *rpos) || isdigit ((unsigned char) *rpos))
+        break;
       /* replace characters listed above with '_' */
       *wpos = '_';
       wpos++;
@@ -1073,24 +1072,19 @@ GNUNET_FS_uri_ksk_canonicalize (const struct GNUNET_FS_Uri *uri)
   for (i = 0; i < kc; i++)
   {
     in = uri->data.ksk.keywords[i];
-    GNUNET_FS_uri_ksk_add_keyword (ret,
-                                   &in[1],
-                                   (in[0] == '+') ? GNUNET_YES : GNUNET_NO);
+    GNUNET_FS_uri_ksk_add_keyword (ret, &in[1],
+                                   (in[0] == '+') ? GNUNET_YES : GNUNET_NO);
     sb = GNUNET_strdup (&in[1]);
 #define DELIMS " \\|\"'`/&@-_,.;!?+-*^$#~=[]{}()<>"
     for (tok = strtok (sb, DELIMS); NULL != tok; tok = strtok (NULL, DELIMS))
 #undef DELIMS
     {
-      if (strlen(tok) < 3)
-        continue;
-      GNUNET_FS_uri_ksk_add_keyword (ret,
-                                     tok,
-                                     GNUNET_NO);
+      if (strlen (tok) < 3)
+        continue;
+      GNUNET_FS_uri_ksk_add_keyword (ret, tok, GNUNET_NO);
       cc = canonicalize_keyword (tok);
       if (strlen (cc) > 2)
-        GNUNET_FS_uri_ksk_add_keyword (ret,
-                                       cc,
-                                       GNUNET_NO);    
+        GNUNET_FS_uri_ksk_add_keyword (ret, cc, GNUNET_NO);
     }
     GNUNET_free (sb);
   }
diff --git a/src/fs/gnunet-fs.c b/src/fs/gnunet-fs.c
index 9b3602d73..310c8a1ae 100644
--- a/src/fs/gnunet-fs.c
+++ b/src/fs/gnunet-fs.c
@@ -53,8 +53,7 @@ static int verbose;
  * @param tc unused
  */
 static void
-do_shutdown (void *cls,
-             const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_FS_stop (fs);
   fs = NULL;
@@ -70,18 +69,12 @@ do_shutdown (void *cls,
  * @return GNUNET_OK to continue iteration
  */
 static int
-print_indexed (void *cls, const char *filename,
-               const GNUNET_HashCode * file_id)
+print_indexed (void *cls, const char *filename, const GNUNET_HashCode * file_id)
 {
   if (verbose)
-    fprintf (stdout,
-             "%s: %s\n",
-             GNUNET_h2s (file_id),
-             filename);
+    fprintf (stdout, "%s: %s\n", GNUNET_h2s (file_id), filename);
   else
-    fprintf (stdout,
-             "%s\n",
-             filename);
+    fprintf (stdout, "%s\n", filename);
   return GNUNET_OK;
 }
 
@@ -100,18 +93,13 @@ run (void *cls, char *const *args, const char *cfgfile,
 {
   if (list_indexed_files)
   {
-    fs = GNUNET_FS_start (cfg,
-                          "gnunet-fs",
-                          NULL, NULL,
-                          GNUNET_FS_FLAGS_NONE);
+    fs = GNUNET_FS_start (cfg, "gnunet-fs", NULL, NULL, GNUNET_FS_FLAGS_NONE);
     if (NULL == fs)
     {
       ret = 1;
       return;
     }
-    GNUNET_FS_get_indexed_files (fs,
-                                 &print_indexed, NULL,
-                                 &do_shutdown, NULL);
+    GNUNET_FS_get_indexed_files (fs, &print_indexed, NULL, &do_shutdown, NULL);
   }
 }
 
@@ -134,8 +122,7 @@ main (int argc, char *const *argv)
   };
   return (GNUNET_OK ==
           GNUNET_PROGRAM_run (argc, argv, "gnunet-fs [OPTIONS]",
-                              gettext_noop
-                              ("Special file-sharing operations"),
+                              gettext_noop ("Special file-sharing operations"),
                               options, &run, NULL)) ? ret : 1;
 }
 
diff --git a/src/fs/gnunet-service-fs.c b/src/fs/gnunet-service-fs.c
index 404993130..f588ee9c4 100644
--- a/src/fs/gnunet-service-fs.c
+++ b/src/fs/gnunet-service-fs.c
@@ -226,19 +226,20 @@ GSF_test_get_load_too_high_ (uint32_t priority)
  */
 static void
 update_latencies (const struct GNUNET_ATS_Information *atsi,
-                  unsigned int atsi_count)
+                  unsigned int atsi_count)
 {
   unsigned int i;
 
-  for (i=0;i<atsi_count;i++)
+  for (i = 0; i < atsi_count; i++)
   {
-    if (ntohl(atsi[i].type) == GNUNET_ATS_QUALITY_NET_DELAY)
+    if (ntohl (atsi[i].type) == GNUNET_ATS_QUALITY_NET_DELAY)
     {
-      GSF_avg_latency.rel_value = (GSF_avg_latency.rel_value * 31 + ntohl (atsi[i].value)) / 32;
+      GSF_avg_latency.rel_value =
+          (GSF_avg_latency.rel_value * 31 + ntohl (atsi[i].value)) / 32;
       GNUNET_STATISTICS_set (GSF_stats,
-                             gettext_noop ("# running average P2P latency (ms)"),
-                             GSF_avg_latency.rel_value,
-                             GNUNET_NO);
+                             gettext_noop
+                             ("# running average P2P latency (ms)"),
+                             GSF_avg_latency.rel_value, GNUNET_NO);
       break;
     }
   }
@@ -261,7 +262,7 @@ static int
 handle_p2p_put (void *cls, const struct GNUNET_PeerIdentity *other,
                 const struct GNUNET_MessageHeader *message,
                 const struct GNUNET_ATS_Information *atsi,
-                unsigned int atsi_count)
+                unsigned int atsi_count)
 {
   struct GSF_ConnectedPeer *cp;
 
@@ -294,13 +295,11 @@ consider_request_for_forwarding (void *cls,
 {
   struct GSF_PendingRequest *pr = cls;
 
-  if (GNUNET_YES !=
-      GSF_pending_request_test_target_ (pr,
-                                        peer))
+  if (GNUNET_YES != GSF_pending_request_test_target_ (pr, peer))
   {
     GNUNET_STATISTICS_update (GSF_stats,
-                              gettext_noop ("# Loopback routes suppressed"), 1,
-                              GNUNET_NO);
+                              gettext_noop ("# Loopback routes suppressed"), 1,
+                              GNUNET_NO);
     return;
   }
   GSF_plan_add_ (cp, pr);
@@ -343,7 +342,7 @@ static int
 handle_p2p_get (void *cls, const struct GNUNET_PeerIdentity *other,
                 const struct GNUNET_MessageHeader *message,
                 const struct GNUNET_ATS_Information *atsi,
-                unsigned int atsi_count)
+                unsigned int atsi_count)
 {
   struct GSF_PendingRequest *pr;
 
@@ -475,13 +474,11 @@ consider_peer_for_forwarding (void *cls, const GNUNET_HashCode * key,
   struct GNUNET_PeerIdentity pid;
 
   GSF_connected_peer_get_identity_ (cp, &pid);
-  if (GNUNET_YES !=
-      GSF_pending_request_test_target_ (pr,
-                                        &pid))
+  if (GNUNET_YES != GSF_pending_request_test_target_ (pr, &pid))
   {
     GNUNET_STATISTICS_update (GSF_stats,
-                              gettext_noop ("# Loopback routes suppressed"), 1,
-                              GNUNET_NO);
+                              gettext_noop ("# Loopback routes suppressed"), 1,
+                              GNUNET_NO);
     return GNUNET_YES;
   }
   GSF_plan_add_ (cp, pr);
@@ -500,7 +497,7 @@ consider_peer_for_forwarding (void *cls, const GNUNET_HashCode * key,
 static void
 peer_connect_handler (void *cls, const struct GNUNET_PeerIdentity *peer,
                       const struct GNUNET_ATS_Information *atsi,
-                      unsigned int atsi_count)
+                      unsigned int atsi_count)
 {
   struct GSF_ConnectedPeer *cp;
 
@@ -568,9 +565,8 @@ main_init (struct GNUNET_SERVER_Handle *server,
   GSF_core = GNUNET_CORE_connect (GSF_cfg, 2,   /* larger? */
                                   NULL, &peer_init_handler,
                                   &peer_connect_handler,
-                                  &GSF_peer_disconnect_handler_,
-                                  NULL, GNUNET_NO,
-                                  NULL, GNUNET_NO, p2p_handlers);
+                                  &GSF_peer_disconnect_handler_, NULL,
+                                  GNUNET_NO, NULL, GNUNET_NO, p2p_handlers);
   if (NULL == GSF_core)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
diff --git a/src/fs/gnunet-service-fs_cp.c b/src/fs/gnunet-service-fs_cp.c
index 859d9275f..d4c81d509 100644
--- a/src/fs/gnunet-service-fs_cp.c
+++ b/src/fs/gnunet-service-fs_cp.c
@@ -332,15 +332,14 @@ get_trust_filename (const struct GNUNET_PeerIdentity *id)
  * @return connection latency
  */
 static struct GNUNET_TIME_Relative
-get_latency (const struct GNUNET_ATS_Information *atsi,
-             unsigned int atsi_count)
+get_latency (const struct GNUNET_ATS_Information *atsi, unsigned int atsi_count)
 {
   unsigned int i;
 
-  for (i=0;i<atsi_count;i++)
+  for (i = 0; i < atsi_count; i++)
     if (ntohl (atsi->type) == GNUNET_ATS_QUALITY_NET_DELAY)
       return GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
-                                            ntohl (atsi->value));
+                                            ntohl (atsi->value));
   return GNUNET_TIME_UNIT_SECONDS;
 }
 
@@ -354,8 +353,7 @@ get_latency (const struct GNUNET_ATS_Information *atsi,
  */
 static void
 update_atsi (struct GSF_ConnectedPeer *cp,
-             const struct GNUNET_ATS_Information *atsi,
-             unsigned int atsi_count)
+             const struct GNUNET_ATS_Information *atsi, unsigned int atsi_count)
 {
   struct GNUNET_TIME_Relative latency;
 
@@ -402,7 +400,7 @@ peer_transmit_ready_cb (void *cls, size_t size, void *buf);
  */
 static void
 ats_reserve_callback (void *cls, const struct GNUNET_PeerIdentity *peer,
-                       int32_t amount, struct GNUNET_TIME_Relative res_delay);
+                      int32_t amount, struct GNUNET_TIME_Relative res_delay);
 
 
 /**
@@ -425,11 +423,9 @@ schedule_transmission (struct GSF_PeerTransmitHandle *pth)
 
   if (0 != cp->inc_preference)
   {
-    GNUNET_ATS_change_preference (ats,
-                                  &target,
-                                  GNUNET_ATS_PREFERENCE_BANDWIDTH,
-                                  (double) cp->inc_preference,
-                                  GNUNET_ATS_PREFERENCE_END);
+    GNUNET_ATS_change_preference (ats, &target, GNUNET_ATS_PREFERENCE_BANDWIDTH,
+                                  (double) cp->inc_preference,
+                                  GNUNET_ATS_PREFERENCE_END);
     cp->inc_preference = 0;
   }
 
@@ -442,9 +438,8 @@ schedule_transmission (struct GSF_PeerTransmitHandle *pth)
     /* reservation already done! */
     pth->was_reserved = GNUNET_YES;
     cp->rc =
-        GNUNET_ATS_reserve_bandwidth (ats, &target,
-                                      DBLOCK_SIZE, 
-                                      &ats_reserve_callback, cp);
+        GNUNET_ATS_reserve_bandwidth (ats, &target, DBLOCK_SIZE,
+                                      &ats_reserve_callback, cp);
   }
   GNUNET_assert (pth->cth == NULL);
   pth->cth_in_progress++;
@@ -525,9 +520,8 @@ retry_reservation (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_PEER_resolve (cp->ppd.pid, &target);
   cp->rc_delay_task = GNUNET_SCHEDULER_NO_TASK;
   cp->rc =
-      GNUNET_ATS_reserve_bandwidth (ats, &target,
-                                    DBLOCK_SIZE, 
-                                    &ats_reserve_callback, cp);
+      GNUNET_ATS_reserve_bandwidth (ats, &target, DBLOCK_SIZE,
+                                    &ats_reserve_callback, cp);
 }
 
 
@@ -543,15 +537,14 @@ retry_reservation (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  */
 static void
 ats_reserve_callback (void *cls, const struct GNUNET_PeerIdentity *peer,
-                      int32_t amount, struct GNUNET_TIME_Relative res_delay)
+                      int32_t amount, struct GNUNET_TIME_Relative res_delay)
 {
   struct GSF_ConnectedPeer *cp = cls;
   struct GSF_PeerTransmitHandle *pth;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Reserved %d bytes / need to wait %llu ms for reservation\n",
-              (int) amount,
-              (unsigned long long) res_delay.rel_value);
+              "Reserved %d bytes / need to wait %llu ms for reservation\n",
+              (int) amount, (unsigned long long) res_delay.rel_value);
   cp->rc = NULL;
   if (0 == amount)
   {
@@ -587,22 +580,20 @@ ats_reserve_callback (void *cls, const struct GNUNET_PeerIdentity *peer,
 struct GSF_ConnectedPeer *
 GSF_peer_connect_handler_ (const struct GNUNET_PeerIdentity *peer,
                            const struct GNUNET_ATS_Information *atsi,
-                           unsigned int atsi_count)
+                           unsigned int atsi_count)
 {
   struct GSF_ConnectedPeer *cp;
   char *fn;
   uint32_t trust;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Connected to peer %s\n",
-              GNUNET_i2s (peer));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connected to peer %s\n",
+              GNUNET_i2s (peer));
   cp = GNUNET_malloc (sizeof (struct GSF_ConnectedPeer));
   cp->ppd.pid = GNUNET_PEER_intern (peer);
   cp->ppd.transmission_delay = GNUNET_LOAD_value_init (GNUNET_TIME_UNIT_ZERO);
   cp->rc =
-      GNUNET_ATS_reserve_bandwidth (ats, peer,
-                                    DBLOCK_SIZE, 
-                                    &ats_reserve_callback, cp);
+      GNUNET_ATS_reserve_bandwidth (ats, peer, DBLOCK_SIZE,
+                                    &ats_reserve_callback, cp);
   fn = get_trust_filename (peer);
   if ((GNUNET_DISK_file_test (fn) == GNUNET_YES) &&
       (sizeof (trust) == GNUNET_DISK_fn_read (fn, &trust, sizeof (trust))))
@@ -613,11 +604,9 @@ GSF_peer_connect_handler_ (const struct GNUNET_PeerIdentity *peer,
                 GNUNET_CONTAINER_multihashmap_put (cp_map, &peer->hashPubKey,
                                                    cp,
                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-  GNUNET_STATISTICS_set (GSF_stats,
-                         gettext_noop
-                         ("# peers connected"), 
-                         GNUNET_CONTAINER_multihashmap_size (cp_map),
-                         GNUNET_NO);
+  GNUNET_STATISTICS_set (GSF_stats, gettext_noop ("# peers connected"),
+                         GNUNET_CONTAINER_multihashmap_size (cp_map),
+                         GNUNET_NO);
   update_atsi (cp, atsi, atsi_count);
   GSF_push_start_ (cp);
   return cp;
@@ -681,9 +670,8 @@ int
 GSF_handle_p2p_migration_stop_ (void *cls,
                                 const struct GNUNET_PeerIdentity *other,
                                 const struct GNUNET_MessageHeader *message,
-                                const struct GNUNET_ATS_Information
-                                *atsi,
-                                unsigned int atsi_count)
+                                const struct GNUNET_ATS_Information *atsi,
+                                unsigned int atsi_count)
 {
   struct GSF_ConnectedPeer *cp;
   const struct MigrationStopMessage *msm;
@@ -697,9 +685,8 @@ GSF_handle_p2p_migration_stop_ (void *cls,
     return GNUNET_OK;
   }
   GNUNET_STATISTICS_update (GSF_stats,
-                            gettext_noop
-                            ("# migration stop messages received"),
-                            1, GNUNET_NO);
+                            gettext_noop ("# migration stop messages received"),
+                            1, GNUNET_NO);
   bt = GNUNET_TIME_relative_ntoh (msm->duration);
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               _("Migration of content to peer `%s' blocked for %llu ms\n"),
@@ -841,8 +828,8 @@ get_randomized_delay ()
   ret =
       GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
                                      GNUNET_CRYPTO_random_u32
-                                     (GNUNET_CRYPTO_QUALITY_WEAK, 
-                                      2 * GSF_avg_latency.rel_value + 1));
+                                     (GNUNET_CRYPTO_QUALITY_WEAK,
+                                      2 * GSF_avg_latency.rel_value + 1));
   GNUNET_STATISTICS_update (GSF_stats,
                             gettext_noop
                             ("# artificial delays introduced (ms)"),
@@ -1179,7 +1166,7 @@ GSF_handle_p2p_query_ (const struct GNUNET_PeerIdentity *other,
     return NULL;
   }
   if (0 != (bm & GET_MESSAGE_BIT_RETURN_TO))
-    cp = GSF_peer_get_ ((const struct GNUNET_PeerIdentity*) &opt[bits++]);
+    cp = GSF_peer_get_ ((const struct GNUNET_PeerIdentity *) &opt[bits++]);
   else
     cp = cps;
   if (cp == NULL)
@@ -1323,9 +1310,7 @@ GSF_handle_p2p_query_ (const struct GNUNET_PeerIdentity *other,
                                      0) ? (const char *) &opt[bits] : NULL,
                                     bfsize, ntohl (gm->filter_mutator),
                                     1 /* anonymity */ ,
-                                    (uint32_t) priority, ttl, spid,
-                                    GNUNET_PEER_intern (other),
-                                    NULL, 0,    /* replies_seen */
+                                    (uint32_t) priority, ttl, spid, GNUNET_PEER_intern (other), NULL, 0,        /* replies_seen */
                                     &handle_p2p_reply, peerreq);
   GNUNET_assert (NULL != pr);
   peerreq->pr = pr;
@@ -1547,11 +1532,9 @@ GSF_peer_disconnect_handler_ (void *cls, const struct GNUNET_PeerIdentity *peer)
   GNUNET_assert (GNUNET_YES ==
                  GNUNET_CONTAINER_multihashmap_remove (cp_map,
                                                        &peer->hashPubKey, cp));
-  GNUNET_STATISTICS_set (GSF_stats,
-                         gettext_noop
-                         ("# peers connected"), 
-                         GNUNET_CONTAINER_multihashmap_size (cp_map),
-                         GNUNET_NO);
+  GNUNET_STATISTICS_set (GSF_stats, gettext_noop ("# peers connected"),
+                         GNUNET_CONTAINER_multihashmap_size (cp_map),
+                         GNUNET_NO);
   if (NULL != cp->migration_pth)
   {
     GSF_peer_transmit_cancel_ (cp->migration_pth);
diff --git a/src/fs/gnunet-service-fs_cp.h b/src/fs/gnunet-service-fs_cp.h
index 8923513c7..a2cc5232c 100644
--- a/src/fs/gnunet-service-fs_cp.h
+++ b/src/fs/gnunet-service-fs_cp.h
@@ -174,7 +174,7 @@ struct GSF_PeerTransmitHandle;
 struct GSF_ConnectedPeer *
 GSF_peer_connect_handler_ (const struct GNUNET_PeerIdentity *peer,
                            const struct GNUNET_ATS_Information *atsi,
-                           unsigned int atsi_count);
+                           unsigned int atsi_count);
 
 
 /**
@@ -270,9 +270,8 @@ int
 GSF_handle_p2p_migration_stop_ (void *cls,
                                 const struct GNUNET_PeerIdentity *other,
                                 const struct GNUNET_MessageHeader *message,
-                                const struct GNUNET_ATS_Information
-                                *atsi,
-                                unsigned int atsi_count);
+                                const struct GNUNET_ATS_Information *atsi,
+                                unsigned int atsi_count);
 
 
 /**
diff --git a/src/fs/gnunet-service-fs_indexing.c b/src/fs/gnunet-service-fs_indexing.c
index 5978e4d66..41a40e125 100644
--- a/src/fs/gnunet-service-fs_indexing.c
+++ b/src/fs/gnunet-service-fs_indexing.c
@@ -538,13 +538,12 @@ GNUNET_FS_handle_on_demand_block (const GNUNET_HashCode * key, uint32_t size,
   odb = (const struct OnDemandBlock *) data;
   off = GNUNET_ntohll (odb->offset);
   fn = (const char *) GNUNET_CONTAINER_multihashmap_get (ifm, &odb->file_id);
-  if ( (NULL == fn) ||
-       (0 != ACCESS (fn, R_OK)) )
+  if ((NULL == fn) || (0 != ACCESS (fn, R_OK)))
   {
     GNUNET_STATISTICS_update (GSF_stats,
-                              gettext_noop ("# index blocks removed: original file inaccessible"),
-                              1,
-                              GNUNET_YES);
+                              gettext_noop
+                              ("# index blocks removed: original file inaccessible"),
+                              1, GNUNET_YES);
     GNUNET_DATASTORE_remove (dsh, key, size, data, -1, -1,
                              GNUNET_TIME_UNIT_FOREVER_REL, &remove_cont, NULL);
     return GNUNET_SYSERR;
diff --git a/src/fs/gnunet-service-fs_lc.c b/src/fs/gnunet-service-fs_lc.c
index 9f284ed8f..30a7f57d6 100644
--- a/src/fs/gnunet-service-fs_lc.c
+++ b/src/fs/gnunet-service-fs_lc.c
@@ -375,7 +375,8 @@ GSF_local_client_start_search_handler_ (struct GNUNET_SERVER_Client *client,
                                         ntohl (sm->anonymity_level),
                                         0 /* priority */ ,
                                         0 /* ttl */ ,
-                                        0 /* sender PID */ , 0 /* origin PID */,
+                                        0 /* sender PID */ ,
+                                        0 /* origin PID */ ,
                                         (const GNUNET_HashCode *) &sm[1], sc,
                                         &client_response_handler, cr);
   return cr->pr;
diff --git a/src/fs/gnunet-service-fs_pe.c b/src/fs/gnunet-service-fs_pe.c
index 088a3dc11..41dd61a64 100644
--- a/src/fs/gnunet-service-fs_pe.c
+++ b/src/fs/gnunet-service-fs_pe.c
@@ -263,22 +263,25 @@ plan (struct PeerPlan *pp, struct GSF_RequestPlan *rp)
   if (rp->transmission_counter < 8)
     delay =
         GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
-                                       rp->transmission_counter);
+                                       rp->transmission_counter);
   else if (rp->transmission_counter < 32)
     delay =
         GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
-                                       8 + (1LL << (rp->transmission_counter - 8)));
+                                       8 +
+                                       (1LL << (rp->transmission_counter - 8)));
   else
-    delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 
-                                           8 + (1LL << 24));
-  delay.rel_value = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
-                                              delay.rel_value + 1);
+    delay =
+        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
+                                       8 + (1LL << 24));
+  delay.rel_value =
+      GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                delay.rel_value + 1);
   if (rp->transmission_counter != 0)
     delay.rel_value += TTL_DECREMENT;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Considering (re)transmission number %u in %llu ms\n",
-              (unsigned int) rp->transmission_counter,
-              (unsigned long long) delay.rel_value);
+              "Considering (re)transmission number %u in %llu ms\n",
+              (unsigned int) rp->transmission_counter,
+              (unsigned long long) delay.rel_value);
   rp->earliest_transmission = GNUNET_TIME_relative_to_absolute (delay);
 #if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -295,9 +298,9 @@ plan (struct PeerPlan *pp, struct GSF_RequestPlan *rp)
         GNUNET_CONTAINER_heap_insert (pp->delay_heap, rp,
                                       rp->earliest_transmission.abs_value);
   GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_multihashmap_contains_value (pp->plan_map,
-                                                               get_rp_key (rp),
-                                                               rp));
+                 GNUNET_CONTAINER_multihashmap_contains_value (pp->plan_map,
+                                                               get_rp_key (rp),
+                                                               rp));
   if (GNUNET_SCHEDULER_NO_TASK != pp->task)
     GNUNET_SCHEDULER_cancel (pp->task);
   pp->task = GNUNET_SCHEDULER_add_now (&schedule_peer_transmission, pp);
@@ -351,8 +354,9 @@ transmit_message_callback (void *cls, size_t buf_size, void *buf)
     /* failed, try again... */
     pp->task = GNUNET_SCHEDULER_add_now (&schedule_peer_transmission, pp);
     GNUNET_STATISTICS_update (GSF_stats,
-                              gettext_noop ("# transmission failed (core has no bandwidth)"), 1,
-                              GNUNET_NO);
+                              gettext_noop
+                              ("# transmission failed (core has no bandwidth)"),
+                              1, GNUNET_NO);
     return 0;
   }
   rp = GNUNET_CONTAINER_heap_peek (pp->priority_heap);
@@ -433,22 +437,17 @@ schedule_peer_transmission (void *cls,
 #if DEBUG_FS
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Sleeping for %llu ms before retrying requests on plan %p.\n",
-                (unsigned long long)
-                delay.rel_value, pp);
+                (unsigned long long) delay.rel_value, pp);
 #endif
-    GNUNET_STATISTICS_set (GSF_stats,
-                           gettext_noop ("# delay heap timeout"), 
-                           delay.rel_value,
-                           GNUNET_NO);
-    
+    GNUNET_STATISTICS_set (GSF_stats, gettext_noop ("# delay heap timeout"),
+                           delay.rel_value, GNUNET_NO);
+
     pp->task =
-      GNUNET_SCHEDULER_add_delayed (delay,
-                                      &schedule_peer_transmission, pp);
+        GNUNET_SCHEDULER_add_delayed (delay, &schedule_peer_transmission, pp);
     return;
   }
-  GNUNET_STATISTICS_update (GSF_stats,
-                            gettext_noop ("# query plans executed"), 1,
-                            GNUNET_NO);
+  GNUNET_STATISTICS_update (GSF_stats, gettext_noop ("# query plans executed"),
+                            1, GNUNET_NO);
   /* process from priority heap */
   rp = GNUNET_CONTAINER_heap_peek (pp->priority_heap);
 #if DEBUG_FS > 1
@@ -488,9 +487,7 @@ struct MergeContext
  *         GNUNET_NO if not (merge success)
  */
 static int
-merge_pr (void *cls, 
-          const GNUNET_HashCode *query,
-          void *element)
+merge_pr (void *cls, const GNUNET_HashCode * query, void *element)
 {
   struct MergeContext *mpr = cls;
   struct GSF_RequestPlan *rp = element;
@@ -550,8 +547,7 @@ GSF_plan_add_ (struct GSF_ConnectedPeer *cp, struct GSF_PendingRequest *pr)
   if (NULL == pp)
   {
     pp = GNUNET_malloc (sizeof (struct PeerPlan));
-    pp->plan_map =
-      GNUNET_CONTAINER_multihashmap_create (128);
+    pp->plan_map = GNUNET_CONTAINER_multihashmap_create (128);
     pp->priority_heap =
         GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MAX);
     pp->delay_heap =
@@ -563,13 +559,13 @@ GSF_plan_add_ (struct GSF_ConnectedPeer *cp, struct GSF_PendingRequest *pr)
   mpc.merged = GNUNET_NO;
   mpc.pr = pr;
   GNUNET_CONTAINER_multihashmap_get_multiple (pp->plan_map,
-                                              &GSF_pending_request_get_data_ (pr)->query,
-                                              &merge_pr, &mpc);
+                                              &GSF_pending_request_get_data_
+                                              (pr)->query, &merge_pr, &mpc);
   if (mpc.merged != GNUNET_NO)
     return;
   GNUNET_CONTAINER_multihashmap_get_multiple (pp->plan_map,
-                                              &GSF_pending_request_get_data_ (pr)->query,
-                                              &merge_pr, &mpc);
+                                              &GSF_pending_request_get_data_
+                                              (pr)->query, &merge_pr, &mpc);
   if (mpc.merged != GNUNET_NO)
     return;
   plan_count++;
@@ -592,10 +588,9 @@ GSF_plan_add_ (struct GSF_ConnectedPeer *cp, struct GSF_PendingRequest *pr)
   GNUNET_CONTAINER_DLL_insert (rp->prl_head, rp->prl_tail, prl);
   rp->pp = pp;
   GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_multihashmap_put (pp->plan_map,
-                                                    get_rp_key (rp),
-                                                    rp,
-                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+                 GNUNET_CONTAINER_multihashmap_put (pp->plan_map,
+                                                    get_rp_key (rp), rp,
+                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
   plan (pp, rp);
 }
 
@@ -632,9 +627,8 @@ GSF_plan_notify_peer_disconnect_ (const struct GSF_ConnectedPeer *cp)
   while (NULL != (rp = GNUNET_CONTAINER_heap_remove_root (pp->priority_heap)))
   {
     GNUNET_break (GNUNET_YES ==
-                  GNUNET_CONTAINER_multihashmap_remove (pp->plan_map,
-                                                        get_rp_key (rp),
-                                                        rp));
+                  GNUNET_CONTAINER_multihashmap_remove (pp->plan_map,
+                                                        get_rp_key (rp), rp));
     while (NULL != (prl = rp->prl_head))
     {
       GNUNET_CONTAINER_DLL_remove (rp->prl_head, rp->prl_tail, prl);
@@ -649,9 +643,8 @@ GSF_plan_notify_peer_disconnect_ (const struct GSF_ConnectedPeer *cp)
   while (NULL != (rp = GNUNET_CONTAINER_heap_remove_root (pp->delay_heap)))
   {
     GNUNET_break (GNUNET_YES ==
-                  GNUNET_CONTAINER_multihashmap_remove (pp->plan_map,
-                                                        get_rp_key (rp),
-                                                        rp));
+                  GNUNET_CONTAINER_multihashmap_remove (pp->plan_map,
+                                                        get_rp_key (rp), rp));
     while (NULL != (prl = rp->prl_head))
     {
       GNUNET_CONTAINER_DLL_remove (rp->prl_head, rp->prl_tail, prl);
@@ -695,9 +688,10 @@ GSF_plan_notify_request_done_ (struct GSF_PendingRequest *pr)
       GNUNET_CONTAINER_heap_remove_node (rp->hn);
       plan_count--;
       GNUNET_break (GNUNET_YES ==
-                    GNUNET_CONTAINER_multihashmap_remove (rp->pp->plan_map,
-                                                          &GSF_pending_request_get_data_ (rpr->prl->pr)->query,
-                                                          rp));
+                    GNUNET_CONTAINER_multihashmap_remove (rp->pp->plan_map,
+                                                          &GSF_pending_request_get_data_
+                                                          (rpr->prl->pr)->query,
+                                                          rp));
       GNUNET_free (rp);
     }
     GNUNET_free (rpr->prl);
diff --git a/src/fs/gnunet-service-fs_pr.c b/src/fs/gnunet-service-fs_pr.c
index 63ae3a75f..ac183a980 100644
--- a/src/fs/gnunet-service-fs_pr.c
+++ b/src/fs/gnunet-service-fs_pr.c
@@ -216,10 +216,10 @@ refresh_bloomfilter (struct GSF_PendingRequest *pr)
   if (pr->bf != NULL)
     GNUNET_CONTAINER_bloomfilter_free (pr->bf);
   pr->mingle =
-    GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, UINT32_MAX);
-  pr->bf = GNUNET_BLOCK_construct_bloomfilter (pr->mingle,
-                                               pr->replies_seen,
-                                               pr->replies_seen_count);
+      GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, UINT32_MAX);
+  pr->bf =
+      GNUNET_BLOCK_construct_bloomfilter (pr->mingle, pr->replies_seen,
+                                          pr->replies_seen_count);
 }
 
 
@@ -319,7 +319,8 @@ GSF_pending_request_create_ (enum GSF_PendingRequestOptions options,
   if (NULL != bf_data)
   {
     pr->bf =
-        GNUNET_CONTAINER_bloomfilter_init (bf_data, bf_size, GNUNET_CONSTANTS_BLOOMFILTER_K);
+        GNUNET_CONTAINER_bloomfilter_init (bf_data, bf_size,
+                                           GNUNET_CONSTANTS_BLOOMFILTER_K);
     pr->mingle = mingle;
   }
   else if ((replies_seen_count > 0) &&
@@ -433,17 +434,16 @@ GSF_pending_request_update_ (struct GSF_PendingRequest *pr,
       pr->mingle =
           GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, UINT32_MAX);
       pr->bf =
-        GNUNET_BLOCK_construct_bloomfilter (pr->mingle,
-                                            replies_seen,
-                                            replies_seen_count);
-    } 
+          GNUNET_BLOCK_construct_bloomfilter (pr->mingle, replies_seen,
+                                              replies_seen_count);
+    }
     else
     {
       for (i = 0; i < pr->replies_seen_count; i++)
-        {
-          GNUNET_BLOCK_mingle_hash (&replies_seen[i], pr->mingle, &mhash);
-          GNUNET_CONTAINER_bloomfilter_add (pr->bf, &mhash);
-        }
+      {
+        GNUNET_BLOCK_mingle_hash (&replies_seen[i], pr->mingle, &mhash);
+        GNUNET_CONTAINER_bloomfilter_add (pr->bf, &mhash);
+      }
     }
   }
 }
@@ -970,10 +970,10 @@ static void
 handle_dht_reply (void *cls, struct GNUNET_TIME_Absolute exp,
                   const GNUNET_HashCode * key,
                   const struct GNUNET_PeerIdentity *get_path,
-                  unsigned int get_path_length,
+                  unsigned int get_path_length,
                   const struct GNUNET_PeerIdentity *put_path,
-                  unsigned int put_path_length,
-                  enum GNUNET_BLOCK_Type type, size_t size, const void *data)
+                  unsigned int put_path_length, enum GNUNET_BLOCK_Type type,
+                  size_t size, const void *data)
 {
   struct GSF_PendingRequest *pr = cls;
   struct ProcessReplyClosure prq;
@@ -1051,11 +1051,10 @@ GSF_dht_lookup_ (struct GSF_PendingRequest *pr)
   pr->gh =
       GNUNET_DHT_get_start (GSF_dht, GNUNET_TIME_UNIT_FOREVER_REL,
                             pr->public_data.type, &pr->public_data.query,
-                            5 /* DEFAULT_GET_REPLICATION */,
-                            GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, 
-                            /* FIXME: can no longer pass pr->bf/pr->mingle... */
-                            xquery, xquery_size, &handle_dht_reply,
-                            pr);
+                            5 /* DEFAULT_GET_REPLICATION */ ,
+                            GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
+                            /* FIXME: can no longer pass pr->bf/pr->mingle... */
+                            xquery, xquery_size, &handle_dht_reply, pr);
 }
 
 
@@ -1231,16 +1230,17 @@ process_local_reply (void *cls, const GNUNET_HashCode * key, size_t size,
                                   /* queue priority */ ,
                                   (0 !=
                                    (GSF_PRO_PRIORITY_UNLIMITED &
-                                    pr->public_data.options)) ? UINT_MAX : datastore_queue_size
+                                    pr->public_data.options)) ? UINT_MAX :
+                                  datastore_queue_size
                                   /* max queue size */ ,
                                   GNUNET_TIME_UNIT_FOREVER_REL,
                                   &process_local_reply, pr);
     if (NULL != pr->qe)
-      return;                   /* we're done */    
+      return;                   /* we're done */
     GNUNET_STATISTICS_update (GSF_stats,
-                              gettext_noop
-                              ("# Datastore lookups concluded (error queueing)"),
-                              1, GNUNET_NO);
+                              gettext_noop
+                              ("# Datastore lookups concluded (error queueing)"),
+                              1, GNUNET_NO);
     goto check_error_and_continue;
   }
   old_rf = pr->public_data.results_found;
@@ -1270,7 +1270,8 @@ process_local_reply (void *cls, const GNUNET_HashCode * key, size_t size,
                                   /* queue priority */ ,
                                   (0 !=
                                    (GSF_PRO_PRIORITY_UNLIMITED &
-                                    pr->public_data.options)) ? UINT_MAX : datastore_queue_size
+                                    pr->public_data.options)) ? UINT_MAX :
+                                  datastore_queue_size
                                   /* max queue size */ ,
                                   GNUNET_TIME_UNIT_FOREVER_REL,
                                   &process_local_reply, pr);
@@ -1329,7 +1330,8 @@ process_local_reply (void *cls, const GNUNET_HashCode * key, size_t size,
                                 /* queue priority */ ,
                                 (0 !=
                                  (GSF_PRO_PRIORITY_UNLIMITED & pr->
-                                  public_data.options)) ? UINT_MAX : datastore_queue_size
+                                  public_data.options)) ? UINT_MAX :
+                                datastore_queue_size
                                 /* max queue size */ ,
                                 GNUNET_TIME_UNIT_FOREVER_REL,
                                 &process_local_reply, pr);
@@ -1353,21 +1355,24 @@ check_error_and_continue:
 
 /**
  * Is the given target a legitimate peer for forwarding the given request?
- * 
+ *
  * @param pr request
  * @param target
  * @return GNUNET_YES if this request could be forwarded to the given peer
  */
 int
 GSF_pending_request_test_target_ (struct GSF_PendingRequest *pr,
-                                  const struct GNUNET_PeerIdentity *target)
+                                  const struct GNUNET_PeerIdentity *target)
 {
   struct GNUNET_PeerIdentity pi;
-  
+
   if (0 == pr->origin_pid)
     return GNUNET_YES;
   GNUNET_PEER_resolve (pr->origin_pid, &pi);
-  return (0 == memcmp (&pi, target, sizeof (struct GNUNET_PeerIdentity))) ? GNUNET_NO :GNUNET_YES;
+  return (0 ==
+          memcmp (&pi, target,
+                  sizeof (struct GNUNET_PeerIdentity))) ? GNUNET_NO :
+      GNUNET_YES;
 }
 
 
@@ -1405,16 +1410,17 @@ GSF_local_lookup_ (struct GSF_PendingRequest *pr,
                                 /* queue priority */ ,
                                 (0 !=
                                  (GSF_PRO_PRIORITY_UNLIMITED & pr->
-                                  public_data.options)) ? UINT_MAX : datastore_queue_size
+                                  public_data.options)) ? UINT_MAX :
+                                datastore_queue_size
                                 /* max queue size */ ,
                                 GNUNET_TIME_UNIT_FOREVER_REL,
                                 &process_local_reply, pr);
   if (NULL != pr->qe)
     return;
   GNUNET_STATISTICS_update (GSF_stats,
-                            gettext_noop
-                            ("# Datastore lookups concluded (error queueing)"),
-                            1, GNUNET_NO);
+                            gettext_noop
+                            ("# Datastore lookups concluded (error queueing)"),
+                            1, GNUNET_NO);
   GNUNET_SCHEDULER_cancel (pr->warn_task);
   pr->warn_task = GNUNET_SCHEDULER_NO_TASK;
   pr->llc_cont = NULL;
@@ -1566,10 +1572,8 @@ GSF_pending_request_init_ ()
                 "MAX_PENDING_REQUESTS");
   }
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_number (GSF_cfg,
-                                             "core",
-                                             "TOTAL_QUOTA_OUT",
-                                             &bps))
+      GNUNET_CONFIGURATION_get_value_number (GSF_cfg, "core", "TOTAL_QUOTA_OUT",
+                                             &bps))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 _
@@ -1578,9 +1582,10 @@ GSF_pending_request_init_ ()
     bps = 65536;
   }
   /* queue size should be #queries we can have pending and satisfy within
-     a carry interval: */
-  datastore_queue_size = bps * GNUNET_CONSTANTS_MAX_BANDWIDTH_CARRY_S / DBLOCK_SIZE;
-  
+   * a carry interval: */
+  datastore_queue_size =
+      bps * GNUNET_CONSTANTS_MAX_BANDWIDTH_CARRY_S / DBLOCK_SIZE;
+
   active_to_migration =
       GNUNET_CONFIGURATION_get_value_yesno (GSF_cfg, "FS", "CONTENT_CACHING");
   datastore_put_load = GNUNET_LOAD_value_init (DATASTORE_LOAD_AUTODECLINE);
diff --git a/src/fs/gnunet-service-fs_pr.h b/src/fs/gnunet-service-fs_pr.h
index 538a38248..00249afcf 100644
--- a/src/fs/gnunet-service-fs_pr.h
+++ b/src/fs/gnunet-service-fs_pr.h
@@ -359,14 +359,14 @@ GSF_local_lookup_ (struct GSF_PendingRequest *pr,
 
 /**
  * Is the given target a legitimate peer for forwarding the given request?
- * 
+ *
  * @param pr request
  * @param target
  * @return GNUNET_YES if this request could be forwarded to the given peer
  */
 int
 GSF_pending_request_test_target_ (struct GSF_PendingRequest *pr,
-                                  const struct GNUNET_PeerIdentity *target);
+                                  const struct GNUNET_PeerIdentity *target);
 
 
 
diff --git a/src/fs/gnunet-service-fs_put.c b/src/fs/gnunet-service-fs_put.c
index c029b4141..07d32ef31 100644
--- a/src/fs/gnunet-service-fs_put.c
+++ b/src/fs/gnunet-service-fs_put.c
@@ -161,9 +161,9 @@ process_dht_put_content (void *cls, const GNUNET_HashCode * key, size_t size,
               "Retrieved block `%s' of type %u for DHT PUT\n", GNUNET_h2s (key),
               type);
 #endif
-  GNUNET_DHT_put (GSF_dht, key, 5 /* DEFAULT_PUT_REPLICATION */, 
-                  GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
-                  type, size, data, expiration, GNUNET_TIME_UNIT_FOREVER_REL,
+  GNUNET_DHT_put (GSF_dht, key, 5 /* DEFAULT_PUT_REPLICATION */ ,
+                  GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, type, size, data,
+                  expiration, GNUNET_TIME_UNIT_FOREVER_REL,
                   &delay_dht_put_blocks, po);
 }